File类与IO流

file类的静态成员变量(不同的操作系统不同的结果)

String pathSeparator = File.pathSeparator;//与系统有关的路径分隔符
String separator = File.separator;//与系统有关的默认名称分隔符
System.out.println(pathSeparator);
System.out.println(separator);

------------------结果------------------

;

绝对路径和相对路径

绝对路径：一个完整的路径，以盘符开始的路径
F:360MoveDataUserslenovoDesktop1.基础班1-8 File类与IO流
相对路径：一个简化的路径，相对于当前项目的根目录
简化为-->1-8 File类与IO流

file类的构造方法

File(File parent，String child)
根据parent抽象路径名和child路径名字符串创建一个新File实例
File(String pathname)
通过将给定路径名字符串转换为抽象路径名来创建一个新File实例
File(File parent，String child)
根据parent路径名字符串和child路径名字符串

file类获取功能的方法

File f1 = new File("D:Probjectjavawebdemosrcdict.txt");
        //获取此文件的绝对路径字符串
        System.out.println(f1.getAbsolutePath());
        //将此文件转换为路径名字符串
        System.out.println(f1.getPath());
        //获取此文件的名称
        System.out.println(f1.getName());
        //获取此文件的文件长度
        System.out.println(f1.length());
------------------结果------------------

D:Probjectjavawebdemosrcdict.txt
D:Probjectjavawebdemosrcdict.txt
dict.txt
13

file类判断功能的方法

File f1 = new File("D:\Probjectjava\webdemo\src\dict.txt");
        //此文件夹是否存在
        System.out.println(f1.exists());
        //此file是否为目录
        System.out.println(f1.isDirectory());
        //此file是否为文件
        System.out.println(f1.isFile());

------------------结果------------------

true
false
true

file类创建删除功能的方创建文件

File f1 = new File("src\1.txt");
boolean b1 = f1.createNewFile();
System.out.println(b1);

File f1 = new File("D:\Probjectjava\webdemo\src\1.txt");
boolean b1 = f1.createNewFile();
System.out.println(b1);

创建文件夹：
File f1 = new File("src\aaa");
boolean b1 = f1.mkdir();
System.out.println(b1);

创建多级文件夹
File f1 = new File("src\aaa\bbb");
boolean b1 = f1.mkdirs();
System.out.println(b1);

删除文件
File f1 = new File("src\aaa");
boolean b1 = f1.delete();
System.out.println(b1);

 file类遍历目录功能

返回文件名
File f1 = new File("src");
String[] list = f1.list();
        for (String s : list) {
            System.out.println(s);
        }

返回文件路径
 File f1 = new File("src");
File[] files = f1.listFiles();
        for (File s : files) {
            System.out.println(s);
        }

 字节输出流写多个字节的方法

 字节输出流写多个字节的方法
 FileOutputStream fos = new FileOutputStream(new File("src\1.txt"));
 byte[] bytes = {65,66,67,68,69};
 fos.write(bytes);
//释放资源
 fos.close();

字节输出流量写单个字节的方法
 FileOutputStream fos = new FileOutputStream(new File("src\1.txt"));
 fos.write(46);
//释放资源
 fos.close();

字节流输出字符
FileOutputStream fos = new FileOutputStream(new File("src\1.txt"));
byte[] bytes = "你好".getBytes("gbk");
fos.write(bytes);
//释放资源
fos.close();

字节输出流的续写和换行

//续写
FileOutputStream fos = new FileOutputStream("src\1.txt",true);
byte[] bytes = "你好".getBytes("gbk");
fos.write(bytes);
fos.close();

//换行
FileOutputStream fos = new FileOutputStream("src\1.txt",true);
byte[] bytes = "你好".getBytes("gbk");
fos.write(bytes);
fos.write("
".getBytes("gbk"));
fos.close();

 字节输入流读取字节数据

FileInputStream fis = new FileInputStream("src\1.txt");
int len = 0;
//读取到空白内容len = -1
while((len = fis.read())!= -1){
            System.out.println((char)len);
        }
//释放资源
fis.close();

文件的复制

//需要拷贝的文件
FileInputStream fis = new FileInputStream("文件名");

//拷贝完成的文件
FileOutputStream fos = new FileOutputStream("文件名");

//使用数组缓冲读取多个字节，写入多个字节
byte[] bytes = new byte[1024];
int len = 0;
while((len = fis.read())!= -1){
            fos.write(bytes,0,len);
        }
fos.close();
fis.close();

 使用字符输入流读取中文文件

FileReader fr = new FileReader("src\1.txt");
int len = 0;
while((len = fr.read())!= -1){
      System.out.println((char) len);
        }
fr.close();

------------------结果------------------

你
好
啊
a
b
c

文件1.txt文本内容

你好啊abc

FileReader fr = new FileReader("src\1.txt");
int len = 0;
char[] cs = new char[1024];
while((len = fr.read(cs))!= -1){
//把字符数组转化为字符串String(char[] value)
//把字符数组的一部分转化为字符串 offset数组的开始索引 count转化的个数
            System.out.println(new String(cs,0,len));
        }
//关闭资源
fr.close();

字符输出流写单个字符到文件

FileWriter fw = new FileWriter("src\1.txt");
fw.write(97);
//必须刷新或者关闭资源才能写入文件，刷新之后fw可以继续使用，close之后fw不能继续使用
fw.flush();
fw.close();

字符输出流写数据

FileWriter fw = new FileWriter("src\1.txt");
char[] cs = {'a','b','c',};
//写入字符数组
fw.write(cs);
写入字符数组的某一部分
fw.write(cs,1,2);
//关闭资源
fw.close();

 字节输出流的续写和换行

FileWriter fw = new FileWriter("src\1.txt",true);//后面加true续写
for (int i = 0;i < 10;i++){
            fw.write("hello"+"
");
        }
fw.close();

//换行符号
windows：

linux:/n
mac:/r

使用try catch finally处理流中的异常

        //提高fw的作用域
        //变量在定义的时候可以没有值，但是使用的时候必须有值
        FileWriter fw = null;
        try {
            //可能产生异常的代码
            fw = new FileWriter("src\1.txt",true);
            for (int i = 0;i < 10;i++){
                fw.write("hello"+"
");
            }
        }
        catch (IOException e){
            //异常处理逻辑
            System.out.println(e);
        }
        finally {
            //一定会指定的代码
            //创建对象失败，fw默认值就是null,null是不能调用方法的，会抛出nullpointerexception，需要增加一个判断，不是null在把资源释放
            if (fw == null){
                try {
                    //fw。close方法声明抛出ioexceptio异常对象，所以我们就处理这个异常对象，要么throw，要么try catch
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

使用properties集合存储数据，遍历取出properties集合中的数据

//创建properties对象
Properties prop = new Properties();
//使用setproperties添加数据
prop.setProperty("a","165");
prop.setProperty("b","140");
prop.setProperty("c","180");
//使用stringpropertiesnames把properties集合中的键取出，存储到一个set集合中
Set<String> set = prop.stringPropertyNames();

//遍历set集合
for (String key : set) {
     String value = prop.getProperty(key);
     System.out.println(key+value);
}

properties集合中的方法store

//创建properties对象
Properties prop = new Properties();
//使用setproperties添加数据
prop.setProperty("a","165");
prop.setProperty("b","140");
prop.setProperty("c","180");

//创建字节输出流/字符输出流对象，构造方法中绑定要输出的目的地
FileWriter fw = new FileWriter("src\1.txt");

//使用properties集合中的方法sore，把集合的临时数据，持久写入到硬盘中存储
prop.store(fw,"save date");

fw.close();

properties集合中的方法load

//创建properties对象
Properties prop = new Properties();
//使用properties集合对象中的load方法读取保存键值的文件
prop.load(new FileReader("src\1.txt"));
        
//遍历集合
Set<String> set = prop.stringPropertyNames();
for (String key : set) {
    String value = prop.getProperty(key);
    System.out.println(key+"="+value);
}

bufferoutputstrem字节缓冲输出流

//1.创建fileoutputstrem对象，构造方法中绑定输出的的目的地
FileOutputStream fos = new FileOutputStream("src\1.txt");
//2.创建bufferedoutputstrem对象，构造方法中传递fileoutputstrem对象，提高outputstrem对象效率
BufferedOutputStream bos = new BufferedOutputStream(fos);
//3.使用bufferedoutputstrem对象的方法write，把数据写入到内部缓冲区
bos.write("我把数据写入到内部缓冲区".getBytes("gbk"));
//4.使用bufferedoutputstrem对象中的flush方法，把内部缓冲区的数据，刷新到文件中
bos.flush();
//5.释放资源
bos.close();

bufferoutputstrem字节缓冲输入流

//1.创建fileinputstrem对象，构造方法中绑定输出的的目的地
FileInputStream fis = new FileInputStream("src\1.txt");
//2.创建bufferedinputstrem对象，构造方法中传递fileinputstrem对象，提高fileinputstrem对象效率
BufferedInputStream bis = new BufferedInputStream(fis);
//3.记录每次读取的有效字节个数
int len = 0;
//4.从输入流中读取一定数量的字节，并将其存储在缓冲区数组中
byte[] bytes = new byte[1024];
while((len = bis.read(bytes))!=-1){
　　System.out.println(new String(bytes,0,len));
}
//5.释放资源
bis.close();

缓冲流效率测试(复制文件)

效率从低到高
1.一个字节一个字节的读写
2.使用数组缓冲区读写
3.使用缓冲流读写
4.使用缓冲流+数组缓冲区读写

bufferwriter字符缓冲输出流

//1.创建字符缓冲输出流，构造方法中传递字符输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("src\1.txt"));
//2.调用字符缓冲输出流中的方法write，把数据写入到内存缓冲区
for (int i=0;i < 10;i++){
　　bw.write("你好");
　　//换行
　　//bw.write("
");
　　bw.newLine();
}
//3.调用字符换从输出流的方法flush,把内存缓冲区中的数据，刷新到文件中
bw.flush();
//4.释放资源
bw.close();

bufferwriter字符缓冲输入流

//1.创建字符缓冲输入流对象，构造方法中传入字符输入流
BufferedReader br = new BufferedReader(new FileReader("src\1.txt"));
//2.使用字符缓冲输入流对象中的方法read/readline读取文本
String line;
while((line = br.readLine())!=null){
     System.out.println(line);
}
//3.释放资源
br.close();

OutputStreamWriter

//创建OutputStreamWriter对象，构造方法中传递字节输出流和指定的编码名称
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("src\1.txt"),"gbk");
//使用OutputStreamWriter对象中的方法write，把字符串转换为字节存储缓冲区中
osw.write("你好");
//使用OutputStreamWriter的flush方法，把内存缓冲区的字节刷新到新的文件中
osw.flush();
//释放资源
osw.close();

InputStreamWriter

//创建InputStreamReader对象，构造方法中传递字节输入流和编码表名称
InputStreamReader isr = new InputStreamReader(new FileInputStream("src\1.txt"), "UTF-8");
//使用InputStreamReader的对象中的方法read读取文件
int len = 0;
while((len = isr.read())!=-1){
    System.out.println((char) len);
}
//释放资源
isr.close();

对象的序列化流和对象的反序列化流

ObjectInputStream;
ObjectOutputStream