精华内容
下载资源
问答
  • 集合常用有哪几种

    千次阅读 2020-08-05 10:20:36
    HashMap(首先想起最常用的hashmap,无序,线程不安全,底层是数组加链表加红黑树), HashTable(然后想起线程安全的hashtable), HashTree(然后想起有序的hashtree,底层是红黑树), LinkedHashMap(然后想起有序的...

    从map,list,set三大接口下分类别回答

    • map接口下的:
    1. HashMap(首先想起最常用的hashmap,无序线程不安全,底层是数组加链表加红黑树),
    2. HashTable(然后想起线程安全的hashtable),
    3. HashTree(然后想起有序的hashtree,底层是红黑树),
    4. LinkedHashMap(然后想起有序的hashtree,底层是红黑树),
    5. ConcurrentHashMap(然后想起有序的hashtree,底层是双向链表加数组加链表加红黑树,线程安全)

    ConcurrentHashMap结合了HashMap和Hashtable二者的优势

    • List接口下的:
    1. ArrayList(底层为数组的arraylist,线程不安全),
    2. LinkedList(底层为链表的的LinkedList,线程不安全),
    3. Stack(常用的栈,继承自Vector,底层是通过数组实现的,线程安全)
    4. Vector(底层是通过数组实现的,线程安全)
    • Set接口下的:

      1. HashSet(HashSet底层使用了Hash表实现),
      2. TreeSet(TreeSet底层使用了红黑树来实现),
      3. LinkedHashSet( LinkedHashSet是具有可预知迭代顺序的Set接口的哈希表链接列表实现)
    展开全文
  • 集合拷贝几种常用方法

    千次阅读 2020-08-13 23:36:00
    简单的方式是通过构造方 List<Plant> copy = new ArrayList<>(list); 注意:这里拷贝的是引用而不是元素,也就是说某个集合对元素进行修改,则两个集合都会影响 List<Integer> copy = ...

    一种简单的方式是通过构造方

    List<Plant> copy = new ArrayList<>(list);

    注意:这里拷贝的是引用而不是元素,也就是说某个集合对元素进行修改,则两个集合都会影响

     

    List<Integer> copy = new ArrayList<>(list);
    

    所以对于通过构造方法的方法最好是拷贝不可变的类,例如Integer就是不可以修改的

     

    通过addAll()

    和通过构造方法一样是拷贝的引用而不是元素

     

    通过Collections集合拷贝

    List<Integer> source = Arrays.asList(1,2,3);
    List<Integer> dest = Arrays.asList(4,5,6);
    Collections.copy(dest, source);

     注意这里做的是重写,而不是追加

     

    通过java 8

    List<String> copy = list.stream()
      .collect(Collectors.toList());

    第一个元素跳过

    List<String> copy = list.stream()
      .skip(1)
      .collect(Collectors.toList());

    添加过滤条件

    List<String> copy = list.stream()
      .filter(s -> s.length() > 10)
      .collect(Collectors.toList());
    List<Flower> flowers = list.stream()
      .filter(f -> f.getPetals() > 6)
      .collect(Collectors.toList());

     

    展开全文
  • 常用几种java集合类总结

    万次阅读 多人点赞 2018-08-09 18:13:16
    一:直观框架图 简单版: ...Collection接口又3种子类型,List、Set和Queue,再下面是一些抽象类,最后是具体实现类,常用ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedH...

    一:直观框架图

    简单版:

    详细版:

    Java集合框架

    Java集合框架主要包括两种类型的容器,一种是集合(Collection),另一种是图(Map)。Collection接口又有3种子类型,List、Set和Queue,再下面是一些抽象类,最后是具体实现类,常用的有ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap等等。Map常用的有HashMap,LinkedHashMap等。

    二、Collection接口

    1.List

    List接口扩展自Collection,它可以定义一个允许重复的有序集合,从List接口中的方法来看,List接口主要是增加了面向位置的操作,允许在指定位置上操作元素,同时增加了一个能够双向遍历线性表的新列表迭代器ListIterator。AbstractList类提供了List接口的部分实现,AbstractSequentialList扩展自AbstractList,主要是提供对链表的支持。下面介绍List接口的两个重要的具体实现类,也是我们可能最常用的类,ArrayList和LinkedList。

    1.1ArrayList

    通过阅读ArrayList的源码,我们可以很清楚地看到里面的逻辑,它是用数组存储元素的,这个数组可以动态创建,如果元素个数超过了数组的容量,那么就创建一个更大的新数组,并将当前数组中的所有元素都复制到新数组中。假设第一次是集合没有任何元素,下面以插入一个元素为例看看源码的实现。

    1、找到add()实现方法。
    
       public boolean add(E e) {
            ensureCapacityInternal(size + 1);  // Increments modCount!!
            elementData[size++] = e;
            return true;
        }
    
    2、此方法主要是确定将要创建的数组大小。
    
      private void ensureCapacityInternal(int minCapacity) {
            if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
                minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
            }
    
            ensureExplicitCapacity(minCapacity);
        }
    
        private void ensureExplicitCapacity(int minCapacity) {
            modCount++;
            if (minCapacity - elementData.length > 0)
                grow(minCapacity);
        }
    
    3、最后是创建数组,可以明显的看到先是确定了添加元素后的大小之后将元素复制到新数组中。
    
        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);
        }
    

    1.2LinkedList

    同样,我们打开LinkedList的源文件,不难看到LinkedList是在一个链表中存储元素。

    在学习数据结构的时候,我们知道链表和数组的最大区别在于它们对元素的存储方式的不同导致它们在对数据进行不同操作时的效率不同,同样,ArrayList与LinkedList也是如此,实际使用中我们需要根据特定的需求选用合适的类,如果除了在末尾外不能在其他位置插入或者删除元素,那么ArrayList效率更高,如果需要经常插入或者删除元素,就选择LinkedList。

    1.3CopyOnWriteArrayList

    CopyOnWriteArrayList,是一个线程安全的List接口的实现,它使用了ReentrantLock锁来保证在并发情况下提供高性能的并发读取。

    2.Set

    Set接口扩展自Collection,它与List的不同之处在于,规定Set的实例不包含重复的元素。在一个规则集内,一定不存在两个相等的元素。AbstractSet是一个实现Set接口的抽象类,Set接口有三个具体实现类,分别是散列集HashSet、链式散列集LinkedHashSet和树形集TreeSet。

    2.1HashSet

    散列集HashSet是一个用于实现Set接口的具体类,可以使用它的无参构造方法来创建空的散列集,也可以由一个现有的集合创建散列集。在散列集中,有两个名词需要关注,初始容量和客座率。客座率是确定在增加规则集之前,该规则集的饱满程度,当元素个数超过了容量与客座率的乘积时,容量就会自动翻倍。

    从输出结果我们可以看到,规则集里最后有4个元素,而且在输出时元素还是无序的。

    2.2LinkedHashSet

    LinkedHashSet是用一个链表实现来扩展HashSet类,它支持对规则集内的元素排序。HashSet中的元素是没有被排序的,而LinkedHashSet中的元素可以按照它们插入规则集的顺序提取。

    2.3TreeSet

    TreeSet扩展自AbstractSet,并实现了NavigableSet,AbstractSet扩展自AbstractCollection,树形集是一个有序的Set,其底层是一颗树,这样就能从Set里面提取一个有序序列了。在实例化TreeSet时,我们可以给TreeSet指定一个比较器Comparator来指定树形集中的元素顺序。树形集中提供了很多便捷的方法。

    3.Queue

    队列是一种先进先出的数据结构,元素在队列末尾添加,在队列头部删除。Queue接口扩展自Collection,并提供插入、提取、检验等操作。

    上图中,方法offer表示向队列添加一个元素,poll()与remove()方法都是移除队列头部的元素,两者的区别在于如果队列为空,那么poll()返回的是null,而remove()会抛出一个异常。方法element()与peek()主要是获取头部元素,不删除。

    接口Deque,是一个扩展自Queue的双端队列,它支持在两端插入和删除元素,因为LinkedList类实现了Deque接口,所以通常我们可以使用LinkedList来创建一个队列。PriorityQueue类实现了一个优先队列,优先队列中元素被赋予优先级,拥有高优先级的先被删除。

    三、Map接口

    1.HashMap

    HashMap是基于哈希表的Map接口的非同步实现,继承自AbstractMap,AbstractMap是部分实现Map接口的抽象类。在平时的开发中,HashMap的使用还是比较多的。我们知道ArrayList主要是用数组来存储元素的,LinkedList是用链表来存储的,那么HashMap的实现原理是什么呢?先看下面这张图:

    在之前的版本中,HashMap采用数组+链表实现,即使用链表处理冲突,同一hash值的链表都存储在一个链表里。但是当链表中的元素较多,即hash值相等的元素较多时,通过key值依次查找的效率较低。而JDK1.8中,HashMap采用数组+链表+红黑树实现,当链表长度超过阈值(8)时,将链表转换为红黑树,这样大大减少了查找时间。

    下面主要通过源码介绍一下它的实现原理。

    HashMap存储元素的数组

      transient Node<K,V>[] table;
    

    数组的元素类型是Node<K,V>,Node<K,V>继承自Map.Entry<K,V>,表示键值对映射。

    static class Node<K,V> implements Map.Entry<K,V> {
            final int hash;
            final K key;
            V value;
            Node<K,V> next;
    
            //构造函数 ( Hash值键值下一个节点 )
            Node(int hash, K key, V value, Node<K,V> next) {
                this.hash = hash;
                this.key = key;
                this.value = value;
                this.next = next;
            }
    
            public final K getKey()        { return key; }
            public final V getValue()      { return value; }
            public final String toString() { return key + "=" + value; }
    
            public final int hashCode() {
                return Objects.hashCode(key) ^ Objects.hashCode(value);
            }
    
            public final V setValue(V newValue) {
                V oldValue = value;
                value = newValue;
                return oldValue;
            }
    
            public final boolean equals(Object o) {
                if (o == this)
                    return true;
                if (o instanceof Map.Entry) {
                    Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                    if (Objects.equals(key, e.getKey()) &&
                        Objects.equals(value, e.getValue()))
                        return true;
                }
                return false;
            }
        }
    

    接下来我们看下HashMap的put操作。

        final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
            boolean evict) {
            Node<K,V>[] tab; Node<K,V> p; int n, i;
            if ((tab = table) == null || (n = tab.length) == 0)
                n = (tab = resize()).length;  //如果没有初始化则初始化table
            if ((p = tab[i = (n - 1) & hash]) == null)
                //这里 (n-1)&hash 是根据hash值得到这个元素在数组中的位置(即下标)
                tab[i] = newNode(hash, key, value, null);
            //如果数组该位置上没有元素,就直接将该元素放到此数组中的该位置上
            else {
                Node<K,V> e; K k;
                //第一节节点hash值同,且key值与插入key相同
                if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                    e = p;
                else if (p instanceof TreeNode)
                    //属于红黑树处理冲突
                    e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
                else {
                    /链表处理冲突
                    for (int binCount = 0; ; ++binCount) {
                        if ((e = p.next) == null) {
                            p.next = newNode(hash, key, value, null);
                            if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            //新增节点后如果节点个数到达阈值,则将链表转换为红黑树
                                treeifyBin(tab, hash);
                            break;
                        }
                        if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                            break;
                        p = e;
                    }
                }
                //更新hash值和key值均相同的节点Value值
                if (e != null) { // existing mapping for key
                    V oldValue = e.value;
                    if (!onlyIfAbsent || oldValue == null)
                        e.value = value;
                    afterNodeAccess(e);
                    return oldValue;
                }
            }
            ++modCount;
            if (++size > threshold)
                resize();
            afterNodeInsertion(evict);
            return null;
        }
    

    接下来我们看下HashMap的get操作。

      final Node<K,V> getNode(int hash, Object key) {
            Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
            if ((tab = table) != null && (n = tab.length) > 0 &&
                (first = tab[(n - 1) & hash]) != null) {
                if (first.hash == hash && // always check first node
                    ((k = first.key) == key || (key != null && key.equals(k))))
                    return first;
                if ((e = first.next) != null) {
                    //如果第一个节点是TreeNode,说明采用的是数组+红黑树结构处理冲突
        //遍历红黑树,得到节点值
                    if (first instanceof TreeNode)
                        return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                    do {
                        if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && 
                                                           key.equals(k))))
                            return e;
                    } while ((e = e.next) != null);
                }
            }
            return null;
        }
    

    到这里HashMap的大致实现原理应该很清楚了,有几个需要关注的重点是:HashMap存储元素的方式以及根据Hash值确定映射在数组中的位置还有JDK 1.8之后加入的红黑树的。

    在HashMap中要找到某个元素,需要根据key的hash值来求得对应数组中的位置。对于任意给定的对象,只要它的hashCode()返回值相同,那么程序调用hash(int h)方法所计算得到的hash码值总是相同的。我们首先想到的就是把hash值对数组长度取模运算,这样一来,元素的分布相对来说是比较均匀的。但是,“模”运算的消耗还是比较大的,在HashMap中,(n - 1) & hash用于计算对象应该保存在table数组的哪个索引处。HashMap底层数组的长度总是2的n次方,当数组长度为2的n次幂的时候,(n - 1) & hash 算得的index相同的几率较小,数据在数组上分布就比较均匀,也就是说碰撞的几率小,相对的,查询的时候就不用遍历某个位置上的链表,这样查询效率也就较高了。

    2.LinkedHashMap

    LinkedHashMap继承自HashMap,它主要是用链表实现来扩展HashMap类,HashMap中条目是没有顺序的,但是在LinkedHashMap中元素既可以按照它们插入图的顺序排序,也可以按它们最后一次被访问的顺序排序。

    3.TreeMap

    TreeMap基于红黑树数据结构的实现,键值可以使用Comparable或Comparator接口来排序。TreeMap继承自AbstractMap,同时实现了接口NavigableMap,而接口NavigableMap则继承自SortedMap。SortedMap是Map的子接口,使用它可以确保图中的条目是排好序的。

    在实际使用中,如果更新图时不需要保持图中元素的顺序,就使用HashMap,如果需要保持图中元素的插入顺序或者访问顺序,就使用LinkedHashMap,如果需要使图按照键值排序,就使用TreeMap。

    4.ConcurrentHashMap

    Concurrent,并发,从名字就可以看出来ConcurrentHashMap是HashMap的线程安全版。同HashMap相比,ConcurrentHashMap不仅保证了访问的线程安全性,而且在效率上与HashTable相比,也有较大的提高。

     

    展开全文
  • java中常用几种集合类型

    千次阅读 2012-10-10 23:57:48
    常用集合分为List(有序排放)、Map(以名和值一一对应的存放)、Set(既无序也没名) 在这三者之中其中List和Set是Collection接口的子接口,而Map不是Collection接口的子接口 首先介绍的是集合 一、List: ...
    集合就像数组一样,用来存放东西
    
    常用的集合分为 List(有序排放)、Map(以名和值一一对应的存放)、Set(既无序也没名)
    在这三者之中其中List和Set是Collection接口的子接口,而Map不是Collection接口的子接口
    首先介绍的是集合
    一、List:
    为了学习List,这里介绍List的实现类:ArrayList和LinkedList
    ①ArrayList:索引从0开始,线性存储,有索引,有顺序
    主要方法:add()用于往集合中添加元素,get()用于获取指定索引处的元素,size()获得集合的长度,相当于数组中的length
    ②LinkedList:也是线性存储,有索引,有顺序
    它和ArrayList差不多,它有ArrayList集合中不具备的方法,如:addFirst(Object)这是往list集合的最前边添加元素的方法,相应的还有addLast等
    ③ArrayList和LinkedList的区别和联系:
    linkedlist集合的优势:添加元素时可以指定位置,比ArrayList集合添加元素要快很多。
    但Linkedlist在get获取的时候比Arraylist集合要慢的多,而且获取元素越往后检索的越慢。
     这两种方式各有优缺,为更好的使用可以将这两者进行联合使用,使用Linkedlist集合进行存储和添加元素,使用Arraylist集合进行get获取元素。


    二、Map:名字和值一一对应,是无序的,有名且名字不能重复
    为学习Map,先从它的实现类HashMap学起。
    给map添加元素是使用put方法进行添加。map.put("名",值)
    获得是get(名)
    在map中只要得到全部的名字就能得到所有的值
    这就需要用到set来获得所有的名字:
    Set keyname=map.keySet();
    使用Set中的迭代器:
    Iterator it=keyname.iterator();
    while(it.hasNext()){
    Object key=it.next(); 名
    Object value=map.get(key); 值
    }


    三、Set:既不需要有编号也不需要有名,来了就往里放,存放速度相对较快,但取不好取
    这里就常用HashSet(set的实现类)
    添加元素为add()
    变量获取元素:使用它的iterator()方法是执行迭代器的工具
    Iterator it=set.iterator();
    it.hashNext();  判断下一个是否有
    it.Next();下一个
    使用while(it.hasNext()){
    system.out.println(it.next());
    } 输出也是无序的。
    展开全文
  • * Java数组转List集合 */ public void javaArrayToList() { //1、首先是循环方式 String[] strArray = {"1", "2", "3"}; List<String> stringList = new ArrayList<>(); //循环完毕后list集合中将...
  • 在开发的过程中,会涉及到很多判断一个数组集合是否包含某个元素的需求。强大的list集合框架通过contains这样一个方法实现了我们的需求。list元素类型是基本类型则可以直接调用contains方法来实现。但是如果元素类型...
  • 常用集合有哪些

    万次阅读 多人点赞 2018-09-07 15:56:11
    常用的三大类集合:Set、List、Map。 1 Set 1) Set 集合属于单列集合,不允许包含重复元素; 2) 判断元素是否重复的标准为对象的 equals 方法,存在时返回 false,不存在返回 true; 3) 元素的排序规则,由相应...
  • 常用集合的常用遍历方法

    万次阅读 2018-03-08 17:07:15
    集合框架:就是数据结构,主要List数据结构,Set数据结构,Map数据结构。List数据结构:数据内容无序,但数据的位置是有序的,从0开始,Set 数据结构:数据内容无序,但外置也无序,但内容不能重复。Map数据结构...
  • java常用集合集合讲解

    万次阅读 2018-07-04 13:32:59
    一、java集合系列 java的集合主要分为List列表、Set集合、Map映射、工具类(Iterator迭代器、Enumeration枚举类、Arrays和Collections )java中集合类的关系图 由此图可以看到,主要分为Collection和Map两大类: 1....
  • Linux 常用命令集合

    万次阅读 多人点赞 2021-04-03 14:41:02
    Linux 常用命令集合 一 基本知识了解 1.1 目录结构 /bin: 存放二进制可执行文件,常用命令一般都在这里 /etc: 存放系统管理和配置文件 /home: 存放所有用户文件的根目录,是用户主目录的基点 /usr: 用于存放...
  • java常用集合及集合框架总结

    千次阅读 2018-06-04 23:33:27
    今天这篇文章我们重点总结一下java中常用集合,及他们的特性和适用的场合。常见集合框架结构如下图(不是全部,只包含常用的) 1、List 1.1、ArrayList1.2、LinkedList1.3、Vector1.4、List接口下各种接口实现...
  • java中常用集合

    万次阅读 多人点赞 2019-06-10 20:19:24
    //包含Collection(集合),List,Set,Map(图),以及其Iterator,Comparator,Cloneable,还有常用的具体实现类 //List<List<String>>集合的嵌套使用 //1、是否允许空 //2、是否允许重复数据 //3、...
  • 基本选择器是jQuery中最常用也是最简单的选择器,它通过元素的id、class和标签名等来查找DOM元素。 1、ID选择器 #id 描述:根据给定的id匹配一个元素, 返回单个元素(注:在网页中,id名称不能重复) 示例:$("#...
  • C#的6种常用集合类大比拼【月儿原创】

    万次阅读 热门讨论 2007-06-27 00:35:00
    C#的6种常用集合类大比拼作者:清清月儿 主页:http://blog.csdn.net/21aspnet/ 时间:2007.6.27 说明:MSDN没有说出几种集合类其间的区别,当然欲知更多细节可参考MSDN。一.先来说说数组的不足(也可以说集合与...
  • 几种常用的设计模式介绍

    万次阅读 多人点赞 2013-11-16 18:17:27
    几种常用的设计模式介绍 1.  设计模式的起源 最早提出“设计模式”概念的是建筑设计大师亚力山大Alexander。在1970年他的《建筑的永恒之道》里描述了投计模式的发现,因为它已经存在了千百年之久,而现代才被...
  • map集合取数据的几种方法

    千次阅读 2017-09-14 18:54:30
    常用的方法可以先拿到当前map所有的key 根据key迭代出所有的value Map.Entry是Map的一个工具类,提供了从map中读取一行数据的读取,一次可以迭代出map集合中的键值对,或者说一次迭代一行数据而不是一个key  ...
  • Java常见的几种集合

    千次阅读 2018-05-30 15:56:24
    前提:基本数据类型定义多个变量显得... 集合类主要负责保存、盛装其他数据,因此又将集合类称为容器类,本质上是一数据结构!Java集合类通常分为Set、List、Map和Queue4大体系。其中,Set代表无序的、不允许...
  • 常用集合类的特点

    千次阅读 2016-02-21 21:22:24
    集合类是java中比较重要的类,同时也是面试过程当中经常涉及到的一类问题,在这里对常用集合类进行一下整理总结。 集合类结构如图1所示:
  • Java 中几种常用设计模式

    万次阅读 多人点赞 2018-08-09 16:50:32
    Java 中一般认为23种设计模式,当然暂时不需要所有的都会,但是其中常见的几种设计模式应该去掌握。 总体来说设计模式分为三大类: 创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、...
  • Python常用几种去重方式

    万次阅读 多人点赞 2018-08-24 16:53:33
    由于Python的去重方式比较多,本人在项目中总结了几种常用方法,欢迎补充。 一、对列表去重 1.用循环查找的方式 li = [1,2,3,3,4,2,3,4,5,6,1] news_li = [] for i in li:  if i not in news_li:  news_li....
  • Java中的几种集合的区别及适用场景

    万次阅读 2018-05-08 11:30:00
    后台开发工作中经常遇到一些使用集合的场景,几种集合的优缺点又老是记不住,所以写了这篇博客。首先大的集合分为:List,Set,Map三种,其中List与Set是继承自Collection,而Map不是。List与Set的区别:List中的...
  • 几种常用的特征选择方法

    万次阅读 多人点赞 2017-11-03 16:42:41
    几种常用的特征选择方法 转载 2016年12月14日 16:33:38 标签:特征选择 6084 结合Scikit-learn介绍几种常用的特征选择方法 原文 http://dataunion.org/14072.html 主题 特征选择...
  • Java创建初始化List集合几种方式

    千次阅读 2020-11-20 16:55:17
    1.常用方式 List<Double> list=new ArrayList<>(); list.add(32.5); list.add(78.3); list.add(45.6); 这是比较常用的方式,一项项添加比较麻烦。 2.Arrays工具类 List<Double> list1=...
  • Unity中常用几种设计模式

    万次阅读 2016-10-26 09:42:39
    23设计模式,实在是太多了,而且其中一些看着还貌似差不多,让人很费解,好不容易理解了每一设计模式的含义,并且看了一堆伪代码之后,高高兴兴的合上了书本去玩把LOL,赢了把之后脑袋里关于那23设计...
  • java 中几种常用数据结构

    万次阅读 多人点赞 2016-07-11 09:11:27
    java中有几种常用的数据结构,主要分为Collection和map两个主要接口(接口只提供方法,并不提供实现),而程序中最终使用的数据结构是继承自这些接口的数据结构类。其主要的关系(继承关系): (----详细参见java...
  • java 常用集合类总结

    千次阅读 2017-05-06 14:24:01
    在平常的代码开发中,集合类是经常会使用到的,比如用于列表缓存的ArrayList,用于做映射关系的Map等等 最近重点看了下java集合类的层次继承关系和内部存储结构,做个总结以便后面可以随时翻翻。  java中的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 323,528
精华内容 129,411
关键字:

常用的集合有哪几种