Java集合框架（下）

contains原理

List.contains()

-遍历Lsit，对集合中的每个元素进行equals判断，只要有一个元素equals返回true，则contains返回true。
这里写图片描述

Set.contains()

-遍历Lsit，对集合中的每个元素进行equals以及hashCode判断，只要有一个元素equals以及hashCode返回true，则contains返回true。
这里写图片描述

测试List.contains() and Set.contains()

-Course类

public class Course {
    // 课程编号
    private String id;
    // 课程名
    private String name;

    public Course() {
    }

    public Course(String id, String name) {
        this.id = id;
        this.name = name;
    }


    @Override
    public int hashCode() {
        final int prime = ;
        int result = ;
        result = prime * result + ((name == null) ?  : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (!(obj instanceof Course))
            return false;
        Course other = (Course) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

-Student

import java.util.Set;

public class Student {
    // 学生编号
    private String id;
    // 学生姓名
    private String name;
    // 课程集合
    private Set<Course> courses;

    public Student(String id, String name, Set<Course> courses) {
        this.id = id;
        this.name = name;
        this.courses = courses;
    }

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Set<Course> getCourses() {
        return courses;
    }

    public void setCourses(Set<Course> courses) {
        this.courses = courses;
    }

}

-main程序

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;

public class SetTest {

    private List<Course> listCourses;
    private Scanner scanner;
    private Student student;

    public SetTest() {
    }

    public SetTest(List<Course> listCourses, Scanner scanner) {
        this.listCourses = listCourses;
        this.scanner = scanner;
    }

    // 用于向课程集合中添加被选课程
    public void add() {
        Course course1 = new Course("1", "数据结构");
        listCourses.add(course1);
        Course temp = listCourses.get();
        System.out.println(temp.getId() + "/" + temp.getName());
        Course course2 = new Course("2", "C语言");
        /*
         * 在可以访问的位置中插入数据，之前相应的数据位置往后移动一位 目前可访问的位置为0 若试图访问其他位置则会发生数组下标越界异常
         */
        listCourses.add(, course2);
        Course temp2 = listCourses.get();
        System.out.println(temp2.getId() + "/" + temp2.getName());

        // 一次添加多个元素
        Course[] courses = { new Course("3", "离散数学"), new Course("4", "汇编语言") };
        // asList将数组转换为集合
        listCourses.addAll(Arrays.asList(courses));
        Course temp3 = listCourses.get();
        System.out.println(temp3.getId() + "/" + temp3.getName());
        Course temp4 = listCourses.get();
        System.out.println(temp4.getId() + "/" + temp4.getName());

        Course[] courses2 = { new Course("5", "高等数学"), new Course("6", "大学英语") };
        // 新添加的两门课程从2处插入
        listCourses.addAll(, Arrays.asList(courses2));
        Course temp5 = listCourses.get();
        System.out.println(temp5.getId() + "/" + temp5.getName());
        Course temp6 = listCourses.get();
        System.out.println(temp5.getId() + "/" + temp6.getName());
    }

    // 通过foreach遍历List
    public void foreach() {
        System.out.println("调用foreach");
        for (Course course : listCourses) {
            System.out.println(course.getId() + "/" + course.getName());
        }
    }

    // foreach输出所选课程
    public void StudentForeach(Student student) {
        // 输出学生所选课程，输出顺序不固定
        for (Course course : student.getCourses()) {
            System.out.println(course.getId() + "/" + course.getName());
        }
    }

    // 测试List-contains方法
    public void contains() {
        Course course = listCourses.get();
        System.out.println("取得课程：" + course.getName());
        System.out.println("备选课程中是否包含：" + course.getName() + "," + listCourses.contains(course));
        // 创建一个新课程对象
        System.out.println("输入课程名");
        String name = scanner.next();
        Course course2 = new Course();
        course2.setName(name);
        System.out.println("取得课程：" + course2.getName());
        // 根据需求重写Course.equals方法来获得效果
        System.out.println("备选课程中是否包含：" + course2.getName() + "," + listCourses.contains(course2));
    }

    // 创建学生对象并选课
    public void createStudentAndSelectCourse() {
        // 创建一个学生对象
        Set<Course> courses = new HashSet<Course>();
        student = new Student("1", "小明", courses);
        // 获取键盘输入的课程ID
        Scanner scanner = new Scanner(System.in);
        for (int i = ; i < ; i++) {
            System.out.println("请输入课程ID");
            String id = scanner.next();
            for (Course course : listCourses) {
                if (course.getId().equals(id)) {
                    student.getCourses().add(course);
                }
            }
        }
        StudentForeach(student);
    }

    // 测试Setcontains方法
    public void SetContains() {
        // 提示输入课程名称
        System.out.println("请输入学生已选课程名称");
        String name = scanner.next();
        Course course2 = new Course();
        course2.setName(name);
        System.out.println("取得课程：" + course2.getName());
        // 根据需求重写Course.equals方法来获得效果
        System.out.println("备选课程中是否包含：" + course2.getName() + "," + student.getCourses().contains(course2));
    }

    public static void main(String[] args) {
        List<Course> list = new ArrayList<Course>();
        Scanner scanner = new Scanner(System.in);
        ListTest listCourses = new ListTest(list);
        SetTest setTest = new SetTest(list, scanner);
        setTest.add();
        setTest.foreach();
//      setTest.contains();
        setTest.createStudentAndSelectCourse();
        setTest.SetContains();
    }
}

1/数据结构
2/C语言
3/离散数学
4/汇编语言
5/高等数学
5/大学英语
调用foreach
2/C语言
1/数据结构
5/高等数学
6/大学英语
3/离散数学
4/汇编语言
请输入课程ID
1
请输入课程ID
2
请输入课程ID
3
3/离散数学
2/C语言
1/数据结构
请输入学生已选课程名称
离散数学
取得课程：离散数学
备选课程中是否包含：离散数学,true

获取List中索引位置

-代码跟之前的大同小异，此处只显示略微更改的部分

// 测试List-contains方法
    public void contains() {
        Course course = listCourses.get();
        System.out.println("取得课程：" + course.getName());
        System.out.println("备选课程中是否包含：" + course.getName() + "," + listCourses.contains(course));
        // 创建一个新课程对象
        System.out.println("输入课程名");
        String name = scanner.next();
        Course course2 = new Course();
        course2.setName(name);
        System.out.println("取得课程：" + course2.getName());
        // 根据需求重写Course.equals方法来获得效果
        System.out.println("备选课程中是否包含：" + course2.getName() + "," + listCourses.contains(course2));
        // 通过indexOf方法来取得元素索引位置
        // 如果有多个重复元素，则返回第一次出现时所在索引位置，LastindexOf则是返回最后一次出现的位置
        // 若不出现则返回索引位置为-1
        if(listCourses.contains(course2)){
            System.out.println("课程："+course2.getName()+"索引位置为："+listCourses.indexOf(course2));
        }
    }

public static void main(String[] args) {
        List<Course> list = new ArrayList<Course>();
        Scanner scanner = new Scanner(System.in);
        ListTest listCourses = new ListTest(list);
        SetTest setTest = new SetTest(list, scanner);
        setTest.add();
        setTest.contains();
        setTest.foreach();
//      setTest.createStudentAndSelectCourse();
//      setTest.SetContains();
    }

1/数据结构
2/C语言
3/离散数学
4/汇编语言
5/高等数学
5/大学英语
取得课程：C语言
备选课程中是否包含：C语言,true
输入课程名
离散数学
取得课程：离散数学
备选课程中是否包含：离散数学,true
课程：离散数学索引位置为：4
调用foreach
2/C语言
1/数据结构
5/高等数学
6/大学英语
3/离散数学
4/汇编语言

判断Map中是否包含指定的key和value

-对Student中的equals进行重写

import java.util.Set;

public class Student {
    // 学生编号
    private String id;
    // 学生姓名
    private String name;
    // 课程集合
    private Set<Course> courses;

    public Student(String id, String name, Set<Course> courses) {
        this.id = id;
        this.name = name;
        this.courses = courses;
    }

    @Override
    public int hashCode() {
        final int prime = ;
        int result = ;
        result = prime * result + ((name == null) ?  : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (!(obj instanceof Student))
            return false;
        Student other = (Student) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Set<Course> getCourses() {
        return courses;
    }

    public void setCourses(Set<Course> courses) {
        this.courses = courses;
    }

}

-主程序

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;

public class MapTest {

    // 用了盛装学生类型
    private Map<String, Student> students;
    private Set<Course> courses;

    public MapTest(Map<String, Student> students) {
        this.students = students;
    }

    /*
     * 添加学生：输入ID，判断是否有学生对象， 若没有则输入姓名，创建学生对象并添加到students中
     */
    public void put() {
        Scanner scanner = new Scanner(System.in);
        int i = ;
        while (i < ) {
            System.out.println("请输入学生ID");
            String id = scanner.next();
            // 判断id是否被占用
            Student student = students.get(id);
            if (student == null) {
                System.out.println("请输入学生姓名：");
                String name = scanner.next();
                Student newStudent = new Student(id, name, courses);
                // 向map中添加学生
                students.put(id, newStudent);
                System.out.println("成功添加" + students.get(id).getName());
                i++;
            } else {
                System.out.println("id被占用");
                continue;
            }
        }
    }

    // 测试keySet
    public void keySet() {
        Set<String> key = students.keySet();
        System.out.println("容量" + students.size());
        for (String id : key) {
            Student student = students.get(id);
            // 判断是否为空非常必要，不然会出现空指针异常
            if (student != null) {
                System.out.println(student.getId() + "/" + student.getName());
            }
        }
    }

    // 测试删除Map中的映射
    public void remove() {
        System.out.println("请输入要删除学生的id");
        Scanner scanner = new Scanner(System.in);
        while (true) {
            String id = scanner.next();
            Student student = students.get(id);
            if (student == null) {
                System.out.println("输入的id不存在,请重新输入");
                continue;
            } else {
                students.remove(id);
                System.out.println("删除:" + student.getName() + "成功");
                break;
            }
        }
    }

    // 通过entrySet遍历Map
    public void entrySet() {
        Set<Entry<String, Student>> entrySet = students.entrySet();
        for (Entry<String, Student> entry : entrySet) {
            System.out.println("取得键:" + entry.getKey());
            System.out.println("对应值:" + entry.getValue().getName());
        }
    }

    // 利用put方法修改Map中已有映射
    public void testPut() {
        System.out.println("请输入要修改学生的id");
        Scanner scanner = new Scanner(System.in);
        while (true) {
            String id = scanner.next();
            Student student = students.get(id);
            if (student == null) {
                System.out.println("输入的id不存在,请重新输入");
                continue;
            } else {
                System.out.println("对应学生为：" + student.getName());
                System.out.println("请输入新的学生名");
                String name = scanner.next();
                Student newStudent = new Student(id, name, courses);
                students.put(id, newStudent);
                System.out.println("修改成功");
                break;
            }
        }
    }

    // 测试在Map中是否包含某个key值或者value值
    public void containsKeyOrValue() {
        /*
         * 在Map中，用containsKey()方法，来判断是否包含某个key值
         * 用containsValue()方法，来判断是否包含某个value值 作比较时经常需要对相应类的equals() 和 hasnCode()
         * 重写
         */
        System.out.println("请输入要查询的学生ID");
        Scanner scanner = new Scanner(System.in);
        String id = scanner.next();
        System.out.println("在学生映射表中是否存在：" + students.containsKey(id));
        if (students.containsKey(id)) {
            System.out.println("对应的学生为：" + students.get(id).getName());
        }
        System.out.println("请输入要查询的学生姓名");
        String name = scanner.next();
        if (students.containsValue(new Student(null, name, courses))) {
            System.out.println("包含学生：" + name);
        } else {
            System.out.println("该学生不存在");
        }
    }

    public static void main(String[] args) {
        Map<String, Student> students = new HashMap<String, Student>();
        MapTest mapTest = new MapTest(students);
        mapTest.put();
        mapTest.keySet();
        // mapTest.remove();
        // mapTest.testPut();
        // mapTest.entrySet();
        mapTest.containsKeyOrValue();
    }

    public Map<String, Student> getStudents() {
        return students;
    }

    public void setStudents(Map<String, Student> students) {
        this.students = students;
    }

}

请输入学生ID
1
请输入学生姓名：
lc
成功添加lc
请输入学生ID
2
请输入学生姓名：
shz
成功添加shz
请输入学生ID
3
请输入学生姓名：
cjl
成功添加cjl
容量3
1/lc
2/shz
3/cjl
请输入要查询的学生ID
1
在学生映射表中是否存在：true
对应的学生为：lc
请输入要查询的学生姓名
lc
包含学生：lc

Collection.sort()实现List()排序

-对List排序
-对List排序
-对List排序

字符串排序规则

-先数字后字母即【0-9】、【A-Z】、【a-z】
-从高位到低位即进行比较时，字符串“1000”比“200”小

Comparable and Comparator

-对象想要排序则必须是可以比较的
-Comparable即给对象定义默认的排序规则

-实现该接口表示：这个类的实例可以比较大小，进行自然排序
-定义了默认的比较规则
-其实现类需实现compareTo()方法
-compareTo()方法返回正数表示大，负数表示小，0表示相等

-Comparator临时比较规则

-比较工具的接口，用于定义临时比较规则，而不是默认比较规则
-其实现类需要实现compare()方法
-Comparable and Comparator都是Java集合框架成员

Student改动部分

public class Student implements Comparable<Student>{
//其余代码与之前相同不赘述
@Override
    public int compareTo(Student o) {
        // 将两个对象id的比较结果作为学生对象id的比较结果返回
        return this.id.compareTo(o.id);
    }
}

StudentComparator

import java.util.Comparator;

public class StudentComparator implements Comparator<Student> {

    @Override
    public int compare(Student o1, Student o2) {
        // 按照名字排序
        return o1.getName().compareTo(o2.getName());
    }

}

CollectionTest

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;

import org.omg.CORBA.PRIVATE_MEMBER;

/*
 * 1.通过Collection.sort()方法，对integer泛型的List进行排序；
 * 2.对String泛型的List进行排序；
 * 3.对其他类型的List进行排序。
 */
public class CollectionTest {

    /*
     * 通过Collection.sort()方法，对integer泛型的List进行排序； 插入十个100以内的随机数，调用sort()方法排序。
     */
    public void integerSort() {
        System.out.println("调用integerSort");
        List<Integer> integers = new ArrayList<Integer>();
        // 插入个以内的不重复随机整数
        Random random = new Random();
        Integer kInteger;
        for (int i = ; i < 10; i++) {
            do {
                kInteger = random.nextInt();
            } while (integers.contains(kInteger));
            integers.add(kInteger);
            System.out.println("成功添加：" + kInteger);
        }
        System.out.println("--------排序前----------");
        for (Integer integer : integers) {
            System.out.println(integer);
        }
        System.out.println("--------排序后----------");
        // 进行排序
        Collections.sort(integers);
        for (Integer integer : integers) {
            System.out.println(integer);
        }
    }

    /*
     * 对String进行排序 创建String泛型的List,添加三个乱序的String元素
     */
    public void stringSort() {
        System.out.println("调用stringSort");
        List<String> strings = new ArrayList<String>();
        strings.add("abc");
        strings.add("ggg");
        strings.add("hhd");
        System.out.println("--------排序前----------");
        for (String string : strings) {
            System.out.println(string);
        }
        System.out.println("--------排序后----------");
        /*
         *  排序,因为student本身尚未实现comparable接口，所以需要让student实现comparable接口
         *  并重写compareTo方法，否则会报错
         */
        Collections.sort(strings);
        for (String string : strings) {
            System.out.println(string);
        }
    }

    // 对Student进行排序
    public void studentSort(){
        System.out.println("调用studentSort");
        Set<Course> courses = new HashSet<Course>();
        List<Student> students = new ArrayList<Student>();
        students.add(new Student("1", "lc", courses));
        students.add(new Student("3", "shz", courses));
        students.add(new Student("2", "cjl", courses));
        System.out.println("--------排序前----------");
        for (Student student : students) {
            System.out.println(student.getId()+"/"+student.getName());
        }
        System.out.println("--------按id排序后----------");
        // 排序
        Collections.sort(students);
        for (Student student : students) {
            System.out.println(student.getId()+"/"+student.getName());
        }
        System.out.println("--------按name排序后----------");
        Collections.sort(students, new StudentComparator());
        for (Student student : students) {
            System.out.println(student.getId()+"/"+student.getName());
        }
    }

    public static void main(String[] args) {
        CollectionTest collectionTest = new CollectionTest();
        collectionTest.integerSort();
        collectionTest.stringSort();
        collectionTest.studentSort();
    }

}

调用integerSort
成功添加：29
成功添加：75
成功添加：60
成功添加：74
成功添加：39
成功添加：57
成功添加：11
成功添加：5
成功添加：0
成功添加：15
——–排序前———-
29
75
60
74
39
57
11
5
0
15
——–排序后———-
0
5
11
15
29
39
57
60
74
75
调用stringSort
——–排序前———-
abc
ggg
hhd
——–排序后———-
abc
ggg
hhd
调用studentSort
——–排序前———-
1/lc
3/shz
2/cjl
——–按id排序后———-
1/lc
2/cjl
3/shz
——–按name排序后———-
2/cjl
1/lc
3/shz