集合是否包含某些元素，获取元素索引位置，元素排序（三）

判断集合是否包含某个元素

List

boolean containsAll(Collection<?> c)：如果列表包含指定 collection 的所有元素，则返回 true。
boolean contains(Object o)：如果列表包含指定的元素，则返回 true。实现原理：遍历list中的每一个元素，然后调用每一个元素的equals(obj)方法 ，如果有一个元素的equals方法返回true值，该方法就返回true值，否则返回false。

某个list中是否包含某个对象，对象的类型是存入的类型。

// 取得备选课程序列的第0个元素
Course course = coursesToSelect.get(0);
//coursesToSelected是否包含course对象，结果是包含                
coursesToSelect.contains(course));

创建一个新的对象，此对象与list中的某个对象有相同的属性值，但他们是两个不同的对象，所以调用返回值是false。

通过对象中的某个属性值判断list中是否包含某个元素，根据方法的原理，需要重写equals方法。

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 true;
            else
                return false;
        } else {
            if (name.equals(other.name))
                return true;
            else
                return false;
        }
    }
}

Scanner console= new Scanner(System.in);
// 提示输入课程名称
System.out.println("请输入课程名称：");
String name = console.next();
Course course2 = new Course();
course2.name = name;
System.out.println("备选课程中是否包含课程：" + course2.name + ", "+coursesToSelect.contains(course2));

Set

boolean containsAll(Collection<?> c)：如果此 set 包含指定 collection 的所有元素，则返回 true。如果指定的 collection 也是一个 set，那么当该 collection 是此 set 的 子集 时返回 true。
boolean contains(Object o):如果 set 包含指定的元素，则返回 true。实现机制：调用该方法时，先调用每一个元素的hashCode()来访问哈希码，如果哈希码相等，之后在调用equals(obj),如果这两个方法的返回值都是相等，才相等。

通过对象中的某个属性值判断list中是否包含某个元素，根据方法的原理，需要重写equals方法，和hashCode方法。他们的书写可以通过eclipse快速生成。
快速生成：打开需要重写的类，在空白处右击–>Source–>Generate hashCode() and equals….，在弹出的页面中勾选作为判断的属性，点击ok即可。

测试是否包含的方法和list一样。

List获取元素的索引位置

int indexOf(Object o) ：返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。实现机制：从序列的第0个位置开始，依次循环并调用每一个元素的equals方法和参数对象进行比较，如果某一个元素的equals方法返回true,就把该元素的索引位置返回，多个重复只返回第一次出现的索引位置。
int lastIndexOf(Object o) ：返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1，从尾往头进行遍历。

if (coursesToSelect.contains(course2))
System.out.println("课程：" + course2.name + "的索引位置为：" + coursesToSelect.indexOf(course2));

Map是否包含某个key值或者value值
boolean containsKey(Object key):如果此映射包含指定键的映射关系，则返回 true。
boolean containsValue(Object value):如果此映射将一个或多个键映射到指定值，则返回 true,与list的contains一样，也需要重写equals(obj)方法。

public void testContainsKeyOrValue() {
        System.out.println("请输入要查询的学生ID：");
        Scanner console = new Scanner(System.in);
        String id = console.next();
        // 在Map中，用containsKey()方法，来判断是否包含某个Key值
        System.out.println("您输入的学生ID为：" + id + "，在学生映射表中是否存在："
                + students.containsKey(id));
        System.out.println("请输入要查询的学生姓名：");
        String name = console.next();
        // 用containsValue()方法，来判断是否包含某个Value值
        if (students.containsValue(new Student(null,name)))
            System.out.println("在学生映射表中，确实包含学生：" + name);
        else
            System.out.println("在学生映射表中不存在该学生！");
    }

List排序

Collections工具类：是Java集合框架中，用来操作集合对象的工具类，也是Java集合框架的成员，运用其中的sort()排序，排序的前提是排序的元素是可以比较的。
public static <T extends Comparable<? super T>> void sort(List<T> list)：根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable。
public static void sort(List list,Comparator

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

String字符串的排序规则：从首字母开始按照0-9，A-Z，a-z的顺序进行大小比较，如果第一个字母相同，则看第二个，之后的比较都是相同的方式进行。

    /**
     * 对String泛型的List进行排序；
     * 创建String泛型的List，添加三个乱序的String元素，
     * 调用sort方法，再次输出排序后的顺序
     */
    public void testSort2() {
        List<String> stringList = new ArrayList<String>();
        stringList.add("microsoft");
        stringList.add("google");
        stringList.add("lenovo");
        System.out.println("------------排序前-------------");
        for (String string : stringList) {
            System.out.println("元素：" + string);
        }
        Collections.sort(stringList);
        System.out.println("--------------排序后---------------");
        for (String string : stringList) {
            System.out.println("元素：" + string);
        }
    }

对其他类型泛型的List进行排序，以Student为例，直接运用sort方法会报错，是因为该方法的前提是必须实现Comparable接口，而Student类没有实现。
1.使其实现Comparable接口，实现compateTo()方法

public int compareTo(Student o) {
    //排序的规则，按照id排
    return this.id.compareTo(o.id);
    }
Collections.sort(studentList);

2.新建一个类实现Comparator接口并实现compare()方法

public int compare(Student o1, Student o2) {
   //按照name排   
    return o1.name.compareTo(o2.name);
    }
Collections.sort(studentList, new StudentComparator());

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

Comparator接口-比较工具接口：临时比较规则
用于定义临时比较规则，而不是默认比较规则。
Comparator的实现类必须实现compare()方法。
Comparable和Comparator都是java集合框架的成员。