Java中的集合之Collection的子接口

最新推荐文章于 2024-04-20 11:21:39 发布

一个木木的笨蛋

最新推荐文章于 2024-04-20 11:21:39 发布

阅读量184

点赞数

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/ganfanqiang/article/details/107178014

版权

JavaSE 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

一、List接口

1、List存储数据的特点

存储序有序的、可重复的数据。

鉴于Java中数组用来存储数据的局限性，我们通常使用List替代数组
List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。
List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
JDK AP中List接口的实现类常用的有：ArrayList、LinkedList和 Vector.

2、常用方法

List除了从 Collection集合继承的方法外，List集合里添加了一些根据索引来操作集合元素的方法。

void add(int index, Object ele):在index位置插入ele元素
boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
Object get(int index):获取指定index位置的元素
int indexOf(Object obj):返回obj在集合中首次出现的位置
int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
Object remove(int index):移除指定index位置的元素，并返回此元素
Object set(int index, Object ele):设置指定index位置的元素为ele
List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合

方法总结：

增：add(Object obj)
删：remove(int index) / remove(Object obj)
改：set(int index, Object ele)
查：get(int index)
插：add(int index, Object ele)
长度：size()
遍历： ① Iterator迭代器方式② foreach（增强for循环） ③ 普通的循环

3、List常用实现类

|----Collection接口：单列集合，用来存储一个一个的对象
 	 |----List接口：存储序的、可重复的数据。  -->“动态”数组,替换原的数组
	      |----ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储
	      |----LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
	      |----Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储

3.1、ArrayList

ArrayList是List接口的典型实现类、主要实现类
本质上，ArrayList是对象引用的一个”变长”数组
Array Listi的JDK 1.8之前与之后的实现区别？
- JDK 1.7：ArrayList像饿汉式，直接创建一个初始容量为10的数组
- JDK 1.8：ArrayList像懒汉式，一开始创建一个长度为0的数组，当添加第一个元素时再创建一个始容量为10的数组
Arrays.asList（…）方法返回的List集合，既不是 ArrayList实例，也不是Vector实例。Arrays.asList（…）返回值是一个固定长度的List集合

3.1.1源码分析

3.1.1 JDK 7.0情况下

ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData
list.add(123);//elementData[0] = new Integer(123);
...
list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容。

默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。
结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)

3.1.2 JDK 8.0中ArrayList的变化：

ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}.并没创建长度为10的数组
list.add(123);//第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]
...

后续的添加和扩容操作与JDK 7.0 无异。

3.1.3 小结：

JDK 7.0中的ArrayList的对象的创建类似于单例的饿汉式，而JDK 8.0中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。

3.2、LinkedList

对与对于频繁的插入和删除元素操作，建议使用LinkedList类，效率更高
新增方法：
- void addFirst(Object obj)
- void addLast(Object obj)
- Object getFirst()
- Object getlast)()
- Object removeFirst()
- Object removeLast()
Linkedlist：双向链表，内部没有声明数组，而是定义了Node类型的frst和last，用于记录首末元素。同时，定义内部类Node，作为Linkedlist中保存数据的基本结构。Node除了保存数据，还定义了两个变量：
- prev变量记录前一个元素的位置
- next变量记录下一个元素的位置

3.2.1 源码分析

LinkedList list = new LinkedList(); //内部声明了Node类型的first和last属性，默认值为null
list.add(123);//将123封装到Node中，创建了Node对象。

//其中，Node定义为：体现了LinkedList的双向链表的说法
private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

3.3、Vector

Vector是一个古老的集合，JDK 1.0就有了。大多数操作与ArrayList相同，区别在于Vector是线程安全的
在各种list中，最好把ArrayList作为缺省选择。当插入、删除频繁时，使用LinkedList；Vector总是比ArrayList慢，所以尽量避免选择使用。
JDK 7.0和JDK 8.0中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。
在扩容方面，默认扩容为原来的数组长度的2倍。

3.4、常见问题

请问 ArrayList/LinkedList/Vector的异同？谈谈你的理解？ArrayList底层是什么？扩容机制？ Vector和 ArrayList的最大区别？

ArrayList和 Linkedlist的异同：
二者都线程不安全，相比线程安全的 Vector，ArrayList执行效率高。此外，ArrayList是实现了基于动态数组的数据结构，Linkedlist基于链表的数据结构。对于随机访问get和set，ArrayList觉得优于Linkedlist，因为Linkedlist要移动指针。对于新增和删除操作add（特指插入）和 remove，Linkedlist比较占优势，因为 ArrayList要移动数据。
ArrayList和 Vector的区别：
Vector和ArrayList几乎是完全相同的，唯一的区别在于Vector是同步类(synchronized)，属于强同步类。因此开销就比 ArrayList要大，访问要慢。正常情况下，大多数的Java程序员使用ArrayList而不是Vector，因为同步完全可以由程序员自己来控制。Vector每次扩容请求其大小的2倍空间，而ArrayList是1.5倍。Vector还有一个子类Stack.

二、Set接口

1、存储数据的特点

存储无序的，不可重复的数据
具体：
以HashSet为例说明：

无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的。
不可重复性：保证添加的元素照equals()判断时，不能返回true。即，相同的元素只能添加一个。

2、元素添加过程（以HashSet为例）

我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断

数组此位置上是否已经有元素：

如果此位置上没有其他元素，则元素a添加成功。 —>情况1
如果此位置上有其他元素b(或以链表形式存在的多个元素），则比较元素a与元素b的hash值：
- 如果hash值不相同，则元素a添加成功。—>情况2
- 如果hash值相同，进而需要调用元素a所在类的equals()方法：
  - equals()返回true,元素a添加失败
  - equals()返回false,则元素a添加成功。—>情况3
    对于添加成功的情况2和情况3而言：元素a 与已经存在指定索引位置上数据以链表的方式存储。

JDK 7.0 :元素a放到数组中，指向原来的元素。

JDK 8.0 :原来的元素在数组中，指向元素a

总结：七上八下

HashSet底层：数组+链表的结构。（JDK 7.0以前）
在这里插入图片描述

3、常用方法

Set接口中没额外定义新的方法，使用的都是Collection中声明过的方法。

4、常用实现类

|----Collection接口：单列集合，用来存储一个一个的对象
  |----Set接口：存储无序的、不可重复的数据   -->高中讲的“集合”
       |----HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null值
            |----LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历，对于频繁的遍历操作，LinkedHashSet效率高于HashSet.
       |----TreeSet：可以按照添加对象的指定属性，进行排序。

4.1、HashSet

Hashset是Set接口的典型实现，大多数时候使用Set集合时都使用这个实现类。
HashSet按Hash算法来存储集合中的元素，因此具有很好的存取、查找、删除性能。
HashSet具有以下特点：
- 不能保证元素的排列顺序
- HashSet不是线程安全的
- 集合元素可以是nul
HashSet集合判断两个元素相等的标准：两个对象通过hashCode()方法比较相等，并且两个对象的equals()方法返回值也相等。
对于存放在Set容器中的对象，对应的类一定要重写equals()和hashCode(Object obj)方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码”

4.2、LinkedHashSet

LinkedhashSet是HashSet的子类
LinkedhashSet根据元素的hashCode值来决定元素的存储位置但它同时使用双向链表维护元素的次序，这使得元素看起来是以插入顺序保存的。
LinkedhashSet插入性能略低于HashSet，但在迭代访问Set里的全部元素时有很好的性能。
LinkedhashSet不允许集合元素重复。

在这里插入图片描述

4.3、TreeSet

Treeset是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态。
TreeSet底层使用红黑树结构存储数据
新增的方法如下：（了解）
- Comparator comparator()
- Object first()
- Object last()
- Object lower(object e)
- Object higher(object e)
- SortedSet subSet(fromElement， toElement)
- SortedSet headSet(toElement)
- SortedSet tailSet(fromElement)
TreeSet两种排序方法：自然排序和定制排序。默认情况下，TreeSet采用自然排序。

红黑树图示：
在这里插入图片描述

5、存储对象所在类的要求

5.1、HashSet、LinkedHashSet

要求：向Set(主要指：HashSet、LinkedHashSet)中添加的数据，其所在的类一定要重写hashCode()和equals()
要求：重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码

重写两个方法的小技巧：对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值。

5.2、TreeSet

自然排序中，比较两个对象是否相同的标准为：compareTo()返回0.不再是equals().
定制排序中，比较两个对象是否相同的标准为：compare()返回0.不再是equals().

6、TreeSet的使用

6.1、使用说明：

向TreeSet中添加的数据，要求是相同类的对象。
两种排序方式：自然排序（实现Comparable接口和定制排序（Comparator）

6.2、常用的排序方式

方式一：自然排序

自然排序：TreeSet会调用集合元素的compareTo(object obj)方法来比较元素之间的大小关系，然后将集合元素按升序（默认情况）排列
如果试图把一个对象添加到Treeset时，则该对象的类必须实现Comparable接口。
- 实现Comparable的类必须实现compareTo(Object obj)方法，两个对象即通过compareTo(Object obj)方法的返回值来比较大小
Comparable的典型实现:
- BigDecimal、BigInteger以及所有的数值型对应的包装类：按它们对应的数值大小进行比较
- Character：按字符的unic！ode值来进行比较
- Boolean：true对应的包装类实例大于fase对应的包装类实例
- String：按字符串中字符的unicode值进行比较
- Date、Time：后边的时间、日期比前面的时间、日期大
向TreeSet中添加元素时，只有第一个元素无须比较compareTo()方法，后面添加的所有元素都会调用compareTo()方法进行比较。
因为只有相同类的两个实例才会比较大小，所以向 TreeSet中添加的应该是同一个类的对象。对于TreeSet集合而言，它判断两个对象是否相等的唯一标准是：两个对象通过compareTo(Object obj)方法比较返回值。
当需要把一个对象放入TreeSet中，重写该对象对应的equals()方法时，应保证该方法与compareTo(Object obj)方法有一致的结果：如果两个对象通过equals()方法比较返回true，则通过compareTo(object ob)方法比较应返回0。否则，让人难以理解。

@Test
public void test1(){
    TreeSet set = new TreeSet();

    //失败：不能添加不同类的对象
    //        set.add(123);
    //        set.add(456);
    //        set.add("AA");
    //        set.add(new User("Tom",12));

    //举例一：
    //        set.add(34);
    //        set.add(-34);
    //        set.add(43);
    //        set.add(11);
    //        set.add(8);

    //举例二：
    set.add(new User("Tom",12));
    set.add(new User("Jerry",32));
    set.add(new User("Jim",2));
    set.add(new User("Mike",65));
    set.add(new User("Jack",33));
    set.add(new User("Jack",56));


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

}

方式二：定制排序

TreeSet的自然排序要求元素所属的类实现Comparable接口，如果元素所属的类没有实现 Comparable接口，或不希望按照升序（默认情况）的方式排列元素或希望按照其它属性大小进行排序，则考虑使用定制排序。定制排序，通过 Comparator接口来实现。需要重写 compare(T o1，T o2)方法。
利用int compare(T o1，T o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示o1小于o2。
要实现定制排序，需要将实现Comparator接口的实例作为形参传递给TreeSet的构造器。
此时，仍然只能向Treeset中添加类型相同的对象。否则发生 ClassCastException异常
使用定制排序判断两个元素相等的标准是：通过 Comparator比较两个元素返回了0

@Test
public void test2(){
    Comparator com = new Comparator() {
        //照年龄从小到大排列
        @Override
        public int compare(Object o1, Object o2) {
            if(o1 instanceof User && o2 instanceof User){
                User u1 = (User)o1;
                User u2 = (User)o2;
                return Integer.compare(u1.getAge(),u2.getAge());
            }else{
                throw new RuntimeException("输入的数据类型不匹配");
            }
        }
    };

    TreeSet set = new TreeSet(com);
    set.add(new User("Tom",12));
    set.add(new User("Jerry",32));
    set.add(new User("Jim",2));
    set.add(new User("Mike",65));
    set.add(new User("Mary",33));
    set.add(new User("Jack",33));
    set.add(new User("Jack",56));

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

一个木木的笨蛋

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java中的集合之Collection的子接口

一、List接口1、List存储数据的特点存储序有序的、可重复的数据。鉴于Java中数组用来存储数据的局限性，我们通常使用List替代数组List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。JDK AP中List接口的实现类常用的有：ArrayList、LinkedList和 Vector.2、常用方法List除了从 Collection集合继承的方法外，List集合里添加
复制链接

扫一扫