63.【Java I/O 操作】

已于 2022-10-17 09:13:04 修改
阅读量605 收藏 2
点赞数
文章标签： java 算法 c++
于 2022-10-16 21:34:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_69683957/article/details/127336491
版权

I/O的操作

(一)、基础知识

1.什么是IO?

IO是输入input输出output的首字母缩写形式，直观意思是计算机输入输出，它描述的是计算机的数据流动的过程，因此IO第一大特征是有数据的流动；另外，对于一次IO，它究竟是输入还是输出，是针对不同的主体而言的，不同的主体有不同的描述。例如，甲乙两人交谈，甲将大脑中的想法通过声带震动，继而通过声波传入乙的耳朵，乙通过耳膜的震动再由神经将信号解析到大脑，这个数据流动的过程对甲而言是输出，对乙而言是输入。

2.什么是流?

(1).概念:内存与储存设备之间传输数据的通道

eg: 
我们的程序存储在内存中，我们的文件存储在硬盘中

水库: 数据 
输水的管道: 相当于流
接水池: 流入/流出

水借助管道进行流入/流出  
数据借助流进行传入/传出

3.流的分类

（1）.按照流的方向

输入流: 将硬盘中的数据读入到内存中
输出流: 将内存中的数据输出到硬盘中

（2）.按单位：
字节流：以字节为单位，可以读写所有数据。
字符流：以字符为单位，只能读写文本数据。
（3）.按功能划分:
节点流 ：具有实际传输数据的读写功能
过滤流 ：在节点流的基础之上增强功能

(二).文件字节流(FileInputStream与FileOutStream)

4.字节流的父类（抽象类）

InputStream :  字节输入流
(1).  public int read(){}  从输入流读取数据的下一个字节。
OutputStream : 字节输出流
(1). public void write(){}  将指定的字节写入此输出流。

5.文件字节流（输入流）

FieInputStream :    文件输入流
(1). public int read(byte[] b)  从流中读取多个字节，将读到的内容存入
	b数组，返回实际读到的字节数;如果达到文件的尾部返回-1
FileOutputStream :   文件输出流
(1).public void write(byte []b)  一次写多个字节，将b数组中的所有字节，写入输出流.

基本思路:
public int read(){} 单个单个的读取
1.创建文件输入流,
2.读取文件,因为读的操作（如果文件的下一个为空，那么返回-1）
3.打印读取的文件信息
4.一定要关闭文件的流操作

import java.io.FileInputStream;
public class Demo0 {
    public static void main(String[] args) throws Exception{
        //1.创建文件输入流 ，并且指定文件路径
          FileInputStream fileInputStream_one=new FileInputStream("e:\\123.txt");
        //2.读取文件
        int date=0;
        while ((date=fileInputStream_one.read())!=-1){
            System.out.print((char)date);
        }
                    fileInputStream_one.close();
        }
    }

在这里插入图片描述

基本思路:
1.利用byte数组 一次性储存数据
2.利用new String() 函数，实现以字符串的形式进行输出
3.read() 返回的类型是int ，单个返回指的是ascll码，如果是byte 那么返回的是读取的个数.

import java.io.FileInputStream;
public class Demo0 {
    public static void main(String[] args) throws Exception{
        //1.创建文件输入流 ，并且指定文件路径
          FileInputStream fileInputStream_one=new FileInputStream("e:\\123.txt");
        //2.读取文件
        byte date[]=new byte[4];
        int count=fileInputStream_one.read(date);
        System.out.println(fileInputStream_one.read());
        System.out.println(new String(date));
        System.out.println("个数为:"+count);
         fileInputStream_one.close();
        }
    }

在这里插入图片描述

二次读取操作

import java.io.FileInputStream;
public class Demo0 {
    public static void main(String[] args) throws Exception{
        //1.创建文件输入流 ，并且指定文件路径
          FileInputStream fileInputStream_one=new FileInputStream("e:\\123.txt");
        //2.读取文件
        byte date[]=new byte[3];
        //第一次读取
        int count=fileInputStream_one.read(date);
        System.out.println(new String(date));
        System.out.println("个数为:"+count);
        //第二次读取
        int count1=fileInputStream_one.read(date);
        System.out.println(new String(date));
         fileInputStream_one.close();
        }
    }

在这里插入图片描述

byte[]数组的

import java.io.FileInputStream;
public class Demo0 {
    public static void main(String[] args) throws Exception{
        //1.创建文件输入流 ，并且指定文件路径
          FileInputStream fileInputStream_one=new FileInputStream("e:\\123.txt");
        //2.读取文件
        byte date[]=new byte[3];
        int count=0;
        while ((count=fileInputStream_one.read(date))!=-1){
            System.out.println(new String(date));
        }
         fileInputStream_one.close();
        }
    }

在这里插入图片描述

6.文件字节流 (输出流)

基本思路:
1.FileOutputStream 输出流
2.write 写的操作

import java.io.FileOutputStream;

public class Demo1 {
    public static void main(String[] args) throws Exception{
        //1.创建文件的输出流
        FileOutputStream fileOutputStream_one=new FileOutputStream("e://123.txt");
    /*
        //2.写文件
        fileOutputStream_one.write(97);
        fileOutputStream_one.write('b');
        fileOutputStream_one.write(99);
        */
        String string="hello word";
        fileOutputStream_one.write(string.getBytes());

        //3.关闭文件
        fileOutputStream_one.close();
        System.out.println("项目执行完毕!");
    }
}

在这里插入图片描述

7.文件字节流复制文件

基本思路:
1.首先先从文件中读取数据
2.然后开始使用文件写入数据
3.1024个字节等于1kb,假如说字节数写少了，那么读取的文件会不完整。

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Demo0 {
    public static void main(String[] args) throws Exception{
        //1.创建文件输入流 ，并且指定文件路径
          FileInputStream fileInputStream_one=new FileInputStream("E:\\美化图片\\123.jpg");
          FileOutputStream fileOutputStream_one=new FileOutputStream("E:\\美化图片\\13.jpg");
       //2.边读边写
            byte []buf=new byte[1024];
            int count=0;
            //每次都读取1024个字节
            while ((count=fileInputStream_one.read(buf))!=-1){
            	//截取具体化
                fileOutputStream_one.write(buf,0,count);
            }
         fileInputStream_one.close();
         fileOutputStream_one.close();
        System.out.println("项目完毕!");
        }
    }

在这里插入图片描述
在这里插入图片描述

（三）、字节缓冲流(BufferedOutputStream)

8.字节缓冲流（输入流）

缓冲流: BufferedInputStream/BufferedOutputStream
1.提高IO效率，减少访问磁盘的次数
2.数据存储在缓冲区中，flush是将缓存区的内容写入文件中，也可以直接close.
3.在使用的过程中，会创建一个缓冲区.用于数据的缓存

基本思路:
1.创建文件流，先获取文件()
2.把文件放入缓冲区中去
3.利用缓冲区进行访问文件
（相当于一次性就把文件放入到缓冲区，就访问了一哈硬盘）

import java.io.BufferedInputStream;
import java.io.FileInputStream;
public class Demo3 {
    public static void main(String[] args) throws Exception {
        //1.创建一个输入流
        FileInputStream fileInputStream=new FileInputStream("e://123.txt");
        //2.创建一个缓冲流，并且把文件写入到缓冲区
        BufferedInputStream bufferedInputStream=new BufferedInputStream(fileInputStream);
        //3.读取数据
        int count=0;
        while ((count=fileInputStream.read())!=-1){
            System.out.println((char)count);
        }
        fileInputStream.close();
        bufferedInputStream.close();
    }
}

在这里插入图片描述

9.字节缓冲流（输出流）

基本思路:
1.了解  BufferedOutputStream  字节输出流
2.先创建文件输出流
3.然后创建文件缓冲输出流，并且把文件加载到缓冲流
4.通过缓冲流写文件的时候，  一定一定要进行 flush(); 否则不能显示.

5.写入文件的时候，可以不用创建文件的名字，函数会帮助我们自动创造一个文件。
但是读取文件的名字的时候，我们一定要一个确定的名字

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

public class Demo5 {
    public static void main(String[] args) throws Exception{
        //1.创建物件输出
        FileOutputStream fileOutputStream=new FileOutputStream("e://1234.txt");
        //2.创建文件缓冲
        BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(fileOutputStream);
        //3.写入文件
        for (int i = 0; i <10 ; i++) {
            bufferedOutputStream.write("hello world".getBytes());   //首先写入缓冲区
            
            bufferedOutputStream.flush();   //刷新硬盘
        }
        bufferedOutputStream.close();
        fileOutputStream.close();
    }
}

在这里插入图片描述

(四)、对象流(ObjectInputStream)

10.对象流

1.对象流: ObjectOutputStream/ObjectInputStream
2.增强了缓冲区的功能
3.增强了读写8种基本数据类型和字符串功能
4.增强了读写对象的功能:  readObject() 从流种读取一个对象 writeObject()向流中写入一个对象.
5.内存写入硬盘中 这叫做序列化
6.硬盘读取到内存中 这叫做反序列化.

在这里插入代码片

11.ObjectOutputStream (序列化 Serializable)

基本思路:
1.首先我们要创造一个文件输出流
2.再创建一个对象输出流，并且把文件放入到对象输出流中去
3.利用文件输出流的 writeObject() 把对象写进去
4.进行刷新硬盘的操作
5.如果要对一个对象进行序列化的操作 必须要实现一个接口 Serializable 

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.nio.charset.StandardCharsets;

public class Demo6 {
    public static void main(String[] args) throws Exception {
        //1.创建文件的输出流
        FileOutputStream fileOutputStream=new FileOutputStream("e://2022.bin");
        //2.创建对象流
        ObjectOutputStream objectOutputStream=new ObjectOutputStream(fileOutputStream);
        //3.开始序列化的操作
        Student student=new Student("张三",20);
        objectOutputStream.writeObject(student);
        //4.刷新
        objectOutputStream.flush();
        //5.关闭的草走
        objectOutputStream.close();
        fileOutputStream.close();
    }
}

import java.io.Serializable;

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;
    }
}

在这里插入图片描述

12.ObjectInputStream (反序列化)

基本思路:
1.了解ObjectInputStream
2.需要强制转换文件的类型

import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class Demo6 {
    public static void main(String[] args) throws Exception {
        //1.创建文件的输入流
        FileInputStream fileInputStream=new FileInputStream("e:\\2022.bin");
        //2.创建对象流
        ObjectInputStream objectInputStream=new ObjectInputStream(fileInputStream);
        //3.读取文件
        Student student=(Student) objectInputStream.readObject();
        //4.关闭文件
        fileInputStream.close();
        objectInputStream.close();
        System.out.println(student.toString());
    }
}

import java.io.Serializable;

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;
    }
}

在这里插入图片描述

13.序列化与反序列化的注意事项

（1）.序列化类必须实现 Serializable 接口
(2).序列化类中的对象属性实现 Serializable 接口
eg: Address address;  这个也要实现接口
(3).序列化版本ID，保证序列化的类和反序列化的类是同一个类       
(4).使用transient(瞬间的，瞬时的)，修饰的属性，那么这个属性不能进行序列化（5）.静态属性也不能进行序列化.
（6）.可以序列化多个对象.

(五)、字符编码

14.字符编码

1.ISO-8859-1
收录除Ascll外，还包西欧。希腊语。台语、阿拉伯语、希伯来语对应的文字符号
2.UTF-8  针对UNicode码表的可变长度字符编码
3.GB2312  简体中文
4.GBK  简体中文扩充
5.BIG5 台湾，繁体中文
当编码方式和解码方式不一致的时候，会出现乱码.

15.字符流抽象类

1.字符码:是char类型的.
2.字符流的父类:(抽象类)
(1).Reader: 字符输入流
public int read(){}
(2).Writer:字符输出流
public void write(){}


import java.io.FileInputStream;
public class Demo7 {
    public static void main(String[] args) throws Exception {
        //1.创建文件的输入操作
        FileInputStream fileInputStream=new FileInputStream("e:\\123.txt");
        //2.进行读写的操作
        int date=0;
        while ((date=fileInputStream.read())!=-1){
            System.out.print((char)date);
        }
        fileInputStream.close();
    }
}

在这里插入图片描述

假如说文本文档存的是汉字，那么将会输出乱码

在这里插入图片描述

（六）、文件字符流(FileReader和FileWriter)

16.文件字符流

文件字符流属于自动匹配类型 不用考虑文件的字符编码

FileReader:
public int read(char[] c) //从流中读取多个字符，将读到内容存入c数组，返回
实际读到的字符数；如果达到文件的尾部，就返回-1;
FileWriter:
public void write(String str) //一次写多个字符，将b数组种所有字符，写入输出流

17.文件字符输入流


基本思路:
1.首先创建一个文件字符输入流
2.读取文件

import java.io.FileReader;

public class Demo8 {
    public static void main(String[] args) throws Exception{
        //1.创建FilerReader 文件字符输入流
        FileReader fileReader=new FileReader("e:\\123.txt");

        //2.读取,单个字符读取
        int date=0;
        while ((date=fileReader.read())!=-1){  //这个就是读取文中的一个字符 (3个字节)
            System.out.println((char)date);
        }
        System.out.println(date);

    /*    char[]buf=new char[1024];
        int count=0;
        while ((count=fileReader.read(buf))!=-1){  //读取完毕之后放入到 字符数组中
            System.out.println(new String(buf,0,count));  //目的是为了截取有效的参数
        }

     */
        //3.关闭
        fileReader.close();
    }
}

在这里插入图片描述

18.文件字符输出流

基本思路:
1. 

import java.io.FileOutputStream;
import java.io.FileWriter;
public class Demo9 {
    public static void main(String[] args) throws Exception{
  
//设置文件输出流
        FileWriter fileWriter=new FileWriter("e:\\789");
        //2.开始写入信息
        fileWriter.write("java");
        //3.关闭
        fileWriter.close();
        System.out.println("项目执行完毕!");
    }
}

在这里插入图片描述

19.文件字符流复制文件

只能复制文本文档 ，不能复制图片、声音、视频

基本思路:
1.创建文件的读；
2.创建文件的写
3.边读边写
4.刷新

import java.io.FileReader;
import java.io.FileWriter;
public class Demo10 {
    public static void main(String[] args)  throws Exception{
        //1.文件字符读取
        FileReader fileReader=new FileReader("e:\\123.txt");
        //2.文件字符写入
        FileWriter fileWriter=new FileWriter("e:\\1217.txt");
        int count=0;
        while ((count=fileReader.read())!=-1){
            fileWriter.write((char)count);
            fileWriter.flush();
        }
        System.out.println("复制完毕!!");
    }
}

在这里插入图片描述

（七）、字符缓冲流

20.字符缓冲流（读取）

1.缓冲流:BufferedReader/BufferedWriter
2.高效读写  
3.支持输入换行符 
4.可以一次写一行、读一行。

基本思路:
1.创建一个字符读取流
2.创建一个字符读取缓存区，把文件放到缓存区
3.关闭

import java.io.BufferedReader;
import java.io.FileReader;

public class Demo11 {
    public static void main(String[] args) throws Exception {
        //1.创建一个字符读取流
        FileReader fileReader=new FileReader("e:\\123.txt");
        //2.创建一个字符读取缓冲流
        BufferedReader bufferedReader=new BufferedReader(fileReader);
        int count=0;
        while ((count=bufferedReader.read())!=-1){
            System.out.println((char)count);
        }
        bufferedReader.close();
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
public class Demo11 {
    public static void main(String[] args) throws Exception {
        //1.创建一个字符读取流
        FileReader fileReader=new FileReader("e:\\123.txt");
        //2.创建一个字符读取缓冲流
        BufferedReader bufferedReader=new BufferedReader(fileReader);
        char []buf=new char[1024];
        int count=0;
        while ((count=bufferedReader.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        bufferedReader.close();
    }
}

在这里插入图片描述

21.字符缓冲流（写入）

基本思路:
1.创建文件字符
2.创建文件字符缓冲区
3.写入数据
4. newLine() 写入一个换行符

import java.io.BufferedWriter;
import java.io.FileWriter;
public class Demo12 {
    public static void main(String[] args) throws Exception {
        //1.设置文件字符输出
        FileWriter fileWriter=new FileWriter("e:\\147.txt");
        //2.设置文件字符写的缓存区
        BufferedWriter bufferedWriter=new BufferedWriter(fileWriter);
        //3.开始写的操作
        for (int i = 0; i <10 ; i++) {
            bufferedWriter.write("你好，小明");
            bufferedWriter.newLine(); //写入一个换行
        }
        System.out.println("项目完成");
        //关闭文件
        bufferedWriter.close();
    }
}

在这里插入图片描述

(八).打印输出流(printWriter)

22.打印输出流

打印输出流 （原样输出）
1.PrintWriter()

import java.io.PrintWriter;

public class Demo13 {
    public static void main(String[] args) throws Exception {
        //1.创建打印流
        PrintWriter printWriter=new PrintWriter("e:\\001.txt");
        //2.打印
        printWriter.println(91);
        printWriter.println(true);
        printWriter.println('a');
        printWriter.println("123");
        printWriter.close();
        System.out.println("打印成功");
    }
}

在这里插入图片描述

（九）、转换流（编码格式）

1.也叫做桥转换流:InputStreamReader/OutputStreamWriter
 (1).可将字节流转换为字符流
 (2).可设置字符的编码方式
 切记 : 读的文件的编码格式需要和设置的编码格式要一致否则会乱码
   （eg:utf-8 可以打印汉字 ，gbk 则会出现乱码）

在这里插入图片描述

23.输入转换流

import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;

public class Demo14 {

    public static void main(String[] args) throws Exception{
        //1.创建一个输入流
        FileInputStream fileInputStream=new FileInputStream("e:\\123.txt");
        //2.创建一个输入转换流,并且把输入流放进转换流
        InputStreamReader inputStreamReader=new InputStreamReader(fileInputStream,"utf8");  //指定编码
        int date=0;
        while ((date=inputStreamReader.read())!=-1){
            System.out.println((char)date);
        }
        inputStreamReader.close();
    }
}

在这里插入图片描述

24.输出转换流

基本思路:
1.创建文件流
2.创建文件输出转换流
3.关闭

import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
public class Demo15 {
    public static void main(String[] args) throws Exception{
        //1.创建文件输出流
        FileOutputStream fileOutputStream=new FileOutputStream("e:\\1217.txt");
        //2.文件输出转换流
        OutputStreamWriter outputStream=new OutputStreamWriter(fileOutputStream,"UTF-8");
        for (int i = 0; i <10; i++) {
            outputStream.write("你好，傻瓜");
            outputStream.flush();
        }
        outputStream.close();
        System.out.println("运行完毕!");
    }
}

在这里插入图片描述

(十)、File类

概念:代表物理盘符中的一个文件或则文件夹

25.文件操作

基本思路:
1.创建文件
2.分隔符
3.删除文件
4.获取文件
5.判断文件 

import java.io.File;
import java.util.Date;

public class Demo16 {
    public static void main(String[] args) throws Exception {
        separator();
        fileOpe();
    }
    //1.分隔符
    public static void separator(){
        System.out.println("路径分割符:"+ File.pathSeparator);
        System.out.println("名称分隔符:"+File.separator);
    }
    //2.文件操作
    public static void fileOpe() throws Exception{
        //1.创建文件
        File file=new File("e:\\file.txt");
        System.out.println(file.toString());
        if (!file.exists()) {
            boolean b = file.createNewFile();
            System.out.println("创建的结果是:" + b);
        }
        //2.删除文件
            //2.1直接删除
     /*   if (file.exists()){
            file.delete();
            System.out.println("删除成功");
        }

            //2.2使用jvm进行删除
        file.deleteOnExit();
        Thread.sleep(5000);
        */
        //3.获取文件信息
        System.out.println("获取文件的绝对路径: "+file.getAbsolutePath());
        System.out.println("获取文件的路径 "+file.getPath());
        System.out.println("获取文件的名称 "+file.getName());
        System.out.println("获取父目录"+file.getParent());
        System.out.println("就获取文件的长度:"+file.length());
        System.out.println("获取创建时间:"+ new Date(file.lastModified()));
        //4.判断
        System.out.println("判断是否可写:"+file.canWrite());
        System.out.println("是否是文件"+file.isFile());
        System.out.println("是否是隐藏的:"+file.isHidden());
    }
}

在这里插入图片描述

26.文件夹的操作:

基本思路:
1.遍历文件夹
2.创建文件夹
3.删除文件夹
4.判断文件夹的操作
5.获取文件夹信息

import java.io.File;
import java.util.Date;

public class Demo16 {
    public static void main(String[] args) throws Exception {
        directoryOpe();
    }

    public static void directoryOpe() throws Exception{
        //1.创建文件夹
        File dir=new File("e:\\aaa\\bbb\\ccc");  //d盘下面一个aaa目录，在下面bbb目录
        System.out.println(dir);
        if(!dir.exists()){
            System.out.println("创建多级目录成功:"+dir.mkdirs());
        }
        //2.删除文件
       /*    //2.1直接删除
        System.out.println("删除的结果是:"+dir.delete());  //删除底层目录并且文件内容为空的时候


            //2.2使用jvm进行删除
        dir.deleteOnExit();  //删除底层目录并且文件内容为空的时候
        Thread.sleep(5000);
        */
        //3.获取文件夹的信息
        System.out.println("获取绝对路径:"+dir.getAbsolutePath());
        System.out.println("获取路径"+dir.getPath());
        System.out.println("获取文件的名字"+dir.getName());
        System.out.println("获取父目录:"+dir.getParent());
        System.out.println("获取创建时间"+new Date(dir.lastModified()).toLocaleString());
        //4.判断
        System.out.println("是否是文件夹"+dir.isDirectory());
        System.out.println("是否被隐藏"+dir.isHidden());
        //5.遍历文件夹
        File file=new File("C:\\Users\\22612\\Pictures\\Screenshots");
        //通过集合的方式获取信息
        String []files=file.list();
        System.out.println("------------------------------------");
        for (String string : files){   //for增强遍历
            System.out.println(string);
        }
    }
}

在这里插入图片描述

(十一)、FileFilter(文件过滤器)接口

27.文件过滤器

public interface FileFilter
2.
当调用File类中的listFiles()方法时，支持传入FileFilter接口接口实现类，
对获取文件进行过滤，只有满足条件的文件的才可出现在listFiles()的返回值中。

基本思路:
1.文件过滤器:可以获得指定的文件
2.endsWith(".jpg") 获得后缀为.jpg的文件。
3.适配器

import java.io.File;
import java.io.FileFilter;
import java.util.Date;

public class Demo16 {
    public static void main(String[] args) throws Exception {
        directoryOpe();
    }
    //3.文件夹的操作:
    public static void directoryOpe() throws Exception{
        //5.遍历文件夹
        File file=new File("C:\\Users\\22612\\Pictures\\Screenshots");
        //通过集合的方式获取信息
        String []files=file.list();
        System.out.println("------------------------------------");
        for (String string : files){   //for增强遍历
            System.out.println(string);
        }
        System.out.println("------------------FileFilter------------------");
        File[] files2=file.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if(pathname.getName().endsWith(".jpg")){
                    return true;
                }
                return false;
            }
        });
        for (File file_1:files2) {
            System.out.println(file_1.getName());
        }
    }
}

在这里插入图片描述

(十二)、递归遍历/递归删除

28.递归遍历(文件)

基本思路:
1.利用递归的操作，依次进入文件夹。当遇到文件夹的时候，我们就对其进行遍历
和输出.

import java.io.File;

public class Demo17 {
    public static void main(String[] args) throws Exception {
            list_dir(new File("E:\\aaa"));
    }
    public static void list_dir(File dir){
        File[] files = dir.listFiles();
        System.out.println("文件夹的信息"+dir.getAbsolutePath());
        if(files!=null&&files.length>0){  //假如说文件/文件夹不为空，且长度大于0
            for (File file_one: files
                 ) {
                if(file_one.isDirectory()){  //如果是文件夹就进行递归
                    list_dir(file_one);
                }else {
                    //获取文件的绝对路径
                    System.out.println("文件的信息是:"+file_one.getAbsolutePath());
                }
            }
        }
    }
}

在这里插入图片描述

29.递归删除()

基本思路:
1.因为如果文件夹里面有文本，那么我们只有先删除文本，才能再次删除文件夹

import java.io.File;

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

            delete_dir(new File("E:\\aaa"));
    }
    public static void delete_dir(File dir){
        File[] files_one = dir.listFiles();
        System.out.println("进入文件夹 "+dir.getAbsolutePath());
        if(files_one!=null&&files_one.length>0){
            for (File files_two:files_one
                 ) {
                if(files_two.isDirectory()){ //假如是文件夹
                    delete_dir(files_two);
                }else{
                    System.out.println(files_two.getAbsolutePath()+"文件已被删除 "+files_two.delete());
                }
            }
        }
        System.out.println("删除文件夹"+dir.getAbsolutePath()+dir.delete());
    }
}

在这里插入图片描述

(十三)、Properties

30.properties

properties:属性集合
特点:
1.存储属性名和属性值
2.属性名和属性值都是字符串类型
3.没有泛型
4.和流有关

基本知识:
1.

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.Properties;
import java.util.Set;

public class Demo18 {
    public static void main(String[] args) throws Exception{
        //1.创建集合
        Properties properties=new Properties();
        //2.添加数据
        properties.setProperty("user_name","占山");
        properties.setProperty("age","20");
        System.out.println(properties.toString());
        //3.遍历:
          //3.1  keySet
            //3.2 entrySet
            //3.3 stringProperties.stringProprertyNames()
        Set<String> strings = properties.stringPropertyNames();   //设置一个集合
        for (String string_test:strings
             ) {
            System.out.println(string_test+"===="+properties.getProperty(string_test));  //通过key即可
        }
       //4.和流有关的方法
        PrintWriter printWriter=new PrintWriter("e:\\0303.txt");  //打印到e盘了
        properties.list(printWriter);
        printWriter.close();

  
        //5.=========保存store========
        //1.创建一个文件输出流
        FileOutputStream fileOutputStream=new FileOutputStream("e:\\store.properties");
        properties.store(fileOutputStream,"注释");
        fileOutputStream.close();
        //6.========load加载========
        Properties properties1=new Properties();
        FileInputStream fileInputStream=new FileInputStream("e:\\store.properties");
        properties1.load(fileInputStream);
        fileInputStream.close();
        System.out.println(properties1.toString());
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

吉士先生
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Java I/O技术之文件操作详解
09-04
主要介绍了Java I/O技术之文件操作详解,需要的朋友可以参考下
Java I/O 相关面试题
qq_45818776的博客
10-01 4040
Java I/O 相关面试题
Java之I/O流（最详细的I/O流总结）
熊凯瑞的博客
05-15 5689
I/O流I/O流1、定义2、分类2.1 字节流和字符流2.2 输入流和输出流2.3 节点流和处理流3、结构4、字节流4.1 定义4.2 说明4.3 字节流概述4.4 InputStream的常用方法4.5 OutputStream的常用方法5、字节流读写文件5.1 说明5.2 注意5.3 字节输入流——相关代码5.4 字节输出流——相关代码6、文件的拷贝6.1 需求6.2 分析6.3 注意6.4 快捷键6.5 相关代码7、字节流的缓冲区7. 相关代码8、字节缓冲流8.1 说明8.2 特点8.3 相关代码8.
Java I/O 模型的演进
老卫的技术站
03-01 2039
什么是同步？什么是异步？阻塞和非阻塞又有什么区别？本文先从 Unix 的 I/O 模型讲起，介绍了5种常见的 I/O 模型。而后再引出 Java 的 I/O 模型的演进过程，并用实例说明如何选择合适的 Java I/O 模型来提高系统的并发量和可用性。
java I/O操作相关的类
starlh35的博客
06-23 5516
java I/O操作相关的类 InputStream、OutputStream等常见I／O操作用到的java类整理
I/O error while reading input message； nested exception is java.io.IOException: Stream closed
ChuaWi98的博客
11-16 1万+
SpringMVC控制层接收前端多个参数，报错I/O error while reading input message; nested exception is java.io.IOException: Stream closed 【Controller】 @PostMapping("/list") public Result<List<ReviseInfo>> list(@RequestBody ReviseInfo reviseInfo, @RequestBody R
org.springframework.web.client.ResourceAccessException: I/O error on POST request for ************
热门推荐
weixin_43085797的博客
06-10 3万+
org.springframework.web.client.ResourceAccessException: I/O error on POST request for “http://localhost:9411/api/v2/spans”: org.springframework.web.client.ResourceAccessException: I/O error on POST request for "http://localhost:9411/api/v2/spans": connect
记一次错误:java.lang.IllegalStateException: Request cannot be executed； I/O reactor status: STOPPED
sq_ikk的博客
12-10 4799
java.lang.IllegalStateException: Request cannot be executed; I/O reactor status: STOPPED at org.apache.http.util.Asserts.check(Asserts.java:46) at org.apache.http.impl.nio.client.CloseableHttpAsyncClientBase.ensureRunning(CloseableHttpAsyn.
本地读取HDFS上文件报错：BlockReaderFactory: I/O error constructing remote block reader.
qq_37654889的博客
06-03 4939
背景： 利用IntelliJ IDEA开发在线教育离线数据仓库时，需要将HDFS上的*.log数据进行ETL后加载到dwd层的数据表中，即ods=>dwd，这里面如果使用本地模式运行(local[*])的会涉及到“本地测试环境（外网）访问云服务器HDFS文件系统间的通信”问题，通俗理解，本地环境读取云服务器上的数据。 报错点： 21/06/03 13:41:28 INFO HadoopRDD: Input split: hdfs://mycluster/warehouse/online_educati
Java中I/O（输入/输出）的操作
pan_junbiao的博客
12-19 3381
Java的I/O技术可以将数据保存到文本文件、二进制文件甚至是ZIP压缩文件中，以达到永久性保存数据的要求。 1、流概述 流是一组有序的数据序列，根据操作的类型，可分为输入流和输出流两种。I/O（Input/Output）流提供了一条通道程序，可以使用这条通道把源中的字节序列送到目的地。虽然I/O流经常与磁盘文件存取有关，但是程序的源和目的地也可以是键盘、鼠标、内存或显示器窗口等。 2、输入...
Java——I/O流（一）：字节流（概念理解+应用举例）
胜天半子祁同伟
07-19 9857
Java——I/O流（一）：字节流（概念理解+应用举例）
Java I/O 操作及优化建议
12-22
在Java中，内存泄露和其他内存相关问题在性能和可扩展性方面表现的为突出。我们有充分的理由去详细地讨论他们。 　Java内存模型——或者更确切的说垃圾回收器——已经解决了许多内存问题。然而同时，也带来了新的...
Java I/O 操作及优化详细介绍
08-31
主要介绍了Java I/O 操作及优化详细介绍的相关资料,需要的朋友可以参考下
Java I/O学习笔记： 磁盘操作 字节操作 字符操作 对象操作 网络操作 NIO & AIO Java I/O
12-26
Java I/O学习笔记： 磁盘操作 字节操作 字符操作 对象操作 网络操作 NIO & AIO Java I/O Java是一种面向对象的编程语言，由Sun Microsystems于1995年推出。它是一种跨平台的语言，意味着可以在不同的操作系统上运行...
Java使用I/O流读取文件内容的方法详解
08-25
主要介绍了Java使用I/O流读取文件内容的方法,结合实例形式详细分析了java使用I/O流读取文件常见操作技巧,需要的朋友可以参考下
jdk8新特性----Lambda表达式
最新发布
w_t_y_y的博客
05-11 184
Java的Lambda表达式是Java 8引入的一个特性，它支持函数式编程，允许将函数作为方法的参数或返回值，从而简化了匿名内部类的使用，并提供了对并行编程的更好支持。
java jar包如何运行或调用
NLP与推荐算法
05-08 254
java服务启动
【数据结构】二叉树
m0_73911405的博客
05-05 645
前序：根，左子树，右子树中序：左子树，根，右子树后序：左子树，右子树，根N代表空元素前序 1 2 3 N N N 4 5 N N 6 N N中序 N 3 N 2 N 1 N 5 N 4 N 6 N后序 N N 3 N 2 N N 5 N N 6 4 1层序 1 2 4 3 5 6一层层从左到右一个树分成根和子树，子树再分为根和子树。
CMS垃圾回收器为什么被移除
m0_54187478的博客
05-10 342
由于上述缺点，加上需要将资源投入到更现代垃圾回收器的开发和优化上，Oracle决定从Java 9开始标记CMS为废弃，并在后续版本中完全移除CMS。这些新的收集器旨在提供更低的停顿时间和更高的性能，同时减少配置和维护的复杂性。当它在垃圾收集周期内无法足够快地回收内存时，会退回到一种需要完全暂停所有应用线程的老年代收集模式，这与它设计的初衷相违背。：CMS使用的标记-清除算法会导致较多的内存碎片。：CMS需要更多的CPU资源来执行垃圾回收的并发阶段，而且它在运行时对系统资源的利用也较为激进。
java i o读写本地图片_Java I/O操作
06-11
好的，关于Java I/O操作读写本地图片，可以使用以下步骤： 1. 使用FileInputStream或FileOutputStream类来读写文件。 2. 创建一个File对象，指定要读写的文件路径。 3. 创建一个InputStream或OutputStream对象，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

吉士先生

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值