多用多学之Java中的Set，List，Map

很长时间以来一直代码中用的比较多的数据列表主要是List，而且都是ArrayList，感觉有这个玩意就够了。ArrayList是用于实现动态数组的包装工具类，这样写代码的时候就可以拉进拉出，迭代遍历，蛮方便的。

也不知道从什么时候开始慢慢的代码中就经常会出现HashMap和HashSet之类的工具类。应该说HashMap比较多一些，而且还是面试经典题，平时也会多看看。开始用的时候简单理解就是个键值对应表，使用键来找数据比较方便。随后深入了解后发现这玩意还有点小奥秘，特别是新版本的JDK对HashMap的改成树后，代码都有点小复杂咯。

Set开始用的较少，只是无意中在一个代码中发现一个TreeSet，发现这个类可以自带顺利，感觉蛮有点意思，才慢慢的发现这也是个好工具啊。

代码写的多了就感觉到基础的重要性，所以在此写一篇小文简单的整理一下对集合的一些知识。

好了，简单的整理一下：

  • List：即是列表，支持数组、链表的功能，一般都是线性的
  • Map：即是映射表，存储的是键与值的对应关系
  • Set：即是集合的意思，主要是用于排重数据及排序

先来看看List

List是用于存放线性数据的一种窗口，比如：用于数组的ArrayList和用于链表的LinkedList。

ArrayList

这是一个数组列表，不过提供了自动扩容的功能，实现List接口，外部操作都是通过接口申明的方法访问，这样即安全又方便。

ArrayList的关键就是自动扩容，在对象初始化时可以设定初始容量，也可以按默认的容量。如果对数组大小没有特别明确可以不指定初始大小，如果明确的话可以指定一个大小，这样减少动态扩容时产生的卡顿。说到这就要说一下扩容是怎么实现的了，看下面的代码：


1

2

3

4

5

6

7

8

9

10

11

    private void grow(int minCapacity) {

        // overflow-conscious code

        int oldCapacity = elementData.length;

        int newCapacity = oldCapacity + (oldCapacity >> 1);

        if (newCapacity - minCapacity < 0)

            newCapacity = minCapacity;

        if (newCapacity - MAX_ARRAY_SIZE > 0)

            newCapacity = hugeCapacity(minCapacity);

        // minCapacity is usually close to size, so this is a win:

        elementData = Arrays.copyOf(elementData, newCapacity);

    }

grow是在ArrayList在添加元素或者一些容易检查时会触发的一个方法。主要过程：

1、得到数组的长度，并对其进行右移，这样就相当于oldCapacity/2，得到新的长度

2、如果这个长度小于最小容量那么直接就用最小容易

3、如果大于了最大容易则取一个最大值，这里会调用一个hugeCapacity方法，主要是比较minCapacity与MAX_ARRAY_SIZE的，如果minCapacity大于MAX_ARRAY_SIZE则取Integer.MAX_VALUE，否则就取MAX_ARRAY_SIZE，有意思的是MAX_ARRAY_SIZE取的是Integer.MAX_VALUE - 8;并不知道这样做的意义是什么

4、最后就是调用一个复制方法将现有数复制到一个新的数组中。

因为有这个复制过程，如果数组比较大，那么老是触发扩容当然就会出现卡顿的情况。所以如果一开始就知道最大值而且很容易增长到这个值，那么开始初始化时就指定大小会有一定的作用。

LinkedList

这是针对链表的工具类，链表的优秀是添加删除啥的比较快，但是查找会慢一些。

至于代码好像也没什么特别的，就是一串指针链接起来，当然Java中就使用对象来代替，建立一个Node的对象，Node本身指向了前一个Node和后一个Node，这就是链表的结构：


1

2

3

4

5

6

7

8

9

10

11

    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;

        }

    }

然后用两个Node指向头和尾就完成了，下面的代码：


1

2

3

4

5

6

7

8

9

10

11

12

13

    /**

     * Pointer to first node.

     * Invariant: (first == null && last == null) ||

     *            (first.prev == null && first.item != null)

     */

    transient Node<E> first;

    /**

     * Pointer to last node.

     * Invariant: (first == null && last == null) ||

     *            (last.next == null && last.item != null)

     */

    transient Node<E> last;

看一个add操作：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

    /**

     * Links e as last element.

     */

    void linkLast(E e) {

        final Node<E> l = last;

        final Node<E> newNode = new Node<>(l, e, null);

        last = newNode;

        if (l == null)

            first = newNode;

        else

            l.next = newNode;

        size++;

        modCount++;

    }

过往就是：

1、获取到最后的Node并放在l中

2、创建一个新的Node，将数据取到这个Node中，创建过程会将新Node的prev指向l，这样就接上了链

3、然后将last指向这个新Node

4、然判断l是否null，如果是null说明是空链表，新node就是第一个元素，这样first也要指向newNode

5、如果不为空则将l的next指向newNode

6、累加计数器

删除操作也是这种Node的前后Node指向移动操作。

再来看看Map

Map是键与值做一个映射表的应用，主要的实现类：HashMap,HashTable,TreeMap

HashMap和HashTable

使用hash算法进行键值映射的就是HashMap啦，HashTable是带有同步的线程安全的类，它们两主要的区别就是这个。原理也类似，都是通过桶+链来组合实现。桶是用来存Key的，而由于Hash碰撞的原因值需要用一个链表来存储。

  • 桶的意义在于高效，通过Hash计算可以一步定位
  • 链表的意义在于存取重复hash的数据

具体的原理以前写过一篇《学习笔记：Hashtable和HashMap》

只不过看JDK1.8的HashMap换了存储结构，采用红黑树的结构，这样可能是解决链表查找效率问题吧？具体没有细研究。

TreeMap

看过TreeMap的代码后发现还是使用的树结构，红黑树。由于红黑树是有序的，所以自然带排序功能。当然也可通过comparator来指定比较方法来实现特定的排序。

因为采用了树结构存储那么添加和删除数据时会麻烦一些，看一下put的代码：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

public V put(K key, V value) {

        Entry<K,V> t = root;

        if (t == null) {

            compare(key, key); // type (and possibly null) check

            root = new Entry<>(key, value, null);

            size = 1;

            modCount++;

            return null;

        }

        int cmp;

        Entry<K,V> parent;

        // split comparator and comparable paths

        Comparator<? super K> cpr = comparator;

        if (cpr != null) {

            do {

                parent = t;

                cmp = cpr.compare(key, t.key);

                if (cmp < 0)

                    t = t.left;

                else if (cmp > 0)

                    t = t.right;

                else

                    return t.setValue(value);

            } while (t != null);

        }

        else {

            if (key == null)

                throw new NullPointerException();

            @SuppressWarnings("unchecked")

                Comparable<? super K> k = (Comparable<? super K>) key;

            do {

                parent = t;

                cmp = k.compareTo(t.key);

                if (cmp < 0)

                    t = t.left;

                else if (cmp > 0)

                    t = t.right;

                else

                    return t.setValue(value);

            } while (t != null);

        }

        Entry<K,V> e = new Entry<>(key, value, parent);

        if (cmp < 0)

            parent.left = e;

        else

            parent.right = e;

        fixAfterInsertion(e);

        size++;

        modCount++;

        return null;

    }

1、先是检查根节点是否存在，不存在说明是第一条数据，直接作为树的根

2、判断是否存在比较器，如果存在则使用比较器进行查找数据的存放位置，如果比较器返回结果小于0取左，大于0取右，否则直接替换当前节点的值

3、如果不存在比较器则key直接与节点的key比较，比较和前面方法一样

4、接下来就是在找到的parent上创建一个子节点，并放入左或者右子节点中

5、fixAfterInsertion是对节点进行着色

6、累加器处理

在remove操作时也会有点麻烦，除了删除数据外，还要重新平衡一下红黑树。

另外，TreeMap实现了NavigableMap<K,V>接口，所以也提供了对数据集合的一些返回操作。

最后看看Set

Set主要是两类应用：HashSet和TreeSet。

HashSet

字面意思很明确，使用了Hash的集合。这种集合的特点就是使用Hash算法存数据，所以数据不重复，存取都相对较快。怎么做到的呢？


1

2

3

4

    public boolean add(E e) {

        return map.put(e, PRESENT)==null;

    }

   

原来是存在一个map对象中，再看map是个啥？


1

private transient HashMap<E,Object> map;

是个HashMap，了解HashMap的就明白，这样的数据是不会重复的。因为存入时是鼗对象本身作为Key来存的，所以在HashMap中只会存在一份。

了解了这点其他的东西就非常明白了。

TreeSet

这个集合是用于对集合进行排序的，也就是除了带有排重的能力外，还可以自带排序功能。只不过看了TreeSet的代码发现，其就是在TreeMap的基础实现的。更准确的说应该是NavigableMap的派生类。默认不指定map情况下TreeSet是以TreeMap为基础的。


1

2

3

    public TreeSet() {

        this(new TreeMap<E,Object>());

    }

所以，这里可能更关注的是TreeSet是如何排重呢？看一下add的方法吧：


1

2

3

    public boolean add(E e) {

        return m.put(e, PRESENT)==null;

    }

和HashSet有点类似，都是基于Map的特性来实现排重。确实简单而且有效。

时间： 2024-10-11 17:20:47

多用多学之Java中的Set，List，Map的相关文章

Java中的Collection和Map(二)--List体系

正如我们在Java中的Collection和Map(一)中所看到的那样,我们经常使用的有ArrayList.LinkedList.Vector.Stack.这里不再累述它们的使用方法,这里主要是说一下他们的底层结构以及使用时机. 1.ArrayList 我们都知道ArrayList是我们经常使用的List集合之一.我们在使用的时候经常通过 new ArrayList() 方法来创建一个ArrayList集合,然后调用它的 add(E e) 方法向集合中存储元素.那么你是否了解当我们使用 new

Java中集合List，Map和Set的区别

Java中集合List,Map和Set的区别 1.List和Set的父接口是Collection,而Map不是 2.List中的元素是有序的,可以重复的 3.Map是Key-Value映射关系,且Key不能重复 4.Set中的元素是无序的,不可重复的

JAVA中Collection接口和Map接口的主要实现类

Collection接口 Collection是最基本的集合接口,一个Collection代表一组Object,即Collection的元素(Elements).一些Collection允许相同的元素而另一些不行.一些能排序而另一些不行.Java SDK不提供直接继承自Collection的类,Java SDK提供的类都是继承自Collection的“子接口”如List和Set. 所有实现Collection接口的类都必须提供两个标准的构造函数:无参数的构造函数用于创建一个空的Collectio

Java中的集合框架-Map

前两篇<Java中的集合框架-Commection(一)>和<Java中的集合框架-Commection(二)>把集合框架中的Collection开发常用知识点作了一下记录,从本篇开始,对集合框架里的另外一部分Map作一下记录. 一,集合框架的Map接口 Map与Collection不同之处在于它是以键值对来存储数据: Map比较常用的实现类有四个:HashTable,HashMap,LinkedHashMap,TreeMap: Map的方法也可以分为四类,增删改查,大致如下: 新

Java中四种遍历Map对象的方法

方法一:在for-each循环中使用entry来遍历,通过Map.entrySet遍历key和value,这是最常见的并且在大多数情况下也是最可取的遍历方式.在键值都需要时使用. Map<Integer,Integer> map = new HashMap<Integer,Integer>(); for(Map.Entry<Integer,Integer> entry:map.entrySet()){ System.out.println("key="

Java中的Collection和Map(五)--PriorityQueue

PriorityQueue java api给出的定义: 一个基于优先级堆的无界优先级队列.优先级队列的元素按照其自然顺序进行排序,或者根据构造队列时提供的 Comparator 进行排序,具体取决于所使用的构造方法.优先级队列不允许使用 null 元素.依靠自然顺序的优先级队列还不允许插入不可比较的对象(这样做可能导致 ClassCastException). 此队列的头 是按指定排序方式确定的最小 元素.如果多个元素都是最小值,则头是其中一个元素——选择方法是任意的.队列获取操作 poll.

Java中集合(List,Set,Map)

ArrayList 和Vector是采用数组方式存储数据,此数组元素数大于实际存储的数据以便增加和插入元素,都允许直接序号索引元素,但是插入数据要设计到数组元素移动等内存操作,所以索引数据快插入数据慢,Vector由于使用了synchronized方法(线程安全)所以性能上比ArrayList要差,LinkedList使用双向链表实现存储,按序号索引数据需要进行向前或向后遍历,但是插入数据时只需要记录本项的前后项即可,所以插入数度较快! 线性表,链表,哈希表是常用的数据结构,在进行Java开发时

JAVA中的Api的Map

1.0  Map是一对一对的存在,不能直接用迭代器进行操作,必须想转换成Set其中分为(keySet与entrySet两种)类型,然后才能用迭代器,进行取出的操作. (1)  eg:,建立一个Set子类的一个容器--keySet.然后将存入的Map元素转换成keySet中的元素,然后就能用迭代器进行全部取出了. (2)eg: ,keySet同样的可以用迭代器进行元素的取出.它包含键和值两种元素.它的取出方式为:通过“键”来得与其对应的“值”.然后就可以将Map中的所有元素取出来了. 2.0  什

Java中的集合（Map）

标准库中包含了几种Map的基本实现,包括:HashMap.TreeMap.LinkedHashMap.WeekHashMap.ConcurrentHashMap.IdentityHashMap.它们都有同样的基本接口Map,但是行为特性各不相同,这表现在效率,键值对的保存及呈现次序.对象的保存周期.映射表如何在多线程程序中工作和判定"键"等价的策略等方面. Map可以将键映射到值.一个映射不能包含重复的键:每个键最多只能映射到一个值.Map 接口提供三种collection 视图,允许