Deep Java

Java හි රේඛා බිඳුම් කළමනාකරණය: නව පේළි, මෙහෙයුම් පද්ධති වෙනස්කම්, සහ Text Blocks පැහැදිලි කිරීම

Java මූලික දැනුම
目次

1. හැඳින්වීම

ප්‍රෝග්‍රෑම් භාෂා අතර, Java යනු ව්‍යාපාරික පද්ධති සිට Android යෙදුම් දක්වා සියල්ලම භාවිතා වන විශාල භාෂාවකි. රේඛා බිඳු (line breaks) නිවැරදිව හසුරවීම, ප්‍රතිඵලයේ කියවීමේ හැකියාව වැඩි කිරීම සඳහාම නොව, දෝෂ වැළැක්වීම සහ පරිසර-අනුකූල ගැටළු වලින් වැළැක්වීම සඳහාද මූලික භූමිකාවක් ගනී.

මෙම ලිපියේ, Java හි රේඛා බිඳු නිර්මාණය කිරීමේ මූලික ක්‍රමයන් සිට මෙහෙයුම් පද්ධති අතර රේඛා බිඳු කේතවල වෙනස්කම්, බහු-රේඛා literals හසුරවීම, සහ අරඹන්නන්ට සාමාන්‍යයෙන් සිදුවන වැරදි වැනි ප්‍රායෝගික විෂයයන් දක්වා අපි සවිස්තරාත්මකව පැහැදිලි කරමු. Java 15 සහ ඊට පසු (Text Blocks) හඳුන්වා දී ඇති නව සින්ටැක්ස්ද ප්‍රායෝගික උදාහරණ සමඟ ඉදිරිපත් කරමු.

ලිපියේ පසුගිය අර්ධයේ, නිතර අසන ප්‍රශ්න සහ වාස්තුක සංවර්ධන පරිසරවල සාමාන්‍යයෙන් ඇතිවන ගැටළු සඳහා විසඳුම් සලසමු. Java හි රේඛා බිඳු හසුරවීම පිළිබඳ ඔබට අසපසු වූ විට පළමු උපදෙස් මාර්ගයක් ලෙස මෙම ලිපිය සැලසුම් කර ඇත.

අපි Java හි රේඛා බිඳු මූලික කරුණු පියවරෙන් පියවර පැහැදිලි කිරීමෙන් ආරම්භ කරමු, එබැවින් අවසානය දක්වා කියවන්න.

2. Java හි රේඛා බිඳු ඇතුළත් කිරීමේ මූලික ක්‍රම

Java හි රේඛා බිඳු නිරූපණය කිරීමේ විවිධ ක්‍රම ඇත, නමුත් මූලිකතම සහ සාමාන්‍යයෙන් භාවිතා වන ක්‍රම දෙක නම් නව පේළි අක්ෂරය (\n) සහ ප්‍රමිතිය පළ කිරීමේ ක්‍රමය System.out.println(). මෙම කොටසේ, එක් එක් ක්‍රමය කෙසේ ක්‍රියා කරයි සහ ඒවා අතර වෙනස්කම් කුමක්ද යන්න පැහැදිලි කරමු.

2.1 නව පේළි අක්ෂරය \n භාවිතා කිරීම

Java හි, ඔබට \n (බැක්ස්ලෑෂ් + n) ස්ට්‍රින්ග් එකක් තුළ තබා ඕනෑම ස්ථානයක රේඛා බිඳු එකතු කළ හැක. උදාහරණයක් ලෙස:

System.out.print("First line\nSecond line");

මෙම අවස්ථාවේ, “First line” සහ “Second line” වෙන වෙනම පේළිවල පෙන්වනු ලැබේ. ප්‍රතිඵලය මෙසේ පෙනේ:

First line
Second line

\n අක්ෂරය Linux සහ macOS වැනි UNIX-අධාරිත මෙහෙයුම් පද්ධති වල රේඛා බිඳු කේතයක් ලෙස සාමාන්‍යයෙන් භාවිතා වේ. එහෙත් Windows සාමාන්‍යයෙන් \r\n භාවිතා කරන බැවින්, පරිසරය අනුව රේඛා බිඳු හැසිරීම වෙනස් විය හැකි බව දැන ගැනීම වැදගත් වේ.

2.2 System.out.println() සහ System.out.print() අතර වෙනස්කම්

Java හි console එකට පෙළ මුද්‍රණය කිරීමේදී, සාමාන්‍යයෙන් භාවිතා වන ක්‍රම දෙක System.out.print() සහ System.out.println() වේ. මෙම දෙක අතර වෙනස්කම් පැහැදිලිව අවබෝධ කර ගැනීම වැදගත්ය.

  • System.out.print() ස්ට්‍රින්ග් එක එසේම පෙන්වයි, ප්‍රතිඵලය පසු රේඛා බිඳු එකක් නොඑකතු කරයි.
    System.out.print("Hello");
System.out.print("World");

ප්‍රතිඵලය:

HelloWorld
  • System.out.println() ස්ට්‍රින්ග් එක පෙන්වා පසු ස්වයංක්‍රීයව රේඛා බිඳු එකක් එකතු කරයි. “ln” යනු “line” (රේඛාව) යන අර්ථයයි.
    System.out.println("Hello");
System.out.println("World");

ප්‍රතිඵලය:

Hello
World

System.out.println() හි පරාමිතීන් නොදෙයි නම්, හිස් පේළියක් ඇතුළත් කළ හැක:

System.out.println();

\n සහ System.out.println() නිසි ලෙස භාවිතා කිරීමෙන්, Java හි රේඛා බිඳු නිදහස්ව පාලනය කළ හැක.

3. මෙහෙයුම් පද්ධති අනුව රේඛා බිඳු කේත (Windows / UNIX / Mac)

Java හි රේඛා බිඳු සමඟ වැඩ කරන විට මතක තබා ගත යුතු වැදගත් කරුණක් නම්, රේඛා බිඳු කේතය මෙහෙයුම් පද්ධතිය අනුව වෙනස් වීමයි. මෙම වෙනස්කම බොහෝ විට නොසලකා හැරෙන නමුත්, ගොනු ලිවීමේදී හෝ බාහිර පද්ධති සමඟ ඒකාබද්ධ කිරීමේදී ගැටළු ඇති කරවිය හැක.

3.1 එක් එක් OS එකේ භාවිතා වන රේඛා බිඳු කේත

රේඛා බිඳු කේතය යනු නව පේළියක් ආරම්භ කිරීම සඳහා පෙළ දත්ත තුළ භාවිතා වන විශේෂ අක්ෂර අනුක්‍රමයකි. එක් එක් මෙහෙයුම් පද්ධතියේ ප්‍රධාන රේඛා බිඳු කේත පහත පරිදි වේ:

  • Windows : \r\n (carriage return + line feed) (කැරියජ් රිටර්න් + ලයින් ෆීඩ්)
  • UNIX/Linux/macOS (modern) : \n (ලයින් ෆීඩ් පමණක්)
  • පැරණි Mac OS (OS 9 දක්වා) : \r (කැරියජ් රිටර්න් පමණක්)

3.2 OS අනුව රේඛා බිඳු කේත වෙනස් වීමේ හේතුව

රේඛා බිඳු කේත OS අනුව වෙනස් වීමේ හේතුව පරණ පරිගණක යුගයේ සිට ආරම්භ වේ; එවිට සෑම වෙළඳුන් සහ OS එකක්ම රේඛා බිඳු වෙනස් ලෙස නිර්වචනය කළහ. මෙම වෙනස්කම් අද දින තෙක් පවත්වාගෙන ඇත.

උදාහරණයක් ලෙස, Windows ටයිප් රයිටර්හි යාන්ත්‍රික චලනය අනුකරණය කිරීම සඳහා carriage return සහ line feed යන අක්ෂර දෙකක් භාවිතා කළේය. වෙනත් වශයෙන්, UNIX මත පදනම් වූ පද්ධති සරල ප්‍රවේශයක් තෝරාගත්තේය, නව පේළියක් නියෝජනය කිරීම සඳහා line feed අක්ෂරයක් පමණක් (\n) භාවිතා කරමින්.

3.3 Java හි \n භාවිතා කරන විට සිදුවන දේ?

බොහෝ අවස්ථාවලදී, Java වැඩසටහනක \n භාවිතා කිරීමෙන් පේළි බිඳීමක් නිවැරදිව නිපදවනු ඇත. එහෙත්, නිපදවන ලද පාඨ පිටුව විස්තරාත්මක යෙදුම්වලදී විවෘත කරන විට ගැටලු ඇති විය හැක, උදාහරණයක් ලෙස Windows හි Notepad හෝ විවිධ මෙහෙයුම් පද්ධතිවල පාඨ සංස්කරණකරුවන්.

විශේෂයෙන්ම, Windows හි \n පමණක් භාවිතා කරමින් පාඨ පිටුවක් නිර්මාණය කළහොත්, Notepad හි දැකීමේදී පේළි සම්බන්ධ විය හැක, පේළි බිඳීම් යෙදා නොතිබුණු බවක් පෙනෙනු ඇත.

3.4 සැබෑ ලෝක සංවර්ධනයේ ප්‍රායෝගික සලකා බැලීම්

  • පිටු ලිවීමේදී හෝ මෙහෙයුම් පද්ධති අනුව දත්ත හුවමාරු කිරීමේදී, සැමවිටම පේළි බිඳීමේ කේතවලට අවධානය යොමු කරන්න.
  • ඔබේ පරිසරයේ පාඨ නිවැරදි පෙනුනත්, එය වෙනත් පරිසරයක නිවැරදිව පෙන්වන්නේ නැත.
  • මෙම ගැටලු වළක්වා ගැනීම සඳහා, පරිසරයෙන් ස්වාධීන ප්‍රවේශයන් භාවිතා කිරීම නිර්දේශ කෙරේ, ඒවා මීළඟ කොටසේ පැහැදිලි කෙරේ.

4. පරිසරයෙන් නිර්බන්ධ පේළි බිඳීමේ ගැටලු වළක්වා ගන්නේ කෙසේද

පෙර කොටසේ පැහැදිලි කළ පරිදි, පේළි බිඳීමේ කේත මෙහෙයුම් පද්ධතිය අනුව වෙනස් වේ. එබැවින්, Java වැඩසටහන්වලින් පිටපත් වන පාඨ අපේක්ෂිත පරිදි පෙනෙන්නේ නැත. මෙය විශේෂයෙන් වැදගත් වන්නේ විවිධ මෙහෙයුම් පද්ධති පරිසර අතර පාඨ පිටු හුවමාරු කිරීමේදී, හෝ කණ්ඩායම් සංවර්ධනය සහ පද්ධති ඒකාබද්ධ කිරීමේ තත්ත්වයන්හිදී.

4.1 System.getProperty("line.separator") භාවිතා කිරීම

Java වර්තමාන ක්‍රියාත්මක පරිසරය සඳහා වඩාත් සුදුසු පේළි බිඳීමේ කේතය ස්වයංක්‍රීයව ලබා ගැනීම සඳහා බුද්ධිමය යාන්ත්‍රණයක් සපයයි. මෙය System.getProperty("line.separator") භාවිතා කරමින් සිදු කෙරේ.

උදාහරණය:

String lineSeparator = System.getProperty("line.separator");
System.out.print("Line 1" + lineSeparator + "Line 2");

Windows හි ක්‍රියාත්මක වන විට, මෙම කේතය \r\n භාවිතා කරයි. Linux හෝ macOS හි, එය \n භාවිතා කරයි. මෙය මෙහෙයුම් පද්ධතිය අනුව පේළි බිඳීම් නිවැරදිව කළමනාකරණය කරයි.

4.2 PrintWriter සහ BufferedWriter හි පේළි බිඳීමේ ක්‍රම

PrintWriter හෝ BufferedWriter වැනි පන්ති භාවිතා කරමින් පිටුවලට ලිවීමේදී, println() ක්‍රමය ස්වයංක්‍රීයව පරිසරය සඳහා සුදුසු පේළි බිඳීමේ කේතය භාවිතා කරයි.

PrintWriter pw = new PrintWriter("output.txt");
pw.println("This is the first line.");
pw.println("This is the second line.");
pw.close();

මෙලෙස සම්මත පුස්තකාල ක්‍රමවලට පේළි බිඳීමේ කළමනාකරණය පැවරීම බොහෝ විට ආරක්ෂිත සහ ප්‍රායෝගික ප්‍රවේශයකි.

4.3 සාරාංශය

  • විලාසයෙන් \n හෝ \r\n විලාසයන් ඇතුළත් කිරීම සරලය, එහෙත් ප්‍රවාහනය සහ පුනර්භාවිතය සඳහා, System.getProperty("line.separator") හෝ println() වැනි පිටපත් ක්‍රම භාවිතා කිරීම ආරක්ෂිතය.
  • ඔබේ වැඩසටහන කිහිපයක් මෙහෙයුම් පද්ධතිවල ක්‍රියාත්මක විය හැකි නම්, සැමවිටම පරිසරයෙන් ස්වාධීන විසඳුමක් තෝරන්න.

5. Text Blocks සමඟ බහු-පේළි සාක්ෂි (Java 15 සහ පසුව)

Java 15 සිට ආරම්භ වන විට, Text Blocks නම් නව වර්ගයේ විලාසයක් නිල වශයෙන් හඳුන්වා දුන්නේය. Text blocks ඔබට ආකෘතිකරණය කළ හෝ බහු-පේළි පාඨ සමඟ වැඩ කිරීමේදී විශේෂයෙන් උපකාරී වන ලෙස, සංක්ෂිප්ත සහ පාඨක සුලබ ආකාරයකින් බහු-පේළි විලාස නිර්වචනය කිරීමට ඉඩ සලසයි.

5.1 Text Blocks හි මූලික ව්‍යාකරණය

Text block එකක් තුනේ ද්විත්ව උපුටා දැක්වීම් ලකුණු (""") තුළ පාඨ ඇතුළත් කරමින් නිර්වචනය කෙරේ.

String text = """
    This is the first line.
    This is the second line.
    This is the third line.
    """;
System.out.println(text);

මෙම කේතය ක්‍රියාත්මක වන විට, පිටපත පහත පරිදි පෙනෙනු ඇත:

This is the first line.
This is the second line.
This is the third line.

5.2 Text Blocks හි විශේෂාංග සහ සැලකිලිමත් විය යුතු කරුණු

  • ඉඩකඩ කළමනාකරණය පහසුයි පොදු ආරම්භක ඉඩකඩ ස්වයංක්‍රීයව ඉවත් කරයි, සමස්ත කේතයේ කියවීමේ හැකියාව වැඩි කරයි.
  • පේළි බිඳු ලියූ පරිදි රැකගනී සාම්ප්‍රදායික string literals වලට වඩා, ඔබට \n භාවිතා කිරීමට අවශ්‍ය නැත; text block එකේ පේළි බිඳු සෘජුවම ප්‍රතිඵලයේ පෙන්වයි.
  • අවසාන පේළි බිඳු ගැන සැලකිල්ලෙන් සිටින්න ඔබ text block එකේ අවසානයේ හිස් පේළියක් ඇතුළත් කරන්නේ නම්, එය ප්‍රතිඵලයටද ඇතුළත් වේ. අතිරේක හිස් ඉඩකඩ හෝ අතිරේක පේළි බිඳු වලින් වැළකී සිටින්න.

5.3 Text Blocks සඳහා ප්‍රායෝගික භාවිතා කේස්

Text blocks යනු JSON, SQL, හෝ HTML වැනි ආකෘතිකරණය කළ බහු-පේළි අන්තර්ගතය සෘජුවම මූලාශ්‍ර කේතයේ නිර්වචනය කිරීමේදී ඉතා ප්‍රයෝජනවත් වේ.

උදාහරණය: බහු-පේළි SQL ප්‍රකාශයක් නිර්වචනය කිරීම

String sql = """
    SELECT id, name, email
    FROM users
    WHERE status = 'active'
    ORDER BY id DESC
    """;

උදාහරණය: Text block එකක් HTML ආකෘතියක් ලෙස භාවිතා කිරීම

String html = """
    <html>
      <body>
        <h1>Hello, Java!</h1>
      </body>
    </html>
    """;

5.4 සාරාංශය

  • Text blocks ඔබට බහු-පේළි strings අර්ථවත් සහ කියවීමට පහසු ලෙස ලිවීමට ඉඩ දෙයි.
  • පේළි බිඳු සහ ඉඩකඩ රැකගත් බැවින්, ප්‍රතිදානය හෝ ගොනු ලිවීමේදී සැලසුම් බිඳීමේ අවදානම අඩු වේ.
  • Text blocks Java 15 සහ ඊට පසු පමණක් ලබා ගත හැකි බැවින්, ඔබ පැරණි සංස්කරණයක් භාවිතා කරනවා නම් ඒ ගැන සැලකිල්ලෙන් සිටින්න.

6. උසස් විෂය: Scanner ආදානය සහ “නව පේළි පරිභෝජනය” ගැටලුව

Java හි පරිශීලක ආදානය පිළිගැනීමේදී, Scanner පන්තිය සාමාන්‍යයෙන් ප්‍රමිතීන් ආදානය සඳහා භාවිතා වේ. එහෙත්, ආරම්භකයන්ට සාමාන්‍යයෙන් වැටහීමට බරපතළ වන “නව පේළි පරිභෝජනය” ගැටලුවක් ඇත.

6.1 සාමාන්‍ය ගැටලූ තත්ත්වයක්

උදාහරණයක් ලෙස, සංඛ්‍යාත්මක ආදානයකට පසු string ආදානයක් ඇතුළත් කරන විට, වැඩසටහන අනපේක්ෂිත ලෙස ක්‍රියා කළ හැක.

Scanner scanner = new Scanner(System.in);

System.out.print("Please enter your age: ");
int age = scanner.nextInt();

System.out.print("Please enter your name: ");
String name = scanner.nextLine();

System.out.println("Age: " + age + "  Name: " + name);

පළමු නරඹන විට, මෙම කේතය නිවැරදි බව පෙනේ. නමුත්, ක්‍රියාත්මක කිරීමේදී, වැඩසටහන නාමය ඇතුළත් කිරීමේ ප්‍රශ්නය මඟ හැරී, පරිශීලකයාට කිසිවක් ටයිප් කිරීමට අවස්ථාව නොදෙයි.

6.2 මෙය සිදුවන්නේ ඇයි

මෙය සිදුවන්නේ nextInt() වැනි සංඛ්‍යාත්මක ආදාන ක්‍රමයන් සංඛ්‍යාව පමණක් කියවී, නව පේළි අක්ෂරය (Enter යතුර) පරිභෝජනය නොකිරීම නිසාය. එබැවින්, පසුගිය nextLine() ඉක්මනින් ඉතිරි නව පේළිය කියවා, එය හිස් string එකක් ලෙස සැලකේ.

6.3 විසඳුම

මෙම ගැටලුව විසඳීමට, සංඛ්‍යාත්මක ආදානයෙන් පසු අතිරේක nextLine() ඇමතුමක් එක් කර ඉතිරි නව පේළිය පැහැදිලිව පරිභෝජනය කළ යුතුය.

සංශෝධිත උදාහරණය:

Scanner scanner = new Scanner(System.in);

System.out.print("Please enter your age: ");
int age = scanner.nextInt();
scanner.nextLine();  // Consume the remaining newline

System.out.print("Please enter your name: ");
String name = scanner.nextLine();

System.out.println("Age: " + age + "  Name: " + name);

සංඛ්‍යාත්මක (හෝ token-අධාරිත) ආදානය සහ පේළි-අධාරිත string ආදානය එකට භාවිතා කරන විට, ඉතිරි නව පේළිය nextLine() භාවිතයෙන් පරිභෝජනය කිරීම හොඳම ක්‍රමවේදයකි.

6.4 සාරාංශය

  • Scanner භාවිතා කරන විට, සංඛ්‍යාත්මක හෝ token ආදානය සහ string ආදානය මිශ්‍ර කිරීම අනපේක්ෂිත හැසිරීමක් ඇති කරයි.
  • මෙම ගැටලුව nextLine() මඟින් නව පේළිය පැහැදිලිව පරිභෝජනය කිරීමෙන් පහසුවෙන් වැළැක්විය හැක.
  • විවිධ ආදාන ක්‍රම එකට භාවිතා කරන විට නව පේළි පරිභෝජනය ගැන සැලකිල්ලෙන් සිටින්න.

7. පේළි බිඳු පාලනයේ සාරාංශය සහ ප්‍රායෝගික Java උපදෙස්

මෙතෙක්, Java හි පේළි බිඳු කළමනාකරණය සඳහා විවිධ ක්‍රම පරීක්ෂා කර ඇත. මෙම කොටස තුළ, ඒවායේ ලක්ෂණ සංවිධානය කර, වාස්තුකලාවකදී නිවැරදි ක්‍රමය තෝරා ගැනීමට ප්‍රායෝගික උපදෙස් ලබා දේ.

7.1 පේළි බිඳු ක්‍රමවල සංසන්දනය

MethodCharacteristicsTypical UsagePortability
\nSimple and easy to use within strings"Line 1\nLine 2"△ (OS-dependent)
System.out.println()Automatically appends a line break to outputSystem.out.println("Text");◎ (OS-aware)
System.getProperty("line.separator")Retrieves the appropriate line break for the execution environmenttext + System.getProperty("line.separator")◎ (OS-adaptive)
Text Blocks (Java 15+)Clean multi-line literals with indentation support"""Multi-line text"""◎

7.2 ප්‍රායෝගික මාර්ගෝපදේශ

  • සරල console output හෝ logging: කියවීමට සහ පහසුවට System.out.println() භාවිතා කරන්න.
  • පෙළ ගොනු වලට ලිවීම: OS අතර නිවැරදි හැසිරීම සඳහා System.getProperty("line.separator") සමඟ output එක එකතු කරන්න.
  • HTML හෝ SQL වැනි බහු-පේළි literals: Java 15 හෝ පසුගිය සංස්කරණ භාවිතා කරනවා නම්, text blocks භාවිතා කිරීම ඉතාමත් නිර්දේශිතයි.
  • පරිශීලක input සැකසීම: Scanner භාවිතා කරන විට newline පරිභෝජනයට විශේෂ අවධානයක් දෙන්න.

7.3 සංවර්ධනයේ පොදු වැරදි

  • OS වෙනස්කම් නොසලකා \n පමණක් භාවිතා කිරීම → වෙනත් පරිසරයන්හි ගොනු විවෘත කරන විට පෙළ ගොනු අඛණ්ඩ ලෙස පෙනෙන්නට හැකිය.
  • Scanner සමඟ අනපේක්ෂිත හිස් input → සංඛ්‍යාත්මක හෝ token input පසු newline එක සෑම විටම පරිභෝජනය කරන්න.
  • පරණ Java සංස්කරණවල text blocks භාවිතා කිරීම → Java 15ට පෙර text blocks සහාය නොදෙයි; ඒ නිසා සංකලන දෝෂ ඇති වේ.

7.4 ප්‍රායෝගික උපදෙස්

  • පරිසර-අනුකූලතාවය වැළැක්වීමට, System.getProperty("line.separator") හෝ println() වැනි output API භාවිතා කරන්න.
  • Text blocks ලේඛන ජනනය සහ embedded templates සඳහා ඉතා ප්‍රයෝජනවත් වේ.
  • කේතය කවුද භාවිතා කරනවා, එය කොහේ ධාවනය වනවා යන කරුණු අනුව line break ක්‍රමය තෝරන්න.

8. FAQ (නිතර අසන ප්‍රශ්න)

Java හි line break ගැටළු සම්බන්ධයෙන් සාමාන්‍ය ප්‍රශ්න සහ ගැටළු සඳහා මෙහි පිළිතුරු ඇත, වාස්තුකලාවක පදනම් වූ සංවර්ධන අත්දැකීම් මත.

Q1. මට \n හෝ \r\n භාවිතා කළ යුතුද?

බොහෝ අවස්ථාවල, වැඩසටහන් තුළ \n භාවිතා කිරීම ප්‍රමාණවත් වේ. නමුත් ගොනු ලිවීම හෝ වෙනත් පද්ධති සමඟ දත්ත හුවමාරු කිරීමේදී, පරිසර-විශේෂ ගැටළු වැළැක්වීමට System.getProperty("line.separator") භාවිතා කිරීම නිර්දේශිතයි.

Q2. System.out.println() සහ System.out.print("\n") අතර වෙනස කුමක්ද?

System.out.println() ස්වයංක්‍රීයව පරිසරයට ගැළපෙන line break එකක් එක් කරයි. එයට විරුද්ධව, System.out.print("\n") සෑම විටම \n එකක් ඇතුළත් කරයි, එය සියලු මෙහෙයුම් පද්ධතිවල නිවැරදි ලෙස ක්‍රියා නොකරනු ඇත. ගොනු output සඳහා println() සාමාන්‍යයෙන් ආරක්ෂිතයි.

Q3. මට text blocks තුළ අතිරේක ඉන්ඩෙන්ටේෂන් හෝ line break ගැන සැලකිල්ලක් ඇත. මට කුමක් කළ යුතුද?

Text blocks ස්වයංක්‍රීයව පොදු ඉදිරිපස ඉන්ඩෙන්ටේෂන් ඉවත් කරයි, එබැවින් පෙළවල වමට සකස් කිරීම නිර්දේශිතයි. අනිවාර්ය නොවන trailing spaces හෝ හිස් පේළි ඇතුළත් නොකරන්න, එය output තුළ රඳා පවතී.

Q4. Scanner භාවිතා කරන විට සංඛ්‍යාත්මක input පසු string input අසාර්ථක වන්නේ ඇයි?

මෙය සංඛ්‍යාත්මක input ක්‍රමයන් newline අක්ෂරය buffer එකේ තබා ගැනීම නිසා වේ. පසුකාලීනව string එකක් කියවීමට scanner.nextLine() එකක් ඇතුළත් කර, ඉතිරි newline එක පරිභෝජනය කරන්න.

Q5. Java 15ට පෙර සංස්කරණවල බහු-පේළි strings ලිවීමට පිරිසිදු ක්‍රමයක් තිබේද?

Java 15ට පෙර text blocks නොමැත. එවැනි අවස්ථාවල, strings එකට + භාවිතා කර, \n අතිරේකව ඇතුළත් කර concatenate කරන්න.

String text = "Line 1\n"
            + "Line 2\n"
            + "Line 3";

පෙළවල කියවීමට පහසුව සඳහා පේළි සහ ඉන්ඩෙන්ටේෂන් සුදුසු ලෙස බෙදා ලියන්න.

9. අවසාන සාරාංශය සහ ඊළඟ ඉගෙනුම් පියවර

මෙම ලිපියේ, Java හි line break ගැටළු සඳහා මූලික භාවිතයෙන් උසස් අවස්ථා දක්වා විවිධ තාක්ෂණ සහ සැලකිලිමත් කරුණු ආවරණය කර ඇත.

Java හි සරල syntax එකක් තිබුණද, line break ගැටළු පරිසරය සහ භාවිතය අනුව සැලකිලිමත් කළ යුතුය.

ප්‍රධාන ග්‍රහණයන්:

  • මූලික line break \n සහ System.out.println() සමඟ පහසුවෙන් කළ හැකිය.
  • OS-විශේෂ ගැටළු වැළැක්වීමට System.getProperty("line.separator") භාවිතා කරන්න.
  • Java 15+ හි text blocks භාවිතා කර බහු-පේළි literals සරලව ලියන්න.
  • Scanner භාවිතා කරන විට newline පරිභෝජනය ගැන අවධානයෙන් සිටින්න.

Line break ගැටළු කුඩා මාතෘකාවක් වැනි පෙනුනත්, එය පාලනය කිරීම පරිවර්තනීය, විශ්වාසනීය වැඩසටහන් සහ පිරිසිදු, නඩත්තු කළ හැකි කේත නිර්මාණයට හේතු වේ.

ඔබ Java දැනුම තවත් ගැඹුරු කර ගැනීමට කැමති නම්, පහත මාතෘකාවන් පරීක්ෂා කරන්න:

  • String එකතු කිරීම, බෙදීම, සහ ආකෘතිකරණය ( String.format , StringBuilder )
  • ගොනු I/O හි අක්ෂර කේතනය සහ පේළි බිඳුම්
  • සම්මත ආදාන/ප්‍රතිදාන සහ අපවාද සැකසීම
  • Java හි ජාත්‍යන්තරීකරණය සහ ස්ථානිකරණය

කුඩා තාක්ෂණික ක්‍රම සහ එකතු කළ දැනුම වාස්තුක සංවර්ධනයේ ශක්තිමත් මෙවලම් බවට පත්වේ. අපි බලාපොරොත්තු වෙමු මෙම ලිපිය ඔබේ Java කුසලතා සහ ප්‍රායෝගික විශේෂඥතාවය වැඩිදියුණු කිරීමට උපකාරී වේ.