ජාවා හි TXT ගොනුවකට දත්ත සුරකින ආකාරය

ක්‍රමලේඛන ලෝකයේ දත්ත සුරැකීමට සහ කියවීමට හැකියාව තිබීම අත්‍යවශ්‍ය වේ ගොනුවකින් වින්‍යාස කිරීම් සුරැකීම, දත්ත සමුදායන්හි තොරතුරු ගබඩා කිරීම හෝ සරලව ක්‍රියාත්මක කිරීම වැනි කාර්යයන් ඉටු කිරීමට උපස්ථ පිටපත්. මෙම ලිපියෙන් අපි ජාවා ක්‍රමලේඛන භාෂාව භාවිතයෙන් TXT ගොනුවකට දත්ත සුරකින ආකාරය ගවේෂණය කරමු. a වෙතින් තොරතුරු ගබඩා කිරීමට සහ ලබා ගැනීමට අපට ඉඩ සලසන ඵලදායී කේතයක් ලියන්නේ කෙසේදැයි අපි ඉගෙන ගනිමු කාර්යක්ෂම මාර්ගය සහ තේරුම් ගැනීමට පහසුය. සියලු විස්තර දැන ගැනීමට දිගටම කියවන්න!

1. ජාවා හි TXT ගොනු හැසිරවීම පිළිබඳ හැඳින්වීම

ජාවා හි, TXT ගොනු හැසිරවීම සාමාන්‍ය පෙළ ගොනුවකට තොරතුරු කියවීමට සහ ලිවීමට අපට ඉඩ සලසන පොදු කාර්යයකි. මෙම ලිපියෙන් මම ඔබට මඟ පෙන්වමි පියවරින් පියවර ජාවා හි TXT ගොනු හසුරුවන්නේ කෙසේද යන්න පිළිබඳව. මීට අමතරව, ඔබට මෙම ක්‍රියාකාරිත්වය තේරුම් ගැනීමට සහ භාවිතා කිරීමට හැකි වන පරිදි ප්‍රයෝජනවත් උපදෙස් සහ ප්‍රායෝගික උදාහරණ කිහිපයක් මම ඔබ සමඟ බෙදා ගන්නෙමි. .ලදායී ලෙස.

ජාවා හි TXT ගොනු හැසිරවීමට, ඔබට ගොනුවකට ලිවීමට FileWriter පන්තිය සහ පවතින ගොනුවකින් කියවීමට FileReader පන්තිය භාවිතා කිරීමට අවශ්‍ය වනු ඇත. මෙම පන්ති java.io පැකේජයේ දක්නට ලැබේ, එබැවින් ඔබට මෙම පැකේජය ඔබගේ කේතයට ආයාත කිරීමට අවශ්‍ය වනු ඇත.

ඔබ java.io පැකේජය ආයාත කළ පසු, ඔබට විශේෂිත ගොනුවකට ලිවීමට FileWriter පන්තියේ උදාහරණයක් සෑදිය හැක. ඔබට ලිවීමට අවශ්‍ය ගොනුවේ මාර්ගය සඳහන් කිරීමට FileWriter(String filePath) constructor භාවිතා කළ හැක. ගොනු ලිවීමේදී සිදුවිය හැකි ඕනෑම ව්යතිරේකයක් හැසිරවීමට වග බලා ගන්න. ඔබ ගොනුවට ලිවීම අවසන් වූ පසු, එය close() ක්‍රමය භාවිතයෙන් වසා දැමීමට මතක තබා ගන්න.

2. ජාවා හි TXT ගොනුවක් විවෘත කිරීම සහ නිර්මාණය කිරීම

ජාවා හි TXT ගොනුවක් විවෘත කිරීමට සහ නිර්මාණය කිරීමට, විකල්ප කිහිපයක් තිබේ. මෙය සාක්ෂාත් කර ගැනීම සඳහා අවශ්‍ය පියවර පහත දැක්වේ:

පියවර 1: පළමුවෙන්ම, ඔබ ඔබේ පද්ධතියේ Java සංවර්ධන පරිසරය (Eclipse හෝ NetBeans වැනි) ස්ථාපනය කර ඇති බවට සහතික විය යුතුය. මෙය ඔබට ඔබගේ ජාවා කේතය ලිවීමට සහ සම්පාදනය කිරීමට ඉඩ සලසයි කාර්යක්ෂමව.

පියවර 2: ඔබ ඔබේ සංවර්ධන පරිසරය සැකසූ පසු, ඔබට TXT ගොනුවක් විවෘත කිරීමට හෝ නිර්මාණය කිරීමට ජාවා කේතය ලිවීම ආරම්භ කළ හැක. පවතින ගොනුවක් විවෘත කිරීමට, ඔබට පන්තිය භාවිතා කළ හැකිය FileReader o BufferedReader. උදාහරණයක් ලෙස: FileReader archivo = new FileReader("archivo.txt");. නිර්මාණය කිරීමට නව ගොනුවක්, ඔබට පන්තිය භාවිතා කළ හැකිය FileWriter o BufferedWriter. උදාහරණයක් ලෙස: FileWriter archivo = new FileWriter("nuevoarchivo.txt");.

පියවර 3: ගොනුව විවෘත කිරීමෙන් හෝ නිර්මාණය කිරීමෙන් පසු, ඔබට අනුරූප පන්තිවල ඇති ක්‍රම භාවිතා කර එය මත විවිධ මෙහෙයුම් සිදු කළ හැකිය. උදාහරණයක් ලෙස, ඔබට ක්‍රමය භාවිතා කර ගොනුවක අන්තර්ගතය කියවිය හැකිය read() පන්තිය තුල FileReader සහ ක්‍රම භාවිතා කරමින් ගොනුවකට ලියන්න write() o append() පන්තිය තුල FileWriter. ක්‍රමය භාවිතා කිරීමෙන් පසු ගොනුව වසා දැමීමට අමතක නොකරන්න close().

3. ජාවා හි TXT ගොනුවකට දත්ත ලිවීම

ජාවා වල ටෙක්ස්ට් ෆයිල් එකකට ඩේටා ලිවීමට අපි මුලින්ම ඔබ්ජෙක්ට් ඔෆ් ක්ලාස් එකක් සාදාගත යුතුයි File එය ගොනු පද්ධතියේ ගොනුව නියෝජනය කරයි. ඊළඟට, අපි පන්තියේ වස්තුවක් භාවිතා කරමු FileWriter ගොනුවට දත්ත ලිවීමට.

එය කරන්නේ කෙසේද යන්න පිළිබඳ උදාහරණයක් මෙන්න:

import java.io.FileWriter;
import java.io.IOException;

public class EscribirArchivoTXT {
    public static void main(String[] args) {
        String datos = "Estos son los datos que queremos escribir en el archivo.";

        try {
            FileWriter archivo = new FileWriter("ruta_del_archivo.txt");
            archivo.write(datos);
            archivo.close();
            System.out.println("Los datos se han escrito correctamente en el archivo.");
        } catch (IOException e) {
            System.out.println("Ha ocurrido un error al escribir en el archivo.");
            e.printStackTrace();
        }
    }
}

මෙම උදාහරණයේදී, අපි පන්තියේ උදාහරණයක් නිර්මාණය කරමු FileWriter අමතන්න archivo සහ අපි නිර්මාණය කිරීමට අවශ්ය ගොනුවේ මාර්ගය සහ නම සඳහන් කරමු. එවිට අපි ක්රමය භාවිතා කරමු write() ගොනුවට සහ ක්‍රමයට දත්ත ලිවීමට close() අපි ලිවීම අවසන් වූ පසු ගොනුව වසා දැමීමට. අවසාන වශයෙන්, අපි දත්ත නිවැරදිව ලියා ඇත්නම් සාර්ථක පණිවිඩයක් හෝ ගැටලුවක් සිදුවුවහොත් දෝෂ පණිවිඩයක් පෙන්වමු.

පන්තිය භාවිතා කරන විට එය සැලකිල්ලට ගැනීම වැදගත්ය FileWriter, නිශ්චිත ගොනුව නොපවතී නම්, එය ස්වයංක්රීයව සාදනු ලැබේ. කෙසේ වෙතත්, ගොනුව දැනටමත් පවතී නම්, පෙර දත්ත මකා දමා අප ලියන නව දත්ත මගින් ප්‍රතිස්ථාපනය වේ. එබැවින්, එය සෑදීමට යෝග්ය වේ උපස්ථය වැදගත් දත්ත අහිමි වීම වළක්වා ගැනීම සඳහා කිසියම් ලිවීමේ මෙහෙයුමක් සිදු කිරීමට පෙර ගොනුවේ.

4. Java හි TXT ගොනුවකට වෙනස්කම් වසා දැමීම සහ සුරැකීම

දැන් අපි ජාවා වල TXT ගොනුවක් විවෘත කර කියවන්නේ කෙසේදැයි ඉගෙන ගෙන ඇති අතර, එම ගොනුවේ අප විසින් සිදු කරන ලද වෙනස්කම් වසා දමා සුරැකීමට දැන ගැනීම වැදගත් වේ. වාසනාවකට මෙන්, ජාවා අපට මෙය කිරීමට පහසු ක්රමයක් සපයයි.

ගොනුවක් වසා දැමීම සඳහා, අපි ගොනුවට ලිවීමට භාවිතා කරන `BufferedWriter` වස්තුවේ ඇති `close()` ක්‍රමය ඇමතීමට අවශ්‍ය වේ. ගොනුව වැසීමට පෙර සියලුම පොරොත්තු වෙනස් කිරීම් නිවැරදිව සුරකින බව මෙය සහතික කරයි.

"ජාවා
BufferedWriter writer = null;
උත්සාහ කරන්න {
ලේඛකයා = නව BufferedWriter (නව FileWriter("file.txt"));
// … ගොනුවට ලිවීමට කේතය ...
} අල්ලා ගැනීම (IOException e) {
//… ව්‍යතිරේක හැසිරවීම…
} අවසාන {
නම් (ලේඛකයා != ශුන්‍ය) {
උත්සාහ කරන්න {
ලේඛකයා.close();
} අල්ලා ගැනීම (IOException e) {
//… ව්‍යතිරේක හැසිරවීම…
}
}
}
""

ගොනුවට ලිවීමේදී ව්‍යතිරේකයක් සිදු වුවද එය ක්‍රියාත්මක වන බව සහතික කිරීම සඳහා `writer.close()` block එක `අවසාන` වාරණයක් තුළ ඇති බව සහතික කිරීම වැදගත් වේ.

5. ජාවා හි TXT ගොනුවකින් දත්ත කියවීම

ජාවා හි TXT ගොනුවකින් දත්ත කියවීමට, විකල්ප කිහිපයක් තිබේ. වඩාත් පොදු ක්රමයක් වන්නේ පන්තිය භාවිතා කිරීමයි Scanner පැකේජයට අයිති බව java.util. මෙම පන්තිය පෙළ ගොනු ඇතුළුව විවිධ ආකාරයේ ආදාන දත්ත කියවීම සඳහා ක්‍රම සපයයි.

TXT ගොනුවකින් දත්ත කියවීමේ පළමු පියවර වන්නේ පන්තියේ උදාහරණයක් නිර්මාණය කිරීමයි Scanner සහ වස්තුව තර්කයක් ලෙස සම්මත කරන්න File අපට කියවීමට අවශ්‍ය ගොනුව නියෝජනය කරයි. එවිට අපට පන්තියේ ක්‍රම භාවිතා කළ හැකිය Scanner ගොනු රේඛාවෙන් පේළියකින් හෝ විශේෂිත බෙදුම්කරුවෙකු භාවිතයෙන් දත්ත කියවීමට.

අපි ගොනුවෙන් දත්ත කියවූ පසු, අපගේ අවශ්‍යතාවලට වඩාත් ගැලපෙන මෙවලම් සහ ශිල්පීය ක්‍රම භාවිතයෙන් අපට එය සැකසිය හැක. උදාහරණයක් ලෙස, අපට කියවන දත්ත ගබඩා කිරීම සඳහා අරා හෝ ලැයිස්තු වැනි දත්ත ව්‍යුහයන් භාවිතා කළ හැකිය, නැතහොත් වඩාත් දියුණු මෙහෙයුම් සිදු කිරීමට පෙළ සැකසුම් ඇල්ගොරිතම භාවිතා කළ හැක. පහත දැක්වෙන්නේ පන්තිය භාවිතයෙන් TXT ගොනුවකින් දත්ත කියවන ආකාරය පිළිබඳ උදාහරණයකි Scanner:

6. ජාවා හි TXT ගොනුවක ව්‍යුහය හැසිරවීම

Java හි, TXT ගොනුවක ව්‍යුහය හැසිරවීම විවිධ අවස්ථාවන්හිදී ඉතා ප්‍රයෝජනවත් විය හැක. දත්ත කියවීමේ සහ ලිවීමේ සිට, අන්තර්ගතය වෙනස් කිරීම සහ මකා දැමීම දක්වා, මෙම ගොනු ව්‍යුහය හැසිරවිය යුතු ආකාරය දැන ගැනීම යෙදුම් සංවර්ධනය සඳහා අත්‍යවශ්‍ය වේ. මෙම මෙහෙයුම් ඵලදායී ලෙස සිදුකිරීමට අවශ්‍ය පියවර පහත විස්තර කෙරේ.

1. දත්ත කියවීම: TXT ගොනුවක ව්‍යුහය හැසිරවීමේ පළමු පියවර වන්නේ ගොනුවේ පවතින දත්ත කියවීමයි. මෙය සිදු කිරීම සඳහා, ඔබට පෙළ ගොනුවක් විවෘත කර එහි අන්තර්ගතය කියවීමට ඉඩ සලසන FileReader පන්තිය භාවිතා කිරීම අවශ්ය වේ. ගොනුව විවෘත කළ පසු, එහි අන්තර්ගතය පේළියෙන් පේළියට ප්‍රවේශ විය හැකි අතර පසුව සැකසීම සඳහා විචල්‍යයන් තුළ ගබඩා කරයි.

2. දත්ත ලිවීම: TXT ගොනුවකින් දත්ත කියවීමට අමතරව, එයට නව දත්ත ලිවීමට හැකිය. මෙය සිදු කිරීම සඳහා, FileWriter පන්තිය භාවිතා කරනු ලැබේ, එය පෙළ ගොනු වලට ලිවීමට ඉඩ සලසයි. ගොනුවක් ලිවීමේ ආකාරයෙන් විවෘත කිරීමේදී, ගොනුවට අන්තර්ගතය එක් කිරීමට ලියන්න() හෝ append() වැනි ක්‍රම භාවිතා කළ හැක. ලිවීම අවසන් වූ පසු, වෙනස්කම් නිවැරදිව සුරකින බව සහතික කිරීම සඳහා සමීප () ක්‍රමය භාවිතයෙන් ගොනුව වසා දැමිය යුතු බව සැලකිල්ලට ගැනීම වැදගත්ය.

3. අන්තර්ගතය වෙනස් කිරීම සහ මකා දැමීම: සමහර විට TXT ගොනුවකින් නිශ්චිත අන්තර්ගතය වෙනස් කිරීමට හෝ මකා දැමීමට අවශ්‍ය විය හැකිය. මෙය සිදු කිරීම සඳහා, ගොනුවේ අන්තර්ගතය තාවකාලිකව ගබඩා කිරීම සඳහා ලැයිස්තු හෝ අරා වැනි ව්යුහයන් භාවිතා කිරීම ප්රයෝජනවත් වේ. ඔබට දත්ත කැබැල්ලක් වෙනස් කිරීමට අවශ්‍ය නම්, ඔබට එය ලැයිස්තුවේ හෝ අරාවේ පිහිටීම හරහා ප්‍රවේශ විය හැක, අවශ්‍ය වෙනස් කිරීම් සිදු කර පසුව ගොනුවේ වෙනස්කම් සුරැකිය හැක. අන්තර්ගතය ඉවත් කිරීම සඳහා, ඔබට නිශ්චිත මූලද්‍රව්‍ය ඉවත් කිරීමට ArrayList පන්තියේ ඉවත් කිරීමේ() ක්‍රමය හෝ ගොනුවෙන් සියලුම අන්තර්ගතයන් ඉවත් කිරීමට පැහැදිලි() ක්‍රමය භාවිතා කළ හැක.
[අවසානය]

7. ජාවා හි TXT ගොනුවකට දත්ත සුරැකීමට අක්ෂර ප්‍රවාහ භාවිතා කිරීම

ජාවා හි පෙළ ගොනුවකට (.txt) දත්ත සුරැකීමට, අපට අක්ෂර ප්‍රවාහ භාවිතා කළ හැක. අක්ෂර ප්‍රවාහ යනු පෙළ ගොනු වෙත දත්ත කියවීමට සහ ලිවීමට පහසු ක්‍රමයකි. ජාවා හි, අක්ෂර ප්‍රවාහ නියෝජනය කරනු ලබන්නේ FileReader සහ FileWriter පන්ති මගිනි.

පෙළ ගොනුවකට ලිවීමට, අපි මුලින්ම FileWriter පන්තියේ වස්තුවක් සාදා එය ගමනාන්ත ගොනුව සමඟ සම්බන්ධ කරමු. ඉන්පසුව, අපි ගොනුවට දත්ත ලිවීමට ලියන්න() ක්‍රමය භාවිතා කරමු. අවසාන වශයෙන්, අපි සමීප () ක්රමය භාවිතයෙන් ප්රවාහය වසා දමමු.

උදාහරණයක් අපි බලමු.

try {
FileWriter archivo = new FileWriter("datos.txt");
archivo.write("Este es un ejemplo de datos que se escriben en un archivo de texto en Java.");
archivo.close();
} catch (IOException e) {
e.printStackTrace();
}

මෙම උදාහරණයේදී, අපි ලියන්නේ "මෙය ජාවා හි පෙළ ගොනුවකට දත්ත ලිවීමේ උදාහරණයකි." data.txt ගොනුවේ. ගොනු ලිවීමේදී සිදුවිය හැකි ඕනෑම ව්යතිරේකයක් අල්ලා ගැනීමට සහ හැසිරවීමට මතක තබා ගන්න.

8. Java හි TXT ගොනුවකට දත්ත සුරැකීමට byte streams භාවිතා කිරීම

ජාවා හි පෙළ ගොනුවක දත්ත සුරැකීමට, අපට බයිට් ප්‍රවාහ භාවිතා කළ හැකිය. මෙම ප්‍රවාහ මඟින් අපට ගොනුවකට බයිට් අනුපිළිවෙලක් අනුක්‍රමිකව කියවීමට සහ ලිවීමට ඉඩ සලසයි. මුලින්ම අපි class එක භාවිතා කරලා output file එකක් හදන්න ඕන FileOutputStream. එවිට අපට ගොනුවට බයිට් ලිවීමට දත්ත ප්‍රවාහයක් භාවිතා කළ හැක. අපට බ්ලොක් එකක් භාවිතා කළ හැකිය try-catch හැකි ව්යතිරේක හැසිරවීමට.

ප්‍රතිදාන ගොනුව සෑදූ පසු, අපට ක්‍රමය භාවිතා කළ හැකිය write() අපට සුරැකීමට අවශ්‍ය දත්ත ලිවීමට ඇති දත්ත ප්‍රවාහයේ. පෙළ තන්තුවක් ලිවීමට, අපට එය ක්‍රමය භාවිතයෙන් බයිට් බවට පරිවර්තනය කළ හැකිය getBytes() ඉන්පසු ගොනුවට බයිට් ලියන්න. අපිටත් ක්‍රමය භාවිතා කරන්න පුළුවන් writeUTF() UTF-8 ආකෘතියෙන් කෙලින්ම පෙළ තන්තු ලිවීමට. අපට පූර්ණ සංඛ්‍යා හෝ දශම වැනි වෙනත් දත්ත වර්ග ලිවීමට අවශ්‍ය නම්, අපට පන්ති භාවිතා කළ හැක DataOutputStream සහ ඒවායේ අනුරූප ක්රම.

අවසාන වශයෙන්, දත්ත ප්රවාහය වසා දැමීම සහ ක්රමය භාවිතා කර සම්පත් නිදහස් කිරීම වැදගත් වේ close(). මෙමගින් දත්ත ගොනුව වෙත නිවැරදිව සුරකින බවට සහතික වන අතර තොරතුරු නැතිවීම වලක්වනු ඇත. ඊට අමතරව, අපට බ්ලොක් එක භාවිතා කළ හැකිය finally ලිවීමේ ක්‍රියාවලියේදී ව්‍යතිරේකයක් සිදු වුවද ප්‍රවාහය වසා ඇති බව සහතික කිරීමට. මෙම පියවරයන් සමඟ, අපට ජාවා හි ඇති පෙළ ගොනුවකට දත්ත කාර්යක්ෂමව සහ ආරක්ෂිතව සුරැකීමට බයිට් ප්‍රවාහ භාවිතා කළ හැකිය.

9. Java හි TXT ගොනුවකට ආරක්ෂිතව දත්ත සුරැකීම

TXT ගොනුවකට දත්ත සුරැකීමට ආරක්ෂිත ආකාරයකින් ජාවා වලදී, යම් යම් පියවර අනුගමනය කිරීම සහ නිවැරදි මෙවලම් භාවිතා කිරීම වැදගත් වේ. මෙම ලිපියෙන් අපි මෙය සාක්ෂාත් කර ගන්නේ කෙසේද යන්න පිළිබඳ පියවරෙන් පියවර නිබන්ධනයක් ලබා දෙන්නෙමු.

පළමුව, ඔබ TXT ගොනුව වෙත සම්බන්ධතාවයක් ඇති කර ගැනීම සඳහා FileWriter වර්ගයේ වස්තුවක් සෑදිය යුතුය. මෙය සාක්ෂාත් කරගනු ලබන්නේ FileWriter කන්ස්ට්‍රක්ටරය භාවිතා කිරීමෙන් සහ ගොනු මාර්ගය තර්කයක් ලෙස සම්මත කිරීමෙනි. උදාහරණයක් සාදා එය FileWriter කන්ස්ට්‍රක්ටරය වෙත යැවීමට ගොනු පන්තිය භාවිතා කිරීම සුදුසුය. මෙම ගොනුව නිවැරදිව නිර්මාණය කර ඇති බව සහ නිශ්චිත මාර්ගයේ පිහිටා ඇති බව සහතික කරනු ඇත.

එවිට ඔබ ගොනුවට ලිවීමට BufferedWriter වර්ගයේ වස්තුවක් භාවිතා කළ යුතුය කාර්යක්ෂම ආකාරයෙන්. මෙම වස්තුව නිර්මාණය කර ඇත්තේ BufferedWriter කන්ස්ට්‍රක්ටරය භාවිතයෙන් සහ FileWriter වස්තුව තර්කයක් ලෙස සම්මත කරමිනි. BufferedWriter දත්ත ගොනුවට ලිවීමට පෙර තාවකාලිකව බෆරයක ගබඩා කරයි, එය ලිවීමේ ක්‍රියාවලියේ ක්‍රියාකාරිත්වය වැඩි දියුණු කරයි. දත්ත බෆර් කළ පසු, එය ලිවීම () ක්‍රමය භාවිතයෙන් ගොනුවට ලිවිය හැකිය. අවසාන වශයෙන්, සම්පත් නිවැරදිව මුදා හැරීම සහ දත්ත සුරැකීම සහතික කිරීම සඳහා, සමීප() ක්‍රම භාවිතයෙන් BufferedWriter සහ FileWriter දෙකම වසා දැමීම වැදගත් වේ. ආරක්ෂිත ආකාරයකින්.

10. Java හි විශාල TXT ගොනු සමඟ වැඩ කිරීම

ජාවා හි විශාල පෙළ ගොනු සමඟ වැඩ කිරීම අභියෝගාත්මක විය හැකිය, විශේෂයෙන්ම නිසි තාක්ෂණික ක්රම භාවිතා නොකළහොත්. කෙසේ වෙතත්, මෙම කාර්යය වඩාත් කළමනාකරණය කළ හැකි සහ කාර්යක්ෂම කළ හැකි උපාය මාර්ග සහ මෙවලම් කිහිපයක් තිබේ. පහත දැක්වෙන්නේ Java හි විශාල TXT ගොනු සමඟ වැඩ කිරීමේදී ප්‍රයෝජනවත් විය හැකි උපදෙස් සහ ප්‍රවේශයන් කිහිපයක්.

1. ගොනුව බ්ලොක් වලින් කියවන්න: සම්පූර්ණ ගොනුව එකවර කියවීමට උත්සාහ කරනවා වෙනුවට කුඩා බ්ලොක් වලින් එය කියවීම සුදුසුය. මෙය පද්ධතියේ අධි බර වැළැක්වීමට සහ කාර්ය සාධනය වැඩි දියුණු කිරීමට උපකාරී වේ. ඔබට ජාවා හි ඇති BufferedReader පන්තිය භාවිතයෙන් මෙය කළ හැකිය, එමඟින් ඔබට ගොනු පේළියෙන් පේළියකින් හෝ නිශ්චිත ප්‍රමාණයේ බ්ලොක් වලින් කියවීමට ඉඩ සලසයි.

2. මතකය භාවිතා කරන්න කාර්යක්ෂම මාර්ගය: සමග වැඩ කරන විට විශාල ගොනු, මතක භාවිතය ප්‍රශස්ත කිරීම වැදගත් වේ. මෙය කිරීමට එක් ක්රමයක් වන්නේ ගොනුවෙන් කියවන දත්ත ගබඩා කිරීම සඳහා බෆර භාවිතා කිරීමයි. මේ ආකාරයෙන්, ඔබට සම්පූර්ණ ගොනුව මතකයට පැටවීම වෙනුවට බ්ලොක් වල දත්ත සැකසිය හැක.

3. සමගාමීත්වය භාවිතා කරන්න: ගොනු දත්ත සැකසීම තීව්‍ර නම්, කාර්ය සාධනය වැඩි දියුණු කිරීම සඳහා ඔබට සමගාමීත්වය භාවිතා කළ හැක. ඔබට ගොනුව කුඩා කොටස් වලට බෙදිය හැකි අතර ඒවා විවිධ නූල් වල එකවර සැකසීමට හැකිය. මෙය ගොනුව කියවීම සහ සැකසීමේ ක්රියාවලිය වේගවත් කරනු ඇත.

මතක තබා ගැනීමට මතක තබා ගන්න මෙම ඉඟි සහ Java හි විශාල TXT ගොනු සමඟ වැඩ කරන විට ප්රවේශයන්. මෙම ශිල්පීය ක්‍රම ක්‍රියාත්මක කිරීමෙන්, ඔබට විශාල පෙළ ගොනු හැසිරවීමේ කාර්ය සාධනය සහ කාර්යක්ෂමතාව වැඩි දියුණු කිරීමට, කාර්ය සාධන ගැටළු සහ මතක අධි බර මගහරවා ගැනීමට හැකි වනු ඇත.

11. ජාවා කේතනය කළ TXT ගොනු හැසිරවීම

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

පළමුව, ජාවා විසින් කේතනය කරන ලද පෙළ ගොනු හැසිරවීම පහසු කරන පන්ති සහ ක්‍රම කිහිපයක් සපයන බව සඳහන් කිරීම වැදගත්ය. UTF-8 හෝ ISO-8859-1 වැනි නිශ්චිත ආකෘතියකින් අන්තර්ගතය කියවීමට InputStreamReader සමඟ ඒකාබද්ධව භාවිතා කළ හැකි ගොනු කියවීමට FileInputStream බහුලව භාවිතා වන ක්‍රමයක් වේ.

ඔබ කේතනය කරන ලද පෙළ ගොනුව කියවූ පසු, ඔබට ගොනුවට ලිවීමට OutputStreamWriter සමඟ ඒකාබද්ධව FileOutputStream භාවිතා කළ හැක. මීට අමතරව, ඔබට BufferedReader හෝ BufferedWriter පන්තිය භාවිතා කළ හැකි අතර, විශාල ගොනු සමඟ වැඩ කිරීමේදී ප්රයෝජනවත් විය හැකි, පේළියකින් ගොනුව කියවීමට සහ ලිවීමට. විය හැකි ගැටළු මඟහරවා ගැනීම සඳහා ඔබ ගොනුව කියවීම හෝ ලිවීම අවසන් කළ පසු ආදාන සහ ප්‍රතිදාන ප්‍රවාහ වසා දැමීමට මතක තබා ගන්න.

12. ජාවා හි TXT ගොනුවකට දත්ත සුරැකීමේදී දෝෂ හැසිරවීම

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

ජාවා හි TXT ගොනුවකට දත්ත සුරැකීමේදී දෝෂ පාලනය කිරීමට ඔබට ගත හැකි පළමු පියවර වන්නේ ගොනුව තිබේද යන්න සහ ඔබට එයට ලිවීමේ අවසර තිබේද යන්න පරීක්ෂා කිරීමයි. මෙය එය කළ හැකිය පන්තිය විසින් සපයන ලද කාර්යයන් භාවිතා කිරීම java.io.File. ගොනුව නොපවතී නම් හෝ ඔබට අවශ්‍ය අවසර නොමැති නම්, ඔබට පරිශීලකයාට දෝෂ පණිවිඩයක් පෙන්වීමට හෝ ගැටළුව විසඳීමට අවශ්‍ය ක්‍රියාමාර්ග ගත හැකිය.

අතිරේකව, ගොනුව වෙත ලිවීමේ ක්රියාවලියේදී ඇතිවිය හැකි දෝෂයන් සැලකිල්ලට ගැනීම වැදගත්ය. මේ සඳහා, ඔබට පන්තිය භාවිතා කළ හැකිය java.io.FileWriter පෙළ ගොනුවකට දත්ත ලිවීමට අපට ඉඩ සලසයි. ගොනුවට ලිවීම සඳහා කේතය බ්ලොක් එකක ඔතා තැබීම සුදුසුය try-catch විසි කළ හැකි ඕනෑම ව්යතිරේකයක් අල්ලා ගැනීමට. ව්‍යතිරේකයක් සිදුවුවහොත්, පරිශීලකයාට දෝෂ පණිවිඩයක් පෙන්විය හැකිය, නැතහොත් ගැටළුව විසඳීමට සුදුසු ක්‍රියාමාර්ග ගත හැකිය.

13. ජාවා හි TXT ගොනුවකට දත්ත ලිවීම ප්‍රශස්ත කිරීම

ජාවා හි TXT ගොනුවකට දත්ත ලිවීමේදී, කාර්යක්ෂම කාර්ය සාධනය සහතික කිරීම සඳහා ක්‍රියාවලිය ප්‍රශස්ත කිරීම වැදගත් වේ. මෙය සාක්ෂාත් කර ගැනීම සඳහා භාවිතා කළ හැකි උපාය මාර්ග සහ ශිල්පීය ක්‍රම කිහිපයක් තිබේ. ජාවා හි TXT ගොනුවකට දත්ත ලිවීම ප්‍රශස්ත කිරීම සඳහා නිර්දේශ කිහිපයක් පහත දැක්වේ.

1. බෆර් කළ දත්ත ප්‍රවාහයක් භාවිතා කරන්න: TXT ගොනුවකට ලිවීමේදී BufferedWriter භාවිතා කිරීමෙන් කාර්ය සාධනය සැලකිය යුතු ලෙස වැඩිදියුණු කළ හැක. මෙම බෆර කළ දත්ත ප්‍රවාහය ගොනුවට ලිවීමට පෙර දත්ත තාවකාලිකව මතකයේ ගබඩා කරයි, එමඟින් සිදු කළ යුතු ලිවීමේ මෙහෙයුම් ගණන අඩු කරයි.

2. ෆ්ලෂ් () ක්‍රමය අරපිරිමැස්මෙන් භාවිතා කරන්න: TXT ගොනුවකට ලිවීමේදී flush() ක්‍රමය භාවිතා කිරීමේදී ප්‍රවේශම් වීම වැදගත් වේ. මෙම ක්රමය නිතර නිතර කැඳවනු ලැබුවහොත්, එය කාර්ය සාධනයට අහිතකර ලෙස බලපෑ හැකිය. ඔබ ලිවීම් සමූහයක් සම්පූර්ණ කළ පසු හෝ ඔබ ගොනුවට ලිවීම අවසන් කළ පසු flush() ඇමතීමට නිර්දේශ කෙරේ.

3. නූල් භාවිතය සලකා බලන්න: ඔබට TXT ගොනුවකට විශාල දත්ත ප්‍රමාණයක් ලිවීමට අවශ්‍ය නම්, ඔබට නූල් භාවිතා කිරීමෙන් කාර්ය සාධනය වැඩි දියුණු කළ හැක. ගොනුවට එකවර ලිවීමට බහු නූල් සෑදිය හැක, එමගින් කාර්ය භාරය බෙදීම සහ ලිවීමේ ක්රියාවලිය වේගවත් කරයි.

14. ජාවා හි TXT ගොනු සමඟ වැඩ කිරීම සඳහා අතිරේක පුස්තකාල සහ සම්පත්

පහත දැක්වෙන්නේ Java හි TXT ගොනු සමඟ වැඩ කිරීමට ප්‍රයෝජනවත් විය හැකි අතිරේක පුස්තකාල සහ සම්පත් ලැයිස්තුවකි:

1. Apache Commons IO පුස්තකාලය: මෙම පුස්තකාලය ජාවා ලෝකයේ බහුලව භාවිතා වන අතර ගොනු සමඟ වැඩ කිරීම සඳහා උපයෝගිතා ගණනාවක් සපයයි. TXT ගොනු සමඟ වැඩ කිරීමට, විශේෂයෙන් දත්ත කියවීම සහ ලිවීමේදී, ඔබට Apache Commons IO FileUtils පන්තිය භාවිතා කළ හැකිය. මෙම පන්තිය මෙම කාර්යයන් සරල කරන readFileToString() සහ writeStringToFile() වැනි ක්‍රම ඉදිරිපත් කරයි.

2. OpenCSV: OpenCSV යනු CSV (කොමාවෙන් සීමා කළ) ගොනු කියවීමට සහ ලිවීමට ඉඩ දෙන ජාවා පුස්තකාලයකි. එය TXT ගොනු සඳහා විශේෂයෙන් නිර්මාණය කර නොතිබුණද, එය සරල පෙළ ආකෘතියෙන් දත්ත කියවීමට සහ ලිවීමට භාවිතා කළ හැක. නිශ්චිත පරිසීමකයක් මත පදනම්ව පෙළ රේඛා කියවීම සහ ක්ෂේත්‍ර බෙදීම සඳහා සරල අතුරු මුහුණතක් සපයයි. අතිරේකව, හිස් හෝ අදහස් දැක්වූ රේඛා මඟ හැරීම වැනි කාර්යයන් සිදු කළ හැක. ඔබට නිල OpenCSV ප්‍රලේඛනය තුළ භාවිත උදාහරණ සහ නිබන්ධන සොයා ගත හැක.

3. Java FileReader සහ FileWriter: ඔබ TXT ගොනු සමඟ වැඩ කිරීමට ස්වදේශීය ජාවා පන්ති භාවිතා කිරීමට කැමති නම්, ඔබට FileReader සහ FileWriter භාවිතා කළ හැක. මෙම පන්ති පෙළ ගොනුවකට අක්ෂර කියවීම සහ ලිවීම සඳහා සරල අතුරු මුහුණතක් සපයයි. මෙම මෙහෙයුම් සිදු කිරීමට ඔබට read(), write() සහ close() වැනි ක්‍රම භාවිතා කළ හැක. කෙසේ වෙතත්, මෙම පන්ති ක්‍රියා කරන්නේ චරිත මට්ටමින් බවත්, ඉහත සඳහන් කළ පුස්තකාලවල සාමාන්‍ය උසස් ක්‍රියාකාරීත්වයන් ලබා නොදෙන බවත් සලකා බැලීම වැදගත් වේ.

මේවා ජාවා හි TXT ගොනු සමඟ වැඩ කිරීම සඳහා අමතර පුස්තකාල සහ සම්පත් සඳහා උදාහරණ කිහිපයක් පමණක් බව මතක තබා ගන්න. ඔබේ නිශ්චිත අවශ්‍යතා මත පදනම්ව, ඔබට වෙනත් විකල්ප ගවේෂණය කර ඔබේ අවශ්‍යතාවලට වඩාත් ගැලපෙන එකක් සොයා ගත හැක.

සාරාංශයක් ලෙස, ජාවා හි TXT ගොනුවකට දත්ත සුරැකීමේ ක්‍රියාවලිය අඛණ්ඩව තොරතුරු ගබඩා කිරීම අවශ්‍ය වන ව්‍යාපෘති සඳහා අත්‍යවශ්‍ය වේ. FileInputStream සහ FileOutputStream පන්ති හරහා, TXT ගොනු වෙත ප්‍රවේශ වී කාර්යක්ෂමව හැසිරවිය හැක. ඊට අමතරව, ව්‍යතිරේක භාවිතය සහ සම්පත් නිසි ලෙස වසා දැමීම දත්ත අඛණ්ඩතාව සහ වැඩසටහනේ නිසි ක්‍රියාකාරිත්වය සහතික කරයි.

Java හි ගොනු හැසිරවීම යනු නිසි ව්‍යතිරේක හැසිරවීම, ගොනු වල පැවැත්ම සහ අවසරයන් පරීක්ෂා කිරීම සහ සම්පත් නිවැරදිව වසා දැමීම වැනි හොඳ භාවිතයන් ක්‍රියාත්මක කිරීම බව මතක තබා ගැනීම වැදගත්ය. එසේම, විශාල දත්ත පරිමාවක් හැසිරවීමේදී කාර්ය සාධනය සහ කාර්යක්ෂමතාව සලකා බැලීම සුදුසුය.

සාරාංශයක් ලෙස, ජාවා හි TXT ගොනුවකට දත්ත සුරැකීම මෘදුකාංග සංවර්ධනයේ මූලික අංගයක් වන අතර මෙම ශිල්පීය ක්‍රම ප්‍රගුණ කිරීම ක්‍රමලේඛකයින්ට වඩාත් කාර්යක්ෂමව සහ වෘත්තීයමය වශයෙන් වැඩ කිරීමට ඉඩ සලසයි.