14Java文件操作-I/O流

已于 2023-07-28 08:31:45 修改
阅读量253 收藏
点赞数
文章标签： java
于 2023-07-27 17:31:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45863727/article/details/131920627
版权

14Java文件操作-I/O流

File类

File类概述和构造方法

  • File类介绍

    • 它是文件和目录路径名的抽象表示
    • 文件和目录是可以通过File封装成对象的
    • 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的

  • File类的构造方法

    方法名说明
    File(String pathname)通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
    File(String parent, String child)从父路径名字符串和子路径名字符串创建新的 File实例
    File(File parent, String child)从父抽象路径名和子路径名字符串创建新的 File实例

  • 示例代码

public class FileDemo01 {
    public static void main(String[] args) {
        //File(String pathname)：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
        File f1 = new File("E:\\itcast\\java.txt");
        System.out.println(f1);

        //File(String parent, String child)：从父路径名字符串和子路径名字符串创建新的 File实例。
        File f2 = new File("E:\\itcast","java.txt");
        System.out.println(f2);

        //File(File parent, String child)：从父抽象路径名和子路径名字符串创建新的 File实例。
        File f3 = new File("E:\\itcast");
        File f4 = new File(f3,"java.txt");
        System.out.println(f4);
    }
}

File类创建功能

  • 方法分类

    方法名说明
    public boolean createNewFile()当具有该名称的文件不存在时，创建一个由该抽象路径名命名的新空文件
    public boolean mkdir()创建由此抽象路径名命名的目录
    public boolean mkdirs()创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录

  • 示例代码

public class FileDemo02 {
    public static void main(String[] args) throws IOException {
        //需求1：我要在E:\\itcast目录下创建一个文件java.txt
        File f1 = new File("E:\\itcast\\java.txt");
        System.out.println(f1.createNewFile());
        System.out.println("--------");

        //需求2：我要在E:\\itcast目录下创建一个目录JavaSE
        File f2 = new File("E:\\itcast\\JavaSE");
        System.out.println(f2.mkdir());
        System.out.println("--------");

        //需求3：我要在E:\\itcast目录下创建一个多级目录JavaWEB\\HTML
        File f3 = new File("E:\\itcast\\JavaWEB\\HTML");
//        System.out.println(f3.mkdir());
        System.out.println(f3.mkdirs());
        System.out.println("--------");

        //需求4：我要在E:\\itcast目录下创建一个文件javase.txt
        File f4 = new File("E:\\itcast\\javase.txt");
//        System.out.println(f4.mkdir());
        System.out.println(f4.createNewFile());
    }
}

File类判断和获取功能

  • 判断功能

    方法名说明
    public boolean isDirectory()测试此抽象路径名表示的File是否为目录
    public boolean isFile()测试此抽象路径名表示的File是否为文件
    public boolean exists()测试此抽象路径名表示的File是否存在

  • 获取功能

    方法名说明
    public String getAbsolutePath()返回此抽象路径名的绝对路径名字符串
    public String getPath()将此抽象路径名转换为路径名字符串
    public String getName()返回由此抽象路径名表示的文件或目录的名称
    public String[] list()返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
    public File[] listFiles()返回此抽象路径名表示的目录中的文件和目录的File对象数组

  • 示例代码

public class FileDemo04 {
    public static void main(String[] args) {
        //创建一个File对象
        File f = new File("myFile\\java.txt");

//        public boolean isDirectory()：测试此抽象路径名表示的File是否为目录
//        public boolean isFile()：测试此抽象路径名表示的File是否为文件
//        public boolean exists()：测试此抽象路径名表示的File是否存在
        System.out.println(f.isDirectory());
        System.out.println(f.isFile());
        System.out.println(f.exists());

//        public String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串
//        public String getPath()：将此抽象路径名转换为路径名字符串
//        public String getName()：返回由此抽象路径名表示的文件或目录的名称
        System.out.println(f.getAbsolutePath());
        System.out.println(f.getPath());
        System.out.println(f.getName());
        System.out.println("--------");

//        public String[] list()：返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
//        public File[] listFiles()：返回此抽象路径名表示的目录中的文件和目录的File对象数组
        File f2 = new File("E:\\itcast");

        String[] strArray = f2.list();
        for(String str : strArray) {
            System.out.println(str);
        }
        System.out.println("--------");

        File[] fileArray = f2.listFiles();
        for(File file : fileArray) {
//            System.out.println(file);
//            System.out.println(file.getName());
            if(file.isFile()) {
                System.out.println(file.getName());
            }
        }
    }
}

File类删除功能

  • 方法分类

    方法名说明
    public boolean delete()删除由此抽象路径名表示的文件或目录

  • 示例代码

public class FileDemo03 {
    public static void main(String[] args) throws IOException {
//        File f1 = new File("E:\\itcast\\java.txt");
        //需求1：在当前模块目录下创建java.txt文件
        File f1 = new File("myFile\\java.txt");
//        System.out.println(f1.createNewFile());

        //需求2：删除当前模块目录下的java.txt文件
        System.out.println(f1.delete());
        System.out.println("--------");

        //需求3：在当前模块目录下创建itcast目录
        File f2 = new File("myFile\\itcast");
//        System.out.println(f2.mkdir());

        //需求4：删除当前模块目录下的itcast目录
        System.out.println(f2.delete());
        System.out.println("--------");

        //需求5：在当前模块下创建一个目录itcast,然后在该目录下创建一个文件java.txt
        File f3 = new File("myFile\\itcast");
//        System.out.println(f3.mkdir());
        File f4 = new File("myFile\\itcast\\java.txt");
//        System.out.println(f4.createNewFile());

        //需求6：删除当前模块下的目录itcast
        System.out.println(f4.delete());
        System.out.println(f3.delete());
    }
}
  • 绝对路径和相对路径的区别
    • 绝对路径：完整的路径名，不需要任何其他信息就可以定位它所表示的文件。例如：E:\itcast\java.txt
    • 相对路径：必须使用取自其他路径名的信息进行解释。例如：myFile\java.txt

递归

递归概念

  • 递归的介绍

    • 以编程的角度来看，递归指的是方法定义中调用方法本身的现象
    • 把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解
    • 递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算

  • 递归的注意事项

    • 递归一定要有出口。否则内存溢出
    • 递归虽然有出口，但是递归的次数也不宜过多。否则内存溢出

递归优化不死神兔问题

public class DiGuiDemo {
    public static void main(String[] args) {
        //回顾不死神兔问题，求第20个月兔子的对数
        //每个月的兔子对数：1,1,2,3,5,8，...
        int[] arr = new int[20];

        arr[0] = 1;
        arr[1] = 1;

        for (int i = 2; i < arr.length; i++) {
            arr[i] = arr[i - 1] + arr[i - 2];
        }
        System.out.println(arr[19]);
        System.out.println(f(20));
    }

    /*
        递归解决问题，首先就是要定义一个方法：
            定义一个方法f(n)：表示第n个月的兔子对数
            那么，第n-1个月的兔子对数该如何表示呢？f(n-1)
            同理，第n-2个月的兔子对数该如何表示呢？f(n-2)

        StackOverflowError:当堆栈溢出发生时抛出一个应用程序递归太深
     */
    public static int f(int n) {
        if(n==1 || n==2) {
            return 1;
        } else {
            return f(n - 1) + f(n - 2);
        }
    }
}

递归求阶乘

  • 案例需求
    ​ 用递归求5的阶乘，并把结果在控制台输出

  • 代码实现

    public class DiGuiDemo01 {
    public static void main(String[] args) {
        //调用方法
        int result = jc(5);
        //输出结果
        System.out.println("5的阶乘是：" + result);
    }

    //定义一个方法，用于递归求阶乘，参数为一个int类型的变量
    public static int jc(int n) {
        //在方法内部判断该变量的值是否是1
        if(n == 1) {
            //是：返回1
            return 1;
        } else {
            //不是：返回n*(n-1)!
            return n*jc(n-1);
        }
    }
}

递归遍历目录

  • 案例需求
    ​ 给定一个路径(E:\itcast)，通过递归完成遍历该目录下所有内容，并把所有文件的绝对路径输出在控制台

  • 代码实现

public class DiGuiDemo02 {
    public static void main(String[] args) {
        //根据给定的路径创建一个File对象
//        File srcFile = new File("E:\\itcast");
        File srcFile = new File("E:\\itheima");

        //调用方法
        getAllFilePath(srcFile);
    }

    //定义一个方法，用于获取给定目录下的所有内容，参数为第1步创建的File对象
    public static void getAllFilePath(File srcFile) {
        //获取给定的File目录下所有的文件或者目录的File数组
        File[] fileArray = srcFile.listFiles();
        //遍历该File数组，得到每一个File对象
        if(fileArray != null) {
            for(File file : fileArray) {
                //判断该File对象是否是目录
                if(file.isDirectory()) {
                    //是：递归调用
                    getAllFilePath(file);
                } else {
                    //不是：获取绝对路径输出在控制台
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
    }
}

IO流

IO流概述和分类

  • IO流介绍
    • IO：输入/输出(Input/Output)
    • 流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输
    • IO流就是用来处理设备间数据传输问题的。常见的应用：文件复制；文件上传；文件下载
  • IO流的分类
    • 按照数据的流向
      • 输入流：读数据
      • 输出流：写数据
    • 按照数据类型来分
      • 字节流
        • 字节输入流
        • 字节输出流
      • 字符流
        • 字符输入流
        • 字符输出流
  • IO流的使用场景
    • 如果操作的是纯文本文件，优先使用字符流
    • 如果操作的是图片、视频、音频等二进制文件。优先使用字节流
    • 如果不确定文件类型，优先使用字节流。字节流是万能的流

字节流写数据

  • 字节流抽象基类

    • InputStream：这个抽象类是表示字节输入流的所有类的超类
    • OutputStream：这个抽象类是表示字节输出流的所有类的超类
    • 子类名特点：子类名称都是以其父类名作为子类名的后缀

  • 字节输出流

    • FileOutputStream(String name)：创建文件输出流以指定的名称写入文件

  • 使用字节输出流写数据的步骤

    • 创建字节输出流对象(调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件)
    • 调用字节输出流对象的写数据方法
    • 释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源)

  • 示例代码

public class FileOutputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        //FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
        /*
            做了三件事情：
                A:调用系统功能创建了文件
                B:创建了字节输出流对象
                C:让字节输出流对象指向创建好的文件
         */

        //void write(int b)：将指定的字节写入此文件输出流
        fos.write(97);
//        fos.write(57);
//        fos.write(55);

        //最后都要释放资源
        //void close()：关闭此文件输出流并释放与此流相关联的任何系统资源。
        fos.close();
    }
}

字节流写数据的三种方式

  • 写数据的方法分类

    方法名说明
    void write(int b)将指定的字节写入此文件输出流 一次写一个字节数据
    void write(byte[] b)将 b.length字节从指定的字节数组写入此文件输出流 一次写一个字节数组数据
    void write(byte[] b, int off, int len)将 len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流 一次写一个字节数组的部分数据

  • 示例代码

public class FileOutputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
        //new File(name)
//        FileOutputStream fos = new FileOutputStream(new File("myByteStream\\fos.txt"));

        //FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件
//        File file = new File("myByteStream\\fos.txt");
//        FileOutputStream fos2 = new FileOutputStream(file);
//        FileOutputStream fos2 = new FileOutputStream(new File("myByteStream\\fos.txt"));

        //void write(int b)：将指定的字节写入此文件输出流
//        fos.write(97);
//        fos.write(98);
//        fos.write(99);
//        fos.write(100);
//        fos.write(101);

//        void write(byte[] b)：将 b.length字节从指定的字节数组写入此文件输出流
//        byte[] bys = {97, 98, 99, 100, 101};
        //byte[] getBytes()：返回字符串对应的字节数组
        byte[] bys = "abcde".getBytes();
//        fos.write(bys);

        //void write(byte[] b, int off, int len)：将 len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流
//        fos.write(bys,0,bys.length);
        fos.write(bys,1,3);

        //释放资源
        fos.close();
    }
}

字节流写数据的两个小问题

  • 字节流写数据如何实现换行

    • windows:\r\n
    • linux:\n
    • mac:\r

  • 字节流写数据如何实现追加写入

    • public FileOutputStream(String name,boolean append)
    • 创建文件输出流以指定的名称写入文件。如果第二个参数为true ，则字节将写入文件的末尾而不是开头

  • 示例代码

public class FileOutputStreamDemo03 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
//        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt",true);

        //写数据
        for (int i = 0; i < 10; i++) {
            fos.write("hello".getBytes());
            fos.write("\r\n".getBytes());
        }

        //释放资源
        fos.close();
    }
}

字节流写数据加异常处理

  • 异常处理格式

    • try-catch-finally

      try{
	可能出现异常的代码;
}catch(异常类名 变量名){
	异常的处理代码;
}finally{
	执行所有清除操作;
}

    • finally特点

      • 被finally控制的语句一定会执行，除非JVM退出

  • 示例代码

public class FileOutputStreamDemo04 {
    public static void main(String[] args) {
        //加入finally来实现释放资源
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("myByteStream\\fos.txt");
            fos.write("hello".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

字节流读数据(一次读一个字节数据)

  • 字节输入流

    • FileInputStream(String name)：通过打开与实际文件的连接来创建一个FileInputStream ，该文件由文件系统中的路径名name命名

  • 字节输入流读取数据的步骤

    • 创建字节输入流对象
    • 调用字节输入流对象的读数据方法
    • 释放资源

  • 示例代码

public class FileInputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        //FileInputStream(String name)
        FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");

        int by;
        /*
            fis.read()：读数据
            by=fis.read()：把读取到的数据赋值给by
            by != -1：判断读取到的数据是否是-1
         */
        while ((by=fis.read())!=-1) {
            System.out.print((char)by);
        }

        //释放资源
        fis.close();
    }
}

字节流读数据(一次读一个字节数组数据)

  • 一次读一个字节数组的方法

    • public int read(byte[] b)：从输入流读取最多b.length个字节的数据
    • 返回的是读入缓冲区的总字节数,也就是实际的读取字节个数

  • 示例代码

public class FileInputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");

        /*
            hello\r\n
            world\r\n

            第一次：hello
            第二次：\r\nwor
            第三次：ld\r\nr

         */

        byte[] bys = new byte[1024]; //1024及其整数倍
        int len;
        while ((len=fis.read(bys))!=-1) {
            System.out.print(new String(bys,0,len));
        }

        //释放资源
        fis.close();
    }
}

字节流复制文本文件

  • 案例需求
    ​ 把“E:\file\謎罹.txt”复制到模块目录下的“謎罹.txt”

  • 实现步骤

    • 复制文本文件，其实就把文本文件的内容从一个文件中读取出来(数据源)，然后写入到另一个文件中(目的地)

    • 数据源：
      ​ E:\file\謎罹.txt — 读数据 — InputStream — FileInputStream

    • 目的地：
      ​ E:\謎罹.txt — 写数据 — OutputStream — FileOutputStream

  • 代码实现

public class CopyTxtDemo {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("E:\\file\\謎罹.txt");
        //根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("E:\\謎罹.txt");

        //读写数据，复制文本文件(一次读取一个字节，一次写入一个字节)
        int by;
        while((by = fis.read()) != -1) {
            fos.write(by);
        }

        //释放资源
        fos.close();
        fis.close();
    }
}

字节流复制图片

  • 案例需求
    ​ 把“E:\file\lay.jpg”复制到E盘目录下的“lay.jpg”

  • 实现步骤

    • 根据数据源创建字节输入流对象
    • 根据目的地创建字节输出流对象
    • 读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
    • 释放资源

  • 代码实现

public class CopyJpgDemo {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("E:\\file\\lay.jpg");
        //根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("E:\\lay.jpg");

        //读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
        byte[] bytes = new byte[1024];
        int len;
        while ((len = fis.read(bytes)) != -1) {
            fos.write(bytes,0,len);
        }
        
        //释放资源
        fos.close();
        fis.close();
    }
}

字节缓冲流

字节缓冲流构造方法

  • 字节缓冲流介绍

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

  • 构造方法：

    方法名说明
    BufferedOutputStream(OutputStream out)创建字节缓冲输出流对象
    BufferedInputStream(InputStream in)创建字节缓冲输入流对象

  • 示例代码

public class BufferStreamDemo {
    public static void main(String[] args) throws IOException {
        //字节缓冲输出流：BufferedOutputStream(OutputStream out)
 
        BufferedOutputStream bos = new BufferedOutputStream(new 				                                       FileOutputStream("myByteStream\\bos.txt"));
        //写数据
        bos.write("hello\r\n".getBytes());
        bos.write("world\r\n".getBytes());
        //释放资源
        bos.close();
    

        //字节缓冲输入流：BufferedInputStream(InputStream in)
        BufferedInputStream bis = new BufferedInputStream(new                                                          FileInputStream("myByteStream\\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();
    }
}

字节流复制视频

  • 案例需求
    把“E:\file\字节流复制图片.avi”复制到E盘目录下的“字节流复制图片.avi”

  • 实现步骤

    • 根据数据源创建字节输入流对象

    • 根据目的地创建字节输出流对象

    • 读写数据，复制视频

    • 释放资源

  • 代码实现

public class CopyAviDemo {
    public static void main(String[] args) throws IOException{
        //记录开始时间
        long startTime = System.currentTimeMillis();

        //测试不同的方法
        //method1();
        //method2();
        //method3();
        method4();

        //记录结束时间
        long endTime = System.currentTimeMillis();

        //计算耗时
        long usedTime = endTime - startTime;
        System.out.println("耗时" + usedTime + "毫秒");
    }

    //基本字节流一次读写一个字节
    public static void method1() throws IOException {
        //E:\\file\\字节流复制图片.avi
        //E盘目录下的 字节流复制图片.avi
        FileInputStream fis = new FileInputStream("E:\\file\\字节流复制图片.avi");
        FileOutputStream fos = new FileOutputStream("E:\\字节流复制图片.avi");

        int by;
        while ((by = fis.read()) != -1) {
            fos.write(by);
        }

        //释放资源
        fos.close();
        fis.close();
    }

    //基本字节流一次读写一个字节数组
    public static void method2() throws IOException {
        //E:\\file\\字节流复制图片.avi
        //E盘目录下的 字节流复制图片.avi
        FileInputStream fis = new FileInputStream("E:\\file\\字节流复制图片.avi");
        FileOutputStream fos = new FileOutputStream("E:\\字节流复制图片.avi");

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

        //释放资源
        fos.close();
        fis.close();
    }

    //字节缓冲流一次读写一个字节
    public static void method3() throws IOException {
//        FileInputStream fis = new FileInputStream("E:\\file\\字节流复制图片.avi");
//        FileOutputStream fos = new FileOutputStream("E:\\字节流复制图片.avi");
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\file\\字节流复制图片.avi"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\字节流复制图片.avi"));

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

        //释放资源
        bos.close();
        bis.close();
    }

    //字节缓冲流一次读写一个字节数组
    public static void method4() throws IOException {
//        FileInputStream fis = new FileInputStream("E:\\file\\字节流复制图片.avi");
//        FileOutputStream fos = new FileOutputStream("E:\\字节流复制图片.avi");
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\file\\字节流复制图片.avi"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\字节流复制图片.avi"));
        
        byte[] bytes = new byte[1024];
        int len;
        while ((len = bis.read(bytes)) != -1) {
            bos.write(bytes,0,len);
        }
        
        //释放资源
        bos.close();
        bis.close();
    }
}

字符流

为什么会出现字符流

  • 字符流的介绍
    由于字节流操作中文不是特别的方便，所以Java就提供字符流
    字符流 = 字节流 + 编码表

  • 中文的字节存储方式
    用字节流复制文本文件时，文本文件也会有中文，但是没有问题，原因是最终底层操作会自动进行字节拼接成中文，如何识别是中文的呢？
    汉字在存储的时候，无论选择哪种编码存储，第一个字节都是负数

编码表

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

  • 常见的字符集

    • ASCII字符集：
      lASCII：是基于拉丁字母的一套电脑编码系统，用于显示现代英语，主要包括控制字符(回车键、退格、换行键等)和可显示字符(英文大小写字符、阿拉伯数字和西文符号)
      基本的ASCII字符集，使用7位表示一个字符，共128字符。ASCII的扩展字符集使用8位表示一个字符，共256字符，方便支持欧洲常用字符。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等

    • GBXXX字符集：
      GBK：最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案，共收录了21003个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等

    • Unicode字符集：
      UTF-8编码：可以用来表示Unicode标准中任意字符，它是电子邮件、网页及其他存储或传送文字的应用 中，优先采用的编码。互联网工程工作小组（IETF）要求所有互联网协议都必须支持UTF-8编码。它使用一至四个字节为每个字符编码

      编码规则：
      128个US-ASCII字符，只需一个字节编码
      拉丁文等字符，需要二个字节编码
      大部分常用字（含中文），使用三个字节编码
      其他极少使用的Unicode辅助字符，使用四字节编码

字符串中的编码解码问题

  • 相关方法

    方法名说明
    byte[] getBytes()使用平台的默认字符集将该 String编码为一系列字节
    byte[] getBytes(String charsetName)使用指定的字符集将该 String编码为一系列字节
    String(byte[] bytes)使用平台的默认字符集解码指定的字节数组来创建字符串
    String(byte[] bytes, String charsetName)通过指定的字符集解码指定的字节数组来创建字符串

  • 代码演示

public class StringDemo {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //定义一个字符串
        String s = "中国";

        //byte[] bys = s.getBytes(); //[-28, -72, -83, -27, -101, -67]
        //byte[] bys = s.getBytes("UTF-8"); //[-28, -72, -83, -27, -101, -67]
        byte[] bys = s.getBytes("GBK"); //[-42, -48, -71, -6]
        System.out.println(Arrays.toString(bys));

        //String ss = new String(bys);
        //String ss = new String(bys,"UTF-8");
        String ss = new String(bys,"GBK");
        System.out.println(ss);
    }
}

字符流中的编码解码问题

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

    • InputStreamReader：是从字节流到字符流的桥梁
      ​ 它读取字节，并使用指定的编码将其解码为字符
      ​ 它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集

    • OutputStreamWriter：是从字符流到字节流的桥梁
      ​ 是从字符流到字节流的桥梁，使用指定的编码将写入的字符编码为字节
      ​ 它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集

  • 构造方法

    方法名说明
    InputStreamReader(InputStream in)使用默认字符编码创建InputStreamReader对象
    InputStreamReader(InputStream in,String chatset)使用指定的字符编码创建InputStreamReader对象
    OutputStreamWriter(OutputStream out)使用默认字符编码创建OutputStreamWriter对象
    OutputStreamWriter(OutputStream out,String charset)使用指定的字符编码创建OutputStreamWriter对象

  • 代码演示

public class ConversionStreamDemo {
    public static void main(String[] args) throws IOException {
        //OutputStreamWriter osw = new OutputStreamWriter(new                                             FileOutputStream("myCharStream\\osw.txt"));
        OutputStreamWriter osw = new OutputStreamWriter(new                                              FileOutputStream("myCharStream\\osw.txt"),"GBK");
        osw.write("中国");
        osw.close();

        //InputStreamReader isr = new InputStreamReader(new 	                                         FileInputStream("myCharStream\\osw.txt"));
        InputStreamReader isr = new InputStreamReader(new                                                 FileInputStream("myCharStream\\osw.txt"),"GBK");
        //一次读取一个字符数据
        int ch;
        while ((ch=isr.read())!=-1) {
            System.out.print((char)ch);
        }
        isr.close();
    }
}

字符流写数据的5种方式

  • 方法介绍

    方法名说明
    void write(int c)写一个字符
    void write(char[] cbuf)写入一个字符数组
    void write(char[] cbuf, int off, int len)写入字符数组的一部分
    void write(String str)写一个字符串
    void write(String str, int off, int len)写一个字符串的一部分

  • 刷新和关闭的方法

    方法名说明
    flush()刷新流，之后还可以继续写数据
    close()关闭流，释放资源，但是在关闭之前会先刷新流。一旦关闭，就不能再写数据

  • 代码演示

public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"));

        //void write(int c)：写一个字符
//        osw.write(97);
//        osw.write(98);
//        osw.write(99);

        //void writ(char[] cbuf)：写入一个字符数组
        char[] chs = {'a', 'b', 'c', 'd', 'e'};
//        osw.write(chs);

        //void write(char[] cbuf, int off, int len)：写入字符数组的一部分
//        osw.write(chs, 0, chs.length);
//        osw.write(chs, 1, 3);

        //void write(String str)：写一个字符串
//        osw.write("abcde");

        //void write(String str, int off, int len)：写一个字符串的一部分
//        osw.write("abcde", 0, "abcde".length());
        osw.write("abcde", 1, 3);

        //释放资源
        osw.close();
    }
}

字符流读数据的2种方式

  • 方法介绍

    方法名说明
    int read()一次读一个字符数据
    int read(char[] cbuf)一次读一个字符数组数据

  • 代码演示

public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
   
        InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\ConversionStreamDemo.java"));

        //int read()：一次读一个字符数据
//        int ch;
//        while ((ch=isr.read())!=-1) {
//            System.out.print((char)ch);
//        }

        //int read(char[] cbuf)：一次读一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len = isr.read(chs)) != -1) {
            System.out.print(new String(chs, 0, len));
        }

        //释放资源
        isr.close();
    }
}

字符缓冲流

  • 字符缓冲流介绍

    • BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途

    • BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小。 默认值足够大，可用于大多数用途

  • 构造方法

    方法名说明
    BufferedWriter(Writer out)创建字符缓冲输出流对象
    BufferedReader(Reader in)创建字符缓冲输入流对象

  • 代码演示

public class BufferedStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //BufferedWriter(Writer out)
        BufferedWriter bw = new BufferedWriter(new                                                            FileWriter("myCharStream\\bw.txt"));
        bw.write("hello\r\n");
        bw.write("world\r\n");
        bw.close();

        //BufferedReader(Reader in)
        BufferedReader br = new BufferedReader(new                                                           FileReader("myCharStream\\bw.txt"));

        //一次读取一个字符数据
//        int ch;
//        while ((ch=br.read())!=-1) {
//            System.out.print((char)ch);
//        }

        //一次读取一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len=br.read(chs))!=-1) {
            System.out.print(new String(chs,0,len));
        }

        br.close();
    }
}

字符缓冲流特有功能

  • 方法介绍
    BufferedWriter：

    方法名说明
    void newLine()写一行行分隔符，行分隔符字符串由系统属性定义

    BufferedReader:

    方法名说明
    String readLine()读一行文字。 结果包含行的内容的字符串，不包括任何行终止字符如果流的结尾已经到达，则为null

  • 代码演示

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

        //创建字符缓冲输出流
        BufferedWriter bw = new BufferedWriter(new                                                          FileWriter("myCharStream\\bw.txt"));

        //写数据
        for (int i = 0; i < 10; i++) {
            bw.write("hello" + i);
            //bw.write("\r\n");
            bw.newLine();
            bw.flush();
        }

        //释放资源
        bw.close();

        //创建字符缓冲输入流
        BufferedReader br = new BufferedReader(new                                                          FileReader("myCharStream\\bw.txt"));

        String line;
        while ((line=br.readLine())!=null) {
            System.out.println(line);
        }

        br.close();
    }
}

IO流小结

  • 字节流
    在这里插入图片描述

  • 字符流
    在这里插入图片描述

  • 字符流和字节流的区别

    • 字节流操作的基本单元是字节；字符流操作的基本单元是字符
    • 字节流默认不使用缓冲区，而字符流使用缓冲区
    • 字节流通常用于处理二进制数据，不支持直接读写字符；字符流通常用于处理文本数据

  • 两者使用情景
    在读写文件需要对文本内容进行处理：按行处理、比较特定字符的时候一般会选择字符流；仅仅读写文件，不处理内容，一般选择字节流。

IO特殊操作流

标准输入流

  • System类中有两个静态的成员变量

    • public static final InputStream in：标准输入流。通常该流对应于键盘输入或由主机环境或用户指定的另一个输入源
    • public static final PrintStream out：标准输出流。通常该流对应于显示输出或由主机环境或用户指定的另一个输出目标

  • 自己实现键盘录入数据

public class SystemInDemo {
    public static void main(String[] args) throws IOException {
        //public static final InputStream in：标准输入流
//        InputStream is = System.in;

//        int by;
//        while ((by=is.read())!=-1) {
//            System.out.print((char)by);
//        }

        //如何把字节流转换为字符流？用转换流
//        InputStreamReader isr = new InputStreamReader(is);
//        //使用字符流能不能够实现一次读取一行数据呢？可以
//        //但是，一次读取一行数据的方法是字符缓冲输入流的特有方法
//        BufferedReader br = new BufferedReader(isr);

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        System.out.println("请输入一个字符串：");
        String line = br.readLine();
        System.out.println("你输入的字符串是：" + line);

        System.out.println("请输入一个整数：");
        int i = Integer.parseInt(br.readLine());
        System.out.println("你输入的整数是：" + i);

        //自己实现键盘录入数据太麻烦了，所以Java就提供了一个类供我们使用
        Scanner sc = new Scanner(System.in);
    }
}

标准输出流

  • System类中有两个静态的成员变量

    • public static final InputStream in：标准输入流。通常该流对应于键盘输入或由主机环境或用户指定的另一个输入源
    • public static final PrintStream out：标准输出流。通常该流对应于显示输出或由主机环境或用户指定的另一个输出目标

  • 输出语句的本质：是一个标准的输出流

    • PrintStream ps = System.out;
    • PrintStream类有的方法，System.out都可以使用

  • 示例代码

public class SystemOutDemo {
    public static void main(String[] args) {
        //public static final PrintStream out：标准输出流
        PrintStream ps = System.out;

        //能够方便地打印各种数据值
//        ps.print("hello");
//        ps.print(100);

//        ps.println("hello");
//        ps.println(100);

        //System.out的本质是一个字节输出流
        System.out.println("hello");
        System.out.println(100);

        System.out.println();
//        System.out.print();
    }
}

字节打印流

  • 打印流分类

    • 字节打印流：PrintStream
    • 字符打印流：PrintWriter

  • 打印流的特点

    • 只负责输出数据，不负责读取数据
    • 永远不会抛出IOException
    • 有自己的特有方法

  • 字节打印流

    • PrintStream(String fileName)：使用指定的文件名创建新的打印流
    • 使用继承父类的方法写数据，查看的时候会转码；使用自己的特有方法写数据，查看的数据原样输出
    • 可以改变输出语句的目的地
      ​ public static void setOut(PrintStream out)：重新分配“标准”输出流

  • 示例代码

public class PrintStreamDemo {
    public static void main(String[] args) throws IOException {
        //PrintStream(String fileName)：使用指定的文件名创建新的打印流
        PrintStream ps = new PrintStream("myOtherStream\\ps.txt");

        //写数据
        //字节输出流有的方法
//        ps.write(97);

        //使用特有方法写数据
//        ps.print(97);
//        ps.println();
//        ps.print(98);
        ps.println(97);
        ps.println(98);
        
        //释放资源
        ps.close();
    }
}

字符打印流

  • 字符打印流构造房方法

    方法名说明
    PrintWriter(String fileName)使用指定的文件名创建一个新的PrintWriter，而不需要自动执行刷新
    PrintWriter(Writer out, boolean autoFlush)创建一个新的PrintWriter out：字符输出流 autoFlush： 一个布尔值，如果为真，则println ， printf ，或format方法将刷新输出缓冲区

  • 示例代码

public class PrintWriterDemo {
    public static void main(String[] args) throws IOException {
        //PrintWriter(String fileName) ：使用指定的文件名创建一个新的PrintWriter，而不需要自动执行行刷新
//        PrintWriter pw = new PrintWriter("myOtherStream\\pw.txt");

//        pw.write("hello");
//        pw.write("\r\n");
//        pw.flush();
//        pw.write("world");
//        pw.write("\r\n");
//        pw.flush();

//        pw.println("hello");
        /*
            pw.write("hello");
            pw.write("\r\n");
         */
//        pw.flush();
//        pw.println("world");
//        pw.flush();

        //PrintWriter(Writer out, boolean autoFlush)：创建一个新的PrintWriter
        PrintWriter pw = new PrintWriter(new FileWriter("myOtherStream\\pw.txt"),true);
//        PrintWriter pw = new PrintWriter(new FileWriter("myOtherStream\\pw.txt"),false);

        pw.println("hello");
        /*
            pw.write("hello");
            pw.write("\r\n");
            pw.flush();
         */
        pw.println("world");

        pw.close();
    }
}

对象序列化流

  • 对象序列化介绍

    • 对象序列化：就是将对象保存到磁盘中，或者在网络中传输对象
    • 这种机制就是使用一个字节序列表示一个对象，该字节序列包含：对象的类型、对象的数据和对象中存储的属性等信息
    • 字节序列写到文件之后，相当于文件中持久保存了一个对象的信息
    • 反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化

  • 对象序列化流： ObjectOutputStream

    • 将Java对象的原始数据类型和图形写入OutputStream。 可以使用ObjectInputStream读取（重构）对象。 可以通过使用流的文件来实现对象的持久存储。 如果流是网络套接字流，则可以在另一个主机上或另一个进程中重构对象

  • 构造方法

    方法名说明
    ObjectOutputStream(OutputStream out)创建一个写入指定的OutputStream的ObjectOutputStream

  • 序列化对象的方法

    方法名说明
    void writeObject(Object obj)将指定的对象写入ObjectOutputStream

  • 示例代码

    • 学生类
      public class Student implements Serializable {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
    • 测试类
      public class ObjectOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //ObjectOutputStream(OutputStream out)：创建一个写入指定的OutputStream的ObjectOutputStream
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("myOtherStream\\oos.txt"));

        //创建对象
        Student s = new Student("林青霞",30);

        //void writeObject(Object obj)：将指定的对象写入ObjectOutputStream
        oos.writeObject(s);

        //释放资源
        oos.close();
    }
}

  • 注意事项

    • 一个对象要想被序列化，该对象所属的类必须必须实现Serializable 接口
    • Serializable是一个标记接口，实现该接口，不需要重写任何方法

对象反序列化流

  • 对象反序列化流： ObjectInputStream

    • ObjectInputStream反序列化先前使用ObjectOutputStream编写的原始数据和对象

  • 构造方法

    方法名说明
    ObjectInputStream(InputStream in)创建从指定的InputStream读取的ObjectInputStream

  • 反序列化对象的方法

    方法名说明
    Object readObject()从ObjectInputStream读取一个对象

  • 示例代码

public class ObjectInputStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //ObjectInputStream(InputStream in)：创建从指定的InputStream读取的ObjectInputStream
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("myOtherStream\\oos.txt"));

        //Object readObject()：从ObjectInputStream读取一个对象
        Object obj = ois.readObject();

        Student s = (Student) obj;
        System.out.println(s.getName() + "," + s.getAge());

        ois.close();
    }
}

serialVersionUID&transient

  • serialVersionUID

    • 用对象序列化流序列化了一个对象后，假如我们修改了对象所属的类文件，读取数据会不会出问题呢？
      • 会出问题，会抛出InvalidClassException异常
    • 如果出问题了，如何解决呢？
      • 重新序列化
      • 给对象所属的类加一个serialVersionUID
        • private static final long serialVersionUID = 42L;

  • transient

    • 如果一个对象中的某个成员变量的值不想被序列化，又该如何实现呢？
      • 给该成员变量加transient关键字修饰，该关键字标记的成员变量不参与序列化过程

  • 示例代码

    • 学生类
      public class Student implements Serializable {
    private static final long serialVersionUID = 42L;
    private String name;
//    private int age;
    private transient int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

//    @Override
//    public String toString() {
//        return "Student{" +
//                "name='" + name + '\'' +
//                ", age=" + age +
//                '}';
//    }
}
    • 测试类
      public class ObjectStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
//        write();
        read();
    }

    //反序列化
    private static void read() throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("myOtherStream\\oos.txt"));
        Object obj = ois.readObject();
        Student s = (Student) obj;
        System.out.println(s.getName() + "," + s.getAge());
        ois.close();
    }

    //序列化
    private static void write() throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("myOtherStream\\oos.txt"));
        Student s = new Student("林青霞", 30);
        oos.writeObject(s);
        oos.close();
    }
}

Properties集合

Properties作为Map集合的使用

  • Properties介绍

    • 是一个Map体系的集合类
    • Properties可以保存到流中或从流中加载
    • 属性列表中的每个键及其对应的值都是一个字符串

  • Properties基本使用

    public class PropertiesDemo01 {
    public static void main(String[] args) {
        //创建集合对象
//        Properties<String,String> prop = new Properties<String,String>(); //错误
        Properties prop = new Properties();

        //存储元素
        prop.put("itheima001", "林青霞");
        prop.put("itheima002", "张曼玉");
        prop.put("itheima003", "王祖贤");

        //遍历集合
        Set<Object> keySet = prop.keySet();
        for (Object key : keySet) {
            Object value = prop.get(key);
            System.out.println(key + "," + value);
        }
    }
}

Properties作为Map集合的特有方法

  • 特有方法

    方法名说明
    Object setProperty(String key, String value)设置集合的键和值，都是String类型，底层调用 Hashtable方法 put
    String getProperty(String key)使用此属性列表中指定的键搜索属性
    Set stringPropertyNames()从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串

  • 示例代码

    public class PropertiesDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Properties prop = new Properties();

        //Object setProperty(String key, String value)：设置集合的键和值，都是String类型，底层调用Hashtable方法put
        prop.setProperty("itheima001", "林青霞");
        /*
            Object setProperty(String key, String value) {
                return put(key, value);
            }

            Object put(Object key, Object value) {
                return map.put(key, value);
            }
         */
        prop.setProperty("itheima002", "张曼玉");
        prop.setProperty("itheima003", "王祖贤");

        //String getProperty(String key)：使用此属性列表中指定的键搜索属性
//        System.out.println(prop.getProperty("itheima001"));
//        System.out.println(prop.getProperty("itheima0011"));

//        System.out.println(prop);

        //Set<String> stringPropertyNames()：从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串
        Set<String> names = prop.stringPropertyNames();
        for (String key : names) {
//            System.out.println(key);
            String value = prop.getProperty(key);
            System.out.println(key + "," + value);
        }
    }
}

Properties和IO流相结合的方法

  • 和IO流结合的方法

    方法名说明
    void load(InputStream inStream)从输入字节流读取属性列表（键和元素对）
    void load(Reader reader)从输入字符流读取属性列表（键和元素对）
    void store(OutputStream out, String comments)将此属性列表（键和元素对）写入此 Properties表中，以适合于使用 load(InputStream)方法的格式写入输出字节流
    void store(Writer writer, String comments)将此属性列表（键和元素对）写入此 Properties表中，以适合使用 load(Reader)方法的格式写入输出字符流

  • 示例代码

    public class PropertiesDemo03 {
    public static void main(String[] args) throws IOException {
        //把集合中的数据保存到文件
//        myStore();

        //把文件中的数据加载到集合
        myLoad();

    }

    private static void myLoad() throws IOException {
            Properties prop = new Properties();

        //void load(Reader reader)：
        FileReader fr = new FileReader("myOtherStream\\fw.txt");
        prop.load(fr);
        fr.close();

        System.out.println(prop);
    }

    private static void myStore() throws IOException {
        Properties prop = new Properties();

        prop.setProperty("itheima001","林青霞");
        prop.setProperty("itheima002","张曼玉");
        prop.setProperty("itheima003","王祖贤");

        //void store(Writer writer, String comments)：
        FileWriter fw = new FileWriter("myOtherStream\\fw.txt");
        prop.store(fw,null);
        fw.close();
    }
}
謎罹
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
java文件操作-IO流
qq_53464269的博客
03-03 2316
文件操作
Java文件操作-I/O流
qq_49001678的博客
02-17 767
File类是文件和目录路径名的抽象表示文件和目录是可以通过File封装成对象的File封装的不是一个真实存在的文件，只是一个路径名；它可以存在，也可以不存在；将来要通过具体的操作把这个路径的内容转换为具体存在。从编程来看，递归是指方法定义中调用方法本身的现象。递归可以把一个复杂问题层层转化为一个相较于原问题规模较小的问题来求解。只需少量程序就可描述出解题过程中的多次重复计算。注意事项递归一定要有出口，否则内存溢出。但是递归次数不宜过多。否则也会溢出。逐个分析。
Java中的文件操作与IO流
X_H学Java的博客
04-19 506
本文详细的介绍了如何使用Java操作文件以及如何使用Java中的IO流操作来对文件的内容进行读写，最后也简单介绍了如何使用Files更快捷的读取小文件
IL汇编语言读取控制台输入和转换为整数
bcbobo21cn的专栏
08-05 227
IL汇编语言读取控制台输入；
springboot网络办公系统_sbgs0[独有源码]如何选择高质量的计算机毕业设计
嘉人Java毕设程序源码
08-05 94
选题背景： 随着信息技术的快速发展和互联网的普及，网络办公系统作为一种新型的办公方式逐渐受到了广大企事业单位的关注和应用。传统的办公模式存在着诸多问题，如沟通效率低下、信息传递不及时、文件管理困难等，给工作效率和质量带来了一定的影响。而网络办公系统的出现，为企事业单位提供了一个高效、便捷、安全的办公平台，极大地改善了办公环境和工作效率。 选题意义： 网络办公系统的引入和应用对于企事业单位具有重要的意义。首先，网络办公系统能够实现信息的共享和协同办公，使得各部门之间的沟通更加便捷高效，避免了传统办公模式中频
Java使用I/O流读取文件内容的方法详解
08-25
Java使用I/O流读取文件内容的方法详解 Java使用I/O流读取文件内容的方法是Java编程中常用的文件读取方式。该方法可以将文件内容读取到程序中，并对其进行处理和分析。在Java中，I/O流是指数据流向某个对象的数据...
Java I/O技术之文件操作详解
09-04
Java I/O技术是Java编程中不可或缺的一部分，它用于处理输入和输出操作，特别是在与文件系统交互时。在Java中，I/O操作的核心是`java.io`包，它提供了丰富的类和接口来支持文件操作和其他形式的数据传输。本文将深入...
Java课程设计报告书-学生版-1_I/O流与文件课程设计_
09-30
本课程设计报告书——“Java课程设计报告书-学生版-1_I/O流与文件课程设计_”旨在帮助学生深入理解并掌握如何在Java中进行文件操作，通过实际的实验案例来学习文件对象和流类的应用。 一、Java I/O流概述 Java的I/O...
Java I/O中I/O流的典型使用方式详解
08-25
Java I/O中I/O流的典型使用方式详解是Java编程中的一种重要技术，它提供了多种方式来处理输入和输出操作。下面将详细介绍四种典型的I/O流使用方式：缓冲输入文件、从内存输入、格式化的内存输入和基本的文件输出。 ...
java基础之I/O流
10-12
通过学习和理解这些知识点，初学者能够熟练地使用Java I/O流进行各种数据操作，无论是简单的文件读写，还是复杂的网络数据交换，都能游刃有余。在实际编程中，根据需求选择合适的流类型和组合，能有效地提升程序的...
I/O 函数/缓存和字节流、占位符、getchar()，putchar()
最新发布
阿利同学的博客
08-06 938
C 语言提供了一些函数，用于与外部设备通信，称为输入输出函数，简称 I/O 函数。输入（import）指的是获取外部数据，输出（export）指的是向外部传递数据。
【备战秋招】每日一题:2023.03.19-米哈游(第二题)--构造数组
m0_73659489的博客
08-05 139
为了更好的阅读体检，可以查看我的算法。
第十三章 配置Production - 添加HL7业务操作
yaoxin521123的博客
08-06 224
运行时向用户设备发送通知的能力。警报可以通过电子邮件、文本寻呼机或其他机制发送。以根据警报消息的来源（即哪个元素出现问题）和各种条件（例如一天中的时间）将警报消息路由到不同的业务操作。中，只需将其标识为接收消息的目标即可。可以配置任意数量的复制这些起始操作的目标。中，并根据需要对其进行配置。以下小节提供详细信息。传递文件，并且不想将文件解析或格式化为。路由规则集确定适合使用哪个目标。默认值是此操作所基于的类的名称。此选择确定此业务操作的主机类。品中，必须创建它，将其集成到。，则可以选择其中任何一个。
回归预测 | MATLAB实现基于SVM-RFE-BP支持向量机递归特征消除特征选择算法结合BP神经网络的多输入单输出回归预测
关注并私信文章链接，获取对应文章源码和数据，机器学习之心的博客。
08-05 1446
回归预测 | MATLAB实现基于SVM-RFE-BP支持向量机递归特征消除特征选择算法结合BP神经网络的多输入单输出回归预测
2020年06月 Python（一级）真题解析#中国电子学会#全国青少年软件编程等级考试
人生就是一个不断学习的过程
08-05 764
以下哪种输入结果不可能得到以下反馈： 重要的事情说三遍：安全第一！安全第一！安全第一！A：print(“重要事情说三遍：”+“安全第一！”*3)B：print(“重要事情说三遍：”+“安全第一！“+”安全第一！”*2)C：print(“重要事情说三遍：”+“安全第一！”+“安全第一！”+“安全第一！”)D：print(“重要事情说三遍：”+“安全第一！”/3)正确答案是 D解析：题目要求输出 “重要的事情说三遍：安全第一！安全第一！安全第一！
Java IO流
can_chen的博客
09-26 306
文章目录一、文件1. 创建文件2. 文件相关操作3. 目录相关操作二、IO流1. IO流的分类2. IO流体系图三、字节文件流1. 字节文件输入流 FileInputStream2. 字节文件输出流 FileOutputStream四、字符文件流1. 字符文件输入流 FileReader2. 字符文件输出流 FileWriter五、节点流和处理流六、字符缓冲流1. 字符输入缓冲流 BufferedReader2. 字符输出缓冲流 BufferedWriter3. 通过BufferedReader和Buf
java入门之 文件处理 (I/O流)
Y_999777的博客
11-18 530
介绍I/O流（FIle、类File、字节流、字符流 及相关代码）
【JAVA】File I/O
未入门的程序员笔记
09-12 2161
Java：File I/O
Java—文件I/O操作
LiLi的博客
08-08 3109
大多数的应用程序都需要与外部的输入/输出设备I/O（Input/Output）进行数据交换。在Java中，所有的I/O机制都是基于数据“流”方式进行输入/输出。这些“数据流”可视为同一台计算机不同设备或网络中不同计算机之间流动的数据序列。如同水管里的水流一样，在水管的一端一点一滴地供水，而在水管的另一端看到的是一股连续不断的水流。 Java把这些不同来源和目标的数据统一抽象为“数据流”。当Java程序需要读取数据时，就会开启一个通向数据源的流，这个数据源可以是文件、内存、也可以是网络连接。而当Java程序需
Java I/O流详解：缓冲区与文件操作
文件操作I/O流涉及对文件的读写操作，如使用`FileInputStream`和`FileOutputStream`读写文件，或者使用`FileReader`和`FileWriter`处理文本文件。在进行文件操作时，需要注意异常处理，如`FileNotFoundException`和`...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值