Java基础 - 10 - IO流（二）

一. IO流 - 字符流

1.1 FileReader（文件字符输入流）

作用：以内存为基准，可以把文件中的数据以字符的形式读入到内存中去

构造器说明
public FileReader(File file)创建字符输入流管道与源文件接通
public FileReader(String pathname)创建字符输入流管道与源文件接通
方法名称说明
public int read()每次读取一个字符返回，如果发现没有数据可读会返回-1
public int read(char[] buffer)每次用一个字符数组去读取数据，返回字符数组读取了多少个字符，如果发现没有数据可读会返回-1
public class demo {
    public static void main(String[] args) {
        try (
                //创建一个文件字符输入流管道与源文件接通
                Reader fr = new FileReader("demo\\src\\wosun.txt");
                ){
            //读取文本文件的内容
            //1.每次读取一个字符（性能较差）
//            int c; //记住每次读取的字符编号
//            while((c = fr.read()) != -1){
//                System.out.print((char)c);
//            }

            //2.每次读取多个字符（性能不错）
            char[] buffer = new char[10];
            int len; //记住每次读取多少个字符
            while((len = fr.read(buffer)) != -1){
                System.out.print(new String(buffer, 0, len));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

1.2 FileWriter（文件字符输出流）

作用：以内存为基准，把内存中的数据以字符的形式写出到文件中去

构造器说明
public FileWriter(File file)创建字符输出流管道与源文件对象接通
public FileWriter(String filepath)创建字符输出流管道与源文件路径接通
public FileWriter(File file, boolean append)创建字符输出流管道与源文件对象接通，可追加数据
public FileWriter(String filepath, boolean append)创建字符输出流管道与源文件路径接通，可追加数据
方法名称说明
public void write(int a)写一个字符
public void write(String str)写一个字符串
public void write(String str, int off, int len)写一个字符串的一部分
public void write(char[] cbuf)写入一个字符数组
public void write(char[] cbuf, int off, int len)写入一个字符数组的一部分
public class demo {
    public static void main(String[] args) {

        try (
                //创建一个文件字符输出流关单与目标文件接通
                //Writer fw = new FileWriter("demo/src/new_wosun.txt"); //覆盖管道
                Writer fw = new FileWriter("demo/src/new_wosun.txt",true); //追加数据管道
                ){
            //1.public void write(int a) 写一个字符
            fw.write('a');
            fw.write(97);
            fw.write('中'); //写一个字符进去
            fw.write("\r\n"); //换行

            //2.public void write(String str) 写一个字符串
            fw.write("我爱你我的国anc");
            fw.write("\r\n");

            //3.public void write(String str, int off, int len)	写一个字符串的一部分
            fw.write("我爱你我的国anc",0,6);
            fw.write("\r\n");

            //public void write(char[] cbuf)	写入一个字符数组
            char[] buffer = {'小','小','J','a','v','a'};
            fw.write(buffer);
            fw.write("\r\n");

            //public void write(char[] cbuf, int off, int len)	写入一个字符数组的一部分
            fw.write(buffer,2,4);
            fw.write("\r\n");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

字符输出流使用时的注意事项

        字符输出流写出数据后，必须刷新流，或者关闭流，写出去的数据才能生效

        原理是：字符输出流在写出数据的时候，先将内容写入缓冲区，然后通过刷新流操作，将缓冲区中内容一次性写出（缓冲区满会自动刷新）

public class demo {
    public static void main(String[] args) throws Exception {

        Writer fw = new FileWriter("demo/src/new_wosun.txt"); //追加数据管道

        fw.write('a');
        fw.write(97);
        fw.write('中'); //写一个字符进去
        fw.write("\r\n"); //换行

        fw.flush(); //刷新流
        fw.write("你好");
        fw.close(); //关闭流，关闭流包含刷新操作
    }
}

二. IO流 - 缓冲流

缓冲流的作用：对原始流进行包装，以提高原始流读写数据的性能

2.1 字节缓冲流

        包括字节缓冲输入流和字节缓冲输出流

作用：提高字节流读写数据的性能

原理：字节缓冲输入流自带8KB缓冲池；字节缓冲输出流也自带8KB缓冲池

构造器说明
public BufferedInputStream(InputStream is)把低级的字节输入流包装成一个高级的缓冲字节输入流，从而提高读数据的性能
public BufferedOutputStream(OutputStream os)把低级的字节输出流包装成一个高级的缓冲字节输出流，从而提高读数据的性能
public class demo {
    public static void main(String[] args) {
        try (
                InputStream is = new FileInputStream("demo/src/wosun.txt");
                //定义一个字节缓冲输入流包装原始的字节输入流
                InputStream bis = new BufferedInputStream(is,8192*2);

                OutputStream os = new FileOutputStream("demo/src/wosun_bak.txt");
                //定义一个字节缓冲输出流包装原始的字节输出流
                OutputStream bos = new BufferedOutputStream(os,8192*2);
                ){
            byte[] buffer = new byte[1024];
            int len;
            while((len = bis.read(buffer)) != -1){
                bos.write(buffer,0,len);
            }
            System.out.println("复制完成！");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2.2 字符缓冲流

2.2.1 BufferedReader（字符缓冲输入流）

作用：自带8K（8192）的字符缓冲池，可以提高字符输入流读取字符数据的性能

构造器说明
public BufferedReader(Reader r)把低级的字符输入流包装成字符缓冲输入流管道，从而提高读数据的性能

字符缓冲输入流新增的功能：按照行读取字符

方法说明
public String readLine()读取一行数据返回，如果没有数据可读了，会返回null
public class demo {
    public static void main(String[] args) {
        try (
                Reader fr = new FileReader("demo/src/wosun.txt");
                //创建一个字符缓冲输入流包装原始的字符输入流
                BufferedReader bfr = new BufferedReader(fr);
                ){
//            char[] buffer = new char[3];
//            int len;
//            while ((len = bfr.read(buffer)) != -1){
//                System.out.println(new String(buffer,0,len));
//            }

//            System.out.println(bfr.readLine());
//            System.out.println(bfr.readLine());
//            System.out.println(bfr.readLine());
//            System.out.println(bfr.readLine());
//            System.out.println(bfr.readLine()); //没有内容，输出null

            String line; //记录每次读取的每一行数据
            while((line = bfr.readLine()) != null){
                System.out.println(line);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2.2.2 BufferedWriter（字符缓冲输出流）

作用：自带8K（8192）的字符缓冲池，可以提高字符输出流读取字符数据的性能

构造器说明
public BufferedWriter(Writer r)把低级的字符输出流包装成一个字符缓冲输出流管道，从而提高字符输出流写数据的性能

字符缓冲输出流新增的功能：换行

方法说明
public void newLine()换行
public class demo {
    public static void main(String[] args) {
        try (
               Writer fw = new FileWriter("demo/src/wosun_back.txt",true);
               //创建一个字符缓冲输出流管道包装原始的字符输出流
               BufferedWriter bw = new BufferedWriter(fw);

                ){
            bw.write('a');
            bw.write(97);
            bw.write('中');
            bw.newLine();

            bw.write("你好你好你222adc好好");
            bw.write("\r\n");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2.2.3 字符缓冲流综合案例

public class demo {
    public static void main(String[] args) {
        //恢复出师表的顺序到新文件中
        //3.侍中、侍郎郭攸之、费祎、董允等，此皆良实，志虑忠纯，是以先帝简拔以遗陛下。愚以为宫中之事，事无大小，悉以咨之，然后施行，必能裨补阙漏，有所广益。
        //7.先帝知臣谨慎，故临崩寄臣以大事也。受命以来，夙夜忧叹，恐托付不效，以伤先帝之明；故五月渡泸，深入不毛。今南方已定，兵甲已足，当奖率三军，北定中原；庶竭驽钝，攘除奸凶，兴复汉室，还于旧都。此臣所以报先帝而忠陛下之职分也。至于斟酌损益，进尽忠言，则攸之、祎、允之任也。
        //5.亲贤臣，远小人，此先汉所以兴隆也；亲小人，远贤臣，此后汉所以倾颓也。先帝在时，每与臣论此事，未尝不叹息痛恨于桓、灵也。侍中、尚书、长史、参军，此悉贞亮死节之臣，愿陛下亲之信之，则汉室之隆，可计日而待也。
        //9.今当远离，临表涕零，不知所言。
        //6.臣本布衣，躬耕于南阳，苟全性命于乱世，不求闻达于诸侯。先帝不以臣卑鄙，猥自枉屈，三顾臣于草庐之中，咨臣以当世之事。由是感激，遂许先帝以驱驰。后值倾覆，受任于败军之际，奉命于危难之间，尔来二十有一年矣！
        //1.先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。然侍卫之臣不懈于内，忠志之士忘身于外者，盖追先帝之殊遇，欲报之于陛下也。诚宜开张圣听，以光先帝遗德，恢弘志士之气；不宜妄自菲薄，引喻失义，以塞忠谏之路也。
        //8.愿陛下托臣以讨贼兴复之效，不效，则治臣之罪，以告先帝之灵。若无兴德之言，则责攸之、祎、允等之慢，以彰其咎。陛下亦宜自谋，以咨诹善道，察纳雅言，深追先帝遗诏，臣不胜受恩感激。
        //2.宫中府中，俱为一体，陟罚臧否，不宜异同。若有作奸犯科及为忠善者，宜付有司论其刑赏，以昭陛下平明之理；不宜偏私，使内外异法也。
        //4.将军向宠，性行淑均，晓畅军事，试用于昔日，先帝称之曰能，是以众议举宠为督。愚以为营中之事，悉以咨之，必能使行阵和睦，优劣得所。
        try(
//                //创建文件字符输入流
//                Reader r = new FileReader("demo/src/wosun.txt");
//                //创建字符缓冲输入流
//                BufferedReader br = new BufferedReader(r);

                BufferedReader br = new BufferedReader(new FileReader("demo/src/wosun.txt"));
                BufferedWriter bw = new BufferedWriter(new FileWriter("demo/src/wosun_copy.txt"))

                ) {
            //定义一个ArrayList集合用来存储每段内容
            List<String> arrayList = new ArrayList<>();

            String s; //记录每一行的内容
            while((s = br.readLine()) != null){
                arrayList.add(s);
            }

            //对arrayList里面的内容进行排序
            Collections.sort(arrayList);  //默认按照首位排序
            System.out.println(arrayList);

            //遍历arrayList的内容，一次写出去到一个新文件中
            for (String s1 : arrayList) {
                bw.write(s1);
                bw.newLine();
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2.2.4 原始流、缓冲流的性能分析   

        低级的字节流按照字节数组的形式复制文件的性能不一定比缓冲字节流按照字节数组的形式复制文件的性能差，具体要看这个字节数组的容量。但字节数组的容量也不是越大一定越好，达到一定容量之后，复制的效率提升不会太大。

public class demo {
    //复制的视频路径
    private static final String SRC_File = "D:\\zm\\111.mp4";
    //目的地路径
    private static final String DEST_File ="D:\\zm\\test\\";

    public static void main(String[] args) {
        //复制一个42.4MB的视频文件
          //低级字节流一个一个字节复制耗时：626.895s (太慢了)
          //低级字节流使用字节数组（1KB）复制耗时：0.697s
          //缓冲流一个一个字节复制耗时：0.93s
          //缓冲流使用字节数组复制耗时：0.137s
        //将低级字节流和缓冲流用的字符数组容量扩大（8KB）
          //低级字节流使用字节数组复制耗时：0.128s
          //缓冲流使用字节数组复制耗时：0.122s
        //将低级字节流和缓冲流用的字符数组容量扩大（16KB）
          //低级字节流使用字节数组复制耗时：0.068s
          //缓冲流使用字节数组复制耗时：0.067s
        //将低级字节流和缓冲流用的字符数组容量扩大（32KB）
          //低级字节流使用字节数组复制耗时：0.051s
          //缓冲流使用字节数组复制耗时：0.049s

        //copy01();
        copy02();
        //copy03();
        copy04();
    }

    private static void copy01(){ //一个个字节的形式复制文件
        long startTime = System.currentTimeMillis();
        try(
                InputStream is = new FileInputStream(SRC_File);
                OutputStream os = new FileOutputStream(DEST_File + "copy1.mp4");
                ) {
            int a; //用于记住读取的字节
            while((a = is.read()) != -1){
                os.write(a);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("低级字节流一个一个字节复制耗时：" + (endTime - startTime)/1000.0 +"s");
    }

    private static void copy02(){ //字节数组的形式复制文件
        long startTime = System.currentTimeMillis();
        try(
                InputStream is = new FileInputStream(SRC_File);
                OutputStream os = new FileOutputStream(DEST_File + "copy2.mp4");
        ) {
            byte[] buffer = new byte[1024 * 32]; //用于记住读取的字节的字符数组(大小1KB 8KB 16KB 32KB)
            int len; //用于记住读取的字节长度
            while((len = is.read(buffer)) != -1){
                os.write(buffer,0,len);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("低级字节流使用字节数组复制耗时：" + (endTime - startTime)/1000.0 +"s");
    }

    private static void copy03(){ //字节缓冲流 一个个字节的形式复制文件
        long startTime = System.currentTimeMillis();
        try(
                InputStream is = new FileInputStream(SRC_File);
                BufferedInputStream bis = new BufferedInputStream(is);
                OutputStream os = new FileOutputStream(DEST_File + "copy3.mp4");
                BufferedOutputStream bos = new BufferedOutputStream(os);
        ) {
            int a; //用于记住读取的字节
            while((a = bis.read()) != -1){
                bos.write(a);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("缓冲流一个一个字节复制耗时：" + (endTime - startTime)/1000.0 +"s");
    }

    private static void copy04(){ //字节缓冲流 字节数组的形式复制文件
        long startTime = System.currentTimeMillis();
        try(
                InputStream is = new FileInputStream(SRC_File);
                BufferedInputStream bis = new BufferedInputStream(is,1024 * 32);
                OutputStream os = new FileOutputStream(DEST_File + "copy4.mp4");
                BufferedOutputStream bos = new BufferedOutputStream(os,1024 * 32);
        ) {
            //超过8KB需要修改缓冲流默认的缓冲池大小
            byte[] buffer = new byte[1024 * 32]; //用于记住读取的字节的字符数组
            int len; //用于记住读取的字节长度
            while((len = bis.read(buffer)) != -1){
                bos.write(buffer,0,len);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("缓冲流使用字节数组复制耗时：" + (endTime - startTime)/1000.0 +"s");
    }
}

三. IO流 - 转换流

问题引入：不同编码读取出现乱码的问题

public class demo {
    public static void main(String[] args) {
        try (
                //创建一个文件字符输入流与源文件接通
                //代码编码：UTF-8 文件的编码：UTF-8 不会乱码
                //代码编码：UTF-8 文件的编码：GBK 会乱码
                Reader r = new FileReader("demo/src/wosun_back.txt");
                //把文件字符输入流包装成缓冲字符输入流
                BufferedReader br = new BufferedReader(r);
                ){
            String line;
            while((line = br.readLine()) != null){
                System.out.println(line);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

因此，引入字符输入/输出转换流来解决乱码问题 

3.1 InputStreamReader（字符输入转换流）

作用：解决不同编码时，字符流读取文本内容乱码的问题

解决思想：先获取文件的原始字节流，再将其按真实的字符集编码转成字符输入流，这样字符输入流中的字符就不会乱码了

构造器说明
public InputStreamReader(InputStream is)把原始的字节输入流，按照代码默认编码转换成字符输入流（与直接用FileReader的效果一样）
public InputStreamReader(InputStream is , String charset)把原始的字节输入流，按照指定字符集编码转成字符输入流
public class demo {
    public static void main(String[] args) {
        try (
                //得到文件的原始字节流（GBK的字节流形式）
                InputStream is = new FileInputStream("demo/src/wosun_back.txt");
                //字符输入转换流：把原始的字节输入流按照指定的字符集编码转换成字符输入流
                Reader isr = new InputStreamReader(is,"GBK");
                //把字符输入流包装成缓冲字符输入流
                BufferedReader br = new BufferedReader(isr);
                ){
            String line;
            while((line = br.readLine()) != null){
                System.out.println(line);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3.2 OutputStreamWriter（字符输出转换流）

作用：可以控制写出去的字符使用什么字符集编码

解决思路：获取字节输出流，再按照指定的字符集编码将其转换成字符输出流，这样写出去的字符就会用该字符集编码了

构造器说明
public OutputStreamWriter(OutputStream os)可以把原始的字节输出流，按照代码默认编码转换成字符输出流
public OutputStreamWriter(OutputStream os , String charset)可以把原始的字节输出流，按照指定编码转换成字符输出流
public class demo {
    public static void main(String[] args) {
        try (
                //创建一个文件字节输出流
                OutputStream os = new FileOutputStream("demo/src/wosun_back.txt");
                //字符输出转换流：把原始的字节输出流按照指定的字符集编码转换成字符输出转换流
                Writer osw = new OutputStreamWriter(os,"GBK");
                //把字符输出转换流包装成缓冲字符输出流
                BufferedWriter bw = new BufferedWriter(osw);
                ){
            bw.write("这里是我的家abc");
            bw.write("acf哪里是我的家");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

四. IO流 - 打印流

4.1 PrintStream/PrintWriter（打印流）

作用：打印流可以实现更方便、更高效的打印（即写）数据出去，能实现打印啥出去就是啥出去（如打印97就是97，打印a就是a）

public class demo {
    public static void main(String[] args) {
        try(
                //创建一个打印流管道
                // PrintStream ps = new PrintStream("demo/src/wosun_back.txt", String.valueOf(Charset.forName("GBK")));
                PrintStream ps = new PrintStream("demo/src/wosun_back.txt");
                ) {
            ps.println(97);
            ps.println('a');
            ps.println("你好你好你好");
            ps.println(true);
            ps.println(99.0);

            ps.write(97); //'a'

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class demo {
    public static void main(String[] args) {
        try(
                //创建一个打印流管道
                // PrintStream ps = new PrintStream("demo/src/wosun_back.txt", String.valueOf(Charset.forName("GBK")));
                // PrintWriter pw = new PrintWriter("demo/src/wosun_back.txt"); //高级流不能直接追加数据
                //想要追加数据的话
                PrintWriter pw = new PrintWriter(new FileWriter("demo/src/wosun_back.txt",true));
                ) {
            pw.println(97);
            pw.println('a');
            pw.println("你好你好你好");
            pw.println(true);
            pw.println(99.0);

            pw.write(97); //'a'

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

打印流的一种应用：输出语句的重定向

         可以把输出语句的打印位置改到某个文件中去

public class demo {
    public static void main(String[] args) {
        System.out.println("你想是怎样的人");
        System.out.println("你就是怎样的人");
        try (
                PrintStream ps = new PrintStream("demo/src/wosun.txt");
                ){
            //把系统默认的打印流对象改成自己设置的打印流
            System.setOut(ps);
            System.out.println("你想成为怎样的人");
            System.out.println("你就会离这个目标不会太远");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

五. IO流 - 数据流

5.1 DataOutputStream（数据输出流） 

        允许把数据和其类型一并写出去

5.2 DataInputStream（数据输入流）

        用于读取数据输出流写出去的数据

//数据输出流
public class demo {
    public static void main(String[] args) {
        try (
                DataOutputStream dos = new DataOutputStream(new FileOutputStream("demo/src/wosun.txt"));
                ){
            dos.writeInt(97);
            dos.writeDouble(99.9);
            dos.writeBoolean(true);
            dos.writeUTF("你好你好nihao你好哇");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

//数据输入流
public class demo2 {
    public static void main(String[] args) {
        //使用数据输入流读取特定类型的数据
        try (
                DataInputStream dis = new DataInputStream(new FileInputStream("demo/src/wosun.txt"));
                ){
            //读取的顺序要和输出的顺序一致
            System.out.println(dis.readInt());
            System.out.println(dis.readDouble());
            System.out.println(dis.readBoolean());
            System.out.println(dis.readUTF());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

六. IO流 - 序列化流

        对象序列化：把Java对象写入到文件中去

        对象反序列化：把文件里的Java对象读出来

6.1 ObjectOutputStream（对象字节输出流）

        可以把Java对象进行序列化：把Java对象存入到文件中去

        注意：对象如果需要序列化，必须要实现序列化接口

6.2 ObjectInputStream（对象字节输入流）

        可以把Java对象进行反序列化：把存储在文件中的Java对象读入到内存中去

//序列化
public class demo {
    public static void main(String[] args) {
        try (
                //2.创建一个对象字节输出流包装原始的字节输出流
                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("demo/src/wosun.txt"));
                ){
            //1.创建一个Java对象
            User u = new User("小小","wosun",10);
            //3.序列化对象到文件中去
            oos.writeObject(u);
            System.out.println("序列化对象成功！");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

//反序列化
public class demo2 {
    public static void main(String[] args) {
        //对象字节输入流的使用：反序列化对象
        try (
                //1.创建一个对象字节输入流管道，包装低级的字节输入流与源文件接通
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("demo/src/wosun.txt"));
                ){
            User u = (User) ois.readObject(); //readObject()返回的是Object类型，要根据Java对象的类型进行强转
            System.out.println(u);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

//User
//对象如果需要序列化，必须要实现序列化接口
public class User implements Serializable {
    private String userName;
    //transient 这个成员变量将不参与序列化
    private transient String password;
    private int age;

    public User() {
    }

    public User(String userName, String password, int age) {
        this.userName = userName;
        this.password = password;
        this.age = age;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                '}';
    }
}

七. IO框架

什么是框架？

  · 解决某类问题，编写的一套类、接口等，可以理解成一个半成品，大多框架都是第三方研发的

  · 好处：在框架的基础上开发，可以得到优秀的软件架构，并能提高开发效率

  · 框架的形式：一般是把类、接口等编译成class形式，再压缩成一个.jar结尾的文件发行出去

什么是IO框架？

  · 封装了Java提供的对文件、数据进行操作的代码，对外提供了更简单的方式来对文件进行操作，对数据进行读写等

7.1 Commons-io

Commons-io是apache开源基金组织提供的一组有关IO操作的小框架，目的是提高IO流的开发效率

public class demo {
    public static void main(String[] args) throws Exception {
        FileUtils.copyFile(new File("demo/src/wosun.txt"),new File("demo/src/wosun_copy.txt"));
        FileUtils.copyDirectory(new File("demo/src/test"),new File("demo/src/test_copy"));
        FileUtils.deleteDirectory(new File("D:\\zm\\ddd"));

        //Java提供的原生的一行代码搞定很多事情
        //System.out.println(Files.readString(Path.of("demo/src/wosun.txt"))); 
        //Files.copy(Path.of("demo/src/wosun.txt"),Path.of("demo/src/wosun_c.txt"))
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/553378.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Linux系统编程开发环境搭建

Linux系统编程开发环境搭建

开发环境搭建 桥接网络&#xff08;Bridged Network&#xff09;、网络地址转换&#xff08;NAT, Network Address Translation&#xff09;和主机模式网络&#xff08;Host-only Networking&#xff09; 在虚拟化环境中&#xff0c;常见的三种网络模式是桥接网络&#xff08…
阅读更多...
[Linux_IMX6ULL驱动开发]-总线设备驱动模型

[Linux_IMX6ULL驱动开发]-总线设备驱动模型

目录 框架分层 总线驱动模型实现 上层驱动代码(leddrv.c)的实现以及解析 交叉依赖的避免 下层驱动的设备文件(board_A_led.c)的实现 下层驱动的驱动文件(chip_demo_gpio.c)的实现 框架分层 在之前&#xff0c;我们对于驱动的框架有过两种不同的框架。第一种框架&#xf…
阅读更多...
如何爬出 Kotlin 协程死锁的坑？

如何爬出 Kotlin 协程死锁的坑？

作者&#xff1a;悬衡 一、前言 在 Java 中有一个非常经典的死锁问题, 就是明明自己已经占用了线程池, 却还继续去申请它, 自己等自己, 就死锁了, 如下图和代码: // 这段代码将死锁到天荒地老final ExecutorService executorService Executors.newSingleThreadExecutor();exe…
阅读更多...
科学突破可能开创6G通信新时代

科学突破可能开创6G通信新时代

格拉斯哥大学开发的火柴盒大小的天线可以为全息通话、改进自动驾驶和更好的医疗保健的世界铺平道路。 格拉斯哥大学表示&#xff0c;这种创新的无线通信天线将超材料的独特特性与复杂的信号处理相结合&#xff0c;有助于构建未来的 6G 网络。 数字编码动态超表面天线&#xf…
阅读更多...
前端请求发送成功，后端收到null

前端请求发送成功，后端收到null

1、dishId为64&#xff0c;有数据 2、但是后端调试接不到数据&#xff0c;为null 3、形参部分缺少RequestBody接收JSON数据&#xff0c;加上即可
阅读更多...
Kimichat炒股：7个提示词案例

Kimichat炒股：7个提示词案例

●了解股票投资基本概念和知识 什么是有息负债率&#xff1f;用浅显明白的话语针对没有财务会计基础的小白进行解释 Kimi的回答&#xff1a; 有息负债率是一个财务指标&#xff0c;用来衡量一家公司在其负债中有多少是需要支付利息的。简单来说&#xff0c;就是公司借的钱中&…
阅读更多...
获取公募基金持仓【数据分析系列博文】

获取公募基金持仓【数据分析系列博文】

摘要 从指定网址获取公募基金持仓数据&#xff0c;快速解析并存储数据。 &#xff08;该博文针对自由学习者获取数据&#xff1b;而在投顾、基金、证券等公司&#xff0c;通常有Wind、聚源、通联等厂商采购的数据&#xff09; 1. 导入必要的库&#xff1a; pandas 用于数据处理…
阅读更多...
【第1节】书生·浦语大模型全链路开源开放体系

【第1节】书生·浦语大模型全链路开源开放体系

目录 1 简介2 内容&#xff08;1&#xff09;书生浦语大模型发展历程&#xff08;2&#xff09;体系&#xff08;3&#xff09;亮点&#xff08;4&#xff09;全链路体系构建a.数据b 预训练c 微调d 评测e.模型部署f.agent 智能体 3 相关论文解读4 ref 1 简介 书生浦语 InternLM…
阅读更多...
深度Q-Learning在算法交易中的应用

深度Q-Learning在算法交易中的应用

一、说明 在《华尔街的随机漫步》一书中&#xff0c;作者伯顿马尔基尔&#xff08;Burton G. Malkiel&#xff09;声称&#xff1a;“一只蒙着眼睛的猴子向报纸的财经版面投掷飞镖&#xff0c;可以选择一个与专家精心挑选的投资组合一样好的投资组合。 如果我们让巴甫洛夫的狗接…
阅读更多...
RabbitMQ-交换机

RabbitMQ-交换机

文章目录 交换机fanoutDirecttopicHeadersRPC 交换机 **交换机 **是消息队列中的一个组件&#xff0c;其作用类似于网络路由器。它负责将我们发送的消息转发到相应的目标&#xff0c;就像快递站将快递发送到对应的站点&#xff0c;或者网络路由器将网络请求转发到相应的服务器…
阅读更多...
使用prompt_toolkit构建交互式命令行工具

使用prompt_toolkit构建交互式命令行工具

prompt_toolkit是一个python库&#xff0c;用于构建命令行工具和终端应用。其官网介绍如下&#xff0c; prompt_toolkit is a library for building powerful interactive command line and terminal applications in Python. 安装命令如下&#xff0c; pip install prompt_to…
阅读更多...
CCIA信息系统业务安全服务资质证书介绍条件要求

CCIA信息系统业务安全服务资质证书介绍条件要求

CCIA&#xff08;中国通信工业协会&#xff09;证书是由中国通信工业协会颁发的一种专业资质证书&#xff0c;旨在评估和认证信息化建设企业在信息化项目建设中提供的服务能力。该证书不涉及技术和产品标准&#xff0c;而是重点强调企业在行业服务方向、安全服务意识和专业服务…
阅读更多...
基于Springboot的心灵治愈交流平台

基于Springboot的心灵治愈交流平台

基于SpringbootVue的心灵治愈交流平台的设计与实现 开发语言&#xff1a;Java数据库&#xff1a;MySQL技术&#xff1a;SpringbootMybatis工具&#xff1a;IDEA、Maven、Navicat 系统展示 用户登录 首页展示 系统公告 心理咨询师 心灵专栏 压力测试 小纸条 后台登录界面 后…
阅读更多...
CST电磁仿真物体表面的Sheet结构和生成3D Model【基础教程】

CST电磁仿真物体表面的Sheet结构和生成3D Model【基础教程】

由Sheet结构生成3D Model 使用Shell Solid and Thicken Sheet&#xff01; Modeling > Tools > Shape Tools > Shell Solid or Thicken Sheet Shell Solidor ThickenSheet会根据不同类型的模型提供两种完全不同的功能。 如033.由3D Model生成Cavity 所述&#xff…
阅读更多...
量子密钥分发系统设计与实现（一）：系统基本架构讨论

量子密钥分发系统设计与实现（一）：系统基本架构讨论

经过一段时间讨论&#xff0c;我们了解到量子密钥分发设备是当前量子保密通信系统的基础。从本文开始&#xff0c;我将开启量子密钥分发系统设计与实现系列&#xff0c;详细讨论量子密钥分发设备如何从0到1的搭建。 1.QKD系统总体讨论 QKD系统的核心功能就是为通信双方提供理论…
阅读更多...
后端插入数据库问题

后端插入数据库问题

IDEA报错&#xff1a;Error updating database. Cause: java.sql.SQLException: Column count doesn’t match value count at row 1 1、看报错消息&#xff0c;SQLException&#xff0c;定位到SQL语句问题 并且看best guess最好猜测&#xff0c;再去找路径下的ShoppingCartMa…
阅读更多...
第十二章 屏幕后处理效果

第十二章 屏幕后处理效果

屏幕后处理效果是实现屏幕特效的常见方法。 建立一个基本的屏幕后处理的脚本 屏幕后处理指的是在渲染完整个场景得到屏幕图像后，再对这个图像进行一系列操作，实现各种屏幕特效。 想要实现屏幕后处理的基础在于抓取屏幕。Unity为我们提供了一个接口-OnRenderImage函数。 声…
阅读更多...
【C语言回顾】函数

【C语言回顾】函数

前言1. 函数的概念和分类2.库函数3. 自定义函数3.1 自定义函数的简单介绍3.2 自定义函数举例 4. 形参和实参4.1 形参4.2 实参4.3 形参和实参的关系4.3.1 理解4.3.2 举例代码和调试 5. 嵌套函数和链式访问5.1 嵌套函数5.2 链式访问 6. 函数的声明和定义6.1 单个文件6.2 多个文件…
阅读更多...
Java PDF文件流传输过程中速度很慢，如何解决？

Java PDF文件流传输过程中速度很慢，如何解决？

专栏集锦&#xff0c;大佬们可以收藏以备不时之需&#xff1a; Spring Cloud 专栏&#xff1a;http://t.csdnimg.cn/WDmJ9 Python 专栏&#xff1a;http://t.csdnimg.cn/hMwPR Redis 专栏&#xff1a;http://t.csdnimg.cn/Qq0Xc TensorFlow 专栏&#xff1a;http://t.csdni…
阅读更多...
Https网站接口被黑被恶意调取

Https网站接口被黑被恶意调取

背景&#xff1a; 维护的一个网站最近短信接口被黑&#xff0c;发送大量短信。起初以为是在网站内部操作&#xff0c;优化了发送短信前的操作&#xff0c;如添加图形验证码&#xff0c;屏蔽国外IP等。但后续还存在被调取情况&#xff0c;定位排查到是该接口在外部被恶意调取。 …
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站