复习-java集合简记

1.集合概述

ava集合类存放于 java.util 包中，是一个用来存放对象的容器。

集合只能保存对象（实际上也是保存对象的引用变量）,Java主要由两个接口派生而出：Collection和Map，继承树如下：

Map体系结构树

2 Collection集合常用方法：

//我们这里将 ArrayList集合作为 Collection 的实现类

        Collection collection = new ArrayList();

        //添加元素

        collection.add("Tom");

        collection.add("Bob");

        //删除指定元素

        collection.remove("Tom");

        //删除所有元素

        Collection c = new ArrayList();

        c.add("Bob");

        collection.removeAll(c);

        //检测是否存在某个元素

        collection.contains("Tom");

        //判断是否为空

        collection.isEmpty();

        //利用增强for循环遍历集合

        for(Object obj : collection){

            System.out.println(obj);

        }

        //利用迭代器 Iterator

        Iterator iterator = collection.iterator();

        while(iterator.hasNext()){

            Object obj = iterator.next();

            System.out.println(obj);

        }

遍历集合可以通过Iterator或者foreach遍历集合

3 Set接口

hashset是最常用的实现类

1、Set hashSet = new HashSet();

　　①、HashSet:不能保证元素的顺序；不可重复；不是线程安全的；集合元素可以为 NULL;

　　②、其底层其实是一个数组，存在的意义是加快查询速度。我们知道在一般的数组中，元素在数组中的索引位置是随机的，元素的取值和元素的位置之间不存在确定的关系，因此，在数组中查找特定的值时，需要把查找值和一系列的元素进行比较，此时的查询效率依赖于查找过程中比较的次数。而 HashSet 集合底层数组的索引和值有一个确定的关系：index=hash(value),那么只需要调用这个公式，就能快速的找到元素或者索引。

　　③、对于 HashSet: 如果两个对象通过 equals() 方法返回 true，这两个对象的 hashCode 值也应该相同。

　　　1、当向HashSet集合中存入一个元素时，HashSet会先调用该对象的hashCode（）方法来得到该对象的hashCode值，然后根据hashCode值决定该对象在HashSet中的存储位置

　　　　　　1.1、如果 hashCode 值不同，直接把该元素存储到 hashCode() 指定的位置

　　　　　　1.2、如果 hashCode 值相同，那么会继续判断该元素和集合对象的 equals() 作比较

　　　　　　　　　　1.2.1、hashCode 相同，equals 为 true，则视为同一个对象，不保存在 hashSet（）中

　　　　　　　　　　1.2.2、hashCode 相同，equals 为 false，则存储在之前对象同槽位的链表上，这非常麻烦，我们应该约束这种情况，即保证：如果两个对象通过 equals() 方法返回 true，这两个对象的 hashCode 值也应该相同。

注意：每一个存储到哈希表中的对象，都得提供 hashCode() 和 equals() 方法的实现，用来判断是否是同一个对象

　　　对于 HashSet 集合，我们要保证如果两个对象通过 equals() 方法返回 true，这两个对象的 hashCode 值也应该相同。

LinkHashSet也是根据元素hashcode值决定存储位置，同时使用链表维护元素次序，会根据元素的添加顺序来访问集合的元素，性能低于HashSet的性能

treeSet是Sorted接口的唯一实现，可以确保元素处于排序状态，底层使用红黑树算法，擅长于范围查询。

* 如果使用 TreeSet() 无参数的构造器创建一个 TreeSet 对象, 则要求放入其中的元素的类必须实现 Comparable 接口所以, 在其中不能放入 null 元素

* 必须放入同样类的对象.(默认会进行排序) 否则可能会发生类型转换异常.我们可以使用泛型来进行限制

Set treeSet = new TreeSet();

treeSet.add(1); //添加一个 Integer 类型的数据

treeSet.add("a"); //添加一个 String 类型的数据

System.out.println(treeSet); //会报类型转换异常的错误

*　自动排序：添加自定义对象的时候，必须要实现 Comparable 接口，并要覆盖 compareTo(Object obj) 方法来自定义比较规则

　　　　如果 this > obj,返回正数 1

　　　　如果 this < obj,返回负数 -1

　　　　如果 this = obj,返回 0 ，则认为这两个对象相等

* 定制排序: 创建 TreeSet 对象时, 传入 Comparator 接口的实现类. 要求: Comparator 接口的 compare 方法的返回值和两个元素的 equals() 方法具有一致的返回值

public class TreeSetTest {

public static void main(String[] args) {

Person p1 = new Person(1);

Person p2 = new Person(2);

Person p3 = new Person(3);

Set<Person> set = new TreeSet<>(new Person());

set.add(p1);

set.add(p2);

set.add(p3);

System.out.println(set); //结果为[1, 2, 3]

}

class Person implements Comparator<Person>{

public int age;

public Person(){}

public Person(int age){

this.age = age;

}

@Override

/***

* 根据年龄大小进行排序

*/

public int compare(Person o1, Person o2) {

// TODO Auto-generated method stub

if(o1.age > o2.age){

return 1;

}else if(o1.age < o2.age){

return -1;

}else{

return 0;

}

@Override

public String toString() {

// TODO Auto-generated method stub

return ""+this.age;

}

EnumSet类

enum Season {

    SPRING, SUMMER, FALL, WINTER

}

public class EnumSetTest {

    public static void main(String[] args) {

        //创建一个EnumSet集合，集合元素就是Season枚举类的全部枚举值

        EnumSet es1 = EnumSet.allOf(Season.class);

        //输出[SPRING, SUMMER, FALL, WINTER]

        System.out.println(es1);

        //创建一个EnumSet空集合，指定其集合元素是Season类的枚举值

        EnumSet es2 = EnumSet.noneOf(Season.class);

        //输出[]

        System.out.println(es2);

        //手动添加两个元素

        es2.add(Season.WINTER);

        es2.add(Season.SPRING);

        //输出[Spring, WINTER]

        System.out.println(es2);

        //以指定枚举值创建EnumSet集合

        EnumSet es3 = EnumSet.of(Season.SUMMER, Season.WINTER);

        //输出[SUMMER, WINTER]

        System.out.println(es3);

　　　　　//创建一个包含两个枚举值范围内所有枚举值的EnumSet集合

        EnumSet es4 = EnumSet.range(Season.SUMMER, Season.WINTER);

        //输出[SUMMER, FALL, WINTER]s

        System.out.println(es4);

        //新创建的EnumSet集合元素和es4集合元素有相同的类型

        //es5集合元素 + es4集合元素=Season枚举类的全部枚举值

        EnumSet es5 = EnumSet.complementOf(es4);

        System.out.println(es5);

        //创建一个集合

        Collection c = new HashSet();

        c.clear();

        c.add(Season.SPRING);

        c.add(Season.WINTER);

        //复制Collection集合中的所有元素来创建EnumSet集合

        EnumSet es = EnumSet.copyOf(c);

        //输出es

        System.out.println(es);

        c.add("111");

        c.add("222");

        //下面代码出现异常，因为c集合里的元素不是全部都为枚举值

        es = EnumSet.copyOf(c);

    }

}

4 List接口

由于 List 接口是继承于 Collection 接口，所以基本的方法如上所示。

1、List 接口的三个典型实现：

　　①、List list1 = new ArrayList();

　　　　底层数据结构是数组，查询快，增删慢;线程不安全，效率高

　 ②、List list2 = new Vector();

　　　　底层数据结构是数组，查询快，增删慢;线程安全，效率低,几乎已经淘汰了这个集合

　 ③、List list3 = new LinkedList();

　　　　底层数据结构是链表，查询慢，增删快;线程不安全，效率高

怎么记呢？我们可以想象：

　　数组就像身上编了号站成一排的人，要找第10个人很容易，根据人身上的编号很快就能找到。但插入、删除慢，要望某个位置插入或删除一个人时，后面的人身上的编号都要变。当然，加入或删除的人始终末尾的也快。

　　链表就像手牵着手站成一圈的人，要找第10个人不容易，必须从第一个人一个个数过去。但插入、删除快。插入时只要解开两个人的手，并重新牵上新加进来的人的手就可以。删除一样的道理。

2、除此之外，List 接口遍历还可以使用普通 for 循环进行遍历，指定位置添加元素，替换元素等等。

//产生一个 List 集合，典型实现为 ArrayList

        List list = new ArrayList();

        //添加三个元素

        list.add("Tom");

        list.add("Bob");

        list.add("Marry");

        //构造 List 的迭代器

        Iterator it = list.iterator();

        //通过迭代器遍历元素

        while(it.hasNext()){

            Object obj = it.next();

            //System.out.println(obj);

        }

        //在指定地方添加元素

        list.add(2, 0);

        //在指定地方替换元素

        list.set(2, 1);

        //获得指定对象的索引

        int i=list.indexOf(1);

        System.out.println("索引为："+i);

        //遍历：普通for循环

        for(int j=0;j<list.size();j++){

             System.out.println(list.get(j));

        }

5 Map

1、Set hashSet = new HashSet();

　　①、HashSet:不能保证元素的顺序；不可重复；不是线程安全的；集合元素可以为 NULL;

　　③、对于 HashSet: 如果两个对象通过 equals() 方法返回 true，这两个对象的 hashCode 值也应该相同。

　　　　　　1.1、如果 hashCode 值不同，直接把该元素存储到 hashCode() 指定的位置

　　　　　　1.2、如果 hashCode 值相同，那么会继续判断该元素和集合对象的 equals() 作比较

　　　　　　　　　　1.2.1、hashCode 相同，equals 为 true，则视为同一个对象，不保存在 hashSet（）中

注意：每一个存储到哈希表中的对象，都得提供 hashCode() 和 equals() 方法的实现，用来判断是否是同一个对象

　　　对于 HashSet 集合，我们要保证如果两个对象通过 equals() 方法返回 true，这两个对象的 hashCode 值也应该相同。

2、Set linkedHashSet = new LinkedHashSet();

　　①、不可以重复，有序

　　因为底层采用链表和哈希表的算法。链表保证元素的添加顺序，哈希表保证元素的唯一性

3、Set treeSet = new TreeSet();

　　TreeSet:有序；不可重复，底层使用红黑树算法，擅长于范围查询。

　　* 如果使用 TreeSet() 无参数的构造器创建一个 TreeSet 对象, 则要求放入其中的元素的类必须实现 Comparable 接口所以, 在其中不能放入 null 元素

* 必须放入同样类的对象.(默认会进行排序) 否则可能会发生类型转换异常.我们可以使用泛型来进行限制

以上三个 Set 接口的实现类比较：

　　共同点：1、都不允许元素重复

　　　　　　2、都不是线程安全的类，解决办法：Set set = Collections.synchronizedSet(set 对象)

巴特西

复习-java集合简记

最新文章

热门文章