多用多学之Java中的Set,List,Map详解

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

也不知道从什么时候开始慢慢的代码中就经常会出现HashMap和HashSet之类的工具类。应该说HashMap比较多一些,而且还是面试经典题,平时也会多看看。开始用的时候简单理解就是个键值对应表,使用键来找数据比较方便。随后深入了解后发现

这玩意还有点小奥秘,特别是新版本的JDK对HashMap的改成树后,代码都有点小复杂咯。

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

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

好了,简单的整理一下:

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

先来看看List

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

ArrayList

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

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

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,这就是链表的结构:

 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指向头和尾就完成了,下面的代码:

/**

   * 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操作:

/**

   * 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的代码:

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算法存数据,所以数据不重复,存取都相对较快。怎么做到的呢?

public boolean add(E e) {

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

  }

原来是存在一个map对象中,再看map是个啥?

private transient HashMap<E,Object> map;

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

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

TreeSet

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

public TreeSet() {

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

  }

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

public boolean add(E e) {

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

  }

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

以上就是小编为大家带来的多用多学之Java中的Set,List,Map详解全部内容了,希望大家多多支持我们~

时间: 2016-06-27

java中快速创建带初始值的List和Map实例

初始化一个List和Map对象并为期加入值的写法如下: List<String> sList = new ArrayList<String>(); sList.add("str1"); sList.add("str2"); Map<String,String> sMap = new HashMap<String, String>(); sMap.put("k1", "v1");

Java中的Set、List、Map的用法与区别介绍

Collection 接口 :Collection是最基本的集合接口,声明了适用于JAVA集合(只包括Set和List)的通用方法.Set和List都继承了Conllection,Map Collection接口的方法: boolean add(Object o):向集合中加入一个对象的引用 void clear():删除集合中所有的对象,即不再持有这些对象的引用 boolean isEmpty():判断集合是否为空 boolean contains(Object o):判断集合中是否持有特定对

Java中List与Map初始化的一些写法分享

Java的在还没有发现新写法之前时,我一直是这么初始化List跟Map: 复制代码 代码如下: //初始化List    List<string> list = new ArrayList</string><string>();    list.add("www.jb51.net");    list.add("string2");    //some other list.add() code......    list.add

详解Java中list,set,map的遍历与增强for循环

详解Java中list,set,map的遍历与增强for循环 Java集合类可分为三大块,分别是从Collection接口延伸出的List.Set和以键值对形式作存储的Map类型集合. 关于增强for循环,需要注意的是,使用增强for循环无法访问数组下标值,对于集合的遍历其内部采用的也是Iterator的相关方法.如果只做简单遍历读取,增强for循环确实减轻不少的代码量. 集合概念: 1.作用:用于存放对象 2.相当于一个容器,里面包含着一组对象,其中的每个对象作为集合的一个元素出现 3.jav

java中 Set与Map排序输出到Writer详解及实例

 java中 Set与Map排序输出到Writer详解及实例 一般来说java.util.Set,java.util.Map输出的内容的顺序并不是按key的顺序排列的,但是java.util.TreeMap,java.util.TreeSet的实现却可以让Map/Set中元素内容以key的顺序排序,所以利用这个特性,可以将Map/Set转为TreeMap,TreeSet然后实现排序输出. 以下是实现的代码片段: /** * 对{@link Map}中元素以key排序后,每行以{key}={val

Java中对list map根据map某个key值进行排序的方法

实例如下所示: package test; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.HashMap; import java.util.List; import java.util.Map; public class java_ListMapSort { public static void main(String[] args)

Java中List for循环的6种写法总结(推荐)

如下所示: List<String> list = new ArrayList<String>(); /** * 方法一:最普通的不加思考的写法 * <p> * 优点:较常见,易于理解 * <p> * 缺点:每次都要计算list.size() */ for (int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); } /** * 方法二:数组长度提取出来 * <p&g

浅谈java中定义泛型类和定义泛型方法的写法

1.方法中的泛型 public static <T> T backSerializable(Class<T> clazz , String path ,String fileName){ FileInputStream fis = null; ObjectInputStream ois = null; Object obj = null; try { fis = new FileInputStream(path + fileName); ois = new ObjectInputS

基于Shell中for循环的几个常用写法分享

第一类:数字性循环 for1-1.sh #!/bin/bash for((i=1;i<=10;i++)); do echo $(expr $i \* 3 + 1); done for1-2.sh #!/bin/bash for i in $(seq 1 10) do echo $(expr $i \* 3 + 1); done for1-3.sh #!/bin/bash for i in {1..10} do echo $(expr $i \* 3 + 1); done for1-4.sh #!

Java中List根据map的某个key去重的代码

话不多说,看代码和效果 /** * 根据map中的某个key 去除List中重复的map * @author shijing * @param list * @param mapKey * @return */ public static List<Map<String, Object>> removeRepeatMapByKey(List<Map<String, Object>> list, String mapKey){ if (CollectionUt

java中hashmap容量的初始化实现

HashMap使用HashMap(int initialCapacity)对集合进行初始化. 在默认的情况下,HashMap的容量是16.但是如果用户通过构造函数指定了一个数字作为容量,那么Hash会选择大于该数字的第一个2的幂作为容量.比如如果指定了3,则容量是4:如果指定了7,则容量是8:如果指定了9,则容量是16. 为什么要设置HashMap的初始化容量 在<阿里巴巴Java开发手册>中,有一条开发建议是建议我们设置HashMap的初始化容量. 下面我们通过具体的代码来了解下为什么会这么

java中数组list map三者之间的互转介绍

三者之间转换关系,一张图清晰呈现.  上代码: 其中的maputils是apache的collection包. 复制代码 代码如下: package util; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; import org.apache.commons.collections.MapUtil