集合框架_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;

    }

}

巴特西

集合框架_DAY16

最新文章

热门文章