集合框架_DAY16

1:List及其子类(掌握)

　　    (1)List的特点：

　　　　    Collection

　　　　   |--List:元素有序(存入顺序和取出顺序一致),可重复。

　　　　   |--Set:元素无序,唯一。

　　    (2)List的特有功能：

　　     A:添加功能

　　 　   add(int index,Object obj)

　　  B:删除功能

　　　  remove(int index)

　　 C:获取功能

　　　     get(int index)

　　  D:修改功能

　　  　   set(int index,Object obj)

　　 (3)案例：

　　 　　  List存储字符串并遍历。

　　　　  List存储自定义对象并遍历。

注： 使用集合存储自定义对象的步骤：

　　　　  1）、定义要存储到集合当中的类

　　　　   2）、创建     集合<要存储到集合当中的类> 集合引用变量 = new 集合<要存储到集合当中的类>();

　　　　  3）、创建要存储到集合当中的类的对象们

　　　　   4）、调用集合方法，存储对应的对象

　　　　   5）、返回对应集合的迭代器

　　　　  6）、使用迭代器判断是否有下个元素

　　　　  7）、如果有下个元素则获取下个元素

　　 (4)List的三个子类的特点：

　　　　 List:

　　　　      |--ArrayList

　　　　　       底层数据结构是数组,查询快,增删慢。

　　　　           线程不安全,效率高。

　　　　   |--Vector

　　　　　底层数据结构是数组,查询慢,增删慢。

线程安全,效率低。所以一般不用。

　　　　     |--LinkedList

　　　　   底层数据结构是链表,查询慢,增删快。

线程不安全,效率高。

　　　　 到底使用谁?

　　　　 是否需要安全：

　　　　　　   是：Vector(将来其实也不用这个，会有更好的方式，后面提)

　　　　　　 否：用ArrayList或者LinkedList

　　如何查询多：ArrayList

　　如果增删多：LinkedList

　　　　 如果你根本就不知道用谁?用ArrayList。

　　 (6)List的三个儿子的各自特有功能：(了解)

　　　　  A:ArrayList

　　　　 B:Vector

　　　　    JDK1.0时候的功能。但是后来被替代。所以不用掌握。

　　　　 C:LinkedList

　　　　由于是链表，所以，操作开头和结尾比较简答。提高了添加，删除，获取开头或者结尾。

　　 (7)案例：

　　　　  Collection

　　　　　　   List

　　　　 　　　　 ArrayList

　　　　　　　　 Vector

　　　　　　　　  LinkedList

　      　对上述集合分别存储字符串和自定义对象并遍历。

　　  (8)遍历：

　　　　    Collection：迭代器（所有集合都适用）

　　　　       |--List：普通for

　　　        |--ArrayList

　　　      |--Vector   返回Enumeration

　　　        |--LinkedList

2:Set(掌握)

　　   (1)Set集合的特点:

　　　　 无序(存储和取出的顺序不一致),唯一。

　　    (2)HashSet

　　　　    如何保证元素的唯一性呢?

　　        底层数据结构是哈希表。哈希表依赖于哈希值。（集合中存储的对象所在的类的中hashCode()和equals()方法需要重写，才能保正元素的唯一性）

　　　      最终依赖两个方法hashCode()和equals()。

　　　　 比较顺序：

　　　　 先比较hashCode()值：

　　　相同：

　　 　　 继续走equals()方法，根据返回值：

　　　   true:说明元素重复。不添加。

　　     false:说明元素不重复，添加。

　　　 不同：就直接添加到集合。

　　　　    案例：

　　　　  HashSet存储字符串并遍历。(String类重写了hashCode()和equals())

　　　　  HashSet存储自定义对象并遍历。

　　　      存储Person对象，然后去掉重复值。(标准代码)

　　    (3)TreeSet(理解)

　　　　如何保证元素的唯一性?

　　　  根据返回值是否是0。

　　　　  如何保证元素的排序?

　　　　    A:自然排序(元素具备比较性)

　　　　　　 让元素所属的类实现Comparable接口

　　　　  　　 重写compareTo(T t)

　　　　 B:比较器排序(集合具备比较性)

　　　　　　  在创建集合对象的时候，传递Comparator接口的子类对象

　　　　　　  重写compare(T t,T t2)

　　　　　  案例：

　　　　　　TreeSet存储字符串并遍历。(String实现了Comparable接口)

　　　　　　   TreeSet存储自定义对象并遍历。

　　　　　   (标准代码 看懂就行)

　　　　　存储学生对象，要求保证唯一和排序(先比较年龄，再比较姓名)。

　　　  (4)LinkedHashSet：(理解)

　　　　 底层数据结构是哈希表和链表。

　　　　由哈希表保证元素唯一。

　　　　 由链表保证元素有序。

3:增强for(掌握)

　　  (1)是针对数组和Collection集合进行遍历的一种方式。

　　    (2)格式：

　　　　    for(数组或者Collection集合中的元素的数据类型 变量名 : 数组或者Collection集合对象) {

　　　　　　直接使用变量名即可，这个时候的变量名其实就是元素。

　　　　    }

　　注意：

　　      A:增强for的底层封装了迭代器的操作。

　　  B:在使用增强for的时候，请保证迭代目标不为null。

　　   C:增强for循环只能做展示数据的功能，不能修改数据。

附题：分别用ArrayList，LinkedList，HashSet，LinkeHashSet，TreeSet存储字符串和自定义对象并遍历

import java.util.*;

public class SetTest {
    //分别用ArrayList,LinkedList，HashSet，LinkeHashSet,TreeSet存储字符串和自定义对象并遍历。
    public static void main(String[] args) {

        System.out.println("ArrayList存储字符串和自定义对象并遍历:");
        // ArrayList存储字符串和自定义对象并遍历
        //字符串遍历
        ArrayList arrayList1 = new ArrayList();

        String str1 = "2杨幂";
        String str2 = "3柳岩";
        String str3 = "1哈哈";
        String str4 = "2杨幂";

        arrayList1.add(str1);
        arrayList1.add(str2);
        arrayList1.add(str3);
        arrayList1.add(str4);

        for (Object string : arrayList1) {
            System.out.println((String) string);
        }
        //自定义对象遍历
        ArrayList arrayList2 = new ArrayList();

        Person p1 = new Person(29, "2杨幂");
        Person p2 = new Person(27, "3柳岩");
        Person p3 = new Person(30, "1哈哈");
        Person p4 = new Person(29, "1杨幂");

        arrayList2.add(p1);
        arrayList2.add(p2);
        arrayList2.add(p3);
        arrayList2.add(p4);

        Iterator iterator = arrayList2.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        System.out.println("-----------------------");

        System.out.println("LinkedList存储字符串和自定义对象并遍历");
        //LinkedList存储字符串和自定义对象并遍历
        //字符串遍历
        LinkedList linkedList1 = new LinkedList();

        linkedList1.add(str1);
        linkedList1.add(str2);
        linkedList1.add(str3);
        linkedList1.add(str4);

        for (Object string : linkedList1) {
            System.out.println((String) string);
        }
        //自定义对象遍历
        LinkedList linkedList2 = new LinkedList();

        linkedList2.add(p1);
        linkedList2.add(p2);
        linkedList2.add(p3);
        linkedList2.add(p4);

        Iterator iterator1 = linkedList2.iterator();
        while (iterator1.hasNext()) {
            System.out.println(iterator1.next());
        }

        System.out.println("----------------------");

        System.out.println("HashSet存储字符串和自定义对象并遍历");
        //HashSet存储字符串和自定义对象并遍历
        //字符串对象遍历
        HashSet hashSet1 = new HashSet();

        hashSet1.add(str1);
        hashSet1.add(str2);
        hashSet1.add(str3);
        hashSet1.add(str4);

        for (Object string : hashSet1) {
            System.out.println(string);
        }

        //自定义对象并遍历
        HashSet hashSet2 = new HashSet();
        hashSet2.add(p1);
        hashSet2.add(p2);
        hashSet2.add(p3);
        hashSet2.add(p4);

        for (Object person : hashSet2) {
            System.out.println((Person) person);
        }

        System.out.println("----------------------");
        System.out.println("LinkeHashSet存储字符串和自定义对象并遍历");
        //LinkeHashSet存储字符串和自定义对象并遍历

        //字符串遍历
        LinkedHashSet linkedHashSet1 = new LinkedHashSet();

        linkedHashSet1.add(str1);
        linkedHashSet1.add(str2);
        linkedHashSet1.add(str3);
        linkedHashSet1.add(str4);

        for (Object string : linkedHashSet1) {
            System.out.println((String) string);
        }

        //自定义对象并遍历
        LinkedHashSet linkedHashSet2 = new LinkedHashSet();

        linkedHashSet2.add(p1);
        linkedHashSet2.add(p2);
        linkedHashSet2.add(p3);
        linkedHashSet2.add(p4);

        for (Object person : linkedHashSet2) {
            System.out.println((Person) person);
        }

        System.out.println("-----------------------");
        System.out.println("TreeSet存储字符串和自定义对象并遍历");
        //TreeSet存储字符串和自定义对象并遍历
        //字符串遍历
        TreeSet treeSet = new TreeSet();

        treeSet.add(str1);
        treeSet.add(str2);
        treeSet.add(str3);
        treeSet.add(str4);

        for (Object string : treeSet) {
            System.out.println(string);
        }

        //自定义对象并遍历
        TreeSet treeSet2 = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Person p1=(Person)o1;
                Person p2=(Person)o2;
                int result=0;
                result=p1.getAge()-p2.getAge();
                if(result==0){
                    result=p1.getName().compareTo(p2.getName());
                }

                return result;
            }
        });

        treeSet2.add(p1);
        treeSet2.add(p2);
        treeSet2.add(p3);
        treeSet2.add(p4);

        for (Object person : treeSet2) {
            System.out.println((Person) person);
        }

    }
}

public class Person implements Comparable {
    //属性
    int age;
    String name;

    //构造器

    public Person() {

    }

    public Person(String name){
        this.name=name;
    }

    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }

    //方法
    public int getAge(){
        return  age;
    }

    public String getName(){
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Person person = (Person) o;

        if (age != person.age) return false;
        return name != null ? name.equals(person.name) : person.name == null;

    }

    @Override
    public int hashCode() {
        int result = age;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        return result;
    }

    /*@Override
    //先比较年龄，在比较姓名
    public int compareTo(Object o) {
        Person p=(Person) o;
        int result=0;
        result=this.age-p.age;

        if(result==0){
            result=this.name.compareTo(p.getName());
        }

        return result;
    }*/

    @Override
    //先比较姓名，再比价年龄
    public int compareTo(Object o) {
        Person p=(Person) o;
        int result=0;
        result=this.name.compareTo(p.name);

        if(result==0){
            result=this.age-p.age;
        }

        return result;
    }
}