io流

IO框架

什么是流

流的分类

文件字节流

文件字节输入流

package com.ljh.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * 演示FileInputStream的使用
 * 文件字节输入流
 */
public class Demo1 {
    public static void main(String[] args) throws IOException {
        //1.创建FileInputStream
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        //2读取文件
//        fis.read();
//        System.out.println(fis.read());
//        //单个字节读取
//        int data = 0;
//        while ((data = fis.read())!=-1){
//            System.out.println((char)data);
//        }
        //2.2一次读取多个字节
        byte[] buf = new byte[3];
        int count = 0;
        while ((count=fis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));

        }
        //3.关闭
        fis.close();
        System.out.println("执行完毕");


    }
}

文件字节输出流

package com.ljh.io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 演示文件字节输出流的使用
 */
public class Demo2 {
    public static void main(String[] args) throws IOException {
        //1.创建文件字节输出流对象
        FileOutputStream fos = new FileOutputStream("d:\\bbb.txt");
        //2.写入文件
//        fos.write(97);
//        fos.write('b');
//        fos.write('c');
        String string = "helloworld";
        fos.write(string.getBytes());
        //3.关闭
        fos.close();
    }

}

文件字节流复制

package com.ljh.io;

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

public class Demo3 {
    public static void main(String[] args) throws IOException {
        //1.创建流
        //1.1文件字节输入流
        FileInputStream fis = new FileInputStream("d:\\000.jfif");
        //1.2文件字节输出流
        FileOutputStream fos = new FileOutputStream("d:\\111.jfif");
        //2,一边读，一边写
        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("执行完毕");

    }
}

字节缓冲流

package com.ljh.io;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * 使用字节缓冲流读取
 *
 */
public class Demo4 {
    public static void main(String[] args) throws IOException {

        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
//        //2读取
//        int data = 0;
//        while((data=bis.read())!=-1){
//            System.out.println((char)data);
//        }

        byte[] buf = new byte[1024];
        int cout = 0;
        while ((cout=bis.read(buf))!=-1){
            System.out.println(new String(buf,0,cout));
        }
    }
}

package com.ljh.io;

import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 使用字节缓冲流写入文件
 */
public class Demo5 {
    public static void main(String[] args) throws IOException {
        //1.创建流对象
        FileOutputStream fos = new FileOutputStream("d:\\buffer.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //2.写入文件
        for (int i = 0; i < 10; i++) {
            bos.write("helloworld".getBytes());
            bos.flush();//刷新都硬盘

        }
        //3.关闭（内部调用flush方法）
        bos.close();
    }

}

对象流

序列化

package com.ljh.io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

/**
 * 使用ObjectOutputStream实现对象的序列化
 * 要求，序列化类必须要实现Serializable接口
 * 注意事项：
 * （1）序列化类必须要实现Serializable接口
 * （2）序列化类中对象属性要求实现Serializable接口
 * （3）序列化版本号ID，保证序列化的类和反序列化的类是同一个类
 * （4）使用transient(瞬间的)修饰属性，这个属性不能序列化
 * （5）静态属性不能序列化
 * （6）序列化多个对象
 */
public class Demo6 {
    public static void main(String[] args) throws IOException {
        //1。创建对象流
        FileOutputStream fos = new FileOutputStream("d:\\stu.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //2.序列化（写入操作）
//        Student student = new Student("张三", 20);
//        oos.writeObject(student);
         Student student = new Student("张三", 20);
         Student student2 = new Student("李四", 20);
        ArrayList<Student> list = new ArrayList<>();
        list.add(student);
        list.add(student2);
        oos.writeObject(list);
        //3.关闭
        oos.close();
        System.out.println("序列化");
    }
}

反序列化

package com.ljh.io;

import java.io.*;
import java.util.ArrayList;

/**
 * 使用ObjectInputStream实现反序列化（读取重构成对象）
 */
public class Demo7 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1.创建对象流
        FileInputStream fis = new FileInputStream("d:\\stu.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        //2.读取文件（反序列化）
//        Student s = (Student)ois.readObject();
//        Student s2 = (Student)ois.readObject();
        ArrayList<Student> s = (ArrayList<Student>)ois.readObject();
        //3.关闭
        ois.close();
        System.out.println("执行完毕");
        System.out.println(s.toString());
    }
}

字符编码

字符流

文件字符流

package com.ljh.io;

import java.io.FileReader;

/**
 * 使用
 */
public class Demo9 {
    public static void main(String[] args) throws Exception{
        //1.创建FileReader文件字符输入流
        FileReader fr = new FileReader("d:\\hello.txt");
        //2.读取
        //2.1单个字符读取
        int data = 0;
        while ((data=fr.read())!=-1){//读取一个字符
            System.out.println((char)data);
        }

        char[] buf = new char[1024];
        int count = 0;
        while ((count=fr.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //3.关闭
        fr.close();
    }
}

package com.ljh.io;

import java.io.FileWriter;
import java.io.IOException;

public class Demo10 {
    public static void main(String[] args) throws Exception {
        //1.创建FileWriter对象
        FileWriter fw = new FileWriter("d:\\write.txt");
        for (int i = 0; i < 10; i++) {
            fw.write("java是世界上最好的语言");
            fw.flush();

        }
        //3.关闭
        fw.close();
    }
}

文件字符流复制文件

package com.ljh.io;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;

/**
 * 使用FileReader和FileWriter复制文本文件，不能复制图片或二进制文件
 */
public class Demo11 {
    public static void main(String[] args) throws Exception {
        //1.创建FileReader FileWriter
        FileReader fr = new FileReader("d:\\write.txt");
        FileWriter fw = new FileWriter("d:\\cc.txt");
        //2读写
        int data = 0;
        while ((data=fr.read())!=-1){
            fw.write(data);
            fw.flush();
        }
        fr.close();
        fw.close();
    }
}

字符缓冲流

package com.ljh.io;

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

/**
 * 字符缓冲流读取文件
 * BufferReader
 */
public class Demo12 {
    public static void main(String[] args) throws Exception {
        //创建缓冲流
        FileReader fr = new FileReader("d:\\write.txt");
        BufferedReader bfr = new BufferedReader(fr);
//        char[] buf = new char[];
//        int count = 0;
//        while ((count=bfr.read())!=-1){
//            System.out.println(new String(buf,0,count));
//        }
//
        //2.第二种方式，一行一行的读取
        String line = null;
        while ((line=bfr.readLine())!=null){
            System.out.println(line);
        }
        bfr.close();
    }
}

package com.ljh.io;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class Demo13 {
    public static void main(String[] args) throws Exception {
        //1创建BufferWriter
        FileWriter fw = new FileWriter("d:\\buffer.txt");
        BufferedWriter bfw = new BufferedWriter(fw);
        //2.写入
        for (int i = 0; i < 10; i++) {
            bfw.write("好汉");
            bfw.newLine();//换行
            bfw.flush();
        }
        bfw.close();
    }
}

打印流

package com.ljh.io;

import java.io.FileNotFoundException;
import java.io.PrintWriter;

/**
 * PrintWriter的使用
 */
public class Demo14 {
    public static void main(String[] args) throws Exception {
        //1.创建打印流
        PrintWriter pw = new PrintWriter("d:\\print.txt");
        //2.打印
        pw.println(97);
        pw.println(true);
        pw.println(3.14);
        pw.println('a');

        //3.关闭
        pw.close();
        System.out.println("执行完毕");

    }
}

转换流

package com.ljh.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;

/**
 * 使用InoutStreamReader读取文件，指定使用的编码
 */
public class Demo15 {
    public static void main(String[] args) throws Exception {

        //1.创建InputStreamReader对象
        FileInputStream fis = new FileInputStream("d:\\write.txt");
        InputStreamReader isr = new InputStreamReader(fis,"gbk");
        //2.读取文件
        int data = 0;
        while ((data=isr.read())!=-1){
            System.out.println((char)data);
        }
        isr.close();
    }
}

package com.ljh.io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

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

        }
        //关闭流
        osw.close();
    }
}

File类

FileFilter接口

package com.ljh.io;

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

/**
 * File类的使用
 * 1.分隔符
 * 2.文件操作
 * 3.文件夹操作
 */
public class Demo17 {
    public static void main(String[] args) throws IOException, InterruptedException {
//        separator();
        fileOpe();
    }
    //1.分隔符
    public static void separator(){
        System.out.println("路径分隔符"+ File.pathSeparator);
        System.out.println("名称分隔符"+File.separator);
    }
    //2.文件操作
    public static void fileOpe() throws IOException, InterruptedException {
        //1.创建文件
        File file = new File("d:\\file.txt");
        if(file.exists()){
            boolean b = file.createNewFile();
            System.out.println("创建结果："+b);

        }
        //2.删除文件
        //2.1直接删除
        System.out.println("删除结果："+file.delete());
        //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()).toLocaleString());

        //4.判断
        System.out.println("是否可写："+file.canWrite());
        System.out.println("是否可读："+file.canRead());
        System.out.println("是否文件："+file.isFile());
        System.out.println("是否隐藏："+file.isHidden());
    }

    //3.文件夹操作
    public static void directoryOpe() throws InterruptedException {
        //1.创建文件夹
        File dir = new File("d:\\aaa\\bbb\\ccc");
        System.out.println(dir.toString());
        if(dir.exists()){
            dir.mkdir();//只能创建单级目录
            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 dir2 = new File("d:\\aaa");
        String[] files = dir2.list();
        for (String string : files) {
            System.out.println(string);

        }
        System.out.println("--------------------");
        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());
        }


    }


}

递归遍历和递归删除

package com.ljh.io;

import java.io.File;

/**
 * 递归遍历文件夹
 */
public class Demo18 {
    public static void main(String[] args) {
        listDir(new File("d:\\aaa"));
        deleteDir(new File("d:\\aaa"));
    }
    //遍历文件夹
    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();
        System.out.println(dir.getAbsolutePath());
        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(dir.getAbsolutePath()+"删除"+dir.delete());
        }
    }

}

Properties

package com.ljh.io;

import java.io.*;
import java.util.Properties;
import java.util.Set;

public class Demo19 {
    public static void main(String[] args) throws IOException {
        //1.创建集合
        Properties properties = new Properties();
        //2.添加数据
        properties.setProperty("username","zhangsan");
        properties.setProperty("age","20");
        System.out.println(properties.toString());
        //3.遍历
        //3.1--keySet
        //3.1--entrySet
        //3.1--stringPropertyNames()
        Set<String> pronames = properties.stringPropertyNames();
        for (String proname : pronames) {
            System.out.println(proname+"======="+properties.getProperty(proname));

        }
        //4.和流有关的方法
        //------list方法-------
        PrintWriter pw = new PrintWriter("d:\\print.txt");
        properties.list(pw);
        pw.close();
        //--------2.store方法--------
        FileOutputStream fos = new FileOutputStream("d:\\store.priperties");
        properties.store(fos,"注释");
        fos.close();
        //3------load方法加载------
        Properties properties1 = new Properties();
        FileInputStream fis = new FileInputStream("d:\\store.priperties");
        properties.load(fis);
        fos.close();
        System.out.println(properties1.toString());
    }
}