1. 云图网首页
  2. 技术专区
  3. 编程笔记

JAVA基础之字节流与字符流详解编程语言

• 编程笔记

个人理解：

　　IO流就是将数据进行操作的方式，因为编码的不同，所以对文件的操作就产生两种。最好用字节流，为了方便看汉字等，（已经确定文字的话）可以使用字符流。每个流派也就分为输入和输出，这样就可以产生复制文件了！需要注意的是Flush() 是清空，而不是刷新啊。
　　一般主要用在IO中，即清空缓冲区数据，就是说你用读写流的时候，其实数据是先被读到了内存中，然后用数据写到文件中，当你数据读完的时候不代表你的数据已经写完了，因为还有一部分有可能会留在内存这个缓冲区中。这时候如果你调用了 close()方法关闭了读写流，那么这部分数据就会丢失，所以应该在关闭读写流之前先flush()，先清空数据。

一、IO流：

1、JAVA对数据的操作是通过流的方式，JAVA用于操作数据流的类都在IO包中；

2、IO用于在设备间进行数据传输的操作；

3、分类：

①、流向：

　　　　输入流（读取数据）

　　　　输出流（写出数据）

②、数据类型：

　　　　字节流（可以操作任何数据）：

　　　　　　　　字节输入流

　　　　　　　　字节输出流

　　　　字符流：　　

　　　　　　　　字符输入流

　　　　　　　　字符输出流

注意：

　　如果没明确说明按照什么分，默认按照数据类型分；

　　除非文件用windows自带的记事本打开我们能够读懂，才采用字符流，否则建议使用字节流。

4、IO程序书写：

　　使用前，导入IO包中的异常；

　　使用时，可进行IO异常的处理；

　　使用后，释放资源。

二、字节流：

1、字节输出流：outputStream

　　子类：文件输出流FileOutputStream用于将数据写入File的输出流。

import java.io.FileNotFoundException; 
import java.io.FileOutputStream; 
import java.io.IOException; 
 
public class Demo01 { 
    public static void main(String[] args) throws IOException { 
        //创建字节输出流对象(因为是输出，必须有数据所以必须是文件，不能是文件夹） 
        //构造方法指定文件地址时，如果存在，则覆盖！如果不存在，则创建! 
    FileOutputStream fos=new FileOutputStream("D://java//a.txt"); 
    //向文件中写入一个字节       write (直接写数字 会对应其ASCII值）0-48  a-97 A-65 
    fos.write(49); 
    fos.write(48); 
    fos.write(48); 
    //向文件中写入一个字节数组 write(byte[] b)正的走表，负的是汉字，两个字节组成一个汉字！多的一个字节显示？ 
    byte[] bytes={-66,-67,-68,-69,-70}; 
    //fos.write(bytes); 
    fos.write(bytes,2,2);//从第一个数字开始传第二个数字的个数 
    //释放资源 
    fos.close(); 
    }     
}
import java.io.FileNotFoundException; 
import java.io.FileOutputStream; 
import java.io.IOException; 
 
public class Demo02 { 
    public static void main(String[] args) throws IOException { 
        //创建字节输出流(开启续写功能）默认是flase 
        FileOutputStream fos=new FileOutputStream("D://java//b.txt",true); 
        //字符串转字节数组 getByte() 
        fos.write("abc".getBytes()); 
        //换行 /r/n 
        fos.write("/r/n换行了".getBytes()); 
        //释放资源 
        fos.close(); 
    } 
}

异常处理：

　　

import java.io.FileNotFoundException; 
import java.io.FileOutputStream; 
import java.io.IOException; 
 
public class Demo03 { 
    public static void main(String[] args)  { 
        //处理异常:close必须执行所以放在finally里面， 
        //但是设计fos定义问题，所以先在外面进行赋值定义 
        FileOutputStream fos=null; 
        try { 
            fos=new FileOutputStream("D://java//b.txt",true); 
            fos.write("abc".getBytes()); 
        } catch (IOException e) { 
            // TODO Auto-generated catch block 
            e.printStackTrace(); 
        }finally{ 
            try { 
                fos.close(); 
            } catch (IOException e) { 
                // TODO Auto-generated catch block 
                e.printStackTrace(); 
            } 
        } 
    } 
}

2、字节输入流：InputStream

　子类：FileInputStream文件输入流

import java.io.FileInputStream; 
import java.io.FileNotFoundException; 
import java.io.IOException; 
public class Demo04 { 
    public static void main(String[] args) throws IOException { 
        //创建字节输入流(明确从哪个文件中读取数据） 
        FileInputStream fis=new FileInputStream("D://java//d.txt"); 
        //读取一个字节 
        /*int len=fis.read(); 
        System.out.println((char)len);//将字节的int类型强转成char类型 
        len=fis.read(); 
        System.out.println((char)len);//将字节的int类型强转成char类型 
        len=fis.read(); 
        System.out.println((char)len);//将字节的int类型强转成char类型 
        len=fis.read(); 
        System.out.println((char)len);//将字节的int类型强转成char类型 
        len=fis.read(); 
        System.out.println((char)len);//将字节的int类型强转成char类型 
        len=fis.read(); 
        System.out.println(len);//一共5个字节，当读取到没有值的时候，返回len值为-1*/ 
        //一个字节一个字节的读取文件所有数据 
        int len=0; 
        while((len=fis.read())!=-1){ 
            System.out.println((char)len); 
        } 
        //释放资源 
        fis.close(); 
    } 
}    
import java.io.FileInputStream; 
import java.io.IOException; 
 
public class Demo05 { 
        public static void main(String[] args) throws IOException { 
            //明确数据源 
            FileInputStream fis=new FileInputStream("D://java//d.txt"); 
            //创建字节数组 
            byte[] bytes=new byte[2]; 
        /*    //读取一个字节数组 
            int len= fis.read(bytes); 
            //实际读取的有效字节数 
            System.out.println(len); 
            //字节数组转字符串  
            System.out.println(new String(bytes));*/ 
            //循环读取字节数组 
            int len=0; 
            while((len=fis.read(bytes))!=-1){ 
                System.out.println(new String(bytes,0,len));//从0开始 截取len个 
            } 
            fis.close(); 
        } 
}

3、复制文件：

　　

import java.io.FileInputStream; 
import java.io.FileNotFoundException; 
import java.io.FileOutputStream; 
import java.io.IOException; 
 
public class Copy { 
    public static void main(String[] args) throws IOException { 
        //明确数据源 
        FileInputStream fis=new FileInputStream("D://java//d.txt"); 
        //明确目的地 
        FileOutputStream fos=new FileOutputStream("D://java//e.txt"); 
        //开始复制 
        int len=0; 
        while((len=fis.read())!=-1){ 
            fos.write(len); 
        } 
        //释放资源 
        fis.close(); 
        fos.close(); 
    } 
}

三、字符流：

1、字符流介绍：

　　对比字节流（可以操作任何数据）

　　①、字节流操作中文数据不是特别的方便，所以就出现了转换流；

　　　　转换流的作用就是把字节流转换字符流来使用；

　　②、转换流其实是一个字符流：

　　　　字符流 = 字节流 + 编码表

2、编码表：

　　①、ASCII表：一个字节中的7位就可以表示，对应的字节都是正数。

　　②、GBK：目前最常用的中文码表，2万的中文和符号。用两个字节表示，其中一部分文字，第一个字节开头是1，第二个字节开头是0；

　　③、unicode：国际标准编码表；无论是什么文字，都用两个字节存储：

　　　　　　char类型就是这个码表，占两个字节。

　　　　utf-8基于unicode，一个字节就可以存储数据，不要用两个字节存储，而且这个码表更加的标准化。

3、字符输入流：Reader

　　子类FileReader文件输入流

　　

import java.io.FileNotFoundException; 
import java.io.FileReader; 
import java.io.IOException; 
 
public class Demo02 { 
    public static void main(String[] args) throws IOException { 
        //创建字符输入流 
        FileReader fr=new FileReader("D://java//d.txt"); 
        //创建字符数组 
        char[] ch=new char[1024]; 
        //一个字符数组一个字符数组读 
        int len=0; 
        while((len=fr.read(ch))!=-1){ 
            System.out.println(new String(ch,0,len)); 
        } 
        //释放资源 
        fr.close(); 
    } 
}

4、字符输出流：Writer

　　子类：FileWriter

import java.io.FileWriter; 
import java.io.IOException; 
 
public class Demo03 { 
    public static void main(String[] args) throws IOException { 
        //创建字符输出流 
        FileWriter fw=new FileWriter("D://java//d.txt"); 
        //写入一个字符 
        fw.write(100); 
        fw.flush(); 
        //写入一个字符串 
        fw.write("你好啊"); 
        fw.flush(); 
        //写入一个字符数组 
        char[] ch={'a','1','r'}; 
        fw.write(ch); 
        fw.flush(); 
        //释放资源 
        fw.close(); 
    } 
}

5、Flush()和close()的区别：

　　flush():将流中的缓冲区缓冲的数据刷新到目的地中，刷新后，流还可以继续使用。（写入一次就刷新一次，主要用于有可能数据过多的时候，以免承受不了）

　　close():关闭资源，但在关闭前会将缓冲区中的数据先刷新到目的地，否则丢失数据，然后在关闭流。流不可以使用。如果写入数据多，一定要一边写一边刷新，最后一次可以不刷新，由close完成刷新并关闭。

6、复制文件：

import java.io.FileReader; 
import java.io.FileWriter; 
import java.io.IOException; 
 
public class Copy { 
    public static void main(String[] args) throws IOException { 
        //明确数据源 
        FileReader fr=new FileReader("D://java//d.txt"); 
        //明确目的地 
        FileWriter fw=new FileWriter("D://java//d.txt"); 
        //开始复制 
        int len=0; 
        while((len=fr.read())!=-1){ 
            fw.write(len); 
            fw.flush(); 
        } 
        fr.close(); 
        fw.close(); 
    } 
}

 

原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/16573.html

赞 (0)
0
上一篇 2021年7月19日
下一篇 2021年7月19日

相关推荐

发表回复

登录后才能评论