JAVA字节流与字符流的相互转换

先来看一下流的概念：

     在程序中所有的数据都是以流的方式进行传输或保存的，程序需要数据的时候要使用输入流读取数据，而当程序需要将一些数据保存起来的时候，就要使用输出流完成。

     程序中的输入输出都是以流的形式保存的，流中保存的实际上全都是字节文件。

字节流与字符流

     在java.io包中操作文件内容的主要有两大类：字节流、字符流，两类都分为输入和输出操作。在字节流中输出数据主要是使用OutputStream完成，输入使的是InputStream，在字符流中输出主要是使用Writer类完成，输入流主要使用Reader类完成。（这四个都是抽象类）

     java中提供了专用于输入输出功能的包Java.io,其中包括：
     InputStream,OutputStream,Reader,Writer
     InputStream 和OutputStream,两个是为字节流设计的,主要用来处理字节或二进制对象,
     Reader和 Writer.两个是为字符流（一个字符占两个字节）设计的,主要用来处理字符或字符串.

     字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串，而字节流处理单元为1个字节，操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，所以它对多国语言支持性比较好！如果是音频文件、图片、歌曲，就用字节流好点，如果是关系到中文（文本）的，用字符流好点
     所有文件的储存是都是字节（byte）的储存，在磁盘上保留的并不是文件的字符而是先把字符编码成字节，再储存这些字节到磁盘。在读取文件（特别是文本文件）时，也是一个字节一个字节地读取以形成字节序列

      字节流可用于任何类型的对象，包括二进制对象，而字符流只能处理字符或者字符串； 字节流提供了处理任何类型的IO操作的功能，但它不能直接处理Unicode字符，而字符流就可以
     字节流是最基本的，所有的InputStrem和OutputStream的子类都是,主要用在处理二进制数据，它是按字节来处理的 但实际中很多的数据是文本，又提出了字符流的概念，它是按虚拟机的encode来处理，也就是要进行字符集的转化 这两个之间通过 InputStreamReader,OutputStreamWriter来关联，实际上是通过byte[]和String来关联 在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的 。

     字节流和字符流的操作过程：   

     以文件操作为例，主要的操作流程如下：

    1 使用File类打开一个文件

    2 通过字节流或字符流的子类，指定输出的位置

    3 进行读/写操作

    4 关闭输入/输出

     IO操作属于资源操作，一定要记得关闭 

     字节流的操作：

     字节流主要是操作byte类型数据，以byte数组为准，主要操作类就是OutputStream、InputStream     

     字节输出流：OutputStream

　　OutputStream是整个IO包中字节输出流的最大父类，此类的定义如下：

public abstract class OutputStream extends Object implements Closeable,Flushable

　　从以上的定义可以发现，此类是一个抽象类，如果想要使用此类的话，则首先必须通过子类实例化对象，那么如果现在要操作的是一个文件，则可以使用：FileOutputStream类。通过向上转型之后，可以为OutputStream实例化

　　Closeable表示可以关闭的操作，因为程序运行到最后肯定要关闭

　　Flushable：表示刷新，清空内存中的数据

　　FileOutputStream类的构造方法如下：

public FileOutputStream(File file)throws FileNotFoundException

 

写数据：

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class Test11 {
      public static void main(String[] args) throws IOException {
          File f = new File("d:" + File.separator+"test.txt");
          OutputStream out=new FileOutputStream(f);//如果文件不存在会自动创建
         String str="Hello World";
         byte[] b=str.getBytes();
         out.write(b);//因为是字节流，所以要转化成字节数组进行输出
         out.close();
     }
 }

也可以一个字节一个字节进行输出，如下：

 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;

 public class Test11 {
      public static void main(String[] args) throws IOException {
          File f = new File("d:" + File.separator+"test.txt");
          OutputStream out=new FileOutputStream(f);//如果文件不存在会自动创建
         String str="Hello World";
         byte[] b=str.getBytes();
         for(int i=0;i<b.length;i++){
             out.write(b[i]);
         }
         out.close();
     }
 }

以上输出只会进行覆盖，如果要追加的话，请看FileOutputStream类的另一个构造方法：

public FileOutputStream(File file,boolean append)throws FileNotFoundException

在构造方法中，如果将append的值设置为true，则表示在文件的末尾追加内容。

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

 public class Test11 {
      public static void main(String[] args) throws IOException {
          File f = new File("d:" + File.separator+"test.txt");
          OutputStream out=new FileOutputStream(f,true);//追加内容
         String str="\r\nHello World";
         byte[] b=str.getBytes();
         for(int i=0;i<b.length;i++){
             out.write(b[i]);
         }
         out.close();
     }
 }

　　字节输入流：InputStream

　　既然程序可以向文件中写入内容，则就可以通过InputStream从文件中把内容读取进来，首先来看InputStream类的定义：

　　　　　　public abstract class InputStream extends Object implements Closeable

　　与OutputStream类一样，InputStream本身也是一个抽象类，必须依靠其子类，如果现在是从文件中读取，就用FileInputStream来实现。

　　观察FileInputStream类的构造方法：

　　　　　　public FileInputStream(File file)throws FileNotFoundException

　　读文件：

 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;

  public class Test12 {
      public static void main(String[] args) throws IOException {
          File f = new File("d:" + File.separator+"test.txt");
          InputStream in=new FileInputStream(f);
         byte[] b=new byte[(int) f.length()];  //根据文件的大小来定义字节数组的大小int len=in.read(b);
         in.close();
         System.out.println(new String(b,0,len));
     }
 }

换种方式，一个字节一个字节读入

 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;

  public class Test14 {
      public static void main(String[] args) throws IOException {
          File f = new File("d:" + File.separator+"test.txt");
          InputStream in=new FileInputStream(f);
         byte[] b=new byte[(int) f.length()];
         for(int i=0;i<b.length;i++){
             b[i]=(byte) in.read();
         }
         in.close();
         System.out.println(new String(b));
     }
 }

但以上情况只适合知道输入文件的大小，不知道的话用如下方法：

 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;

  public class Test15 {
      public static void main(String[] args) throws IOException {
          File f = new File("d:" + File.separator+"test.txt");
          InputStream in=new FileInputStream(f);
         byte[] b=new byte[1024];
         int temp=0;
         int len=0;
         while((temp=in.read())!=-1){//-1为文件读完的标志
             b[len]=(byte) temp;
             len++;
        }
         in.close();
         System.out.println(new String(b,0,len));
     }
 }

　　字符流

　　在程序中一个字符等于两个字节，那么java提供了Reader、Writer两个专门操作字符流的类。

字符输出流：Writer

　　Writer本身是一个字符流的输出类，此类的定义如下：

　　　　　public abstract class Writer extends Object implements Appendable，Closeable，Flushable

　　此类本身也是一个抽象类，如果要使用此类，则肯定要使用其子类，此时如果是向文件中写入内容，所以应该使用FileWriter的子类。

　　FileWriter类的构造方法定义如下：

　　　　　public FileWriter(File file)throws IOException

　　字符流的操作比字节流操作好在一点，就是可以直接输出字符串了，不用再像之前那样进行转换操作了。

　　写文件：

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

  public class Test16 {
      public static void main(String[] args) throws IOException {
          File f = new File("d:" + File.separator+"test.txt");
          Writer out=new FileWriter(f);
         String str="Hello World";
         out.write(str);
         out.close();
     }
 }

在默认情况下再次输出会覆盖，追加的方法也是在构造函数上加上追加标记

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

  public class Test17 {
     public static void main(String[] args) throws IOException {
          File f = new File("d:" + File.separator+"test.txt");
          Writer out=new FileWriter(f,true);//追加
         String str="\r\nHello World";
         out.write(str);
         out.close();
     }
 }

　　字符输入流：Reader

　　Reader是使用字符的方式从文件中取出数据，Reader类的定义如下：

　　　　public abstract class Reader extends Objects implements Readable，Closeable

　　Reader本身也是抽象类，如果现在要从文件中读取内容，则可以直接使用FileReader子类。

　　FileReader的构造方法定义如下：

　　　　public FileReader(File file)throws FileNotFoundException

　　以字符数组的形式读取出数据：

 import java.io.File;
 import java.io.FileReader;
 import java.io.IOException;
 import java.io.Reader;

  public class Test18 {
      public static void main(String[] args) throws IOException {
          File f = new File("d:" + File.separator+"test.txt");
          Reader input=new FileReader(f);
         char[] c=new char[1024];
         int len=input.read(c);
         input.close();
         System.out.println(new String(c,0,len));
     }
 }

也可以用循环方式，判断是否读到底

import java.io.File;
import java.io.FileReader;
 import java.io.IOException;
 import java.io.Reader;

 public class Test19 {
     public static void main(String[] args) throws IOException {
          File f = new File("d:" + File.separator+"test.txt");
          Reader input=new FileReader(f);
         char[] c=new char[1024];
         int temp=0;
         int len=0;
         while((temp=input.read())!=-1){
             c[len]=(char) temp;
             len++;
         }
         input.close();
         System.out.println(new String(c,0,len));
     }
 }

　　字节流与字符流的区别

　　字节流和字符流使用是非常相似的，那么除了操作代码的不同之外，还有哪些不同呢？

　　字节流在操作的时候本身是不会用到缓冲区（内存）的，是与文件本身直接操作的，而字符流在操作的时候是使用到缓冲区的

　　字节流在操作文件时，即使不关闭资源（close方法），文件也能输出，但是如果字符流不使用close方法的话，则不会输出任何内容，说明字符流用的是缓冲区，并且可以使用flush方法强制进行刷新缓冲区，这时才能在不close的情况下输出内容

　　那开发中究竟用字节流好还是用字符流好呢？

　　在所有的硬盘上保存文件或进行传输的时候都是以字节的方法进行的，包括图片也是按字节完成，而字符是只有在内存中才会形成的，所以使用字节的操作是最多的。

　　如果要java程序实现一个拷贝功能，应该选用字节流进行操作（可能拷贝的是图片），并且采用边读边写的方式（节省内存）。

字节流与字符流的转换

     虽然Java支持字节流和字符流，但有时需要在字节流和字符流两者之间转换。InputStreamReader和OutputStreamWriter，这两个为类是字节流和字符流之间相互转换的类。

　　InputSreamReader用于将一个字节流中的字节解码成字符：

　　有两个构造方法：

　　　　InputStreamReader(InputStream in);

　　　　功能：用默认字符集创建一个InputStreamReader对象

　　　　InputStreamReader(InputStream in,String CharsetName);

　　　　功能：接收已指定字符集名的字符串，并用该字符创建对象

　　OutputStream用于将写入的字符编码成字节后写入一个字节流。

　　同样有两个构造方法：

　　　　OutputStreamWriter(OutputStream out);

　　　　功能：用默认字符集创建一个OutputStreamWriter对象；

　　　　OutputStreamWriter(OutputStream out,String  CharSetName);

　　　　功能：接收已指定字符集名的字符串，并用该字符集创建OutputStreamWrite对象

      为了避免频繁的转换字节流和字符流，对以上两个类进行了封装。

　　BufferedWriter类封装了OutputStreamWriter类；

　　BufferedReader类封装了InputStreamReader类；

　　封装格式：

　　BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));

　　BufferedReader in= new BufferedReader(new InputStreamReader(System.in);

　　利用下面的语句，可以从控制台读取一行字符串：

　　BufferedReader in=new BufferedReader(new InputStreamReader(System.in));

　　String line=in.readLine();

时间： 2024-09-30 01:23:01

JAVA字节流与字符流的相互转换的相关文章

java 字节流和字符流的区别

字节流与和字符流的使用非常相似,两者除了操作代码上的不同之外,是否还有其他的不同呢? 实际上字节流在操作时本身不会用到缓冲区(内存),是文件本身直接操作的,而字符流在操作时使用了缓冲区,通过缓冲区再操作文件,如图12-6所示. <iframe id="iframe_0.4142593172691813" style="margin: 0px; padding: 0px; border-width: initial; border-style: none; width:

java IO之 字符流 （字符流 = 字节流 + 编码表） 装饰器模式

字符流 计算机并不区分二进制文件与文本文件.所有的文件都是以二进制形式来存储的,因此, 从本质上说,所有的文件都是二进制文件.所以字符流是建立在字节流之上的,它能够提供字符 层次的编码和解码.列如,在写入一个字符时,Java虚拟机会将字符转为文件指定的编码(默认 是系统默认编码),在读取字符时,再将文件指定的编码转化为字符. 常见的码表如下: ASCII:           美国标准信息交换码.用一个字节的7位可以表示. ISO8859-1:   拉丁码表.欧洲码表,用一个字节的8位表示.又称

java的IO当中字节流和字符流的区别和联系是什么

问题描述 java的IO当中字节流和字符流的区别和联系是什么 java的IO当中字节流和字符流的区别和联系是什么 在什么情况下用字符流,或者用字节流. 解决方案 两个都是流,一个是以一个个字节传的,一个是以一个个字符传的,再不懂百度 解决方案二: 不清数 不是这份专业的 解决方案三: 不清数 不是这份专业的 解决方案四: 不清数 不是这份专业的 解决方案五: 不清数 不是这份专业的 解决方案六: Java IO中字节流和字符流的区别Java IO中字节流和字符流的区别字节流和字符流的区别是什么?

Java编程中字节流与字符流IO操作示例_java

 IO流基本概念IO流用来处理设备之间的数据传输 Java对数据的操作是通过流的方式 Java用于操作流的对象都是在IO包上 流按操作数据分为两种:字节流和字符流 流按流向分为:输入流,输出流. 字节流的抽象基类:InputStream,OutputStream 字符流的抽象基类:Reader,Writer 注:由这4个类派生出来的子类名称都是以其父类名作为子类名的后缀. 如:InputStream的子类:FileInputStream 如:Reader的子类FileReader 如创建一个Fi

Core Java - 流(Stream) - 字节流和字符流(一)

0. 概述: Java中基于流的I/O构建在4个抽象类之上, 其中2个是字节流,另外2个是字符流. 字节流: InputStream / OutputStream 当操作字节或其它二进制对象时,应当使用字节流.   字符流: Reader / Writer 当操作字符或字符串时,应当使用字符流.   1. InputStream InputStream:   输入字节流,它是一个抽象类. 常用主要方法: int read() 返回代表下一个可用字节的整数,当文件达到末尾时,返回-1.   int

Java IO--字节-字符流转换OutputStreamWriter/InputStreamReader

OutputStreamWriter和InputStreamReader 一般在操作输入输出内容的就需要使用字节或字符流,但是有些时候需要将字符流变为字节流的形式,或者将字节流变为字符流的形式,所以,就需要另外一组转换流的操作类. import java.io.* ; public class OutputStreamWriterDemo01{ public static void main(String args[]) throws Exception { // 所有异常抛出 File f =

字节流通向字符流的桥梁：InputStreamReader

public class InputStreamReader extends Reader InputStreamReader 是字节流通向字符流的桥梁:它使用指定的 charset 读取字节并将其解码为字符.它使用的字符集可以由名称指定或显式给定,或者可以接受平台默认的字符集. 每次调用 InputStreamReader 中的一个 read() 方法都会导致从底层输入流读取一个或多个字节.要启用从字节到字符的有效转换,可以提前从底层流读取更多的字节,使其超过满足当前读取操作所需的字节. 为了

在学Java，以字符流read一个txt文件，文件里写的是中文，控制台显示的乱码，大牛看下，谢谢

问题描述 在学Java,以字符流read一个txt文件,文件里写的是中文,控制台显示的乱码,大牛看下,谢谢 试了下,txt文件是英文的话不乱码,但是是中文的话就会出现乱码. public class test { public static void main(String[] args){ readFile(); //System.out.println(""); } public static void readFile(){ try { File file=new File(&q

ASP中利用ADODB.Stream对象将字节流转换为字符流

'--------------------------------------------------------------------' 二进制转字符串'' 入口参数:字节流' 函数返回:字符串' Code By:Madpolice 2002-12-20' 利用 ADODB.Stream 对象,速度比原来的字符替换法快了n倍,n≈30!!)'--------------------------------------------------------------------'下面的常量是函