精华内容
下载资源
问答
  • 如何获得集合的数量
    万次阅读
    2015-04-16 16:26:28

    网上看到这个问题其中使用了:

    <%@ taglib uri="http://java.sun.com/jsp/jstl/functions"prefix="fn"%>

    用其length属性可以获得集合数量:${fn:length(list)} (fn后面是冒号)其中的list就是<c:forEach>标签中items属性的值

    试了一下:直接用集合的size方法也行。                               

                                        <c:forEach items="${roleList}" var="role" varStatus="status">

                                        <c:if test="${status.index % 3 == 0 }">
                                            <tr>
                                        </c:if>
                                            <td align="left">[<a href='editRole.do?RoleID=${role.roleID }'>${role.roleName }</a>]<br /></td>

                                        <c:if test="${(status.index+1) % 3 == 0 }">
                                            </tr>
                                        </c:if>
                                        <c:if test="${status.count == roleList.size() }">
                                            </tr>
                                        </c:if>
                                    </c:forEach>
    更多相关内容
  • 本文主要介绍了Java 得到集合中所有子集的方法。具有很好的参考价值,下面跟着小编一起来看下吧
  • 分别沿包含不同晶粒数量的多晶集合体的各方向进行单向拉伸数值模拟实验,得到多晶集合体各方向在一定等效应变下的等效应力,并用云图和等高线表示在多晶体的参考球面上。定义了描述多晶集合体各向异性程度的参考指标...
  • 获取list集合中每一个元素的数量

    千次阅读 2021-11-05 16:03:07
    获取list集合中每一个元素的数量 List<String> list = new ArrayList(){{ add("10.10.10.10"); add("10.10.10.11"); add("10.10.10.12"); add("10.10.10.10"); add("10.10.10.10"); }}; Map<String,...

    获取list集合中每一个元素的数量

    List<String> list = new ArrayList(){{
       add("10.10.10.10");
       add("10.10.10.11");
       add("10.10.10.12");
       add("10.10.10.10");
       add("10.10.10.10");
    }};
    
    Map<String,Integer> map = new HashMap<>();
    for(String l : list){
       if(map.get(l) == null){
          map.put(l,1);
       }else{
          map.put(l,map.get(l) + 1);
       }
    }
    
    System.out.println(map);
    
    展开全文
  • Java——集合(超详细超级全)

    千次阅读 多人点赞 2021-09-11 09:45:08
    Java 集合类可以用于存储数量不等的多个对象,还可用于保存具有映射关系的关联数组。 在这里主要讲一些我们平常很常用的一些接口和一些实现类。 Java 集合可分为 Collection 和 Map 两种体系: Collection接口:单列...

    集合

    Java 集合类可以用于存储数量不等的多个对象,还可用于保存具有映射关系的关联数组。
    在这里主要讲一些我们平常很常用的一些接口和一些实现类。

    Java 集合可分为 Collection 和 Map 两种体系:

    Collection接口:单列数据,定义了存取一组对象的方法的集合

    1. List:元素有序、可重复的集合(动态数组)
    2. Set:元素无序、不可重复的集合(类似于高中所讲的集合)

    Map接口:双列数据,保存具有映射关系“key-value对”的集合(高中时所讲的函数)

    Collection接口的使用方法

    Collection 接口是 List、Set 和 Queue 接口的父接口,该接口里定义的方法既可用于操作 Set 集合,也可用于操作 List 和 Queue 集合。
    JDK不提供此接口的任何直接实现,而是提供更具体的子接口(如:Se和List)实现。
    在 Java5 之前,Java 集合会丢失容器中所有对象的数据类型,把所对象都当成 Object 类型处理;从 JDK 5.0 增加了泛型以后,Java 集合以记住容器中对象的数据类型。

    Collection 接口方法
    1、添加
    add(Object obj)
    addAll(Collection coll) (把另一个集合的所有元素都加到当前集合中)
    2、获取有效元素的个数
    int size()
    3、清空集合
    void clear()
    4、是否是空集合
    boolean isEmpty()
    5、是否包含某个元素
    boolean contains(Object obj):是通过元素的equals方法来判断是否是同一个对象。
    boolean containsAll(Collection c):判断这个集合中的所有元素是否都在我原来的集合中。也是调用元素的equals方法来比较的。拿两个集合的元素挨个比较。
    6、删除
    boolean remove(Object obj) :通过元素的equals方法判断是否是要删除的那个元素。只会删除找到的第一个元素
    boolean removeAll(Collection coll):移除这个集合中与当前集合中共有的元素。
    7、取两个集合的交集
    boolean retainAll(Collection c):把交集的结果存在当前集合中,不影响 c
    8、集合是否相等 (注意当前集合到底是有序的还是无序的,在于你使用的具体是Collection的哪个接口)
    boolean equals(Object obj)
    9、转成对象数组
    Collection coll =new ArrayList();
    Object[] array = coll.toArray();
    10、遍历
    iterator():返回迭代器对象,用于集合遍历

    Iterator迭代器接口

    使用 Iterator 接口遍历集合元素

    1. Iterator对象称为迭代器(设计模式的一种),主要用于遍历 Collection 集合中的元素。
    2. GOF给迭代器模式的定义为:提供一种方法访问一个容器(container)对象中各个元素,而又不需暴露该对象的内部细节。迭代器模式,就为容器而生。类似于“公交车上的售票员”、“火车上的乘务员”、“空姐”。
    3. Collection接口继承了java.lang.Iterable接口,该接口有一个iterator()方法,那么所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了Iterator接口的对象。
    4. Iterator 仅用于遍历集合,Iterator 本身并不提供承装对象的能力。如果需要创建Iterator 对象,则必须有一个被迭代的集合。
    5. 集合对象每次调用iterator()方法都得到一个全新的迭代器对象,默认游标(指针)都在集合的第一个元素之前。

    API
    1.遍历集合

    原理:
    在这里插入图片描述

    我们想要调用集合中所有元素的时候可以用这样来操作:

    //创建一个集合对象,然后添加元素,自己去动手实操一下
    
    
      Iterator iterator = coll.iterator(); //创建迭代器对象
      //然后通过while循环
      while(iterator.hasNext()){    /判断集合中是否还有元素
          System.out.println(itarator.next());   // 一个一个的输出出来
      }
    

    2.移除集合中的元素

      Iterator iter = coll.iterator();//回到起点
      while(iter.hasNext()){
            Object obj = iter.next();
            if(obj.equals("Tom")){
            iter.remove();
            }
    }
    

    注意

    1. Iterator可以删除集合的元素,但是是遍历过程中通过迭代器对象的remove方法,不是集合对象的remove方法。
    2. 注意我们使用迭代器对象时,他是指针下移的操作。如果我刚刚是用remove方法后,现在的指针应该是已经到了最后一个元素的位置。如果还想去遍历,则需要在重新设置迭代器对象。

    使用 foreach 循环遍历集合元素

    Java 5.0 提供了 foreach 循环迭代访问 集合和数组。
    遍历操作不需获取Collection或数组的长度,无需使用索引访问元素。
    遍历集合的底层调用Iterator完成操作。
    foreach还可以用来遍历数组。
    例如:
    在这里插入图片描述

    集合(Collection子接口——List接口)

    List接口

    鉴于Java中数组用来存储数据的局限性,我们通常使用List(动态数组)替代数组

    List集合类中元素有序、且可重复,集合中的每个元素都有其对应的顺序索引。
    List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素。
    JDK API中List接口的实现类常用的有:ArrayList、LinkedList和Vector(现在基本没有人使用了)。

    List除了从Collection集合继承的方法外,List 集合里添加了一些根据索引(区别于set)来操作集合元素的方法。
    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在集合中首次出现的位置,如果不存在返回 -1
    int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
    Object remove(int index):移除指定index位置的元素,并返回此元素(重载了Ccllection的remove方法)
    Object set(int index, Object ele):设置指定index位置的元素为ele
    List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置(左闭右开)的子集合,原来的list并没有变化。

    ArrayList

    ArrayList 源码分析

    jdk7 :
    ArrayList list = new ArrayList(); // 底层会直接创建了长度为10的 Object[] 数组 elementData
    list.add(123);
    ···
    ···
    list(11);// 当添加的元素个数超过了10,之后数组的容量就不够了,就会发生扩容,但这些不需要我们自己去动手,在底层直接会自动扩容,一般情况下是扩容1.5倍,同时将原数组的元素复制到新数组上。
    结论:建议使用代参的构造器,ArrayList list = new ArrayList(int capacity); capacity在这里指的是数组的长度。

    jdk8:
    ArrayList list = new ArrayList(); // 底层是 Object[] 数组 elementData{},说明在我们创建对象的时候没有直接给定长度。
    list.add(123); //但是当第一次执行add方法时,才会创建长度为10 的数组。
    其余的扩容方法都与jdk7中一样。

    小结:jdk7中的ArrayList 对象的创建模式相当于单例模式中的饿汉式,jdk8中的ArrayList 对象的创建模式相当于单例模式中的懒汉式,延迟了数组的创建,节省了内存。

    LinkedList

    新增方法:
    void addFirst(Object obj)
    void addLast(Object obj)
    Object getFirst()
    Object getLast()
    Object removeFirst()
    Object removeLast()

    LinkedList:双向链表,内部没有声明数组,而是定义了Node类型的first和last,用于记录首末元素。同时,定义内部类Node,作为LinkedList中保存数据的基本结构。Node除了保存数据,还定义了两个变量:
    prev变量记录前一个元素的位置
    next变量记录下一个元素的位置

    在这里插入图片描述

    LinkedList源码分析

    其实跟我前几天写的单链表差不过,只不过在节点类中多加了一个指针,能指向上一个节点,这样就能在底层构成双向链表。其实看图就很容易懂了,不懂可以翻翻我之前写的单链表的api。

    面试题

    面试题:ArrayList、LinkedList和Vector的异同
    相同:三个类都是实现了List接口,存储数据都是有序的,可重复的。
    不同:
    ArrayList:作为List接口的主要实现类,线程不安全,效率高。而在调用get和set方法时,使用ArrayList会比LinkedList更快捷。底层使用Object[] 存储。
    LinkedList:线程不安全。对于频繁的插入和删除操作时,使用此类比ArrayList效率高。底层使用的是双向链表存储。
    Vector:作为List接口的古老实现类,线程安全的,效率低。底层使用Object[] 存储。Vector每次扩容请求其大小的2倍空间,而ArrayList是1.5倍。

    面试题:

       public void testListRemove() {
                List list = new ArrayList();
                list.add(1);
                list.add(2);
                list.add(3);
                updateList(list);
                System.out.println(list);
        }
       private static void updateList(List list) {
                list.remove(2);
         }
    
    

    输出的结果为:

    1
    2
    

    因为我这个remove方法是根据索引删除的,所以删除的是 3 这个元素。如果想要删除2这个元素应该这么写

    list.remove(new Integer(2));//这样才表示删除的是2 这个元素 ,而不是索引。
    

    集合(Collection子接口——Set接口)

    Set 接口概述

    Set接口存储无序的,不可重复的数据(类似高中所学的集合)。
    Set接口是Collection的子接口,set接口没有提供额外的方法。
    Set 集合不允许包含相同的元素,如果试把两个相同的元素加入同一个Set 集合中,则添加操作失败。
    Set 判断两个对象是否相同不是使用 == 运算符,而是根据 equals() 方法。
    Set接口的实现类 HashSet,LinkedHashSet 和TreeSet 。

    以HashSet为例:
    无序性:不等于随机性。(存放位置无序性)存储的数据在底层数组中并非按照数组的索引的顺序去添加的,而是根据数据的哈希值决定的。

    不可重复性:保证添加的元素按照equals()判断时,不能返回true。即相同的元素只能添加一个。

    euqals()和 = = 的区别

    添加元素的过程:以HashSet为例:
    在这里插入图片描述

    我们想HashSet中添加元素a,首先调用元素a所在类的hashCode()方法,计算元素a的哈希值,此哈希值通过某种算法计算出HashSet底层数组中的存放位置(索引位置),然后在判断此位置上是否已经有元素:

    1. 如果此位置上没有其他元素,则元素 a添加成功。
    2. 如果此位置上有其他元素 b(或者是有以链表形式存在的多个元素),则比较元素a与元素b的哈希值 :
      如果哈希值不同,则元素a 添加成功。
      如果哈希值相同,则需要调用元素a所在类的equals()方法:
      equals()方法返回true,则元素a添加失败。
      equals()方法返回false,则元素a添加成功。

    通过图片和之前所说的添加元素的方法,能看出来我们HsahSet在底层是一个数组加链表的方法存储数据。

    jdk7:将元素a放到数组中,指向原来的元素。
    jdk8:原来的元素在数组中,指向元素a。
    总结: 七上八下

    HashSet

    HashSet 是 Set 接口的典型实现,大多数时候使用 Set 集合时都使用这个实现类。
    HashSet 按 Hash 算法来存储集合中的元素,因此具有很好的存取、查找、删除性能。

    HashSet 具有以下特点:

    1. 不能保证元素的排列顺序
    2. HashSet 不是线程安全的
    3. 集合元素可以是 null

    HashSet 集合判断两个元素相等的标准:两个对象通过 hashCode() 方法比较相等,并且两个对象的 equals() 方法返回值也相等。
    对于存放在Set容器中的对象,对应的类一定要重写equals()和hashCode(Object obj)方法,以实现对象相等规则。即:“相等的对象必须具有相等的散列码(哈希值)”。

    HashSet扩容问题:
    底层也是数组,初始容量为16,当如果使用率超过0.75,(16*0.75=12)就会扩大容量为原来的2倍。(16扩容为32,依次为64,128…等)。

    问题:
    以Eclipse/IDEA为例,在自定义类中可以调用工具自动重写equals和hashCode。为什么用Eclipse/IDEA复写hashCode方法,有31这个数字?

    1. 选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址越大,所谓的“冲突”就越少,查找起来效率也会提高。(减少冲突)
    2. 并且31只占用5bits,相乘造成数据溢出的概率较小。
    3. 31可以 由i*31== (i<<5)-1来表示,现在很多虚拟机里面都有做相关优化。(提高算法效率)
    4. 31是一个素数,素数作用就是如果我用一个数字来乘以这个素数,那么最终出来的结果只能被素数本身和被乘数还有1来整除!(减少冲突)

    LinkedHashSet

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

    在这里插入图片描述

    TreeSet

    TreeSet 是 SortedSet 接口的实现类,TreeSet 可以确保集合元素处于排序状态。也就是说TreeSet可以按照添加对象的指定属性,进行排序。所以在向TreeSet中添加数据时,要求是相同类的对象,因为只有相同类的对象才能比较。
    TreeSet底层使用红黑树结构存储数据。所以不能存放相同数据。
    TreeSet 两种排序方法:自然排序和定制排序。默认情况下,TreeSet采用自然排序。

    自然排序

    自然排序:TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系,然后将集合元素按升序(默认情况)排列
    如果试图把一个对象添加到 TreeSet 时,则该对象的类必须实现Comparable 接口。
    向 TreeSet 中添加元素时,只有第一个元素无须比较compareTo()方法,后面添加的所有元素都会调用compareTo()方法进行比较。

    对于 TreeSet 集合而言,它判断两个对象是否相等的唯一标准是:两个对象通过 compareTo(Object obj) 方法比较返回值。不再是equals()方法。
    实现 Comparable 的类必须实现 compareTo(Object obj) 方法,两个对象即通过compareTo(Object obj) 方法的返回值来比较大小。
    Comparable 的典型实现:
    BigDecimal、BigInteger 以及所有的数值型对应的包装类:按它们对应的数值大小进行比较
    Character:按字符的 unicode值来进行比较
    Boolean:true 对应的包装类实例大于 false 对应的包装类实例
    String:按字符串中字符的 unicode 值进行比较
    Date、Time:后边的时间、日期比前面的时间、日期大

    定制排序

    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。

    集合(Map接口)

    Map接口概述
    Map与Collection并列存在。用于保存具有映射关系的数据:key-value(双列数据)。
    Map 中的 key 和 value 都可以是任何引用类型的数据。
    Map 中的 key 用Set来存放,不允许重复,即同一个 Map 对象所对应的类,须重写hashCode()和equals()方法。
    key 和 value 之间存在单向一对一关系,即通过指定的 key 总能找到唯一的、确定的 value。
    Map接口的常用实现类:HashMap、Hashtable、TreeMap、LinkedHashMap和Properties。其中,HashMap是 Map 接口使用频率最高的实现类

    Map实现类的特点:
    Map:双列数据,存储key-value对的数据 —类似于高中的函数:y=f(x)

    • HashMap:作为Map的主要实现类;线程不安全的,效率高;可以存储null的key和value
    • LinkedHashMap:保证在遍历map元素时,可以按照添加的顺序实现遍历。
      原因:在原有的HashMap底层结构基础上,添加了一对指针,指向前一个和后一个元素。对于频繁的遍历操作,此类执行效率高于HashMap。
    • TreeMap:保证按照添加的key-value对进行排序,实现排序遍历。此时考虑key的自然排序或定制排序,底层使用红黑树。
    • Hashtable:作为古老的实现类;线程安全的,效率低;不能存储null的key和value
    • Properties:常用来处理配置文件。key和value都是String类型。

    Map接口:常用方法

    添加、删除、修改操作

    • Object put(Object key,Object value):将指定key-value添加到(或修改)当前map对象中
    • void putAll(Map m):将m中的所有key-value对存放到当前map中
    • Object remove(Object key):移除指定key的key-value对,并返回value
    • void clear():清空当前map中的所有数据

    元素查询的操作

    • Object get(Object key):获取指定key对应的value
    • boolean containsKey(Object key):是否包含指定的key
    • boolean containsValue(Object value):是否包含指定的value
    • int size():返回map中key-value对的个数
    • boolean isEmpty():判断当前map是否为空
    • boolean equals(Object obj):判断当前map和参数对象obj是否相等

    元视图操作的方法

    • Set keySet():返回所有key构成的Set集合
    • Collection values():返回所有value构成的Collection集合
    • Set entrySet():返回所有key-value对构成的Set集合

    我想遍历map时不能使用迭代器了,因为迭代器是Collection接口下的,所以我们可以进行一些操作。
    集合遍历

    Map map = new HashMap();
    //map.put(..,..)省略
    System.out.println("map的所有key:");
    Set keys = map.keySet();// HashSet
    for (Object key : keys) {  //增强for循环遍历
    System.out.println(key + "->" + map.get(key));
    }
    System.out.println("map的所有的value:");
    Collection values = map.values();
    Iterator iter = values.iterator();
    while (iter.hasNext()) {   //迭代器遍历
    System.out.println(iter.next());
    }
    System.out.println("map所有的映射关系:");
    // 映射关系的类型是Map.Entry类型,它是Map接口的内部接口
    Set mappings = map.entrySet();
    for (Object mapping : mappings) {
    Map.Entry entry = (Map.Entry) mapping; //强制转型 
    System.out.println("key是:" + entry.getKey() + ",value是:" + entry.getValue());
    }
    

    HashMap

    HashMap是 Map 接口使用频率最高的实现类。
    HashMap允许使用null键和null值,与HashSet一样,不保证映射的顺序。
    HashMap所有的key构成的集合是Set:无序的、不可重复的。所以,key所在的类要重写:equals()和hashCode()。
    HashMap所有的value构成的集合是Collection:无序的、可以重复的。所以,value所在的类要重写:equals()。
    HashMap一个key-value构成一个entry。所有的entry构成的集合是Set:无序的、不可重复的。
    HashMap 判断两个 key 相等的标准是:两个 key 通过 equals() 方法返回 true,hashCode 值也相等。
    HashMap 判断两个 value相等的标准是:两个 value 通过 equals() 方法返回 true。
    在这里插入图片描述

    HashMap的底层实现原理(高频面试)

    jdk7:
    HashMap map = new HashMap();
    在实例化以后,底层创建了长度是16的一维数组Entry[] table。
    …可能已经执行过多次put…
    map.put(key1,value1);
    首先,调用key1所在类的hashCode()计算key1哈希值,此哈希值经过某种算法计算以后,得到在Entry数组中的存放位置。

    1. 如果此位置上的数据为空,此时的key1-value1添加成功。 ----情况1

    2. 如果此位置上的数据不为空,(意味着此位置上存在一个或多个数据(以链表形式存在)),比较key1和已经存在的一个或多个数据 的哈希值:

    3. 如果key1的哈希值与已经存在的数据的哈希值都不相同,此时key1-value1添加成功。----情况2

    4. 如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同,继续比较:调用key1所在类的equals(key2)方法,比较:
      如果equals()返回false:此时key1-value1添加成功。----情况3
      如果equals()返回true:使用value1替换value2。

    • 补充:关于情况2和情况3:此时key1-value1和原来的数据以链表的方式存储。

      在不断的添加过程中,会涉及到扩容问题,当超出临界值(且要存放的位置非空)时,扩容。默认的扩容方式:扩容为原来容量的2倍,并将原有的数据复制过来。
      在这里插入图片描述

    jdk8:

    jdk8 相较于jdk7在底层实现方面的不同:

    1. new HashMap():底层没有创建一个长度为16的数组

    2. jdk 8底层的数组是:Node[],而非Entry[]

    3. 首次调用put()方法时,底层创建长度为16的数组

    4. jdk7底层结构只有:数组+链表。jdk8中底层结构:数组+链表+红黑树。

      4.1 形成链表时,七上八下(jdk7:新的元素指向旧的元素。jdk8:旧的元素指向新的元素)

      4.2 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时,此时此索引位置上的所数据改为使用红黑树存储(方便查找)。
      在这里插入图片描述

    HashMap源码中的重要常量:

    • DEFAULT_LOAD_FACTOR:HashMap的默认加载因子:0.75
    • threshold:扩容的临界值,=容量*填充因子:16 * 0.75 => 12(数组中元素大于12的时候可能就会发生扩容,但是当添加第12个元素的位置是null时,也不会发生扩容,只会继续生成链表,不是null的时候一定会扩容)
      为什么会提前扩容? 防止链表的长度太长
    • TREEIFY_THRESHOLD:Bucket中链表长度大于该默认值,转化为红黑树:8
    • MIN_TREEIFY_CAPACITY:桶中的Node被树化时最小的hash表容量:64
    • MAXIMUM_CAPACITY : HashMap的最大支持容量,2^30

    table:存储元素的数组,总是2的n次幂
    entrySet:存储具体元素的集
    size:HashMap中存储的键值对的数量
    modCount:HashMap扩容和结构改变的次数。
    threshold:扩容的临界值,=容量*填充因子
    loadFactor:填充因子

    HashMap的扩容:
    jdk7:
    当HashMap中的元素越来越多的时候,hash冲突的几率也就越来越高,因为数组的长度是固定的。所以为了提高查询的效率,就要对HashMap的数组进行扩容,而在HashMap数组扩容之后,最消耗性能的点就出现了:原数组中的数据必须重新计算其在新数组中的位置,并放进去,这就是resize。
    所以如果我们已经预知HashMap中元素的个数,那么预设元素的个数能够有效的提高HashMap的性能。

    jdk8:
    当HashMap中的其中一个链的对象个数如果达到了8个,此时如果capacity没有达到64,那么HashMap会先扩容解决,如果已经达到了64,那么这个链会变成树,结点类型由Node变成TreeNode类型。当然,如果当映射关系被移除后,下次resize方法时判断树的结点个数低于6个,也会把树再转为链表。

    面试题

    负载因子值的大小,对HashMap有什么影响:

    • 负载因子的大小决定了HashMap的数据密度。
    • 负载因子越大密度越大,发生碰撞的几率越高,数组中的链表越容易长,造成查询或插入时的比较次数增多,性能会下降。
    • 负载因子越小,就越容易触发扩容,数据密度也越小,意味着发生碰撞的几率越小,数组中的链表也就越短,查询和插入时比较的次数也越小,性能会更高。但是会浪费一定的内容空间。而且经常扩容也会影响性能,建议初始化预设大一点的空间。
    • 按照其他语言的参考及研究经验,会考虑将负载因子设置为0.7~0.75,此时平均检索长度接近于常数。

    LinkedHashMap

    LinkedHashMap 是 HashMap 的子类。
    在HashMap存储结构的基础上,使用了一对双向链表来记录添加
    元素的顺序。
    与LinkedHashSet类似,LinkedHashMap 可以维护 Map 的迭代顺序:迭代顺序与 Key-Value 对的插入顺序一致。

    HashMap中的内部类:Node
    其中涉及到的泛型<>,过几天就会讲到。

    static class Node<K,V> implements Map.Entry<K,V> {
                   final int hash;
                   final K key;
                   V value;
                   Node<K,V> next;
    }
    

    LinkedHashMap中的内部类:Entry

    static class Entry<K,V> extends HashMap.Node<K,V> {
                  Entry<K,V> before, after;
                  Entry(int hash, K key, V value, Node<K,V> next) {
                         super(hash, key, value, next);
                   }
    }
    

    TreeMap

    TreeMap存储 Key-Value 对时,需要根据 key-value 对进行排序。
    TreeMap 可以保证所有的 Key-Value 对处于有序状态。
    TreeSet底层使用红黑树结构存储数据。
    TreeMap 的 Key 的排序:

    • 自然排序:TreeMap 的所有的 Key 必须实现 Comparable 接口,而且所有的 Key 应该是同一个类的对象,否则将会抛出ClasssCastException
    • 定制排序:创建 TreeMap 时,传入一个 Comparator 对象,该对象负责对TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现Comparable 接口。

    TreeMap判断两个key相等的标准:两个key通过compareTo()方法或者compare()方法返回0。

    
    
    public class TreeMapTest {
    
        //向TreeMap中添加key-value,要求key必须是由同一个类创建的对象
        //因为要按照key进行排序:自然排序 、定制排序
        //自然排序
        @Test
        public void test1(){
            TreeMap map = new TreeMap();
            User u1 = new User("Tom",23);
            User u2 = new User("Jerry",32);
            User u3 = new User("Jack",20);
            User u4 = new User("Rose",18);
    
            map.put(u1,98);
            map.put(u2,89);
            map.put(u3,76);
            map.put(u4,100);
    
            Set entrySet = map.entrySet();
            Iterator iterator1 = entrySet.iterator();
            while (iterator1.hasNext()){
                Object obj = iterator1.next();
                Map.Entry entry = (Map.Entry) obj;
                System.out.println(entry.getKey() + "---->" + entry.getValue());
    
            }
        }
    
        //定制排序
        @Test
        public void test2(){
            TreeMap map = new TreeMap(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());
                    }
                    throw new RuntimeException("输入的类型不匹配!");
                }
            });
            User u1 = new User("Tom",23);
            User u2 = new User("Jerry",32);
            User u3 = new User("Jack",20);
            User u4 = new User("Rose",18);
    
            map.put(u1,98);
            map.put(u2,89);
            map.put(u3,76);
            map.put(u4,100);
    
            Set entrySet = map.entrySet();
            Iterator iterator1 = entrySet.iterator();
            while (iterator1.hasNext()){
                Object obj = iterator1.next();
                Map.Entry entry = (Map.Entry) obj;
                System.out.println(entry.getKey() + "---->" + entry.getValue());
    
            }
        }
    
    
    }
    
    

    Hashtable

    • Hashtable是个古老的 Map 实现类,JDK1.0就提供了。不同于HashMap,Hashtable是线程安全的。
    • Hashtable实现原理和HashMap相同,功能相同。底层都使用哈希表结构,查询速度快,很多情况下可以互用。
    • 与HashMap不同,Hashtable 不允许使用 null 作为 key 和 value
    • 与HashMap一样,Hashtable 也不能保证其中 Key-Value 对的顺序
    • Hashtable判断两个key相等、两个value相等的标准,与HashMap一致。

    Properties

    Properties 类是 Hashtable 的子类,该对象用于处理属性文件。
    由于属性文件里的 key、value 都是字符串类型,所以 Properties 里的 key 和 value 都是字符串类型。
    存取数据时,建议使用setProperty(String key,String value)方法和
    getProperty(String key)方法。

    大家主要还是主要关注HashMap,其他的需要了解知道是干什么用的就好了,实际场景中用的还是HashMap。

    Collections工具类

    Collections 是一个操作 Set、List 和 Map 等集合的工具类
    Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作,还提供了对集合对象设置不可变、对集合对象实现同步控制等方法。

    排序操作:(均为static方法)

    • reverse(List):反转 List 中元素的顺序。
    • shuffle(List):对 List 集合元素进行随机排序。
    • sort(List):根据元素的自然顺序对指定 List 集合元素按升序排序
    • sort(List,Comparator):根据指定的 Comparator 产生的顺序对 List 集合元素进行排序。
    • swap(List,int, int):将指定 list 集合中的 i 处元素和 j 处元素进行交换。

    查找、替换

    • Object max(Collection):根据元素的自然顺序,返回给定集合中的最大元素
    • Object max(Collection,Comparator):根据 Comparator 指定的顺序,返回给定集合中的最大元素
    • Object min(Collection)
    • Object min(Collection,Comparator)
    • int frequency(Collection,Object):返回指定集合中指定元素的出现次数
    • void copy(List dest,List src):将src中的内容复制到dest中
    • boolean replaceAll(List list,Object oldVal,Object newVal):使用新值替换List 对象的所有旧值

    Collections常用方法:同步控制

    Collections 类中提供了多个 synchronizedXxx() 方法,该方法可使将指定集合包装成线程同步的集合,从而可以解决多线程并发访问集合时的线程安全问题。

    在这里插入图片描述

    展开全文
  • python学习笔记——集合与字典1. 集合的基本概念1.1 set(x)函数1.2 集合类型的10个操作函数2. 字典的基本概念2.1 字典的索引2.2 字典的操作2.3 字典小结 1. 集合的基本概念 集合类型和数学集合中的概念一致,即包含0...
  • 按指定数量读取集合或数组中的值 学习记录 前言:因项目需要写的这个算法,可能代码不像诗,不优雅,但总算达到需求了,请大家多多指点 代码如下: @org.junit.Test public void test(){ //指定每次输出多少数量的...

    java算法按指定数量读取集合或数组中的值

    学习记录

    前言:因项目需要写的这个算法,可能代码不像诗,不优雅,但总算达到需求了,请大家多多指点

    代码如下:

     @org.junit.Test
        public void test(){
            //指定每次输出多少数量的数据
            int munber = 5;
            //存放任意数量的数据
            String brandIds[] = new String[177];
            for (int i = 0; i<177; i++){
                brandIds[i] = i+"";
            }
            List<String> stringList = new ArrayList<>();
            //向上取值获得总循环数
            int result =(int) Math.floor(brandIds.length/munber);
            int count =0;
            int rs = 0;
            for (int j = 0; j< result+1;j++) {
                String str = "";
                rs = count;
                count += munber;
                for (int i = 0; i < brandIds.length; i++) {
                    //当前j 循环次数不等于总循环次数时执行下方if
                    if (j != result) {
                        if (i >= count) {
                            System.out.println("str:" + str.substring(0,str.length()-1));
                            stringList.add(str.substring(0,str.length()-1));
                            break;
                        }
                        if (i >= rs) {
                            str += brandIds[count - count + i] + ",";
                        }
                    } else {//当前j循环次数等于总循环次数时进入else,因为我们是向上取得总循环数,最后一次循环做特殊处理因为数量可能达不到我们指定的输出数量,从而导致异常
                        if (i >= result * munber) {
                            str += brandIds[count - count + i] + ",";
                            if (i==brandIds.length-1){
                                stringList.add(str.substring(0,str.length()-1));
                                System.out.println("str2:"+str.substring(0,str.length()-1));
                            }
                        }
                    }
                }
            }
        }
    

    效果如下:
    在这里插入图片描述在这里插入图片描述

    展开全文
  •  ②两者都可以获得某一范围的元素 下面列举区别:  ①列表是链表实现的,靠近两边的数据读取极快,而元素过多后获取中间元素的速度则会很慢;有序集合类型使用的散列表和跳跃表(Skip list)实现的,所以读取哪
  • 第三阶段 JAVA常见对象的学习集合框架概述和集合的遍历(一) 集合框架的概述(1) 集合的由来如果一个程序只包含固定数量的且其生命周期都是已知的对象,那么这是一个非常简单的程序。通常,程序总是根据运行时才知道的...
  • 集合实例(集合覆盖)

    千次阅读 2020-12-24 23:46:09
    问题如下:给定一个集合S,集合P由集合S的子集A1到An组成,集合C由集合P中的一个或多个子集组成。如果S中的每个成员都包含在C的至少一个子集中则称集合C覆盖集合S。此外,C包含的P的子集越少越好。设想从一大群选手...
  • 1、查询Student对象,得到集合List<Student> 2、声明集合List<List<Student>>,将分割后的集合存储到该集合中 3、使用Strea流指定Student对象,通过Collectors.groupingBy,声明对根据name分割 ...
  • java数组和集合

    千次阅读 2021-03-08 09:50:52
    对于集合的使用是通过实例化集合类得到集合对 象。而集合对象则代表以某种方式组合到一起的一组对象,对于这组对象的使用是通过引用集合对象来进行的。通过班级的例子来给集合举例:(示意代码如下)班级集合 班级A = ...
  • js获取集合对象的个数

    千次阅读 2018-03-18 16:23:00
    l 就是集合 s 的长度   但是获取到的一直是0, 在 MDN 上有一篇详细的说明 , length 一直是0,应该使用 size 属性: const set1 = new Set([1, 2, 3, 4, 5,66]); set1.size 转载于:...
  • 什么是集合的减法运算??,集合运算问题-什么是集合的减法运算??,集合运算问题-匿名网友:集合不能进行加法、减法、乘法。集合的运算包括交、并、差。初学集合可能比较难理解。不过要这样思考:运算是要有意义的。...
  • jdk1.8集合操作新特性

    千次阅读 2019-07-25 16:44:37
    jdk1.8出了很多新特性,对集合操作很多,整理了一下方法,供大家使用 Map<String,Supplier> map = materialSupplierList.stream().collect(Collectors.toMap(MaterialSupplier::getMaterialCode, supplier -&...
  • Java中大规模集合快速求和计算

    千次阅读 2020-08-14 16:21:35
    在做实验的过程中,有时会遇到大规模集合的求和计算。如下给出了两种求和方法: package topic; import java.util.ArrayList; import java.util.List; public class DoubleTest { public static void main...
  • 沪深交易所的集合竞价机制

    千次阅读 2020-12-01 18:29:15
    集合竞价 集合竞价是指对一段时间内接收的买卖申报一次性集中撮合的竞价方式。 以我国竞价交易制度为例,集合竞价时成交价格的确定原则是: 1、在有效价格范围内选取成交量最大的价位; 2、高于成交价格的买进申报与...
  • java集合详解和集合面试题目

    万次阅读 多人点赞 2018-02-12 11:01:14
    数组(可以存储基本数据类型)是用来存现对象的一种容器,但是数组的长度固定,不适合在对象数量未知的情况下使用。 集合(只能存储对象,对象类型可以不一样)的长度可变,可在多数情况下使用。 二、层次关系 如...
  • 最近在工作的时候拿到一个集合List之后想要做一个数量排行,就想到如何得到List 分组后,每组的数量 下面是代码,提供大家参考 static void Main(string[] args) { List<DbInfo> list = new List<DbInfo...
  • 给大家整理了在操作Redis集合类型中的常用命令,文章总结的很全面,对大家学习Redis具有一定的参考借鉴价值,下面来一起看看吧。
  • 得到结果: [1, 1, 2, 2, 3] {1, 2, 3} 3 原理就是set集合中不允许重复元素出现。 以上这篇python 统计列表中不同元素的数量方法就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持软件...
  • Java集合学习

    万次阅读 2022-03-31 09:59:47
    集合 一 、集合概述 1.1集合类的特点 提供一种存储空间可变的存储模型,存储的数据容量可以随时发生改变。 1.2 集合类体系结构 二、Collection集合 2.1 Collection集合概述和使用 是单例集合的顶层接口,它表示一...
  • 集合(collection)

    千次阅读 2021-02-07 20:11:29
    使用数组存放数据的弊端:长度不可变,而集合可以动态的添加值java集合类不仅可以存储数量不等的多个对象,还可以保存具有映射关系的关联数组/** 1.存储对象可以考虑:①数组 ②集合* 2.数组存储对象的特点:Student...
  • 集合的概念以及集合框架的介绍

    千次阅读 2018-07-01 13:36:55
    集合的概念 集合框架是为表示和操作多个对象而规定的一种统一的标准体系结构 任何集合框架都包含三大块内容:对外的接口、接口的实现和对集合运算的算法。 接口:即表示集合的抽象数据类型,接口提供了让我们对...
  • jsp页面获取集合长度

    千次阅读 2018-02-03 13:28:41
    需要使用fn标签 需要引用: http://java.sun.com/jsp/jstl/functions"prefix="fn"%> 用其length属性可以获得集合数量:${fn:length(list)} (fn后面是冒号) 其中的list就是标签中items属性的值
  • nums = [-1, 2, 4, 0, -2, 1, 3, 4] counts = {} for i in nums: counts[i] = counts.get(i, 0) + 1 print(counts) # {-1: 1, 2: 1, 4: 2, 0: 1, -2: 1, 1: 1, 3: 1}
  • java中的集合

    万次阅读 多人点赞 2021-11-20 20:26:04
    java集合概述 Java 集合可分为 Collection 和 Map 两种体系 Collection接口:单列数据,定义了存取一组对象的方法的集合 List:元素有序(指的是存储时,与存放顺序保持一致)、可重复的集合 Set:元素无序、不可...
  • 目录一、集合容器概述1. 什么是集合2. 集合的特点3. 集合和数组的区别4. 使用集合框架的好处5. 常用的集合类有哪些?6. List,Set,Map三者的区别?7. 集合框架底层数据结构8. 哪些集合类是线程安全的?9. Java集合...
  • 找出两个集合中相同的数 给定两个正整数的集合,分别含有m个和n个元素,找出在两个集合中都出现过的数并输出。 输入格式: 第一行输入两个整数m和n,分别表示两个集合中的整数的个数。 第二行输入m个用空格隔开的整数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 406,815
精华内容 162,726
关键字:

如何获得集合的数量