25. File、递归、IO流

最新推荐文章于 2023-04-04 04:01:40 发布
最新推荐文章于 2023-04-04 04:01:40 发布
阅读量236 收藏
点赞数
分类专栏： # Java SE基础 文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010171285/article/details/123175853
版权

File类概述

 

public class Test {
    public static void main(String[] args) {
        // 创建 File对象（指定了文件的路径）
        // 文件名可以是绝对路径，也可以是相对路径
        File f = new File("C:\\Users\\pan\\Desktop\\picture\\1.jpeg");
        File f1 = new File("Learn/src/Picture/1.jpeg");
        System.out.println(f1.length());
        System.out.println(f.length());

        // File创建对象，可以是文件也可以是文件夹
        File f2 = new File("C:\\Users\\pan\\Desktop\\picture");
        System.out.println(f2.exists());
    }
}

File类常用API

判断文件类型、获取文件信息

public class Test {
    public static void main(String[] args) {
        // 1.绝对路径创建一个文件对象
        File f1 = new File("Learn/src/Picture/1.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());
        System.out.println(f1.isDirectory());
    }
}

创建文件、删除文件功能

public class Test {
    public static void main(String[] args) throws IOException {
        File file = new File("Learn/src/Picture/f1.txt");
        // a.创建新文件，创建成功返回true ,反之 ,不需要这个，以后文件写出去的时候都会自动创建
        System.out.println(file.createNewFile());
        // b.mkdir创建一级目录
        File file2 = new File("D:/aaa/aaa");
        System.out.println(file2.mkdir());
        // c.mkdirs创建多级目录(重点)
        File file3 = new File("D:/aaa/aaa/bbbb");
        System.out.println(file3.mkdirs());
        // d.删除文件或者空文件夹
        System.out.println(file3.delete());
        System.out.println(file2.delete());
        // 只能删除空文件夹,不能删除非空文件夹.
    }
}

 

遍历文件夹

public class Test {
    public static void main(String[] args) throws IOException {
        // 1、定位一个目录 只能定义一级文件对象
        File f1 = new File("D:/picture");
        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());
        }
    }
}

方法递归

递归的形式与特点

public class Test {
    public static void main(String[] args) throws IOException {
        test();
    }

    public static void test() {
        System.out.println("===========test被执行===============");
        test(); //方法递归：直接递归形式
    }

    public static void test1() {
        System.out.println("===========test1被执行===============");
        test2(); //方法递归：间接递归
    }

    private static void test2() {
        System.out.println("===========test2被执行===============");
        test1();
    }
}

递归的算法流程、核心要素

public class Test {
    public static void main(String[] args) {
        System.out.println(jc(5));

    }

    public static int jc(int n) {
        if(n == 1) {
            return 1;
        } else {
            return jc(n - 1) * n;
        }
    }
}

递归常见案例

public class Test {
    public static void main(String[] args) throws {
        System.out.println(jc(100));

    }

    public static int jc(int n) {
        if (n == 1) {
            return 1;
        } else {
            return jc(n - 1) + n;
        }
    }
}

递归的经典问题

public class Test {
    public static void main(String[] args) {
        System.out.println(f(1));
    }

    public static int f(int n) {
        if (n == 10) {
            return 1;
        } else {
            return 2 * f(n+1) +2;
        }
    }
}

非规律化递归案例-文件搜索

 

public class Test {
    public static void main(String[] args) {
        // 2. 传入目录和文件夹
        searchFile(new File("D:/") ,"aaa");
    }

    /**
     * 1. 搜索某个目录下的全部文件，找到目标文件
     * @param dir 被搜索的原目录
     * @param fileName 被搜索的文件名称
     */
    public static void searchFile(File dir ,String fileName) {
        // 3. 判断dir是否是文件夹
        if (dir.isDirectory() && (dir != null)) {
            // 开始找
            // 4. 遍历文件夹:提取当前目录下的一级文件对象
            File[] files = dir.listFiles(); //null
            // 5. 判断是否存在一级文件对象
            if (files != null && (files.length > 0)) {
                for (File f : files) {
                    // 6. 判断当前遍历的一级文件是否为文件夹
                    if (f.isFile()) {
                        // 7. 是否是目标文件 ，是输出文件路径
                        if (f.getName().contains(fileName)) {
                            System.out.println("路径为：" + f.getAbsolutePath());
                        }
                    }else {
                        // 是文件夹，需要递归寻找
                        searchFile(f ,fileName);
                    }
                }
            }
        }else {
            System.out.println("当前搜索的不是文件夹");
        }
    }
}

非递归化文件案例-啤酒问题

public class Test {

    // 定义一个静态的成员变量用于存储可以买的酒数量
    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);
        }
    }
}

字符集

常见字符集介绍

 

字符集的编码、解码操作

public class Test {
    public static void main(String[] args) throws UnsupportedEncodingException {
        // 编码：把文字转换成字节（使用指定的编码）
        String s = "abc我爱你";
        byte[] bytes = s.getBytes("GBK"); // 以当前代码默认字符集进行编码(UTF-8)
        System.out.println(bytes.length);
        System.out.println(Arrays.toString(bytes));

        // 2. 把字节转换成对应的中文形式（编码前 和 编码后的字符集必须一致）
        String rs = new String(bytes ,"GBK"); // 以当前代码默认字符集进行解码(UTF-8)
        System.out.println(rs);
    }
}

IO流概述

字节流的使用

文件字节输入流：每次读取一个字节

public class Test {
    public static void main(String[] args) throws Exception {
        // 创建一个文件字节输入流(管道)
        InputStream input = new FileInputStream("F:\\Windows\\Test File\\Java\\Learn\\src\\Picture\\f1.txt");

        // 读取一个字节返回（每次读取一个字节）
        char b1 = (char) input.read(); // 读取文件返回-1
        // 定义一个变量记录每次读取的字节
        int b;
        while ((b = input.read()) != -1) {
            System.out.print((char) b);
        }
    }
}

文件字节输出流：每次读取一个字节数组

public class Test {
    public static void main(String[] args) throws Exception{
        // 创建一个文件字符输入流管道与源文件接通
        InputStream input = new FileInputStream("F:\\Windows\\Test File\\Java\\Learn\\src\\Picture\\f1.txt");
        int len; // 记录每次读取一个字节数组
        byte[] buffer = new byte[3]; // 每次读3个字节
        while ((len = input.read(buffer)) != -1) {
            System.out.print(new String(buffer, 0,len));
        }
    }
}

文件字节输入流：一次读完全部字节

 

public class Test {
    public static void main(String[] args) throws Exception{
        // 创建一个文件字符输入流管道与源文件接通
        File f = new File("F:\\Windows\\Test File\\Java\\Learn\\src\\Picture\\f1.txt");
        InputStream input = new FileInputStream(f);

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

        byte[] buffer1 = input.readAllBytes();
        System.out.print(new String(buffer1));
    }
}

文件字节输出流：写字节数据到文件

 

public class Test {
    public static void main(String[] args) throws Exception {
        // 1、创建一个文件字节输出流管道与目标文件接通
        OutputStream output = new FileOutputStream("F:\\Windows\\Test File\\Java\\Learn\\src\\Picture\\2.txt",true);

        // b.public void write(byte[] buffer):写一个字节数组出去。
        output.write('a');
        output.write(98);
        output.write("\n\r".getBytes());
        //output.write('我'); false

        byte[] buffer = {'a' , 89 ,99};
        output.write(buffer);

        //写数据必须刷新数据
        output.flush(); //刷新之后可以使用

        byte[] buffer2 = "我是".getBytes();
        output.write(buffer2); //支持中文


        // c. public void write(byte[] buffer , int pos , int len):写一个字节数组的一部分出去。
        byte[] buffer3 = {'a',97 ,98 ,99};
        output.write(buffer3 , 0 ,3);
        
        
        output.close(); //释放资源 包含刷新了 关闭流后不可以使用
    }
}

文件拷贝

public class Test {
    public static void main(String[] args) {
        // 定义一个字节输入流管道与原视频接通
        try {
            InputStream is = new FileInputStream("src/Picture/2.mp4");

            // 创建一个字节流输出管道与目标文件接通
            OutputStream os = new FileOutputStream("src/Picture/f1.mp4");

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

            //关闭流
            is.close();
            os.close();

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

 

资源释放的方式

try-catch-finally

public class Test {
    public static void main(String[] args) {
            // 创建一个字节流输出管道与目标文件接通
            InputStream is = null;
            // 定义一个字节数组来转移数据
            OutputStream os = null;
        // 定义一个字节输入流管道与原视频接通
        try {
            is = new FileInputStream("src/Picture/2.mp4");
            os = new FileOutputStream("src/Picture/f1.mp4");
            byte[] buffer = new byte[1024];
            int len; //记录每次读取的字节数
            while ((len = is.read()) != -1) {
                os.write(buffer , 0 ,len);
            }
            System.out.println("复制完成");

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 无论代码是否正常结束，finally始终都要最后执行这里
            System.out.println("=========finally==========");

            //关闭流
            try {
                if (is != null)is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (os != null)os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

try-catch-resource

 

public class Test {
    public static void main(String[] args) {
        // 定义一个字节输入流管道与原视频接通
        try (
                //这里只能放资源对象，用完自动关闭资源
                InputStream is = new FileInputStream("src/Picture/2.mp4");
                OutputStream os = new FileOutputStream("src/Picture/f1.mp4");
                
                ){

            byte[] buffer = new byte[1024];
            int len; //记录每次读取的字节数
            while ((len = is.read()) != -1) {
                os.write(buffer , 0 ,len);
            }
            System.out.println("复制完成");

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

 

字符流的使用

文件字符输入流-一次读取一个字符

public class Test {
    public static void main(String[] args) throws Exception{
        // 创建一个字符输入流管道与源文件接通
        Reader fr = new FileReader("Learn\\src\\Picture\\f1.txt");

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

    }
}

文件字符输入流-一次读取一个字符数组

public class Test {
    public static void main(String[] args) throws Exception{
        // 创建一个字符输入流管道与源文件接通
        Reader fr = new FileReader("Learn\\src\\Picture\\f1.txt");

        // 定义一个字符数组
        char[] buffer = new char[1024]; //1k字符
        int len; //记录每次读取的字符长度

        // 开始读取字符
        while ((len = fr.read(buffer)) > 0) {
            String rs = new String(buffer ,0 ,len);
            System.out.print(rs);
        }
    }
}

文件字符输出流

 

public class Test {
    public static void main(String[] args) throws Exception{
        // 创建一个字符输入流管道与源文件接通
       // Reader fr = new FileReader("Learn\\src\\Picture\\f1.txt");
        Writer fw = new FileWriter("F:\\Windows\\Test File\\Java\\Learn\\src\\Picture\\2.txt");

        //写一个字符出去
        fw.write('a');
        fw.write(89);

        //写一个字符串出去
        fw.write("abc老王");

        //写一个字符串数组出去
        char[] chars = "abcasd老王".toCharArray();
        fw.write(chars);

        //写一个字符串的一部分出去
        fw.write("asdqwe哈哈哈" ,0 ,3);

        //写一个字符串数组一部分出去
        fw.write(chars , 0 ,3);

        //刷新缓存区
        fw.flush();
        fw.close();
    }
}

 

蓝胖子（*^_^*）
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
方法引用, Stream流，File类 , 递归 ，字节流.md
08-25
关于一些java的流处理
Java学习之File类（递归）
qq_38777285的博客
11-26 184
目录 递归的本质：方法的调用 Flie中的listFiles方法 文件的递归遍历，显示文件夹内所有的子元素的绝对路径 递归删除文件夹 查找文件的父目录 1.递归的本质：方法的调用 方法的调用一直在等待方法的执行，将方法压入栈中，直到最后一个方法没有调用对象则开始执行方法，然后释放(弹出栈顶)，按照栈中顺序依次执行方法，结果就是方法的调用和方法的执行是相反的，即第一...
File文件使用
qq_38843689的博客
05-21 196
File类：是用来读写计算机中的文件和文件夹 创建目录 并读取目录 文件的名字和大小 public class Filelist {  public static void main(String[] args) {   File file=new File("D:/Lenovo");   file.mkdir();   File file1=new File(
Java文件操作
m0_56620669的博客
04-06 4935
Java的文件操作, 主要包含两类操作: 文件系统相关的操作, 比如创建文件, 文件改名的操作等 文件内容相关的操作 File类 构造方法: 构造方法内可以写绝对路径,也可以写相对路径. 典型方法: 查看文件名,路径名 public static void main(String[] args) throws IOException { File file = new File("./test.txt"); System.out.println(.
java获取文件夹下所有的文件
热门推荐
qq_46258463的博客
09-06 5万+
java获取文件夹下所有的文件，文件名，递归
file类的遍历
gaoweiyuan1996的博客
10-02 386
package IO输入输出流; import java.io.File; import java.io.IOException; // 列出file类的一些常用操作，比如过滤、遍历等操作 public class FileUtils { public static void listDirectory(File dir) throws IOException{ /...
spawar_internship.github.io
05-16
迭代和递归线。 完成了Scott的一些简单的Python挑战。 他们在这里： 很棒的Python计算机语言教程： 有用Linux命令： ~ $ cd internship/game/ 转到另一个文件夹（更改目录） ~ $ ipython notebook 打开ipython...
22_IO_第1天（File、递归）_讲义
02-16
22_IO_第1天（File、递归）_讲义
dirwatch:Clojure目录观察程序，包装了JDK 7 java.nio.file.WatchService
05-05
目录监视 监视目录以查找更改。 类似于t望塔（但使用JDK 7异步... ( watch-dir println ( clojure.java.io/file " /tmp " )) 执照 版权所有:copyright:2013 JUXT。 与clojure一样，根据Eclipse Public License分发。
TreeFile.txt
12-27
import java.io.File; import java.util.ArrayList; import java.util.List; /** * * 项目名称：FileTest * 类名称：TreeFile * 类描述：将制定目录下得所有子目录和文件按树形输出 * 创建时间：2011-10-19 ...
File f = new File怎么用？
m0_52226803的博客
04-27 1万+
例：File f = new File(“D:\Folder”); 这名话并不真正会创建D:\Folder 这个文件。 而是创建了一个代表 D:\Folder 这个文件的一个File对象。 你需要判断,如果文件不存在,再创建,如: File f = new File(“D:\Folder”); //判断文件是否真正存在,如果不存在,创建一个; if(!f.exists()) { f.mkdirs(); } ...
迭代及用递归遍历File文件
crazyhsl的博客
12-14 335
递归：指的是当前方法调用自己的一 递归的分类： 递归分为两类：直接递归和间接递归 直接递归：称为方法自身调用自己的情况 间接递归：可以归结为：方法A调用了方法B,方法B调用了方法C，方法C反过来又调用了方法A。 种现象。 注意事项： 递归一定要有边界条件 （条件限定），保证递归能够停止下来，否则会发生栈内存溢出。 在递归当中虽然有限定条件，但是递归的次数也不能太多，否则也会发生栈内存溢出现象。 构造方法禁止递归。 递归实例代码： 1.计算1.
java中File类的常用所有方法及其应用
weixin_30770783的博客
02-09 593
创建：createNewFile()在指定位置创建一个空文件，成功就返回true，如果已存在就不创建，然后返回false。mkdir() 在指定位置创建一个单级文件夹。mkdirs() 在指定位置创建一个多级文件夹。renameTo(File dest)如果目标文件与源文件是在同一个路径下，那么renameTo的作用是重命名， 如果目标文件与源文件不是在同一个路径下，那么renameTo的作用...
File 类的用法和文件内容的操作
书生-w的博客
04-04 2万+
在java程序中操纵 文件/目录 ？怎么办？ java程序，最典型的特点，面向对象，java程序最擅长的就是操作对象，盘符上的文件/目录，将它的各种信息进行了封装，封装为一个对象， java程序最擅长的就是操纵对象，这个对象属于 ---》File类
JavaFile类基础知识学习笔记
TIANJIAWEN的博客
03-21 473
写在前面:马上秋招，开个知识点记录贴，就当做课堂笔记吧.
【了解Java File类】Java文件类的常见操作
m0_46427461的博客
08-18 481
明晰Java中File类的基本概念，从File对象的构造方法、File类的常见功能入手，对File操作做一系列举例。
File类
qq_41923771的博客
05-17 154
1.File类是对文件进行处理的类File类是IO流的基础,因为IO就得输入和输出都要用文件进行读取或者输出, 三种新建文件的方法        public File(String pathname):表示pathname的抽象路径表现的形式 (开发中使用这种方式)        public File(String parent,String child)根据 parent路径名字符串和 ch...
java中File类
feng_xi_的博客
07-28 118
1、File类 1.1、File类概述和构造方法 import java.io.File; public class work12 { public static void main(String[] args){ File file1 = new File("E:\\File测试\\java2.text"); System.out.println(file1); //E:\File测试\java2.text ...
IO File file
最新发布
07-27
引用\[1\]:在给定的示例中，使用System.IO命名空间中的File类来创建、写入和读取文件。首先，使用File.Create方法创建一个文件，并使用FileStream来写入一些文本信息到文件中。然后，使用File.OpenText方法打开文件，并使用StreamReader逐行读取文件内容。最后，将读取的内容打印到控制台上。 引用\[2\]:在第二个示例中，使用Java的File类来打印指定目录下的文件树形结构。首先，判断给定的路径是否合法，如果是文件，则直接打印文件名；如果是目录，则使用递归的方式遍历目录下的文件和子目录，并打印出树形结构。 引用\[3\]:在第三个示例中，使用System.IO命名空间中的File类来移动文件。首先，使用File.Create方法创建一个文件，然后使用File.Move方法将文件移动到指定的目标路径。移动完成后，检查原始文件是否存在，如果存在则打印出错误信息，如果不存在则打印出移动成功的信息。 根据你的问题，IO File file是一个不完整的表达，无法确定具体指的是哪个示例中的代码。请提供更多的上下文或明确的问题，以便我能够给出更准确的回答。 #### 引用[.reference_title] - *1* *3* [【.Net实用方法总结】 整理并总结System.IO中File类及其方法介绍](https://blog.csdn.net/baidu_33146219/article/details/126445772)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [IO及File介绍](https://blog.csdn.net/m0_46853673/article/details/117047152)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值