精华内容
下载资源
问答
  • java字节流和字符流

    2011-07-02 16:37:32
    java字节流和字符流java字节流和字符流java字节流和字符流
  • Java字节流和字符流

    2019-12-05 16:17:32
    Java字节流和字符流Java字节流和字符流的主要区别是编码方式,字节流主要是基于二进制以字节为单位进行输入输出,字符流是Unicode编码的方法以字符为单位进行输入输出。 其实字符流的本质也是字节流 只不过使用...

    Java字节流和字符流:
    Java字节流和字符流的主要区别是编码方式,字节流主要是基于二进制以字节为单位进行输入输出,字符流是Unicode编码的方法以字符为单位进行输入输出。

    其实字符流的本质也是字节流 只不过使用编码规定来约束字符和字节之间的对应关系。

    总而言之,一切都是字节流,其实没有字符流这个东西。字符只是根据编码集对字节流翻译之后的产物。

    https://www.zhihu.com/question/39262026

    展开全文
  • JAVA 字节流和字符流

    2015-06-08 14:30:11
    在整个IO 包中,流的操作就分两种 字节流 字节输出流 OutputStream、字节输入流 InputStream ...字符流,一个字符 = 两个字节 ...在java 中使用IO 操作必须按照以下的步骤完成: ...2、使用字节流字符流的子类

    在整个IO 包中,流的操作就分两种

    字节流

    字节输出流 OutputStream、字节输入流 InputStream

    字符流,一个字符 = 两个字节

    字符输出流 Writer、字符输入流是 Reader


    IO 操作的基本步骤

    在java 中使用IO 操作必须按照以下的步骤完成:

    1、使用File 找到一个文件

    2、使用字节流或字符流的子类为OutputStream、InputStream、Writer、Reader 进行实例化操作

    3、进行读或写的操作

    4、关闭:close(),在流的操作中最终必须进行关闭。


    字节输出流:OutputStream

    在java.io 包中 OutputStream 是字节输出流的最大父类


    1. public abstract cla OutputStream  
    2.   
    3. extends Object  
    4.   
    5. implements Closeable,Flushable  

    此类是一个抽象类,所以使用时需要依靠子类进行实例化操作

    如果此时要完成文件的输出操作,则使用FileOutputStream 为 OutputStream 进行实例化操作。

    OutputStream 提供了以下的写入数据方法:

    写入全部字节数组: public void write(byte[] b) throws IOException

    写入部份字节数组: public void write(byte[] b,int off,int len) throws IOException

    定入一个数据: public abstract void wirte(int b) throws IOException

    1. package org.ouputstreamdemo;  
    2.   
    3. import java.io.File;  
    4. import java.io.FileOutputStream;  
    5. import java.io.OutputStream;  
    6.   
    7. public class OutPutStreamDemo01 {  
    8.   
    9.     /** 
    10.      * @param args 
    11.      */  
    12.     public static void main(String[] args) throws Exception  {  
    13.         // TODO Auto-generated method stub  
    14.         File file = new File("D:"+File.separator+"demo.txt"); //要操作的文件  
    15.         OutputStream opts = new FileOutputStream(file); //声明字节输出流 通过子类实例化  
    16.         String str = "Hello World"//要输出的信息  
    17.                 byte b[] = str.getBytes();  //将String变为byte数组  
    18.                 opts.write(b); //写入数据  
    19.         opts.close(); //关闭  
    20.     }  
    21.   
    22. }  

    以上的操作是全部的字节数组内容输出,当然,也可以通过循环一个个的输出


    1. package org.ouputstreamdemo;  
    2.   
    3. import java.io.File;  
    4. import java.io.FileOutputStream;  
    5. import java.io.OutputStream;  
    6.   
    7. public class OutputStreamDemo02 {  
    8.   
    9.     /** 
    10.      * @param args 
    11.      */  
    12.     public static void main(String[] args) throws Exception {  
    13.         // TODO Auto-generated method stub  
    14.         File file = new File("D:"+File.separator+"demo.txt"); //要操作的文件  
    15.         OutputStream opts = new FileOutputStream(file); //声明字节输出流 通过子类实例化  
    16.         String str = "Hello World"//要输出的信息  
    17.         byte b[] = str.getBytes(); 将String变为byte数组  
    18.         for (int i=0;i<b.length;i++){  
    19.             opts.write(b[i]); //写入数据  
    20.         }  
    21.         opts.close(); //关闭  
    22.     }  
    23.   
    24. }  

    但是,以上执行的时候可以发现也会存在一些问题,每次执行完之后,所有的内容将会被新的内容替换。如果希望追加内容,则需要观察FileOutputStream类的构造方法:

    1. public FileOuputStream(File file,boolean append) throws FileNotFoundException  

    如果将append 的内容设置为true,则表示增加内容


    1. package org.ouputstreamdemo;  
    2.   
    3. import java.io.File;  
    4. import java.io.FileOutputStream;  
    5. import java.io.OutputStream;  
    6.   
    7. public class OutputStreamDemo02 {  
    8.   
    9.     /** 
    10.      * @param args 
    11.      */  
    12.     public static void main(String[] args) throws Exception {  
    13.         // TODO Auto-generated method stub  
    14.         File file = new File("D:"+File.separator+"demo.txt"); //要操作的文件  
    15.         OutputStream opts = new FileOutputStream(file,true); //声明字节输出流 通过子类实例化  
    16.         String str = "Hello World\r\n"//要输出的信息 "\r\n" 表示回车  
    17.         byte b[] = str.getBytes(); 将String变为byte数组  
    18.         for (int i=0;i<b.length;i++){  
    19.             opts.write(b[i]); //写入数据  
    20.         }  
    21.         opts.close(); //关闭  
    22.     }  
    23.   
    24. }  

    字节输入流:InputStream

    使用InputStream 可以读取输入流的内容,那么此类的定义如下:

    1. public abstract class InputStream  
    2.   
    3. extends Object  
    4.   
    5. implements Closeable  

    此类也属于一个抽象类,那么如果要想使用的话,则肯定还是依靠其子类,如果现在是文件操作则使用是FileInputStream,FileInputStream类的构造方法:

    public FileInputStream(File file) throws FileNotFoundException

    实例化之后就可以通过如下的方法取得数据:

    将内容读入到字节数组之中:public int read(byte[] b) throws IOException

    每次读一个数据:public abstract int read() throws IOException


    1. package org.inputstreamdemo;  
    2.   
    3. import java.io.File;  
    4. import java.io.FileInputStream;  
    5. import java.io.InputStream;  
    6.   
    7. public class InputStreamDemo01 {  
    8.   
    9.     /** 
    10.      * @param args 
    11.      */  
    12.     public static void main(String[] args) throws Exception {  
    13.         // TODO Auto-generated method stub  
    14.         File file =  new File("D:"+File.separator+"demo.txt"); //要操作的文件  
    15.         InputStream ipts = new FileInputStream(file); //字节输入流 通过子类进行实例化操作  
    16.         byte b[] = new byte[2000]; //开辟空间接收读取的内容  
    17.         int len = ipts.read(b); //将内容读入到byte数组中   
    18.         System.out.println(new String(b,0,len));//输出内容  
    19.         ipts.close();//关闭  
    20.     }  
    21.   
    22. }  

    以上是一种比较常见的读取形式,但是以上的代码有一个缺点,会受到开辟空间的限制。如果现在想动态的开辟数组的空间,则可以根据文件的大小来决定 。采用read()方法一个个的读取数据


    1. package org.inputstreamdemo;  
    2.   
    3. import java.io.File;  
    4. import java.io.FileInputStream;  
    5. import java.io.InputStream;  
    6.   
    7. public class InputStreamDemo02 {  
    8.   
    9.     /** 
    10.      * @param args 
    11.      */  
    12.     public static void main(String[] args) throws Exception {  
    13.         // TODO Auto-generated method stub  
    14.         File file =  new File("D:"+File.separator+"demo.txt"); //要操作的文件  
    15.         InputStream ipts = new FileInputStream(file); //字节输入流 通过子类进行实例化操作  
    16.         byte b[] = new byte[(int)file.length()]; //开辟空间接收读取的内容  
    17.         for (int i=0;i<b.length;i++){  
    18.             b[i] = (byte) ipts.read(); //一个个的读取数据  
    19.         }  
    20.         System.out.println(new String(b)); //输出内容,直接转换  
    21.         ipts.close(); //关闭  
    22.     }  
    23.   
    24. }  


    字符输出流:Writer

    Writer 类是在io包中操作字符的最大父类,主要功能是完成字符流的输出。Writer类的定义格式:


    1. public abstract class Writer  
    2.   
    3. extends Object  
    4.   
    5. implements Appendable,Closeable,Flushable  


    与OutputStream 一样,都属于抽象类,如果要进行文件中的保存,则使用FileWriter

    写入操作:public void write(String str) throws IOException,不用再转换


    1. package org.writerdemo;  
    2.   
    3. import java.io.File;  
    4. import java.io.FileWriter;  
    5. import java.io.Writer;  
    6.   
    7. public class WriterDemo01 {  
    8.   
    9.     /** 
    10.      * @param args 
    11.      */  
    12.     public static void main(String[] args) throws Exception {  
    13.         // TODO Auto-generated method stub  
    14.         File file = new File ("D:"+File.separator+"demo.txt"); //要操作的文件  
    15.         Writer wt = new FileWriter(file); //声明字符输出流 通过子类实例化  
    16.         String str = "Hello World\r\n"//要输出的信息  
    17.         wt.write(str);  //写入数据  
    18.         wt.close(); //关闭  
    19.           
    20.     }  
    21.   
    22. }  

    程序也可以进行内容的追加: public FileWriter(File file,bollean append) throws IOException


    1. package org.writerdemo;  
    2.   
    3. import java.io.File;  
    4. import java.io.FileWriter;  
    5. import java.io.Writer;  
    6.   
    7. public class WriterDemo01 {  
    8.   
    9.     /** 
    10.      * @param args 
    11.      */  
    12.     public static void main(String[] args) throws Exception {  
    13.         // TODO Auto-generated method stub  
    14.         File file = new File ("D:"+File.separator+"demo.txt"); //要操作的文件  
    15.         Writer wt = new FileWriter(file,true); //声明字符输出流 通过子类实例化 表示可以追加  
    16.         String str = "Hello World\r\n"//要输出的信息  
    17.         wt.write(str);  //写入数据  
    18.         wt.close(); //关闭  
    19.           
    20.     }  
    21.   
    22. }  


    字符输入流:Reader


    字符输入流与字节输入流不同的地方在与,使用的是char 数组。Reader类的定义:


    1. public abstract class Reader  
    2.   
    3. extends Object  
    4.   
    5. implements Readable,Closeable  


    是一个抽象类,要是现在进行文件的读取使用 FileReader

    读取的方法:

    读取一组字符: public int read(char[] cbuf) throws IOException

    读取一个个字符: public int read() throws IOException


    1. package org.readerdemo;  
    2.   
    3. import java.io.File;  
    4. import java.io.FileReader;  
    5. import java.io.Reader;  
    6.   
    7. public class ReaderDemo01 {  
    8.   
    9.     /** 
    10.      * @param args 
    11.      */  
    12.     public static void main(String[] args) throws Exception {  
    13.         // TODO Auto-generated method stub  
    14.         File file = new File("D:"+File.separator+"demo.txt"); //要操作的文件  
    15.         Reader rd = new FileReader(file); //字节输入流 通过子类进行实例化操作  
    16.         char str[] = new char[1024]; //开辟空间接收读取的内容  
    17.         int len = rd.read(str); 将内容读入到char 数组中  
    18.         System.out.println(new String(str,0,len)); 输出内容  
    19.   
    20.                 rd.close();  
    21.   
    22.   }}  


    以上完成了一个字符的输入流,那么当然也可以通过循环的方式,一个个的进行读取的操作


    1. package org.readerdemo;  
    2.   
    3. import java.io.File;  
    4. import java.io.FileReader;  
    5. import java.io.Reader;  
    6.   
    7. public class ReaderDemo01 {  
    8.   
    9.     /** 
    10.      * @param args 
    11.      */  
    12.     public static void main(String[] args) throws Exception {  
    13.         // TODO Auto-generated method stub  
    14.         File file = new File("D:"+File.separator+"demo.txt"); //要操作的文件  
    15.         Reader rd = new FileReader(file); //字节输入流 通过子类进行实例化操作  
    16.         char str[] = new char[(int) file.length()]; //开辟空间接收读取的内容  
    17.         for (int i =0;i<str.length;i++){  
    18.             str[i]=(char) rd.read(); //一个个的读取数据  
    19.         }  
    20.         System.out.println(new String(str)); //输出内容,直接转换  
    21.                 rd.close();  
    22.          }  
    23.   
    24. }  


    字节流与字符流的区别

    以上操作的代码有两组,那么实际中应该使用那组更好呢?

    为了看清楚区别,下面以一对简单的程序为例,此程序就是向文件中保存内容。

    范例:使用OutputStream 完成


    1. package org.ouputstreamdemo;  
    2.   
    3. import java.io.File;  
    4. import java.io.FileOutputStream;  
    5. import java.io.OutputStream;  
    6.   
    7. public class OutputStreamDemo02 {  
    8.   
    9.     /** 
    10.      * @param args 
    11.      */  
    12.     public static void main(String[] args) throws Exception {  
    13.         // TODO Auto-generated method stub  
    14.         File file = new File("D:"+File.separator+"demo.txt"); //要操作的文件  
    15.         OutputStream opts = new FileOutputStream(file); //声明字节输出流 通过子类实例化  
    16.         String str = "Hello World"//要输出的信息  
    17.         byte b[] = str.getBytes(); 将String变为byte数组  
    18.         for (int i=0;i<b.length;i++){  
    19.             opts.write(b[i]); //写入数据  
    20.         }  
    21.     }  
    22.   
    23. }  


    以上的程序执行时没有关闭发现内容可以正常的输出,下面再看字符流


    1. package org.writerdemo;  
    2.   
    3. import java.io.File;  
    4. import java.io.FileWriter;  
    5. import java.io.Writer;  
    6.   
    7. public class WriterDemo01 {  
    8.   
    9.     /** 
    10.      * @param args 
    11.      */  
    12.     public static void main(String[] args) throws Exception {  
    13.         // TODO Auto-generated method stub  
    14.         File file = new File ("D:"+File.separator+"demo.txt"); //要操作的文件  
    15.         Writer wt = new FileWriter(file); //声明字符输出流 通过子类实例化  
    16.         String str = "Hello World\r\n"//要输出的信息  
    17.         wt.write(str);  //写入数据  
    18.       
    19.     }  
    20.   
    21. }  

    以上的字符流并没有关闭。但是执行之后文件中并不存在内容,意味着没有输出。

    但是现在使用Writer 类中的一个访法:flush()。


    1. package org.writerdemo;  
    2.   
    3. import java.io.File;  
    4. import java.io.FileWriter;  
    5. import java.io.Writer;  
    6.   
    7. public class WriterDemo01 {  
    8.   
    9.     /** 
    10.      * @param args 
    11.      */  
    12.     public static void main(String[] args) throws Exception {  
    13.         // TODO Auto-generated method stub  
    14.         File file = new File ("D:"+File.separator+"demo.txt"); //要操作的文件  
    15.         Writer wt = new FileWriter(file); //声明字符输出流 通过子类实例化  
    16.         String str = "Hello World\r\n"//要输出的信息  
    17.         wt.write(str);  //写入数据  
    18.             wt.flush(); //刷新  
    19.     }  
    20.   
    21. }  

    实际上来讲,最早的操作中,并没有刷新,但是因为使用了关闭,所以表示会强制刷新,刷新的是缓冲区(内存)

    得出这样的一个结论:

    字节流在操作的时候是直接与文件本身关联,不使用缓冲区

    字节 --> 文件

    字符流在操作的时候是通过缓冲区与文件操作

    字符 --> 缓冲 --> 文件

    综合比较来讲,在传输或者在硬盘上保存的内容都是以字节的形式存在的,所以字节流的操作较多,但是在操作中文的时候字符流比较好使

    展开全文
  • 主要介绍了JAVA 字节流和字符流的的相关资料,文中讲解非常的细致,代码帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • 可以使用流 访问文件系统上的文件。在最低的级别上,流允许程序接收来自数据源的字节,或者允许将输出发送到目的地。一些流可以处理所有类型的 16 位字符(类型 Reader ...在最高级别的抽象中,有一些字符流 ...

    可以使用流 访问文件系统上的文件。在最低的级别上,流允许程序接收来自数据源的字节,或者允许将输出发送到目的地。一些流可以处理所有类型的 16 位字符(类型 Reader 和 Writer)。而其他一些流则只能处理 8 位字符(类型 InputStream 和 OutputStream)。在这些分层结构中,有几种风格的流(所有流都可以在 java.io 包中找到)。在最高级别的抽象中,有一些字符流 和字节流。

    字节流读取(InputStream 及其子类)并编写(OutputStream 及其子类)8 位字节。换句话说,可以将字节流看作是一种更原始的流。因此,也就不难理解为什么关于基本 Java 语言类的 Java.sun.com 教程说字节流通常用于二进制数据,比如说图像。以下是一个选定的字节流列表:

    FileInputStream 从某一文件中读取文件

    FileOutputStream 将字节写入某个文件中。

    ByteArrayInputStream

    ByteArrayOutputStream

    从某个内存数组中读取字节,以及将字节写入某个内存数组中。

    字符流可以读取(Reader 及其子类)和写入(Writer 及其子类)16 位的字符。子类也可以从数据接收器 中读取或写入数据,或者处理转换中的字节。以下是一个选定的字符流列表:

    StringReader

    StringWriter

    这些流从内存中的 String 中读取或写入字符。

    InputStreamReader

    InputStreamWriter(及其子类 FileReader

    FileWriter)

    是字节流与字符流之间的桥梁。Reader 风格(flavor)从字节流读取字节,并将它们转换成字符。而 Writer 风格将字符转换成字节,并将它们放在字节流上。

    BufferedReader 和 BufferedWriter

    在缓冲数据的同时读取或写入另个流,它使读取或写入操作更加有效。可以用缓冲的流包装 另一个流。

    存在着几种读取和写入 File 的方法,但是通常,最简便的方法如下所示:

    在 File 上创建一个 FileWriter。

    将 FileWriter 包装到一个 BufferedWriter 中。

    只要有必要,可以在 BufferedWriter 上调用 write() 来编写 File 的内容,通常每个行都是以一个行终止符(即 \n)结尾的。

    在 BufferedWriter 上调用 flush() 来清空它。

    关闭 BufferedWriter,如果有必要,还需要清除它

    展开全文
  • java 字节流和字符流

    2014-04-23 13:50:11
    一、字节流 二、字符流 三、比较

    一、利用File类生成文件

    例如:

    import java.io.File;
    import java.io.IOException;
    
    public class test {
    	public static void main(String args[]) throws IOException{
    		File fl = new File("F:\\test\\file");//生成文件的父路径
    		File file = new File(fl, "test.txt");//实例化File类,并变量引用;
    		/*******************首先,对路径进行判断,如果存在,输出路径名;如果不存在,创建新的路径名******************************/
    		if(fl.exists()){
    			String str = fl.getName();
    			System.out.println(str);
    		}
    		else{
    			try{
    				fl.mkdirs();//因为要创建多个文件夹,所以用mkdirs(),而不用mkdir();
    				System.out.println("创建test和file文件夹成功");
    			}catch(Exception e){
    				e.printStackTrace();
    			}
    		}
    		/****************然后,对文件进行判断,如果存在,输出文件名;如果不存在,创建文件*******************/
    		if(file.exists()){
    			String str = file.getName();
    			System.out.println(str);
    		}
    		else{
    			try{
    				file.createNewFile();
    				System.out.println("生成文件test.txt");
    			}catch(Exception e){
    				e.printStackTrace();
    			}
    		}
    	}
    
    }


    IO的分类其实有很多种,如果是按是否堵塞,可以分为堵塞(BIO)和非堵塞(NIO);如果是按照读取来源,可以分文件IO和socket IO,而对于处理对象,可以氛围字节IO和字符IO。另外,有部分辅助的IO,主要是用于处理缓存(例如BufferedReader)或者字符串处理的(PrintWriter)。


    二、字节流

    在上面例子中添加FileOutputStream和FileInputStream内容,例如:

    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class test {
    	public static void main(String args[]) throws IOException{
    		File fl = new File("F:\\test\\file");//生成文件的父路径
    		File file = new File(fl, "test.txt");//实例化File类,并变量引用;
    		/*******************首先,对路径进行判断,如果存在,输出路径名;如果不存在,创建新的路径名******************************/
    		if(fl.exists()){
    			String str = fl.getName();
    			System.out.println(str);
    		}
    		else{
    			try{
    				fl.mkdirs();//因为要创建多个文件夹,所以用mkdirs(),而不用mkdir();
    				System.out.println("创建test和file文件夹成功");
    			}catch(Exception e){
    				e.printStackTrace();
    			}
    		}
    		/****************然后,对文件进行判断,如果存在,输出文件名;如果不存在,创建文件*******************/
    		if(file.exists()){
    			String str = file.getName();
    			System.out.println(str);
    		}
    		else{
    			try{
    				file.createNewFile();
    				System.out.println("生成文件test.txt");
    			}catch(Exception e){
    				e.printStackTrace();
    			}
    		}
    		/*********利用FileOutputStream和FileInputStream分别往文件test.txt中写数据和读取数据****************/
    		byte [] data = "hello world!".getBytes();//getBytes()将字符转为字节数组
    		FileOutputStream out = new FileOutputStream(file, true);
    		FileInputStream in = new FileInputStream(file);
    		try{			
    			out.write(data);//往文件test.txt中写数据data内容
    			int content;
                             while((content = in.read()) != -1){// 逐个数据读取文件test.txt中的数据
                                    System.out.print((char)content);
    			}
    			System.out.println("成功写入和读取数据");
    			
    		}catch(Exception e){
    			e.printStackTrace();
    		}
    		finally{
    			out.close();
    			in.close();
    		}
    		
    	}
    
    }


    三、字符流

    例如:

    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    
    public class test {
    	public static void main(String args[]) throws IOException{
    		File fl = new File("F:\\test\\file");//生成文件的父路径
    		File file = new File(fl, "test.txt");//实例化File类,并变量引用;
    		/*******************首先,对路径进行判断,如果存在,输出路径名;如果不存在,创建新的路径名******************************/
    		if(fl.exists()){
    			String str = fl.getName();
    			System.out.println(str);
    		}
    		else{
    			try{
    				fl.mkdirs();//因为要创建多个文件夹,所以用mkdirs(),而不用mkdir();
    				System.out.println("创建test和file文件夹成功");
    			}catch(Exception e){
    				e.printStackTrace();
    			}
    		}
    		/****************然后,对文件进行判断,如果存在,输出文件名;如果不存在,创建文件*******************/
    		if(file.exists()){
    			String str = file.getName();
    			System.out.println(str);
    		}
    		else{
    			try{
    				file.createNewFile();
    				System.out.println("生成文件test.txt");
    			}catch(Exception e){
    				e.printStackTrace();
    			}
    		}
    		/*********字节流操作:利用FileOutputStream和FileInputStream分别往文件test.txt中写数据和读取数据****************/
    		byte [] data = "hello world".getBytes();//getBytes()将字符转为字节数组
    		FileOutputStream out = new FileOutputStream(file, true);
    		FileInputStream in = new FileInputStream(file);
    		try{			
    			out.write(data);//往文件test.txt中写数据data内容
    			int content;
                            while((content = in.read()) != -1){// 逐个数据读取文件test.txt中的数据
                                     System.out.print((char)content);
                           }
                           System.out.println("成功写入和读取数据");
    			
    		}catch(Exception e){
    			e.printStackTrace();
    		}
    		finally{
    			out.close();
    			in.close();
    		}
    		/*********字符流操作:利用FileWriter和FileReader分别往文件test.txt中写数据和读取数据****************/
    		String data1 = " welcome to you ";
    		FileWriter filewriter = new FileWriter(file, true);
    		FileReader filereader = new FileReader(file);
    		BufferedReader br = new BufferedReader(filereader);
    		try{
    			filewriter.write(data1);
    			String line = br.readLine();
    			while(line != null){
    				System.out.print(line);
    				line = br.readLine();
    			}
    		}catch(Exception e){
    			e.printStackTrace();
    		}
    		finally{
    			filewriter.close();
    			filereader.close();
    		}
    	}
    
    }



    四、字节流和字符流比较

    字节流 :InputStream OutputStream
    字符流 :Reader Writer
    这四个类都是抽象类 ,不能直接new对象。

    具体实现 :
    字节流: FileInputStream FileOutputStream
    字符流:FileReader FileWriter 

    字符流处理的单元为2个字节的Unicode字符,分别操作字符、字符数组或字符串,而字节流处理单元为1个字节,操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的,所以它对多国语言支持性比较好!如果是音频文件、图片、歌曲,就用字节流好点,如果是关系到中文(文本)的,用字符流好点。
    所有文件的储存是都是字节(byte)的储存,在磁盘上保留的并不是文件的字符而是先把字符编码成字节,再储存这些字节到磁盘。在读取文件(特别是文本文件)时,也是一个字节一个字节地读取以形成字节序列。
    字节流可用于任何类型的对象,包括二进制对象,而字符流只能处理字符或者字符串; 字节流提供了处理任何类型的IO操作的功能,但它不能直接处理Unicode字符,而字符流就可以。

    字节流转换成字符流可以用 InputSteamReader OutputStreamWriter转换成BufferdReader BufferedWriter;BufferdReader BufferedWriter具有缓冲区。

    字节流与和字符流的使用非常相似,两者除了操作代码上的不同之外。实际上字节流在操作时本身不会用到缓冲区(内存),是文件本身直接操作的,而字符流在操作时使用了缓冲区,通过缓冲区再操作文件


    详细过程参考博文:http://blog.csdn.net/cynhafa/article/details/6882061

    展开全文
  • Java字节流和字符流的区别首先我们先大概总结一下前面学习的内容,可分为以下几点:以 Stream 结尾都是字节流,Reader 和 Writer 结尾都是字符流。InputStream 是所有字节输入流的父类,OutputStream 是所有字节输出...
  • Java字节流和字符流的区别 首先我们先大概总结一下前面学习的内容,可分为以下几点: 以 Stream 结尾都是字节流,Reader 和 Writer 结尾都是字符流。 InputStream 是所有字节输入流的父类,OutputStream 是所有字节...
  • java 字节流和字符流的区别 转载 转载自:http://blog.csdn.net/cynhafa/article/details/6882061 java 字节流和字符流的区别 字节流与和字符流的使用非常相似,两者除了操作代码上的不同之外,是否还有...
  • Java中的字节流有助于执行8位字节的输入输出操作;它以stream结尾。换句话说,它逐字节处理数据,适用于处理二进制文件等原始数据。 (推荐学习:java课程)字节流操作最常用的类是FileInputStream...
  • Java中的字节流有助于执行8位字节的输入输出操作;它以stream结尾。换句话说,它逐字节处理数据,适用于处理二进制文件等原始数据。 (推荐学习:java课程)字节流操作最常用的类是FileInputStream...
  • Java字节流和字符流的区别 首先我们先大概总结一下前面学习的内容,可分为以下几点: 以 Stream 结尾都是字节流,Reader 和 Writer 结尾都是字符流。 InputStream 是所有字节输入流的父类,OutputStream 是所有字节...
  • java 字节流和字符流的区别 字节流与和字符流的使用非常相似,两者除了操作代码上的不同之外,是否还有其他的不同呢?实际上字节流在操作时本身不会用到缓冲区(内存),是文件本身直接操作的,而字符流在操作时...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,534
精华内容 4,613
关键字:

java字节流和字符流

java 订阅