java基础 IO流和文件类的学习

文件 IO

1.File类

java.io.File类
文件和目录路径名的抽象表示形式
java把电脑的文件和文件夹（目录 ）封装为了一个File类，我们可以使用File类对文件文件夹操作
1.使用File类的方法创建文件/文件夹
2.删除文件/文件夹
3.获取文件/文件夹
4.判断文件/文件夹是否存在
5.获取文件/文件夹的大小
File类是一个与系统无关的类，任何操作系统都可以使用类中的方法

重点：
记住三个单词
file：文件
directory：文件夹/目录
path:路径

文件路径：不能写死了"+File.separator+"来代替/，而linux中为\

        String file = File.pathSeparator;//路径分隔符，windows分号，linux:冒号
        System.out.println(file);
        String sep = File.separator;//文件名称分割符。windows反斜杠，linux:正斜杠
        System.out.println(sep);

构造方法

* File(String pathname)* 传递路径名:可以写到文件夹，可以写到文件；
* File(String parent,String child)* 传递路径，传递字符串父路径，字符串子路径
*File(File parent,String child)；传递路径，传递字符串父路径，字符串子路径

常用方法

getAbsolutPath() 返回绝对路径
getPath() 返回原写的路径
getName() 获取构造方法中路径的结尾部分
length() 返回此file表示的文件长度（获取的文件的大小，字节）
exists() 判断段构造方法路径是否存在
isDirectory() 此file是否为目录//路径不存在返回false
isFile() 此file是否为文件//路径不存在返回false
mkdir() 创建次file表示的目录/单级
mkdirs() 创建次file表示的目录/可多级
delete() 删除此file表示的文件或目录/目录里面有内容返回false/没有路径返回false
createNewFile() 当前文件不存在时创建一个空文件/不能创建文件夹
list() String[ ]返回目录下所有文件和子目录名称，存入字符串数组中/路径不存在空指针异常
listFiles() File[ ]返回File数组，表示目录中所有的子文件目录

递归

直接递归：自己调用自己

间接递归：A方法调用B方法，B方法调用C方法，C方法调用A方法

构造方法禁止递归，太多可能栈内存溢出

IO

一切皆为字节

	输入流	输出流
字节流	InputStream	OutputStream
字符流	Reader	Writer

OutputStream（抽象类）

所有输出字节流的超类

void close() 关闭流，释放资源

void flush() 刷新次输出流并强转任何缓冲流的输出字节被写出

void write(byte[ ] b) 把指定字节数组写入此流

void write(byte[ ] b,int off,int len)

InputStream

java.io.InputStream：字节输入流，字节输入流的所有类的超类
InputStream抽象类
定义了所有子类共性的方法：
1.int read()从输入流中读取数据的下一个字节,读到末尾返回-1
2.int read(byte[ ] b) 从输入流中读取一定数量的字节，并存储在缓冲数组b中
3.void close()关闭输入流并释放与该流并联的所有系统资源

FIleOutputStream

构造方法：
FileOutputStream(String name)目的地是文件路径
FileOutputStream(File file)目的地是文件
需要续写和追加在构造方法添加参数true否则false

FileInputStream

public class Demo06InputOutputStream {
    public static void main(String[] args) throws IOException {
        long s = System.currentTimeMillis();
        FileInputStream fis = new FileInputStream("Demo01HelloWorld\\123");
        FileOutputStream fos = new FileOutputStream("Demo01HelloWorld\\111");

        //使用数组缓冲，读写多个字节
        byte[] bets = new byte[1024];
        int len = 0;//每次读取的有效字节个数
        while((len = fis.read(bets))!=-1){
            fos.write(bets,0,len);
        }
        //先关写数据流，再关读数据流
        fos.close();
        fis.close();
        long e = System.currentTimeMillis();
        System.out.println("文件复制共耗时："+(e-s)+"毫秒");
    }
}

Reader

java.io.Reader字符输入流的最顶层父类，定义了一些共性的成员方法，是一个抽象类

共性的成员方法：
1.read()读取单个字符，并返回
2.read()一次读取多个字符，将字符读入数组
3.close()关闭并释放资源

Writer

java.io.Writer
字符输出流的最顶层父类，定义了一些共性的成员方法，是一个抽象类
共性的成员方法：
public void write(int c) 写入单个字符
public void write(char[] cbuf, int off, int len) 写入字符组某一部分
public void write(String str) 写入字符串
public void write(String str, int off, int len)写入字符串某一部分
public void flush()刷新改流的缓冲
public void close() 关闭此流，但先刷新她

FileReader

java.io.FileReader extends InputStreamReader extends Reader

FileReader：文件字符输入流
作用：把硬盘中的数据以字符的方式读取到内存中
构造方法：
FileReader(String fileName)
FileReader(File file)

**字符输入流的使用步骤：
1.创建FileReader对象，在构造方法中绑定要读取的数据源
2.使用FileReader对象中的方法read读取文件
3.释放资源

FileWriter

java.io.FileWriter extends OutputStreamReader extends Writer
FileWriter：文件字符输出流
作用：把内存中的字符数据写入到硬盘中
构造方法：
FileWriter(String fileName)
FileWriter(File file)
参数：写入数据的目的地
String fileName：文件路径
需要续写和追加在构造方法添加参数true否则falseFile file：文件

构造方法的作用：
1.创建FileWriter对象
2.会根据构造方法中传递的文件/文件路径创建文件
3.把FileWriter对象指向创建好的文件

**字符输入流的使用步骤：
1.创建FileWriter对象，在构造方法中绑定要写入数据的目的地
2.使用FileWriter对象中的方法write把数据写入到内存缓冲区中（字符转换为字节的过程）字符流和字节流最大区别
3.使用FileWriter对象中的方法flush,把内存缓冲区的数据，刷新到文件中
4.释放资源（会先把内存缓冲区数据刷新文件中）

流IO异常处理

1.jdk1.7之前使用try … catch finally

 //提高变量fw的作用域，让finally可以使用
        //变量在定义时可以没有值，但是使用时必须有值
        FileWriter fw = null;
        try{
            fw = new FileWriter("Demo01HelloWorld\\123.txt",true);
            for (int i = 0; i < 10; i++) {
                fw.write("HelloWorld"+i+"\r\n");
            }
            //fw.close();
        }catch (IOException e){
            System.out.println(e);
        }finally {
            //创建对象失败了，fw的默认值为null，null是不能调用方法的会抛出NullPointerException异常
            //需要增加一个判断，不是null再把资源释放
            if(fw!=null){
                try {
                    //close声明抛出了IOException异常对象，我们要处理这个异常对象，要么throws，要么try catch
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

2.jdk7后

JDK7新特性
在try的后边可以增加一个(),在括号中可以定义流对象
那么这个流对象的作用域在try中有效
try中的代码执行完毕，会自动把流对象释放，不会些finally
格式：
try(定义流对象;可以定义多个…){
可能会产生异常的代码
}catch(异常类变量 变量名){
异常的处理逻辑
}

public static void main(String[] args) {
        try(FileInputStream fis = new FileInputStream("Demo01HelloWorld\\123.txt");
            FileOutputStream fos = new FileOutputStream("Demo01HelloWorld\\123.txt");){
            int len = 0;
            while((len = fis.read())!=-1){
                fos.write(len);
            }
        }catch (IOException e){
            System.out.println(e);
        }

3.jdk9

格式：
    A a = new A();
    B b = new B();
    try(a;b){
    可能会产生异常的代码
}catch(异常类变量 变量名){
    异常的处理逻辑
}

 */

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

public class Demo03JDK9 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("Demo01HelloWorld\\123.txt");
        FileOutputStream fos = new FileOutputStream("Demo01HelloWorld\\123.txt");
        try(fis;fos){
            int len = 0;
            while((len = fis.read())!=-1){
                fos.write(len);
            }
        }catch (IOException e){
            System.out.println(e);
        }
    }
}

Properties

java.util.Properties extends hashtable<key,value> implements Map<k,v>
Properties类表示一个持久的属性类，Properties可保存在流中或从流中加载
Properties集合是一个唯一和io流相结合的集合
1.可以使用Properties集合中的方法store，把集合中的临时数据，持久化写入到硬盘中存储
2.可以使用Properties中的方法load,把硬盘中保存的文件（键值对）读取到集合中使用

属性列表中每个键值及其对应值都是一个字符串
Properties集合是一个双列集合，key和value默认都是字符串
Properties中有一些操作字符串的特有方法
Object setProperty(String key,String value)调用hashtable的方法put，往里面放入字符
String getProperty(String key),通过key找到value,类似于Map方法中的get()value方法
stringPropertyNames返回此属性中的键集，相当于keySet方法

集合中的临时数据写到硬盘中保存

​ //public void store(Writer writer, String comments)
​ //public void store(OutputStream out, String comments)
​ /*
​ 参数：OutputStream out：字节输出流，不能写入中文，Writer writer字符输出流，可以写中文
​ String comments：用来解释说明保存的文件是做什么的，不能使用中文
​ 使用步骤：
​ 1.创建Properties集合对象，并存储数据
​ 2.创建字节输出流或者是字符输出流对象，构造方法中绑定要输出的目的地
​ 3.使用Properties集合中的方法store，把集合中的数据持久化写入到硬盘中存储
​ 4.释放资源

lode()方法

可以使用Properties集合中的方法load,把硬盘中保存的文件(键值对),读取到集合中使用
void Load(InputStream inStream )
void Load(Reader reader)
参数:
InputStream inStream:字节输 入流,不能读取含有中文的键值对
Reader reader :字符输入流,能读取含有中文的键值对
使用步骤:
1.创建Properties集合对象
2.使用Properties集合对象中的方法Loadi读取保存键值对的文件
3.遍历Properties集合
.注意:
1.存储键值对的文件中,键与值默认的连接符号可以使用=,空格(其他符号)
2.存储键值对的文件中,可以使用进行注释,被注释的键值对不会再被读取
3.存储键值对的文件中,键与值默认都是字符串,不用再加引号

示例

private static void show03() throws IOException {
        /*
        public synchronized void load(Reader reader)
        public synchronized void load(InputStream inStream)
        Reader reader：字符输入流；可以读取含有中文的键值对
        InputStream inStream：字节输入流，不能读取含有中文的键值对
        使用步骤：
        1.创建Properties集合对象
        2.使用Properties集合中的方法load读取保存键值对的文件
        3.遍历Properties集合
        注意：
        1.存储键值对的文件中，键与值默认的连接符号可以使用=，空格（其他的一些符号）
        2.存储键值对的文件中，可以使用#进行注释，被注释的键值对不会被读取
        3.存储键值对的文件中，键与值默认都是字符串，不用加上引号
         */
        Properties pro = new Properties();
        pro.load(new FileReader("Demo01HelloWorld\\123.txt"));
        Set<String> set = pro.stringPropertyNames();
        for (String key : set) {
            String value = pro.getProperty(key);
            System.out.println(key+"="+value);
        }
    }

    private static void show02() throws IOException {
        //集合中的临时数据写到硬盘中保存
        //public void store(Writer writer, String comments)
        //public void store(OutputStream out, String comments)
        /*
        参数：OutputStream out：字节输出流，不能写入中文，Writer writer字符输出流，可以写中文
        String comments：用来解释说明保存的文件是做什么的，不能使用中文
        使用步骤：
        1.创建Properties集合对象，并存储数据
        2.创建字节输出流或者是字符输出流对象，构造方法中绑定要输出的目的地
        3.使用Properties集合中的方法store，把集合中的数据持久化写入到硬盘中存储
        4.释放资源
         */
        Properties pro = new Properties();
        pro.setProperty("java","20");
        pro.setProperty("python","21");
        pro.setProperty("go","22");
        FileWriter fw = new FileWriter("Demo01HelloWorld\\123.txt");
        pro.store(fw,"save data");
        fw.close();
//        pro.store(new FileOutputStream("Demo01HelloWorld\\123.txt"),"save data");

    }

    private static void show01() {
        Properties pro = new Properties();
        pro.setProperty("java","20");
        pro.setProperty("python","21");
        pro.setProperty("go","22");
        Set<String> str = pro.stringPropertyNames();//取出键值，存储到set中
        //遍历set集合，取出Properties集合的每一个键
        for (String key : str) {
            String property = pro.getProperty(key);
            System.out.println(key+"="+property);
        }
    }

字节缓冲输出流

java.io.BufferedOutputStream extends OutputStream
BufferedOutputStream字节缓冲输出流
继承自父类的共性成员方法：
…
构造方法：
BufferedOutputStream(OutputStream out)创建一个新的缓冲输出流，以将数据写入指定的底层输出流
BufferedOutputStream(OutputStream out,int size)创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流
OutputStream out：字节输出流
int size：指定缓冲区大小
我们可以传递FileOutputStream,缓冲流会给FileOutputStream增加一个缓冲区，提高FileOutputStream的写入效率
**使用步骤：
1.创建一个FileOutputStream对象，构造方法中绑定要输出的目的地
2.创建BufferedOutputStream对象，构造方法中传递FileOutputStream对象，提高FileOutputStream对象效率
3.使用BufferedOutputStream对象的方法write，把数据写入到内部的缓冲区中
4.使用BufferedOutputStream对象的方法flush，把内部缓冲区的数据刷新到文件中
5.释放资源（先调用flush刷新数据，第四步可以省略）

字节缓冲输入流

java.io.BufferedOInputStream extends InputStream
BufferedInputStream字节缓冲输入流
继承自父类的共性成员方法：
1.int void()从输入流中读取数据的下一个字节
2.int read(byte[] b)从输入流中读取一定数量的字节，并存储在缓冲数组b中
3.void close()关闭输入流并释放与该流并联的所有系统资源

构造方法：
BufferedInputStream(InputStream out)创建一个新的缓冲输入流，以将数据读出到指定的底层输入流
BufferedInputStream(InputStream out,int size)创建一个新的缓冲输入流，以将具有指定缓冲区大小的数据读出到指定的底层输入流
InputStream in：字节输入流
int size：指定缓冲区大小
使用步骤：
1.创建一个FileInputStream对象，构造方法中绑定要读取的数据源
2.创建BufferedInputStream对象，构造方法中传递FileInputStream对象，提高FileInputStream对象效率
3.使用BufferedInputStream对象的方法read，把数据读出到内部的缓冲区中
4.释放资源

字符缓冲输出流

BufferedWriter：字符缓冲输出流
继承自父类的方法
public void write(int c)
public void write(char[] cbuf, int off, int len)
public void write(String str)
public void write(String str, int off, int len)
public void flush()
public void close()
构造方法：
public BufferedWriter(Writer out)创建默认缓冲区
public BufferedWriter(Writer out, int sz)指定大小的
Writer out：传一个字符输出流，可以传递FileWriter，缓冲流会给FileWriter增加一个缓冲区，提高FileWriter的写入效率
int sz：指定缓冲区大小，不写默认大小

特有的成员方法：
public void newLine()写个行分隔符
好处：会根据不同的操作系统获取不同的行分隔符
使用步骤：
1.创建字符缓冲输出流对象，构造方法中传递字符输出流
2.调用字符缓冲输出流write，把数据写入到内存缓冲区
3.调用flush方法
4.释放资源

字符缓冲输入流

java.io.BufferedReader extends Reader
继承自父类的成员方法
1.read()读取单个字符，并返回
2.read()一次读取多个字符，将字符读入数组
3.close()关闭并释放资源
构造方法：
public BufferedReader(Reader in)
public BufferedReader(Reader in, int sz)
参数：
Reader in：字符输入流，参考与BufferedWriter
int sz：指定大小
特有的成员方法
String readLine(boolean ignoreLF)读一行数据
行的终止符号：通过下列字符之一即可认为某行已终止，换行（‘\n’）回车或者回车后直接跟着换行（\r\n）
返回值：包含改行内容的字符串，不包含任何终止字符，如果已到达流末尾，则返回null
使用步骤：
1.创建字符缓冲输入流对象，构造方法中传递字符输入流
2.使用字符缓冲输入流对象中的方法read/readLine读取文本
3.释放资源

InputStreamReader转换流

java.io.InputStreamReader extends Reader
是字节通向字符的桥梁（解码）
共性的成员方法：
1.read()读取单个字符，并返回
2.read()一次读取多个字符，将字符读入数组
3.close()关闭并释放资源
构造方法：
public InputStreamReader(InputStream in)
public InputStreamReader(InputStream in, String charsetName)
InputStream in：字节输入流，读取文件中保存的字节
String charsetName：指定的编码表名称，不分大小写，不指定，默认UTF-8

**使用步骤：
1.创建一个InputStreamReader对象，构造方法中传递字节输入流和指定的编码表名称
2.使用InputStreamReader对象的方法read读取文件
3.释放资源
注意事项：
构造方法中指定的编码表名称要和文件的编码相同，否则会发生乱码

OutputStreamWriter转换流

java.io.OutputStreamWriter extends Writer
OutputStreamWriter:是字符通向字节的桥梁（编码）
继承自父类的方法
public void write(int c)
public void write(char[] cbuf, int off, int len)
public void write(String str)
public void write(String str, int off, int len)
public void flush()
public void close()
构造方法：
public OutputStreamWriter(OutputStream out, String charsetName)指定字符集的OutputStreamWriter
public OutputStreamWriter(OutputStream out)默认的
参数：
OutputStream out：字节输出流，可以用来写转换之后的字节到文件中
String charsetName：指定的编码表名称，不分大小写，不指定，默认UTF-8

**使用步骤：
1.创建一个OutputStreamWriter对象，构造方法中传递字节输出流和指定的编码表名称
2.使用OutputStreamWriter对象的方法write把字符转换为字节存储到缓冲区中（编码）
3.使用OutputStreamWriter对象的方法flush，把内存缓冲区中的字节刷新到文件中（使用字节流写字节的过程）
4.释放资源