本文主要是介绍学习Java中IO流，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

目录

 1.File 类

File 类基本功能

2.IO流

IO 的分类

 字节流——输出

字节流 try-catch-finally 捕获异常

 字节流——输入

缓冲流

字符流-编码表

字符流-写出数据

字符流-读取数据

缓冲流

转换流 

对象操作流

Properties

Properties-load、store

 1.File 类

在读取的时候告诉虚拟机要操作的（文件/文件夹）在哪
对（文件/文件夹）本身进行操作。包括创建，删除等。

FIle 类概述和构造方法
File ：他是文件和目录路径的抽象表示
        文件和目录可以通过File 封装成对象
        File 封装的对象仅仅是一个路径名。它可以是存在的，也可以是不存在的。

File 类基本功能

public class Main {
    public static void main(String[] args) throws IOException {
        File f1 = new File("src/demo2/a.txt");
        File f2 = new File("src/demo2/b.txt");
        //创建文件
        System.out.println(f1.createNewFile());
        System.out.println(f2.createNewFile());
    }
}

执行结果：

小结：
        如果路径文件存在，则返回false，不创建文件
        如果路径文件不存在，则返回true，创建文件（只能创建文件）

public class Main {
    public static void main(String[] args) throws IOException {
        File f1 = new File("src/demo2/aaa/bbb/ccc.txt");
        //创建多级目录
        System.out.println(f1.mkdirs());
    }
}

执行结果：

 小结：
        如果路径存在，则返回false，不创建文件夹
        如果路径不存在，则返回true，创建文件夹（只能创建文件夹）

public class Main {
    public static void main(String[] args) throws IOException {
        File f1 = new File("src/demo2/aaa/bbb/ccc.txt/a.txt");
        //删除文件或者目录
        System.out.println(f1.delete());
    }
}

执行结果： 

小结：
        1.不走回收站的 （删除后无法简单复原）
        2.只能删除存在的 文件和空文件夹

public class Main {
    public static void main(String[] args) throws IOException {
        File f1 = new File("src/demo2/aaa");
        File f2 = new File("src/demo2/aaa/a.txt");
        //判断File是否为目录
        System.out.println(f1.isDirectory());
        //判断File是否为文件
        System.out.println(f2.isFile());
        //判断File是否存在
        System.out.println(f2.exists());
        //获得File绝对路径
        System.out.println(f1.getAbsolutePath());
        //获得文件名或者文件夹名
        System.out.println(f2.getName());
        //获得最后一次修改时间
        Date date = new Date(f2.lastModified());
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年 HH:mm:ss");
        String result = sdf.format(date);
        System.out.println(result);
    }
}

执行结果：

public class Main {
    public static void main(String[] args) throws IOException {
        File f = new File("C:/");
        //返回路径中的所有文件和文件夹
        for (File file : f.listFiles()) {
            System.out.println(file);
        }
    }
}

执行结果：

2.IO流

IO 的概述                （流的体系，流的构造，流的操作步骤）
        I  ：in      输入
       O ：out    输出

IO 的数据传输，可以看做一种数据的流向，按照流动得方向，需要以“内存”为参照物，进行读写操作
        说明：
                内存（Java 程序） ——>  硬盘（文件）        ： 输出（写数据）
                硬盘（文件）——>   内存（Java 程序）        ： 输入（读数据）

IO 的分类

 字节流——输出

步骤：
        1.创建字节流对象        （如果不存在就创建，根据构造参数是否清空）
        2.写数据                      
        3.释放资源                   （注意使用完释放资源）

构造方法：
        FileOutputStream（String name，boolean append）
        创建一个向具有指定name的文件种写入数据的输出文件流 

写数据的方法分类

public class Main {
    public static void main(String[] args) throws IOException {
        //目录不存在就会报错，文件不存在会自动创建
        File f = new File("src/a.txt");
        FileOutputStream fos = new FileOutputStream(f,true);
        int b1 = 95;
        byte[] b2 = {98,99,100};
        fos.write(b1);

        fos.write("\r\n".getBytes());
        fos.write("起飞".getBytes());

        fos.write(b2);

        fos.write(System.lineSeparator().getBytes());

        fos.write(b2,0,2);
        fos.close();
    }
}

执行结果：
  

字节流 try-catch-finally 捕获异常

格式：
        try{
            可能出现异常的代码;    
        } catch (异常类名 变量名){
            异常的处理代码;
        } finally {
            执行所有清除操作;
        }

finally 特点：
        被finally控制的语句一定会执行，除非JVM退出

public class Main {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            //目录不存在就会报错，文件不存在会自动创建
            File f = new File("src/a.txt");
            fos = new FileOutputStream(f,true);
            byte[] b2 = {98,99,100};
            fos.write(b2);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 字节流——输入

步骤：
        1.创建字节输入流对象        （一定要存在）
        2.读取一个字节
        3.关闭流

构造方法：
        FileInputStream（String name）

public class Main {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("D:/a.txt");
        FileOutputStream fos = new FileOutputStream("D:/b.txt");
        //输出char
        int read1;
        while ((read1 = fis.read()) != -1){
            System.out.print((char)read1);
        }
        //输出String
        byte[] b = new byte[1024];
        int read2;
        while ((read2 = fis.read(b)) != -1){
            System.out.print(new String(b));
        }
        //写入文件
        int read3;
        while ((read3 = fis.read()) != -1){
            fos.write(read3);
        }
        fis.close();
        fos.close();
    }
}

执行结果：

缓冲流

字节缓冲流
        BufferedOutputStream：字节缓冲输出流
        BufferedInputStream：字节缓冲输入流

构造方法        (默认缓冲区大小：8192 byte)
        字节缓冲输出流：BufferedOutputStream（OutputStream out）
        字节缓冲输入流：BufferedInputStream（InputStream in）

为什么构造方法需要的是字节流，而不是具体的文件或者路径呢？
        字节缓冲流仅仅提供缓冲区，而真正的读写数据还得依靠基本的字节流对象经行操作

public class Main {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("src/ASCII.jpg");
        BufferedInputStream bis = new BufferedInputStream(fis);
        FileOutputStream fos = new FileOutputStream("src/cpASCII2.jpg");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        byte[] b = new byte[1024];
        int len;
        while ((len = fis.read(b)) != -1){
            fos.write(b,0,len);
        }
        bis.close();
        bos.close();
    }
}

执行结果：

字节流：
        可以操作（拷贝）所有类型的文件
字节缓冲流：
        可以提高效率
        不能直接操作文件，需要传递字节流

拷贝文件的四种方式：
        字节流一次读写一个字节
        字节流一次读写一个字节数组
        字节缓冲流一次操作一个字节
        字节缓冲流一次操作一个字节数组

字符流-编码表

编码：字符转成编号
解码：把编号转成字符
编码表：字符和编号之间的对应关系表
字符集：字符的集合,字符集会对应一个编码表

常见编码表有哪些?
ASCII：现代英语,美国
GB2312：简体中文,7000字符
gbk：2万多字符,兼容GB2312
gb18030：中文最全的码表,包含少数民族文字
iso-8859-1：欧洲编码 ,拉丁字母
unicode码表：万国码,全世界主要国家语言的文字字符.
    utf-8：变长 英文一个,其他2个,中文3个,最多4个字节
    utf-16：固定长度,2个字节,4个字节
    utf-32：固定4个字节

编码：
        byte[] getBytes()：使用平台默认字符集将该String 编码为一系列字节，存在数组种
        byte[] getBytes(String charseName)：使用上方指定字符集将该String 编码

解码：
        String(byte[] bytes)：通过默认字符集解码 指定字节数组来构造新的String
        String(byte[] bytes，String charsetName)：通过指定字符集解码

public class Main {
    public static void main(String[] args) throws IOException {
        byte[] b1 = "我真帅".getBytes();
        System.out.println(Arrays.toString(b1));

        byte[] b2 = "我真帅".getBytes("GBK");
        System.out.println(Arrays.toString(b2));

        String s1 = new String(b1);
        System.out.println(s1);

        String s2 = new String(b2,"GBK");
        System.out.println(s2);

        String s3= new String(b2,"UTF-8");
        System.out.println(s3);
    }
}

执行结果：

字符流-写出数据

步骤：
        创建字符输出流对象
                如果文件不存在，就创建，但要保证父级路径存在。
                如果文件存在，更具参数是否清空。

        写数据
                写出的int 类型的数据，实际上写出的是整数在码表上对应的字母。
                写出字符串数据，是把字符串本身原样写出。

        释放资源

介绍:        （底层：字节流 + 编码表）
        Writer: 用于写入字符流的抽象父类
        FileWriter: 用于写入字符流的常用子类

构造方法

成员方法

public class Main {
    public static void main(String[] args) throws IOException {
        File f = new File("src/a.txt");
        FileWriter fw = new FileWriter(f,true);

        int n1 = 97;
        fw.write(n1);

        char[] n2 = {'\r','a','b','c','d'};
        fw.write(n2);

        fw.write(n2,0,4);

        String s = "\r中国乒乓nb";
        fw.write(s);

        fw.write(s,0,5);
        fw.close();
    }
}

执行结果：

字符流-读取数据

构造方法

成员方法

public class Main {
    public static void main(String[] args) throws IOException {
        File f = new File("src/a.txt");
        FileReader fr = new FileReader(f);

        int len;
        while ((len = fr.read()) != -1){
            System.out.print((char)len);
        }

        char[] chars = new char[1024];
        int len2;
        while ((len2 = fr.read(chars)) != -1){
            System.out.print(new String(chars,0,len2));
        }
        fr.close();
    }
}

执行代码：

缓冲流

        BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途

        BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小。 默认值足够大，可用于大多数用途

构造方法

特有成员方法

public class Main {
    public static void main(String[] args) throws IOException {
        File f = new File("src/a.txt");
        BufferedWriter bw = new BufferedWriter(new FileWriter(f));
        bw.write("你女朋友真漂亮");
        bw.newLine();
        bw.write("才怪，你根本就没有女朋友");
        bw.close();

        BufferedReader br = new BufferedReader(new FileReader(f));
        String line;
        while ((line = br.readLine()) != null){
            System.out.println(line);
        }
        br.close();
    }
}

执行结果：

转换流 

        InputStreamReader：是从字节流到字符流的桥梁,父类是Reader 它读取字节，并使用指定的编码将其解码为字符它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集

        OutputStreamWriter：是从字符流到字节流的桥梁,父类是Writer 使用指定的编码将写入的字符编码为字节它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集

构造方法        (JKD 11 之前才需要)

public class Main {
    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream("D:/a.txt"),"utf-8");
        char[] chars = new char[1024];
        ArrayList<String> al = new ArrayList<>();
        int len;
        while ((len = isr.read(chars)) != -1){
            al.add(new String(chars));
        }
        isr.close();

        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:/a.txt"),"gbk");
        for (String s : al) {
            osw.write(s);
        }
        osw.close();
    }
}

对象操作流

对象序列化：
        将对象转成字节序列 (保存在磁盘中,或通过网络传输)
         ObjectOutputStream(OutputStream)
对象反序列化： 
        读取字节序列,返回一个对象(字节序列可以来自于文件,也可以来自于网络)

序列化的步骤
    1.创建 ObjectOutputStream(OutputStream)
    2.创建对象(学生对象)
    3.writeObject(stu);
    4.关闭流

注意:
    1.被序列化的对象所在的类必须实现 Serializable
    2.如果某个成员变量不想被序列化，可以使用 transient 关键字修饰

构造方法以及序列化方法

public class Main {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        User user = new User("zhangsan","fawaikuangtu");
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("src/a.txt"));
        oos.writeObject(user);
        oos.close();

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("src/a.txt"));
        User us = (User) ois.readObject();
        System.out.println(us);
    }
}

执行结果：

Properties

概述：
        是一个Map体系的集合类
        Properties可以保存到流中或从流中加载
        属性列表中的每个键及其对应的值都是一个字符串

特有方法

public class Main {
    public static void main(String[] args) {
        Properties prop = new Properties();
        prop.setProperty("小龙女", "杨过");
        System.out.println(prop);

        String value = prop.getProperty("小龙女");
        System.out.println(value);

        Set<String> strings = prop.stringPropertyNames();
        for (String string : strings) {
            String value2 = prop.getProperty(string);
            System.out.println(string + " " + value2);
        }
    }
}

执行结果：

Properties-load、store

和IO流结合的方法

public class Main {
    public static void main(String[] args) throws IOException {
        Properties prop = new Properties();
        prop.put("wo","n");
        prop.put("hao","0");
        prop.put("shuai","1");
        FileWriter fw = new FileWriter("src/demo1/prop.properties");
        prop.store(fw,"我是注释");
        fw.close();

        Properties prop2 = new Properties();
        FileReader fr = new FileReader("src/demo1/prop.properties");
        prop2.load(fr);
        fr.close();
        System.out.println(prop2);
    }
}

执行结果：

这篇关于学习Java中IO流的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！