Java中的IO流（三）

朱雀 2023-06-27 06:13 25阅读 0赞

**[Java中的IO流（一）：][Java_IO]  
https://blog.csdn.net/Veer\_c/article/details/103833045  
[Java中的IO流（二）：][Java_IO 1]  
https://blog.csdn.net/Veer\_c/article/details/103833423  
[Java中的IO流（三）：][Java_IO 2]  
https://blog.csdn.net/Veer\_c/article/details/103833811**

**IO流练习：**  
复制文本文件：  
4种：  
基本字符流一次读写一个字符  
基本字符流一次读写一个字符数组  
高效字符流一次读写一个字符  
高效字符流一次读写一个字符数组  
数据源：a.txt  
目的地：b.txt

package com.edu_07;
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    public class Test { 
        public static void main(String[] args) throws IOException { 
            method();//基本字符流一次读写一个字符
            method2();//基本字符流一次读写一个字符数组
            method3();//高效字符流一次读写一个字符
            method4();//高效字符流一次读写一个字符数组
        }
        private static void method4() throws IOException { 
            //高效字符流一次读写一个字符数组
            BufferedReader br = new BufferedReader(new FileReader("a.txt"));
            BufferedWriter bw = new BufferedWriter(new FileWriter("j.txt"));
            //一次读写一个字符数组
            char[] chs = new char[1024];
            int len;
            while ((len = br.read(chs))!=-1) { 
                bw.write(chs, 0, len);
                bw.flush();
            }
            //释放资源
            bw.close();
            br.close();
        }
        private static void method3() throws IOException { 
            //高效字符流一次读写一个字符
            BufferedReader br = new BufferedReader(new FileReader("a.txt"));
            BufferedWriter bw = new BufferedWriter(new FileWriter("j.txt"));
            //一次读写一个字符
            int ch;
            while ((ch=br.read())!=-1) { 
                bw.write(ch);
                bw.flush();
            }
            //关流
            bw.close();
            br.close();
        }
        private static void method2() throws IOException { 
            //基本字符流一次读写一个字符数组
            FileReader fr = new FileReader("a.txt");
            FileWriter fw = new FileWriter("j.txt");
            //一次读写一个字节数组
            char[] chs = new char[1024];
            int len;
            while ((len = fr.read(chs))!=-1) { 
                fw.write(chs, 0, len);
                fw.flush();
            }
            //关流
            fw.close();
            fr.close();
        }
        private static void method() throws IOException { 
            //基本字符流一次读写一个字符
            FileReader fr = new FileReader("a.txt");
            FileWriter fw = new FileWriter("j.txt");
            //一次读取一个字符,返回的是该字符对应的int值
    /* System.out.println((char)fr.read()); System.out.println((char)fr.read()); System.out.println((char)fr.read()); System.out.println((char)fr.read()); System.out.println((char)fr.read()); */
            int ch;
            while ((ch=fr.read())!=-1) { 
                //System.out.println((char)ch);
                fw.write(ch);
                fw.flush();
            }
            //释放资源
            fr.close();
            fw.close();
        }
    }

BufferedReader:字符缓冲输入流  
BufferedWriter:字符缓冲输出流  
1.需求：向文件中写入十个中国好，每写一个换一行（普通方式实现，高效流输出流特性实现）

package com.edu_08;
    import java.io.BufferedWriter;
    import java.io.FileWriter;
    import java.io.IOException;
    public class BufferedWriterDemo { 
        public static void main(String[] args) throws IOException { 
            //1.需求：向文件中写入十个中国好，每写一个换一行（高效流输出流特性实现）
            //创建高效字符输出流对象，并指向ff.txt文件
            BufferedWriter bw = new BufferedWriter(new FileWriter("ff.txt"));
            //写入数据
            for (int i = 0; i < 10; i++) { 
                /* 1.写一行 * 2.换行 * 3.刷新 */
                bw.write("中国好");
                bw.newLine();
                bw.flush();
            }
            //释放资源
            bw.close();
        }
    }

2.利用字符高效流的一次读写一行的特性复制文件  
写数据注意三部曲：  
bw.write(line);  
bw.newLine();  
bw.flush();

package com.edu_08;
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileNotFoundException;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    import javax.annotation.processing.Filer;
    import javax.lang.model.element.Element;
    import javax.tools.FileObject;
    import javax.tools.JavaFileObject;
    import javax.tools.JavaFileManager.Location;
    /* 2.利用字符高效流的一次读写一行的特性复制文 写数据注意三部曲： bw.write(line); bw.newLine(); bw.flush(); */
    public class Test { 
        public static void main(String[] args) throws IOException { 
            //封装数据源和目的地
            BufferedReader br = new BufferedReader(new FileReader("InputStreamReaderDemo.java"));
            BufferedWriter bw = new BufferedWriter(new FileWriter("copy.java"));
            //读取一行写一行
            String line;
            while ((line = br.readLine())!=null) { 
                //System.out.println();
                bw.write(line);
                bw.newLine();
                bw.flush();
            }
            //释放资源
            bw.close();
            br.close();
        }
    }

## IO流练习 ##

1.键盘录入数据并存储  
键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低存入文本文件。  
分析：  
A:定义学生类  
B:创建集合，采用TreeSet集合，并按照比较器排序  
C:键盘录入5个学生信息并存入集合  
D:遍历集合，并把数据写到文本文件

创建一个学生的Javabean
    package com.edu_09;
    public class Student { 
        private String name;
        private int chinese;
        private int math;
        private int english;
        public Student(String name, int chinese, int math, int english) { 
            super();
            this.name = name;
            this.chinese = chinese;
            this.math = math;
            this.english = english;
        }
        public Student() { 
            super();
            // TODO Auto-generated constructor stub
        }
        public String getName() { 
            return name;
        }
        public void setName(String name) { 
            this.name = name;
        }
        public int getChinese() { 
            return chinese;
        }
        public void setChinese(int chinese) { 
            this.chinese = chinese;
        }
        public int getMath() { 
            return math;
        }
        public void setMath(int math) { 
            this.math = math;
        }
        public int getEnglish() { 
            return english;
        }
        public void setEnglish(int english) { 
            this.english = english;
        }
        //获取总成绩的方法
        public int getAllScore(){ 
            return chinese+math+english;
        }
    }
    一个测试类：
    import java.io.BufferedWriter;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.util.Comparator;
    import java.util.Scanner;
    import java.util.TreeSet;
    /* 1.键盘录入数据并存储 * 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低存入文本文件 * 分析： * 1.创建学生类 * 2.键盘录入5个学生信息，并封装成学生对象，存储到TreeSet(使用比较器写一个排序算法) * 3.遍历集合，将信息存储到文本文件中(BufferedWriter) */
    public class StudentTest { 
        public static void main(String[] args) throws IOException { 
            //创建一个TreeSet集合，并写一个比较器
            TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() { 
                @Override
                public int compare(Student s1, Student s2) { 
                    int num = s1.getAllScore() - s2.getAllScore();
                    int num2 = num==0?s1.getName().compareTo(s2.getName()):num;
                    return num2;
                }
            });
            //键盘录入5个学生信息
            for (int i = 0; i < 5; i++) { 
                //创建键盘录入对象
                Scanner sc = new Scanner(System.in);
                //接受键盘录入数据
                System.out.println("请输入你的姓名");
                String name = sc.nextLine();
                System.out.println("请输入你的语文成绩");
                int chinese = sc.nextInt();
                System.out.println("请输入你的数学成绩");
                int math = sc.nextInt();
                System.out.println("请输入你的英语成绩");
                int english = sc.nextInt();
                //封装成学生对象，存储集合
                Student s = new Student(name, chinese, math, english);
                ts.add(s);
            }
            System.out.println("数据录入完毕。。");
            //遍历集合，将集合中的数据全取不出来之后写入文件中，每一个学生信息占一行
            BufferedWriter bw = new BufferedWriter(new FileWriter("score.txt"));
            for (Student s : ts) { 
                String info = s.getName()+" "+s.getChinese()+" "+s.getMath()+" "+s.getEnglish()+" "+s.getAllScore();
                //将拼接成的字符串写入文件中
                bw.write(info);
                bw.newLine();
                bw.flush();
            }
            //释放资源
            bw.close();
        }
    }

## 设计模式 ##

设计模式概述：设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。  
使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性以及代码的结构更加清晰.

**设计模式分类**  
创建型模式(创建对象的): 单例模式、抽象工厂模式、建造者模式、工厂模式、原型模式。  
行为型模式(对象的功能): 适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。  
结构型模式(对象的组成): 模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。

**单例设计模式（掌握）**  
单例设计思想：保证类在内存中只有一个对象  
如何实现类在内存中只有一个对象呢?  
构造私有  
本身提供一个对象  
通过公共的方法让外界访问  
单例模式分为 ：懒汉式、饿汉式  
**饿汉式：**

package com.edu_10;
    public class SingleInstanceDemo { 
        /* 饿汉式：当这个类一被加载，就在内存中创建了一个对象 * 1.保证内存中只有一个对象(构造私有) * 2.在本类中创建一个该类的对象 * 3.创建一个公共的访问方式给外界获取该对象 */
        private SingleInstanceDemo(){ }
        //静态的随着类的加载而加载
        private static SingleInstanceDemo instance = new SingleInstanceDemo();
        //给外界提供公共的访问方式，返回该对象
        public static SingleInstanceDemo getInstance(){ 
            return instance;
        }
    }
    //证明：
    package com.edu_10;
    public class SingleInstanceDemoTest { 
        public static void main(String[] args) { 
            SingleInstanceDemo instance = SingleInstanceDemo.getInstance();
            SingleInstanceDemo instance2 = SingleInstanceDemo.getInstance();
            System.out.println(instance==instance2);
        }
    }

**懒汉式：**

public class SingleInstanceDemo2 { 
        /* 单例设计模式之懒汉式： * 需要的时候才去创建对象，不需要的时候不创建 */
        private SingleInstanceDemo2(){ }
    
        private static SingleInstanceDemo2 instance = null;
    
        public static SingleInstanceDemo2 getInstance(){ 
            if (instance==null) { 
                instance = new SingleInstanceDemo2();
            }
            return instance;
        }
    }
    //证明：
    package com.edu_10;
    public class SingleInstanceDemo2Test { 
        public static void main(String[] args) { 
            SingleInstanceDemo2 instance = SingleInstanceDemo2.getInstance();
            SingleInstanceDemo2 instance2 = SingleInstanceDemo2.getInstance();
            System.out.println(instance==instance2);
        }
    }

## 工厂设计模式 ##

简单工厂模式概述: 又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例。  
优点: 使用静态工厂模式的优点是实现责任的分割，该模式的核心是工厂类，工厂类含有必要的选择逻辑，可以决定什么时候创建哪一个产品的实例，而客户端则免去直接创建产品的责任，而仅仅是消费产品。也就是说静态工厂模式在不改变客户端代码的情况可以动态的增加产品。  
明确了类的职责  
缺点：这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护。

工厂方法模式概述：工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。  
优点：客户端不需要在负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性。  
缺点: 需要额外的编写代码，增加了工作量。

package com.edu_12;
    public abstract class Animal { 
        public abstract void eat();
    }
    public abstract class AnimalFactory { 
        //创建动物的功能
        public abstract Animal getAnimal();
    }
    public class Cat extends Animal{ 
        @Override
        public void eat() { 
            System.out.println("猫吃鱼");
        }
    }
    public class CatFactory extends AnimalFactory{ 
        @Override
        public Animal getAnimal() { 
            // TODO Auto-generated method stub
            return new Cat();
        }
    }
    public class Dog extends Animal{ 
        @Override
        public void eat() { 
            System.out.println("狗吃骨头");
        }
    }
    public class DogFactory extends AnimalFactory{ 
        @Override
        public Animal getAnimal() { 
            // TODO Auto-generated method stub
            return new Dog();
        }
    }
    //在之后要添加对象的时候：需要添加这个对象的工厂，然后再创建对象
    public class TigerFactory extends AnimalFactory{ 
        @Override
        public Animal getAnimal() { 
            // TODO Auto-generated method stub
            return new Tiger();
        }
    }
    public class Tiger extends Animal{ 
        @Override
        public void eat() { 
            System.out.println("虎吃人");
        }
    }
    public class Test { 
        public static void main(String[] args) { 
            //需要一个狗对象
            AnimalFactory af = new DogFactory();
            Animal a = af.getAnimal();
            a.eat();
            //需要一个猫对象
            af = new CatFactory();
            a = af.getAnimal();
            a.eat();
            //需要一个老虎类
            af = new TigerFactory();
            a = af.getAnimal();
            a.eat();
        }
    }

[Java_IO]: https://blog.csdn.net/Veer_c/article/details/103833045
[Java_IO 1]: https://blog.csdn.net/Veer_c/article/details/103833423
[Java_IO 2]: https://blog.csdn.net/Veer_c/article/details/103833811