从零开始学java--集合类（2）

最新推荐文章于 2025-05-07 11:48:08 发布

爱吃小土豆豆豆豆

最新推荐文章于 2025-05-07 11:48:08 发布

阅读量954

点赞数 26

文章标签： java 开发语言

本文链接：https://blog.csdn.net/PluMage11/article/details/147507006

版权

集合类

Queue

队列的使用：

在Java中，Queue是个接口，底层是通过链表实现的。

方法	功能
boolean add(E e)	入队列（插入失败会抛出异常）
boolean offer(E e)	入队列
E remove( )	出队列（队列已经为空会抛出异常）
E poll( )	出队列
element( )	获取对头元素（队列已经为空会抛出异常）
peek( )	获取队头元素
int size( )	获取队列中有效元素个数
boolean isEmpty()	boolean isEmpty()

注意：Queue是个接口，在实例化时必须实例化LinkedList的对象，因为LinkedList实现了Queue接口。

双端队列（Deque）

双端队列（deque）是指允许两端都可以进行入队和出队操作的队列，deque 是 “double ended queue” 的简称。那就说明元素可以从队头出队和入队，也可以从队尾出队和入队。

双端队列既可以当做普通队列使用，也可以当做栈来使用。

Deque是一个接口，使用时必须创建LinkedList的对象。

Map和Set

概念：

Map和set是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关。以前常见的搜索方式有：

直接遍历，时间复杂度为O(N)，元素如果比较多效率会非常慢
二分查找，时间复杂度为 ,但搜索前必须要求序列是有序的

上述排序比较适合静态类型的查找，即一般不会对区间进行插入和删除操作了，而现实中的查找比如：

根据姓名查询考试成绩
通讯录，即根据姓名查询联系方式
不重复集合，即需要先搜索关键字是否已经在集合中

可能在查找时进行一些插入和删除的操作，即动态查找，那上述两种方式就不太适合了，本节介绍的Map和Set是一种适合动态查找的集合容器。

模型：

一般把搜索的数据称为关键字（Key），和关键字对应的称为值（Value），将其称之为Key-value的键值对，所以模型会有两种：

纯 key 模型，比如：

有一个英文词典，快速查找一个单词是否在词典中
快速查找某个名字在不在通讯录中

Key-Value 模型，比如：

统计文件中每个单词出现的次数，统计结果是每个单词都有与其对应的次数：<单词，单词出现的次数>
梁山好汉的江湖绰号：每个好汉都有自己的江湖绰号

而Map中存储的就是key-value的键值对，Set中只存储了Key。

Map

Map是一个接口类，该类没有继承自Collection，该类中存储的是结构的键值对，并且K一定是唯一的，不能重复。

常见方法说明：

方法	解释
V get(Object key)	返回 key 对应的 value
V getOrDefault(Object key, V defaultValue)	返回 key 对应的 value，key 不存在，返回默认值
V put(K key, V value)	设置 key 对应的 value
V remove(Object key)	删除 key 对应的映射关系
void putAll(Map<? extands K, ? extands V)	将另一个Map中的所有键值对添加到当前Map中
void clear( )	清空整个Map
Set keySet()	返回所有 key 的不重复集合
Collection values()	返回所有 value 的可重复集合
Set<Map.Entry<K,V>> entrySet()	返回所有的 key-value 映射关系
boolean containsKey(Object key)	判断是否包含 key
boolean containsValue(Object value)	判断是否包含 value

注意：

Map是一个接口，不能直接实例化对象，如果要实例化对象只能实例化其实现类TreeMap或者HashMap
Map中存放键值对的Key是唯一的，value是可以重复的
在TreeMap中插入键值对时，key不能为空，否则就会抛NullPointerException异常，value可以为空。但是HashMap的key和value都可以为空。
Map中的Key可以全部分离出来，存储到Set中来进行访问(因为Key不能重复)。
Map中的value可以全部分离出来，存储在Collection的任何一个子集合中(value可能有重复)。
Map中键值对的Key不能直接修改，value可以修改，如果要修改key，只能先将该key删除掉，然后再来进行重新插入。

TreeMap和HashMap的区别：

Map底层结构	TreeMap	HashMap
底层结构	红黑树	哈希桶
插入/删除/查找时间复杂度	O(log2N)	O(1)
是否有序	关于Key有序	无序
线程安全	不安全	不安全
插入/删除/查找区别	需要进行元素比较	通过哈希函数计算哈希地址
比较与覆写	key必须能够比较，否则会抛出ClassCastException异常	自定义类型需要覆写equals和hashCode方法
应用场景	需要Key有序场景下	Key是否有序不关心，需要更高的时间性能

LinkedHashMap按照插入顺序遍历

    public static void main(String[] args){
        Map<Integer,String> map=new HashMap<>();
        map.put(1,"小红");
        map.put(2,"小明");
        map.forEach((k,v)->System.out.println(k+"="+v));

        Map<Integer,String>map1=new TreeMap<>((a,b)->b-a); //按倒序输出
        map1.put(2,"m");
        map1.put(1,"j");
        map1.put(3,"a");
        map1.forEach((k1,v1)->System.out.println(k1+"="+v1));

    }
/*
1=小红
2=小明
3=a
2=m
1=j
*/

Set

常见方法说明：

方法	解释
boolean add(E e)	添加元素，但重复元素不会被添加成功
void clear()	清空集合
boolean contains(Object o)	判断o是否在集合中
Iterator<E> iterator()	返回迭代器
boolean remove(Object o)	删除集合中的o
int size()	返回set中元素的个数
boolean isEmpty()	检测set是否为空，空返回true，否则返回false
Object[] toArray()	将set中的元素转换为数组返回
boolean containsAll(Collection<?> c)	集合c中的元素是否在set中全部存在，是返回true,否则返回false
boolean addAll(Collection<?extends E>c)	将集合c中的元素添加到set中，可以达到去重的效果

注意：

Set是继承自Collection的一个接口类
Set中只存储了key，并且要求key一定要唯一
不支持随机访问（不允许通过下标访问）
TreeSet的底层是使用Map来实现的，其使用key与Object的一个默认对象作为键值对插入到Map中的
Set最大的功能就是对集合中的元素进行去重
实现Set接口的常用类有TreeSet和HashSet，还有一个LinkedHashSet，LinkedHashSet是在HashSet的基础上维护了一个双向链表来记录元素的插入次序。
Set中的Key不能修改，如果要修改，先将原来的删除掉，然后再重新插入
TreeSet中不能插入null的key，HashSet可以。

TreeSet和HashSet的区别：

Set底层结构	TreeSet	HashSet
底层结构	红黑树	哈希桶
插入/删除/查找时间复杂度	O	O(1)
是否有序	关于key有序	不一定有序
线程安全	不安全	不安全
插入/删除/查找区别	按照红黑树的特性来进行插入和删除	1、先计算key哈希地址 2、然后进行插入和删除
比较与覆写	key必须能够比较，否则会抛出ClassCastException异常	自定义类型需要覆写equals和hashCode方法
应用场景	需要Key有序场景下	Key是否有序不关心，需要更高的时间性能

Stream流

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。Stream使用一种类似用SQL语句从数据库查询数据的直观方式来提供一种对Java集合运算和表达的高阶抽象。这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选、排序、聚合等。

    public static void main(String[] args){
        List<String> list =new ArrayList<>(Arrays.asList("aaaa","Saaaa","Saaaa","xx","Xss","Lxxx"));
        //删除长度不大于3的字符串
        //删除首字母不为大写的字母
        //去掉重复的字符串
        list=list.stream()
                .filter(str ->str.length()>3) //保留的条件
                .filter(str ->str.charAt(0)>='A'&&str.charAt(0)<='Z')
                .distinct()  //去重，用equals判断
                .collect(Collectors.toList());
        System.out.println(list);

        List<Integer>collect=list.stream()
                .map(String::length)
                .collect(Collectors.toList());
        System.out.println(collect);

    }
//输出[Saaaa, Lxxx]
//[5, 4]

不能认为每一步是直接依次执行的。Stream会先记录每一步操作，而不是直接开始执行内容，当整个链式调用完成后，才会依次执行，也就是说需要的时候，工厂的机器才会按照预定的流程启动。

生成随机数：

    public static void main(String[] args){
        Random random=new Random();
        random.
                ints(-100,100)
                .limit(10)
                .filter(i -> i<0) //只保留小于0的数字
                .sorted()  //默认从小到大排序
                .forEach(System.out::println);
    }

Collections工具类

Arrays是一个用于操作数组的工具类

Collections类是专用于集合的工具类

常用方法：

    public static void main(String[] args){

        List list1=new ArrayList<>(Arrays.asList(1,4,5,2,9,0));
        //求最大值最小值
        Collections.max(list1);
        Collections.min(list1);

        //对集合进行二分搜索（注意：集合的具体类型必须是实现Comparable接口的类）
        Collections.sort(list1);
        System.out.println(Collections.binarySearch(list1,4));
//输出3

        //对集合的元素进行快速填充，注意这个填充是对集合中的已有元素进行覆盖
        //如果集合中本身没有元素，那么fill操作不会生效
        Collections.fill(list1,0);
        System.out.println(list1);
//输出[0, 0, 0, 0, 0, 0]

        //emptyXXX快速生成一个只读的空集合
        List<Integer>list2=Collections.emptyList();
        //Collections.singletonList()会生成一个只有一个元素的List
        list2.add(10); //不支持，会直接抛出异常

        //将一个可修改的集合变成只读的集合：
        List<Integer>list3=new ArrayList<>(Arrays.asList(1,3,3,24));
        List<Integer>newList=Collections.unmodifiableList(list3);
        newList.add(10); //不支持，会抛出异常

        //寻找子集合的位置
        System.out.println(Collections.indexOfSubList(list3,Arrays.asList(3,3)));
//输出1
    }

由于泛型机制上的一些漏洞，实际上对应类型的集合类有可能会存放其他类型的值，泛型的检查值存在于编译阶段，我们只要绕过这个阶段，在实际运行时，并不会真的进行类型检查，要解决这些问题就是在运行时进行类型检查：

    public static void main(String[] args){

        List list1=new ArrayList<>(Arrays.asList(1,4,5,2,9,0));
        list1=Collections.checkedList(list1,Integer.class);
        list1.add("aaa");
        System.out.println(list1);
        
    }
//在输出时会报错