java之Collection, Set, List集合等的总结

最新推荐文章于 2023-11-15 08:53:34 发布
最新推荐文章于 2023-11-15 08:53:34 发布
阅读量346 收藏 4
点赞数 1
分类专栏： java相关
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sgy1993/article/details/115802358
版权

文章目录

1. 集合体系结构

1. 集合类的特点

提供了一种存储空间可变的存储模型，存储的数据容量可以随时发生改变

2. 集合体系里面有哪些类

1. Collection接口

public interface Collection<E>
extends Iterable<E>

2. 列表List接口，有序集合

public interface List<E>
extends Collection<E>

3. Set集合接口

public interface Set<E>
extends Collection<E>

4. Map集合接口

public interface Map<K,V>

5. ArrayList实现类，实现了List接口

public class ArrayList<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable

6. LinkedList实现类， 实现了List接口

public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, Serializable

7. HashSet集合类，实现了Set接口

public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, Serializable

8. LinkedHashSet 类，继承了HashSet类, 实现了Set接口

public class LinkedHashSet<E>
extends HashSet<E>
implements Set<E>, Cloneable, Serializable

9. TreeSet 类 继承了 AbstractSet 类

AbstractSet 类实现了 Set 接口

public class TreeSet<E>
extends AbstractSet<E>
implements NavigableSet<E>, Cloneable, Serializable


public abstract class AbstractSet<E>
extends AbstractCollection<E>
implements Set<E>

10. HashMap类 实现了 Map<K,V>接口

public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable

3. Colleciton 接口

1. Collection接口介绍

集合层次结构中的父类。

集合表示一组被称为其元素的对象。

一些集合允许重复元素，而其他集合不允许。

有些被命令和其他无序。

JDK不提供此接口的任何直接实现：它提供了更具体的子接口的实现，如Set和List 。

该界面通常用于传递集合，并在需要最大的通用性的情况下对其进行操作。

包或多重集 （可能包含重复元素的无序集合）应直接实现此接口。

public interface Collection<E>
extends Iterable<E>

2. Collection 常用方法

方法名说明
boolean add(E e)添加元素
boolean remove(Object o)从集合中移除指定的元素
void clear()清空集合中的元素
boolean contains(Object o)判断集合中是否存在指定的元素
boolean isEmpty()判断集合是否为空
int size()集合的长度，也就是集合中元素的个数
Iterator<E> iterator()返回此集合中元素的迭代器

3. Collection 的2种 的遍历方式

因为 Collection 没有索引，所以只能使用 增强 for 循环 和迭代器进行遍历

1. 使用增强for 循环

package com.itheima.demo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

public class Test {
    public static void main(String[] args) {
//        UseInterface u1 = new UseInterface();
//        u1.show();


        Collection<String> c1 = new ArrayList<>();

        c1.add("1");
        c1.add("2");
        c1.add("3");
        c1.add("4");
        c1.add("1");

        //增强for循环的方式进行遍历
        for (String s : c1) {
            System.out.println(s);
        }

        //迭代器的方式进行遍历
        Iterator<String> it = c1.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }


        System.out.println(c1);
    }
}

2. 使用迭代器

package com.itheima.demo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

public class Test {
    public static void main(String[] args) {
//        UseInterface u1 = new UseInterface();
//        u1.show();


        Collection<String> c1 = new ArrayList<>();

        c1.add("1");
        c1.add("2");
        c1.add("3");
        c1.add("4");
        c1.add("1");

        //增强for循环的方式进行遍历
        for (String s : c1) {
            System.out.println(s);
        }

        //迭代器的方式进行遍历
        Iterator<String> it = c1.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }


        System.out.println(c1);
    }
}

4. 列表List， 有序集合（也称为序列 ）

1. List接口介绍

该界面的用户可以精确控制列表中每个元素的插入位置。

用户可以通过整数索引（列表中的位置）访问元素，并搜索列表中的元素。

与集合不同，列表通常允许重复的元素。 更正式地，列表通常允许元素e1和e2成对使得e1.equals(e2)

public interface List<E>
extends Collection<E>

2. List接口特点

  1. 有序集合，列表，也称为序列，用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素
  2. 与Set集合不同，列表通常允许重复的元素
  3. 有索引
  4. 可以存储重复元素
  5. 元素存取有序

3. List集合的方法

方法名说明
boolean add(E e)添加元素
boolean remove(Object o)从集合中移除指定的元素
void clear()清空集合中的元素
boolean contains(Object o)判断集合中是否存在指定的元素
boolean isEmpty()判断集合是否为空
int size()集合的长度，也就是集合中元素的个数
void add(int index, E element)在此集合中的指定位置插入指定的元素
E remove(int index)删除指定索引处的元素，返回被删除的元素
E set(int index, E element)修改指定索引处的元素，返回被修改的元素
E get(int index)返回指定索引处的元素
Iterator<E> iterator()返回此集合中元素的迭代器

4. List集合的遍历

1. 普通for循环

package com.itheima.demo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        List<String> l1 = new ArrayList<>();

        l1.add("1");
        l1.add("2");
        l1.add("3");
        l1.add("4");
        l1.add("1");

        System.out.println(l1);

        //普通for循环的方式进行遍历
        for (int i = 0; i < l1.size(); i++) {
            String s = l1.get(i);
            System.out.println(s);
        }

    }
}

2. 增强for循环

package com.itheima.demo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        List<String> l1 = new ArrayList<>();

        l1.add("1");
        l1.add("2");
        l1.add("3");
        l1.add("4");
        l1.add("1");

        System.out.println(l1);

        //增强for循环遍历
        for (String s : l1) {
            System.out.println(s);
        }


    }
}

3. 使用迭代器

package com.itheima.demo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        List<String> l1 = new ArrayList<>();

        l1.add("1");
        l1.add("2");
        l1.add("3");
        l1.add("4");
        l1.add("1");

        System.out.println(l1);

        //迭代器的方式进行遍历
        Iterator<String> it = l1.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }

    }
}

4. 使用List 列表专用的迭代器 ListIterator()方法

  • 通过 List 集合的 listIterator()方法得到，所以说它是List集合特有的迭代器

  • 用于允许程序员沿任一方向遍历的列表迭代器，在迭代器期间修改列表，并获取列表中迭代器的当前位置。添加元素的时候，需要使用 ListIterator 的 add方法

public interface ListIterator<E>
extends Iterator<E>
1. ListIterator常用方法
方法名说明
boolean hasNext()如果此列表迭代器在向后面遍历列表时具有更多的元素，则返回true。
E next()返回列表中的下一个元素，并且前进光标位置
boolean hasPrevious()如果此列表迭代器在相反方向遍历列表时具有更多的元素，则返回true
E previous()返回列表中的上一个元素，并向后移动光标位置
void add(E e)将指定的元素插入列表
package com.itheima.demo;

import java.util.*;

public class Test {
    public static void main(String[] args) {
        List<String> l1 = new ArrayList<>();

        l1.add("1");
        l1.add("2");
        l1.add("3");
        l1.add("4");
        l1.add("1");

        ListIterator<String> lit = l1.listIterator();
        while (lit.hasNext()) {
            String s = lit.next();
            if (s.equals("1")) {
                lit.add("7");
            }
        }
        System.out.println(l1);
    }
}

5. List集合的注意事项

使用迭代器进行遍历的时候，会出现ConcurrentModificationException ， 并发修改异常

出现这种问题的原因

/*
    Iterator<String> it = list.iterator();
        while (it.hasNext()) {
        String s = it.next();
        if(s.equals("haha")) {
            list.add("javaee");
        }
上面的代码：列表 使用 迭代器的时候，报了下面的错误
Exception in thread "main" java.util.ConcurrentModificationException
    at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
	at java.util.ArrayList$Itr.next(ArrayList.java:859)
    at com.itheima.demo.ListCollection.ListCollectionDemo1.main(ListCollectionDemo1.java:34)
错误 发生在  it.next() 语句当中 it是 Iterator 类型,
它是由 ArrayList.iterator()方法得到的，返回的是 一个 new Itr();
    public Iterator<E> iterator() {
        return new Itr();
    }
调用关系：调用的是 Itr 类的 next 方法
@SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }
 然后是 checkForComodification(); 报错了
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }
    那么 modCount 和 expectedModCount 又是什么时候改变的，应该是 add执行的时候，更改了其中一个变量，导致两者数据不一致
expectedModCount: 是预期需要修改的 次数
    add方法增加了 modCount 的数量
      public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
 */

在这里插入图片描述

5. ArrayList类

public class ArrayList<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable

底层是数组结构实现，查询快、增删慢

1. 3种遍历方式

可以使用三种遍历方式， 参见 4. List集合的遍历

6. LinkedList 类

public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, Serializable

底层是链表结构实现，查询慢、增删快

1. LinkedList 集合的特有功能

方法名说明
public void addFirst(E e)在该列表开头插入指定的元素
public void addLast(E e)将指定的元素追加到此列表的末尾
public E getFirst()返回此列表中的第一个元素
public E getLast()返回此列表中的最后一个元素
public E removeFirst()从此列表中删除并返回第一个元素
public E removeLast()从此列表中删除并返回最后一个元素

2. 3种遍历方式

可以使用三种遍历方式， 参见 4. List集合的遍历

7. Set 集合

1. Set集合特点

public interface Set<E>
extends Collection<E>
  • 元素存取无序
  • 没有索引、只能通过迭代器或增强 for循环遍历
  • 不能存储重复元素

2. Set集合的方法

方法名说明
boolean add(E e)添加元素
boolean remove(Object o)从集合中移除指定的元素
void clear()清空集合中的元素
boolean contains(Object o)判断集合中是否存在指定的元素
boolean isEmpty()判断集合是否为空
int size()集合的长度，也就是集合中元素的个数
Iterator<E> iterator()返回此集合中元素的迭代器

3. Set集合的遍历方式

1. 增强for循环

2. 迭代器的方式

8. HashSet 类，实现Set接口的类

public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, Serializable

1. HashSet集合的特点

  • 底层数据结构是哈希表
  • 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
  • 没有带索引的方法，所以不能使用普通for循环遍历
  • 由于是Set集合，所以是不包含重复元素集合

2. HashSet 类的方法

方法名说明
boolean add(E e)添加元素
boolean remove(Object o)从集合中移除指定的元素
void clear()清空集合中的元素
boolean contains(Object o)判断集合中是否存在指定的元素
boolean isEmpty()判断集合是否为空
int size()集合的长度，也就是集合中元素的个数
Iterator<E> iterator()返回此集合中元素的迭代器

3. HashSet 集合保证元素唯一性源码分析

在这里插入图片描述

HashSet 的 add 方法  (hs.add("java");)
public boolean add(E e) {// E 是String 对象
    return map.put(e, PRESENT)==null;
}
//返回 "java".hashCode() 
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
//put("java", PRESENT); key = "java"
public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
}
//putVal("java".hashCode(), "java");
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;
    //根据对象的哈希值计算对象的存储位置，如果该位置没有元素，就存储元素
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        /*
        存入的元素和以前的元素比较哈希值
        如果哈希值不同，会继续向下执行，把元素添加到集合中
        如果哈希值相同，会调用对象的equals()方法比较，
        如果返回 false，会继续向下执行，把元素添加到集合当中
        如果返回true，说明元素重复，不存储
        */
        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;
            }
        }
        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;
}

结论：

  • 要保证元素的唯一性，需要重写存储对象的 hashCode() 和 equals()

4. HashSet 集合的遍历

因为它是实现 Set 接口的类，所以也只有两种方式进行遍历。

1. 增强for循环

2. 迭代器

9. LinkedHashSet 集合

public class LinkedHashSet<E>
extends HashSet<E>
implements Set<E>, Cloneable, Serializable

1. LinkedHashSet 集合特点

  • 哈希表和链表实现的Set接口，具有可预测的迭代次序
  • 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
  • 由哈希表保证元素唯一，也就是说没有重复的元素

2. LinkedHashSet 方法

方法名说明
boolean add(E e)添加元素
boolean remove(Object o)从集合中移除指定的元素
void clear()清空集合中的元素
boolean contains(Object o)判断集合中是否存在指定的元素
boolean isEmpty()判断集合是否为空
int size()集合的长度，也就是集合中元素的个数
Iterator<E> iterator()返回此集合中元素的迭代器

3. LinkedHashSet 集合的遍历

1. 增强for循环

2. 迭代器

10. TreeSet集合

public class TreeSet<E>
extends AbstractSet<E>
implements NavigableSet<E>, Cloneable, Serializable


public abstract class AbstractSet<E>
extends AbstractCollection<E>
implements Set<E>

1. TreeSet集合特点

  • 元素有序，可以按照一定的规则进行排序，具体排序方式取决于构造方法
    • TreeSet()：根据其元素的自然排序进行排序
    • TreeSet(Comparator comparator)
  • 没有带索引的方法，所以不能使用普通的for循环遍历
  • 由于是Set集合，所以不包含重复的元素

2. 自然排序 Comparable 的使用

  • 案例需求
    存储学生对象并遍历，创建TreeSet集合使用无参构造方法
  • 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
  • 实现步骤
    用TreeSet()集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
    自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法
    重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

代码实现
学生类

public class Student implements Comparable<Student> {
    
}

3. 比较器排序 Comparator 的使用

  • 案例需求
    存储学生对象并遍历，创建TreeSet集合使用带参构造方法

  • 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

  • 实现步骤

  • 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的

    • 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法
    • 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

代码实现
学生类

就是一个普通的 Student 类

测试类

TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
    @Override
    public int compare(Student o1, Student o2) {
        return 0;
    }
});

4. TreeSet 集合遍历

1. 增强for循环

2. 迭代器

5. TreeSet 集合靠什么保证 元素唯一性?

1. 如果是 自然排序，是存储的 类对象(Student) 实现 Comparable 来保证的。

public class Student implements Comparable<Student> {
    
}

2. 如果是比较器排序，是通过传递过来的 Comparator<Student> 来实现的

TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
    @Override
    public int compare(Student o1, Student o2) {
        return 0;
    }
});
梦悦foundation
关注
专栏目录
Java集合教程之Collection实例详解
08-27
Collection Framework是Java中的一种重要的API，提供了丰富的集合操作API，包括Collection、List、Set、Map等。这些接口和类的设计目的是为了提供一种灵活、可扩展的集合操作机制，能够满足不同的应用场景。 在Java...
Mybatis的mapper.xml中<collection></collection>的用法
热门推荐
朱哲的博客
06-05 2万+
在mapper.xml文件中，我们在使用collection时有两种用法。这里做一下简单记录：1、直接将collection集合元素的属性写为collection的字标签如下：&lt;resultMap type="com.space.shiro.bean.User" id="userMap"&gt; &lt;id property="id" column="uid"/&gt;
Mybatis 一对多查询列表属性处理
搬山境KL攻城狮的修炼手册
05-09 4756
Mybatis 一对多查询列表属性处理 一、说明 1.``标签属性说明 2. 示例代码 二、平铺查询 三、 嵌套查询（Nested Select for Collection） 3.1 外键查询 3.2 select传入多个参数
MyBatis之association和collection标签
csdnzhang365的博客
03-24 1万+
一般情况下一对一使用标签，一对多使用标签。
在xml中collection、association的用法
m0_52563512的博客
05-06 2807
在xml中collection、association用法
集合
weixin_49538651的博客
01-17 326
集合 一、集合概念 集合的概念：当在程序创建的对象比较多的时候，需要对进行统一的管理和操作，那么我们就需要把这些对象存储起来。存储对象的容器称之为集合。 集合的作用：当对象多的时候，先进行存储。 集合的特点： （1）集合的长度是可变的 （2）集合存储的都是对象，而且对象的类型可以不一致 集合框架：集合本身是一个工具，它存放在java.util包中。 ​JDK最早的1.0版本中。提供的集合容器很少。升级到1.2版，为了更多的需求，出现了 集合框架 。有了更多的容器。可以完成不同的需求。 容器区分的方式：每一个
Java集合定义与用法实例总结【Set、List与Map】
08-27
Java集合定义与用法实例总结【Set、List与Map】 Java集合是Java语言中的一种数据结构，主要用于存储和操作数据。Java集合可以分为三大类：Set、List和Map。这些集合都继承了基类接口Collection，Collection接口定义...
Java中的collection集合类型总结
09-02
在集合框架的设计中，`AbstractCollection`、`AbstractList`和`AbstractSet`作为抽象类，实现了`Collection`、`List`和`Set`接口中的大部分方法，降低了具体实现类的编写工作量。 总结来说，Java集合框架提供了一套...
Java集合Collection、List、Set、Map使用详解编程资料
03-24
Java集合Collection、List、Set、Map使用详解
Tedu一阶段JavaSet集合和List集合
最新发布
03-04
### Tedu一阶段Java Set集合和List集合详解 #### 一、集合概述 - **集合的概念**：在Java中，集合是一种容器，用于存储多个对象。它可以存储不同类型的对象，并且提供了一系列的操作来管理这些对象。 - **...
Java Collection总结
Keep moving
10-25 745
ArrayList和Vector是采用数组方式存储数据，此数组元素总数大于实际存储的数据个数以便增加和插入元素，二者都允许直接序号索引元素，但是插入数据要移动数组元素等内存操作，所以它们索引数据快、插入数据慢。 ArrayList数组存储方式： [java] view plaincopyprint? private transient Ob
类集框架(一)--Collection接口
iamwiam的博客
05-21 311
1.类集框架定义 jdk提供的一系列类和接口，位于java.util包中，主要用于存储和管理对象。主要分为三大类：集合、列表和映射。 集合Set：用于存储一系列对象的集合（无序且不允许元素重复）。 列表List：用来存储有顺序的一组数据的集合（有序，元素可以重复）。 映射Map：以键值对的方式进行数据存储的集合(键不可以重复，值可重复)。 最常用到的集合API如下(Map事实上并没有继承C
Collection 和 Collections 有什么区别？Collection 和 Collections的详解
2301_77247579的博客
10-06 446
Collection是 Java 集合框架的根接口之一，用于表示一个对象集合，它不是一个具体的类，而是一个接口定义了一组通用的集合操作。Collection接口定义了对集合的操作，包括添加、删除、查询、遍历等。是 Java 集合框架提供的一个实用类，用于对集合进行各种操作和处理。类中的方法通常用于操作集合的元素，而不是直接操作集合本身。类中的方法都是静态方法，不需要创建对象，可以通过类名直接调用。Collection是一个接口，定义了集合框架的通用操作，用于操作对象集合本身。
关于mybatis中的＜collection＞两种用法我想说
qq_36917119的博客
08-31 3403
概述 mybatis中的两种用法 内嵌ResultMap 内嵌Query 以下介绍都会围绕场景：一片博客blog有多个标签tag来进行。 内嵌ResultMap 用法如下 <collection property="tags" ofType="com.blog.po.Tag"> <id property="id" column="tagid" /> <result property="name" column="tagname" /&
java中的集合collection，list，set，map...详解
烛照@123的博客
11-15 271
集合类是Java数据结构的实现。Java的集合类是java.util包中的重要内容，它允许以各种方式将元素分组，并定义了各种使这些元素更容易操作的方法。
Java 学习速记三：集合一（Collection，Set）
红烧栗子黄瓜鱼的博客
03-23 580
Java 学习速记三：集合一（Collection，Set）
关于 Collection 用于 .xml 文件的使用及说明
m0_54162653的博客
03-14 1254
一. 关于Collection 在 .xml中设置, 让一对多数据返回成 list 集合形式 ***首先看使用方式 : *** (注: collection 中的 property 类型必须是 SysUser创建对应的哦~ ) Mybatis 会自动将非 SysUser对象属性并且 SysUser相同的 数据进行封装成一个集合 并返给你; 如果想返回的是对象的话 那么ofType 就可以换成已经创建的对象就行了; ...
Java进阶技术：集合
weixin_44598691的博客
03-14 221
集合 Set接口： 一个不包含重复元素的 collection。 数据无序(因为set集合没有下标)。 由于集合中的元素不可以重复。常用于给数据去重。 特点： HashSet：底层是哈希表，包装了HashMap，相当于向HashSet中存入数据时，会把数据作为K，存入内部的HashMap中。当然K仍然不许重复。 TreeSet：底层就是TreeMap，也是红黑树的形式，便于查找数据。 Has...
Java学习笔记——Collection之Set
D77的博客
07-28 1044
Set接口常用的实现类有HashSet、LinkedHashSet、TreeSet。Set无序不可重复的集合，只能根据元素本身来访问。
Java集合框架深度解析：Collection、List、Map与Set
"Java集合框架详解，包括Collection、List、Map、Set等核心概念和技术的详细解析。" 在Java编程中，集合框架是一个重要的组成部分，它提供了存储和操作对象的统一接口和实现。本资料详细介绍了集合框架的各个方面，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值