精华内容
下载资源
问答
  • io流写入文件不覆盖
    2022-05-18 13:43:16

    C# IO流读写文件操作

    1、创建文件流

    2、创建文件读写器

    3、执行读写操作

    4、关闭文件读写器和文件流

    1、创建文件流

    string filePath = AppDomain.CurrentDomain.BaseDirectory + @"..\..\..\TextFile1.txt";//文件相对路径
    string filePath2 = @"D:\file\TextFile2.txt";//文件绝对路径
    FileStream fs =new FileStream( filePath,FileMode.OpenOrCreate,FileAccess.ReadWrite) ;
    

    PS:“\”在C#中表示转译,所以我们在写文件路径是不能直接以这样的形式写(“D:\files”),我们可以在“”号的前面加一个@符号来取消转译,也可以用”\”来代替“\”

    FileMode指定文件的打开方式

    • Create:用指定的名称新建一个文件,如果文件已存在则覆盖原有的文件
    • CreateNew:新建一个文件,如果文件已存在会报异常提示文件已存在
    • Open:打开一个文件,使用这个枚举是文件必须已存在,否则会报异常
    • OpenOrCreate:与Open成员类似,如果文件不存在则用指定的名称新建一个文件并打开它
    • Appen:打开现有文件,并在末尾追加新的内容。

    FileAccess文件的访问权限

    • Read:可从文件读取数据的访问权限
    • Write:可将数据写入文件的访问权限
    • ReadWrite:可从文件读取数据和将数据写入文件的访问权限

    2、创建文件读写器

    创建文件写入器

    //参数一:创建的文件流对象
    //参数二:true表示追加,false表示覆盖
    StreamWriter sw=New StreamWriter(fs,true);
    

    常用方法:

    • sw.Write():用于写入流
    • sw.WriteLine():用于写入一行数据,写入某些数据后跟换行符
    • sw.Close():用于关闭写入器

    创建文件读取器

    StreamReader sr = new StreamReader(fs,Encoding.Default);//fs:文件流对象
    

    常用方法:

    • sr.ReadLIne():读取文件流中的一行数据,并返回字符串
    • sr.ReadToEnd():从当前位置读到末尾,返回字符串
    • sr.Close();用于关闭读取器。

    Encoding指定编码格式防止中文乱码

    • Default表示获取操作系统当前的编码格式
    • UTF-8表示获取UTF-8格式的编码

    3、执行读写操作

    try
    {
        String content = String.Empty;
        while ((content = sr.ReadLine()) != null)//读取文件一每一行数据
        {
            content = content.Trim().ToString();
            sw.WriteLine(content);//一行一行地写入文件二
        }
    }
    catch
    {
        Console.WriteLine("读取内容到文件方法错误");
    }
    

    4、关闭文件读写器和文件流

    1、关闭文件读写器和文件流一定要写在finally里面,无论是否有异常都要关闭

    2、先打开的后关闭,后打开的先关闭,如果a流依赖b流,那么应该先关a流再关b流

    3、当然完全可以只关闭处理流,不用关闭节点流。处理流关闭的时候,会调用其处理的节点流的关闭方法;如果将节点流关闭以后再关闭处理流,会抛出IO异常

    finally
    {
        if (sw != null)//关闭文件写入器
        {
            sw.Close();
        }
        if (sr != null)//关闭文件读取器
        {
            sr.Close();
        }
        if (fs != null)//关闭文件流
        {
            fs.Close();
        }
    }
    
    更多相关内容
  • java写入文件不覆盖写入Java provides several ways to write to file. We can use FileWriter, BufferedWriter, java 7 Files and FileOutputStream to write a file in Java.Java提供了几种写入文件的方法。 我们...

    java写入文件不覆盖写入

    Java provides several ways to write to file. We can use FileWriter, BufferedWriter, java 7 Files and FileOutputStream to write a file in Java.

    Java提供了几种写入文件的方法。 我们可以使用FileWriter , BufferedWriter ,java 7 Files和FileOutputStream用Java编写文件。

    Java写入文件 (Java Write to File)

    Let’s have a brief look at four options we have for java write to file operation.

    让我们简要地看一下java写入文件操作的四个选项。

    FileWriter: FileWriter is the simplest way to write a file in Java. It provides overloaded write method to write int, byte array, and String to the File. You can also write part of the String or byte array using FileWriter. FileWriter writes directly into Files and should be used only when the number of writes is less.

    FileWriter :FileWriter是用Java编写文件的最简单方法。 它提供了重载的write方法,可以将int,字节数组和String写入File。 您也可以使用FileWriter编写String或byte数组的一部分。 FileWriter直接写入文件,仅在写入次数较少时才应使用。

    BufferedWriter: BufferedWriter is almost similar to FileWriter but it uses internal buffer to write data into File. So if the number of write operations is more, the actual IO operations are less and performance is better. You should use BufferedWriter when the number of write operations is more.

    BufferedWriter :BufferedWriter与FileWriter几乎相似,但是它使用内部缓冲区将数据写入File。 因此,如果写入操作的数量更多,则实际的IO操作会更少,而性能会更好。 当写入操作的数量更多时,应使用BufferedWriter。

    FileOutputStream: FileWriter and BufferedWriter are meant to write text to the file but when you need raw stream data to be written into file, you should use FileOutputStream to write file in java.

    FileOutputStream :FileWriter和BufferedWriter旨在将文本写入文件,但是当您需要将原始流数据写入文件时,应使用FileOutputStream在Java中写入文件。

    Files: Java 7 introduced Files utility class and we can write a file using its write function. Internally it’s using OutputStream to write byte array into file.

    Files :Java 7引入了Files实用程序类,我们可以使用其write函数编写文件。 在内部,它使用OutputStream将字节数组写入文件。

    Java写入文件示例 (Java Write to File Example)

    Here is the example showing how we can write a file in java using FileWriter, BufferedWriter, FileOutputStream, and Files in java.

    这是显示如何在Java中使用FileWriter,BufferedWriter,FileOutputStream和Files编写文件的示例。

    WriteFile.java

    WriteFile.java

    package com.journaldev.files;

    import java.io.BufferedWriter;

    import java.io.File;

    import java.io.FileOutputStream;

    import java.io.FileWriter;

    import java.io.IOException;

    import java.io.OutputStream;

    import java.nio.file.Files;

    import java.nio.file.Paths;

    public class WriteFile {

    /**

    * This class shows how to write file in java

    * @param args

    * @throws IOException

    */

    public static void main(String[] args) {

    String data = "I will write this String to File in Java";

    int noOfLines = 10000;

    writeUsingFileWriter(data);

    writeUsingBufferedWriter(data, noOfLines);

    writeUsingFiles(data);

    writeUsingOutputStream(data);

    System.out.println("DONE");

    }

    /**

    * Use Streams when you are dealing with raw data

    * @param data

    */

    private static void writeUsingOutputStream(String data) {

    OutputStream os = null;

    try {

    os = new FileOutputStream(new File("/Users/pankaj/os.txt"));

    os.write(data.getBytes(), 0, data.length());

    } catch (IOException e) {

    e.printStackTrace();

    }finally{

    try {

    os.close();

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    }

    /**

    * Use Files class from Java 1.7 to write files, internally uses OutputStream

    * @param data

    */

    private static void writeUsingFiles(String data) {

    try {

    Files.write(Paths.get("/Users/pankaj/files.txt"), data.getBytes());

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    /**

    * Use BufferedWriter when number of write operations are more

    * It uses internal buffer to reduce real IO operations and saves time

    * @param data

    * @param noOfLines

    */

    private static void writeUsingBufferedWriter(String data, int noOfLines) {

    File file = new File("/Users/pankaj/BufferedWriter.txt");

    FileWriter fr = null;

    BufferedWriter br = null;

    String dataWithNewLine=data+System.getProperty("line.separator");

    try{

    fr = new FileWriter(file);

    br = new BufferedWriter(fr);

    for(int i = noOfLines; i>0; i--){

    br.write(dataWithNewLine);

    }

    } catch (IOException e) {

    e.printStackTrace();

    }finally{

    try {

    br.close();

    fr.close();

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    }

    /**

    * Use FileWriter when number of write operations are less

    * @param data

    */

    private static void writeUsingFileWriter(String data) {

    File file = new File("/Users/pankaj/FileWriter.txt");

    FileWriter fr = null;

    try {

    fr = new FileWriter(file);

    fr.write(data);

    } catch (IOException e) {

    e.printStackTrace();

    }finally{

    //close resources

    try {

    fr.close();

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    }

    }

    These are the standard methods to write a file in java and you should choose any one of these based on your project requirements. That’s all for Java write to file example.

    这些是用Java编写文件的标准方法,您应根据项目要求选择其中一种。 这就是Java写入文件示例的全部内容。

    GitHub Repository. GitHub存储库中签出更多Java IO示例。

    翻译自: https://www.journaldev.com/878/java-write-to-file

    java写入文件不覆盖写入

    展开全文
  • Java是面向对象的程序语言,每一个数据都是一个对象,它们提供了各种支持“读入”与“写入”操作的类。 Java的输入输出功能来自java.io 包中的InputStream类、OutputStream类、Reader类和Writer类以及继承它们的...

    输入输出的重要性:

    输入和输出功能是Java对程序处理数据能力的提高,Java以流的形式处理数据。流是一组有序的数据序列,根据操作的类型,分为输入流和输出流。

    程序从输入流读取数据,向输出流写入数据。Java是面向对象的程序语言,每一个数据流都是一个对象,它们提供了各种支持“读入”与“写入”操作的流类。

    Java的输入输出功能来自java.io 包中的InputStream类、OutputStream类、Reader类和Writer类以及继承它们的各种子类。


    (一)解析文件处理的奥秘

    1、学习使用文件类 : File类

    File类用于封装系统的文件和目录的相关信息。在该类中定义了一些与平台无关的方法来操作文件。例如文件的大小、修改时间、文件路径等。

    创建 File 对象可以通过下面3种方式:

    方法1:方法2:方法3:
    new File(String pathName)File file = new File(“E://1.txt”)new File(String parent , String child)
    parent :父抽象路径名;child:子路径名字符串

    2、如何获取文件信息

    File 类是对文件和文件夹的抽象,包含了对文件和文件夹的多种属性和操作方法。File类的常用方法如下表:

    返回方法说明
    StringgetName获取文件名称
    StringgetParent获取文件的父路径字符串
    StringgetPath获取文件的相对路径字符串
    StringgetAbsolutePath获取文件的绝对路径字符串
    booleanexists判断文件或者文件夹是否存在
    booleanisFile判断是不是文件类型
    booleanisDirectory判断是不是文件夹类型
    booleandelete删除文件或文件夹,如果删除成功返回结果为true
    booleanmkdir创建文件夹,创建成功返回true
    booleansetReadOnly设置文件或文件夹的只读属性
    longlength获取文件的长度
    longlastModified获取文件的最后修改时间
    String[ ]list获取文件夹中的文件和子文件夹的名称,并存放到字符串数组中

    下面通过实例介绍File类获取文件信息

    package com.zch.io;
    
    import java.io.File;
    import java.util.Date;
    
    /**
     * 在src根目录下创建FileInfo类,在该类的主方法中创建文件对象,通过File类的相关方法,获取文件的相关信息
     * 
     */
    public class FileInfo {
    	public static void main(String[] args) {
    
    		String filePath = "src/com/zch/io/FileInfo.java";
    		// 根据指定路径创建文件对象
    		File file = new File(filePath);
    		System.out.println("文件名称:" + file.getName());
    		System.out.println("文件是否存在:" + file.exists());
    		System.out.println("文件的相对路径:" + file.getPath());
    		System.out.println("文件的绝对路径:" + file.getAbsolutePath());
    		System.out.println("是否为可执行文件:" + file.canExecute());
    		System.out.println("文件可以读取:" + file.canRead());
    		System.out.println("文件可以写入:" + file.canWrite());
    		System.out.println("文件上级路径:" + file.getParent());
    		System.out.println("文件大小:" + file.length() + "B");
    		System.out.println("文件最后修改时间:" + new Date(file.lastModified()));
    		System.out.println("是否文件类型:" + file.isFile());
    		System.out.println("是否为文件夹:" + file.isDirectory());
    
    	}
    
    }
    

    运行结果如下:

    文件名称:FileInfo.java
    文件是否存在:true
    文件的相对路径:src\com\zch\io\FileInfo.java
    文件的绝对路径:D:\Java\IO\src\com\zch\io\FileInfo.java
    是否为可执行文件:true
    文件可以读取:true
    文件可以写入:true
    文件上级路径:src\com\zch\io
    文件大小:1195B
    文件最后修改时间:Sat 03 21:30:10 CST 2022
    是否文件类型:true
    是否为文件夹:false
    

    在使用delete()方法删除File对象时,如果删除的对象是目录,该目录中的内容必须为空。


    (二)使用字节输入输出流

    字节流用于处理二进制数据的读取和写入,它以字节为单位,InputStream类和OutputStream类是字节流的抽象类,它们定义了数据流读取和写入的基本方法。各个子类会依其特点实现或覆盖这些方法。


    1、字节数入流抽象类InputStream

    InputStream 类是字节输入流的抽象类,定义了操作输入流的各种方法,这些方法如表:

    返回方法说明
    intavailable()返回当前输入流的数据读取方法可以读取的有效字节数量
    Abstract intread()从当前数据流中读取一个字节。若已达到流结尾,则返回-1
    intread(byte[ ] bytes)从当前输入流读取一定的byte数据,并存取在数组中,然后返回读取的byte数据的数量,若已到达流结尾,则返回-1。
    voidreset()将当前的输入流重新定位到最后一次调用mark()方法时的位置
    voidmark(int readlimit)在当前输入流中做标记位置,当调用reset()方法时将返回到该位置,从标记位置开始,到再读入readlimit个字符为止,这个标记都维持有效。
    BooleanmarkSupported()测试当前输入流是否支持mark()和reset()方法,只要其中一个不支持,则返回false
    longskip(long n)跳过和丢弃当前输入的n个字节数据
    voidclose()关闭当前输入流,并释放任何与之相关联的系统资源

    InputStream 类是抽象类,不能通过new关键字来创建该实例对象,需要其子类创建该实例对象。下面通过实例如何使用InputStream从控制台获取用户输入的数据信息。

    package com.zch.io;
    
    import java.io.IOException;
    import java.io.InputStream;
    
    /**
     * 创建InputStream实例inp,并将其赋值为System类的in属性,定义为控制台输入流,从inp输入流中获取字节信息,
     * 用这些字节信息创建字符串,并将其在控制台上输出。
     */
    public class InputMessage {
    	public static void main(String[] args) {
    		InputStream inp = System.in;
    		
    		byte[] bytes = new byte[1024];
    		
    		try {
    			while(inp.read() != -1){
    				//根据用户输入的信息创建字符串
    				
    				String str = new String(bytes).trim();
    				
    			}
    			inp.close();		//关闭流
    			
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		
    	}
    }
    

    2、字节输出流抽象类OutputStream类

    OutputStream定义了输出流的各种方法,如下表:


    和InputStream类一样,OutputStream 类是抽象类,不能通过new关键字来创建该实例对象,需要其子类创建该实例对象。

    package com.zch.io;
    
    import java.io.IOException;
    import java.io.OutputStream;
    
    /**
     * 创建OutputStream实例out,并将其赋值为System.out标准输出流。通过write()方法向流写入数据。
     */
    public class OutputData {
    	public static void main(String[] args) {
    	OutputStream output = System.out;			//实例化OutputStream对象
    	
    	byte[] bytes = "使用OutputStream输出流在控制台输出字符串\n".getBytes();		//创建bytes数组
    	
    	try {
    		output.write(bytes);
    		
    		bytes = "输出内容:\n".getBytes();
    		output.write(bytes);        //向流中写入数据
    		
    		bytes = "Java数据交互管道——IO流 \n".getBytes();
    		output.write(bytes);
    		
    		output.close();
    		
    	} catch (IOException e) {
    		// TODO Auto-generated catch block
    		e.printStackTrace();
    	}
    	}
    }
    

    输出结果如下:

    使用OutputStream输出流在控制台输出字符串
    输出内容:
       Java数据交互管道——IO流 
    

    3、文件字节输入流类 : FileInputStream类

    文件字节输入流可以从指定路径的文件中读取字节数据。文件字节输入流类继承InputStream类,并实现了读取输入流的各种方法。

    ​ 创建文件字节输入流创建的构造方法语法如下:

    • 语法1:以File对象为参数创建FileInputStream实例
    new FileInputStreamFile file)
    
    • 语法2:以文件对象的绝对路径为参数创建FIleInputStream实例
    new FileInputStreamString filepath)
    

    4、文件字节输出流类:FileOutputStream

    文件字节输出流关联指定文件路径的文件,数据通过文件字节输出流以字节为单位输出并保存到文件中。文件字节输出流继承自OutputStream类,并实现OutputStream类的各种方法。

    文件字节输出流的构造方法语法如下:

    • 语法1:以File对象为参数创建FileOutputStream实例
    new FileOutputStreamFile file)
    
    • 语法2:以文件对象的绝对路径为参数创建FIleOutputStream实例
    new FileOutputStreamString filepath)
    

    下面通过实例介绍文件的写入和读取:

    package com.zch.io;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /**
     * 创建OutputStream实例out,并将其赋值为System.out标准输出流,通过write方法向流中写入数据
     * 
     */
    public class FileCreate {
    	public static void main(String[] args) {
    		File file = new File("D:/", "word.txt");  //创建文件对象
    
    		try {
    			if (!file.exists()) {				//如果文件不存在则新建文件
    				file.createNewFile();			
    
    			}
    			FileOutputStream output = new FileOutputStream(file);
    
    			byte[] bytes = "Java数据交流管道——IO流".getBytes();
    
    			output.write(bytes);				//将数组的信息写入文件中
    
    			output.close();
    
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    
    		try {
    			FileInputStream input = new FileInputStream(file);
    
    			byte[] bytes2 = new byte[1024];
    
    			int len = input.read(bytes2);
    
    			System.out.println("文件中的信息是:" + new String(bytes2, 0, len));
    
    			input.close();
    
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    
    	}
    }
    

    (三) 使用字符输入输出流

    字符输入输出流 与 字节输入输出流有相同的功能,但传送数据的方式不一样,字节流以字节为单位传送数据,可以使任何类型的数据,例如文本、音频、视频、图片等。字符流以字符为单位传送数据,只能传送文本类型的数据。使用字符输入输出流的好处是,当读取中文时不会出现乱码问题,而使用字节输入输出流时,却不能保证这一点。

    1、字符输入流抽象类:Reader类

    该类定义了操作字符输入流的方法,如下表:

    返回方法说明
    booleanready()判断此数据流是否准备好
    intread()读入一个字符,若已读到流结尾,则返回值为-1
    intread(char[ ])读取一些字符到char[ ]数组内,并返回所读入的字符的数量,若已到达流结尾,则返回-1
    Abscract intread(char[ ] chars,int off,int len)读取一些字符到char[ ]数组下标从off开始到off+len的位置,并返回所读入的字符的数量,若已到达流结尾,则返回-1;
    voidreset()将当前输入流重新定位到最后一次mark()方法时的位置
    voidmark(int readLimit)将当前输入流中做标记,当调用reset方法时将返回到该位置,从标记位置开始,到再读入readLimit个字符为止,这个标记都维持有效
    booleanmarkSupported测试当前输入流是否支持mark()方法和reset()方法。只要有一个方法不支持,则返回-1
    longskip(long n)跳过参数n指定的字符数量,并返回所跳过字符的数量
    Abstract voidclose()关闭字符输入流,并释放与之关联的所有资源

    2、字符输出流类Writer类

    ​ Writer 类主要是用于解决字符输入流的类,其地位与Reader类在输入流的地位和作用是相同的,也是所有字符输出流的流类。

    Writer类的主要方法如下:

    返回方法说明
    voidwrite(char[ ] cbuf)将字符数组的数据写入字符输出流
    Abstract voidwrite(char[ ] cbuf int off ,int len)将字符数组从下标off 开始向输入流写入长度为len的数据
    voidwrite(int c )向字符输入流中写入一个字符数据
    voidwrite(String str )向输入流中写入一个字符串数据
    voidwrite(String str , int off ,int len)向输入流中写入一个字符串从off 开始长度为len的数据
    Abstract voidflush()刷新当前输出流,并强制写入所有缓冲区的字节数据
    voidclose()向输出流中写入缓冲区的数据,然后关闭当前输出流,释放所有与当前输出流相关联的系统资源

    3、文件字符输入流FileReader

    ​ 文件字符输入流与文件字节输入流的功能相似,但是传送数据的方式不一样,字节流以字节为单位传送数据,可以使文本、视频、音频、图片等。字符流以字符为单位传送数据,只能传送文本类型的数据。

    创建字符输入流常用的构造方法:

    • 语法1:
    new FileReaderFile file);
    
    • 语法2:
    new FileReader(String path);
    

    下面通过实例介绍FileReader类读取指定磁盘文件的内容。

    package com.zch.io;
    
    import java.io.File;
    import java.io.FileReader;
    
    public class FileInAndOut {
    	public static void main(String[] args) {
    		//定义指定磁盘的文件的File对象
    		File file = new File("D://word.txt");
    		
    		if(! file.exists()){
    			System.out.println("对不起,不包含指定路径的文件");
    		}else{
    			//根据指定路径的File对象创建FileReader对象
    			try {
    				FileReader fr = new FileReader(file);
    				
    				char[] data = new char[23];			//定义char数组
    				
    				int length = 0;
    				
    				while((length = fr.read(data))>0){			//循环读取文件中的数据
    					String str = new String(data,0,length);			//根据读取文件的内容创建String 对象
    					System.out.println(str);				//输出读取内容
    				}
    				fr.close();								//关闭流
    				
    				
    				
    			} catch (Exception e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    			
    		}
    	}
    }
    

    运行结果如下图:

    这里写图片描述
    这里写图片描述


    4、文件字符输出流FileWriter

    ​ 文件字符输出流继承自Writer类,提供了向文件输出的各种方法,数据通过文件字符输出流以字符为单位输出并保存到文件中。

    package com.zch.io;
    /**
     * 通过给定的String类型参数的指定文件名称与路径,创建FileWriter类。
     */
    import java.io.File;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    
    public class FileWriterDemo {
    	public static void main(String[] args) {
    		File file = new File("D://word2.txt");		//创建指定文件
    		
    		try {
    		if(! file.exists()){
    				file.createNewFile();				//如果指定文件不存在,新建文件
    			
    		}
    		
    		FileReader fr = new FileReader("D://word.txt");
    		
    		FileWriter fw = new FileWriter(file);				//创建FileWriter对象
    		
    		int length = 0;
    		while((length = fr.read()) != -1){			//如果没有读到文件末尾
    			fw.write(length);			//向文件写入数据
    			
    		}
    		fr.close();							//关闭流
    		fw.close();
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    }
    

    运行后创建了Word2.txt 文件,并向其中写入数据
    这里写图片描述


    (四)IO流实战:

    1、Java IO流实现复制文件夹

    ​ 通过IO不仅可以复制文件,还可以复制文件夹,但是文件夹内,可能包含其他文件夹,因此需要对他们进行分别复制。

    package com.zch.io;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    
    public class CopyFile {
    	public static void main(String[] args) {
    		File sourceFile = null;
    		File desFile = null;
    
    		String sourceFolder = "D://简历2";
    		String copyFolder = "D://copy";
    
    		sourceFile = new File(sourceFolder);
    
    		if (!sourceFile.isDirectory() || !sourceFile.exists()) {
    			System.out.println("源文件夹不存在!");
    		} else {
    			desFile = new File(copyFolder);
    			desFile.mkdir();
    
    			copy(sourceFile.listFiles(), desFile);
    			System.out.println("文件夹复制成功!");
    		}
    	}
    /**
     * 创建copy方法,该方法接收文件数组和目标文件夹两个参数,如果目标文件夹不存在,则调用mkdir()方法创建文件夹,然后再循环中将文件数组
     * 中的每个文件对象写到目标文件夹内。
     * @param fl
     * @param file
     */
    	public static void copy(File[] fl, File file) {
    		if (!file.exists()) { // 如果文件夹不存在
    			file.mkdir(); // 建立新的文件夹
    		}
    
    		for (int i = 0; i < fl.length; i++) {
    			if (fl[i].isFile()) { // 如果是文件类型,则复制文件
    				try {
    					FileInputStream fis = new FileInputStream(fl[i]);
    					FileOutputStream out = new FileOutputStream(new File(
    							file.getPath() + File.separator + fl[i].getName()));
    
    					int count = fis.available();
    					byte[] data = new byte[count];
    
    					if ((fis.read(data)) != -1) {
    						out.write(data);
    					}
    				} catch (Exception e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    
    			if (fl[i].isDirectory()) { // 如果是文件夹类型
    				File des = new File(file.getPath() + File.separator
    						+ fl[i].getName());
    				des.mkdir(); // 在目标文件夹中创建相同的文件夹
    				copy(fl[i].listFiles(), des); // 递归调用方法本身
    			}
    
    		}
    
    	}
    }
    

    运行本实例,会将D盘中的简历文件中的内容复制到D盘的copy文件夹中,而且包含文件夹的子文件夹


    2、Java IO流实现分行向文件中写入数据

    FileWriter类可以向文件写入字符数据,如果将FileWriter类封装到BufferWriter类的缓冲字符流中,能够实现缓冲字符输出流,并且可以通过读输出流的newLine()方法,来实现数据的分行写入。

    package com.zch.io;
    
    import java.io.BufferedWriter;
    import java.io.File;
    import java.io.FileWriter;
    import java.io.IOException;
    
    /**
     * 创建BranchWriter类,在主方法中定义文件对象,将该对象作为参数创建BufferedWriter类实例,
     * 调用该实例的writer方法将数据写入文件中,然后 调用newLine()方法写入换行符,实现分行向文件写入数据。
     * 
     */
    public class BranchWriter {
    	public static void main(String[] args) {
    		String filePath = "D://BranchWriter.txt";
    
    		File file = new File(filePath);
    
    		try {
    			if (!file.exists()) {
    				file.createNewFile();
    			}
    			FileWriter fw = new FileWriter(file); // 创建文件输出流
    
    			BufferedWriter bw = new BufferedWriter(fw); // 使用缓冲区数据流封装输出流
    			for (int i = 0; i < 100; i++) {				//循环写入100行数据
    				
    				bw.write("Java交互管道——IO流".toCharArray());// 写入数据到输出流
    				
    				bw.newLine(); // 写入换行符
    				
    				bw.flush(); // 刷新缓冲区
    			}
    
    			System.out.println("成功写入数据!");
    
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    }
    

    3、删除指定文件

    ​ File类的delete()方法可以实现删除指定的文件,首先使用目标文件路径创建File类的实例对象,然后再调用File类的delete()方法。

    package com.zch.io;
    
    import java.io.File;
    
    public class FileDelete {
    
    	public static void main(String[] args) {
    		String filePath = "D://word.txt";
    
    		File file = new File(filePath);
    		delFile(file);
    	}
    
    	public static void delFile(File file) {
    		if (!file.exists()) {
    			System.out.println("文件不存在!");
    			return;
    		}
    		boolean rs = file.delete();
    		if (rs) {
    			System.out.println("文件删除成功!");
    		} else {
    			System.out.println("文件删除失败!");
    		}
    	}
    }
    
    展开全文
  • Java实现文件写入——IO流

    千次阅读 2021-02-12 14:52:34
    程序从输入读取数据,向输出流写入数据。Java是面向对象的程序语言,每一个数据都是一个对象,它们提供了各种支持“读入”与“写入”操作的类。Java的输入输出功能来自java.io 包中的InputStream类、...

    输入输出的重要性:

    输入和输出功能是Java对程序处理数据能力的提高,Java以流的形式处理数据。流是一组有序的数据序列,根据操作的类型,分为输入流和输出流。

    程序从输入流读取数据,向输出流写入数据。Java是面向对象的程序语言,每一个数据流都是一个对象,它们提供了各种支持“读入”与“写入”操作的流类。

    Java的输入输出功能来自java.io 包中的InputStream类、OutputStream类、Reader类和Writer类以及继承它们的各种子类。

    (一)解析文件处理的奥秘

    1、学习使用文件类 : File类

    File类用于封装系统的文件和目录的相关信息。在该类中定义了一些与平台无关的方法来操作文件。例如文件的大小、修改时间、文件路径等。

    创建 File 对象可以通过下面3种方式:

    方法1:方法2:方法3:

    new File(String pathName)

    File file = new File(“E://1.txt”)

    new File(String parent , String child)

    parent :父抽象路径名;child:子路径名字符串

    2、如何获取文件信息

    File 类是对文件和文件夹的抽象,包含了对文件和文件夹的多种属性和操作方法。File类的常用方法如下表:

    返回方法说明

    String

    getName

    获取文件名称

    String

    getParent

    获取文件的父路径字符串

    String

    getPath

    获取文件的相对路径字符串

    String

    getAbsolutePath

    获取文件的绝对路径字符串

    boolean

    exists

    判断文件或者文件夹是否存在

    boolean

    isFile

    判断是不是文件类型

    boolean

    isDirectory

    判断是不是文件夹类型

    boolean

    delete

    删除文件或文件夹,如果删除成功返回结果为true

    boolean

    mkdir

    创建文件夹,创建成功返回true

    boolean

    setReadOnly

    设置文件或文件夹的只读属性

    long

    length

    获取文件的长度

    long

    lastModified

    获取文件的最后修改时间

    String[ ]

    list

    获取文件夹中的文件和子文件夹的名称,并存放到字符串数组中

    下面通过实例介绍File类获取文件信息

    1 packagecom.zch.io;2

    3 importjava.io.File;4 importjava.util.Date;5

    6 /**

    7 * 在src根目录下创建FileInfo类,在该类的主方法中创建文件对象,通过File类的相关方法,获取文件的相关信息8 *9 *@authorzch10 *11 */

    12 public classFileInfo {13 public static voidmain(String[] args) {14

    15 String filePath = "src/com/zch/io/FileInfo.java";16 //根据指定路径创建文件对象

    17 File file = newFile(filePath);18 System.out.println("文件名称:" +file.getName());19 System.out.println("文件是否存在:" +file.exists());20 System.out.println("文件的相对路径:" +file.getPath());21 System.out.println("文件的绝对路径:" +file.getAbsolutePath());22 System.out.println("是否为可执行文件:" +file.canExecute());23 System.out.println("文件可以读取:" +file.canRead());24 System.out.println("文件可以写入:" +file.canWrite());25 System.out.println("文件上级路径:" +file.getParent());26 System.out.println("文件大小:" + file.length() + "B");27 System.out.println("文件最后修改时间:" + newDate(file.lastModified()));28 System.out.println("是否文件类型:" +file.isFile());29 System.out.println("是否为文件夹:" +file.isDirectory());30

    31 }32

    33 }

    运行结果如下:

    文件名称:FileInfo.java

    文件是否存在:true

    文件的相对路径:src\com\zch\io\FileInfo.java

    文件的绝对路径:D:\Java\IO\src\com\zch\io\FileInfo.java

    是否为可执行文件:true

    文件可以读取:true

    文件可以写入:true

    文件上级路径:src\com\zch\io

    文件大小:1195B

    文件最后修改时间:Sat Sep 09 21:30:10 CST 2017

    是否文件类型:true

    是否为文件夹:false

    在使用delete()方法删除File对象时,如果删除的对象是目录,该目录中的内容必须为空。

    (二)使用字节输入输出流

    字节流用于处理二进制数据的读取和写入,它以字节为单位,InputStream类和OutputStream类是字节流的抽象类,它们定义了数据流读取和写入的基本方法。各个子类会依其特点实现或覆盖这些方法。

    1、字节数入流抽象类InputStream

    InputStream 类是字节输入流的抽象类,定义了操作输入流的各种方法,这些方法如表:

    返回方法说明

    int

    available()

    返回当前输入流的数据读取方法可以读取的有效字节数量

    Abstract int

    read()

    从当前数据流中读取一个字节。若已达到流结尾,则返回-1

    int

    read(byte[ ] bytes)

    从当前输入流读取一定的byte数据,并存取在数组中,然后返回读取的byte数据的数量,若已到达流结尾,则返回-1。

    void

    reset()

    将当前的输入流重新定位到最后一次调用mark()方法时的位置

    void

    mark(int readlimit)

    在当前输入流中做标记位置,当调用reset()方法时将返回到该位置,从标记位置开始,到再读入readlimit个字符为止,这个标记都维持有效。

    Boolean

    markSupported()

    测试当前输入流是否支持mark()和reset()方法,只要其中一个不支持,则返回false

    long

    skip(long n)

    跳过和丢弃当前输入的n个字节数据

    void

    close()

    关闭当前输入流,并释放任何与之相关联的系统资源

    InputStream 类是抽象类,不能通过new关键字来创建该实例对象,需要其子类创建该实例对象。下面通过实例如何使用InputStream从控制台获取用户输入的数据信息。

    1 packagecom.zch.io;2

    3 importjava.io.IOException;4 importjava.io.InputStream;5

    6 /**

    7 * 创建InputStream实例inp,并将其赋值为System类的in属性,定义为控制台输入流,从inp输入流中获取字节信息,8 * 用这些字节信息创建字符串,并将其在控制台上输出。9 *@authorzch10 *11 */

    12 public classInputMessage {13 public static voidmain(String[] args) {14 InputStream inp =System.in;15

    16 byte[] bytes = new byte[1024];17

    18 try{19 while(inp.read() != -1){20 //根据用户输入的信息创建字符串

    21

    22 String str = newString(bytes).trim();23

    24 }25 inp.close(); //关闭流

    26

    27 } catch(IOException e) {28 //TODO Auto-generated catch block

    29 e.printStackTrace();30 }31

    32 }33 }34

    2、字节输出流抽象类OutputStream类

    OutputStream定义了输出流的各种方法,如下表:

    返回方法说明

    void

    write(byte[ ] b)

    将byte[ ] 数组中的数据写入当前输出流

    void

    write(byte[] b ,int off, int len)

    将byte[ ]数组下标off开始的len长度的数据写入当前输出流

    Abstract void

    write(int b)

    写入一个byte数据到当前输出流

    void

    flush()

    刷新当前输出流,并强制写入所有缓冲的字节数据

    void

    close()

    关闭当前输出流

    和InputStream类一样,OutputStream 类是抽象类,不能通过new关键字来创建该实例对象,需要其子类创建该实例对象。

    packagecom.zch.io;importjava.io.IOException;importjava.io.OutputStream;/*** 创建OutputStream实例out,并将其赋值为System.out标准输出流。通过write()方法向流写入数据。

    *@authorzch

    **/

    public classOutputData {public static voidmain(String[] args) {

    OutputStream output= System.out; //实例化OutputStream对象

    byte[] bytes = "使用OutputStream输出流在控制台输出字符串\n".getBytes(); //创建bytes数组

    try{

    output.write(bytes);

    bytes= "输出内容:\n".getBytes();

    output.write(bytes);//向流中写入数据

    bytes= "Java数据交互管道——IO流 \n".getBytes();

    output.write(bytes);

    output.close();

    }catch(IOException e) {//TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    }

    输出结果如下:

    使用OutputStream输出流在控制台输出字符串

    输出内容:

    Java数据交互管道——IO流

    3、文件字节输入流类 : FileInputStream类

    文件字节输入流可以从指定路径的文件中读取字节数据。文件字节输入流类继承InputStream类,并实现了读取输入流的各种方法。

    创建文件字节输入流创建的构造方法语法如下:

    语法1:以File对象为参数创建FileInputStream实例

    new FileInputStream(File file)

    语法2:以文件对象的绝对路径为参数创建FIleInputStream实例

    new FileInputStream(String filepath)

    4、文件字节输出流类:FileOutputStream

    文件字节输出流关联指定文件路径的文件,数据通过文件字节输出流以字节为单位输出并保存到文件中。文件字节输出流继承自OutputStream类,并实现OutputStream类的各种方法。

    文件字节输出流的构造方法语法如下:

    语法1:以File对象为参数创建FileOutputStream实例

    new FileOutputStream(File file)

    语法2:以文件对象的绝对路径为参数创建FIleOutputStream实例

    new FileOutputStream(String filepath)

    下面通过实例介绍文件的写入和读取:

    package com.zch.io;

    import java.io.File;

    import java.io.FileInputStream;

    import java.io.FileOutputStream;

    import java.io.IOException;

    /**

    * 创建OutputStream实例out,并将其赋值为System.out标准输出流,通过write方法向流中写入数据

    *

    * @author zch

    *

    */

    public class FileCreate {

    public static void main(String[] args) {

    File file = new File("D:/", "word.txt"); //创建文件对象

    try {

    if (!file.exists()) {//如果文件不存在则新建文件

    file.createNewFile();

    }

    FileOutputStream output = new FileOutputStream(file);

    byte[] bytes = "Java数据交流管道——IO流".getBytes();

    output.write(bytes);//将数组的信息写入文件中

    output.close();

    } catch (IOException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    try {

    FileInputStream input = new FileInputStream(file);

    byte[] bytes2 = new byte[1024];

    int len = input.read(bytes2);

    System.out.println("文件中的信息是:" + new String(bytes2, 0, len));

    input.close();

    } catch (Exception e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    }

    (三) 使用字符输入输出流

    字符输入输出流 与 字节输入输出流有相同的功能,但传送数据的方式不一样,字节流以字节为单位传送数据,可以使任何类型的数据,例如文本、音频、视频、图片等。字符流以字符为单位传送数据,只能传送文本类型的数据。使用字符输入输出流的好处是,当读取中文时不会出现乱码问题,而使用字节输入输出流时,却不能保证这一点。

    1、字符输入流抽象类:Reader类

    该类定义了操作字符输入流的方法,如下表:

    返回方法说明

    boolean

    ready()

    判断此数据流是否准备好

    int

    read()

    读入一个字符,若已读到流结尾,则返回值为-1

    int

    read(char[ ])

    读取一些字符到char[ ]数组内,并返回所读入的字符的数量,若已到达流结尾,则返回-1

    Abscract int

    read(char[ ] chars,int off,int len)

    读取一些字符到char[ ]数组下标从off开始到off+len的位置,并返回所读入的字符的数量,若已到达流结尾,则返回-1;

    void

    reset()

    将当前输入流重新定位到最后一次mark()方法时的位置

    void

    mark(int readLimit)

    将当前输入流中做标记,当调用reset方法时将返回到该位置,从标记位置开始,到再读入readLimit个字符为止,这个标记都维持有效

    boolean

    markSupported

    测试当前输入流是否支持mark()方法和reset()方法。只要有一个方法不支持,则返回-1

    long

    skip(long n)

    跳过参数n指定的字符数量,并返回所跳过字符的数量

    Abstract void

    close()

    关闭字符输入流,并释放与之关联的所有资源

    2、字符输出流类Writer类

    Writer 类主要是用于解决字符输入流的类,其地位与Reader类在输入流的地位和作用是相同的,也是所有字符输出流的流类。

    Writer类的主要方法如下:

    返回

    方法

    说明

    void

    write(char[ ] cbuf)

    将字符数组的数据写入字符输出流

    Abstract void

    write(char[ ] cbuf int off ,int len)

    将字符数组从下标off 开始向输入流写入长度为len的数据

    void

    write(int c )

    向字符输入流中写入一个字符数据

    void

    write(String str )

    向输入流中写入一个字符串数据

    void

    write(String str , int off ,int len)

    向输入流中写入一个字符串从off 开始长度为len的数据

    Abstract void

    flush()

    刷新当前输出流,并强制写入所有缓冲区的字节数据

    void

    close()

    向输出流中写入缓冲区的数据,然后关闭当前输出流,释放所有与当前输出流相关联的系统资源

    3、文件字符输入流FileReader

    文件字符输入流与文件字节输入流的功能相似,但是传送数据的方式不一样,字节流以字节为单位传送数据,可以使文本、视频、音频、图片等。字符流以字符为单位传送数据,只能传送文本类型的数据。

    创建字符输入流常用的构造方法:

    语法1:

    new FileReader(File file);

    语法2:

    new FileReader(String path);

    下面通过实例介绍FileReader类读取指定磁盘文件的内容。

    package com.zch.io;

    import java.io.File;

    import java.io.FileReader;

    public class FileInAndOut {

    public static void main(String[] args) {

    //定义指定磁盘的文件的File对象

    File file = new File("D://word.txt");

    if(! file.exists()){

    System.out.println("对不起,不包含指定路径的文件");

    }else{

    //根据指定路径的File对象创建FileReader对象

    try {

    FileReader fr = new FileReader(file);

    char[] data = new char[23];//定义char数组

    int length = 0;

    while((length = fr.read(data))>0){//循环读取文件中的数据

    String str = new String(data,0,length);//根据读取文件的内容创建String 对象

    System.out.println(str);//输出读取内容

    }

    fr.close();//关闭流

    } catch (Exception e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    }

    }

    运行结果如下图:

    901ed501932e19b9eb571e5d8285d1cf.png

    9816a55aacc4ae52d52b69b7511e5421.png

    4、文件字符输出流FileWriter

    文件字符输出流继承自Writer类,提供了向文件输出的各种方法,数据通过文件字符输出流以字符为单位输出并保存到文件中。

    package com.zch.io;

    /**

    * 通过给定的String类型参数的指定文件名称与路径,创建FileWriter类。

    *

    * @author zch

    */

    import java.io.File;

    import java.io.FileReader;

    import java.io.FileWriter;

    import java.io.IOException;

    public class FileWriterDemo {

    public static void main(String[] args) {

    File file = new File("D://word2.txt");//创建指定文件

    try {

    if(! file.exists()){

    file.createNewFile();//如果指定文件不存在,新建文件

    }

    FileReader fr = new FileReader("D://word.txt");

    FileWriter fw = new FileWriter(file);//创建FileWriter对象

    int length = 0;

    while((length = fr.read()) != -1){//如果没有读到文件末尾

    fw.write(length);//向文件写入数据

    }

    fr.close();//关闭流

    fw.close();

    } catch (IOException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    }

    运行后创建了Word2.txt 文件,并向其中写入数据

    2b43bf976219b78e70ca1b1e0a479abd.png

    (四)IO流实战:

    1、Java IO流实现复制文件夹

    通过IO不仅可以复制文件,还可以复制文件夹,但是文件夹内,可能包含其他文件夹,因此需要对他们进行分别复制。

    1 packagecom.zch.io;2

    3 importjava.io.File;4 importjava.io.FileInputStream;5 importjava.io.FileOutputStream;6

    7 public classCopyFile {8 public static voidmain(String[] args) {9 File sourceFile = null;10 File desFile = null;11

    12 String sourceFolder = "D://简历2";13 String copyFolder = "D://copy";14

    15 sourceFile = newFile(sourceFolder);16

    17 if (!sourceFile.isDirectory() || !sourceFile.exists()) {18 System.out.println("源文件夹不存在!");19 } else{20 desFile = newFile(copyFolder);21 desFile.mkdir();22

    23 copy(sourceFile.listFiles(), desFile);24 System.out.println("文件夹复制成功!");25 }26 }27 /**

    28 * 创建copy方法,该方法接收文件数组和目标文件夹两个参数,如果目标文件夹不存在,则调用mkdir()方法创建文件夹,然后再循环中将文件数组29 * 中的每个文件对象写到目标文件夹内。30 *@paramfl31 *@paramfile32 */

    33 public static voidcopy(File[] fl, File file) {34 if (!file.exists()) { //如果文件夹不存在

    35 file.mkdir(); //建立新的文件夹

    36 }37

    38 for (int i = 0; i < fl.length; i++) {39 if (fl[i].isFile()) { //如果是文件类型,则复制文件

    40 try{41 FileInputStream fis = newFileInputStream(fl[i]);42 FileOutputStream out = new FileOutputStream(newFile(43 file.getPath() + File.separator +fl[i].getName()));44

    45 int count =fis.available();46 byte[] data = new byte[count];47

    48 if ((fis.read(data)) != -1) {49 out.write(data);50 }51 } catch(Exception e) {52 //TODO Auto-generated catch block

    53 e.printStackTrace();54 }55 }56

    57 if (fl[i].isDirectory()) { //如果是文件夹类型

    58 File des = new File(file.getPath() +File.separator59 +fl[i].getName());60 des.mkdir(); //在目标文件夹中创建相同的文件夹

    61 copy(fl[i].listFiles(), des); //递归调用方法本身

    62 }63

    64 }65

    66 }67 }

    运行本实例,会将D盘中的简历文件中的内容复制到D盘的copy文件夹中,而且包含文件夹的子文件夹

    2、Java IO流实现分行向文件中写入数据

    FileWriter类可以向文件写入字符数据,如果将FileWriter类封装到BufferWriter类的缓冲字符流中,能够实现缓冲字符输出流,并且可以通过读输出流的newLine()方法,来实现数据的分行写入。

    1 packagecom.zch.io;2

    3 importjava.io.BufferedWriter;4 importjava.io.File;5 importjava.io.FileWriter;6 importjava.io.IOException;7

    8 /**

    9 * 创建BranchWriter类,在主方法中定义文件对象,将该对象作为参数创建BufferedWriter类实例,10 * 调用该实例的writer方法将数据写入文件中,然后 调用newLine()方法写入换行符,实现分行向文件写入数据。11 *12 *@authorzch13 *14 */

    15 public classBranchWriter {16 public static voidmain(String[] args) {17 String filePath = "D://BranchWriter.txt";18

    19 File file = newFile(filePath);20

    21 try{22 if (!file.exists()) {23 file.createNewFile();24 }25 FileWriter fw = new FileWriter(file); //创建文件输出流

    26

    27 BufferedWriter bw = new BufferedWriter(fw); //使用缓冲区数据流封装输出流

    28 for (int i = 0; i < 100; i++) { //循环写入100行数据

    29

    30 bw.write("Java交互管道——IO流".toCharArray());//写入数据到输出流

    31

    32 bw.newLine(); //写入换行符

    33

    34 bw.flush(); //刷新缓冲区

    35 }36

    37 System.out.println("成功写入数据!");38

    39 } catch(IOException e) {40 //TODO Auto-generated catch block

    41 e.printStackTrace();42 }43 }44 }

    3、删除指定文件

    File类的delete()方法可以实现删除指定的文件,首先使用目标文件路径创建File类的实例对象,然后再调用File类的delete()方法。

    package com.zch.io;

    import java.io.File;

    public class FileDelete {

    public static void main(String[] args) {

    String filePath = "D://word.txt";

    File file = new File(filePath);

    delFile(file);

    }

    public static void delFile(File file) {

    if (!file.exists()) {

    System.out.println("文件不存在!");

    return;

    }

    boolean rs = file.delete();

    if (rs) {

    System.out.println("文件删除成功!");

    } else {

    System.out.println("文件删除失败!");

    }

    }

    }

    ————————————————

    版权声明:本文为CSDN博主「Christopher Cheung」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。

    原文链接:https://blog.csdn.net/zch19960629/java/article/details/77917739

    展开全文
  • IO 写入文件内容追加与覆盖

    千次阅读 2019-08-08 09:39:31
    IO 写入文件内容追加与覆盖 File file = new File(path); if (!file.exists()) { file.mkdirs(); } OutputStreamWriter out = null; try { out = new OutputStreamWriter(new FileOutpu...
  • IO流 文件得读取与写入

    千次阅读 2019-03-27 23:34:35
    IO输入输出 ...Out:把自己的东西写入文件里边去。 Reader:把东西读出来; Witer:把东西写进去。 字节 (FileInputStream) 字节输入:读入文件到内存中进行使用,是先到磁盘里去把文件读入到内存中...
  • 下面用**setOut重定向System.out.print输出地址:**的例子来演示如何不覆盖写入 import java.io.*; public class SysteminReader { public static void main(String[] args) throws Exception { //System.out....
  • 基于C++的IO流文件读入和写入(详细综合版) 大多数情况下都需要对txt进行操作,目前IO流都比较简单,以下对IO进行详细综合介绍,基于C++语言。 1.综合介绍 (1) 头文件fstream #include (2)常用函数以及用法 ...
  • 程序从输入读取数据,向输出流写入数据。Java是面向对象的程序语言,每一个数据都是一个对象,它们提供了各种支持“读入”与“写入”操作的类。Java的输入输出功能来自java.io 包中的InputStream类、...
  • 第1关:学习-Java输入输出之文件字符IO流文件内容加密 任务描述 相关知识 FileReader (文件字符输入) FileReader 的方法 FileWriter (文件字符输出) FileWriter 构造方法 FileWriter 的...
  • 输入文件到内存,ir 读入】input read 输出【内存到文件 ow 写出】out write 文件:相关记录的数据放在一起的集合 文件存储位置:内存,光盘硬盘 访问方法:java.io, 2.创建文件对象 File f=new File(“文档名...
  • 这几天学io,总发现一个问题,如果对一个已经存在的文件源用输出对其再进行写的操作时,会覆盖掉原有文件的内容,而这里用a.txt举例,a.txt是已经存在的一个文件,并且里面有内容↓ 此时我们不管是使用字节...
  • C#io流操作

    2022-06-23 21:13:43
    IO流基础操作 1.创建文件流 2.创建读写器 3.执行读写操作 4.关闭读写器与文件流
  • 写入文件覆盖文件的内容)

    千次阅读 2018-10-08 21:59:00
    function saveEltValuestoFile(that,signleList){ //eltid是用来给文件命名的关键字 plus.io.requestFileSystem(plus.io.PUBLIC_DOCUMENTS, function(fs){ //fs.root 是根目录操作对象 fs.root.getFile...
  • package copyfile;import java.io.*;public class copy {public static void main(String[] args) throws IOException {copyFile("d:/new/a.txt","d:/new/b....//oldpath,newpath,是否不覆盖前文}public static voi...
  • 第1关:学习-Java输入输出之文件字节IO流之拆分文件 任务描述 相关知识 FileInputStream (文件字节输入) FileInputStream 的方法 FileOutputStream (文件字节输出) FileOutputStream 的构造方法...
  • Java IO流之拷贝(复制)文件

    万次阅读 2016-10-17 09:31:58
    在android中使用最多的就是ListView,GridView,用到这两个控件那么肯定要用到适配器,那就是定义一个类继承BaseAdapter,让后覆写它里面的getCount...主布局文件:activity_main.xml<?xml version="1.0" encoding="utf-
  • Java读写IO流详解

    2021-11-21 20:35:11
    一、IO流要明确的几点 (1)明确要操作的数据是数据源还是数据目的(是读还是写) 源/读 InputStream Reader 目的/写 OutputStream Writer (2)明确操作设备上的数据是字节还是文本 源/读 字节:...
  • 输入:只能读取数据,写入数据。 输出:只能写入数据,能读取数据。 因为程序是运行在内存中,以内存角度来理解输入输出概念,如下: 按照处理的数据单位分为字节和字符 字节:操作的数据单元是8...
  • python中文件循环写入不覆盖方法

    万次阅读 2019-04-03 17:23:36
    问题描述: 今天在做python爬虫练习时爬取完毕后需要将爬取到的内容写入文档中,发现每次只能...百度了一下发现要循环写入不覆盖需要用‘a’写入方法,我原来用的‘w’所以被覆盖了 filename = 'allserver.txt' ...
  • io流写入数据通过new FileWriter("myfile\\b.txt",false)第二参数传入false就可以在每次写入覆盖原有内容吗,答案否定的! public class MyBufferTest1 { public static void main(String[] args) throws ...
  • java写入文件覆盖和续写)

    万次阅读 2018-12-07 15:04:25
    1、写入文件 覆盖 @Override public boolean addFile(String string,String path) { PrintStream stream=null; try { stream=new PrintStream(path);//写入的文件path stream.print(string);//写入的字符串...
  • 小师妹学JavaIO之:文件写入那些事

    千次阅读 2020-05-25 06:38:23
    字符输出和字节输出 小师妹:F师兄,上次你的IO讲到了一半,文件读取是基本上讲完了,但是文件写入还没有讲,什么时候给小师妹我再科普科普? 小师妹:F师兄,你知道我这个人一直以来都是勤奋好学的典范,是老师...
  • Java.IO 字符读写文件

    千次阅读 2020-08-17 08:30:00
    点击上方IT牧场,选择置顶或者星标技术干货每日送达!一、序上一篇我们谈了 java.IO 文件字节读写操作(能懂系列Java.io文件字节读写)大家应该都很熟悉了。但是中文和英...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 97,032
精华内容 38,812
热门标签
关键字:

io流写入文件不覆盖