Java学习——day 12

主要内容

• 分拣存储及其实例
• 冒泡排序
• 引用数据类型的排序

笔记详情

1. 分拣存储及其实例

Map容器能够实现键值对 一对一 存储，但是如果我们想要实现 一对多 ，单单使用Map容器是不能完成的，这个时候我们可以采用面向对象的思想，结合Map容器来存储。今天介绍一种存储方式：分拣存储。

分拣存储，类似于快递员分配快递一样。快递员在分拣快递的时候，如果看到上海的快递，会把它放到盛放上海快递的袋子中，如果没有这个袋子，那就找一个，之后上海的快递全部放在这个袋子里面。

这个袋子就相当于是 键 ，袋子里面的快递，就相当于是值，使用这种方式，就可以实现 一对多 的存储。

下面看一个 一对多 的分拣存储实例：一个班级里面有多个学生，建立 班级 ： 学生 的一对多的关系，最后算出班级的考试总分和平均分：

学生类：

package HashMap;

public class Student {
    private String name;        // 姓名
    private String classNo;     // 班级编号
    private double score;       // 成绩

    public Student(String name, String classNo, double score) {
        this.name = name;
        this.classNo = classNo;
        this.score = score;
    }

    public String getClassNo() {
        return classNo;
    }

    public double getScore() {
        return score;
    }
}

班级类：

import java.util.ArrayList;
import java.util.List;

public class ClassRoom {
    private String classNo;
    private List<Student> studentList;
    private double totalScore;
    private double avageScore;

    public ClassRoom() {
        this.studentList = new ArrayList<Student>();
    }

    public ClassRoom(String classNo) {
        this();
        this.classNo = classNo;
    }

    public String getClassNo() {
        return classNo;
    }

    public void setClassNo(String classNo) {
        this.classNo = classNo;
    }

    public double getTotalScore() {
        return totalScore;
    }

    public void setTotalScore(double totalScore) {
        this.totalScore = totalScore;
    }

    public double getAvageScore() {
        return avageScore;
    }

    public void setAvageScore(double avageScore) {
        this.avageScore = avageScore;
    }

    public List<Student> getStudentList(){
        return this.studentList;
    }
}

分拣存储主代码

import java.util.*;

public class Demo04 {

    private static List<Student> stuList = new ArrayList<Student>();
    private static HashMap<String, ClassRoom> classMap = new HashMap<String, ClassRoom>();

    // 1. 添加学生的信息数据
    public static void exam() {
        stuList.add(new Student("fengzhen", "001", 80));
        stuList.add(new Student("Tom", "001", 75));
        stuList.add(new Student("Jack", "001", 70));
        stuList.add(new Student("Jane", "002", 90));
        stuList.add(new Student("Tang", "002", 80));
        stuList.add(new Student("Yuan", "002", 85));
        stuList.add(new Student("Lucy", "002", 82));
    }

    // 2. 将学生的信息添加到班级中，进行分数的处理
    public static void count() {
        for (Student stu : stuList) {
            String classNo = stu.getClassNo();
            double stuScore = stu.getScore();

            ClassRoom newClass = classMap.get(classNo);
            // 之前没有该班级,新建一个班级，将该班级的学生全部放在里面
            if (newClass == null) {
                newClass = new ClassRoom(classNo);
                classMap.put(classNo, newClass);
            }

            newClass.getStudentList().add(stu);
            newClass.setTotalScore(newClass.getTotalScore() + stu.getScore());
            newClass.setAvageScore(newClass.getTotalScore() / newClass.getStudentList().size());
        }
    }


    // 3. 遍历班级数据，显示总分和平均分
    public static void view() {
        Set<String> keySet = classMap.keySet();
        Iterator<String> classKey = keySet.iterator();

        while (classKey.hasNext()) {
            String classNo = classKey.next();
            System.out.println(classNo + "班级的总分是：" + classMap.get(classNo).getTotalScore() + "，平均分是：" + classMap.get(classNo).getAvageScore());
        }
    }
    
    public static void main(String[] args) {
        exam();
        count();
        view();
    }
}

2. 冒泡排序

标准版本

public static void main(String[] args) {
    int[] arr = {2, 55, 6, 9, 88, 20, 13};

    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] >= arr[j + 1]) {
                int temp;
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

优化版本

public static void main(String[] args) {
    int[] arr = {2, 55, 6, 9, 88, 20, 13};
    boolean sorted;     // 表示经过一轮循环比较之后，数组是否已经有序

    for (int i = 0; i < arr.length - 1; i++) {
        sorted = true;
        for (int j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] >= arr[j + 1]) {
                int temp;
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                sorted = false;
            }
        }
        // 如果数组已经有序，则停止比较
        if (sorted) {
            break;
        }
    }
}

3. 引用数据类型的排序

jdk提供了内置引用类型的排序规则，这些内置应用类型继承了 Comparable 接口，重写了 compareTo() 方法。如果是我们自定义的引用，也可以实现 Comparable 接口，根据我们自己的需求重写**compareTo()** 方法。

内置引用类型的排序规则如下：

• 整数、浮点数（Integer、Float、Double）：直接比较基本数据类型的大小
• 字符：比较unicode码之差
• 字符串：如果其中一个字符串是另外一个字符串其实开始的子串，返回长度之差，例如： “abcde” 和 “abc” ；否则返回第一个不相等的unicode码之差。
• 日期类：根据日期对应的的长整型数比较。

此处列出几个实例：

String str1 = "abc";
String str2 = "abcdef";
System.out.println(str1.compareTo(str2));       // -3，表示str1比str2的长度小3

Date date1 = new Date();
Date date2 = new Date(System.currentTimeMillis() - 1000 * 60 * 6);
System.out.println(date1.compareTo(date2));     // 1，表示data1 > date2