java中的集合(List、Set、Map集合使用大解析)

于 2024-03-13 08:45:00 发布
阅读量1.4k 收藏 16
点赞数 38
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39038328/article/details/136666262
版权

一、java集合简介

1.集合简介

java集合可分为Set、List、Queue和Map四种体系。
在这里插入图片描述
Java集合就像一种容器，可以把多个对象（实际上是对象的引用，但习惯上都称对象）“丢进”该容器中。从Java 5 增加了泛型以后，Java集合可以记住容器中对象的数据类型，使得编码更加简洁、健壮。

2.集合和数组的区别

在这里插入图片描述

二、List集合

1.概述

在这里插入图片描述

2.ArrayList集合

ArrayList集合的特点

在这里插入图片描述

ArrayList集合的一些方法

①.add(Object element) 向列表的尾部添加指定的元素。
②.size() 返回列表中的元素个数。
③.get(int index) 返回列表中指定位置的元素，index从0开始。

public class Test {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>(); //<String>泛型表示集合中存的是字符串形式的元素。
        list.add("青城"); //add()用于向List集合容器中添加元素。
        list.add("博雅");
        System.out.println(list);
        System.out.println(list.size()); //size()用于获取集合中有多少个元素。
        System.out.println(list.get(1)); //get()获取指定索引（从0开始）位置的元素。
    }
}

④.add(int index, Object element) 在列表的指定位置（从0开始）插入指定元素

public class Test {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("qc");
        list.add("by");
        System.out.println(list);
        list.add(1, "gc"); //在指定位置添加元素，原来位置的元素后置。
        System.out.println(list);
    }
}

⑤.set(int i, Object element) 使用元素element替换索引i位置的元素，并返回被替换的元素。

public class Test {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("qc");
        list.add("by");
        System.out.println(list);
        list.set(1, "wd"); //替换指定位置的元素，从0开始，替换了“wd”。
        System.out.println(list);
    }
}

⑥.clear() 从列表中移除所有元素。
⑦.isEmpty() 判断列表是否包含元素，不包含元素则返回 true，否则返回false。

public class Test {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("qc");
        list.add("by");
        System.out.println(list);
        list.clear(); //清空List集合中的所有元素。
        System.out.println(list.isEmpty()); //集合容器没有元素，则true。
        System.out.println(list);
    }
}

⑧.contains(Object o) 如果列表包含指定的元素，则返回 true。

public class Test {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("qc");
        list.add("by");
        boolean flag = list.contains("gc"); //用来判断集合容器中是否含有参数元素。
        System.out.println(flag);
    }
}

⑨.remove(int index) 移除列表中指定位置的元素，并返回被删元素，删除位置后面的元素（如果有）向前移动。

public class Test {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("qc");
        list.add("by");
        list.add("gc");
        System.out.println(list.remove(1)); //删除指定索引（从0开始）位置的元素，并将元素返回,并后面元素前移。
        System.out.println(list);
    }
}

⑩.remove(Object o) 从List集合中移除第一次出现的指定元素，移除成功返回true，否则返回false。当且仅当List集合中含有满(o==null ? get(i)==null : o.equals(get(i)))条件的最低索引i的元素时才会返回true。

public class Test {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("青城");
        list.add("博雅");
        list.add("博雅");
        list.add("教育");
        System.out.println(list.remove("博雅")); //删除List集合元素，返回boolean,并后面元素前移。
        System.out.println(list);
    }
}

11.iterator() 返回按适当顺序在列表的元素上进行迭代的迭代器。

public class Test {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("青城");
        list.add("博雅");
        Iterator<String> ite = list.iterator(); //将List集合中元素转到iterator变量中。
        while(ite.hasNext()) //hasNext()判断当前“指针”下面是否还有元素的方法，java中没有指针，这只是举个例子。
        {
            System.out.println(ite.next()); //如果“指针”下面有元素，则移动“指针”并获取相应位置的元素。
        }
    }
}

12.for循环遍历List集合

public class Test {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("青城");
        list.add("博雅");
        for (int i = 0; i < list.size(); i++) {  //用size方法获取长度。
            System.out.println(list.get(i));  //用get方法获取值。
        }
    }
}

13.加强for循环遍历List集合

public class Test {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("青城");
        list.add("博雅");
        for (String name : list) {   //使用foreach进行遍历。
            System.out.println(name);
        }
    }
}

二、LinkedList集合

LinkedList集合的特点

在这里插入图片描述

LinkedList集合的一些方法

①.添加
boolean add（Object element） 它将元素附加到列表的末尾。
boolean add（int index,Object element） 指定位置插入。
void addFirst(E element) 元素附加到列表的头部
void addLast(E element) 元素附加到列表的尾部

LinkedList<Integer> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
linkedList.addFirst(4);
linkedList.addFirst(5);
linkedList.addLast(6);
linkedList.add(2,9);
System.out.println(linkedList);

②：获取数据
Object get(int index) 根据下标获取数据
Object getFirst（） 它返回链表的第一个元素。
Object getLast（） 它返回链接列表的最后一个元素。

LinkedList<Integer> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
System.out.println("获取下标为1的元素："+linkedList.get(1));
System.out.println("链表的第一个元素："+linkedList.getFirst());
System.out.println("链表的最后一个元素："+linkedList.getLast());

③.查询
boolean contains（Object element）如果元素存在于列表中，则返回true。

LinkedList<Integer> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
linkedList.add(1);
System.out.println("是否出现过元素1："+linkedList.contains(1));
System.out.println("是否出现过元素4:"+linkedList.contains(4));

输出

是否出现过元素1：true
是否出现过元素4:false

④.修改
Object set（int index，Object element）它用于用新元素替换列表中的现有元素

LinkedList<Integer> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
linkedList.add(1);
linkedList.set(1,9);
System.out.println("更新过的链表："+linkedList);

输出

更新过的链表：[1, 9, 3, 1]

⑤.删除
E remove() 删除第一个元素
E remove(int location) 删除指定位置的元素
E removeFirst() 删除并返回链接列表的头部一个元素
E removeLast() 删除并返回链接列表的尾部一个元素

LinkedList<Integer> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
linkedList.add(1);
linkedList.remove(); //删除第一个元素
linkedList.remove(2);//删除指定位置的元素
System.out.println(linkedList);

⑥: 清空
void clear（）：它删除列表中的所有元素。

LinkedList<Integer> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
linkedList.add(1);
linkedList.clear();
System.out.println(linkedList);

输出

[]

⑦:链表长度

LinkedList<Integer> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
linkedList.add(1);
System.out.println("链表的长度："+linkedList.size());

输出

链表的长度：4

三、Vector集合(不建议使用)

在这里插入图片描述

二、set集合

1.HashSet集合

HashSet集合的特点

在这里插入图片描述

HashSet常用方法

①：add(Object o)：向Set集合中添加元素，不允许添加重复数据。
②：size()：返回Set集合中的元素个数

public class Test {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<String>(); //调用HashSet无参构造方法——>创建HashMap对象并给map全局变量。
        set.add("青城");
        set.add("博雅");
        System.out.println(set);
        System.out.println(set.size());
    }
}

注意:不会按照保存的顺序存储数据（顺序不定），遍历时不能保证下次结果和上次相同。且向HashSet集合中添加元素，HashSet add方法实质是map全局变量调用了put方法，将数据存到了key，因为HashMap的 key不允许，所以HashSet添加的元素也不允许重复。

③.remove(Object o)： 删除Set集合中的obj对象，删除成功返回true，否则返回false。
④.isEmpty()：如果Set不包含元素，则返回 true。

public class Test {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<String>();
        set.add("青城");
        set.add("博雅");
        System.out.println(set.isEmpty());
        System.out.println(set.remove("博雅"));
        System.out.println(set);
    }
}

⑤.clear()： 移除此Set中的所有元素。

public class Test {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<String>();
        set.add("青城");
        set.add("博雅");
        System.out.println(set);
        set.clear();
        System.out.println(set);
    }
}

⑥.iterator()：返回在此Set中的元素上进行迭代的迭代器。

public static void main(String[] args) {
    HashSet<String> set = new HashSet<String>();
    set.add("青城");
    set.add("博雅");
    Iterator<String> ite =set.iterator();
    while(ite.hasNext())
    {
        System.out.println(ite.next());
    }
}

⑦.contains(Object o)：判断集合中是否包含obj元素。

public class Test {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<String>();
        set.add("青城");
        set.add("博雅");
        System.out.println(set.contains("青城"));
    }
}

⑧：加强for循环遍历Set集合：

public class Test {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<String>();
        set.add("青城");
        set.add("博雅");
        for (String name : set) {   //使用foreach进行遍历。
            System.out.println(name);
        }
    }
}

2.LinkedHashSet集合

LinkedHashSet集合的特点

在这里插入图片描述

3.TreeSet集合

TreeSet集合的特点

在这里插入图片描述

TreeSet的基本使用

①.插入是按字典序排序的

public class Test {
    public static void main(String[] args) {
        TreeSet ts=new TreeSet();
        ts.add("agg");
        ts.add("abcd");
        ts.add("ffas");
        Iterator it=ts.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

输出 ： 按照字典序排序的方式进行排序

abcd
agg
ffas

②.如果插入的是自定义对象 需要让类实现 Comparable 接口并且必须要重写compareTo

class Person implements Comparable{
    
    String name;
    int age;
    Person(String name,int age)
    {
        this.name=name;
        this.age=age;
    }

    @Override
    public int compareTo(Object o) {
        Person p=(Person)o;
        //先对姓名字典序比较 如果相同 比较年龄
        if(this.name.compareTo(p.name)!=0) {
            return this.name.compareTo(p.name);
        }
        else
        {
            if(this.age>p.age) return 1;
            else if(this.age<p.age) return -1;
        }
        return 0;
    }

}

public class Test {
    public static void main(String args[])
    {
        TreeSet ts=new TreeSet();
        ts.add(new Person("agg",21));
        ts.add(new Person("abcd",12));
        ts.add(new Person("ffas",8));
        ts.add(new Person("agg",12));
        Iterator it=ts.iterator();
        while(it.hasNext())
        {
            Person p=(Person)it.next();
            System.out.println(p.name+":"+p.age);
        }
    }
}

输出

abcd:12
agg:12
agg:21
ffas:8

4.HashSet、LinkedHashSet、TreeSet的使用场景

HashSet: HashSet的性能基本上比LinkedHashSet和TreeSet要好，特别是添加和查询，这也是用的最多的两个操作
LinkedHashSet： LinkedHashSet的查询稍慢一些，但是他可以维持元素的添加顺序。所以只有要求当插入顺序和取出顺序一致的时候 才使用LinkedHashSet。
TreeSet: 只有在需要对元素进行排序时使用

5.list和set集合的区别

在这里插入图片描述

三、map集合

1.HashMap集合

HashMap示意图

在这里插入图片描述

HashMap的特点

在这里插入图片描述

HashMap的常用方法

①.put(K key, V value) 将键（key）/值（value）映射存放到Map集合中

public class Test {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        map.put("Tom", 100);//向HashMap中添加元素  
    }
}

②.get(Object key) 返回指定键所映射的值，没有该key对应的值则返回 null，即获取key对应的value。

public class Test {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        map.put("Tom", 100);
        map.put("Tom", 0);
        int score = map.get("Tom");// 获取key对应的value
        System.out.println(score);// key不允许重复，若重复，则覆盖已有key的value
    }
}

在这里插入图片描述
可知，之前加入的value已被覆盖，前面的观点得证

③. size() 返回Map集合中数据数量，准确说是返回key-value的组数。

public class Test {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        map.put("Tom", 100);
        map.put("Jim", 90);
        map.put("Sam", 91);
        System.out.println(map.size());
    }
}

④：clear() 清空Map集合

public class Test {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        map.put("Tom", 100);
        map.put("Jim", 90);
        map.put("Sam", 91);
        map.clear();// 清空map中的key-value
        System.out.println(map.size());
    }
}

⑤：isEmpty () 判断Map集合中是否有数据，如果没有则返回true，否则返回false

public class Test {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        map.put("Tom", 100);
        map.put("Jim", 90);
        map.put("Sam", 91);
        map.clear();// 清空map中的key-value
        System.out.println(map.isEmpty());
    }
}

⑥：remove(Object key) 删除Map集合中键为key的数据并返回其所对应value值。

public class Test {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        map.put("Tom", 100);
        map.put("Jim", 90);
        map.put("Sam", 91);
        map.remove("Tom");
        System.out.println(map);
    }
}

⑦：containsKey(Object key) Hashmap判断是否含有key

public class Test {
    public static void main(String[] args) {
        HashMap<String, Integer> map=new HashMap<>();
         /*boolean*///判断map中是否存在这个key
         System.out.println(map.containsKey("DEMO"));//false
         map.put("DEMO", 1);
         System.out.println(map.containsKey("DEMO"));//true
    }
}

⑧：containsValue(Object value) Hashmap判断是否含有value：

public class Test {
    public static void main(String[] args) {
        HashMap<String, Integer> map=new HashMap<>();
        /*boolean*///判断map中是否存在这个value
        System.out.println(map.containsValue(1));//false
        map.put("DEMO", 1);
        System.out.println(map.containsValue(1));//true
    }
}

⑨：Hashmap添加另一个同一类型的map下的所有数据

public class Test {
    public static void main(String[] args) {
        HashMap<String, Integer> map=new HashMap<>();
        HashMap<String, Integer> map1=new HashMap<>();
        /*void*///将同一类型的map添加到另一个map中
        map1.put("DEMO1", 1);
        map.put("DEMO2", 2);
        System.out.println(map);//{DEMO2=2}
        map.putAll(map1);
        System.out.println(map);//{DEMO1=1, DEMO2=2}
    }
}

⑩：Hashmap替换这个key的value

public class Test {
    public static void main(String[] args) {
        HashMap<String, Integer> map=new HashMap<>();
        /*value*///判断map中是否存在这个key
        map.put("DEMO1", 1);
        map.put("DEMO2", 2);
        System.out.println(map);//{DEMO1=1, DEMO2=2}
        System.out.println(map.replace("DEMO2", 1));//2
        System.out.println(map);//{DEMO1=1, DEMO2=1}
    }
}

二、TreeMap集合

TreeMap的特点

在这里插入图片描述

TreeMap基本使用

TreeMap中的元素默认按照keys的自然排序排列。
①:使用无参构造器创建对象
对Integer来说，其自然排序就是数字的升序；对String来说，其自然排序就是按照字母表排序。

public static void main(String[] args) {
    Map<String, Integer> map = new TreeMap<>();
    map.put("orange", 1);
    map.put("apple", 2);
    map.put("pear", 3);
    System.out.println(map);
}

// {apple=2, orange=1, pear=3}

public static void main(String[] args) {
    Map<Integer, String> map = new TreeMap<>();
    map.put(3, "val");
    map.put(2, "val");
    map.put(1, "val");
    map.put(5, "val");
    map.put(4, "val");
    System.out.println(map);
}

// {1=val, 2=val, 3=val, 4=val, 5=val}

②:Comparable接口
使用TreeMap时，放入的Key必须实现Comparable接口。String、Integer这些类已经实现了Comparable接口，因此可以直接作为Key使用。作为Value的对象则没有任何要求。
如果作为Key的class没有实现Comparable接口，那么，必须在创建TreeMap时同时指定一个自定义排序算法：

public class Main {
    public static void main(String[] args) {
        Map<Person, Integer> map = new TreeMap<>(new Comparator<Person>() {
            public int compare(Person p1, Person p2) {
                return p1.name.compareTo(p2.name);
            }
        });
        map.put(new Person("Tom"), 1);
        map.put(new Person("Bob"), 2);
        map.put(new Person("Lily"), 3);
        for (Person key : map.keySet()) {
            System.out.println(key);
        }
        // {Person: Bob}, {Person: Lily}, {Person: Tom}
        System.out.println(map.get(new Person("Bob"))); // 2
    }
}

class Person {
    public String name;
    Person(String name) {
        this.name = name;
    }
    public String toString() {
        return "{Person: " + name + "}";
    }
}
青城小虫
关注
  • 38
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java集合超详解
feiyan的博客
08-03 44万+
一、集合大纲 1.集合和数组的区别： 2.Collection集合的方法： 3.常用集合的分类： Collection 接口的接口 对象的集合（单列集合） ├——-List 接口：元素按进入先后有序保存，可重复 │—————-├ LinkedList 接口实现类， 链表， 插入删除， 没有同步， 线程不安全 │—————-├ ArrayList 接口...
java容器-集合
qq_53464269的博客
02-22 302
集合
Java集合/容器
weixin_56846554的博客
03-13 212
Java 集合概览 Java 集合， 也叫作容器，主要是由两大接口派生而来：一个是Collection 接口，主要用于存放单一元素；另一个是 Map 接口，主要用于存放键值对。对于 Collection 接口，下面又有三个主要的子接口： List 、 Set 和 Queue。
Java中的集合
weixin_52071901的博客
06-13 4852
java-api，day01
java集合使用方法_java集合类的基本方法的使用
weixin_39693101的博客
02-24 141
欢迎进入Java社区论坛，与200万技术人员互动交流 >>进入 if(collection.isEmpty()) System.out.println(“collection is Empty!”); //使用collection.isEmpty()方法来判断 } }||| 程序的运行结果为: iterator = s1 iterator = s2 iterator = s3 coll...
Java集合:Collection、List、Set、Map使用详解
08-16
集合是Java里面最重要的一部分，也是最常用的了。能够用好集合和理解好集合对于做Java程序的开发拥有无比的好处。本文详细解释了关于Java中的集合是如何实现的，以及他们的实现原理。
Java 集合框架高难度进阶版面试题集锦解析
06-14
提供了20道高难度的Java集合框架面试题及详细答案解析，涵盖了List、Set、Map、Iterator、Collections类等关键概念和操作方法。从数据结构、线程安全性、性能等多个角度深入探讨了集合框架的不同实现和应用场景。...
java容器详细解析
02-24
在java开发中我们肯定会大量的使用集合，在这里我将总结常见的集合类，每个集合类的优点和缺点，以便我们能更好的使用集合。下面我用一幅图来表示其中淡绿色的表示接口，红色的表示我们经常使用的类。Java容器类类库...
Java面试题深入解析：在互联网公司面试程序员需要留意的六个问题.docx
06-15
# Java面试题深入解析：在...Java集合是Java程序员必须熟练掌握的，包括List、Set、Map等等。在面试中，面试官可能会问及Java集合中的ArrayList和LinkedList的区别是什么？HashMap和TreeMap的区别是什么等等。 ## 4.
java中集合的使用
m0_45425492的博客
05-08 1057
一、按照列数可以分为单双列集合。 单列集合以Collection接口作为根，下面有两个子接口List、Set。各自在下面都有两个实现类。 分别为List（实现类①ArrayList，②LinkedList）Set（实现类①HashSet，②TreeSet） 1.1四个实现类分出来的按照List和Set区分。其中各有的区别是 ArrayList，LinkedList 特点：①有索引，所以可以进行正常遍历 ②元素可以重复 ③存入与取出的顺序相同（Set的存入与取出顺序不同，这是由于他们的底层架构决
java中集合容器的详细介绍
03-07
在常见用法中，集合（collection）和数学上直观的集（set）的概念是相同的。集是一个唯一项组，也就是说组中没有重复项。实际上，“集合框架”包含了一个 Set 接口和许多具体的 Set 类。但正式的集概念却比 Java 技术提前了一个世纪，那时英国数学家 George Boole 按逻辑正式的定义了集的概念。大部分人在小学时通过我们熟悉的维恩图引入的“集的交”和“集的并”学到过一些集的理论。
java集合
暖夏的博客
09-22 312
一、集合大纲 1.集合和数组的区别： 2.Collection集合的方法： 3.常用集合的分类： Collection接口的接口 对象的集合（单列集合） ├——-List接口：元素按进入先后有序保存，可重复 │—————-├LinkedList接口实现类， 链表， 插入删除， 没有同步， 线程不安全 │—————-├ArrayList接口实现类， 数组， 随机访问， 没有同步， 线程不安全 │—————-└Vector接口实现类 数组， 同步， 线程安全 │ ——————...
Java集合（容器）
zhouwenxing666的博客
05-26 429
1​ 集合又称容器。是Java中对数据结构(数据存储方式)的具体实现。​ 我们可以利用集合存放数据，也可以对集合进行新增、删除、修改、查看等操作。​ 集合中数据都是在内存中，当程序关闭或重启后集合中数据会丢失。所以集合是一种临时存储数据的容器。2.​ List和Set接口的父接口, 还有其他的实现类或子接口。​ Collection接口的子接口。Collection中包含的内容List接口中可以继承。​ List专门存储有序，可重复数据的接口。​ 实现了List接口, 底层实现可变长度数组。
java集合（容器）基本知识
liwangcuihua的博客
08-15 648
1、List有序，可重复；可根据索引获取元素。 2、Set无序，不可重复；独一无二；不能根据索引获取元素。 3、Queue按特定的排队规则来确定先后顺序，有序的、可重复； 4、Map使用键值对（key-value）存储，类似于数学上的函数 y=f(x)，"x" 代表 key，"y" 代表 value，key 是无序的、不可重复的，value 是无序的、可重复的，每个键最多映射到一个值。...
Java中集合的简单使用
xx的博客
11-14 822
java集合的简单使用
JAVA集合的介绍及使用
adminwxc的博客
04-21 5789
JAVA集合一、java集合简介二、集合分类三、集合的特点和好处四、集合的基础用法及其特性1、Collection接口下的List接口2、Collection接口下的set接口3、Map接口下的常用接口4、不同接口下的集合特性A、List集合特性B、Set集合特性C、Map集合特性五、集合常用的循环遍历方法A、List接口常用循环遍历方法B、Set接口常用循环遍历方法C、Map接口常用循环遍历方法 一、java集合简介 集合类是Java数据结构的实现。Java的集合类是java.util包中的重要内容，它允
java集合（超详细）
热门推荐
zdl66的博客
08-12 4万+
所有的集合类和集合接口都在java.util包下。 在内存中申请一块空间用来存储数据，在Java中集合就是替换掉定长的数组的一种引用数据类型。
Java 集合看这一篇就够了
weixin_49527334的博客
10-16 488
Java 集合，也称作容器，主要是由两大接口 (Interface) 派生出来的： Collection 和 Map 顾名思义，容器就是用来存放数据的。 那么这两大接口的不同之处在于： Collection 存放单一元素； Map 存放 key-value 键值对。 就是单身狗放 Collection 里面，couple 就放 Map 里。（所以你属于哪里？ 学习这些集合框架，我认为有 4 个目标： 明确每个接口和类的对应关系； 对每个接口和类，熟悉常用的 API； 对不同的场景，能够选择合适的数据结.
java集合框架面试题
最新发布
07-27
在Java集合框架中，有一些线程安全的类和接口，如Vector和Hashtable，它们是旧的，从Java一诞生就提供的，因此是线程安全的。而ArrayList和HashMap是在Java2时才提供的，它们是线程不安全的。因此，在使用这些类时...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

青城小虫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值