IO流_集合写到文件

需求:把ArrayList集合中的字符串数据写入到文本文件 要求:每一个字符串元素作为文件中的一行数据

思路: 1、创建ArrayList集合 2、往集合中存储字符串元素 3、创建字符缓冲输出流对象 4、遍历集合，得到每一个字符串数据 5、调用字符缓冲输出流对象的方法写数据 6、释放资源

IO流_集合写到文件的练习

xxxxxxxxxx
package ch19;

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

//把ArrayList集合里面的数据写入文件里面
public class a_16_1测试 {

    public static void main(String[] args) throws IOException {

        //1、创建ArrayList集合
        ArrayList<String> array = new ArrayList<String>();

        //2、往集合中存储字符串元素
        array.add("hello");
        array.add("world");
        array.add("java");

        //3、创建字符缓冲输出流对象。报红线就选中它，按Alt+Enter，抛出异常
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\huanf\\java\\src\\ch18_ch19_储物区\\array.txt"));

        //4、遍历集合，得到每一个字符串数据。使用增强for来遍历集合
        for(String s : array){
            //5、调用字符缓冲输出流对象的方法写数据
            bw.write(s);
            bw.newLine();//调用newLine方法来换行，不然会把数据都写在一行
            bw.flush();//刷新缓冲流，这不必要，但是写了就是好习惯
        }

        //释放资源
        bw.close();

    }
}

IO流_文件写到集合

需求:把文本文件中的数据读取到集合中，并遍历集合 要求:文件中每一行数据是一个集合元素，即我们要使用BufferedReader类的特有方法，即public String readLine():读一行文字，即字符缓冲输入流对象

思路: 1、创建字符缓冲输入流对象 2、创建ArrayList集合对象 3、调用字符缓冲输入流对象的方法读数据 4、把读取到的字符串数据存储到集合中 5、释放资源 6、遍历集合

IO流_文件写到集合的练习

xxxxxxxxxx
package ch19;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

//把文件里面的数据读取到集合里面
public class a_17_1测试 {

    public static void main(String[] args) throws IOException {

        //1、创建字符缓冲输入流对象。报红线就选中它，按Alt+Enter，抛出异常
        BufferedReader br = new BufferedReader(new FileReader("D:\\huanf\\java\\src\\ch18_ch19_储物区\\array.txt"));

        //2、创建ArrayList集合对象
        ArrayList<String> array = new ArrayList<String>();

        //3、调用字符缓冲输入流对象的方法读数据
        String line;
        while ((line= br.readLine())!=null){
            //4、把读取到的字符串数据存储到集合中
            array.add(line);
        }

        //5、释放资源
        br.close();

        //6、遍历集合
        for (String s : array){
            System.out.println(s);
        }

        //控制台输出的就是集合里面的数据

    }
}

IO流集合到文件改进版

需求:把ArrayList集合中的学生数据写入到文本文件 要求:每一个学生对象的数据作为文件中的一行数据 格式:学号，姓名，年龄，居住地 举例:std001,张三，18，厦门 改进的地方:之前ArrayList集合中存储的是字符串数据，现在ArrayList集合中存储的是学生对象数据

思路: 1、定义学生类 2、创建ArrayList集合 3、创建学生对象 4、把学生对象添加到集合中 5、创建字符缓冲输出流对象 6、遍历集合，得到每一个学生对象 7、把学生对象的数据拼接成指定格式的字符串 8、调用字符缓冲输出流对象的方法写数据 9、释放资源

IO流集合到文件改进版的练习

xxxxxxxxxx
package ch19;

public class a_19_1Student {


    //成员变量
    private String sid;
    private String name;
    private int age;
    private String address;

    //无参构造方法
    public a_19_1Student() {
    }

    //无参构造方法
    public a_19_1Student(String sid, String name, int age, String address) {
        this.sid = sid;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    //成员变量对应的get、set方法
    public String getSid() {
        return sid;
    }
    public void setSid(String sid) {
        this.sid = sid;
    }
    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 getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
}

xxxxxxxxxx
package ch19;

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

//往集合里面添加数据，再把集合里面的数据写到文件里面
public class a_19_2测试 {

    public static void main(String[] args) throws IOException {

        //2、创建ArrayList集合
        ArrayList<a_19_1Student> array = new ArrayList<a_19_1Student>();

        //3、创建学生对象
        a_19_1Student s1 = new a_19_1Student("std001", "张三", 18, "厦门");
        a_19_1Student s2 = new a_19_1Student("std001", "李四", 18, "广州");
        a_19_1Student s3 = new a_19_1Student("std001", "王五", 18, "福建");

        //4、把学生对象添加到集合中
        array.add(s1);
        array.add(s2);
        array.add(s3);

        //5、创建字符缓冲输出流对象。报红线就选中它，按Alt+Enter，抛出异常
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\huanf\\java\\src\\ch18_ch19_储物区\\students.txt"));

        //6、遍历集合，得到每一个学生对象。使用增强for来遍历集合
        for (a_19_1Student s : array) {
            //7、把学生对象的数据拼接成指定格式的字符串
            StringBuilder sbd = new StringBuilder(); //StringBuilder用于拼接
            sbd.append(s.getSid()).append(",").append(s.getName()).append(",").append(s.getAge()).append(",").append(s.getAddress());

            //8、调用字符缓冲输出流对象的方法写数据
            bw.write(sbd.toString());//把StringBuilder类型转为字符串类型
            bw.newLine();//换行
            bw.flush();//刷新缓冲流
        }

        //9、释放资源
        bw.close();

    }
}

IO流文件到集合改进版

需求:把文本文件中的数据读取到集合中，并遍历集合 要求:文件中每一行数据是一个学生对象的成员变量值 举例:std001，张三，18，厦门 。注意这里的数据都是用逗号分割的，所以我们需要用split方法进行分割 改进的地方:之前ArrayList集合中存储的是字符串数据，现在ArrayList集合中存储的是学生对象数据

思路: 1、定义学生类 2、创建字符缓冲输入流对象 3、创建ArrayList集合对象 4、调用字符缓冲输入流对象的方法读数据 5、把读取到的字符串数据用split()进行分割，得到一个字符串数组 6、创建学生对象 7、把字符串数组中的每一个元素取出来，对应地赋值给学生对象的成员变量值 8、把学生对象添加到集合 9、释放资源 10、遍历集合

IO流文件到集合改进版的练习

xxxxxxxxxx
package ch19;

public class a_20_1Student {

    //成员变量
    private String sid;
    private String name;
    private int age;
    private String address;

    //无参构造方法
    public a_20_1Student() {
    }

    //无参构造方法
    public a_20_1Student(String sid, String name, int age, String address) {
        this.sid = sid;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    //成员变量对应的get、set方法
    public String getSid() {
        return sid;
    }
    public void setSid(String sid) {
        this.sid = sid;
    }
    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 getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
}

xxxxxxxxxx
package ch19;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

//先提前准备一个学生名字的文件，把文件里面的数据读取到集合里面，遍历集合把集合里面的数据输出在控制台
public class a_20_2测试 {

    public static void main(String[] args) throws IOException {

        //2、创建字符缓冲输入流对象。报红线就选中它，按Alt+Enter，抛出异常
        BufferedReader br = new BufferedReader(new FileReader("java\\src\\ch18_ch19_储物区\\students.txt"));

        //3、创建ArrayList集合对象
        ArrayList<a_20_1Student> array = new ArrayList<a_20_1Student>();

        //4、调用字符缓冲输入流对象的方法读数据
        String line;
        while ((line = br.readLine()) != null) {
            //5、把读取到的字符串数据用split()进行分割，得到一个字符串数组
            String[] strArray = line.split(",");

            //6、创建学生对象
            a_20_1Student s = new a_20_1Student();
            //7、把字符串数组中的每一个元素取出来，对应地赋值给学生对象的成员变量值。具体的索引以文件的数据为准，例如std001,张三,18,厦门
            s.setSid(strArray[0]);
            s.setName(strArray[1]);
            s.setAge(Integer.parseInt(strArray[2]));//Integer.parseInt()的作用是把字符串strArray[2]转换成整型
            s.setAddress(strArray[3]);

            //8、把学生对象添加到集合
            array.add(s);
        }

        //9、释放资源
        br.close();

        //10、遍历集合。使用增强for来遍历集合
        for (a_20_1Student s : array) {
            System.out.println(s.getSid() + "," + s.getName() + "," + s.getAge() + "," + s.getAddress());
        }

    }
}

点名器案例

案例:点名器 需求:有一个文件里面存储了班级同学的姓名，每一个姓名占一行 要求:通过程序实现随机点名器

思路: 1、创建字符缓冲输入流对象 2、创建ArrayList集合对象 3、调用字符缓冲输入流对象的方法读数据 4、把读取到的字符串数据存储到集合中 5、释放资源 6、使用Random产生一个随机数，随机数的范围在:[0,集合的长度) 7、把第6步产生的随机数作为索引到ArrayList集合中获取值 8、把第7步得到的数据输出在控制台

点名器案例的练习

xxxxxxxxxx
package ch19;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Random;

//把姓名文件里面的姓名随机输出一个。把读到的文件的数据放到集合里，再用一个随机数作为索引去拿集合里面的数据
public class a_18_1测试 {

    public static void main(String[] args) throws IOException {

        //1、创建字符缓冲输入流对象。报红线就选中它，按Alt+Enter，抛出异常
        BufferedReader br = new BufferedReader(new FileReader("java\\src\\ch18_ch19_储物区\\names.txt"));

        //2、创建ArrayList集合对象
        ArrayList<String> array = new ArrayList<String>();

        //3、调用字符缓冲输入流对象的方法读数据
        String line;
        while ((line = br.readLine()) != null) {
            //4、把读取到的字符串数据存储到集合中
            array.add(line);
        }

        //5、释放资源
        br.close();

        //6、使用Random产生一个随机数，随机数的范围在:[0,集合的长度)
        Random r = new Random();
        int index = r.nextInt(array.size());//范围是集合的长度

        //7、把第6步产生的随机数作为索引到ArrayList集合中获取值
        String name = array.get(index);

        //8、把第7步得到的数据输出在控制台
        System.out.println("幸运者是: " + name);

    }
}

IO流集合到文件数据排序改进版

需求:键盘录入5个学生信息(姓名，语文成绩，数学成绩，英语成绩) 要求:按照成绩总分从高到低写入文本文件。排序那就用TreeSet集合 格式:姓名，语文成绩，数学成绩，英语成绩 举例:张三，90,91,92

思路: 1、定义学生类 2、创建TreeSet集合，通过比较器排序进行排序 3、键盘录入学生数据 4、创建学生对象，把键盘录入的数据对应赋值给学生对象的成员变量 5、把学生对象添加到TreeSet集合 6、创建字符缓冲输出流对象 7、遍历集合，得到每一个学生对象 8、把学生对象的数据拼接成指定格式的字符串 9、调用字符缓冲输出流对象的方法写数据 10、释放资源

IO流集合到文件数据排序改进版的练习

xxxxxxxxxx
package ch20;

public class a_1_1Student {

    //成员变量
    private String name;
    private int chinese;
    private int math;
    private int english;

    //无参构造方法
    public a_1_1Student() {
    }

    //无参构造方法
    public a_1_1Student(String name, int chinese, int math, int english) {
        this.name = name;
        this.chinese = chinese;
        this.math = math;
        this.english = english;
    }

    //成员变量对应的get、set方法
    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 getSum() {
        return this.chinese + this.math + this.english;
    }

}

xxxxxxxxxx
package ch20;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

//从键盘录入5个学生的数据，存储到集合里面且赋值给学生类里面的变量，遍历集合把数据写到文件里面。学生不重复，学生总分从高到低排序
public class a_1_2测试 {

    public static void main(String[] args) throws IOException {

        //2、创建TreeSet集合，通过比较器排序进行排序
        TreeSet<a_1_1Student> ts = new TreeSet<a_1_1Student>(new Comparator<a_1_1Student>() {
            @Override
            public int compare(a_1_1Student s1, a_1_1Student s2) {//这里对应的改成s1和s2
                //可以在这里写计算总分的方法，也可以去学生类里面写方法。这里采用的是后者
                int num = s2.getSum() - s1.getSum();//s2-s1就可以得到从高到低排序。getSum方法在学生类里面写好了
                //次要条件，当成绩总分相同时即num==0，未必是同一个人，所以我们还要再判断其他几科的成绩
                int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;//如果总分相同，语文成绩也相同，就再比较数学成绩，如下
                int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2;//如果总分相同，语文和数学成绩相同，那英语也必然是相同的，就不用比较英语了
                //当所有成绩相同时，也未必是同一个人，再比较一下名字
                int num4 = num3 == 0 ? s1.getName().compareTo(s2.getName()) : num3;
                return num4;
            }
        });
        //因为我们等下要用比较器排序，所以上面那部分在构造方法的地方用匿名内部类的方式来传递一个比较器

        //3、键盘录入学生数据
        for (int i=0; i<5; i++){
            Scanner sc = new Scanner(System.in);
            System.out.println("请录入第"+(i+1)+"个学生信息");//i是从0开始，我们加1就可以从1开始，总共录入5个数据
            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();
            if (i<4){
                System.out.println("-----请继续录入，还剩"+(4-i)+"个学生信息--------");
            } else{
                System.out.println("录入完成，请前往文件查看");
            }

            //4、创建学生对象，把键盘录入的数据对应赋值给学生对象的成员变量
            a_1_1Student s = new a_1_1Student();
            s.setName(name);
            s.setChinese(chinese);
            s.setMath(math);
            s.setEnglish(english);

            //5、把学生对象添加到TreeSet集合
            ts.add(s);
        }

        //6、创建字符缓冲输出流对象。报红线就选中它，按Alt+Enter，抛出异常
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\huanf\\java\\src\\ch18_ch19_储物区\\ts.txt"));

        //7、遍历集合，得到每一个学生对象。。使用增强for来遍历集合
        for (a_1_1Student s : ts){
            //8、把学生对象的数据拼接成指定格式的字符串。格式:姓名，语文成绩，数学成绩，英语成绩
            StringBuilder sbd = new StringBuilder();//拼接顺序是姓名、逗号、语文成绩、逗号、数学成绩、逗号、英语成绩、逗号、总分，如下
            sbd.append(s.getName()).append(",").append(s.getChinese()).append(",").append(s.getMath()).append(",").append(s.getEnglish()).append(",").append(s.getSum());

            //9、调用字符缓冲输出流对象的方法写数据
            bw.write(sbd.toString());//把数据作为字符串写进去
            bw.newLine();//每写进一个数据，就换行一次
            bw.flush();//刷新缓冲流
        }

        //10、释放资源
        bw.close();

    }
}