Collections，Map以及Collections工具类复习

已于 2022-05-10 19:15:05 修改
阅读量1k 收藏
点赞数
文章标签： java 开发语言
于 2022-05-10 16:41:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46058550/article/details/124690371
版权

文章目录

一 Collection

1.1概念

集合存储的优点： 初始化时长度可不定 提供的方法比较多 对于增删改 效率较高 可有序 可无序 可重复 可不重复

1.2 体系结构

请添加图片描述

/**
 * 分为Collection 和Map体系
 *Collection接口：  单列数据   常用的实现类   List 有序，可重复 Set 无序，不可重复
 *              ArrayList LinkedList Vector
 *              HashSet，Linked，TreeSet
 *      Map: 双列数据  key-value数据存储
 *          HashMap LinkedMap TreeMap  HashTable  Properties
 */
1.3 Collection中的方法
    @Test
    public void te1() {
        Collection coll = new ArrayList();
        Collection coll1 = new ArrayList();
        //boolean add(E e);//添加元素
        coll.add(new Date());
        System.out.println(coll.size());//1 有多少元素
        coll1.add(120);
        //addAll(Collection coll)
        coll.addAll(coll1);
        System.out.println(coll.size());//2
        System.out.println(coll);//相当于toString ArrayList的

        //boolean isEmpty(); 判断里面是否有数据
        System.out.println(coll.isEmpty());//false
        //void clear(); 清空元素 仍保留对象
        coll.clear();
        System.out.println(coll.isEmpty());//true
//         boolean contains(Object o);  判断的不是地址值而是内容
//         在判断是 会调用对象自己重写的equals 内容相等
        coll.add(110);
        System.out.println(coll.contains(110));//true
        Collection coll3 = Arrays.asList(110);
//        boolean containsAll(Collection<?> c); 判断coll3是否全部都在coll里面
        System.out.println(coll.containsAll(coll3));//true
//      boolean remove(Object o);  也是从第一个开始找 既然是找内容相等 就依然要调用equals
        System.out.println(coll.remove(110));
        coll.add(110);
//         boolean removeAll(Collection<?> c); 依然要调用equals
        System.out.println(coll.removeAll(coll3));//true
    }

    @Test
    public void te2() {
        Collection coll = new ArrayList();
        Collection coll1 = new ArrayList();
        //boolean add(E e);//添加元素
        coll.add(123);
        coll.add(456);
        coll1.add(123);
//        boolean retainAll(Collection<?> c);保留一样的，删除不一样的
        System.out.println(coll.retainAll(coll1));//true
        System.out.println(coll);
//        boolean equals(Object o);
        System.out.println(coll.equals(coll1));//true  ArrayList 是有序的 所以顺序不对也是false
//         int hashCode(); 返回当前对象的hash值
        System.out.println(coll.hashCode());
//        集合->Array数组Object[] toArray();
        Object[] b = coll.toArray();
//        数组->集合 public static <T> List<T> asList(T... a)
        List<int[]> ints = Arrays.asList(new int[]{123});
        System.out.println(ints);//[[I@4ee285c6] 一维数组 只有一个对象 认为是一个元素
        List arr = Arrays.asList(123, 456);
        System.out.println(arr);//[123, 456]
    }

2. Iterator 迭代器（遍历集合）

其对象主要用于遍历Collection集合中的元素， 主要就是为容器 遍历对象。

//         hasNext(); 判读是否还有下一个元素
//        next();指针下移并返回
//        void remove() 删除集合中的元素 删除 的是指针所指的元素

   @Test
    public void te3() {

        Collection coll = Arrays.asList(123, 456, false, "123");
        //Iterator<E> iterator();每次调用coll.iterator(); 都会返回一个新的Iterator对象
        Iterator iterator = coll.iterator();
        //iterator的遍历
        // boolean hasNext(); 判读是否还有下一个元素
        while (iterator.hasNext()) {
            //  E next(); 1.初始的时候指向的是第一个元素上面 2.指针下移 3.下移之后 把下移之后的元素返回
            System.out.println(iterator.next());
//            foreach 内部调用的仍然是迭代器
//              执行过程 就是 每次取出coll中的一个元素 赋值给Object obj

            for (Object obj : coll) {
                System.out.println(obj);
            }
        }

    }

3.ArrayList

3.1 概念

作为list的主要实现类 线程不安全的，效率高 底层使用 Object[]

3.2 jdk7和jdk8的源码区别
  //1.7源码 创建初始化为10的一个数组 然后不够以1.5倍容量进行扩充，并Arrays.copyOf()把之前的复制 相当于饿汉式
    //1.8 初始化时没有创建 而是add操作时进行创建 长度为10 的数组 其后相等 相当于懒汉式

4.LinkedList

4.1概念

对于频繁的 插入，删除操作 主要存着的就是对上一个元素和下一个元素的标识 可以把它转移给新的元素，只影响相邻的2个元素。
底层双向链表 既知道上面的，也知道下面的。

4.2底层实现
transient Node<E> first; transient Node<E> last; 默认值为null add(123)

    //把123封装到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;
        }
    }

5. Vector

5.1概念

作为list的古老实现类 线程安全的，效率低

5.2 底层使用
protected Object[] elementData;
//初始化为10 的数组扩容为原理数组的2倍 线程安全一般也不用

6.List的常用方法

@Test
    public void teList() {
        //List 主要就是比 Collection 多了几个索引的方法
        ArrayList aList = new ArrayList();
        aList.add(123);
        aList.add(456);
        aList.add(123);
        aList.add("hhh");
//           public void add(int index, E element)
        aList.add(2, 234);//在index 位置，插入element
        System.out.println(aList);//[123, 456, 234, 123, hhh]

        List l = Arrays.asList("aa", "bb");
// public boolean addAll(int index, Collection<? extends E> c) 在index位置上 添加一个集合
//        如果是 add(l) 是把l看成一个整体 即不管l有几个元素 添加进去时都会当成一个集合元素
        aList.addAll(1, l);
//        public E get(int index) 获取第index个元素
        System.out.println(aList.get(1));//aa
//      public int indexOf(Object o) 返回集合中首次出现的位置 不存在返回-1
        System.out.println(aList.indexOf(123));
//        public int lastIndexOf(Object o) 返回集合中最后一次出现的位置 不存在返回-1
//        public E remove(int index)  删除index位置的元素 返回删除的元素 删除之后后面往前移动
//        注意Collection 中也有个 boolean remove(Object o)  删除的是那个元素
        System.out.println("remove"+aList.remove(2));
//        public List<E> subList(int fromIndex, int toIndex)  返回的是左闭右开的集合
        System.out.println("subList"+aList.subList(1, 3));


    }

Set

1.并没有定义新的方法，主要是其父类Collection的
2.无序性：不等于随机性。并非按照数组的索引添加，而是按照数据的hash值决定的
3.不可重读性： 按照equals 判断是否相等，即要有重写equals 在判断前会进行hashCode

7.HashSet

7.1概念

作为set的主要实现类 可以存null值

7.2.底层分析
     *  添加元素的过程
     *  存放一个元素时计算其hash值，经过计算得出其应该放在那个位置上（这个是数组的索引）（底层实现是数组＋链表），如果有第二个元素
     *  也在此位置上，判断其hash值是否相等，如果相等再判断equals方法，如果还相等，则不添加，反之hash或者equals不等，
     *  则加在其索引位置的链表上，以链表的方式存储，
     *  jdk7 该元素放在数组中指向原来的元素，
     *  jdk8原来的元素位置不变指向该元素
     *要求：向Set中添加数据 ，其 数据所在的类 要 重写equals和hashCode方法

8.LinkedHashSet

8.1概念

作为HashSet的子类 ，遍历时是按添加的顺序遍历的，在添加数据的同时还保存了两个引用，即上一个 和下一个，记录前一个数据 和后一个数据。

8.2底层结构理解

请添加图片描述

9.TreeSet

9.1 概念

可以按照添加对象的指定属性进行排序

9.2排序要求

1.要求添加的数据必须是相同类的对象
2。自燃排序 要求添加的的数据重写 public int compareTo(Object o) 排序从小到打大（默认）还是从大到小是根据compareTo(Object o) 决定的
特殊 TreeSet默认是按照compareTo比较的 如果这个方法返回0 默认认为就是相等的 则此不会进行添加
3.定制排序

 @Test
    public void teTreeSet(){
        //自然排序要求添加的的数据重写   public int compareTo(Object o) 
        //排序从小到打大（默认）还是从大到小是根据compareTo(Object o) 决定的
        Set set = new TreeSet();
        set.add(new User("aa",12));
        set.add(new User("cc",12));
        set.add(new User("bb",18));

// User{name='aa', age='12'}
//User{name='bb', age='18'}
//User{name='cc', age='12'}


        for (Object o:
                set) {
            System.out.println(o);//h h 123

        }
        //定制排序  public TreeSet(Comparator<? super E> comparator) 此时按照 Comparator中的compare 进行排序
       Comparator comparator = new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof User && o2 instanceof User)  {
                User user1 = (User)o1;
                User user2 = (User)o2;
                return  Integer.compare(user1.age, user2.age);

            }else {
                throw new RuntimeException("类型不匹配");
            }
            }
        };
        Set set1 = new TreeSet(comparator);
        set1.add(new User("aa",12));
        set1.add(new User("cc",14));
        set1.add(new User("bb",18));
        System.out.println("~~~~~~~~~~~~~~~~~~~");
        for (Object o:
                set1) {
            System.out.println(o);//h h 123

        }
// User{name='aa', age='12'}
//User{name='cc', age='14'}
//User{name='bb', age='18'}
    }

User中定义的compareTo

  @Override
    public int compareTo(Object o) {
        if (o instanceof User){
            User user = (User)o;
            //根据名字的顺序进行比较 此时调的是String的compareTo
            return this.name.compareTo(user.name);
        }else {
            throw new RuntimeException("类型不匹配");
        }

    }

二 Map

1.概念

双列数据 存储key-value数据

2.结构

    /*
   
HashMap  作为主要的实现类  线程不安全 效率高  可以存储null的key和Value

         		LinkedHashMap 遍历元素时，按照添加的顺序遍历的 在HashMap的基础上 增加了指针  频繁遍历是使用

                TreeMap  主要用来排序  ，此时考虑key 的自然排序或者定制排序，底层是红黑树  和TreeList
                Hashtable 古老实现类线程安全，效率低
                       Properties  key和value都是String  主要用来做配置文件
     */

请添加图片描述

3.Map结构理解

Map 中的key-value 结构 key无序，使用set的去存储不重复 所以key 所在的类要重写 equals 和 hashCode方法
value可重复 用collection存储 所在的类要重写 equals
Map中的Entry : key-value构成了Entry对象 无序，不可重复，用set储存

4.HashMap

1.概念

作为主要的实现类 线程不安全 效率高 可以存储null的key和Value

2.底层实现原理
/*底层：
        jdk7的时候 数组+链表 长度16的数组 Entry数组   put 时 计算hash值得到其存放位置  其位置为空时，添加成功 位置不为空时
        比较key的hash值 hash值不同添加成功 相同 比较equals 再相同 把新的value替换到原来的value上 反之 添加成功
        当put不下时 扩容为原来长度的两倍 扩容并非到16时才扩容 16*0.75时候（且要存放的位置非空）就扩容
        8的时候 链表+数组+ 红黑树 当链表长度大于8 且当前数组的长度大于64时会用红黑树
        临界值：length*0.75
        加载因子：0.75 小了数组利用率低 大了链表中的数据过多
        存在加载临界值的原因就是 既然是通过hash值计算的索引（具有不确定性），那就是不像数组那样 为空就去填充 ，或许一个位置通过链表存放了很多个，
        但是其还有很多位置为空
                new 的时候并没有赋予长度 当首次调用put时 创建长度为16的数组 底层数组是Node
    * */

请添加图片描述

5.LinkedHashMap

1.概念

遍历元素时，按照添加的顺序遍历的 在HashMap的基础上 增加了指针 频繁遍历时使用。

2.底层实现原理
    *       put 时调用的是Map的然后调用了 Map的putVal 然后调用了重写的的newNode
    *       然后 Entry继承了父类的Node 并添加了 before和after属性  记录元素的添加记录

6.TreeMap

1.概念

主要用来排序 ，此时考虑key 的自然排序或者定制排序，底层是红黑树 和TreeList

2.TreeMap 自然排序和定制排序

注：只能按照key进行排序

   @Test
    public void te3(){
        Map<String, Object> map = new TreeMap<>();
        map.put("aa",119);
        map.put("cc",110);
        map.put("bb",110);
        //1.自然排序  即实现Comparable接口
        Set<Map.Entry<String, Object>> entries = map.entrySet();
        for (Object o:
                entries) {
            System.out.println(o);
            //aa=119
            //bb=110
            //cc=110
        }
        //2.定制排序 实现Comparator接口
        Map<String, Object> map1 = new TreeMap<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                if ( o1 instanceof String && o2 instanceof String){
                    String str1 = (String)o1;
                    String str2 = (String)o2;
//                    加 - 号 是其相反的顺序 进行排序
                    return -str1.compareTo(str2);
                }else {
                    throw new RuntimeException("类型不匹配");
                }
            }
        });
        map1.put("aa",119);
        map1.put("cc",110);
        map1.put("bb",110);
        Set<Map.Entry<String, Object>> entries1 = map1.entrySet();
        for (Object o:
                entries1) {
            System.out.println(o);
                //cc=110
                //bb=110
                //aa=119
        }
    }

7. Map 的常用方法

请添加图片描述

  @Test
    public  void  te1(){
        Map<String, Object> map = new HashMap<>();
        Map<String, Object> map1 = new HashMap<>();
//         V put(K key, V value); 添加一个键值对 如果key一样，返回值为上一个value 反之返回null
        System.out.println(map.put("aa", 110));//null
        System.out.println(map.put("aa", 120));//110
        map1.put("aa",119);
        map.put("bb",110);
        System.out.println(map);//{aa=120}
//        void putAll(Map<? extends K, ? extends V> m); 添加一个Map
        map.putAll(map1);//{aa=120, bb=110}
//        V remove(Object key); 返回remove里卖弄的value 不存在返回null
        System.out.println(map.remove("aa")); //119
//        void clear(); 清空数据 并不是删除此map对象
        map.clear();
//       V get(Object key); 返回其对应的value 不存在 返回null
        System.out.println(map1.get("aa"));//119
//         boolean containsKey(Object key); 是否包含指定的key boolean containsValue(Object value);是否包含指定的value
        System.out.println(map1.containsKey("aa"));//true
        System.out.println(map1.containsValue(119));//true
//         boolean isEmpty();
        System.out.println(map.isEmpty());//true
//        int size(); 返回有几个键值对
        System.out.println(map.size());//0

    }

8. 遍历

 @Test
    public void te2(){
        Map<String, Object> map = new HashMap<>();
        map.put("aa",119);
        map.put("bb",110);
        map.put("cc",110);
        //1.遍历所有的key    Set<K> keySet();
        Set<String> set = map.keySet();
        for (Object s:
             set) {
            System.out.println(s);
            //aa
            //bb
            //cc
        }
//        2.遍历所有的value  Collection<V> values(); 注意遍历key和value的白遍历顺序是一样的
        Collection<Object> values = map.values();
        for (Object o:
             values) {
            System.out.println(o);
                //119
                //110
                //110
        }
//        3.1遍历所有的key和value Set<Map.Entry<K, V>> entrySet();
        Set<Map.Entry<String, Object>> entries = map.entrySet();
        for (Object o:
             entries) {
            System.out.println(o);
            //aa=119
            //bb=110
            //cc=110
        }
//        3.2 遍历所有的key和value 用Iterator
        Set<Map.Entry<String, Object>> entries1 = map.entrySet();
        Iterator<Map.Entry<String, Object>> iterator = entries1.iterator();
        while (iterator.hasNext()){
            Object o = iterator.next();
//            entrySet集合元素里面都是Entry
//            Entry 是Map 里面定义的内部接口  里面有getKey() 和getValue()  setValue(V value);
            Map.Entry entry = (Map.Entry) o;
            System.out.println(entry.getKey() + "-->" + entry.getValue());
                //aa-->119
                //bb-->110
                //cc-->110
        }

    }

9.Properties

9.1概念

Properties的key和value都是String 主要用来处理属性文件

9.2代码实现
public class PropertiesTest {
        //      Properties的key和value都是String  主要用来处理属性文件

    public static void main(String[] args) throws Exception {
        Properties properties = new Properties();
//        通过IO流获取配置文件 
        FileInputStream fis = new FileInputStream("jdbc.properties");
        properties.load(fis);
        System.out.println(properties.getProperty("name"));
        System.out.println(properties.getProperty("pwd"));
                //admin
                //123
//        流的关闭
        fis.close();
    }
}

jdbc.properties
注：不要有空格什么的，放在项目下，防止找不到文件

name=admin
pwd=123

三 Collections工具类

1.概念

Collections是用来操作Collection 和Map的一个工具类

2.一些常用的方法

    @Test
    public void te1(){
        List list = new ArrayList();
        list.add(8);
        list.add(12);
        list.add(23);
        list.add(4);
        System.out.println(list);//[8, 12, 23, 4]
//        public static void reverse(List<?> list) 反转
        Collections.reverse(list);
        System.out.println(list);//[4, 23, 12, 8]
//        public static void shuffle(List<?> list) 随机化
        Collections.shuffle(list);
        System.out.println(list);//无序 [12, 4, 8, 23]
//         public static <T extends Comparable<? super T>> void sort(List<T> list) 此时按照的是Integer里面的Comparator方法
        Collections.sort(list);
        System.out.println(list);//[4, 8, 12, 23]
//         public static void swap(List<?> list, int i, int j) 交换 list 里面的i和j元素
        Collections.swap(list,1,3);
        System.out.println(list);//[4, 23, 12, 8]
//         public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
//        public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)
//        此时按照的是Integer里面的Comparator方法 的最大值和最小值
        System.out.println(Collections.max(list));//23
        System.out.println(Collections.min(list));//4
//         public static int frequency(Collection<?> c, Object o) list集合里面 o出现了几次
        System.out.println(Collections.frequency(list,12));//1


//         public static <T> void copy(List<? super T> dest, List<? extends T> src)
//        注意源码中 if (srcSize > dest.size())
//                  throw new IndexOutOfBoundsException("Source does not fit in dest");
//        所以应该这样copy
        List destList = Arrays.asList(new Object[list.size()]);
        Collections.copy(destList,list);
        System.out.println(destList);//[4, 23, 12, 8]


    }

3.当涉及到线程安全时

提供了多个synchronized…的方法 使集合包装成线程同步的集合，从而解决多线程安全问题。
请添加图片描述

脑袋空白的此刻
关注
Java基础知识Map集合与Collections工具类
weixin_49087146的博客
03-23 446
Map Map : 无序的,去重的 键值对数据的集合 键值对->映射关系 价值对: K-V K键 : 无序的,去重的|唯一的 ---> Set V值 : 无序的,可重复 ---> Collection K-V可以为任意引用数据类型 特点: 一个key只能对应一个Value key相同value覆盖 遍历方式: 1.values
Map集合以及Collections工具类的使用
瘾力的博客
11-13 481
一、Map （一）概述 1、体系位置：双列集合的顶层接口 2、类比理解：单词含义：地图，在地图上的每一个点，都表示生活中的一个具体位置。地图的点和生活中的位置，有一一对应的关系，这种关系是通过穷举罗列的。 3、数据结构：描述的是一个数据（Key）到另一个数据（Value）的映射关系 (1)Key（键）：有规律的，容易记忆的，是一个简单的数据 (2)Value（值）：没有规律，不容易记忆，复杂的数据 (3)操作：通过Key来寻找Value 4、映射：对应关系 (1)数学：y = x * x (2)穷举罗列：{
Java 2中的Collections框架 -- Map
键者天行
07-26 6835
在Java 2的Collections框架中，主要包括两个接口及其扩展和实现类：Collection接口和Map接口。两者的区别在于前者存储一组对象，后者则存储一些关键字/值对。public interface java.util.Map {    //Altering Methods      public Object put(Object key, Object value);       
Map集合、Collections类
李十八的博客
05-14 444
  在生活中有许多带有映射关系的数据，比如一个身份证号就对应一个人，那么我们如何存储这样的数据呢，在Java中为我们提供了另外的集合：Map集合。Map集合常用的实现类有（ HashMap, Hashtable, LinkedHashMap TreeMap Properties）   Map集合属于双列集合，是通过键来找值；在Map集合中键不能重复，每个键也只能对应一个值。如果键相同的时候，...
Map与Collections
未知的希望，是我不灭的信仰
03-27 517
上一篇文章分享了个人对于list和set的看法，翻了一下部分底层，这次来分享一下map map在我们的使用中非常频繁，因为它的用法很灵活，它的一些方法也可以省掉我们很多麻烦 这里补充一点上一次没说的东西，Collections，就像Objects一样，Collections是处理集合的工具类，常用的有这么几种： Collections.shuffle(List<?> list) // 打乱集合中元素顺序 Collections.sort(List<T> list)
java集合Collection(单列集合)、Map(双列)
热门推荐
thisfeng
08-12 1万+
———— 一、集合(Collection) (1)集合的由来? 我们学习的是Java -- 面向对象 -- 操作很多对象 -- 存储 -- 容器(数组和StringBuffer) -- 数组 而数组的长度固定，所以不适合做变化的需求，Java就提供了集合供我们使用。 (2)
Java操作集合工具类Collections使用详解
08-25
Collections工具类提供了大量方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法。 Collections工具类中的方法可以分为以下几类： 1. 排序操作：Collections...
Collections工具类_动力节点Java学院整理
08-30
Collections工具类是Java中一个功能强大的工具类，提供了大量针对Collection/Map的操作。下面我们将对该工具类进行详细的介绍。 排序操作 Collections工具类提供了多种排序操作，主要针对List接口相关。这些方法...
Java容器类详解：List、Set、Map与Collections工具类
"Java容器类主要包括List、Set和Map接口，以及Collections工具类。这些是Java编程中常用的数据结构，用于存储和管理对象。ArrayList、Vector、Set接口、HashSet、HashMap以及Collections类的方法是本文档的重点。" ...
Java入门笔记之（第六章 collections之map）
沉晨尘宸的博客
06-03 529
Map三.实例第一步：建立User类第二步：创建基础list接口第三步：基础键值对获取第四步:对map进行提取输出 三.实例 第一步：建立User类 这个类组成：地名，序号，名字等，包括了常见的存取地方名字，序号等功能 package demo; public class User { public static final String HAERBIN = "哈尔滨"; public static final String BEIJING = "北京"; private int i
第十三章 、集合（续）---Map集合、Collections集合工具类
爱码者的博客
07-27 1008
Map集合、Collections集合工具类 目录 文章目录Map集合、Collections集合工具类目录主要内容学习目标第十三章 集合（续）13.7 Map集合13.7.1 概述13.7.2 Map常用方法13.7.3 Map集合的遍历13.7.4 Map的实现类们**1、HashMap和Hashtable的区别与联系****2、LinkedHashMap****3、TreeMap****4...
Collections之Map&List&Set详解
Joanna_or_zhouzhou的博客
05-11 234
Collections之Map&List&Set详解
Collections和Map小结
qq_39805535的博客
11-18 306
在学习过程中，总结了一点~ 接口 Collection 里面声明了适用于Set和List的通用方法 Set和list接口集成了Collection Object to Array[] 返回一个数组，该数组包含集合中所有元素 一。Set: 一种无序的，放进去的对象不能重复，Set集合中存放的是对象的引用， 当一个新的对象加入Set集合中时，它遍历既存对象，通过equals方法比较...
Java笔记-Collection集合-Map集合常用方法、遍历方式、原理
weixin_46057732的博客
04-29 903
Collection是单列集合的根接口，Collection接口下面又有两个子接口List接口、Set接口，List和Set下面分别有不同的实现类，如下图所示：List：有序、可重复、有索引Set：无序、不可重复、无索引HashSet：无序、不可重复、无索引：有序、不可重复、无索引TreeSet：默认升序、不可重复、无索引//简单确认一下Collection集合的特点//存取顺序一致，可以重复，有索引//存取顺序不一致，不重复，无索引。
List / Map / Collections方法
janghaifeng的博客
11-07 146
Collections则是集合类的一个工具类/帮助类，其中提供了一系列静态方法，用于对集合中元素进行排序、搜索以及线程安全等各种操作。 1) 排序(Sort)使用sort方法可以根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable接口。此列表内的所有元素都必须是使用指定比较器可相互比较的 double array[] = {112, 111, 23, 4
ES6学习——集合（Collections）：Map 应用示例
Challenge Next Challenge
01-14 645
先看一下如何遍历Map的entries，keys，values： let map = new Map([ [false, 'no'], [true, 'yes'], ]); for (let key of map.keys()) { trace(key); } for (let value of map.values()) { trace(value);
Collections常用功能、Set与Map集合
LyonBlog
12-30 386
第一章 Collections类 1.1 Collections常用功能 概述：java.util.Collections是集合工具类，用来对集合进行操作。 常用方法： public static void shuffle(List<?> list) :打乱集合顺序。 public class Test1_shuffle { public static void main(String[] args) { // public static void shuffle
Java（四）：Java集合（ Collection ，Map）、Collections工具类
最新发布
qq_54517101的博客
05-17 878
Collection接口继承了java.lang.Iterable接口，该接口有一个iterator()方法，那么所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象，用于遍历集合中的元素。这里的无序性与元素的添加位置有关。这里删除失败是因为：最开始AA的hash值假设是3，那么改为CC之后，哈希值其实是没变的，so当删除P1时，计算P1的hash值不是3（此时hash值是按照CC算的），所以就找不到之前那个AA的位置，删除失败。
Java基础_Map集合_Collections类
weixin_63736489的博客
01-18 523
Java基础_Map集合_Collections类
Collections工具类详解：操作、排序与查找
Collections 是Java Collections框架中的一个核心类，它提供了一系列用于操作各种集合框架（如List, Set, Map等）的方法。Collections并非Collection的复制品，而是其扩展，专门用于对集合进行高效的、线程安全的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值