Java集合

最新推荐文章于 2023-03-08 09:44:17 发布
最新推荐文章于 2023-03-08 09:44:17 发布
阅读量100 收藏
点赞数
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37280534/article/details/118105216
版权

集合

1.集合结构图

在这里插入图片描述
在这里插入图片描述

2.数组和集合

在这里插入图片描述
在这里插入图片描述

3.Collection接口

3.1 Collection接口和常用方法

在这里插入图片描述
测试常用方法：对于remove，可删除对象也可按照下标删除，下标优先。

package com.collection_;

import java.util.ArrayList;
import java.util.List;

/**
 * Created on 2021/6/22.
 *
 * @author Ryan_小王
 */
@SuppressWarnings({"all"})
public class Test {
    public static void main(String[] args) {
        List arrayList = new ArrayList();
        arrayList.add("wcw");
        arrayList.add("wj");
        arrayList.add(10);
        arrayList.add(0,12);
        arrayList.remove(0);
        System.out.println(arrayList);
        System.out.println(arrayList.contains("wcw"));
        System.out.println(arrayList.size());
        System.out.println(arrayList.isEmpty());
        arrayList.clear();
        //添加多个元素
        List arrayList1 = new ArrayList();
        arrayList1.add(13);
        arrayList1.add("wc");
        arrayList.addAll(arrayList1);
        System.out.println(arrayList.containsAll(arrayList1));
        arrayList.removeAll(arrayList1);
        System.out.println(arrayList);

    }
}

3.2 Collection接口遍历元素

方式1：使用Iterator（迭代器）

  • Iterator对象称为迭代器，主要用于遍历Collection集合中的元素
  • 实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象，即可以返回一个迭代器。
  • Iterator仅用于遍历集合，Iterator本身并不存放对象。
package com.collection_;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * Created on 2021/6/22.
 *
 * @author Ryan_小王
 */
public class CollectionIterator {
    public static void main(String[] args) {
        Collection coll = new ArrayList();

        coll.add("wcw");
        coll.add(12);
        coll.add("hsp");
        
        Iterator iterator = coll.iterator();
        //hashNext():判断是否还有下一个元素
        //快捷键itit
        while (iterator.hasNext()) {
            //next()：1.下移动 2.将下移以后集合位置上的元素返回
            Object obj = iterator.next();
            System.out.println(obj);
        }
    }
}

方式2：使用增强for，在Collection集合

1.使用增强for，在Collection集合
2.增强for，底层仍然是迭代器
3.增强for可以理解成就是简化版本的迭代器遍历
4.增强for可以直接用于数组

package com.collection_;

import java.util.ArrayList;
import java.util.Collection;

/**
 * Created on 2021/6/22.
 *
 * @author Ryan_小王
 */
public class CollectionIterator {
    public static void main(String[] args) {
        Collection coll = new ArrayList();

        coll.add("wcw");
        coll.add(12);
        coll.add("hsp");

        //1.使用增强for，在Collection集合
        //2.增强for，底层仍然是迭代器
        //3.增强for可以理解成就是简化版本的迭代器遍历
        for (Object obj: coll) {
            System.out.println("元素：" + obj);
        }
        
        //增强for可以直接用于数组
        int[] nums = {1, 2, 4};
        for (int i: nums) {
            System.out.println(i);
        }
        
    }
}

3.3 List

1.基本介绍

List接口是Collection接口的子接口，List集合类中元素有序、且可重复，支持索引访问，实现List接口常用的类有：ArrayList、LinkedList和Vector。

2.List接口常用方法在这里插入图片描述
3.List三种遍历

多一个普通for循环获取：
1.使用增强for
2.使用Iterator（迭代器）
3.普通for循环，因为ArrayList底层其实是数组。

package com.collection_;

import java.util.ArrayList;
import java.util.List;

/**
 * Created on 2021/6/22.
 *
 * @author Ryan_小王
 */
public class CollectionIterator {
    public static void main(String[] args) {
        List list = new ArrayList();

        list.add("wcw");
        list.add(12);
        list.add("hsp");


        //1.使用增强for，在Collection集合
        //2.增强for，底层仍然是迭代器
        //3.增强for可以理解成就是简化版本的迭代器遍历
        for (Object obj: list) {
            System.out.println("元素：" + obj);
        }
        
		Iterator iterator = coll.iterator();
        //hashNext():判断是否还有下一个元素
        //快捷键itit
        while (iterator.hasNext()) {
            //next()：1.下移动 2.将下移以后集合位置上的元素返回
            Object obj = iterator.next();
            System.out.println(obj);
        }
    }

        //使用普通for循环
        for (int i=0; i < list.size(); i++) {
            Object obj = list.get(i);
            System.out.println(obj);
        }

    }
}

3.3.1 ArrayList扩容机制

1.ArrayList中维护了一个Object类型的数组elementData。

2.当创建ArrayList对象时，若使用无参构造器，则初始elementData容量为0，第一次添加，则扩容elementData为10，如需再次扩容，则扩容elementData为1.5倍。

3.若使用自定大小的构造器，则初始elementData容量为指定大小，如果需要扩容，则直接扩容elementData为1.5倍。
在这里插入图片描述
无参构造器扩容流程图：
在这里插入图片描述
自定大小的构造器扩容机制：
在这里插入图片描述
第一次扩容就按照elementData的1.5倍扩容，整个流程和前面的一样。

3.3.2 Vector

1.基本介绍

Vector底层也是一个对象数组，Vector是线程同步的，即线程安全，Vector类的操作方法带有synchronized。在开发中，需要线程同步安全时，考虑使用Vector，若是单线程则可以使用ArrayList，效率更高一点。
在这里插入图片描述
2.ArrayList和Vector的比较

扩容机制不同，ArrayList不是线程安全，Vector是线程安全。
在这里插入图片描述

3.3.3 LinkedList

1.基本介绍
在这里插入图片描述
在这里插入图片描述
双向链表的定义和使用举例：

package com.collection_;

/**
 * Created on 2021/6/23.
 *
 * @author Ryan_小王
 */
public class LinkedList01 {
    public static void main(String[] args) {
        Node jack = new Node("Jack");
        Node mike = new Node("Mike");
        Node smith = new Node("Smith");

        //链接起来
        jack.next = mike;
        mike.next = smith;
        smith.pre = mike;
        mike.pre = jack;

        //头指针和尾指针
        Node first = jack;
        Node last = smith;

        System.out.println("======正向遍历======");
        //正向遍历
        while (true) {
            if (first == null) {
                break;
            }
            System.out.println(first);
            first = first.next;
        }


        System.out.println("=======反向遍历=======");
        //反向遍历
        while (true) {
            if (last == null) {
                break;
            }
            System.out.println(last);
            last = last.pre;
        }
    }
}

class Node {
    public Object item;
    public Node next;
    public Node pre;

    public Node(Object name) {
        this.item = name;
    }

    public String toString() {
        return "name=" +item;
    }
}

2.ArrayList和LinkedList的比较

底层实现不同，ArrayList底层是可变数组，LinkedList底层实现是双向链表；增删效率不同，ArrayList增删效率较低，因为涉及到数组扩容，LinkedList增删效率较高，通过链表追加；改查效率不同，ArrayList较高，可直接索引找到，LinkedList较低，得从头开始。
在这里插入图片描述

3.4 Set

1.基本介绍

  1. 无序
  2. 不允许重复，只允许一个null
  3. Set接口实现类：HashSet、TreeSet、LinkedHashSet…

在这里插入图片描述

3.4.1 HashSet

1.基本介绍

  1. HashSet实现了Set接口，HashSet底层是HashMap，HashMap底层是（数组+链表+红黑树）
  2. 可以存放null值，但是只能有一个null
  3. HashSet不保证元素是有序的，取决于hash后，再确定索引的结果.(即,不能保证存放元素的顺序和取出顺序一致）.
  4. 不能有重复元素/对象
    在这里插入图片描述

2.底层机制说明

  1. HashSet添加元素底层实现(hashCode()+equals()).
  2. HashSet的扩容和转成红黑树机制

注意：加入第一个元素时候扩容到16，临界值为12，加入前八个到同一链表，此时数组还是16，加入第九个元素时候，数组扩容机制启动，数组扩容到32，临界值为24。
在这里插入图片描述

练习：在HashSet集合中添加员工，若name和age相同则不能添加，归根到底就是重写equals()和hashcode()方法。

package com.collection_;

import java.util.HashSet;
import java.util.Objects;

/**
 * Created on 2021/6/25.
 *
 * @author Ryan_小王
 */
public class HashSetEx01 {
    public static void main(String[] args) {
        Employee wcw = new Employee("wcw", 12);
        Employee wc = new Employee("wc", 12);
        Employee wcw2 = new Employee("wcw", 12);

        HashSet hashSet = new HashSet();
        hashSet.add(wcw);
        hashSet.add(wc);
        hashSet.add(wcw2);

        System.out.println(hashSet);



    }
}

class Employee {
    private String name;
    private  int age;

    public Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return age == employee.age &&
                Objects.equals(name, employee.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

3.4.2 LinkedHashSet

1.基本说明
只是换成了双向链表，这样可以保证元素插入和取出顺序一致。其余的操作和扩容机制和HashSet一样。

注意：HashSet和LinkedHashSet一个是存放Node类型，一个是存放Entry类型。

HashSet的table维护的是Node类对象数组，Node是HashMap的静态内部类，插入的元素也是Node类的对象。
在这里插入图片描述LinkedHashSet维护也是Node类对象数组，Node是HashMap的内部类，插入的元素是Entry类的对象。Entry是Node的子类。在这里插入图片描述
2.全面说明
在这里插入图片描述
在这里插入图片描述

3.4.3 TreeSet

底层是TreeMap，可以排序，通过传入实现了Comparator接口的匿名内部类，重写compare()方法定制排序规则。

package com.collection_;

import java.util.Comparator;
import java.util.TreeSet;

/**
 * Created on 2021/6/27.
 *
 * @author Ryan_小王
 */
@SuppressWarnings({"all"})
public class TreeSet_ {
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String)o2).compareTo((String)o1);
            }
        });
        treeSet.add("tom");
        treeSet.add("jack");
        treeSet.add("so");
        treeSet.add("bom");
        treeSet.add("a");
        System.out.println(treeSet);
    }
}

//结果：[tom, so, jack, bom, a]

注意：重写了compare()方法，会根据该方法判断元素是否加入，如下举例中，根据字符串的长度来排序，"bom"和"tom"的长度都是3，则不会被加入，最终的结果为[a, so, tom, jack]。

package com.collection_;

import java.util.Comparator;
import java.util.TreeSet;

/**
 * Created on 2021/6/27.
 *
 * @author Ryan_小王
 */
@SuppressWarnings({"all"})
public class TreeSet_ {
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String)o1).length() - ((String)o2).length();
            }
        });
        treeSet.add("tom");
        treeSet.add("jack");
        treeSet.add("so");
        treeSet.add("bom");
        treeSet.add("a");
        System.out.println(treeSet);
    }
}

//结果：[a, so, tom, jack]

4.Map接口

1.基本介绍
在这里插入图片描述

4.1 HashMap

1.Map接口的特点

EntrySet存放的Entry只是指向，真正存放数据的地方还是在HashMap的Node。
在这里插入图片描述

1.k-v最后是HashMap$Node node = newNode(hash, key, value, null)

2.k-v为了方便程序员遍历，还会创建EntrySet集合，该集合存放的元素类型是Entry，而一个Entry对象就有k,v EntrySet<Entry<K,V>> 即：transient Set<Map.Entry<K,V>> entrySet;
3.entrySet中，定义的类型是Map.Entry，但是实际上存放的还是HashMap$Node ，这是因为 static class Node<K, V> implements Map.Entry<K, V>
4.当把HashMap$Node对象存放到entrySet就方便我们的遍历，因为Map.Entry提供了重要的方法 ，K getKey(); V getValue()

//1.k-v最后是HashMap$Node node = newNode(hash, key, value, null)
//2.k-v为了方便程序员遍历，还会创建EntrySet集合，改集合存放的元素类型是Entry，而一个Entry
// 对象就有k,v EntrySet<Entry<K,V>> 即：transient Set<Map.Entry<K,V>> entrySet;
//3.entrySet中，定义的类型是Map.Entry，但是实际上存放的还是HashMap$Node
// 这是因为 static class Node<K, V> implements Map.Entry<K, V>
//4.当把HashMap$nODE对象存放到entrySet就方便我们的遍历，因为Map.Entry提供了重要的方法
// K getKey(); V getValue()
HashMap hashMap = new HashMap();
hashMap.put("no1", "wcw");
hashMap.put("no2", "wc");


Set set = hashMap.entrySet();
System.out.println(set.getClass()); //HashMap$EntrySet
for (Object obj: set) {
    System.out.println(obj.getClass()); // HashMap$Node
    Map.Entry entry = (Map.Entry) obj;
    System.out.println("key=" + entry.getKey() + " value=" + entry.getValue());
}

2.Map接口常用方法
在这里插入图片描述
在这里插入图片描述
3.Map接口遍历
在这里插入图片描述
第一组：先取出所有的Key，通过Key取出所有的Value，取出的keyset是一个Set类型的集合，通过增强for或者迭代器遍历取出后，通过HashMap的get()方法获取value。

Set keyset = hashMap.keySet();

第二组：把所有的values取出，取出的为一个Collection类型的集合，同样通过增强for或者迭代器遍历取出value。

Collection coll = hashMap.values();

第三组：通过entrySet取出

Set entrySet = hashMap.entrySet();
for (Object obj: entrySet) {
    Map.Entry entry = (Map.Entry) obj;
    System.out.println(entry.getKey() + "-" + entry.getValue());
}

完整代码示例：

package com.collection_;

import java.util.*;

/**
 * Created on 2021/6/26.
 *
 * @author Ryan_小王
 */
public class HashMap_ {
    public static void main(String[] args) {
        HashMap hashMap = new HashMap();

        hashMap.put(1, "wcw");
        hashMap.put(2, "wc");
        hashMap.put(3, "wj");
        System.out.println(hashMap);

        //第一组：先取出所有的Key，通过Key取出所有的Value
        Set keyset = hashMap.keySet();
        //(1)增强for
        System.out.println("===第一种方式===");
        for (Object key: keyset) {
            System.out.println(key + "-" + hashMap.get(key));
        }

        //(2)迭代器
        System.out.println("===第二种方式===");
        Iterator iterator = keyset.iterator();
        while (iterator.hasNext()) {
            Object object = iterator.next();
            System.out.println(object + "-" + hashMap.get(object));
        }

        //第二组：把所有的values取出
        Collection coll = hashMap.values();
        //(1)增强for
        System.out.println("取出所有的value(增强for)");
        for (Object value: coll) {
            System.out.println(value);
        }
        //(2)迭代器
        System.out.println("取出所有vaule(迭代器)");
        Iterator iterator1 = coll.iterator();
        while (iterator1.hasNext()) {
            Object value = iterator1.next();
            System.out.println(value);
        }

        //第三组：entrySet
        System.out.println("通过entrySet");
        Set entrySet = hashMap.entrySet();
        for (Object obj: entrySet) {
//            System.out.println(obj);
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "-" + entry.getValue());
        }
    }
}

4.HashMap小结
在这里插入图片描述
5.HashMap底层机制

实际存储的为HashMap$Node，它实现了Map$Entry接口。
在这里插入图片描述

在这里插入图片描述

4.2 Hashtable

1.基本介绍
在这里插入图片描述

2.扩容机制

第一次加数据数组扩容为11，达到临界值8，再次加入数据时数组容量就乘以2然后加1变为23，临界值为23*0.75=17。
在这里插入图片描述
3.Hashtable和HashMap对比
在这里插入图片描述

4.3 Properties

在这里插入图片描述
在这里插入图片描述

4.4 TreeMap

可以排序，通过传入实现了Comparator接口的匿名内部类，重写compare()方法定制排序规则。

注意：重写了compare()方法，会根据该方法判断元素是否加入，如下举例中，根据字符串的长度来排序，"bom"和"tom"的长度都是3，则不会被加入，最终的结果为{a=5, so=3, tom=4, jack=2}。

package com.collection_;

import java.util.Comparator;
import java.util.TreeMap;

/**
 * Created on 2021/6/27.
 *
 * @author Ryan_小王
 */
@SuppressWarnings({"all"})
public class TreeMap_ {
    public static void main(String[] args) {
        TreeMap treeMap = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String)o1).length() - ((String)o2).length();
            }
        });
        treeMap.put("tom",1);
        treeMap.put("jack",2);
        treeMap.put("so",3);
        treeMap.put("bom",4);
        treeMap.put("a",5);
        System.out.println(treeMap);
    }
}

//结果：{a=5, so=3, tom=4, jack=2}

5.开发中如何选择集合实现类

在这里插入图片描述

6.Collections工具类


我喜欢

注：拷贝时候，dest的size()大小应该和原先数组一样。

package com.collection_;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

/**
 * Created on 2021/6/22.
 *
 * @author Ryan_小王
 */
@SuppressWarnings({"all"})
public class ArrayList01 {
    public static void main(String[] args) {
        // 无参构造器
        ArrayList arrayList= new ArrayList(8);
        for (int i = 1; i <= 10; i++) {
            arrayList.add(i);
        }

        for (int i = 1; i <=15; i++) {
            arrayList.add(i);
        }

        arrayList.add(10);

        System.out.println(arrayList);
        //排序
        Collections.sort(arrayList, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return (Integer)o2 - (Integer) o1;
            }
        });
        //反转
        Collections.reverse(arrayList);
        System.out.println(arrayList);
        //打乱
        Collections.shuffle(arrayList);
        System.out.println(arrayList);
        //交换
        Collections.swap(arrayList, 0, 1);

        //个数
        int a = Collections.frequency(arrayList, 1);
        System.out.println(a);
        
        //拷贝，注意dest大小应该和原先数组一样
        ArrayList dest = new ArrayList(26);
        for (int i=0; i < arrayList.size(); i++) {
            dest.add("");
        }
        Collections.copy(dest, arrayList);


    }
}
Ryan_小王
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 集合
04-07
本文将深入探讨Java集合框架的基础知识，包括接口、类、以及它们在实际开发中的应用。 首先，Java集合框架由一系列接口和实现这些接口的类组成。主要的接口有`List`、`Set`和`Queue`，它们各自代表了不同特性的数据...
java集合
一个小小的码农
05-10 5165
以上的代码则表示定义了一个名为list的一个List集合，它存放的数据类型为。。。
Java集合特点
m0_68206534的博客
03-26 4256
1、基本语法 这包括static、final、rtransient等关键字的作用，foreach循环的原理等等。 2、集合 基本上就是List、Map、Set，问的是各种实现类的底层原理，实现类的优缺点 List集合：有序集合，用户可以精确控制列表中每个元素的插入位置。用户也可以通过整数索引访问元素，并搜索列表中的元素。与Set集合不同，列表通常允许重复元素。 ArrayList的底层数据结构是数组 特点： 索引查询速度最快；长度可以自动动态变化 添加和删除元素效率低；按照内容查询需要逐个比
Java集合底层原理
小凯的博客
03-04 2558
Java集合框架的体系结构、集合架构中的类、算法、底层原理
java集合（超详细）
zdl66的博客
08-12 5万+
所有的集合类和集合接口都在java.util包下。 在内存中申请一块空间用来存储数据，在Java中集合就是替换掉定长的数组的一种引用数据类型。
Java集合（全）
小杨的博客
05-03 1万+
一.Java集合框架概述 一方面，面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。另一方面，使用Array存储对象方面具有一些弊端，而Java集合就像一种容器，可以动态的把多个对象的引用放入容器中。 1.数组Array存储 （1）数组在内存存储方面的特点： ①数组初始化以后，长度就确定了。 ②数组声明的类型，就决定了进行元素初始化的类型。 （2）数组在存储数据方面的弊端： ①数组初始化以后，.........
Java集合去重
qq_41053971的博客
04-21 7281
在日常工作中，我们时常会遇到需要对数据进行遍历去重的操作，笔者便将自己所熟知的几种方法分享给大家。 首先模拟一个实体类，并创建一个main方法调用。 public static void main(String[] args) { List<User> list = new ArrayList(4); list.add(new User("张三","杭州")); list.add(new User("李四","上海")); .
Java集合中List,Set以及Map等集合体系详解(史上最全)
热门推荐
君羊
06-12 33万+
概述: List Set Map都是接口，前两个继承至Collection接口，Map为独立接口 Set下有HashSet，LinkedHashSet，TreeSet List下有ArrayList，Vector，LinkedList Map下有Hashtable，LinkedHashMap，HashMap，TreeMap 还有Collection接口下还有个Queue接口，有Priority...
java集合（详解）
abc98526的博客
04-24 1万+
文章目录 什么是集合? Collection的基本使用 接口实现类 Collections工具类 Map接口及其实现类 Map是不是集合? 什么是集合? 集合是指具有某种特定性质的具体的或抽象的对象汇总而成的集体，有时集合也称之为容器，java中在util包...
Java 集合分页
最新发布
暗武逢天的博客
03-08 5389
java实现集合分页
Java集合概述与实例分析
10-26
Java集合框架是Java编程语言中的一个核心特性，它提供了一种高效、灵活的方式来存储和操作对象数组。在Java中，集合被分为两个主要接口：Collection和Map。本篇将深入探讨Collection接口及其子接口，包括List和Set，...
实验05 Java集合.doc
06-27
Java集合框架是Java编程语言中一个非常重要的组成部分，它提供了一组高级的数据结构，使得开发者能够更方便地管理和操作对象。在本次实验中，我们主要关注了三个主要的集合接口：Set、List和Map，以及它们的一些常见...
Java集合框架
12-22
Java集合框架是Java编程语言中一个至关重要的组件，它为开发者提供了存储和管理对象的统一方式。集合可以被看作是一个容器，允许我们存放多个对象，并支持常见的操作，如添加、删除和修改元素。 Collection接口是...
java集合框架面试题
11-08
### Java集合框架经典面试题详解 #### 1. Java集合框架概述及优点 - **定义**: Java集合框架是一个设计模式，用于组织和操纵对象集合。它由一系列接口、实现类和算法组成，提供了统一的方式管理和操作数据集合。...
java 集合练习题
07-26
在这个“java集合练习题”中，我们主要关注如何使用Java集合框架来处理数据，特别是对于学生信息的存储、排序和输出。以下是对这个练习题的详细解析： 1. **集合框架简介**： Java集合框架是Java API的一部分，它...
【Java】Java集合框架思维导图。
04-13
xmind格式的Java集合框架学习导图，包括Collection接口/Map接口以及具体实现类。 同样包含大厂面试题，也在导图中有所体现。 能学到什么： 更加成体系的知识框架，更加全面的、系统的知识。 思维导图： 思维导图具有...
Java集合类原理详解.pdf
01-05
### Java集合类原理详解 #### 1. 集合框架概述 集合框架是Java编程语言的核心组件之一，用于组织和操作数据集。它提供了一种灵活高效的方式来存储和访问对象集合，支持多种数据结构，如列表(List)、集(Set)、映射...
Java集合框架详解
"Java集合是Java编程中非常重要的部分，涵盖了数据存储和管理的主要机制。这份教程涵盖了Java集合框架的基本概念、接口和类，包括List、Set和Map接口的实现。" 在Java中，集合框架是处理对象组的核心工具，它提供了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值