මම ගොනුවක් සාදා ජාවා හි එයට ලියන්නේ කෙසේද?

ජාවා හි (පෙළ) ගොනුවක් සෑදීමට සහ ලිවීමට ඇති සරලම ක්‍රමය කුමක්ද?

පහත දැක්වෙන එක් එක් කේත සාම්පල විසි කළ හැකි බව සලකන්න IOException. උත්සාහ කිරීම / අල්ලා ගැනීම / අවසානයේ කුට්ටි සංක්ෂිප්තව ඉවත් කර ඇත. ව්‍යතිරේක හැසිරවීම පිළිබඳ තොරතුරු සඳහා මෙම නිබන්ධනය බලන්න .

පහත දැක්වෙන එක් එක් කේත සාම්පල ගොනුව දැනටමත් තිබේ නම් එය නැවත ලියයි

පෙළ ගොනුවක් නිර්මාණය කිරීම:

PrintWriter writer = new PrintWriter("the-file-name.txt", "UTF-8");
writer.println("The first line");
writer.println("The second line");
writer.close();

ද්විමය ගොනුවක් නිර්මාණය කිරීම:

byte data[] = ...
FileOutputStream out = new FileOutputStream("the-file-name");
out.write(data);
out.close();

ජාවා 7+ පරිශීලකයින්ට Filesලිපිගොනු ලිවීමට පන්තිය භාවිතා කළ හැකිය :

පෙළ ගොනුවක් නිර්මාණය කිරීම:

List<String> lines = Arrays.asList("The first line", "The second line");
Path file = Paths.get("the-file-name.txt");
Files.write(file, lines, StandardCharsets.UTF_8);
//Files.write(file, lines, StandardCharsets.UTF_8, StandardOpenOption.APPEND);

ද්විමය ගොනුවක් නිර්මාණය කිරීම:

byte data[] = ...
Path file = Paths.get("the-file-name");
Files.write(file, data);
//Files.write(file, data, StandardOpenOption.APPEND);

ජාවා 7 සහ ඊට ඉහළින්:

try (Writer writer = new BufferedWriter(new OutputStreamWriter(
              new FileOutputStream("filename.txt"), "utf-8"))) {
   writer.write("something");
}

ඒ සඳහා ප්‍රයෝජනවත් උපයෝගීතා ඇත:

• පොදු- io වෙතින් FileUtils.writeStringtoFile (..)
• Files.write (..) පේර සිට

ඔබට a භාවිතා කළ හැකි බව සලකන්න FileWriter, නමුත් එය පෙරනිමි කේතන ක්‍රමයක් භාවිතා කරයි, එය බොහෝ විට නරක අදහසකි - කේතීකරණය පැහැදිලිව සඳහන් කිරීම වඩාත් සුදුසුය.

පහත දැක්වෙන්නේ ජාවා 7 ට පෙර මුල් පිටපතයි

Writer writer = null;

try {
    writer = new BufferedWriter(new OutputStreamWriter(
          new FileOutputStream("filename.txt"), "utf-8"));
    writer.write("Something");
} catch (IOException ex) {
    // Report
} finally {
   try {writer.close();} catch (Exception ex) {/*ignore*/}
}

මෙයද බලන්න: ලිපිගොනු කියවීම, ලිවීම සහ නිර්මාණය කිරීම (NIO2 ඇතුළත් වේ).

ඔබට දැනටමත් ගොනුවට ලිවීමට අවශ්‍ය අන්තර්ගතය තිබේ නම් (සහ පියාසර කිරීමෙන් උත්පාදනය නොවේ), java.nio.file.Filesස්වදේශීය I / O හි කොටසක් ලෙස ජාවා 7 හි එකතු කිරීම ඔබේ අරමුණු සාක්ෂාත් කර ගැනීම සඳහා සරලම හා කාර්යක්ෂම ක්‍රමය සපයයි.

මූලික වශයෙන් ගොනුවක් සෑදීම සහ ලිවීම එක් පේළියක් පමණි, එපමනක් නොව එක් සරල ක්‍රම ඇමතුමක් !

එය භාවිතා කළ හැකි ආකාරය පෙන්වීමට පහත උදාහරණය විවිධ ගොනු 6 ක් නිර්මාණය කර ලියයි:

Charset utf8 = StandardCharsets.UTF_8;
List<String> lines = Arrays.asList("1st line", "2nd line");
byte[] data = {1, 2, 3, 4, 5};

try {
    Files.write(Paths.get("file1.bin"), data);
    Files.write(Paths.get("file2.bin"), data,
            StandardOpenOption.CREATE, StandardOpenOption.APPEND);
    Files.write(Paths.get("file3.txt"), "content".getBytes());
    Files.write(Paths.get("file4.txt"), "content".getBytes(utf8));
    Files.write(Paths.get("file5.txt"), lines, utf8);
    Files.write(Paths.get("file6.txt"), lines, utf8,
            StandardOpenOption.CREATE, StandardOpenOption.APPEND);
} catch (IOException e) {
    e.printStackTrace();
}

public class Program {
    public static void main(String[] args) {
        String text = "Hello world";
        BufferedWriter output = null;
        try {
            File file = new File("example.txt");
            output = new BufferedWriter(new FileWriter(file));
            output.write(text);
        } catch ( IOException e ) {
            e.printStackTrace();
        } finally {
          if ( output != null ) {
            output.close();
          }
        }
    }
}

ගොනුවක් සෑදීමට හෝ නැවත ලිවීමට කුඩා උදාහරණ වැඩසටහනක් මෙන්න. එය දිගු අනුවාදය බැවින් එය වඩාත් පහසුවෙන් තේරුම් ගත හැකිය.

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;

public class writer {
    public void writing() {
        try {
            //Whatever the file path is.
            File statText = new File("E:/Java/Reference/bin/images/statsTest.txt");
            FileOutputStream is = new FileOutputStream(statText);
            OutputStreamWriter osw = new OutputStreamWriter(is);    
            Writer w = new BufferedWriter(osw);
            w.write("POTATO!!!");
            w.close();
        } catch (IOException e) {
            System.err.println("Problem writing to the file statsTest.txt");
        }
    }

    public static void main(String[]args) {
        writer write = new writer();
        write.writing();
    }
}

ජාවා හි ගොනුවක් සෑදීමට සහ ලිවීමට ඉතා සරල ක්‍රමයක්:

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;

public class CreateFiles {

    public static void main(String[] args) {
        try{
            // Create new file
            String content = "This is the content to write into create file";
            String path="D:\\a\\hi.txt";
            File file = new File(path);

            // If file doesn't exists, then create it
            if (!file.exists()) {
                file.createNewFile();
            }

            FileWriter fw = new FileWriter(file.getAbsoluteFile());
            BufferedWriter bw = new BufferedWriter(fw);

            // Write in file
            bw.write(content);

            // Close connection
            bw.close();
        }
        catch(Exception e){
            System.out.println(e);
        }
    }
}

භාවිත:

try (Writer writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("myFile.txt"), StandardCharsets.UTF_8))) {
    writer.write("text to write");
} 
catch (IOException ex) {
    // Handle me
}  

භාවිතා කිරීම try()ප්‍රවාහය ස්වයංක්‍රීයව වසා දමයි. මෙම අනුවාදය කෙටි, වේගවත් (ස්වාරක්ෂක) වන අතර කේතන තේරීම සක්‍රීය කරයි.

මෙම අංගය ජාවා 7 හි හඳුන්වා දෙන ලදී.

මෙන්න අපි පෙළ ගොනුවකට නූලක් ඇතුළත් කරමු:

String content = "This is the content to write into a file";
File file = new File("filename.txt");
FileWriter fw = new FileWriter(file.getAbsoluteFile());
BufferedWriter bw = new BufferedWriter(fw);
bw.write(content);
bw.close(); // Be sure to close BufferedWriter

අපට පහසුවෙන් නව ගොනුවක් සාදා එයට අන්තර්ගතය එක් කළ හැකිය.

ඊවාල්ඩ් (සූර්යයා සහ අයිබීඑම් යන දෙකින්ම, සහ මේවා තාක්‍ෂණිකව වඩාත්ම පුලුල්ව පවතින ජේවීඑම්) ජාවා අනුවාද සඳහා විසඳුමක් අවශ්‍ය දැයි කතුවරයා නිශ්චිතව දක්වා නොමැති හෙයින්, සහ බොහෝ දෙනා පිළිතුරු දී ඇති බව පෙනේ කතුවරයාගේ ප්‍රශ්නය එය පෙළ (ද්විමය නොවන) ගොනුවක් බව සඳහන් කිරීමට පෙර, මගේ පිළිතුර සැපයීමට මම තීරණය කර ඇත්තෙමි.

පළමුවෙන්ම, ජාවා 6 සාමාන්‍යයෙන් ජීවිතයේ අවසානය කරා ළඟා වී ඇති අතර, කතුවරයාට ඔහුට උරුම අනුකූලතාවයක් අවශ්‍ය බව සඳහන් කර නොමැති හෙයින්, මම සිතන්නේ එය ස්වයංක්‍රීයව ජාවා 7 හෝ ඊට ඉහළින් අදහස් කරන බවයි (ජාවා 7 තවමත් අයිබීඑම් විසින් ඊඕල්ඩ් කර නැත). එබැවින්, I / O නිබන්ධනය: https://docs.oracle.com/javase/tutorial/essential/io/legacy.html ගොනුව දෙස අපට නිවැරදිව බැලිය හැකිය.

ජාවා SE 7 නිකුතුවට පෙර, java.io.File පන්තිය I / O ගොනුව සඳහා භාවිතා කරන යාන්ත්‍රණය වන නමුත් එයට අඩුපාඩු කිහිපයක් තිබුණි.

• බොහෝ ක්‍රම අසාර්ථක වූ විට ව්‍යතිරේකයන් විසි නොකළ බැවින් ප්‍රයෝජනවත් දෝෂ පණිවිඩයක් ලබා ගත නොහැකි විය. උදාහරණයක් ලෙස, ලිපිගොනු මකාදැමීම අසාර්ථක වුවහොත්, වැඩසටහනට "මකාදැමීමේ අසමත් වීමක්" ලැබෙනු ඇත, නමුත් එය ගොනුව නොපවතින නිසාද, පරිශීලකයාට අවසර නොමැතිද, නැතහොත් වෙනත් ගැටළුවක් තිබේද යන්න නොදනී.
• නැවත නම් කිරීමේ ක්‍රමය වේදිකා හරහා අඛණ්ඩව ක්‍රියාත්මක නොවීය.
• සංකේතාත්මක සම්බන්ධතා සඳහා සැබෑ සහයෝගයක් නොතිබුණි.
• ගොනු අවසරයන්, ගොනු හිමිකරු සහ වෙනත් ආරක්ෂක ගුණාංග වැනි පාර-දත්ත සඳහා වැඩි සහයෝගයක් අවශ්‍ය විය. ගොනු පාර-දත්ත වලට ප්‍රවේශ වීම අකාර්යක්ෂම විය.
• බොහෝ ගොනු ක්‍රම පරිමාණය කර නැත. සේවාදායකයක් හරහා විශාල ඩිරෙක්ටරි ලැයිස්තුවක් ඉල්ලීම නිසා එය එල්ලී යා හැක. විශාල ඩිරෙක්ටරි මගින් මතක සම්පත් ගැටළු ඇති විය හැකි අතර එමඟින් සේවාව ප්‍රතික්ෂේප වේ.
• චක්‍රලේඛ සංකේතාත්මක සබැඳි තිබේ නම් ගොනු ගසක් පුනරාවර්තනය වී නිසි පරිදි ප්‍රතිචාර දැක්විය හැකි විශ්වාසදායක කේතයක් ලිවීමට නොහැකි විය.

හොඳයි, එය java.io.File ප්‍රතික්ෂේප කරයි. ගොනුවක් ලිවීමට / එකතු කිරීමට නොහැකි නම්, ඒ මන්දැයි ඔබට දැන ගැනීමට පවා නොහැකි වනු ඇත.

අපට නිබන්ධනය දෙස දිගටම බලා සිටිය හැකිය: https://docs.oracle.com/javase/tutorial/essential/io/file.html#common

ඔබ සතුව සියලු රේඛා තිබේ නම් ඔබ පෙළ ගොනුවට කල්තියා ලියනු ඇත (එකතු කරන්න) , නිර්දේශිත ප්‍රවේශය වන්නේ https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html# write-java.nio.file.Path-java.lang.Iterable-java.nio.charset.Charset-java.nio.file.OpenOption ...-

මෙන්න උදාහරණයක් (සරල):

Path file = ...;
List<String> linesInMemory = ...;
Files.write(file, linesInMemory, StandardCharsets.UTF_8);

තවත් උදාහරණයක් (එකතු කරන්න):

Path file = ...;
List<String> linesInMemory = ...;
Files.write(file, linesInMemory, Charset.forName("desired charset"), StandardOpenOption.CREATE, StandardOpenOption.APPEND, StandardOpenOption.WRITE);

ඔබට යන විට ගොනු අන්තර්ගතය ලිවීමට අවශ්‍ය නම් : https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html#newBufferedWriter-java.nio.file.Path-java .nio.charset.Charset-java.nio.file.OpenOption ...-

සරල කළ උදාහරණය (ජාවා 8 හෝ ඊට වැඩි):

Path file = ...;
try (BufferedWriter writer = Files.newBufferedWriter(file)) {
    writer.append("Zero header: ").append('0').write("\r\n");
    [...]
}

තවත් උදාහරණයක් (එකතු කරන්න):

Path file = ...;
try (BufferedWriter writer = Files.newBufferedWriter(file, Charset.forName("desired charset"), StandardOpenOption.CREATE, StandardOpenOption.APPEND, StandardOpenOption.WRITE)) {
    writer.write("----------");
    [...]
}

මෙම ක්‍රම සඳහා කතුවරයාගේ පැත්තෙන් අවම උත්සාහයක් අවශ්‍ය වන අතර [පෙළ] ලිපිගොනු වලට ලිවීමේදී අනෙක් සියල්ලන්ටම වැඩි කැමැත්තක් දැක්විය යුතුය.

ඔබට සාපේක්ෂව වේදනා රහිත අත්දැකීමක් ලබා ගැනීමට අවශ්‍ය නම්, ඔබට වඩාත් පැහැදිලිවම පන්තිය වන Apache Commons IO පැකේජය දෙස බැලිය හැකිය .FileUtils

තෙවන පාර්ශවීය පුස්තකාල පරීක්ෂා කිරීමට කිසි විටෙකත් අමතක නොකරන්න. දිනය හැසිරවීම සඳහා ජෝඩා-වේලාව , පොදු සංගීත මෙහෙයුම් සඳහා අපාචේ කොමන්ස් ලැන්ග්StringUtils සහ ඔබේ කේතය වඩාත් කියවිය හැකි ය.

ජාවා විශිෂ්ට භාෂාවකි, නමුත් සම්මත පුස්තකාලය සමහර විට ටිකක් පහත් මට්ටමක පවතී. බලවත්, නමුත් පහත් මට්ටමේ කෙසේ වෙතත්.

ජාවා හි ගොනුවක් සෑදීමට සහ ලිවීමට හැකි ක්‍රම කිහිපයක් මෙන්න:

FileOutputStream භාවිතා කිරීම

try {
  File fout = new File("myOutFile.txt");
  FileOutputStream fos = new FileOutputStream(fout);
  BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(fos));
  bw.write("Write somthing to the file ...");
  bw.newLine();
  bw.close();
} catch (FileNotFoundException e){
  // File was not found
  e.printStackTrace();
} catch (IOException e) {
  // Problem when writing to the file
  e.printStackTrace();
}

FileWriter භාවිතා කිරීම

try {
  FileWriter fw = new FileWriter("myOutFile.txt");
  fw.write("Example of content");
  fw.close();
} catch (FileNotFoundException e) {
  // File not found
  e.printStackTrace();
} catch (IOException e) {
  // Error when writing to the file
  e.printStackTrace();
}

PrintWriter භාවිතා කිරීම

try {
  PrintWriter pw = new PrintWriter("myOutFile.txt");
  pw.write("Example of content");
  pw.close();
} catch (FileNotFoundException e) {
  // File not found
  e.printStackTrace();
} catch (IOException e) {
  // Error when writing to the file
  e.printStackTrace();
}

OutputStreamWriter භාවිතා කිරීම

try {
  File fout = new File("myOutFile.txt");
  FileOutputStream fos = new FileOutputStream(fout);
  OutputStreamWriter osw = new OutputStreamWriter(fos);
  osw.write("Soe content ...");
  osw.close();
} catch (FileNotFoundException e) {
  // File not found
  e.printStackTrace();
} catch (IOException e) {
  // Error when writing to the file
  e.printStackTrace();
}

වැඩිදුර විස්තර සඳහා ජාවා හි ලිපිගොනු කියවීම සහ ලිවීම පිළිබඳ නිබන්ධනය පරීක්ෂා කරන්න .

ඔබට කිසියම් හේතුවක් නිසා නිර්මාණය කිරීමේ හා ලිවීමේ ක්‍රියාව වෙන් කිරීමට අවශ්‍ය නම්, ජාවා සමාන touchවේ

try {
   //create a file named "testfile.txt" in the current working directory
   File myFile = new File("testfile.txt");
   if ( myFile.createNewFile() ) {
      System.out.println("Success!");
   } else {
      System.out.println("Failure!");
   }
} catch ( IOException ioe ) { ioe.printStackTrace(); }

createNewFile()පැවැත්ම පරීක්ෂා කර ගොනුව පරමාණුකව නිර්මාණය කරයි. උදාහරණයක් ලෙස ගොනුව ලිවීමට පෙර ඔබ එහි නිර්මාතෘ බව සහතික කිරීමට අවශ්‍ය නම් මෙය ප්‍රයෝජනවත් වේ.

භාවිත:

JFileChooser c = new JFileChooser();
c.showOpenDialog(c);
File writeFile = c.getSelectedFile();
String content = "Input the data here to be written to your file";

try {
    FileWriter fw = new FileWriter(writeFile);
    BufferedWriter bw = new BufferedWriter(fw);
    bw.append(content);
    bw.append("hiiiii");
    bw.close();
    fw.close();
}
catch (Exception exc) {
   System.out.println(exc);
}

හොඳම ක්‍රමය වන්නේ ජාවා 7 භාවිතා කිරීමයි: ජාවා 7 ගොනු පද්ධතිය සමඟ වැඩ කිරීමේ නව ක්‍රමයක් හඳුන්වා දෙයි, නව උපයෝගිතා පන්තියක් සමඟ - ගොනු. ලිපිගොනු පන්තිය භාවිතා කරමින්, අපට ගොනු සහ නාමාවලි නිර්මාණය කිරීමට, ගෙනයාමට, පිටපත් කිරීමට, මකා දැමීමට හැකිය; එය ගොනුවක් කියවීමට හා ලිවීමට ද භාවිතා කළ හැකිය.

public void saveDataInFile(String data) throws IOException {
    Path path = Paths.get(fileName);
    byte[] strToBytes = data.getBytes();

    Files.write(path, strToBytes);
}

FileChannel සමඟ ලියන්න ඔබ විශාල ලිපිගොනු සමඟ කටයුතු කරන්නේ නම්, FileChannel සම්මත IO ට වඩා වේගවත් විය හැකිය. FileChannel භාවිතා කරමින් ගොනුවකට පහත දැක්වෙන කේතය ලියන්න:

public void saveDataInFile(String data) 
  throws IOException {
    RandomAccessFile stream = new RandomAccessFile(fileName, "rw");
    FileChannel channel = stream.getChannel();
    byte[] strBytes = data.getBytes();
    ByteBuffer buffer = ByteBuffer.allocate(strBytes.length);
    buffer.put(strBytes);
    buffer.flip();
    channel.write(buffer);
    stream.close();
    channel.close();
}

DataOutputStream සමඟ ලියන්න

public void saveDataInFile(String data) throws IOException {
    FileOutputStream fos = new FileOutputStream(fileName);
    DataOutputStream outStream = new DataOutputStream(new BufferedOutputStream(fos));
    outStream.writeUTF(data);
    outStream.close();
}

FileOutputStream සමඟ ලියන්න

ගොනුවකට ද්විමය දත්ත ලිවීමට FileOutputStream භාවිතා කරන්නේ කෙසේදැයි දැන් බලමු. පහත කේතය String int බයිට් බවට පරිවර්තනය කර FileOutputStream භාවිතා කරමින් ගොනු කිරීමට බයිට් ලියයි:

public void saveDataInFile(String data) throws IOException {
    FileOutputStream outputStream = new FileOutputStream(fileName);
    byte[] strToBytes = data.getBytes();
    outputStream.write(strToBytes);

    outputStream.close();
}

PrintWriter සමඟ ලියන්න අපට ගොනුවකට ආකෘතිගත පෙළ ලිවීමට PrintWriter භාවිතා කළ හැකිය:

public void saveDataInFile() throws IOException {
    FileWriter fileWriter = new FileWriter(fileName);
    PrintWriter printWriter = new PrintWriter(fileWriter);
    printWriter.print("Some String");
    printWriter.printf("Product name is %s and its price is %d $", "iPhone", 1000);
    printWriter.close();
}

BufferedWriter සමඟ ලියන්න: නව ගොනුවකට නූල් ලිවීමට BufferedWriter භාවිතා කරන්න:

public void saveDataInFile(String data) throws IOException {
    BufferedWriter writer = new BufferedWriter(new FileWriter(fileName));
    writer.write(data);

    writer.close();
}

පවතින ගොනුවට නූලක් එකතු කරන්න:

public void saveDataInFile(String data) throws IOException {
    BufferedWriter writer = new BufferedWriter(new FileWriter(fileName, true));
    writer.append(' ');
    writer.append(data);

    writer.close();
}

මම හිතන්නේ මෙය කෙටිම ක්‍රමයයි:

FileWriter fr = new FileWriter("your_file_name.txt"); // After '.' write
// your file extention (".txt" in this case)
fr.write("Things you want to write into the file"); // Warning: this will REPLACE your old file content!
fr.close();

පවතින ගොනුව නැවත ලිවීමකින් තොරව ගොනුවක් සෑදීමට:

System.out.println("Choose folder to create file");
JFileChooser c = new JFileChooser();
c.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
c.showOpenDialog(c);
c.getSelectedFile();
f = c.getSelectedFile(); // File f - global variable
String newfile = f + "\\hi.doc";//.txt or .doc or .html
File file = new File(newfile);

try {
    //System.out.println(f);
    boolean flag = file.createNewFile();

    if(flag == true) {
        JOptionPane.showMessageDialog(rootPane, "File created successfully");
    }
    else {
        JOptionPane.showMessageDialog(rootPane, "File already exists");
    }
    /* Or use exists() function as follows:
        if(file.exists() == true) {
            JOptionPane.showMessageDialog(rootPane, "File already exists");
        }
        else {
            JOptionPane.showMessageDialog(rootPane, "File created successfully");
        }
    */
}
catch(Exception e) {
    // Any exception handling method of your choice
}

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

public class FileWriterExample {
    public static void main(String [] args) {
        FileWriter fw= null;
        File file =null;
        try {
            file=new File("WriteFile.txt");
            if(!file.exists()) {
                file.createNewFile();
            }
            fw = new FileWriter(file);
            fw.write("This is an string written to a file");
            fw.flush();
            fw.close();
            System.out.println("File written Succesfully");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

ජාවා 7+ සඳහා උත්සාහ කිරීම වටී:

 Files.write(Paths.get("./output.txt"), "Information string herer".getBytes());

එය බලාපොරොත්තු සහගතයි ...

package fileoperations;
import java.io.File;
import java.io.IOException;

public class SimpleFile {
    public static void main(String[] args) throws IOException {
        File file =new File("text.txt");
        file.createNewFile();
        System.out.println("File is created");
        FileWriter writer = new FileWriter(file);

        // Writes the content to the file
        writer.write("Enter the text that you want to write"); 
        writer.flush();
        writer.close();
        System.out.println("Data is entered into file");
    }
}

මට සොයාගත හැකි සරලම ක්‍රමය:

Path sampleOutputPath = Paths.get("/tmp/testfile")
try (BufferedWriter writer = Files.newBufferedWriter(sampleOutputPath)) {
    writer.write("Hello, world!");
}

එය බොහෝ විට ක්‍රියාත්මක වන්නේ 1.7+ සඳහා පමණි.

එක් පේළියක් පමණි! pathසහ lineනූල් වේ

import java.nio.file.Files;
import java.nio.file.Paths;

Files.write(Paths.get(path), lines.getBytes());

ආදාන සහ ප්‍රතිදාන ධාරාව භාවිතා කරමින් ගොනු කියවීම සහ ලිවීම:

//Coded By Anurag Goel
//Reading And Writing Files
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;


public class WriteAFile {
    public static void main(String args[]) {
        try {
            byte array [] = {'1','a','2','b','5'};
            OutputStream os = new FileOutputStream("test.txt");
            for(int x=0; x < array.length ; x++) {
                os.write( array[x] ); // Writes the bytes
            }
            os.close();

            InputStream is = new FileInputStream("test.txt");
            int size = is.available();

            for(int i=0; i< size; i++) {
                System.out.print((char)is.read() + " ");
            }
            is.close();
        } catch(IOException e) {
            System.out.print("Exception");
        }
    }
}

මෙම පැකේජය ඇතුළත් කරන්න:

java.nio.file

ගොනුව ලිවීමට ඔබට මෙම කේතය භාවිතා කළ හැකිය:

Path file = ...;
byte[] buf = ...;
Files.write(file, buf);

ජාවා 8 හි ලිපිගොනු සහ මාර්ග භාවිතා කර සම්පත් සමඟ අත්හදා බැලීම් භාවිතා කරන්න.

import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class WriteFile{
    public static void main(String[] args) throws IOException {
        String file = "text.txt";
        System.out.println("Writing to file: " + file);
        // Files.newBufferedWriter() uses UTF-8 encoding by default
        try (BufferedWriter writer = Files.newBufferedWriter(Paths.get(file))) {
            writer.write("Java\n");
            writer.write("Python\n");
            writer.write("Clojure\n");
            writer.write("Scala\n");
            writer.write("JavaScript\n");
        } // the file will be automatically closed
    }
}

අපි ජාවා 7 සහ ඊට ඉහළින් භාවිතා කරන්නේ නම් සහ ගොනුවට එකතු කළ යුතු (එකතු කළ) අන්තර්ගතය දන්නේ නම් අපට NIO පැකේජයේ නව බෆර්ඩ් රයිටර් ක්‍රමය භාවිතා කළ හැකිය .

public static void main(String[] args) {
    Path FILE_PATH = Paths.get("C:/temp", "temp.txt");
    String text = "\n Welcome to Java 8";

    //Writing to the file temp.txt
    try (BufferedWriter writer = Files.newBufferedWriter(FILE_PATH, StandardCharsets.UTF_8, StandardOpenOption.APPEND)) {
        writer.write(text);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

සැලකිල්ලට ගත යුතු කරුණු කිහිපයක් තිබේ:

1. අක්ෂර කට්ටල කේතනය කිරීම සැමවිටම හොඳ පුරුද්දක් වන අතර ඒ සඳහා අපට පන්තියේ නියතයක් ඇත StandardCharsets.
2. try-with-resourceඋත්සාහයෙන් පසු සම්පත් ස්වයංක්‍රීයව වසා ඇති ප්‍රකාශයක් කේතය භාවිතා කරයි .

OP ඉල්ලා නොසිටි නමුත් අපට නිශ්චිත මූල පදයක් ඇති රේඛා සෙවීමට අවශ්‍ය නම් උදා. confidentialඅපට ජාවා හි ධාරාව API භාවිතා කළ හැකිය:

//Reading from the file the first line which contains word "confidential"
try {
    Stream<String> lines = Files.lines(FILE_PATH);
    Optional<String> containsJava = lines.filter(l->l.contains("confidential")).findFirst();
    if(containsJava.isPresent()){
        System.out.println(containsJava.get());
    }
} catch (IOException e) {
    e.printStackTrace();
}

වැනි සරල ක්‍රම කිහිපයක් තිබේ:

File file = new File("filename.txt");
PrintWriter pw = new PrintWriter(file);

pw.write("The world I'm coming");
pw.close();

String write = "Hello World!";

FileWriter fw = new FileWriter(file);
BufferedWriter bw = new BufferedWriter(fw);

fw.write(write);

fw.close();

පද්ධති දේපලක් භාවිතා කර ඔබට තාවකාලික ගොනුවක් පවා සෑදිය හැකිය, එය ඔබ භාවිතා කරන මෙහෙයුම් පද්ධතියෙන් ස්වාධීන වේ.

File file = new File(System.*getProperty*("java.io.tmpdir") +
                     System.*getProperty*("file.separator") +
                     "YourFileName.txt");

ගූගල් හි ගුවා පුස්තකාලය භාවිතා කරමින් අපට ගොනුවක් ඉතා පහසුවෙන් නිර්මාණය කර ලිවිය හැකිය.

package com.zetcode.writetofileex;

import com.google.common.io.Files;
import java.io.File;
import java.io.IOException;

public class WriteToFileEx {

    public static void main(String[] args) throws IOException {

        String fileName = "fruits.txt";
        File file = new File(fileName);

        String content = "banana, orange, lemon, apple, plum";

        Files.write(content.getBytes(), file);
    }
}

උදාහරණ මඟින් fruits.txtව්‍යාපෘති මූල නාමාවලියෙහි නව ගොනුවක් සාදයි .

JFilechooser සමඟ ගනුදෙනුකරුවන් සමඟ එකතු කිරීම කියවීම සහ ගොනු කිරීමට සුරැකීම.

private void writeFile(){

    JFileChooser fileChooser = new JFileChooser(this.PATH);
    int retValue = fileChooser.showDialog(this, "Save File");

    if (retValue == JFileChooser.APPROVE_OPTION){

        try (Writer fileWrite = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileChooser.getSelectedFile())))){

            this.customers.forEach((c) ->{
                try{
                    fileWrite.append(c.toString()).append("\n");
                }
                catch (IOException ex){
                    ex.printStackTrace();
                }
            });
        }
        catch (IOException e){
            e.printStackTrace();
        }
    }
}

ගොනුවක් සෑදීමට සහ එයට ලිවීමට අවම වශයෙන් ක්‍රම කිහිපයක් තිබේ:

කුඩා ගොනු (1.7)

ගොනුවකට බයිට් හෝ රේඛා ලිවීමට ඔබට එක් ලිවීමේ ක්‍රමයක් භාවිතා කළ හැකිය.

Path file = Paths.get("path-to-file");
byte[] buf = "text-to-write-to-file".getBytes();
Files.write(file, buf);

මෙම ක්‍රම මඟින් ඔබ වෙනුවෙන් ප්‍රවාහය විවෘත කිරීම සහ වැසීම වැනි බොහෝ කාර්යයන් ගැන සැලකිලිමත් වන නමුත් විශාල ගොනු හැසිරවීමට අදහස් නොකෙරේ.

ස්වාරක්ෂක ධාරාව I / O භාවිතා කරමින් විශාල ගොනුවක් ලිවීම (1.7)

මෙම java.nio.fileපැකේජය ආධාරක ධාරාව I / O භාධකයක් හැකි ස්ථර සමහර තුරම වන අවරෝධක චලනය දත්ත, චැනල් I / O.

String s = "much-larger-text-to-write-to-file";
try (BufferedWriter writer = Files.newBufferedWriter(file, StandardCharsets.UTF_8)) {
    writer.write(s, 0, s.length());
}

විශේෂයෙන් ලිවීමේ මෙහෙයුම් විශාල ප්‍රමාණයක් සම්පූර්ණ කිරීමේදී එහි කාර්යක්ෂම ක්‍රියාකාරිත්වය හේතුවෙන් මෙම ප්‍රවේශය මනාප වේ. සෑම බයිට් එකක් සඳහාම මෙහෙයුම් පද්ධතියේ ලිවීමේ ක්‍රමවේදය ඇමතීමට අවශ්‍ය නොවන බැවින්, ආරක්ෂිත මෙහෙයුම් වලට මෙම බලපෑම ඇත, මිල අධික I / O මෙහෙයුම් අඩු කරයි.

නිමැවුම් ධාරාවක් සහිත ගොනුවක් පිටපත් කිරීමට (සහ නව එකක් සෑදීමට) NIO API භාවිතා කිරීම (1.7)

Path oldFile = Paths.get("existing-file-path");
Path newFile = Paths.get("new-file-path");
try (OutputStream os = new FileOutputStream(newFile.toFile())) {
    Files.copy(oldFile, os);
}

ආදාන ප්‍රවාහයක සිට ගොනුවකට සියලුම බයිට් පිටපත් කිරීමට ඉඩ දෙන අතිරේක ක්‍රම ද ඇත.

FileWriter (පෙළ) (<1.7)

කෙලින්ම ගොනුවට ලියයි (අඩු කාර්ය සාධනය) සහ එය භාවිතා කළ යුත්තේ ලිවීම් ගණන අඩු වූ විට පමණි. ගොනුවකට අක්ෂර-නැඹුරු දත්ත ලිවීමට භාවිතා කරයි.

String s= "some-text";
FileWriter fileWriter = new FileWriter("C:\\path\\to\\file\\file.txt");
fileWriter.write(fileContent);
fileWriter.close();

FileOutputStream (ද්විමය) (<1.7)

FileOutputStream යනු රූප දත්ත වැනි අමු බයිට් වල ධාරාවන් ලිවීම සඳහා ය.

byte data[] = "binary-to-write-to-file".getBytes();
FileOutputStream out = new FileOutputStream("file-name");
out.write(data);
out.close();

මෙම ප්‍රවේශයත් සමඟ වරකට එක බයිට් එකක් ලිවීමට වඩා සෑම විටම බයිට් පෙළක් ලිවීමට සලකා බැලිය යුතුය. වේගවත් කිරීම තරමක් වැදගත් විය හැකිය - 10 x දක්වා හෝ ඊට වැඩි. එබැවින් write(byte[])හැකි සෑම විටම ක්රම භාවිතා කිරීම රෙකමදාරු කරනු ලැබේ .