自用 Java 学习 IO流前总结(IO流)

File类

目录

File类

创建File对象

相对路径和绝对路径

File类的常用方法

File操作文件夹练习

IO流

IO流的分类

字节流写数据

字节流读数据

字节流复制文件【重点】

字节缓冲流复制文件【重点】

字符流

字符流写入数据

字符流读取数据

字符流复制文件

字符缓冲流提高读写效率

close和flush的区别

Properties类

Properties方法使用

Properties配合IO使用

---

File类表示文件或者文件夹的路径。

创建File对象

创建File对象时，需要指定一个路径。这个路径可以存在，也可以不存在，可以是文件路径也可是文件夹路径。

File f1=new File("C:\\a.txt");
System.out.println(f1);

File f2=new File("C:\\itheima\\aaa","a.txt");
System.out.println(f2);

File dir=new File("C:\\itheima\\aaa");
File f3=new File(dir,"a.txt");
System.out.println(f3);

File f4=new File("F:\\abc\\a.txt");
System.out.println(f4)

相对路径和绝对路径

绝对路径：从盘符开始的路径
     C:\itheima\a.txt
相对路径： 相对于项目的根目录，下面的路径
     //假设项目的根路径是C:\\IdeaProjects\javase
     绝对路径 C:\\IdeaProjects\javase\myModule\a.txt
     相对路径：myModule\a.txt
     
注意：只有在项目的文件下的文件，才可以写相对路径。

File类的常用方法

判断功能

public boolean exists()  
    判断File对象的路径是否存在
public boolean isDirectory()  
    判断File对象的路径是否为文件夹路径
public boolean isFile() 
    判断File对象的路径是否为文件路径

获取功能

public String getName()  
    获取文件或者文件夹的名称
public String getParent()
    获取文件或者文件夹的父目录，返回字符串
public File getParentFile()  
    获取文件或者文件夹的父目录，返回File对象
public String getPath()  
    获取File对象封装的路径
public String getAbsolutePath()  
    获取绝对路径, 返回值是String类型
public File getAbsoluteFile()  
    获取绝对路径，返回值File对象
    
public long length()
    获取文件的大小，单位(字节)
    不能获取文件夹的长度

创建和删除方法

public boolean mkdir()
    创建文件夹
public boolean mkdirs()  
    创建多级文件夹
    
public boolean createNewFile()
    创建文件
public void delete()
    删除文件或者文件夹（必须是空的文件夹才能删除）

遍历文件夹的方法

public File[]  listFiles()
    获取当前目录下所有文件和文件夹，把获取到文件和文件夹以File对象的方式存在File数组中。
    注意：
        1.返回值是null的几种情况
            File对象的目录路径不存在
            File对象的路径为文件路径
            File对象的文件没有权限访问
            
        2.File对象的目录存在，但是目录中没有东西
            返回值是一个File[],但是数组中没有元素

File操作文件夹练习

遍历文件夹中所有的子文件和子目录

public class Demo2 {
    public static void main(String[] args) {
        File f=new File("C:\\Users\\itheima\\Desktop\\itheima");
        printDirectory(f); 
    }
    //方法：遍历一个文件夹中的所有子文件和子文件夹
    public static void printDirectory(File dir){
        System.out.println(dir); //打印文件夹
        //判断dir是文件夹吗？
        if(dir.isDirectory()){
            //获取文件夹下的子文件和子文件夹，存在File数组中
            File[] files = dir.listFiles();
            if(files!=null){
                for (File file : files) {
                    //判断file是文件吗？是文件，直接打印
                    if(file.isFile()){
                        System.out.println(file);
                    }else {
                        //判断file是文件夹吗？ 如果是文件夹，继续遍历文件夹
                        printDirectory(file); 
                    }
                }
            }
        }
    }
}

删除一个文件夹

public class Demo3 {
    public static void main(String[] args) {
        File file=new File("C:\\Users\\itheima\\Desktop\\itheima");
        deleteDir(file);
    }
    //方法： 删除文件夹
    public static void deleteDir(File dir){
        if(dir.isDirectory()){
            //遍历文件夹中的内容
            File[] files = dir.listFiles();
            if(files!=null){
                for (File file : files) {
                    if(file.isFile()){
                        //是文件，直接删除
                        file.delete();
                    }else{
                        //是文件夹，递归调用
                        deleteDir(file);
                    }
                }
            }
            //删除空的文件夹
            dir.delete(); 
        }
    }
}

统计一个文件夹中每一种文件出现的次数

public static void getCount(HashMap<String,Integer> map,File dir){
    //如果是文件夹，才进行下面的操作
    if(dir.isDirectory()){
        File[] files=dir.listFiles();
        if(files!=null){
            for(File file:files){
                //如果file是文件，统计每一种文件出现多少次，文件-次数对应关系，存储到map集合中
                if(file.isFile()){
                    //获取文件的后缀名 如： a.txt --> txt
                    String fileEndname=file.getName().split("\\.")[1];
                    //判断map集合中是否存在键
                    if(map.containsKey(fileEndname)){
                        //包含这个键，先获取键对应的值，再加1，再存回去
                        Integer count=map.get(fileEndname);
                        map.put(fileEndname,count+1);
                    }else{
                        //不包含键，第一次存
                        map.put(fileEndname,1); 
                    }
                }else{
                    getCount(map,file); 
                } 
            }
        }
    }
}

求文件夹的大小

public class Demo7 {
    public static void main(String[] args) {
        long length = getLength(new File("C:\\Users\\itheima\\Desktop\\Java117期"));
        System.out.println(length);
    }

    //获取文件夹的大小
    //参数：File dir 文件夹
    //返回值： long 文件夹的大小
    public static long getLength(File dir) {
        long length = 0;
        //1.判断dir是否为文件夹
        if (dir.isDirectory()) {
            //2.是文件夹就进行遍历
            File[] files = dir.listFiles();
            if (files != null) {
                for (File file : files) {
                    //file可能是文件，也可能是文件夹
                    if (file.isFile()) {
                        //求文件的大小，和length累加
                        length += file.length();
                    } else if (file.isDirectory()) {
                        //求文件夹的大小，和length累加
                        length += getLength(file);
                    }
                }
            }
        }
        return length;
    }
}

IO流

IO流是用来处理数据的输入（读）和输出（写）的。

IO流的分类

按照流向分类
    输入流： 读数据
    输出流： 写数据

按照读写的数据类型分类
    字节流：读写任意类型的文件（图片、视频、文字、游戏...）
        字节输入流：InputStream，用来读取字节数据
          - FileInputStream：读取文件中的字节
          - BufferedInputStream: 对已有的InputStream进行包装提高读取的效率
            
        字节输出流：OutputStream，用来写字节数据
          - FileOutputStream： 写入文件中的字节
          - BufferedOutputStream：对已有的OutputStream进行包装提高写入的效率
    
    字符流：读写文本文件（用记事本打开，嫩看懂的就是文本文件）
        字符输入流: Reader
                    - FileReader
                    - BufferedReader
        字符输出流: Writer
                    - FileWriter
                    - BufferedWriter

字节流写数据

//创建输出流对象(搭桥)，需要关联一个文件
//如果文件不存在，会自动创建一个
//如果文件存在，会把原来的文件覆盖掉
FileOutputStream fos=new FileOutputStream("myModule11\\a.txt");

//写数据(过桥)
fos.write("helloworld".getBytes());
fos.write("\r\n".getBytes()); //写一个换行
fos.write("你好世界".getBytes()); 

//写单个字节
fos.write(97); //97对应字符'a'

//写多个字节
byte[] bs={97,98,99,100,101}; //'a','b','c','d','e'
fos.write(bs);

//字节数组的一部分
fos.write(bs,0,3);

//释放资源(过河拆桥)
fos.close(); 

字节流读数据

 //1.创建输入流对象
FileInputStream fis=new FileInputStream("myModule11\\a.txt");

//2.读取数据：  一次读多个字节
byte[] bs=new byte[1024];
int len ; //记录每次读取的字节个数
while ((len=fis.read(bs))!=-1){
    //把读取到的有效字节个数，转换为字符串
    String str=new String(bs,0,len);
    System.out.println(str);
}
//3.释放资源
fis.close();

字节流复制文件【重点】

把a.txt文件中的内容，复制到b.txt文件中

文件复制的思路：
    使用输入流，读取源文件(a.txt)
    使用输出流，写入目标文件(b.txt)

//使用输入流，读取源文件(a.txt)
FileInputStream fis=new FileInputStream("myModule11\\itheima42.jpg");
//使用输出流，写入目标文件(b.txt)
FileOutputStream fos=new FileOutputStream("myModule11\\itheima43.jpg");

//一遍读，一遍写
byte[] bs=new byte[1024];
int len; //每次读取的有效个数
while ((len=fis.read(bs))!=-1){
    //把读取到有效字节，写入目标文件中
    fos.write(bs,0,len);
}

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

字节缓冲流复制文件【重点】

BufferedInputStream和BufferedOutputStream用来对已有的InputStream和OutPutStream进行包装，从而提高读写效率。

//记录开始时间
long start = System.currentTimeMillis();

//读取a.exe文件
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\itheima\\a.exe"));

//写入b.exe文件
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("C:\\itheima\\c.exe"));

byte[] bs=new byte[1024];
int len; //读取的有效字节个数
while ((len=bis.read(bs))!=-1){
    bos.write(bs,0,len);
}

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

//记录结束时间
long end = System.currentTimeMillis();
System.out.println(end-start);

总结

一、File类
    1.Filel类概述： 表示文件或者文件夹的路径
    
    2.路径的分类：
        1)绝对路径：从盘符开始的路径
        2)相对路径：从项目的根目录开始的路径(省略项目的根目录不写)
    
    3.File的常用方法：
        1)获取方法
            getAbsolutePath(): 获取文件或者文件夹的绝对路径，返回字符串
            getAbsoluteFile(): 获取文件或者文件夹的绝对路径，返回File对象
            
            getParent(): 获取文件或者文件夹的父路径，返回字符串
            getParentFile(): 获取文件或者文件夹的父路径，返回File对象
            
            getPath(): 获取File对象封装的路径 //File f = new File(路径):
            
            length():  获取文件的大小（单位：byte字节）（注意：有内容的文件夹不能直接获取大小）
            
        2)判断方法
            exists(): 判断文件或者文件夹是否存在
            isFile(): 判断是否是文件
            isDirectory(): 判断是否是文件夹
        
        3)创建删除
            mkdirs(): 创建多级、单级文件夹
            mkdir(): 创建单级文件夹（不推荐）
            createNewFile(): 创建文件
            
            delete(): 删除文件或者空的文件夹（注意：有内容的文件夹不能直接删除）
        
二、IO流
    1.IO流是干什么用的？
        答：对数据进行读和写操作的（今天学习的主要是往文件中读、写数据）
        
    2.IO流的分类？
        1) 按照流向分类
            输入流：用来读取数据
            输出流：用来写入数据
        
        2) 按照读写数据类型分类
            
            字节流：可以读取、写入任何类型的文件（文本、音频、视频....）
                FileInputStream:  读取字节数据
                FileOutputStream: 写入字节数据
            
            字符流：只能读取、写入纯文本文件（用记事本打开没有乱码，那就是纯文本）【明天再讲】
            
            
    3.IO流的操作步骤：
        第一步：创建流对象(搭桥)
        第二步：读、写数据(过桥)
        第三步：释放资源(过河拆桥)
        
    
    4.FileOuputStream写数据
        
        //第一步：创建流对象(搭桥)
        FileOutputStream  fos = new FileOutputStream(路径,续写开关);
        
        //第二步：读、写数据(过桥)
        fos.write(int整数);  //写一个字节
        fos.write(byte数组);  //写多个字节
        fos.write(byte数组, 起始索引, 个数);  //写数组的一部分
        fos.write(字符串.getBytes());   //把字符串转换为字节数组，写入文件
        
        //第三步：释放资源(过河拆桥)
        fos.close();
        

    5.FileInputStream读数据
        
        //第一步：创建流对象(搭桥)  【路径必须存在】
        FileInputStream fis = new FileInputStream(路径);
        
        //第二步：读数据(过桥) 【下面写了两种写法，不能共存】
        //一次读取一个字节
        int b;
        while((b=fis.read())!=-1){
            System.out.println(b); //打印读取到那一个字节
        }
        
        //一次读取多个字节
        byte[] bs = new byte[1024];
        int len; //记录每次读取的有效个数
        while((len=fis.read(bs))!=-1){
            //把数组中有效的字节转换为字符串
            String str = new String(bs, 0, len);
            System.out.println(str);
        }
        
        //第三步：释放资源(过河拆桥)
        fis.close();
        
        
    6.复制文件【重点掌握】
        //创建输入、输出流
        FileInputStream fis = new FileInputStream("day11\\a.txt");
        FileOutputStream fos = new FileOutputStream("day11\\b.txt");

        //一边读，一边写
        byte[] bytes = new byte[1024];
        int len; //记录每次读取个有效个数
        while ((len = fis.read(bytes)) != -1) {
            //把每次读取到的有效数据，写入到目标文件中
            fos.write(bytes, 0, len);
        }

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

字符流

Java的API中，为了解决前面的乱码问题，专门提供了类流用来对文本文件进行操作。Reader和Writer

Reader: 字符输入流(读取字符)
    -- FileReader
    -- BufferedReader
    
Writer: 字符输出流(写入字符)
    -- FileWriter
    -- BufferedWriter

字符流写入数据

//创建输出流对象FileWriter
FileWriter fw=new FileWriter("myModule12\\b.txt");

//写一个字符
fw.write(97); //写97对应的是 字符‘a’

//写多个字符
char[] chs={'h','e','l','l','o'};
fw.write(chs); 

//写一个字符数组的一部分
fw.write(chs,0,3);

//写一个字符串
fw.write("你好世界");

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

字符流读取数据

一次读取多个字符

//创建输入流对象
FileReader fr=new FileReader("myModule12\\a.txt");

//读取数据: 一次读取多个字符
char[] chs=new char[1024];
int len; //记录每次读取的字符个数
while ((len=fr.read(chs))!=-1){
    //把字符数组的一部分，转换为字符串
    String str=new String(chs,0,len);
    System.out.println(str);
}

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

字符流复制文件

//源文件：a.txt ,使用FileReader进行读取
FileReader fr=new FileReader("myModule12\\a.txt");
//目标文件:b.txt，使用FileWriter进行写入
FileWriter fw=new FileWriter("myModule12\\b.txt");

//一边读，一遍写
char[] chs=new char[1024];
int len; //记录每次读取的字符个数
while ((len=fr.read(chs))!=-1){
    //把读取到的有效字符，写入到目标文件
    fw.write(chs,0,len);
}

//释放资源
fw.close();
fr.close();

字符缓冲流提高读写效率

BufferedReader和BufferedWriter是一个包装流，它的读和写依赖于Reader和Writer，在内部有一个缓冲区数组，可以提高读写的效率。

//源文件：a.txt ,使用FileReader进行读取
//FileReader fr=new FileReader("myModule12\\a.txt");
BufferedReader br=new BufferedReader(new FileReader("myModule12\\a.txt"));

//目标文件:b.txt，使用FileWriter进行写入
//FileWriter fw=new FileWriter("myModule12\\b.txt");
BufferedWriter bw=new BufferedWriter(new FileWriter("myModule12\\b.txt"));

//一边读，一遍写
char[] chs=new char[1024];
int len; //记录每次读取的字符个数
while ((len=br.read(chs))!=-1){
    //把读取到的有效字符，写入到目标文件
    bw.write(chs,0,len);
}

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

使用BufferedReader和BufferedWriter缓冲流读取写数据，一次读写一行

BufferedReader 有一个读取一个行的方法  readLine()
    
BufferedWriter 有一个写换行符的方法  newLine(); //具有跨平台性
    Win: \r\n
    Linux: \n
    Mac:  \r

//源文件：a.txt ,使用FileReader进行读取
BufferedReader br=new BufferedReader(new FileReader("myModule12\\a.txt"));
//目标文件:b.txt，使用FileWriter进行写入
BufferedWriter bw=new BufferedWriter(new FileWriter("myModule12\\b.txt"));

//读一行，写一行
String line; //每次读取的行
while ((line=br.readLine())!=null){
    //把读取的每一行，写入到目标文件
    bw.write(line);
    //bw.write("\r\n");  //Win: \r\n  Linux: \r Mac \n
    bw.newLine(); //写一个换行符，具有跨平台性，
}

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

close和flush的区别

flush: 把流中缓冲的数据刷新到文件中
close: 先自动刷新，再释放资源。

Properties类

Properties是Map的子类，是一个双列集合，键和值都是字符串类型。Map集合的方法它都能使用。

Properties方法使用

推荐是Properties自己特有的方法，对集合进行操作。

public Object setProperty(String key, String value)  
    添加键和值，如果键重复，旧值会被覆盖
public String getProperty(String key) 
    据键获取值
public Set<String> stringPropertyNames()
    获取键的集合

--------------------------------------------------------

Properties pro=new Properties();

//使用Properties集合的特有方法，存储键-值
pro.setProperty("张三","18");
pro.setProperty("李四","20");
pro.setProperty("王五","19");
pro.setProperty("王五","22");

//通过键，获取值
String obj = pro.getProperty("李四");
System.out.println(obj);

//遍历
Set<String> keys = pro.stringPropertyNames();
for (String key : keys) {
    String vlaue = pro.getProperty(key);
    System.out.println(key+"..."+vlaue);
}

Properties配合IO使用

Properties提供了两个和IO流相关的方法，用来把键值对存储到文件和读取键值对到集合。

public void store(OutputStream out, String comments) 
    把集合中的键和值存储到文件中
public void load(Reader reader)
    把文件中的键和值读取到集合中

Properties pro=new Properties();
pro.setProperty("zhangsan","20");
pro.setProperty("lis","28");
pro.setProperty("wangwu","21");

//把集合中的键和值，写到文件中
pro.store(new FileWriter("myModule12\\a.txt"),null);

//读取文件中的键和值读取到集合
pro.load(new FileReader("myModule12\\a.txt"));
System.out.println(pro);

Properties集合一般和软件的配置文件一起使用，把软件的相关配置写成一个文件，在文件中键值对的形式来保存配置信息。

Properties pro=new Properties();
// 1.读取配合文件中键对应的值
pro.load(new FileReader("myModule12\\a.txt"));
// 2.把值转换为整数，判断整数是否>0,说明还有使用次数
String count = pro.getProperty("count");
int value = Integer.parseInt(count);
if(value>0){
    System.out.println("欢迎使用");
    //每次使用之后，需要修改配置文件的值，-1
    value--;
    pro.setProperty("count",value+"");
    //把集合中的键和值写到文件中
    pro.store(new FileWriter("myModule12\\a.txt"),null);
}else{
    System.out.println("使用次数已到,请登录XXXXXXXXXXXXXXX");
}