Day20Java基础学习

最新推荐文章于 2024-09-15 15:39:28 发布

小小飞鱼喵

最新推荐文章于 2024-09-15 15:39:28 发布

阅读量88

点赞数

分类专栏：基础知识点

本文链接：https://blog.csdn.net/weixin_44400192/article/details/104791021

版权

基础知识点专栏收录该内容

26 篇文章 0 订阅

订阅专栏

Day20

IO流概述及其分类
（1）概念
IO流用来处理设备之间的数据传输；
Java对数据的操作是通过流的方式；
Java用于操作流的类都在IO包中；

流按照流向分为两种：输入流，输出流；

流按照操作类型分为两种：
字节流：字节流可以操作任何数据，因为在计算机中的任何数据都是以字节的形式存储的。
字符流：字符流只能操作纯字符数据，比较方便。
（2） IO流常用父类
*字节流的抽象父类：
InputStream
OutputStream
*字符流的抽象父类：
Reader
Writer
（3） IO程序书写
使用前，导入IO包中的类
使用时，进行IO异常处理
使用后，释放资源
2. IO流（FileInputStream）
read()一次读取一个字节

public class Demo1_FileInputStream {
    public static void main(String[] args) throws IOException {
       FileInputStream fis = new FileInputStream("xxx.txt");
       int b;
       while ((b = fis.read()) != -1) {
           System.out.println(b);
       }
       fis.close();
    }

    private static void demo1() throws IOException {
        FileInputStream fis = new FileInputStream("xxx.txt");//创建流对象
        int x = fis.read();   //从硬盘上读取一个字节
        System.out.println(x); //关流释放资源
        int y = fis.read();
        System.out.println(y);
        int z = fis.read();
        System.out.println(z);
        int a = fis.read();
        System.out.println(a); //文件的结束标记为-1

        fis.close();
    }
}

IO流（FileInputStream返回值为什么是int）
（1） read（）方法读取的是一个字节，为什么返回值是int，而不是byte
答：因为字节输入流可以操作任意类型的文件，比如图片，音频等，这些文件底层都是二进制形式的存储的，如果每次读取都返回byte，有可能在读到中间的时候遇到11111111，那么这11111111是byte类型的-1，我们程序遇到-1就会停止不读了，后面的数据就读不到了，所以在读取的时候用int类型接收，如果11111111会在其前面补上24个0凑足4个字节，那么byte类型的-1就会变成int类型的255了，这样可以保证整个数据读完，而结束标记的-1就是int类型。
IO流（FileoutputStream）
（1） write()一次写出一个字节

public class Demo2_FileOutputStream {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("yyy.txt"); //创建字节输出流对象，如果没有就自动创建一个
        fos.write(97);  //虽然写出的是int数，但是到文件上为一个字节，会自动请去除前三个8位
        fos.write(98);
        fos.write(99);

        fos.close();
    }
}

IO流（FileoutputStream追加）
（1）案例演示
FileoutputStream的构造方法写出数据如何实现数据的追加写入

public class Demo2_FileOutputStream {
    /*
    FileOutputStream在创建时如果存在这个文件，会将其清空
     */
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("yyy.txt",true);
        //如果想续写，就在第二个参数传true
        fos.write(98);
        fos.write(100);
        fos.close();

    }
}

IO流（拷贝图片）
（1） FileInputStream读取
（2） FileoutputStream写出

public class Demo3_Copy {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("01.jpg"); //创建输入流对象，关联01.jpg
        FileOutputStream fos = new FileOutputStream("copy.jpg");//创建输出流，关联copy.jpg

        int b;
        while ((b = fis.read()) != -1) {  //在不断的读取每一个字节
            fos.write(b);     //将每一个字节写出

        }
        fis.close();
        fos.close();
    }
}

IO流（拷贝音频文件画原理图）
（1）案例演示
字节流一次读写一个字节复制音频
（2）弊端：效率太低
IO流（字节数组拷贝之available（）方法）
（1）案例演示
int read(byte[] b):一次读取一个字节数组
write(byte[] b):一次写出一个字节数组
available()获取读的文件所有的字节个数
弊端：可能会内存溢出

 public class Demo3_Copy {
    public static void main(String[] args) throws IOException {

       //第二拷贝有可能会导致内存溢出
        FileInputStream fis = new FileInputStream("01.jpg"); //创建输入流对象，关联01.jpg
        FileOutputStream fos = new FileOutputStream("copy.jpg");//创建输出流，关联copy.jpg
        //int len = fis.available();
        //System.out.println(len);

        byte[] arr = new byte[fis.available()]; //创建与文件一样大小的字节数组
        fis.read(arr);    //将文件上的字节读取到内存中
        fos.write(arr);   //将字节数组中的数据写到文件上


        fis.close();
        fos.close();
    }
}

IO流（定义小数组）
write（byte[] b)
write（byte[] b,int off,int len)写出有效的字节个数

public class Demo4_ArrayCopy {
    /*
    第三种拷贝
    定义小数组
     */
    public static void main(String[] args) throws IOException {
       FileInputStream fis = new FileInputStream("xxx.txt");
        FileOutputStream fos = new FileOutputStream("yyy.txt");

        byte[] arr = new byte[2];
        int len;
        while ((len = fis.read(arr)) != -1) {
            fos.write(arr ,0,len);

        }
        fis.close();
        fos.close();
    }

    private static void demo1() throws IOException {
        FileInputStream fis = new FileInputStream("xxx.txt");
        byte[] arr = new byte[2];
        int a = fis.read(arr);    //将文件的字节读取到字节数组中

        System.out.println(a);  //读到的有效字节个数
        for(byte b : arr) {    //第一次回去到文件上的a和b
            System.out.println(b);
        }

        int c = fis.read(arr);
        System.out.println(c);
        for(byte b : arr){
            System.out.println(b);
        }
        fis.close();
    }
}

IO流（定义小数组的标准格式）
（1）案例演示
字节流一次读写一个字节数组复制图片和视频

public class Demo4_ArrayCopy {
    /*
    第三种拷贝
    定义小数组
     */
    public static void main(String[] args) throws IOException {
       FileInputStream fis = new FileInputStream("01.jpg");
        FileOutputStream fos = new FileOutputStream("02.jpg");

        byte[] arr = new byte[1024 * 8];  //速度相当于8k,
        int len;
        while ((len = fis.read(arr)) != -1) { //如果忘记加arr,返回的就不是读取的字节个数，而是字节的码表值
            fos.write(arr,0,len);
        }
        fis.close();
        fos.close();
    }
}

IO流（BufferedInputStream和BufferedOutputStream拷贝）
（1）缓冲思想
字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，
这是加入了数组这样的缓冲区效果，java本身在设计的时候也考虑到了这样的设计思想（装饰设计模式后面讲解），所以提供了字节缓冲区流。
（2） BufferedInputStream
BufferedInputStream内置了一个缓冲区（数组），从BufferedInputStream中读取一个字节时，BufferedInputStream会一次性从文件中读取8192个，存在缓冲区中，返回给程序一个，程序再次读取时就不用找文件了，直接从缓冲区中获取。直到缓冲区中所有的都被使用过，才重新从文件中读取8192个。
（3） BufferedOutputStream
BufferedOutputStream也内置了一个缓冲区（数组），程序向流中写出字节时，不会直接写到文件，先写到缓冲区中，直到缓冲区写满，BufferedOutputStream才会把缓冲区中的数据一次性写到文件理。
（4）拷贝的代码

public class Demo5_BufferCopy {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("01.jpg"); //创建输入流对象，关联01，jpg
        FileOutputStream fos = new FileOutputStream("copy.jpg");//创建输出流对象，关联02.jpg
        BufferedInputStream bis = new BufferedInputStream(fis);//创建缓冲区对象，对输入流进行包装让其变得更加强大
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        int b;
        while ((b = bis.read()) != -1) {
            bos.write(b);
        }
        bis.close();
        bos.close();
    }
}

（5）小数组的读写和带Buffered的读取哪个更快
定义小数组如果是8192个字节大小和Buffered比较的话，定义小数组会略胜一筹，因为读和写操作的是同一个数组，而Buffered操作的是两个数组。

IO流（flush和close方法的区别）
（1） flush()方法
用来刷新缓冲区的，刷新后可以再次写出
（2） close()方法
用来关闭流释放资源的，如果是带缓冲区的流对象的close()方法，不但会关闭流，还会再关闭流之前刷新缓冲区，关闭之后不能再写出。

public class Demo5_BufferCopy {
    public static void main(String[] args) throws IOException {
     BufferedInputStream bis = new BufferedInputStream(new FileInputStream("01.jpg"));
     BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.jpg"));

     int b;
     while ((b = bis.read()) != -1){
         bos.write(b);
         bos.flush();  //具备刷新得功能，刷完之后还能继续写
     }
     
     bis.close();
     bos.close();
     //close方法具备刷新得功能，在关闭流之前就会刷新一次缓冲区，将缓冲区得字节全都刷新到文件上。
        //close刷完之后就不能再继续写了


    }
}

IO流（字节流读写中文）
（1）字节流读取中文的问题。
字节流在读取中文的时候有可能会读到半个中文，造成乱码。
（2）字节流写出中文的问题
字节流直接操作的字节，所以写出中文必须将字符串转换成字节数组。
写出回车换行 write(“\r\n”.getBytes());

public class Demo6_Chinese {
    /*
    （1）    字节流读取中文的问题。
    字节流在读取中文的时候有可能会读到半个中文，造成乱码。
    （2）    字节流写出中文的问题
    字节流直接操作的字节，所以写出中文必须将字符串转换成字节数组。
    写出回车换行 write(“\r\n”.getBytes());

     */
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("zzz.txt");
        fos.write("我读书少，你不要骗我".getBytes());
        fos.write("\r\n".getBytes());//换行
        fos.close();

    }

    private static void demo1() throws IOException {
        FileInputStream fis = new FileInputStream("yyy.txt");
        byte[] arr = new byte[3];
        int len;
        while ((len = fis.read(arr)) != -1){
            System.out.println(new String(arr,0,len));

        }
        fis.close();
    }
}

IO流（流的标准处理异常代码1.6版本及其以前）
try finally嵌套

public class Demo7_TryFinally {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
          fis = new FileInputStream("xxx.txt");
           fos = new FileOutputStream("yyy.txt");

          int b;
          while ((b = fis.read()) != -1) {
              fos.write(b);
          }
      }finally {
            try {
                if (fis != null)
                    fis.close();
                }finally{  //try finally的嵌套目的是能关一个是一个
                    if (fos != null) {
                        fos.close();
                    }
                }
            }
        }
    }

IO流（流的标准处理异常代码1.7版本）
try close

public class Demo7_TryFinally {
    public static void main(String[] args) throws IOException {
        try (
                FileInputStream fis = new FileInputStream("xxx.txt");
                FileOutputStream fos = new FileOutputStream("yyy.txt");
        ) {
            int b;
            while ((b = fis.read()) != -1) {
                fos.write(b);
            }//会自动关闭
        }
    }
}

IO流（图片加密）
给图片加密

public class Test1 {
    public static void main(String[] args) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("copy.jpg"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy1.jpg"));
        int b;
        while ((b = bis.read()) != -1) {
            bos.write(b ^ 123); //将写出的字节异或一个数，这个数就是密钥，解密的时候再异或一次
        }
        bis.close();
        bos.close();

    }
}

IO流（拷贝文件）
在控制台录入文件的路径，将文件拷贝到当前项目下

public class Test2 {
    /*
    在控制台录入文件的路径，将文件拷贝到当前项目下
    1:创建键盘录入对象
    2：定义方法，对键盘录入的路径进行判断，如果是文件就返回
    3：在主方法中接收该文件
    4：读和写该文件
     */
    public static void main(String[] args) throws IOException {
        File file = getFile();  //获取文件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file.getName()));
        int b;
        while ((b = bis.read()) != -1){
            bos.write(b);
        }
        bis.close();
        bos.close();
        }

    /* 1+2：定义方法，:创建键盘录入对象，对键盘录入的路径进行判断，如果是文件就返回
    1：返回值类型为File
    2:参数列表无
     */

    public static File getFile() {
        Scanner sc = new Scanner(System.in);

        while (true) {
            String line = sc.nextLine(); //接收键盘录入的路径
            File file = new File(line); //封装成File对象，并对其进行判断
            if(!file.exists()){
                System.out.println("您录入的文件路径不存在，请重新录入");
            }else if (file.isDirectory()) {
                System.out.println("您录入的是文件夹路径，请重新输入");
            }else{
                return file;
            }
        }
    }
}

IO流（录入数据拷贝到文件）
将键盘录入的数据拷贝到当前项目下的text.txt文件中，键盘录入数据当遇到quit时就退出。

public class Test3 {
    /*
    将键盘录入的数据拷贝到当前项目下的text.txt文件中，键盘录入数据当遇到quit时就退出。
     1:创建键盘录入对象
     2：创建输出流对象，关联text.txt文件，
     3;定义无限循环
     4：遇到quit退出循环
     5：如果不是quit，就退出
     6：关闭流
     */
    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        FileOutputStream fos = new FileOutputStream("text.txt");
        System.out.println("请输入数据");
        while (true){
            String line = sc.nextLine(); //将键盘录入对象存储在line中
            if("quit".equals(line)) {
                break;
            }
            // 5：如果不是quit，就退出
            fos.write(line.getBytes()); //字符串写出必须转换成字节数组
            fos.write("\r\n".getBytes());
        }
        fos.close();

    }
}