首页 > 其他分享 >File类和IO

File类和IO

时间：2022-10-15 21:12:17浏览次数：45  
标签：File IO idea file println new String

一.File的相关概念

  1. File是文件和文件的抽象表示形成，在Java中，文件和文件夹都是用对象FIle来描述。

  2. 相对路径和绝对路径

    1. 绝对路径：由电脑的盘符开始，找到该文件或者文件夹经过的路线的字符串表示。

    2. 相对路径：以开发环境的项目的文件夹为起点，找到文件或者文件夹见过的路线的字符串表示

    3. 持久化概念：就是将内存中的数据永久保存到硬盘，这就是所谓的持久化。

    4. 代码实现

      public static void Test1(){
        //创建文件夹的方式
        File file = new File("D:\\idea\\File\\a");
        file.mkdir();
        //2.创建文件夹，除了创建分身文件夹，如果父目不存在，用该方法也可以同时创建父目录
        File file1 = new File("D:/idea/File/a");
        file1.mkdir();
    }
    /*
    如何在指定文件夹里面创建文件
     */
    public static void Test2(){
        //第一种创建文件的方式
        File file = new File("D:\\idea\\File\\a", "abc.txt");
//        file.mkdirs();
        //第二种创建文件的方式
        File parent = new File("D:\\idea\\File\\a");
        File file1 = new File(parent,"a.txt");
        //第三种创建文件的方式
        File file2 = new File("D:/idea/File/a/b.txt");
//        file2.mkdirs();
        //问题：如果不指定目录，会在哪里创建文件
        File file3 = new File("java_3.txt");
        try {
            file.createNewFile();
            file1.createNewFile();
            file2.createNewFile();
            file3.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
​
​
    }
    public static void Test3(){
        File file1 = new File("D:/a", "abc.txt");
        String absolutePath = file1.getAbsolutePath();
        String name = file1.getName();
        String path = file1.getPath();
        System.out.println(absolutePath);
        System.out.println(name);
        System.out.println(path);
        File file = new File("D:\\idea\\File\\a");
        if (!file.exists()){
            file.mkdir();
        }
​
    }
​
    public static void main(String[] args) {
//        Test1();
//        Test2();
        Test3();
    }

二.递归算法

  1. 特点：

    1. 方法自己调自己

    2. 一定要有退出的条件，也就是说必须要在满足条件的时候结束递归

    3. 代码实现

      public class Demo02 {
    public static void main(String[] args) {
        Demo02 demo02=new Demo02();
        int factorial = demo02.Factorial(5);
        System.out.println(factorial);
    }
    public int Factorial(int n){
        int result=0;
        //递归结束条件
        if (n==0){
            return 1;
        }
        result=n*Factorial(n-1);
        return result;
    }
}

  2. 使用递归的方式输出某个文件夹下面的子文件夹和文件，一直到所有的子文件夹找完。

    1. 代码实现

      package com.lyh.com;
​
import java.io.File;
​
/**
 * 使用递归的方式输出某个文件夹下面的子文件夹和文件，
 * 一直到所有的子文件夹找完。
 */
public class Demo03 {
    public static void main(String[] args) {
        String fileName="D:\\idea\\File\\a";
        showFileINfo(fileName);
    }
    public static void showFileINfo(String fileName){
        //1.创建File对象
        File file = new File(fileName);
        //file.exists()文件或目录是否存在
        if (file.exists()){
            //判断是否是目录以字符串名称显示
            if (file.isDirectory()){
                System.out.println("文件夹"+file.getAbsolutePath());
                File[] files = file.listFiles();
                if (null==files||files.length==0){
                    return;
                }else{
                    for (int i = 0; i < files.length; i++) {
                        File son = files[i];
                        //递归调用
                        showFileINfo(son.getAbsolutePath());
                    }
                }
            }else if (file.isFile()){
                System.out.println("文件："+file.getAbsolutePath());
            }
        }
    }
}
​

       

三.IO流相关

  1. 流 的概念

    1. 流：是一个以先进先出传输数据的通道，在电脑的内存中传输数据，也可以用类似水流的方式来传数据。

    2. io就是input和output

  2. 流的分类：

    1. 输出流：OutputStream和Writer作为基类

    2. 输入流：InputStream和Reader作为基类

    3. 说明：

      1. 源：数据开始传输的地方

      2. 目的地：数据要流到的地方

      3. 输入流和输出流：以内存为参照物，流进去的就是输入流，反之输出流

        1. 字节流：输入流InputStream基类。输出流OutputStream

        2. 字符流：输入流Reader。输出流Writer

        3. 一个字符等于两个字节

      4. 输入流和输出流都是成对出现的

四.FileReader和FileWriter

  1. 字符流FileReader和FileWriter的使用

  2. 输入流步骤：

    1. 构造输入流

    2. 用read()方法来读

    3. 关闭流

  3. 输出流步骤：

    1. 构建输出流

    2. 用write()方法写

    3. 用flush()刷新缓冲

    4. 关闭流

  4. 例题：读取文本文件，输出到控制台(读操)

     public static void main(String[] args) {
//        File file = new File("D:\\idea\\File\\a");
     //读取这个文本中的内容，打印在控制台上
        String s1 = readFile("D:\\idea\\File\\a\\1.txt");
        System.out.println(s1);
        System.out.println("======================================");
        String s = readFileForCharArray("D:\\idea\\File\\a\\1.txt");
        System.out.println(s);
    }
​
    //第一种方法
    public static String readFile(String fileName) {
        // StringBuilder让你的文件编程字符串类型
        StringBuilder sb = new StringBuilder();
        try {
            //1.构建输入流
            FileReader reader = new FileReader(fileName);
            //2.开始读，返回的是读到的字符，这里的字符是以ASCII码返回的，实际是一个数字，如果读不到返回一个-1
            int c = -1;
            while ((c = reader.read()) != -1) {
                sb.append((char) c);
            }
            //3.关闭流
            reader.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return sb.toString();
    }
​
    //第二种方式
    public static String readFileForCharArray(String fileName) {
        StringBuilder sb = new StringBuilder();
        try {
            FileReader reader = new FileReader(fileName);
            char[] chars = new char[1024];
            int len = -1;
            while ((len = reader.read(chars, 0, chars.length)) != -1) {
                sb.append(chars, 0, len);
            }
            reader.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
​
        return sb.toString();
    }

  5. 创建一个文本文件，写一段内容到文本文件(写操作)

    public static void main(String[] args) {
//        File file = new File("D:\\idea\\File\\a");
//        String s1 = readFile("D:\\idea\\File\\a\\1.txt");
//        System.out.println(s1);
//        System.out.println("======================================");
//        String s = readFileForCharArray("D:\\idea\\File\\a\\1.txt");
//        System.out.println(s);
        System.out.println("============================");
        //给这个文本中写入一些内容
        witerFile("D:\\idea\\File\\a\\1.txt","我是谁");
    }
/**
 *
 * @param fileName 将文本写入的文件的名字
 * @param str 写入的内容
 */
public static void witerFile(String fileName,String str){
    try {
        //1.创建输出流
        FileWriter fileWriter = new FileWriter(fileName);
        //开始写
        fileWriter.write(str);
        //刷新缓存
        fileWriter.flush();
        fileWriter.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
​
}

  6. 复制1个文本文件到指定的目录(边读边写方式)

    public static void main(String[] args) {
//        File file = new File("D:\\idea\\File\\a");
//        String s1 = readFile("D:\\idea\\File\\a\\1.txt");
//        System.out.println(s1);
//        System.out.println("======================================");
//        String s = readFileForCharArray("D:\\idea\\File\\a\\1.txt");
//        System.out.println(s);
        System.out.println("============================");
        //给这个文本中写入一些内容
//        witerFile("D:\\idea\\File\\a\\1.txt","我是谁");
    //读取第一个文件中的内容，写到第二个文件中
        readWriteFile("D:\\idea\\File\\a\\1.txt","D:\\idea\\File\\a\\2.txt");
​
    }
/**
 *
 * @param srcFileName 源文件的名字
 * @param descFileName 目标文件的名字
 */
public static void readWriteFile(String srcFileName,String descFileName){
​
    try {
        //1.构建输入流
        FileReader fileReader = new FileReader(srcFileName);
        //2.构建输出流，true代表最佳方式的写，false榜最佳，覆盖
        FileWriter fileWriter = new FileWriter(descFileName);
        //3.编写缓冲数字
        char[] chars = new char[1024];
        //4.变量记录读到真实长度
        int len=-1;
        while ((len=fileReader.read(chars,0,chars.length))!=-1){
            fileWriter.write(chars,0,chars.length);
            fileWriter.flush();
        }
        //5.关闭流
​
        fileWriter.close();
        fileReader.close();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
​
}

  1. 总结：

    1. File的用法

      1. new File(FileName):带全路径

      2. new File(parent,filename):第一个参数可以是字符串也可以是File，fileName不带路径

    2. mkdirs和mkdir两个区别：

      1. 如果船舰的文件或者文件夹有父目录，它会连父目录一起创建；mkdir只能创建本目录，不创建父目录，也就是说mkdir创建1级目录，mkdirs创建多级目录

    3. 流的使用选择规则：

      1. 一般文件用字符流，非文本文件用字节流

      2. 字符流步骤：

        1. 创建文件File

        2. 创建流

        3. 字符数组

        4. 循环读或者写

        5. 关闭

五.字节流

  1. 输入流InputStream

    方法摘要  
    void close() 关闭此输入流并释放与该流关联的所有系统资源。
    abstract int read() 从输入流中读取数据的下一个字节。
    int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
    int read(byte[] b, int off, int len) 将输入流中最多 len 个数据字节读入 byte 数组。

     

  2. 输出流OutputStream

    方法摘要  
    close() 关闭此输出流并释放与此流有关的所有系统资源。  
    flush() 刷新此输出流并强制写出所有缓冲的输出字节。  
    write(byte[] b) 将 b.length 个字节从指定的 byte 数组写入此输出流。  
    write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。  
    write(int b) 将指定的字节写入此输出流。  

  1. 例题：编写一个工具类FileStreamUtil，完成如下功能。（编写一个方法读取文本文件，并返回字符串。）

     

  2.  

标签：File,IO,idea,file,println,new,String
From： https://www.cnblogs.com/lyhidea/p/16795027.html

相关文章

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99