性能更好的IO

giao_bro

已于 2022-10-14 17:18:48 修改

阅读量5.1k

点赞数 2

分类专栏： java基础文章标签： java

于 2022-10-05 17:11:20 首次发布

本文链接：https://blog.csdn.net/giao_bro/article/details/127173563

版权

java基础专栏收录该内容

24 篇文章 0 订阅

订阅专栏

前面介绍的都是原始IO,现在介绍性能更好的

1.字节缓冲流

2.字符缓冲流

输入流

多一个readLine()

public static void main(String[] args) {
        try(
            Reader fr=new FileReader("file-io-app2\\src\\heikun3");
            BufferedReader br=new BufferedReader(fr);
            ){
            //和Reader一样的，这不介绍
            //特有的，读一整行readLine();
            String Line;
            while((Line=br.readLine())!=null){
                System.out.println(Line);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

输出流

多一个newLine(),其实就是换行

样例

将文件out_heikun的文件里每行按第一个字排序，并输出到aiyouwei文件中

public static void main(String[] args) {
        try(
                BufferedReader br=new BufferedReader(new FileReader("file-io-                                    app2\\src\\out_heikun"));
                BufferedWriter bw=new BufferedWriter(new FileWriter("file-io-app2\\src\\aiyouwei"));
            ){
            List<String> data =new ArrayList<>();
            String line;
            while((line=br.readLine())!=null){
                data.add(line);
            }
            List<String> indexs=new ArrayList<>();
            Collections.addAll(indexs,"一","二","三","四");
            Collections.sort(data, new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                    return indexs.indexOf(o1.substring(0,o1.indexOf(".")))
                            -indexs.indexOf(o2.substring(0,o2.indexOf(".")));
                }
            });
            for(String newline:data){
                bw.write(newline);
                bw.newLine();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

输出结果

3.字符转化流

使用方法样例

public static void main(String[] args)throws Exception{
        InputStream is=new FileInputStream(".....");
//        Reader isr=new InputStreamReader(is);//默认读UFT-8的文件,跟用普通的FileReader一样
        Reader isr=new InputStreamReader(is,"GBK");//读GBK的文件转化成UFT-8

        BufferedReader br=new BufferedReader(isr);//InputStreamReader也是原始流，用BufferedReader优化速度
/*
*               此处省略字符输入输出*/
        OutputStream  os=new FileOutputStream(".....");

//        Writer osw=new OutputStreamWriter(os);//默认UFT-8形式输出,跟用FileWriter一样
        Writer osw=new OutputStreamWriter(os,"GBK");

        BufferedWriter bw=new BufferedWriter(osw);//InputStreamWriter也是原始流，用BufferedWriter优化速度
    }

4.序列化和反序列化

Kun类

重点知识：

1.//必须实现Serializable接口才能序列化和反序列化

2.private static final long serialVersionUID=2;//版本号，变量名最好不要改就用serialVersionUID，如果版本号数字改变的话，就需要重新序列化才能反序列化

3.private transient String password;//用transient修饰就不会序列化，防止密码泄露

package serializable;

import java.io.Serializable;

public class Kun implements Serializable {//必须实现Serializable接口才能序列化和反序列化
    private static final long serialVersionUID=2;//版本号，变量名最好不要改就用serialVersionUID，如果版本号改变的话，就需要重新序列化才能反序列化
    private String name;
    private int age;
    private String id;
    private transient String password;//用transient修饰就不会序列化，防止密码泄露

    public Kun() {
    }

    public Kun(String name, int age, String id, String password) {
        this.name = name;
        this.age = age;
        this.id = id;
        this.password = password;
    }

    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;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "Kun{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id='" + id + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

1）对象

a）序列化

public static void main(String[] args) throws Exception{
        Kun ji=new Kun("caixukun",25,"jntm","12334");

        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("file-io-app2\\src\\heikun.txt"));

        oos.writeObject(ji);

        System.out.println("ji存储成功");
        oos.close();
    }

file-io-app2\\src\\heikun.txt中的文字

�� sr serializable.Kun��=� �� I ageL idt Ljava/lang/String;L nameq ~ xp   t jntmt caixukun

b）反序列化

public static void main(String[] args) throws Exception{
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("file-io-app2\\src\\heikun.txt"));
        List <Kun> list=new ArrayList<>();
        Kun ji=(Kun) ois.readObject();
        System.out.println(ji);
        ois.close();
    }

输出

Kun{name='caixukun', age=25, id='jntm', password='null'}

2)序列化和反序列化集合

public static void main(String[] args) throws Exception{
        Kun ji=new Kun("caixukun",25,"jntm","12334");
        Kun giao=new Kun("giao",18,"giao","54353");

        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("file-io-app2\\src\\heikun.txt"));

        ArrayList<Kun> list=new ArrayList<>();

        Collections.addAll(list,ji,giao);

        oos.writeObject(list);//把list序列化

        System.out.println("ji存储成功");
        oos.close();
    }

file-io-app2\\src\\heikun.txt中的文字

�� sr java.util.ArrayListx����a� I sizexp   w   sr serializable.Kun��=� �� I ageL idt Ljava/lang/String;L nameq ~ xp   t jntmt caixukunsq ~    t giaoq ~ x

public static void main(String[] args) throws Exception{
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("file-io-app2\\src\\heikun.txt"));
        Object obj=ois.readObject();//反序列化成Object
        ArrayList<Kun> ji=(ArrayList<Kun>)obj;//强转为ArrayList<Kun>
        for(Kun k:ji){
            System.out.println(k);
        }
        ois.close();
    }

输出

Kun{name='caixukun', age=25, id='jntm', password='null'}
Kun{name='giao', age=18, id='giao', password='null'}

5.打印流

6.重定向

作用改变输出语句到文件

public static void main(String[] args) throws Exception{
        System.out.println("锦瑟无端五十弦");
        System.out.println("一线一柱思华年");
        PrintStream ps=new PrintStream("file-io-app2\\src\\heikun2.txt");
        System.setOut(ps);//把系统打印流改成我们自己的打印流

        System.out.println("庄生晓梦迷蝴蝶");
        System.out.println("望帝春心图杜鹃");
    }

系统输出

锦瑟无端五十弦
一线一柱思华年

文件输出

加入这行语句能恢复系统打印流

System.setOut(new PrintStream(new FileOutputStream(FileDescriptor.out)));//恢复成系统打印流

7.properties

离家出走的Map子类,拥有的Map的方法，但是换了方法名

存入键值对

生成users.properties文件

public static void main(String[] args) throws Exception {
        Properties properties=new Properties();
        properties.setProperty("a","123");//等价与put
//        properties.put("a","123");
        properties.setProperty("b","1212");
        properties.setProperty("c","313");
        System.out.println(properties);
/*
*       第一个参数通向管道
*       第二个参数保存心得（随便写）
* */
        properties.store(new FileWriter("file-io-app2\\src\\users.properties")
                ,"give me five");

    }

文件内容

#give me five
#Fri Oct 14 16:24:18 CST 2022
a=123
b=1212
c=313

取键值对

public static void main(String[] args) throws Exception{
        Properties properties=new Properties();
        System.out.println(properties);

        properties.load(new FileReader("file-io-app2/src/users.properties"));
        System.out.println(properties);
        System.out.println(properties.getProperty("a"));//等价get
//        System.out.println(properties.get("a"));
        System.out.println(properties.getProperty("b"));
        System.out.println(properties.getProperty("c"));
    }

输出

{}
{a=123, b=1212, c=313}
123
1212
313

8.io框架

public static void main(String[] args) throws Exception{
        //复制文件
        IOUtils.copy(new FileInputStream(""),new FileOutputStream(""));
        //复制文件到指定文件夹
        FileUtils.copyFileToDirectory(new File(""),new File(""));
        //复制文件夹到文件夹
        FileUtils.copyDirectoryToDirectory(new File(""),new File(""));
        //删除文件
        FileUtils.delete(new File(""));
        //删除文件夹
        FileUtils.deleteDirectory(new File(""));
//        JDK1.7自己写的一行代码完成复制的操作：New IO的技术
        Files.copy(Path.of(""),Path.of(""));
        Files.deleteIfExists(Path.of(""));//只能删除空文夹
        Files.delete(Path.of(""));//只能删除空文夹
    }