IO框架

字节流

流：内存与存储设备之间传输数据的通道

FileInputStream的使用

abcdefg

文件字节输入流

public class Demo1 {
    public static void main(String[] args) throws Exception{
        //创建FileInputStream，并指定文件路径
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        
        //读取文件
        //1.单个字节
        int data = 0;
        while(data=fis.read()!=-1){
            System.out.println((char)data);
        }
        
        //2.多个字节
        byte[] buf = new byte[3]; //new byte[1024]
        int count = fis.read(buf); 
		System.out.println(new String(buf)); //abc
        System.out.println(count);//3
        
        int count2 = fis.read(buf); 
		System.out.println(new String(buf)); //def
        System.out.println(count2);//3
        
        int count3 = fis.read(buf); 
		System.out.println(new String(buf,0,count3)); //g
        System.out.println(count2);//1
        
        //关闭
        fis.close();
        System.out.println("执行完毕");
        
    }
}

FileOutputStream的使用

文件字节输出流

public class Demo2 {
    public static void main(String[] args) throws Exception{
        //1.创建文件字节输出流对象
        FileOutputStream fos = new FileOutputStream("d:\\bbb.txt"); //覆盖
        //new FileOutputStream("d:\\bbb.txt",true); //追加
        
        //2.写入文件
        fos.write(97); //a
        fos.write('b'); //b
        fos.write('c'); //c
        
        String string = "helloworld";
        fos.write(string.getBytes());
        
        //3.关闭
        fos.close();
        System.out.println("执行完毕");
    }
}

字节流复制文件

使用文件字节流实现文件的复制

public class Demo3 {
    public static void main(String[] args) throws Exception {
        FileInputStream fis = new FileInputStream("d:\\001.jpg");
        FileOutputStream fos = new FileOutputStream("d:\\002.jpg");
        
        //一边读 一边写
        byte[] buf = new byte[1024];
        int count = 0;
        while((count = fis.read(buf))!=-1){
            fos.write(buf,0,count);
        }
        
        fis.close();
        fos.close();
        System.out.println("复制完毕");
        
    }
}

字节缓冲流

• 提高IO效率，减少访问磁盘的次数;
• 数据存储在缓冲区，flush是将缓冲区的内容写入文件中，也可以直接close

BufferedInputStream的使用

public class Demo4 {
    public static void main(String[] args) throws Exception{
        //1.创建
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        
        //读取
        int date = 0;
        while((data=bis.read())!=-1) { //一次性读了8k
            System.out.println((char)data);
        }
        
        //自己创建缓冲区
        byte[] buf = new byte[1024];
        int count = 0;
        while((count=bis.read(buf))!=-1) {
            System.out.println(new String(buf,0,count));
        }
        
        //
        bis.close();
        
    }
}

BufferedOutputStream的使用

使用字节缓冲流写入文件

public class Demo5 {
    public static void main(String[] args) throws Exception{
        
        //读取
        FileOutputStream fos = new FileOutputStream("d:\\buffer.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        
        //写入文件
        for(int i=0;i<10;i++) {
            bos.write("helloworld\r\n".getBytes()); //写入缓冲区
            bos.flush();//刷新到硬盘
        }
        
        //关闭(内部调用flush方法)
        bos.close();
    }
}

对象流

public class Student implements Serializable {//标记接口
    //序列化版本号ID
    private static final long serialVersionUID = 100L;
    
    private String name;
    private int age;
    public Student() {
        
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName(){
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    @Override
    public String toString() {
    	return "Student [name=" +name + ", age=" + age + "]"    
    }
    
}

序列化

public class Demo6{
    public static void main(String[] args) throws Exception{
        //创建对象流
    FileOutputStream fos = new FileOutputStream("d:\\stu.bin");
    ObjectOutputStream oos = new ObjectOutputStream(fos);
    
    //序列化（写入操作）
    Student zhangsan = new Student("张三",20);
    oos.writeObject(zhangsan);
    
    //关闭
    oos.close();
    System.out.println("序列化完毕");
    }
    
}

反序列化

public class Demo7 {
    public static void main(String[] args) throws Exception{
        //创建对象流
        FileInputStream fis = new FileInputStream("d:\\stu.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        
        //读取文件(反序列化)
        Student  s = (Student)ois.readObject();
        
        //关闭
        ois.close();
        System.out.println("执行完毕");
        System.out.println(s.toString());
        
    }
}

注意事项

1. 序列化类必须要实现Serializable接口
2. 序列化类中对象属性要求实现Serializable接口
3. 序列化版本号ID，保证序列化的类和反序列化的类是同一个类
4. 使用transient（瞬间的）修饰属性，这个属性不能序列化
5. 静态属性也不能序列化
6. 如果想序列化多个对象

//序列化
ArrayList<Student> list = new ArrayList<>();
list.add(zhangsan);
list.add(lisi);
oos.writeObject(list);

//反序列化
ArrayList<Student> list = ois.readObject();
ois.close();
System.out.println(list.toString());

字符编码

• ISO-8859-1 一个字节
• UTF-8 一个两个或三个字节
• GB2312 简体中文 一个或两个字节
• GBK 简体中文扩充 一个或两个字节
• BIG5 繁体中文

字符流

FileReader使用

public class Demo2 {
    public static void main(String[] args) throws Exception{
        //1.创建FileReader 文件字符输入流
        FileReader fr = new FileReader("d:\\hello.txt");
        
        //读取
        int data = 0;
        while((data=fr.read())!=-1) { //读取一个字符
            System.out.print((char)data);
        }
        
        //缓冲区读取
        char[] buf = new char[1024];
        int count = 0;
        while((count=fr.read(buf))!=-1) {
            System.out.println(new String(buf,0,count));
        }
        
        //关闭
        fr.close();
        
    }
}

FileWriter使用

public class Demo3 {
    public static void main(String[] args) throws Exception{
        //创建FileWriter对象
        FileWriter fw = new FileWriter("d:\\write.txt");
        
        //写入
        for(int i=0; i<10; i++) {
            fw.write("java是世界上最好的语言\r\n");
            fw.flush();
        }
        
        //关闭
        fw.close();
        System.out.println("执行完毕");
    }
}

字符流复制文件

复制文本文件，不能复制图片或二进制文件

public class Demo4 {
    public static void main(String[] args) throws Exception{
        FileReader fr = new FileReader("d:\\write.txt");
        FileWriter fw = new FileWriter("d:\\write2.txt");
        
        //读写
        int data = 0;
        while((date=fr.read())!=-1) {
            fw.write(data);
            fw.flsuh();
        }
        
        fr.close();
        fw.close();
        System.out.println("复制完毕");
    }
}

字符流不能复制图片的原因

图片没有字符编码，可能会出现乱码

使用字节流可以复制任意文件

字符缓冲流

• 高效读写
• 支持输入换行符
• 可一次写一行、读一行

newLine() 写入一个行分隔符

BufferedReader使用

public class Demo5 {
    public static void main(String[] args) throws Exception{
        FileReader fr = new FileReader("d:\\write.txt");
        BufferedReader br = new BufferedReade(fr);
        
        //2.1读取(自己创建缓冲区)
        char[] buf = new char[1024];
        int count = 0;
        while((count=br.read())!=-1) {
            System.out.println(new String(buf,0,count));
        }
        
        //2.2一行一行的读取
        String line = null;
        while((line=br.readLine())!=null) {
            System.out.println(line);
        }
        
        
        br.close();
        
    }
}

BufferedWriter使用

public class Demo6 {
    public static void main(String[] args) throws Exception{
        FileWriter fw = new FileWriter("d:\\buffer.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        
        for(int i=0; i<10; i++){
            bw.write("好好学习，天天向上");
            bw.newLine(); //写入一个换行符\r\n
            bw.flush();
        }
        
        bw.close();
    }
}

打印流PrintWriter

public class Demo7 {
    public static void main(String[] args) throws Exception{
        PrintWriter pw = new PrintWriter("d:\\print.txt");
        
        //打印
        pw.println(97); //97
        pw.println(true); //true
        pw.println(3.14); //3.14
        pw.println('a'); //a
        
        pw.close();
    }
}

转换流

• 可将字节流转换为字符流
• 可设置字符的编码方式

InputStreamReader的使用

public class Demo1 {
    public static void main(String[] args) throws Exception{
        FileInputStream fis = new FileInputStream("d:\\write.txt");
        InputStreamReader isr = new InputStreamReader(fis, "utf-8");
        
        int date = 0;
        while((data=isr.read())!=-1) {
            System.out.println((char)data);
        }
        
        isr.close();
    } 
}

OutputStreamWriter的使用

public class Demo2 {
    public static void main(String[] args) throws Exception{
        FileOutputStream fos = new FileOutputStream("d:\\info.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
        
        for(int i=0;i<10;i++) {
            osw.write("我爱北京，我爱故乡\r\n");
            osw.flush();
        }
        
        osw.close();
    }
}

File类

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

File类的使用

public class Demo1 {
    public static void main(String[] args) throws Exception{
        separator();
        fileOpe();
        directoryOpe();
    }
    //分割符
    public static void separator() {
        System.out.println("路径分隔符"+File.pathSeparator);
        System.out.println("名称分隔符"+File.separatorChar);
    }
    
    //文件操作
    public static void fileOpe() throws Exception{
        //1.创建文件
        File file = new File("d:\\file.txt");
        if(!file.exist()) {
            boolean b = file.createNewFile();
            System.out.println("创建结果"+b); 
        }
        	
        //2.删除文件
        //2.1直接删除
       System.out.println("删除结果"+file.delete()); 
        
        //2.2使用jvm退出时删除
        file.deleteOnExit();
        Thread.sleep(500);
        
        //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()).toLocaleString());
        
        //4.判断
        System.out.println("是否可写: ",file.canWrite());
        System.out.println("是否是文件: ",file.isFile());
        System.out.println("是否隐藏: ",file.isHidden());
    }
    
    public static void directoryOpe() {
        //1.创建文件夹
        File dir = new File("d:\\aaa\\bbb\\ccc");
        if(!dir.exist()) {
            //dir.mkdir(); //只能创建单级目录
            boolean b = dir.mkdirs(); //创建多级目录
            System.out.println("创建结果"+b); 
        }
        
        //2.删除文件夹
        //2.1直接删除
        System.out.println("删除结果"+dir.delete()); //只删除最底层的，而且只能删除空目录
        
        //2.2使用jvm删除
        dir.deleteOnExit();
        Thread.sleep(500);
        
        //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 dir2 = new File("d:\\图片");
        String[] files = dir2.list();
        for (String string : files) {
            System.out.println(string);
        }
        
    }
    
}

FileFilter接口

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

//接上面代码
File[] files2 = dir2.listFiles(new FileFilter(){
    
    @Override
    public boolean accept(File pathname) {
        if(pathname.getName().endsWith(".jpg")) {
            return true;
        }
        return false;
    }
}); //匿名内部类实现接口
for (File file : files2) {
    System.out.println(file.getName());
}

递归遍历和递归删除

public class ListDemo {
	public static void main(String[] args) {
        listDir(new File("d:\\myfiles"));
        deleteDir(new File("d:\\myfiles"));
    }
    //递归遍历
    public static void listDir(File dir) {
        File[] files = dir.listFiles();
        System.out.println(dir.getAbsolutePath()); 
        if(files!=null&&files.length>0){
            for(File file : files) {
                if(file.isDirectory()) {
                    listDir(file);
                }else {
                    System.out.println(file.getAbsolutePath()); 
                }
            }
        }
    }
    
    //递归删除
    public static void deleteDir(File dir) {
        File[] files = dir.listFiles();
        if(files!=null&&files.length>0){
            for(File file : files) {
                if(file.isDirectory()) {
                    deleteDir(file);
                }else {
                    System.out.println(file.getAbsolutePath()+"删除: "+file.delete()); 
                }
            }
        }
        System.out.println(file.getAbsolutePath()+"删除: "+dir.delete());
    }
}

Properties

属性集合 继承hashtable

特点：

• 存储属性名和属性值
• 属性名和属性值都是字符串类型
• 没有泛型
• 和流有关

public class Demo2 {
    public static void main(String[] args) throws Exception{
        Properties properties = new Properties();
    	properties.setProperty("username","zhangsan");
    	properties.setProperty("age","20");
    	System.out.println(properties.toString());
    	//遍历 keySet entrySet stringPropertyNames
    	Set<String> pronames = properties.stringPropertyNames();
    	for (String pro : pronames) {
        	System.out.println(pro+"===="+properties.getProperty(pro));
    	}
    
    	//和流有关方法
    	PrintWriter pw = new PrintWriter("d:\\print.txt");
    	properties.list(pw);
        pw.close();
        
        //store保存
        FileOutputStream fos = new FileOutputStream("d:\\store.properties");
        properties.store(fos,"注释");
        fos.close();
        
        //load加载
        Properties properties2 = new Properties();
        FileInputStream fis = new FileInputStream("d:\\store.properties");
        properties2.load(fis);
        fis.close();
        System.out.println(properties2.toString());
        
    }
    
}