Java_IO流(二十四)——转换流(字符流与字节流的转换)、缓冲流(字节、字符缓冲流)、流的操作规律

目录

第一章 转换流

1.1OutputStreamWriter类

1.2 InputStreamReader类

1.3 转换流和子类区别

第二章 缓冲流

2.1 字节缓冲流

2.1.1 字节缓冲输出流BufferedOutputStream

2.1.2 字节缓冲输入流 BufferedInputStream

2.1.3 使用基本的流与高效的流完成复制文件

2.2 字符缓冲流

2.2.1  字符缓冲输出流 BufferedWriter

2.2.2 字符缓冲输入流 BufferedReader

2.2.3 使用字符缓冲流完成文本文件的复制

第三章 流的操作规律

第四章 总结


第一章 转换流

1.1OutputStreamWriter类

OutputStreamWriter 是字符流通向字节流的桥梁可使用指定的字符编码表,将要写入流中的字符编码成字节。

它的作用的就是,将字符串按照指定的编码表转成字节,在使用字节流将这些字节写出去。

OutputStreamWriter流对象,它到底如何把字符转成字节输出的呢?

其实在OutputStreamWriter流中维护着自己的缓冲区,当调用OutputStreamWriter对象的write方法时,会拿着字符到指定的码表中进行查询把查到的字符编码值转成字节数,存放到OutputStreamWriter缓冲区中。然后再调用刷新功能,或者关闭流,或者缓冲区存满后会把缓冲区中的字节数据使用字节流写到指定的文件中。

过程分析图: 

 

 一个中文在GBK中占两个字节,在UTF-8中占三个字节

package day24.demo1;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

/*
 *  转换流
 *    java.io.OutputStreamWriter 继承Writer类
 *    就是一个字符输出流,写文本文件
 *    write()字符,字符数组,字符串
 *    
 *    字符通向字节的桥梁,将字符流转字节流
 *    
 *    OutputStreamWriter 使用方式
 *     构造方法:
 *       OutputStreamWriter(OuputStream out)接收所有的字节输出流
 *       但是: 字节输出流:  FileOutputStream
 *       
 *      OutputStreamWriter(OutputStream out, String charsetName)
 *      String charsetName 传递编码表名字 GBK  UTF-8 
 *      
 *      OutputStreamWriter 有个子类,  FileWriter
 */
public class OutputStreamWriterDemo {
	public static void main(String[] args)throws IOException {
		writeGBK();
		writeUTF();
	}
	/*
	 * 转换流对象OutputStreamWriter写文本
	 * 采用UTF-8编码表写入
	 */
	public static void writeUTF()throws IOException{
		//创建字节输出流,绑定文件
		FileOutputStream fos = new FileOutputStream("d:\\utf.txt");
		//创建转换流对象,构造方法保证字节输出流,并指定编码表是UTF-8
		OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
		osw.write("你好");
		osw.close();
	}
	
	/*
	 * 转换流对象 OutputStreamWriter写文本
	 * 文本采用GBK的形式写入
	 */
	public static void writeGBK()throws IOException{
		//创建字节输出流,绑定数据文件
		FileOutputStream fos = new FileOutputStream("d:\\gbk.txt");
		//创建转换流对象,构造方法,绑定字节输出流,使用GBK编码表
		OutputStreamWriter osw = new OutputStreamWriter(fos,"GBK");//默认的,可不写GBK
        //OutputStreamWriter osw = new OutputStreamWriter(fos);
		//转换流写数据
		osw.write("你好");
		
		osw.close();
	}
}

运行结果:

                 

找到写入流中的字符编码,再交给字节输出流,让字节输出流负责写入。因此说OutputStreamWriter 是字符流通向字节流的桥梁。

 

 

1.2 InputStreamReader类

InputStreamReader 是字节流通向字符流的桥梁。它使用指定的字符编码表读取字节并将其解码为字符。

它使用的字符集可以由名称指定或显式给定,或者可以接受平台默认的字符集。

过程图解:

 

package day24.demo1;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

/*
 *  转换流
 *    java.io.InputStreamReader 继承 Reader
 *    字符输入流,读取文本文件
 *    
 *    字节流向字符的敲了,将字节流转字符流
 *    
 *    读取的方法:
 *       read() 读取1个字符,读取字符数组
 *    
 *    技巧:  OuputStreamWriter写了文件
 *    InputStreamReader读取文件
 *    
 *    OuputStreamWriter(OuputStream out)所有字节输出流
 *    InputStreamReader(InputStream in) 接收所有的字节输入流
 *      可以传递的字节输入流: FileInputStream
 *    InputStreamReader(InputStream in,String charsetName) 传递编码表的名字
 */
public class InputStreamReaderDemo {
	public static void main(String[] args) throws IOException {
//		readGBK();
		readUTF();
	}
	/*
	 *  转换流,InputSteamReader读取文本
	 *  采用UTF-8编码表,读取文件utf
	 */
	public static void readUTF()throws IOException{
		//创建自己输入流,传递文本文件
		FileInputStream fis = new FileInputStream("d:\\utf.txt");
		//创建转换流对象,构造方法中,包装字节输入流,同时写编码表名
		InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
		char[] ch = new char[1024];
		int len = isr.read(ch);
		System.out.println(new String(ch,0,len));
		isr.close();
	}
	/*
	 *  转换流,InputSteamReader读取文本
	 *  采用系统默认编码表,读取GBK文件
	 */
	public static void readGBK()throws IOException{
		//创建自己输入流,传递文本文件
		FileInputStream fis = new FileInputStream("d:\\gbk.txt");
		//创建转换流对象,构造方法,包装字节输入流
		InputStreamReader isr = new InputStreamReader(fis);
		char[] ch = new char[1024];
		int len = isr.read(ch);
		System.out.println(new String(ch,0,len));
		
		isr.close();
	}
}

 运行结果:

注意:写入和读取的编码格式要保持一致,否则会发生错误。例如:用GBK编码写的就要用GBK读,否则出现乱码。

 

1.3 转换流和子类区别

发现有如下继承关系:

OutputStreamWriter:

                  |--FileWriter:

InputStreamReader:

                   |--FileReader;

父类和子类的功能有什么区别呢?

OutputStreamWriter和InputStreamReader是字符和字节的桥梁:也可以称之为字符转换流。字符转换流原理:字节流+编码表。

FileWriter和FileReader:作为子类,仅作为操作字符文件的便捷类存在。当操作的字符文件,使用的是默认编码表时可以不用父类,而直接用子类就完成操作了,简化了代码。

InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));//默认字符集。

InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"GBK");//指定GBK字符集。

FileReader fr = new FileReader("a.txt");

这三句代码的功能是一样的,其中第三句最为便捷。

注意:一旦要指定其他编码时,绝对不能用子类,必须使用字符转换流。

什么时候用子类呢?(FileWriter、FileReader)

条件:

1、操作的是文件。2、使用默认编码。

总结:

字节--->字符 : 看不懂的--->看的懂的。  需要读。输入流。 InputStreamReader

字符--->字节 : 看的懂的--->看不懂的。  需要写。输出流。 OutputStreamWriter

 

第二章 缓冲流

Java中提高了一套缓冲流,它的存在,可提高IO流的读写速度。

缓冲流,根据流的分类分类字节缓冲流与字符缓冲流。

2.1 字节缓冲流

字节缓冲流根据流的方向,共有2个

  • 写入数据到流中,字节缓冲输出流 BufferedOutputStream
  • 读取流中的数据,字节缓冲输入流 BufferedInputStream

它们的内部都包含了一个缓冲区,通过缓冲区读写,就可以提高了IO流的读写速度

 

2.1.1 字节缓冲输出流BufferedOutputStream

通过字节缓冲流,进行文件的读写操作:写数据到文件的操作。

构造方法:

public BufferedOutputStream(OutputStream out)创建一个新的缓冲输出流,以将数据写入指定的底层输出流。

package day24.demo1;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 *  字节输出流的缓冲流
 *   java.io.BufferedOuputStream 作用: 提高原有输出流的写入效率
 *   BufferedOuputStream 继承 OutputStream
 *   方法,写入 write 字节,字节数组
 *   
 *   构造方法:
 *     BufferedOuputStream(OuputStream out)
 *     可以传递任意的字节输出流, 传递的是哪个字节流,就对哪个字节流提高效率
 *     
 *     FileOutputSteam
 */
public class BufferedOutputStreamDemo {
	public static void main(String[] args)throws IOException {
		//创建字节输出流,绑定文件
		//FileOutputStream fos = new FileOutputStream("d:\\buffer.txt");
		//创建字节输出流缓冲流的对象,构造方法中,传递字节输出流
		BufferedOutputStream bos = new
				BufferedOutputStream(new FileOutputStream("d:\\buffer.txt"));
		
		bos.write(55);
		
		byte[] bytes = "HelloWorld".getBytes();
		
		bos.write(bytes);
		
		bos.write(bytes, 3, 2);
		
		bos.close();
	}
}

 

2.1.2 字节缓冲输入流 BufferedInputStream

刚刚我们学习了输出流实现了向文件中写数据的操作,那么,现在我们完成输入流从读取文件中数据的操作。

构造方法:

public BufferedInputStream(InputStream in)

package day24.demo1;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

/*
 *  字节输入流的缓冲流
 *    java.io.BufferedInputStream 
 *     继承InputStream,标准的字节输入流
 *     读取方法  read() 单个字节,字节数组
 *    
 *    构造方法:
 *      BufferedInputStream(InputStream in)
 *      可以传递任意的字节输入流,传递是谁,就提高谁的效率
 *      可以传递的字节输入流 FileInputStream
 */
public class BufferedInputStreamDemo {
	public static void main(String[] args) throws IOException{
		//创建字节输入流的缓冲流对象,构造方法中包装字节输入流,包装文件
		BufferedInputStream bis = new 
				BufferedInputStream(new FileInputStream("d:\\buffer.txt"));
		byte[] bytes = new byte[10];
		int len = 0 ;
		while((len = bis.read(bytes))!=-1){
			System.out.print(new String(bytes,0,len));
		}
		bis.close();
	}
}

 

2.1.3 使用基本的流与高效的流完成复制文件

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 *  文件复制方式,字节流,一共4个方式
 *  1. 字节流读写单个字节                    125250 毫秒
 *  2. 字节流读写字节数组                    193    毫秒  OK
 *  3. 字节流缓冲区流读写单个字节     1210   毫秒
 *  4. 字节流缓冲区流读写字节数组     73     毫秒  OK
 */
public class Copy {
	public static void main(String[] args)throws IOException {
		long s = System.currentTimeMillis();
		copy_4(new File("c:\\q.exe"), new File("d:\\q.exe"));
		long e = System.currentTimeMillis();
		System.out.println(e-s);
	}
	/*
	 * 方法,实现文件复制
	 *  4. 字节流缓冲区流读写字节数组
	 */
	public static void copy_4(File src,File desc)throws IOException{
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desc));
		int len = 0 ;
		byte[] bytes = new byte[1024];
		while((len = bis.read(bytes))!=-1){
			bos.write(bytes,0,len);
		}
		bos.close();
		bis.close();
	}
	/*
	 * 方法,实现文件复制
	 *  3. 字节流缓冲区流读写单个字节
	 */
	public static void copy_3(File src,File desc)throws IOException{
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desc));
		int len = 0 ;
		while((len = bis.read())!=-1){
			bos.write(len);
		}
		bos.close();
		bis.close();
	}
	
	/*
	 * 方法,实现文件复制
	 *  2. 字节流读写字节数组
	 */
	public static void copy_2(File src,File desc)throws IOException{
		FileInputStream fis = new FileInputStream(src);
		FileOutputStream fos = new FileOutputStream(desc);
		int len = 0 ;
		byte[] bytes = new byte[1024];
		while((len = fis.read(bytes))!=-1){
			fos.write(bytes,0,len);
		}
		fos.close();
		fis.close();
	}
	
	/*
	 * 方法,实现文件复制
	 *  1. 字节流读写单个字节
	 */
	public static void copy_1(File src,File desc)throws IOException{
		FileInputStream fis = new FileInputStream(src);
		FileOutputStream fos = new FileOutputStream(desc);
		int len = 0 ;
		while((len = fis.read())!=-1){
			fos.write(len);
		}
		fos.close();
		fis.close();
	}
}

 

2.2 字符缓冲流

字符缓冲输入流 BufferedReader

字符缓冲输出流 BufferedWriter

完成文本数据的高效的写入与读取的操作。

2.2.1  字符缓冲输出流 BufferedWriter

将文本写入字符输出流,缓冲各个字符,从而提供单个字符、数组和字符串的高效写入。

方法:

void newLine() 根据当前的系统,写入一个换行符。

1.  字符输出流缓冲区流
            java.io.BufferedWriter 继承 Writer
           写入方法 write () 单个字符,字符数组,字符串

2.  构造方法:
       BufferedWriter(Writer w)传递任意字符输出流,传递谁,就高效谁。
       能传递的字符输出流 FileWriter, OutputStreamWriter
    
3.  BufferedWriter 具有自己特有的方法
        void  newLine() 写换行
        newLine()文本中换行, \r\n也是文本换行,但newLine()具有平台无关性。
        Windows换行符为:\r\n
        Linux换行符为:    \n
      
4.   newLine()运行结果,和操作系统是相互关系
      JVM: 安装的是Windows版本,newLine()写的就是\r\n
      安装的是Linux版本,newLine()写的就是\n

package day24.demo1;

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

/*
 *   字符输出流缓冲区流
 *     java.io.BufferedWriter 继承 Writer
 *     写入方法 write () 单个字符,字符数组,字符串
 *     
 *     构造方法:
 *       BufferedWriter(Writer w)传递任意字符输出流
 *       传递谁,就高效谁
 *         能传递的字符输出流 FileWriter, OutputStreamWriter
 *         
 *    BufferedWriter 具有自己特有的方法
 *      void  newLine() 写换行
 *      
 *       newLine()文本中换行, \r\n也是文本换行
 *       方法具有平台无关性
 *       Windows  \r\n
 *       Linux    \n
 *       
 *       newLine()运行结果,和操作系统是相互关系
 *       JVM: 安装的是Windows版本,newLine()写的就是\r\n
 *            安装的是Linux版本,newLine()写的就是\n
 */
public class BufferedWrierDemo {
	public static void main(String[] args) throws IOException{
		//创建字符输出流,封装文件
		FileWriter fw = new FileWriter("c:\\buffer.txt");
		BufferedWriter bfw = new BufferedWriter(fw);
		
		bfw.write("你好");
		bfw.newLine();
		bfw.flush();
		
		
		bfw.write("我好好");
		bfw.newLine();
		bfw.flush();

		bfw.write("大家都好");
		bfw.flush();
		
		bfw.close();
		
	}
}

/*
 * 		
		bfw.write(100);
		bfw.flush();
		
		bfw.write("你好".toCharArray());
		bfw.flush();*/

 

2.2.2 字符缓冲输入流 BufferedReader

从字符输入流中读取文本,缓冲各个字符,从而实现字符、数组和行的高效读取。

方法:

public String readLine() 读取一个文本行,包含该行内容的字符串,不包含任何行终止符,如果已到达流末尾,则返回 null。

1.  字符输入流缓冲流

      java.io.BufferedReader 继承 Reader

      读取功能 read() 单个字符,字符数组

2.  构造方法:

        BufferedReader(Reader r)可以任意的字符输入流(FileReader  InputStreamReader)

       BufferedReader自己的功能:

            String readLine() 读取文本行 \r\n

       方法读取到流末尾,返回null

3.  小特点:

         获取内容的方法一般都有返回值

         int 类型数据,找不到返回的都是负数。

         引用类型,找不到返回null

         boolean,找不到返回false

 4.null   

         String s = null

         String s ="null"

         readLine()方法返回行的有效字符,不输出换行,找不到返回null。

package day24.demo1;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/*
 *  字符输入流缓冲流
 *    java.io.BufferedReader 继承 Reader
 *    读取功能 read() 单个字符,字符数组
 *    构造方法:
 *      BufferedReader(Reader r)
 *      可以任意的字符输入流
 *         FileReader  InputStreamReader
 *         
 *     BufferedReader自己的功能
 *     String readLine() 读取文本行 \r\n
 *     
 *     方法读取到流末尾,返回null
 *     小特点:
 *       获取内容的方法一般都有返回值
 *       int 没有返回的都是负数
 *       引用类型 找不到返回null
 *       boolean 找不到返回false
 *       
 *       String s = null
 *       String s ="null"
 *       
 *       readLine()方法返回行的有效字符,没有\r\n
 */
public class BufferedReaderDemo {
	public static void main(String[] args) throws IOException {
		int lineNumber = 0;
		//创建字符输入流缓冲流对象,构造方法传递字符输入流,包装数据源文件
		BufferedReader bfr = new BufferedReader(new FileReader("c:\\a.txt"));
		//调用缓冲流的方法 readLine()读取文本行
		//循环读取文本行, 结束条件 readLine()返回null
		String line = null;
		while((line = bfr.readLine())!=null){
			lineNumber++;
			System.out.println(lineNumber+"  "+line);
		}
		bfr.close();
	}
}

/*
 * String line = bfr.readLine();
		System.out.println(line);
		
		line = bfr.readLine();
		System.out.println(line);
		
		line = bfr.readLine();
		System.out.println(line);
		
		line = bfr.readLine();
		System.out.println(line);
		
		line = bfr.readLine();
		System.out.println(line);
 */

 

2.2.3 使用字符缓冲流完成文本文件的复制

刚刚我们学习完了缓冲流,现在我们就使用字符缓冲流的特有功能,完成文本文件的复制

package day24.demo1;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
 *  使用缓冲区流对象,复制文本文件
 *  数据源  BufferedReader+FileReader 读取
 *  数据目的 BufferedWriter+FileWriter 写入
 *  读取文本行, 读一行,写一行,写换行
 */
public class Copy_1 {
	public static void main(String[] args) throws IOException{
		BufferedReader bfr = new BufferedReader(new FileReader("c:\\w.log"));	
		BufferedWriter bfw = new BufferedWriter(new FileWriter("d:\\w.log"));
		//读取文本行, 读一行,写一行,写换行
		String line = null;
		while((line = bfr.readLine())!=null){
			bfw.write(line);
			bfw.newLine();
			bfw.flush();
		}
		bfw.close();
		bfr.close();
	}
}

 

第三章 流的操作规律

IO流中对象很多,解决问题(处理设备上的数据时)到底该用哪个对象呢?

把IO流进行了规律的总结(四个明确):

明确一:要操作的数据是数据源还是数据目的。

                  源(读文件):InputStream          Reader

                  目的(写文件):OutputStream    Writer

先根据需求明确要读,还是要写。

明确二:要操作的数据是字节还是文本呢?

                  源:

                           字节:InputStream    //全能流

                           文本:Reader(仅限文本数据)

                  目的:

                           字节:OutputStream    //全能流

                           文本:Writer(仅限文本数据)

已经明确到了具体的体系上。

明确三:明确数据所在的具体设备。

                  源设备:

                           硬盘:文件  File开头。

                           内存:数组,字符串。

                           键盘:System.in;

                           网络:Socket

                  目的设备:

                           硬盘:文件  File开头。

                           内存:数组,字符串。

                           屏幕:System.out

                           网络:Socket

完全可以明确具体要使用哪个流对象。

明确四:是否需要额外功能呢?

                  额外功能:

                           转换吗?转换流。InputStreamReader OutputStreamWriter

                           高效吗?缓冲区对象。BufferedXXX

继承体系:

InputStream

     FileInputStream

     FilterInputStream

           BufferedInputStream

     FileInputStream,FilterInputStream同级,均继承于InputStream, BufferedInputStream继承于FilterInputStream

 

OuputStream

   FileOutputStream

          BufferedOuputStream

Writer

  OutputStreamWriter

     FileWriter

 BufferedWriter

 

Reader//读取文本的

  InputStreamReader

     FileReader

 BufferedReader

 

第四章 总结

字节流

 字节输入流 InputStream

FileInputStream 操作文件的字节输入流

BufferedInputStream高效的字节输入流

   字节输出流 OutputStream

FileOutputStream 操作文件的字节输出流

BufferedOutputStream 高效的字节输出流

字符流

  字符输入流 Reader

FileReader 操作文件的字符输入流

BufferedReader 高效的字符输入流

InputStreamReader 输入操作的转换流(把字节流封装成字符流)

  字符输出流 Writer

FileWriter 操作文件的字符输出流

BufferedWriter 高效的字符输出流

OutputStreamWriter 输出操作的转换流(把字节流封装成字符流)

方法:

   读数据方法:

read() 一次读一个字节或字符的方法

read(byte[]  char[]) 一次读一个数组数据的方法

readLine() 一次读一行字符串的方法(BufferedReader类特有方法)

readObject() 从流中读取对象(ObjectInputStream特有方法)

  写数据方法:

write(int) 一次写一个字节或字符到文件中

write(byte[] char[]) 一次写一个数组数据到文件中

write(String) 一次写一个字符串内容到文件中

writeObject(Object ) 写对象到流中(ObjectOutputStream类特有方法)

newLine() 写一个换行符号(BufferedWriter类特有方法)

向文件中写入数据的过程

  1. 创建输出流对象

  2. 写数据到文件

  3. 关闭输出流

 

从文件中读数据的过程

  1. 创建输入流对象

  2. 从文件中读数据

  3. 关闭输入流

 

文件复制的过程

  1. 创建输入流(数据源)

  2. 创建输出流(目的地)

  3. 从输入流中读数据

  4. 通过输出流,把数据写入目的地

  5. 关闭流

  • 1
    点赞
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
根据提供的引用内容,可以了解到Java IO流分为字节流字符流两种类型。其中字节流字节为单位进行读写,而字符流字符为单位进行读写。下面是Java IO字节流的构造方法和使用方法: 1. InputStream类是所有字节输入的父类,常用方法有: - read():从输入中读取一个字节的数据。 - read(byte[] b):从输入中读取一定数量的字节,并将其存储在缓冲区数组b中。 - skip(long n):跳过并丢弃输入中的n个字节数据。 - available():返回输入中可以被读取的字节数。 2. FileInputStream类是InputStream类的子类,常用方法有: - FileInputStream(String name):创建一个文件输入,以读取具有指定名称的文件。 - read():从输入中读取一个字节的数据。 - read(byte[] b):从输入中读取一定数量的字节,并将其存储在缓冲区数组b中。 - skip(long n):跳过并丢弃输入中的n个字节数据。 - available():返回输入中可以被读取的字节数。 3. FileOutputStream类是OutputStream类的子类,常用方法有: - FileOutputStream(String name):创建一个文件输出,以写入具有指定名称的文件。 - write(int b):将指定的字节写入此文件输出。 - write(byte[] b):将b.length个字节从指定的字节数组写入此文件输出中。 - flush():刷新此输出并强制任何缓冲的输出字节被写出。 下面是一个Java IO字节流复制文件的示例代码: ```java public static void main(String[] args) { try { // 创建要复制文件的字节输入 InputStream inp = new FileInputStream("/Users/chenyq/Documents/learn_Java/code/file-io-app/src/test.pdf"); // 创建目标路径的字节输出 OutputStream oup = new FileOutputStream("/Users/chenyq/Documents/newtest.pdf"); // 使用文件输入获取要复制文件的全部数据的字节数组 byte[] arr = inp.readAllBytes(); // 使用文件输出字节数组写入目标文件 oup.write(arr); System.out.println("复制成功!"); // 释放资源 inp.close(); oup.close(); } catch (IOException e) { e.printStackTrace(); } } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值