[学][2023.12.3] Java 自学 强化 第八天

Test01

 public static void main(String[] args) {
        //创建一个输出流
        //如果目标文件不存在，则创建一个文件
        //第二个参数是true 则定义的是追加写
        //        是false 则定义是覆盖写 默认false可以不写
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream("./myTest.txt" ,true);
            //通过输出流对象 写入数据
            //fileOutputStream.write(65);   //写一个字符
            //byte[] bytes = {65,78,98,98,99};  //写一个完整的字符串
            byte[] bytes = "hello world 你好" . getBytes();
            fileOutputStream.write(bytes);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }

Test02

    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("./myTest.txt");
        //定义输入流对象，因为要将内容读取到当前的程序

        int read = fileInputStream.read();
        //读完了，读到最后一个是-1
        while ( read != -1 ){
            System.out.println((char)read);
            read = fileInputStream.read();
        }
        fileInputStream.close();
    }

Test03

    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("./myTest.txt");

        FileOutputStream fileOutputStream = new FileOutputStream("./myTestNew.txt");

        int by;
        while ((by = fileInputStream.read()) != -1){
            fileOutputStream.write(by);
        }

        fileInputStream.close();
        fileOutputStream.close();
    }

Test04

        //将普通的字节流，封装成效率更高的 缓冲区字节流
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("./myTest.txt"));

        //一次读一个
//        int by;
//        while ((by = bufferedInputStream.read()) != -1){
//            System.out.println((char) by);
//        }

        //一次读取一个数组
        byte[] bytes = new byte[1024];
        int len;
        while ((len = bufferedInputStream.read(bytes)) != -1){
            System.out.println(new String( bytes ,0,len));
        }

        bufferedInputStream.close();
    }

Test05

    public static void main(String[] args) throws IOException {
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("./myTest.txt"));

        //写入数据
        bufferedOutputStream.write("5465nchien\r\n".getBytes());
        bufferedOutputStream.write("5465nchien".getBytes());
        bufferedOutputStream.write("5465nchien\r\n".getBytes());

        bufferedOutputStream.close();
    }

Test06 字节流案例

    public static void main(String[] args) throws IOException {
        final String SRC = "./test.mp4";
        final String SRC0 = "./testNew.mp4";

        long startTime = System.currentTimeMillis();

//        method01(SRC,SRC0); // 耗时196667ms --普通字节流 一次读写一个字节
//        method02(SRC,SRC0); //耗时836ms --普通字节流 一次读写一个数组

//        method03(SRC,SRC0); //耗时711ms --缓冲区字节流 一次读写一个字节
        method04(SRC,SRC0); //耗时155ms --缓冲区字节流 一次读写一个数组

        long endTime = System.currentTimeMillis();
        System.out.println(endTime-startTime);
    }

    /**
     * 缓冲区字节流 一次读写一个数组
     * @param src
     * @param src0
     */
    private static void method04(String src, String src0) throws IOException {
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(src));
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(src0));

        byte[] bytes = new byte[1024];
        int len;
        while (( len  = bufferedInputStream.read(bytes)) != -1){
            bufferedOutputStream.write(bytes,0,len);
        }

        bufferedInputStream.close();
        bufferedOutputStream.close();
    }

    /**
     * 缓冲区字节流 一次读写一个字节
     * @param src 源文件
     * @param src0 目标文件
     */
    private static void method03(String src, String src0) throws IOException {
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(src));
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(src0));

        int by;
        while (( by  = bufferedInputStream.read()) != -1){
            bufferedOutputStream.write(by);
        }

        bufferedInputStream.close();
        bufferedOutputStream.close();
    }

    /**
     * 一次读写一个数组
     * @param src
     * @param src0
     */
    private static void method02(String src, String src0) throws IOException {
        FileInputStream fileInputStream = new FileInputStream(src);
        FileOutputStream fileOutputStream = new FileOutputStream(src0);

        byte[] bytes = new byte[1024];
        int len;
        while ((len = fileInputStream.read(bytes)) != -1){
            fileOutputStream.write(bytes,0,len);
        }

        fileInputStream.close();
        fileOutputStream.close();
    }

    /**
     * 一次读写一个字节
     * @param src 源文件
     * @param src0 目标文件
     */
    private static void method01(String src, String src0) throws IOException {
        FileInputStream fileInputStream = new FileInputStream(src);
        FileOutputStream fileOutputStream = new FileOutputStream(src0);

        int by;
        while ((by = fileInputStream.read()) != -1){
            fileOutputStream.write(by);
        }

        fileInputStream.close();
        fileOutputStream.close();
    }

Test07

 public static void main(String[] args) throws IOException {
        //字节流
        FileOutputStream fileOutputStream = new FileOutputStream("./myTest.txt");
        //将字节流封装成字符流
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, "UTF-8");
        outputStreamWriter.write("涅尘"); //写入数据

        outputStreamWriter.flush();  //刷新流
        fileOutputStream.close();

        FileInputStream fileInputStream = new FileInputStream("./myTest.txt");

        InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "UTF-8");

        int n;
        while ( (n = inputStreamReader.read()) != -1){
            System.out.println((char) n);
        }

        fileInputStream.close();
    }

Test08

 public static void main(String[] args) throws IOException {
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("./myTest.txt"));

//        //写入一个字符
//        outputStreamWriter.write(97);
//        //手动刷新流
//        outputStreamWriter.flush();

//        //写一个数组
//        char[] chars = {'a','b','c','d','e','f','g'};
//        outputStreamWriter.write(chars);
//        outputStreamWriter.flush();

        //写一个字符串
        outputStreamWriter.write("我是一个字符串,nchien");
        outputStreamWriter.flush();

        outputStreamWriter.close();
    }

Test09

    public static void main(String[] args) throws IOException {
        InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("./myTest.txt"));

//        //一次读一个
//        int by;
//        while ( (by = inputStreamReader.read()) != -1){
//            System.out.println((char) by);
//        }

        //一次读一个数组
        char[] chars = new char[1024];
        int len;
        while ((len = inputStreamReader.read(chars)) != -1){
            System.out.println(new String( chars,0, len));
        }
        inputStreamReader.close();
    }

Test10

public static void main(String[] args) throws IOException {
        final String sy = "myTest.txt";
        final String sm = "myTestNew.txt";


        //一次读写一个字符
//        Method1(sy,sm);
        //一次读写一个数组
//        Method2(sy,sm);
        //缓冲区一次读写一个字符
//        Method3(sy,sm);
        //缓冲区一次读写一个数组
        Method4(sy,sm);
    }

    /**
     * 缓冲区一次读写一个数组
     * @param sy
     * @param sm
     */
    private static void Method4(String sy, String sm) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new FileReader(sy));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(sm));

        char[] chars = new char[1024];
        int len;
        while ( (len = bufferedReader.read(chars)) != -1){
            bufferedWriter.write(chars,0,len);
        }

        bufferedReader.close();
        bufferedWriter.close();
    }

    /**
     * 缓冲区一次读写一个字符
     * @param sy
     * @param sm
     * @throws IOException
     */
    private static void Method3(String sy, String sm) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new FileReader(sy));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(sm));

        int i;
        while ((i = bufferedReader.read()) != -1){
            bufferedWriter.write(i);
            bufferedWriter.flush();
        }

        bufferedReader.close();
        bufferedWriter.close();
    }

    /**
     * 一次读写一个数组
     * @param sy
     * @param sm
     * @throws IOException
     */
    private static void Method2(String sy, String sm) throws IOException {
        InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(sy));
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(sm));

        char[] chars = new char[1024];
        int len;
        while ((len = inputStreamReader.read(chars)) != -1){
            outputStreamWriter.write(chars,0,len);
            System.out.println( new String( chars, 0 ,len));
            outputStreamWriter.flush();
        }

        inputStreamReader.close();
        outputStreamWriter.close();
    }

    /**
     * 一次读写一个字符
     * @param sy
     * @param sm
     * @throws IOException
     */
    private static void Method1(String sy, String sm) throws IOException {
        InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(sy));
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(sm));
        int i ;
        while (( i = inputStreamReader.read()) != -1) {
            outputStreamWriter.write(i);
            outputStreamWriter.flush();
        }

        outputStreamWriter.close();
        inputStreamReader.close();
    }

Test11

    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("./myTest.txt"));

        System.out.println("请输入：");

        String string;

        while ( !(string = bufferedReader.readLine()).equals("over")){
            bufferedWriter.write(string);
            bufferedWriter.newLine();
            bufferedWriter.flush();
        }

//        while ( (string = bufferedReader.readLine()) != "over"){
//            bufferedWriter.write(string);
//            bufferedWriter.newLine();
//            bufferedWriter.flush();
//        }

        /**
         * 字符串的比较只能用 equals
         * 1、功能不同
         * "=="是判断两个变量或实例是不是指向同一个内存空间。
         * "equals"是判断两个变量或实例所指向的内存空间的值是不是相同。
         * 2、定义不同
         * "equals"在JAVA中是一个方法。
         * "=="在JAVA中只是一个运算符合。
         * 3、运行速度不同
         * "=="比"equals"运行速度快，因为"=="只是比较引用。
         * "equals"比"=="运行速度要慢。
         */

        bufferedReader.close();
        bufferedWriter.close();
    }