javase加强，九、File、方法递归、IO流

最新推荐文章于 2024-05-23 17:45:07 发布
最新推荐文章于 2024-05-23 17:45:07 发布
阅读量46 收藏
点赞数
分类专栏： Javase 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42403145/article/details/126111365
版权

File

File类概述

  • File类可以定位文件及操作文件（删除、获取文本信息），不能读写文件
  • IO流技术可以读写文件
  • File类创建对象
方法名称说明
public File(String pathname)根据文件路径创建文件对象
public File(String parent, String child)根据父路径名字符串和子路径名字符串创建文件对象
public File(File parent, String child)根据父路径对应文件对象和子路径名字符串创建文件对象
public class FileDemo {
    public static void main(String[] args) {
        // 1、创建File对象（指定了文件的路径）
        // 路径写法： D:\resources\xueshan.jpeg
        //          D:/resources/xueshan.jpeg
        //          File.separator //分割器，因为在别的系统中不一定是斜杠代表分割器
//        File f = new File("D:\\resources\\xueshan.jpeg");
//        File f = new File("D:/resources/xueshan.jpeg");
        File f = new File("D:" + File.separator+"resources"+ File.separator +"xueshan.jpeg");
        long size = f.length(); // 是文件的字节大小
        System.out.println(size);

        // 2、File创建对象，支持绝对路径 支持相对路径（重点）
        File f1 = new File("D:\\resources\\beauty.jpeg"); // 绝对路径
        System.out.println(f1.length());

        // 相对路径：一般定位模块中的文件的。 相对到工程下！！
        File f2 = new File("file-io-app/src/data.txt");
        System.out.println(f2.length());

        // 3、File创建对象 ，可以是文件也可以是文件夹
        File f3 = new File("D:\\resources");
        System.out.println(f3.exists()); // 判断这个路径是否存在，这个文件夹存在否

    }
}

File类常用API

  • API

  • 方法名称说明
    public boolean isDirectory()判断此路径名表示的File是否为文件夹
    public boolean isFile()判断此路径名表示的File是否为文件
    public boolean exists()判断此路径名表示的File是否存在
    public long length()返回文件的大小（字节数量）
    public String getAbsolutePath()返回文件的绝对路径
    public String getPath()返回定义文件时使用的路径
    public String getName()返回文件的名称，带后缀
    public long lastModified()返回文件的最后修改时间（时间毫秒值）
public class FileDemo02 {
    public static void main(String[] args) {
        // 1.绝对路径创建一个文件对象
        File f1 = new File("D:/resources/xueshan.jpeg");
        // a.获取它的绝对路径。
        System.out.println(f1.getAbsolutePath());
        // b.获取文件定义的时候使用的路径。
        System.out.println(f1.getPath());
        // c.获取文件的名称：带后缀。
        System.out.println(f1.getName());
        // d.获取文件的大小：字节个数。
        System.out.println(f1.length()); // 字节大小
        // e.获取文件的最后修改时间
        long time = f1.lastModified();
        System.out.println("最后修改时间：" + new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(time));    //毫秒值转化成习惯看的时间格式
        // f、判断文件是文件还是文件夹
        System.out.println(f1.isFile()); // true
        System.out.println(f1.isDirectory()); // false

        System.out.println("-------------------------");

        File f2 = new File("file-io-app\\src\\data.txt");
        // a.获取它的绝对路径。
        System.out.println(f2.getAbsolutePath());
        // b.获取文件定义的时候使用的路径。
        System.out.println(f2.getPath());
        // c.获取文件的名称：带后缀。
        System.out.println(f2.getName());
        // d.获取文件的大小：字节个数。
        System.out.println(f2.length()); // 字节大小
        // e.获取文件的最后修改时间
        long time1 = f2.lastModified();
        System.out.println("最后修改时间：" + new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(time1));
        // f、判断文件是文件还是文件夹
        System.out.println(f2.isFile()); // true
        System.out.println(f2.isDirectory()); // false
        System.out.println(f2.exists()); // true

        File file = new File("D:/");
        System.out.println(file.isFile()); // false
        System.out.println(file.isDirectory()); // true
        System.out.println(file.exists()); // true

        File file1 = new File("D:/aaa");
        System.out.println(file1.isFile()); // false
        System.out.println(file1.isDirectory()); // false
        System.out.println(file1.exists()); // false

    }
}
  • 拷贝工程里的文件的路径：鼠标右击文件，然后点“copy path”
  • 路径用相对路径比较好
  • 创建文件
方法名称说明
public boolean createNewFile()创建一个新的空的文件
public boolean mkdir()只能创建一级文件夹
public boolean mkdirs()可以创建多级文件夹
  • 删除文件
方法名称说明
public boolean delete()删除由此抽象路径名表示的文件或空文件夹
public class FileDemo03 {
    public static void main(String[] args) throws IOException {
        File f = new File("file-io-app\\src\\data.txt");
        // a.创建新文件，创建成功返回true ,反之 ,一般不需要这个，以后文件写出去的时候都会自动创建
        System.out.println(f.createNewFile());

        // b.mkdir创建一级目录
        File f2 = new File("D:/resources/aaa");
        System.out.println(f2.mkdir());

        // c.mkdirs创建多级目录(重点)
        File f3 = new File("D:/resources/ccc/ddd/eee/ffff");
//        System.out.println(f3.mkdir());
        System.out.println(f3.mkdirs()); // 支持多级创建

        // d.删除文件或者空文件夹
        System.out.println(f.delete());
        File f4 = new File("D:/resources/xueshan.jpeg");
        System.out.println(f4.delete()); // 占用一样可以删除

        // 只能删除空文件夹,不能删除非空文件夹.
        File f5 = new File("D:/resources/aaa");
        System.out.println(f5.delete());
    }
}
  • File遍历
方法名称说明
public String[] list()获取当前目录下所有的"一级文件名称"到一个字符串数组中去返回。
public File[] listFiles()(常用)获取当前目录下所有的"一级文件对象"到一个文件对象数组中去返回（重点）
  • listFiles方法注意事项：
    • 当文件不存在时或者代表文件时，返回null
    • 当文件对象代表一个空文件夹时，返回一个长度为0的数组
    • 当文件对象是一个有内容的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回
    • 当文件对象是一个有隐藏文件的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回，包含隐藏文件
    • 当没有权限访问该文件夹时，返回null
public class FileDemo04 {
    public static void main(String[] args) {
        // 1、定位一个目录
        File f1 = new File("D:/resources");
        String[] names = f1.list();
        for (String name : names) {
            System.out.println(name);
        }

        // 2.一级文件对象
        // 获取当前目录下所有的"一级文件对象"到一个文件对象数组中去返回（重点）
        File[] files = f1.listFiles();
        for (File f : files) {
            System.out.println(f.getAbsolutePath());
        }

        // 注意事项
        File dir = new File("D:/resources/ddd");
        File[] files1 = dir.listFiles();
        System.out.println(Arrays.toString(files1));
    }
}

递归

  • 递归案例：
  • 文件搜索、从C:盘中，搜索出某个文件名称并输出绝对路径。
    • ①先定位出的应该是一级文件对象
    • ②遍历全部一级文件对象，判断是否是文件
    • ③如果是文件，判断是否是自己想要的
    • ④如果是文件夹，需要继续递归进去重复上述过程
public class RecursionDemo05 {
    public static void main(String[] args) {
        // 2、传入目录 和  文件名称
        searchFile(new File("D:/") , "eDiary.exe");
    }

    /**
     * 1、搜索某个目录下的全部文件，找到我们想要的文件。
     * @param dir  被搜索的源目录
     * @param fileName 被搜索的文件名称
     */
    public static void searchFile(File dir,String fileName){
        // 3、判断dir是否是目录
        if(dir != null && dir.isDirectory()){
            // 可以找了
            // 4、提取当前目录下的一级文件对象
            File[] files = dir.listFiles(); // null  []
            // 5、判断是否存在一级文件对象，存在才可以遍历
            if(files != null && files.length > 0) {
                for (File file : files) {
                    // 6、判断当前遍历的一级文件对象是文件 还是 目录
                    if(file.isFile()){
                        // 7、是不是咱们要找的，是把其路径输出即可
                        if(file.getName().contains(fileName)){
                            System.out.println("找到了：" + file.getAbsolutePath());
                            // 启动它。
                            try {
                                Runtime r = Runtime.getRuntime();
                                r.exec(file.getAbsolutePath());
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    }else {
                        // 8、是文件夹，需要继续递归寻找
                        searchFile(file, fileName);
                    }
                }
            }
        }else {
            System.out.println("对不起，当前搜索的位置不是文件夹！");
        }
    }
}

  • 递归案例：啤酒问题

  • 啤酒2元1瓶，4个盖子可以换一瓶，2个空瓶可以换一瓶，

    请问10元钱可以喝多少瓶酒，剩余多少空瓶和盖子。

public class RecursionDemo06 {

    // 定义一个静态的成员变量用于存储可以买的酒数量
    public static int totalNumber; // 总数量
    public static int lastBottleNumber; // 记录每次剩余的瓶子个数
    public static int lastCoverNumber; // 记录每次剩余的盖子个数


    public static void main(String[] args) {
        // 1、拿钱买酒
        buy(10);
        System.out.println("总数：" + totalNumber);
        System.out.println("剩余盖子数：" + lastCoverNumber);
        System.out.println("剩余瓶子数：" + lastBottleNumber);
    }

    public static void buy(int money){
        // 2、看可以立马买多少瓶
        int buyNumber = money / 2; // 5
        totalNumber += buyNumber;

        // 3、把盖子 和瓶子换算成钱
        // 统计本轮总的盖子数  和 瓶子数
        int coverNumber = lastCoverNumber + buyNumber;
        int bottleNumber = lastBottleNumber + buyNumber;

        // 统计可以换算的钱
        int allMoney = 0;
        if(coverNumber >= 4){
            allMoney += (coverNumber / 4) * 2;
        }
        lastCoverNumber = coverNumber % 4;

        if(bottleNumber >= 2){
            allMoney += (bottleNumber / 2) * 2;
        }
        lastBottleNumber = bottleNumber % 2;

        if(allMoney >= 2){
            buy(allMoney);
        }
    }
}

字符集

  • 字符集：多个字符的集合

  • GBK：

    • GBK是中国的码表，包含了几万个汉字等字符，同时也要兼容ASCII编码，

    • GBK编码中一个中文字符一般以两个字节的形式存储。

  • Unicode字符集：

    • 统一码，也叫万国码。是计算机科学领域里的一项业界标准。
    • UTF-8编码后一个中文一般以三个字节的形式存储，同时也要兼容ASCII编码表。
    • 技术人员都应该使用UTF-8的字符集编码。

  • 常见字符集底层字符的编码：

    • 英文和数字等在任何国家的字符集中都占1个字节
    • GBK字符中一个中文字符占2个字节
    • UTF-8编码中一个中文1般占3个字节

  • 编码前的字符集和解码时的字符集有什么要求？

    • 必须一致，否则会出现字符乱码（编码前用GBK，那么解码时也要用GBK）
    • 英文和数字不会乱码
  • String编码：
方法名称说明
byte[] getBytes()使用平台的默认字符集将该 String编码为一系列字节，将结果存储到新的字节数组中
byte[] getBytes(String charsetName)使用指定的字符集将该 String编码为一系列字节，将结果存储到新的字节数组中
  • String解码：
构造器说明
String(byte[] bytes)通过使用平台的默认字符集解码指定的字节数组来构造新的 String
String(byte[] bytes, String charsetName)通过指定的字符集解码指定的字节数组来构造新的 String
public class Test {
    public static void main(String[] args) throws Exception {
        // 1、编码：把文字转换成字节（使用指定的编码）
        String name = "abc我爱你中国";
        // byte[] bytes = name.getBytes(); // 以当前代码默认字符集进行编码 （UTF-8）
        byte[] bytes = name.getBytes("GBK"); // 指定编码
        System.out.println(bytes.length);
        System.out.println(Arrays.toString(bytes));

        // 2、解码：把字节转换成对应的中文形式（编码前 和 编码后的字符集必须一致，否则乱码 ）
        // String rs = new String(bytes); // 默认的UTF-8
        String rs = new String(bytes, "GBK"); // 指定GBK解码
        System.out.println(rs);
    }
}

IO流

  • IO流分类：
    • 字符流：字符输入流、字符输出流
    • 字节流：字节输入流、字节输出流
  • 文件字节输入流：FileInputStream
构造器说明
public FileInputStream(File file)创建字节输入流管道与源文件对象接通
public FileInputStream(String pathname)创建字节输入流管道与源文件路径接通
方法名称说明
public int read()每次读取一个字节返回，如果字节已经没有可读的返回-1
public int read(byte[] buffer)每次读取一个字节数组返回，如果字节已经没有可读的返回-1
public class FileInputStreamDemo01 {
    public static void main(String[] args) throws Exception {
        // 1、创建一个文件字节输入流管道与源文件接通。
        // InputStream is = new FileInputStream(new File("file-io-app\\src\\data.txt"));
        // 简化写法
        InputStream is = new FileInputStream("file-io-app\\src\\data.txt");

        // 2、读取一个字节返回 （每次读取一滴水）
//        int b1 = is.read();
//        System.out.println((char)b1);
//
//        int b2 = is.read();
//        System.out.println((char)b2);
//
//        int b3 = is.read();
//        System.out.println((char)b3);
//
//        int b4 = is.read(); // 读取完毕返回-1
//        System.out.println(b4);

        // 3、使用循环改进
        // 定义一个变量记录每次读取的字节    a  b  3   爱
        //                              o o  o   [ooo]
        int b;
        while (( b = is.read() ) != -1){
            System.out.print((char) b);
        }
    }
}
  • read这个API每次读取一个字节存在的问题
    • 性能较慢
    • 读取中文字符输出会出现乱码，且无法避免
public class FileInputStreamDemo02 {
    public static void main(String[] args) throws Exception {
        // 1、创建一个文件字节输入流管道与源文件接通
        InputStream is = new FileInputStream("file-io-app/src/data02.txt");

        // 2、定义一个字节数组，用于读取字节数组
//        byte[] buffer = new byte[3]; // 3B
//        int len = is.read(buffer);
//        System.out.println("读取了几个字节：" + len);
//        String rs = new String(buffer);
//        System.out.println(rs);
//
//        int len1 = is.read(buffer);
//        System.out.println("读取了几个字节：" + len1);
//        String rs1 = new String(buffer);
//        System.out.println(rs1);
//        // buffer = [a b c]
//  
//        // buffer = [a b c]  ==>  [c d c]
//        int len2 = is.read(buffer);
//        System.out.println("读取了几个字节：" + len2);
//        // 读取多少倒出多少
//        String rs2 = new String(buffer,0 ,len2);
//        System.out.println(rs2);
//
//        int len3 = is.read(buffer);
//        System.out.println(len3); // 读取完毕返回-1

        // 3、改进使用循环，每次读取一个字节数组
        byte[] buffer = new byte[3];
        int len; // 记录每次读取的字节数。
        while ((len = is.read(buffer)) != -1) {
            // 读取多少倒出多少
            System.out.print(new String(buffer, 0 , len));
        }
    }
}
  • 一次读三个字节，仍然不能避免乱码问题

  • 避免乱码：

    1. 自己定义一个字节数组和文件大小一样，一口气把文件读完
    2. 使用官方的API
    方法名称说明
    public byte[] readAllBytes() throws IOException直接将当前字节输入流对应的文件对象的字节数据装到一个字节数组返回
public class FileInputStreamDemo03 {
    public static void main(String[] args) throws Exception {
        // 1、创建一个文件字节输入流管道与源文件接通
        File f = new File("file-io-app/src/data03.txt");
        InputStream is = new FileInputStream(f);

        // 2、定义一个字节数组与文件的大小刚刚一样大。
//        byte[] buffer = new byte[(int) f.length()];
//        int len = is.read(buffer);
//        System.out.println("读取了多少个字节：" + len);
//        System.out.println("文件大小：" + f.length());
//        System.out.println(new String(buffer));

        // 读取全部字节数组
        byte[] buffer = is.readAllBytes();
        System.out.println(new String(buffer));

    }
}
  • 文件输出流：FileOutputStream
  • 可以不提前新建文件，只需要在地址中把文件名补齐，系统会自动创建文件
构造器说明
public FileOutputStream(File file)创建字节输出流管道与源文件对象接通
public FileOutputStream(File file，boolean append)创建字节输出流管道与源文件对象接通，可追加数据
public FileOutputStream(String filepath)创建字节输出流管道与源文件路径接通
public FileOutputStream(String filepath，boolean append)创建字节输出流管道与源文件路径接通，可追加数据
  • 写数据的API
方法名称说明
public void write(int a)写一个字节出去
public void write(byte[] buffer)写一个字节数组出去
public void write(byte[] buffer , int pos , int len)写一个字节数组的一部分出去。
  • 流的刷新和关闭
方法说明
flush()刷新流，还可以继续写数据
close()关闭流，释放资源，但是在关闭之前会先刷新流。一旦关闭，就不能再写数据
  • 换行的API:os.write(“\r\n”.getBytes())
public class OutputStreamDemo04 {
    public static void main(String[] args) throws Exception {
        // 1、创建一个文件字节输出流管道与目标文件接通
        OutputStream os = new FileOutputStream("file-io-app/src/out04.txt" , true); // 追加数据管道
//        OutputStream os = new FileOutputStream("file-io-app/src/out04.txt"); // 先清空之前的数据，写新数据进入

        // 2、写数据出去
        // a.public void write(int a):写一个字节出去
        os.write('a');
        os.write(98);
        os.write("\r\n".getBytes()); // 换行
        // os.write('徐'); // [ooo]

        // b.public void write(byte[] buffer):写一个字节数组出去。
        byte[] buffer = {'a' , 97, 98, 99};
        os.write(buffer);
        os.write("\r\n".getBytes()); // 换行

        byte[] buffer2 = "我是中国人".getBytes();
//        byte[] buffer2 = "我是中国人".getBytes("GBK");
        os.write(buffer2);
        os.write("\r\n".getBytes()); // 换行


        // c. public void write(byte[] buffer , int pos , int len):写一个字节数组的一部分出去。
        byte[] buffer3 = {'a',97, 98, 99};
        os.write(buffer3, 0 , 3);
        os.write("\r\n".getBytes()); // 换行

        // os.flush(); // 写数据必须，刷新数据 可以继续使用流
        os.close(); // 释放资源，包含了刷新的！关闭后流不可以使用了
    }
}
  • 字节流适合任何文件的拷贝
  • 字节流案例：拷贝文件（视频，图片，文本）
public class CopyDemo05 {
    public static void main(String[] args) {
        try {
            // 1、创建一个字节输入流管道与原视频接通
            InputStream is = new FileInputStream("file-io-app/src/out04.txt");

            // 2、创建一个字节输出流管道与目标文件接通
            OutputStream os = new FileOutputStream("file-io-app/src/out05.txt");

            // 3、定义一个字节数组转移数据
            byte[] buffer = new byte[1024];
            int len; // 记录每次读取的字节数。
            while ((len = is.read(buffer)) != -1){
                os.write(buffer, 0 , len);
            }
            System.out.println("复制完成了！");

            // 4、关闭流。
            os.close();
            is.close();
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}
  • 释放资源的方式：try-catch-finally
  • finally：放在try-catch后面的，无论是正常执行还是异常执行代码，最后一定要执行，除非JVM退出。
public class TryCatchFinallyDemo1 {
    public static void main(String[] args) {
        InputStream is = null;
        OutputStream os = null;
        try {

            // System.out.println(10/ 0);

            // 1、创建一个字节输入流管道与原视频接通
             is = new FileInputStream("file-io-app/src/out04.txt");

            // 2、创建一个字节输出流管道与目标文件接通
             os = new FileOutputStream("file-io-app/src/out05.txt");

            // 3、定义一个字节数组转移数据
            byte[] buffer = new byte[1024];
            int len; // 记录每次读取的字节数。
            while ((len = is.read(buffer)) != -1){
                os.write(buffer, 0 , len);
            }
            System.out.println("复制完成了！");

         //   System.out.println( 10 / 0);

        } catch (Exception e){
            e.printStackTrace();
        } finally {
            // 无论代码是正常结束，还是出现异常都要最后执行这里
            System.out.println("========finally=========");
            try {
                // 4、关闭流。
                if(os!=null)os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(is != null) is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        System.out.println(test(10, 2));
    }

    public static int test(int a , int b){
        try {
            int c = a / b;
            return c;
        }catch (Exception e){
            e.printStackTrace();
            return -111111; // 计算出现bug.
        }finally {
            System.out.println("--finally--");
            // 哪怕上面有return语句执行，也必须先执行完这里才可以！
            // 开发中不建议在这里加return ，如果加了，返回的永远是这里的数据了，这样会出问题！
            return 100;
        }
    }
}

  • JDK7和JDK9对try-catch-finally进行改进，可以自动释放资源

  • 资源都是实现了Closeable/AutoCloseable接口的类对象

    • 源码中输出流和输入流都实现了这个接口
    • public abstract class InputStream implements Closeable {}
    • public abstract class OutputStream implements Closeable, Flushable{}

  • JDK7中

    • try(定义流对象){
      可能出现异常的代码;
      }catch(异常类名 变量名){
      异常的处理代码;
      }

  • JDK9中

    • 定义输入流对象;

      定义输出流对象;

      try(输入流对象；输出流对象){
      可能出现异常的代码;
      }catch(异常类名 变量名){
      异常的处理代码;
      }

public class TryCatchResouceDemo2 {
    public static void main(String[] args) {

        try (
                // 这里面只能放置资源对象，用完会自动关闭：自动调用资源对象的close方法关闭资源（即使出现异常也会做关闭操作）
                // 1、创建一个字节输入流管道与原视频接通
               InputStream is = new FileInputStream("file-io-app/src/out04.txt");
                // 2、创建一个字节输出流管道与目标文件接通
               OutputStream os = new FileOutputStream("file-io-app/src/out05.txt");

               // int age = 23; // 这里只能放资源
                MyConnection connection = new MyConnection(); // 最终会自动调用资源的close方法
                ) {

            // 3、定义一个字节数组转移数据
            byte[] buffer = new byte[1024];
            int len; // 记录每次读取的字节数。
            while ((len = is.read(buffer)) != -1){
                os.write(buffer, 0 , len);
            }
            System.out.println("复制完成了！");

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

    }
}

class MyConnection implements AutoCloseable{
    @Override
    public void close() throws IOException {
        System.out.println("连接资源被成功释放了！");
    }
}

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

        // 这里面只能放置资源对象，用完会自动关闭：自动调用资源对象的close方法关闭资源（即使出现异常也会做关闭操作）
        // 1、创建一个字节输入流管道与原视频接通
        InputStream is = new FileInputStream("file-io-app/src/out04.txt");
        // 2、创建一个字节输出流管道与目标文件接通
        OutputStream os = new FileOutputStream("file-io-app/src/out05.txt");
        try ( is ; os ) {
            // 3、定义一个字节数组转移数据
            byte[] buffer = new byte[1024];
            int len; // 记录每次读取的字节数。
            while ((len = is.read(buffer)) != -1){
                os.write(buffer, 0 , len);
            }
            System.out.println("复制完成了！");

        } catch (Exception e){
            e.printStackTrace();
        }
    }
}
  • 文件字符输入流：Reader
  • 好处是不会出现乱码，坏处是性能较慢
构造器说明
public FileReader(File file)创建字符输入流管道与源文件对象接通
public FileReader(String pathname)创建字符输入流管道与源文件路径接通
方法名称说明
public int read()每次读取一个字符返回，如果字符已经没有可读的返回-1
public int read(char[] buffer)每次读取一个字符数组，返回读取的字符个数，如果字符已经没有可读的返回-1
public class FileReaderDemo01 {
    public static void main(String[] args) throws Exception {
        // 目标：每次读取一个字符。
        // 1、创建一个字符输入流管道与源文件接通
        Reader fr = new FileReader("file-io-app\\src\\data06.txt");

        // 2、读取一个字符返回，没有可读的字符了返回-1
//        int code = fr.read();
//        System.out.print((char)code);
//
//        int code1 = fr.read();
//        System.out.print((char)code1);

        // 3、使用循环读取字符
        int code;
        while ((code = fr.read()) != -1){
            System.out.print((char) code);
        }
    }
}

public class FileReaderDemo02 {
    public static void main(String[] args) throws Exception {
        // 1、创建一个文件字符输入流与源文件接通
        Reader fr = new FileReader("file-io-app/src/data07.txt");

        // 2、用循环，每次读取一个字符数组的数据。  1024 + 1024 + 8
        char[] buffer = new char[1024]; // 1K字符
        int len;
        while ((len = fr.read(buffer)) != -1) {
            String rs = new String(buffer, 0, len);
            System.out.print(rs);
        }

    }
}
  • 文件字符输出流：FileWriter
构造器说明
public FileWriter(File file)创建字符输出流管道与源文件对象接通
public FileWriter(File file，boolean append)创建字符输出流管道与源文件对象接通，可追加数据
public FileWriter(String filepath)创建字符输出流管道与源文件路径接通
public FileWriter(String filepath，boolean append)创建字符输出流管道与源文件路径接通，可追加数据
  • 写数据的API
方法名称说明
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()关闭流，释放资源，但是在关闭之前会先刷新流。一旦关闭，就不能再写数据
  • 换行：fw.write(“\r\n”)
public class FileWriterDemo03 {
    public static void main(String[] args) throws Exception {
        // 1、创建一个字符输出流管道与目标文件接通
        // Writer fw = new FileWriter("file-io-app/src/out08.txt"); // 覆盖管道，每次启动都会清空文件之前的数据
        Writer fw = new FileWriter("file-io-app/src/out08.txt", true); // 覆盖管道，每次启动都会清空文件之前的数据

//      a.public void write(int c):写一个字符出去
        fw.write(98);
        fw.write('a');
        fw.write('徐'); // 不会出问题了
        fw.write("\r\n"); // 换行

//       b.public void write(String c)写一个字符串出去
        fw.write("abc我是中国人");
        fw.write("\r\n"); // 换行


//       c.public void write(char[] buffer):写一个字符数组出去
        char[] chars = "abc我是中国人".toCharArray();
        fw.write(chars);
        fw.write("\r\n"); // 换行


//       d.public void write(String c ,int pos ,int len):写字符串的一部分出去
        fw.write("abc我是中国人", 0, 5);
        fw.write("\r\n"); // 换行


//       e.public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
        fw.write(chars, 3, 5);
        fw.write("\r\n"); // 换行


        // fw.flush();// 刷新后流可以继续使用
        fw.close(); // 关闭包含刷线，关闭后流不能使用

    }
}
数二150种子选手
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVASE，IO流部分模块导图
01-13
里面包含了字节输入输出流、字符输入输出流的接口继承以及具体...适用于：初学者：能更清晰地认清javaSE的IO流部分接口与实现类之间的关系。 其他人：要使用IO部分但忘记具体的实现类和常用方法可以充当帮助文档使用。
JavaSe基于IO流的用户管理系统
02-19
使用IO流实现文本存储，集合存放用户信息，使用了stream流等java8新特性，适用于大学生大作业、课设，本人原创
JavaSE进阶、File、方法递归、IO流
飞翔的企鹅的博客
07-15 208
/1、创建file对象(指定文件路径)//多于字符删去//两个斜杠表示第一个斜杠告诉后一个斜杠你只是一个斜杠，你不能做转义//也可以使用正斜杠/D//调用APIFile.separator作为分隔符，可以实现跨平台操作，在不同平台匹配不同分隔符//取文件的字节大小//2、File创建对象，支持绝对路径，也支持相对路径(重点)//D\2ProgramTool\JavaTest\filetest\2(2).jpg从盘符开始绝对路径。......
JavaSE# 笔记【File 递归 IO流 字节流 字符流】@Gray
Gary的博客
11-03 139
一.File类 1. 概述 ​ File表示文件或文件夹的路径。 ​ 注意事项：File对象只表示一个路径，不表示文件，所以不管文件存不存在，File对象都不会报错。 2. 构造方法 方法 说明 public File(String pathname) 给定路径名称创建File对象 public File(String parent, String child) 给定父路径和子路径创建File对象 public File(File parent, String child) 给定父路
JavaSE基础自学---IO流--File
真正的大师,永远都怀着一颗学徒的心----易大师
03-16 132
IO流IO流概述 IO流概述 IO流用来处理设备之间的数据传输,(内存-硬盘) 流:系统资源,Windows系统本身就可以操作设备,各种语言只是使用系统的这个资源 使用完该资源一定要释放 Java对数据的操作是通过流(系统资源)的方式 Java对于操作流的对象都在java.io包中 // 将一个具体的对象封装成File 对象,可以封装成存在的文件,也可以不存在的文件 ...
JavaSE（File类、递归、IO概述、字节流）
weixin_50648720的博客
11-28 154
JavaSE阶段File类File类的概述和构造方法File类的概述File类的构造方法File类常用方法获取功能的方法绝对路径和相对路径判断功能的方法创建删除功能的方法File类遍历目录方法递归递归的概述示例代码递归累和递归求阶乘文件搜索IO概述IO的概述IO的分类IO的顶层父类注意事项字节流字节输出流【OutputStream】OutputStream类的概述OutputStream类的常用方法FileOutputStream类FileOutputStream类的概述FileOutputStream类的
JavaSE基础加强之File类与IO流(六)
zzq的博客
03-02 385
文章目录 (一)File类 (二)递归 (三)过滤器 (四)IO字节流 (五)IO字符流 (六)Properties集合 (七)缓冲流 (八)转换流 (九)序列化流 (十)打印流
JavaSE基础笔记——File概述、方法递归、字符集、IO流
weixin_62993347的博客
08-21 379
File类的使用：1、创建File对象；2、常用方法：判断文件类型、获取文件信息；3、创建文件、删除文件功能；4、遍历文件夹。补充知识：方法递归；字符集。IO流：1、概述；2、字节流；3、资源释放的方式。4、字符流的使用。
JavaSE学习笔记 IO流之File类练习题
qq_41537102的博客
03-24 267
IO流之File类练习题1.删单级目录2.递归删除多级文件夹3.判断多级文件夹下有没有.jpg结尾的文件，如果有把后缀名 .jpg 文件改为.png总结 1.删单级目录 桌面上有一个单级目录demo，目录里面的文件如下，请利用File类基本知识来实现删除单级文件夹。 import java.io.File; public class MyTest { public static void main(String[] args) { //删单级目录 //封装桌面
File&递归&字节流
JhonnyLee的博客
08-15 134
1.File类 1.1 File类概述和构造方法 File类介绍 它是文件和目录路径名的抽象表示 文件和目录是可以通过File封装成对象的 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它是可以存在的，也可以是不存在的。将来时要通过具体的操作把这个路径的内容转换为具体存在的 File类的构造方法 方法名 说明 File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的File实例 File(String paren
重学JavaSE 第15章 : File类、IO流介绍、文件流、缓冲流、转换流、对象流等
Guizy
08-03 1444
重温Java File类、IO流介绍、文件流、缓冲流、转换流、对象流等
JavaSE文件IO流详解.pptx
06-08
JavaSE文件IO流详解
JavaSE专题-IO流重点总结(必读).doc
06-03
Try块里面存放的是有可能发生异常的代码,通常和catch块一起使用,catch块用于处理try块中抛出的异常,finally块不是必须的,通常将释放资源(例如IO流的close方法)的代码放到finally块里面 注意:finally和Final还有...
javase-file.zip
05-15
IO流的源文件，里面主要讲了创建File
docker中安装jenkins，并在node和cloud上跑通基于源码控制SCM的pipeline
qq_29022265的博客
05-19 1109
从安装jenkins到创建jenkins的node和cloud，最后再将scm和FreeStyle两种流水线跑通。
Spring Bean Map之舞
m0_51176516的博客
05-23 186
在Spring框架中，Bean的生命周期管理是其核心功能之一。当Spring容器启动时，它会根据配置信息（如XML配置文件、注解等）来创建和管理Bean实例。这些Bean实例默认会被放置在一个Map数据结构中，以便容器能够快速地根据Bean的名称（或ID）来查找和访问它们。 在Spring的源码中，Bean实例的存储和管理主要依赖于DefaultSingletonBeanRegistry类。这个类内部使用了一个名为singletonObjects的Map来存储单例Bea...
分布式锁2-Zookeeper分布式锁实战
qq_43676797的博客
05-19 249
使用curator操作Zookeeper进行实战；：Apache Curator包含一套高级API框架和工具类，它 是Apache ZooKeeper 的Java 客户端库。
Java高级面试精粹：问题与解答集锦（一）
最新发布
Layla_c的博客
05-23 710
答案多态是Java中的一个核心概念，它允许不同类的对象对同一消息做出响应，但具体的行为会根据对象的实际类型而有所不同。重载（Overloading）：当多个方法具有相同的名称，但参数列表不同时，这称为方法重载。编译器根据方法调用时传递的参数类型和数量来确定调用哪个方法。重写（Overriding）：当子类有一个与父类同名、同参数列表的方法时，子类可以提供特定的实现来覆盖父类的方法。运行时，Java虚拟机（JVM）会根据对象的实际类型调用相应的方法，这个过程称为动态绑定或晚期绑定。答案。
全国v3.0) javase加强第一阶段-第2套卷
07-13
他们应该了解Java集合框架、IO流、多线程等核心类库的使用方法和原理，并能够利用这些类库进行开发和优化。 在加强第一阶段的学习中，学习者还应该注重实践。他们应该通过编写各种类型的Java程序来加深对知识的理解...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值