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 = 31;        int result = 1;        result = prime * result + ((name == null) ? 0 : 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(0);        System.out.println(temp.getId() + "/" + temp.getName());        Course course2 = new Course("2", "C语言");        /*         * 在可以访问的位置中插入数据，之前相应的数据位置往后移动一位 目前可访问的位置为0 若试图访问其他位置则会发生数组下标越界异常         */        listCourses.add(0, course2);        Course temp2 = listCourses.get(0);        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(2);        System.out.println(temp3.getId() + "/" + temp3.getName());        Course temp4 = listCourses.get(3);        System.out.println(temp4.getId() + "/" + temp4.getName());        Course[] courses2 = { new Course("5", "高等数学"), new Course("6", "大学英语") };        // 新添加的两门课程从2处插入        listCourses.addAll(2, Arrays.asList(courses2));        Course temp5 = listCourses.get(2);        System.out.println(temp5.getId() + "/" + temp5.getName());        Course temp6 = listCourses.get(3);        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(0);        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 = 0; i < 3; 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(0);        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 = 31;        int result = 1;        result = prime * result + ((name == null) ? 0 : 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 = 0;        while (i < 3) {            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>();        // 插入10个100以内的不重复随机整数        Random random = new Random();        Integer kInteger;        for (int i = 0; i < 10; i++) {            do {                kInteger = random.nextInt(100);            } 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

Java集合框架总结

-Collection接口

1. List
   -ArrayList
2. Set
   -HashSet
3. Collections工具类
   -Comparator接口
   -Comparable接口
4. Map接口