Java学习笔记（十四）

系统管理员 2023-09-30 09:06 33阅读 0赞

**目录**

一：字节流（续）

二：字符流

--------------------

## 一：字节流（续） ##

**1.1 字节缓冲流**

>  *  BufferOutputStream：该类实现缓冲输出流。通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用。
>  *  BufferInputStream:创建BufferedputStream将创建一个内部缓冲区数组。当从流中读取或跳过字节，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节  
>

构造方法：

>  *  字节缓冲输出流：BufferOutputStream（OutputStream out）
>  *  字节缓冲输入流：BufferedInputStream（InputStream in）

为什么构造方法需要的是字节流，而不是具体的文件或者路径呢？

字节缓冲流仅仅提供缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作。

import java.io.*;
    public class Main {
    
        public static void main(String[] args) throws IOException {
            //字节缓冲输出流  BufferedOutputStream(OutputStream output)
        /*BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("mokuai-06\\bos.txt"));
    
        //写数据
            bos.write("hello\n".getBytes());
            bos.write("world\n".getBytes());
            //释放资源
            bos.close();
        }*/
    
            //字节缓冲输入流：BufferedInputStream(InputStream input)
           InputStream in;
           BufferedInputStream bis=new BufferedInputStream(new FileInputStream("mokuai-06\\bos.txt"));
    
           //一次读取一个字节数据
            /*int by;
            while ((by=bis.read())!=-1){
                System.out.print((char)by);
            }*/
    
            //一次读取一个字节数组数据
            byte[] bys=new byte[1024];
            int len;
            while((len=bis.read(bys))!=-1){
                System.out.print(new String(bys,0,len));
            }
    
            //释放资源
            bis.close();
        }
    }

--------------------

**1.2 案例：字节流复制视频，并且比较耗时时间**

import java.io.*;
    
    public class Main1 {
        public Main1() throws FileNotFoundException {
        }
    
        public static void method1() throws IOException {
           // 1.基本字节流一次读写一个字节
            FileInputStream fis=new FileInputStream("D:\\IT\\字节流复制视频.mp4");
            FileOutputStream fos=new FileOutputStream("mokuai-06\\字节流复制视频.mp4");
    
            int by;
            while((by=fis.read())!=-1){
                fos.write(by);
            }
            fis.close();
            fos.close();
        }
        public static void method2() throws IOException {
           // 2.基本字节流一次读写一个字节数组
            FileInputStream fis=new FileInputStream("D:\\IT\\字节流复制视频.mp4");
            FileOutputStream fos=new FileOutputStream("mokuai-06\\字节流复制视频.mp4");
    
            byte[] bys=new byte[1024];
            int len;
            while((len=fis.read(bys))!=-1){
                fos.write(bys,0,len);
            }
            fis.close();
            fos.close();
        }
        public static void method3() throws IOException {
           // 3.字节缓冲流一次读写一个字节
            BufferedInputStream bis=new BufferedInputStream(new FileInputStream("D:\\IT\\字节流复制视频.mp4"));
            BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("mokuai-06\\字节流复制视频.mp4"));
            int by;
            while((by=bis.read())!=-1){
                bos.write(by);
            }
            bis.close();
            bos.close();
    
        }
        public static void method4() throws IOException {
            // 4.字节缓冲流一次读写一个字节数组
            BufferedInputStream bis=new BufferedInputStream(new FileInputStream("D:\\IT\\字节流复制视频.mp4"));
            BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("mokuai-06\\字节流复制视频.mp4"));
            byte[] by=new byte[1024];
            int len;
            while((len=bis.read(by))!=-1){
                bos.write(by,0,len);
            }
            bis.close();
            bos.close();
    
        }
    
        public static void main(String[] args) throws IOException{
            //案例：复制视频
    
            /*思路：
                   1.根据数据源创建字节输入流对象
                   2.根据目的地创建字节输入流对象
                   3.读写数据，复制图片（一次读取一个字节数组，一次写入一个字节数组）
    
              四种方式实现复制视频。并记录每种方式复制视频的时间
              1.基本字节流一次读写一个字节       共耗时534608毫秒
              2.基本字节流一次读写一个字节数组    共耗时661毫秒
              3.字节缓冲流一次读写一个字节        共耗时526毫秒
              4.字节缓冲流一次读写一个字节数组     共耗时117毫秒
    
            * */
    
    
            //记录开始时间
            long startTime=System.currentTimeMillis();
    
            //复制视频
            method4();
    
            //记录结束时间
            long endTime=System.currentTimeMillis();
            System.out.println("共耗时"+(endTime-startTime)+"毫秒");
    
        }
    }

--------------------

## **二：字符流** ##

**2.1 为什么会出现字符流**

> 由于字节流操作中午不是特别的方便，所以java就提供字符流
> 
> 字符流=字节流+编码表
> 
> 用字节流复制文本文件是，文本文件也会有中文，但是没有问题，原因是最终底层操作会自动进行字节凭接成中文，如何识别是中文呢？
> 
> （汉字在存储的时候，无论选择哪种编码存储，第一个字节都是负数。）

--------------------

import java.io.UnsupportedEncodingException;
    import java.util.*;
    class Main1{
        /*
        * 一个汉字储存：
        *      如果是GBK编码，占用2个字节
        *      如果是UTF——8编码，占用3个字节
        * */
        public static void main(String[] args) throws UnsupportedEncodingException {
            String str1="abc";
            String str2="中国";
    
            byte[] bys1=str1.getBytes();
            byte[] bys2=str2.getBytes("UTF-8");
            byte[] bys3=str2.getBytes("GBK");
            System.out.println(Arrays.toString(bys1));//[97, 98, 99]
            System.out.println(Arrays.toString(bys2));//[-28, -72, -83, -27, -101, -67]
            System.out.println(Arrays.toString(bys3));//[-42, -48, -71, -6]
        }
    }

--------------------

2.2 编码表

基础知识：

>  *  计算机中储存的信息都是用二进制数表示的；我们在屏幕上看到的英文、汉字等字符是二进制数转换之后的结果。
>  *  按照某种规则，将字符存储到计算机中，称为编码。泛指，将存储在计算机中的二进制数按照某种规则解析处理，称为解码。这里强调一些：按照A编码存储，必须按照A编码解析，主要才能显示正确的文本符号。否则就会导致乱码现象。
> 
> 字符编码：就是一套自然语言的字符与二进制数自检的对应规则（A,65）

字符集：

>  *  是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。
>  *  计算机要准确的存储和识别各种字符集符号，就需要进行字符编码，一套字符集必然至少有一套字符编码。
> 
> 常见字符集有ASCII字符集、GBXXX字符集、Unicode字符集等。

--------------------

![420cf03a0b214a70b498953ec6864dfb.png][]

--------------------

![3308f991d95e46f0bfbd57a2c90844e3.png][]

--------------------

![2c71ac0e7bc64d108a7a23dbc80274c0.png][]

--------------------

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmlhWGluZ05hc2hpc2h1YQ_size_15_color_FFFFFF_t_70_g_se_x_16][]

**小结：采用何种规则编码，就要采用对应规则解码，否则就会出现乱码。**

--------------------

**2.3 字符串中的编码解码问题**

> 编码：
> 
>  *  byte\[\] getBytes():使用平台的默认字符集将该String编码为一系列字节，将结果存储到新的字节数组中。
>  *  byte\[\] getBytes(String charsetName):使用指定的字符集将该String编码为一系列字节，将结果存储到新的字节数组中。

--------------------

import java.io.UnsupportedEncodingException;
    import java.util.*;
    class Main1{
        public static void main(String[] args) throws UnsupportedEncodingException {
            //编码:
    
            //定义一个字符串
            String s="中国";
            byte[] bys=s.getBytes();//[-28, -72, -83, -27, -101, -67]---默认字符集
    
            byte[] bys1=s.getBytes("UTF-8");//[-28, -72, -83, -27, -101, -67]---"UTF-8"字符集
    
            byte[] bys2=s.getBytes("GBK");//[-42, -48, -71, -6]---"GBK"字符集
    
    
            System.out.println(Arrays.toString(bys));
            System.out.println(Arrays.toString(bys1));
            System.out.println(Arrays.toString(bys2));
    
        }
    }

--------------------

> 解码：
> 
>  *  String(byte\[\] bytes):通过使用平台默认字符集解码指定的字节数组来构造新的String.
>  *  String(byte\[\] bytes,String charsetName):通过指定的字符集解码指定的字节数组来构造新的String。

--------------------

import java.io.UnsupportedEncodingException;
    class Main1{
        public static void main(String[] args) throws UnsupportedEncodingException {
            //解码:
            String s="中国";
            //
            byte[] bys=s.getBytes();//[-28, -72, -83, -27, -101, -67]---默认字符集
    
            byte[] bys1=s.getBytes("UTF-8");//[-28, -72, -83, -27, -101, -67]---"UTF-8"字符集
    
            byte[] bys2=s.getBytes("GBK");//[-42, -48, -71, -6]---"GBK"字符集
    
            String s1=new String(bys);
            String s2=new String(bys1,"UTF-8");
            String s3=new String(bys2,"GBK");
            System.out.println(s1);//中国
            System.out.println(s2);//中国
            System.out.println(s3);//中国
    
    
        }
    }

--------------------

**2.4 字符流中的编码解码问题**

字符流抽象基类

*  Reader：字符输入流的抽象类
 *  Writer：字符输出流的抽象类

字符流中和编码解码问题相关的两个类：

>  *  **InputStreamReader**是从字节流到字符流的桥梁：它读取字节，并使用指定的`charset`将其解码为字符。 它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。
>     
>     每个调用InputStreamReader的read（）方法之一可能会导致从底层字节输入流读取一个或多个字节。 为了使字节有效地转换为字符，可以从底层流读取比满足当前读取操作所需的更多字节。
>  *  **OutputStreamWriter**是从字符流到字节流的桥梁：使用指定的`charset`将写入的字符编码为字节。 它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。
>     
>     每次调用write（）方法都会使编码转换器在给定的字符上被调用。 所得到的字节在写入底层输出流之前累积在缓冲区中。 请注意，传递给write（）方法的字符不会缓冲。

--------------------

**InputStreamReader（构造方法）：**

**![8a1e0c2fb0e24ad5b9456910b57d09bd.png][]**

--------------------

**OutputStreamWriter（构造方法）：**

**![b3d62b470cad4137844e61ade8a70944.png][]**

--------------------

import java.io.*;
    
    class Main1{
        public static void main(String[] args) throws IOException {
    
          //OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("mokuai-06\\osw.txt"));//创建一个使用默认字符编码的OutputStreamWrite
    
           // OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("mokuai-06\\osw.txt"),"UTF-8");//创建一个使用命名字符集的OutputStreamWrite
    
            OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("mokuai-06\\osw.txt"),"GBK");//创建一个使用命名字符集的OutputStreamWrite        ---------�й�
    
            osw.write("中国");
    
            osw.close();
    
    
    
           // InputStreamReader isr=new InputStreamReader(new FileInputStream("mokuai-06\\osw.txt"));//创建一个使用默认字符编码的InputStreamReader--�й�
    
    
            //InputStreamReader isr=new InputStreamReader(new FileInputStream("mokuai-06\\osw.txt"),"UTF-8");//创建一个使用命名字符集的InputStreamReader--�й�
    
            InputStreamReader isr=new InputStreamReader(new FileInputStream("mokuai-06\\osw.txt"),"GBK");//创建一个使用命名字符集的InputStreamReader--中国
    
            int len;
            while((len=isr.read())!=-1){
                System.out.print((char)len);
            }
            isr.close();
    
    
    
        }
    }

**2.5 字符流写数据的5中方式**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmlhWGluZ05hc2hpc2h1YQ_size_14_color_FFFFFF_t_70_g_se_x_16][]

--------------------

![8caaf13d0b8644ea836e413625a55c6a.png][]

--------------------

import java.io.*;
    
    class Main1 {
        public static void main(String[] args) throws IOException {
            OutputStream out;
            OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("mokuai-06\\osw.txt"));
    
            /*//void write(int c):写一个字符
            osw.write(97);
    
            //void flush():刷新流
            osw.flush();
    
            osw.write("\n");
            osw.write(98);
            osw.flush();*/
    
            //void write(char[] cbuf):写入一个字符数组
              char[] chs={'a','b','c','d','e'};
        //        osw.write(chs);
    
            //void write(char[] cbuf,int off,int len):写入字符数组的一部分
         //   osw.write(chs,0,3);
    
            //void write(String str,int off,int len):写一个字符串的一部分
           // osw.write("abcde");
            osw.write("abcde",0,3);
    
    
            //void close():先刷新，然后释放资源
            osw.close();
    
    
        }
    }

--------------------

**2.6 字符流读数据的两种方式**

**![e8577a92362d44f99989a20affdefdbc.png][]**

--------------------

import java.io.*;
    
    class Main1 {
        public static void main(String[] args) throws IOException {
           //InputStreamReader (InputStream in):创建一个使用默认字符集的InputStreamReader
            InputStreamReader isr=new InputStreamReader(new FileInputStream("mokuai-06\\osw.txt"));
    
            //int read():一次读一个字符数据
            /*int ch;
            while((ch=isr.read())!=-1){
                System.out.print((char)ch);
            }*/
    
            //int read (char[] cbuf):一次读一个字符数组数据
    
           char[] chbr=new char[1024];
            int len;
           while((len=isr.read(chbr))!=-1){
               System.out.print(new String(chbr,0,len));
           }
    
    
    
            //释放资源
            isr.close();
        }
    }

--------------------

**2.7 案例：复制java文件（普通版和进阶版）**

**![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmlhWGluZ05hc2hpc2h1YQ_size_19_color_FFFFFF_t_70_g_se_x_16][]**

--------------------

**普通版代码：**

import java.io.*;
    
    class Main1 {
        public static void main(String[] args) throws IOException {
            //根据数据源创建字符输入流对象
            InputStreamReader isr=new InputStreamReader(new FileInputStream("mokuai-06\\Farmers.java"));
            //根据目的地创建字符输出流对象
            OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("mokuai-06\\copy.java"));
    
            //读写数据，复制文件
            //一次读写一个字符数据
            /*int ch;
            while((ch=isr.read())!=-1){
                osw.write(ch);
            }*/
    
            //一次读写一个字符数组数据
            char[] chs=new char[1024];
            int len;
            while((len=isr.read(chs))!=-1){
                osw.write(chs,0,len);
            }
    
    
            //释放资源
            isr.close();
            osw.close();
        }
    }

--------------------

**进阶版代码：**

import java.io.*;
    
    class Main1 {
        public static void main(String[] args) throws IOException {
            //根据数据源创建字符输入流对象
            FileReader fr=new FileReader("mokuai-06\\Farmers.java");
            //根据目的地创建字符输出流对象
            FileWriter fw=new FileWriter("mokuai-06\\copy.java");
    
            //一次读写一个字符
            /*int len;
            while((len= fr.read())!=-1){
                fw.write(len);
            }*/
    
            //一次读写一个字符数组
            char[] chs=new char[1024];
            int len;
            while((len=fr.read(chs))!=-1){
                fw.write(chs,0,len);
            }
    
            //释放资源
            fr.close();
            fw.close();
        }
    }

--------------------

（PS：以上照片截至黑马程序员java全套视频）

[420cf03a0b214a70b498953ec6864dfb.png]: https://img-blog.csdnimg.cn/420cf03a0b214a70b498953ec6864dfb.png
[3308f991d95e46f0bfbd57a2c90844e3.png]: https://img-blog.csdnimg.cn/3308f991d95e46f0bfbd57a2c90844e3.png
[2c71ac0e7bc64d108a7a23dbc80274c0.png]: https://img-blog.csdnimg.cn/2c71ac0e7bc64d108a7a23dbc80274c0.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmlhWGluZ05hc2hpc2h1YQ_size_15_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/7af15799573e47b3a4062af2b479a841.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBASmlhWGluZ05hc2hpc2h1YQ==,size_15,color_FFFFFF,t_70,g_se,x_16
[8a1e0c2fb0e24ad5b9456910b57d09bd.png]: https://img-blog.csdnimg.cn/8a1e0c2fb0e24ad5b9456910b57d09bd.png
[b3d62b470cad4137844e61ade8a70944.png]: https://img-blog.csdnimg.cn/b3d62b470cad4137844e61ade8a70944.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmlhWGluZ05hc2hpc2h1YQ_size_14_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/d0d46704c9974fb9817fd8b82924a9f6.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBASmlhWGluZ05hc2hpc2h1YQ==,size_14,color_FFFFFF,t_70,g_se,x_16
[8caaf13d0b8644ea836e413625a55c6a.png]: https://img-blog.csdnimg.cn/8caaf13d0b8644ea836e413625a55c6a.png
[e8577a92362d44f99989a20affdefdbc.png]: https://img-blog.csdnimg.cn/e8577a92362d44f99989a20affdefdbc.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASmlhWGluZ05hc2hpc2h1YQ_size_19_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/86869b3a68374a42b187c012eb7baf25.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBASmlhWGluZ05hc2hpc2h1YQ==,size_19,color_FFFFFF,t_70,g_se,x_16