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

最新推荐文章于 2024-05-27 12:58:48 发布
最新推荐文章于 2024-05-27 12:58:48 发布
阅读量1.4k 收藏 7
点赞数 1
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40243295/article/details/112694683
版权

目录

第一章 转换流

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. 关闭流

kww_
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中的io流，输入输出我们该用什么？
m0_43435611的博客
09-11 394
一、概述 Java IO，即input/output，输入输出系统。无论什么样的程序，我们都难免和输入输出相关的媒介打交道，对于不同的媒介（如文件、控制台、网络），采用不同的方式（顺序、随机、二进制、按字符、按字节、按行）进行输入和输出，是十分复杂的一个问题。Java类库提供了大量的类来解决这些难题，这些类位于java.io包中。 1.1 流 在Java IO中，流是一个核心的概念。流从概念上来说是一个连续的数据流。你既可以从流中读取数据，也可以往流中写数据。流与数据源或者数据流向的媒介相关联。在Java
JavaIO实例_字节流_字符流_缓冲流_转换流IODemo
12-16
在Java中，IO流分为两大类：字节流和字符流，每种流又有输入流和输出流之分，分别用于数据的读取和写入。 1. **字节流**： - 字节流处理的是8位的字节数据，是最基本的流类型。Java中的`InputStream`和`...
Java转换流详解
波哩个波的博客
03-18 1655
Java转换流详解
Java常见流的分类及简单讲解
最新发布
m0_59679869的博客
05-27 1262
java中的流介绍
转换流（处理流的一种，属于字符流）
博客的博客
01-18 3109
目录 一、概述 1.转换流的作用 2.种类 ①INputStreamReader ②OutputStreamReader 图示 3.编码&解码 ①解码 ②编码 4.字符集 1.字符编码的由来及常见的编码表 2.UTF-8和Unicode编码的区别 3.Unicode编码 二、INputStreamReader的使用 三、OutputStreamReader的使用 一、概述 1.转换流的作用 提供了在字节流和字符流之间的转换 字节流中的数据都是字符时，转成字符流操
字符流与字节流的相互转换原理及代码（Linux C）
weixin_45121946的博客
07-31 2196
文章目录一. 两者的区别二. 还需要了解三. 字节流转字符流实现三. 字符流转字节流实现四. 测试程序4.1 头文件 4.2 用于测试的程序 4.2 简单写一个makefile 4.3 运行   我们在做项目时，常常会遇到将字节流的数据转成字符流，或者将字符流的数据转为字节流，例如最近做的一个项目，其中一个模块是使用移远的EC20 4G模块通过串口编程实现中英文短信的发送与接收，其中： 在中文短信的发送时，要进行PDU的编码，其中包括了utf-8转unicode的处理，获取到的是字节流的unicode编码
java转换流
yuxialuozi的博客
07-08 457
转换流（InputStreamReader 和 OutputStreamWriter）是 Java 中用于在字节流与字符流之间进行转换的桥梁。它们可以将字节流转换为字符流，并提供了字符编码的功能。转换流的主要作用是将字节流解析成字符流，在读取字节数据或写入字符数据时完成字符编码和解码的过程。同时，通过指定字符编码为 "UTF-8"，将字节流转换为字符流。同时，通过指定字符编码为 "UTF-8"，将字符流转换为字节流。对象按行读取字符数据，进行进一步的处理。在 Java 中，主要使用。类来实现转换流的功能。
IO流【转换流、字符输出流、数据流、对象流】(三)-全面详解（学习总结---从入门到深化）
07-10 227
IO流【转换流、字符输出流、数据流、对象流】(三)-全面详解（学习总结---从入门到深化）
JAVA IO流缓冲字节流缓冲字符流等流经典代码示例加注释总结.rar
11-30
2、常用21个IO流：FileWriter、FileReader、...3、JAVA IO流经典代码示例，示例从易到难。代码功能涉及字节、字符、字符串、文本文件、图片、音频、视频。演示错误用法和经典用法。 4、代码的结构可查看README文件。
Java_IO.rar_IO流 java_java io流
09-21
在Java中，IO流可以分为两类：字节流（处理单个字节）和字符流（处理Unicode字符）。此外，它们又可以分为四大类：输入流（用于读取数据）、输出流（用于写入数据）、节点流（与特定数据源或目的地关联）和过滤流...
JavaIO实例|字节流|字符流|缓冲流|转换流IODemo
12-15
本教程将详细介绍Java IO中的字节流、字符流、缓冲流以及转换流，并通过IODemo实例来展示它们的用法。 ### 1. 字节流 字节流是Java中最基础的流类型，用于处理以字节为单位的数据。字节流分为输入流（InputStream...
java 字节与字符流，字符流转换
03-19
java 字节与字符流，字符流转换
java字节字符转换流操作详解
08-25
Java字节字符转换流操作是Java IO编程中的关键部分，主要涉及如何在字节流（Byte Stream）和字符流（Character Stream）之间进行转换。字节流处理的是字节序列，而字符流处理的是字符序列，这两者在处理文本文件时...
Java中的文件字节流(万能流)
m0_70545163的博客
07-15 1846
摘要：本文讲解了java中的文件字节流，也就是我们常说的万年流，包括文件字节输入流（FileInputStream）和文件字节输出流（FileOutputStream）的内容，这里会讲解这两种流的构造方法和常用方法，后面还有一个案例来理解文件字节流。
java字符串 转字节流
Rockandrollman的博客
03-22 351
【代码】java字符串 转字节流。
IO流---转换流
m0_53380957的博客
09-08 302
IO流之一---转换流
Java转换流
淼淼不暴躁!
08-06 246
使用FileReader读取项目中的文本文件。由于IDEA设置中针对项目设置了UTF-8编码，当读取Windows系统中创建的文本文件时，如果Windows系统默认的是GBK编码，则读入内存中会出现乱码。那么如何读取GBK编码的文件呢？针对文本文件，现在使用一个字节流进行数据的读入，希望将数据显示在控制台上。此时针对包含中文的文本数据，可能会出现乱码。
InputStreamReader介绍&使用
热门推荐
weixin_44664432的博客
09-16 2万+
InputStreamReader类： java.io.InputStreamReader extends Reader InputStreamReader:是字节流通向字符流的桥梁：他使用指定的charset读取字节并将其解码为字符。(解码：把看不懂的变为能看懂的) 继承自父类的共性成员方法： int read() 读取单个字符并返回 int read(char[] cbuf) 一次读取多个字符，经字符读入数组中 void close() 关闭该流并释放与之关联的所有资源 构造方
java基础之文件与字节流字符流
焱宣的博客
02-17 876
第一章 File类 1.1 File类作用 1.2 File类的常用构造方法 1.3 File类文件属性方法 1.1 file 类的作用： 在java程序中，对磁盘文件进行描述的类。文件和目录路径名的抽象表示形式。 1.2 File类的常用构造方法 1.3 File类文件属性方法 属性： static String pathSeparator：与系统有关的路径分隔符，为了方便，它被表示为一个字符串（;）。 static char pathSeparatorChar： static String Sepa
javaio流字节流构造方法
12-14
根据提供的引用内容，可以了解到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、付费专栏及课程。

余额充值