2021-07-26

最新推荐文章于 2024-10-01 18:51:18 发布
最新推荐文章于 2024-10-01 18:51:18 发布
阅读量250 收藏
点赞数 1
分类专栏： java_进阶 文章标签： java 集合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48740620/article/details/119117990
版权

集合

集合的出现

数组存储多个对象，但是数组本身存在一些不可避免的弊端。java针对存储对象提供了一种新的结构，这种结构就是集合，集合就像是一个容器，可以动态的把多个对象的引用放入到容器中。

数组在存储方面的能力

  • 数组在内存存储方面的特点：
  1. 数组初始化以后 长度就是确定的，不可以改变
  2. 数组声明的类型 就决定了进行元素初始化时的类型
  • 数组在存储方面的弊端：
  1. 输出初始化之后 长度不可变 不便于扩展
  2. 数组中提供的属性和方法较少，不便于对元素进行添加 删除 插入等操作，且效率不高，同时无法直接获取存储的元素的个数。
  3. 数组存储的数据是有序的，可以重复。

java集合可以存储数量不等多个对象，还可以保存具有映射关系的数据。

集合的体系结构

集合的特点： 提供一种存储空间可变的存储模型，存储的数据的容量可以随时发生改变。

public interface Collection<E>  extends Iterable<E>

集合层次结构中的根接口，只能存储对象，而其他集合不允许。有的集合是有序的，而有的集合是无序的。 JDK不提供此接口的任何直接实现：它提供了更具体的子接口的实现，如Set和List 。 该接口通常用于传递集合，并在需要最大的通用性的情况下对其进行操作。（多态性）
在这里插入图片描述

Collection接口的使用

Collection 是单列集合的顶层接口，他表示一组对象，这些对象也称为元素。
JDK不提供此接口的直接实现 但是可以通过的子接口的实现来创建集合对象

booleanadd(E e) 确保此集合包含指定的元素（可选操作）。
booleanaddAll(Collection<? extends E> c) 将指定集合中的所有元素添加到此集合（可选操作）。
voidclear() 从此集合中删除所有元素（可选操作）。
booleancontains(Object o) 如果此集合包含指定的元素，则返回 true 。
booleancontainsAll(Collection<?> c) 如果此集合包含指定 集合中的所有元素，则返回true。
booleanequals(Object o) 将指定的对象与此集合进行比较以获得相等性。
inthashCode() 返回此集合的哈希码值。
booleanisEmpty() 如果此集合不包含元素，则返回 true 。
Iterator<E>iterator() 返回此集合中的元素的迭代器。
booleanremove(Object o) 从该集合中删除指定元素的单个实例（如果存在）（可选操作）。
booleanremoveAll(Collection<?> c) 删除指定集合中包含的所有此集合的元素（可选操作）。
booleanretainAll(Collection<?> c) 仅保留此集合中包含在指定集合中的元素（可选操作）。
intsize() 返回此集合中的元素数。
Object[]toArray() 返回一个包含此集合中所有元素的数组。
<T> T[]toArray(T[] a) 返回包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。
  public static void main(String[] args) {
        //创建一个Collection对象
        Collection collection = new ArrayList();
        //Collection接口中的方法 添加元素
        collection.add("Hello");
        collection.add(123);//自动装箱 对应的基本类型的包装类
        collection.add(true);
        System.out.println(collection);
    }

public static void main(String[] args) {
        //创建一个Collection对象
        Collection collection = new ArrayList();
        //Collection接口中的方法 添加元素
        collection.add("Hello");
        collection.add(123);//自动装箱 对应的基本类型的包装类
        collection.add(true);
       // collection.clear();//清除集合中的元素
        // 判断集合中是否包含某一个对象
        System.out.println(collection.contains(123));
        // 移除集合中的某一个元素
        System.out.println(collection.remove(123));
        // 判断集合是否为空
        System.out.println(collection.isEmpty());
        //获取集合中元素的个数
        System.out.println(collection.size());
        //将一个集合转换为数组
        Object[] arr = collection.toArray();
        System.out.println(arr.length);
        System.out.println(collection);
    }

public class CollectionTest {
    public static void main(String[] args) {
        //创建一个Collection对象
        Collection collection = new ArrayList();
        //Collection接口中的方法 添加元素
        collection.add("Hello");
        collection.add(123);//自动装箱 对应的基本类型的包装类
        collection.add(true);
        Collection c1 = new ArrayList();
        c1.add("world");
        c1.add("hello");
        c1.add(false);
        Student stu1 = new Student("张三",18);
        c1.add(stu1);
        // addAll
        collection.addAll(c1);
        System.out.println(collection);
        //判断集合中是否包含另一个集合中的所有元素
        System.out.println(collection.containsAll(c1));
        // 取两个集合的交集  存放在当前集合中
        collection.retainAll(c1);
        System.out.println(collection);
        //删除此集合中的另一个集合
//        collection.removeAll(c1);
//        System.out.println(collection);
    }

Iterator

迭代集合的迭代器

booleanhasNext() 如果迭代具有更多元素，则返回 true 。
Enext() 返回迭代中的下一个元素。
    public static void main(String[] args) {
        //创建一个Collection对象
        Collection collection = new ArrayList();
        //Collection接口中的方法 添加元素
        collection.add("Hello");
        collection.add(123);//自动装箱 对应的基本类型的包装类
        collection.add(true);
        collection.add("world");
        collection.add("hello");
        collection.add(false);
        Student stu1 = new Student("张三",18);
        collection.add(stu1);
        // 迭代器迭代集合
       Iterator iter =  collection.iterator();
       // 使用迭代器来迭代集合
       while(iter.hasNext()){
         Object obj =   iter.next();
           System.out.println(obj);
       }
    }

源码分析

ArrayList

在这里插入图片描述

   public boolean hasNext() {
            return cursor != size;// size表示集合中元素个数
        }

        @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];
        }

List

List集合的特点：

  • 有序集合（也称为序列 ）。 可以精确控制列表中每个元素的插入位置。 用户可以通过整数索引（列表中的位置）访问元素，并搜索列表中的元素。

  • 列表通常允许重复的元素

  • 可以存储null 并且可以存储多个

    典型实现

    ArrayList LinkedList Vector

List接口特有方法：

  • add(int index, Object element) 将指定的元素插入此列表中的指定位置（可选操作）。

  • Objectget(int index) 返回此列表中指定位置的元素。
  • intindexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
  • intlastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
  • ListIterator<E>listIterator() 返回列表中的列表迭代器（按适当的顺序）。
  • Eset(int index, E element) 用指定的元素（可选操作）替换此列表中指定位置的元素。
  • List<E>subList(int fromIndex, int toIndex) 返回此列表中指定的 fromIndex （含）和 toIndex之间的视图。

List的使用

public class ListTest {
    public static void main(String[] args) {
        Student stu1 = new Student("张三",18);
        Student stu2 = new Student("李四",21);
        Student stu3 = new Student("王五",20);
        Student stu4 = new Student("赵六",22);
        List list = new ArrayList();
        list.add(stu4);
        list.add(stu3);
        list.add(stu2);
        list.add(stu1);
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);
        list.add(stu4);
       Iterator iter =  list.iterator();
       while(iter.hasNext()){
           Object obj = iter.next();
           System.out.println(obj);
       }
        System.out.println("------------------------------");
       for(int i = 0 ; i < list.size();i++){
            Object obj = list.get(i);
           System.out.println(obj);
       }
    }
}

List集合的有序：这里的有序指的是元素的存入顺序和迭代的顺序是一致的

集合的迭代方式

   public static void main(String[] args) {
        Student stu1 = new Student("张三",18);
        Student stu2 = new Student("李四",21);
        Student stu3 = new Student("王五",20);
        Student stu4 = new Student("赵六",22);
        List list = new ArrayList();
        list.add(stu4);
        list.add(stu3);
        list.add(stu2);
        list.add(stu1);
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);
        list.add(stu4);
       Iterator iter =  list.iterator();
       while(iter.hasNext()){
           Object obj = iter.next();
           System.out.println(obj);
       }
        System.out.println("------------------------------");
       for(int i = 0 ; i < list.size();i++){
            Object obj = list.get(i);
           System.out.println(obj);
       }
        System.out.println("------------------------------");
       for(Object obj : list){
           System.out.println(obj);
       }
        System.out.println("------------------------------");
       for(  Iterator itr =  list.iterator();itr.hasNext();){
           Object obj = itr.next();//在使用迭代器迭代的时候  在一个循环中  next方法只能在一处调用
           System.out.println(obj);
       }
        System.out.println("------------------------------");
        Iterator itr1 =  list.iterator();
        for(;itr1.hasNext();){
            Object obj = itr1.next();//在使用迭代器迭代的时候  在一个循环中  next方法只能在一处调用
            System.out.println(obj);
        }
    }

迭代器使用while和for那个更好？

​ for循环更利于空间的释放

但是在开发中 普遍使用while

并发修改异常

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("java");
        Iterator iter =  list.iterator();
        while(iter.hasNext()){
            Object obj = iter.next();
            String str = (String) obj;
            if(str.equals("world")){
                list.add("hadoop");
            }
        }
    }

ConcurrentModificationException ： 并发修改异常

产生原因：

​ 迭代器在迭代集合的过程中，通过集合对象修改了集合的元素，造成迭代器获取园中判断预期修改值和实际修改值不一致

解决方案：通过集合本身来进行遍历集合，有集合自己修改

for(int i = 0 ; i < list.size();i++){
    String str = (String)list.get(i);
    if(str.equals("world")){
      //  list.add("hadoop");//新增  新增到集合的末尾
        list.set(i,"hadoop");// 修改元素
    }
}
System.out.println(list);

Listlteator

voidadd(E e) 将指定的元素插入列表（可选操作）。
booleanhasNext() 返回 true如果遍历正向列表，列表迭代器有多个元素。
booleanhasPrevious() 返回 true如果遍历反向列表，列表迭代器有多个元素。
Enext() 返回列表中的下一个元素，并且前进光标位置。
intnextIndex() 返回随后调用 next()返回的元素的索引。
Eprevious() 返回列表中的上一个元素，并向后移动光标位置。
intpreviousIndex() 返回由后续调用 previous()返回的元素的索引。
voidremove() 从列表中删除由 next()或 previous()返回的最后一个元素（可选操作）。
voidset(E e) 用 指定的元素替换由 next()或 previous()返回的最后一个元素（可选操作）。
public class ListDemo {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("java");
        // 获取列表迭代器
       ListIterator iterator =  list.listIterator();
       // 遍历同时天剑
        while(iterator.hasNext()){
            Object obj = iterator.next();
            // 当遇到元素为world的时候  给列表追加元素spring
            if(obj.equals("world")){
                iterator.add("spring");
                iterator.previous();//是的指针指向前一个元素
            }
            System.out.println(obj);
        }
        System.out.println(list);
        System.out.println("-----------------------");
        //迭代的同时删除元素
        ListIterator iterator1 =  list.listIterator();
        while(iterator1.hasNext()){
            Object obj = iterator1.next();
            if(obj.equals("world")){
                iterator1.remove();
            }else{
                System.out.println(obj);
            }
        }
        System.out.println("-----------------------");
        //修改
        ListIterator iterator2 =  list.listIterator();
        while(iterator2.hasNext()){
            Object obj = iterator2.next();
            if(obj.equals("hello")){
                iterator2.set("mybatis");
                iterator2.previous();

            }else{
                System.out.println(obj);
            }
        }
    }
}

 public static void main(String[] args) {
        List list = new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("java");
        ListIterator iter = list.listIterator();
        while(iter.hasNext()){
            Object obj = iter.next();
            System.out.println(obj);
        }
        System.out.println("----------------------");//在逆序之前必须先正序遍历  
        while(iter.hasPrevious()){
            Object obj = iter.previous();
            System.out.println(obj);
        }
    }

List sub =  list.subList(1,2);//获取子集  包含1  不包含2
        System.out.println(sub);
Sakura婷
关注
专栏目录
2021-07-26 .NET高级班 120-直播项目专题(图片防盗链)
微软MVP Eleven
07-26 4万+
/// <summary> /// 这里是一个标准的中间件的定义 /// </summary> public class HotlinkingPreventionMiddleware { private readonly RequestDelegate _next; private readonly IConfiguration _IConfiguration = null; public HotlinkingPreventionMiddle..
12.定义一个集合类SET，处理整型数组。
Mr123zhangchao的博客
05-18 1266
12.定义一个集合类SET，处理整型数组。通过成员函数重载运算符“==”，判断一个数是否属于集合;通 过友元重载运算符“==”，判断两个集合是否相同，即集合中的所有元素相同，但顺序可不同。具体要求如下: (1)私有数据成员: int *a; //数据成员，存放整型数组，集合为数组中的所有元素 int len; //数据成员，数组的长度 (2)公有成员函数: SET(int*p,intn):构造函数，以形参初始化数据成员; int operator==(intm):重载函数，判断m是否属于当前对象所属的集..
2021-07-20
女巫哈哈的博客
07-20 234
Git 删除分支恢复 git reflog 查看所有本地提交记录，根据记录确定需要恢复的最新的HEAD{} git checkout -b branchName HEAD{刚刚看到记录里确定的num}
2021-04-26
sandrew0916的博客
04-26 732
导语 explicit防止隐式转换 拷贝构造 拷贝赋值
css虚线间隔——2021-07-26
m0_51400566的博客
07-26 2352
第一种最简单的实现虚线效果，无间隔。效果如下 第二种若想加大虚线中间的间隔，可以使用如下代码，效果如下。 注：background-size的数值大小可以改变虚线间隔的大小。
2021-03-15
weixin_44902539的博客
03-15 1279
好网站 https://blog.csdn.net/u013317445/article/details/88196373?utm_medium=distribute.pc_relevant.none-task-blog-OPENSEARCH-6.control&dist_request_id=1328641.48931.16157665162059593&depth_1-utm_source=distribute.pc_relevant.none-task-blog-OPENSEARCH-
2021-07-26 WSL2 的安装和联网
QAQ_dream的博客
07-26 3066
0、说明 最近在学习 Data Assimilation Research Testbed (DART) 相关内容，其软件是在 Unix/Linux 操作系统下编译和运行的 ，由于我的电脑是 Windows 10 的，DART 推荐可以使用 Windows Subsystem For Linux (WSL) 来创建一个 Windows 下的 Linux 子系统。以下的内容主要介绍如何安装 WSL2，以及 WSL2 的联网。 1、如何在 Windows 10 下安装WSL 具体的安装流程可以在 microso
2021-01-18
weixin_54641072的博客
01-18 1857
找程序猿哥哥！！！！编制App或者小程序
2021-07-28
lixiaoxianer的博客
07-28 4078
kubeadmin 安装k8s1.20集群 标签（空格分隔）： kubernetes架构系列 一：k8s1.20.x 的重要更新 二：k8s1.20.x 的安装 2.1 ：高可用Kubernetes集群规划 2.2 yum 的更新配置 （所有节点全部安装） 一：k8s1.20.x 的重要更新 1、Kubectl debug 设置一个临时容器 2、Sidecar 3、Volume：更改目录权限，fsGroup 4、ConfigMap和Secret K8S官网：https://kubernetes.io/
2021-07-10
qq_51747477的博客
07-15 2575
Docker容器学习 一、Docker的概述 1、Docker的三个文件 二、Docker的安装 查看系统环境 [root@localhost ~]# uname -r 3.10.0-1127.el7.x86_64 [root@localhost ~]# cat /etc/os-release NAME=“CentOS Linux” VERSION=“7 (Core)” ID=“centos” ID_LIKE=“rhel fedora” VERSION_ID=“7” PRETTY_NAME=
【2021-07-26更新】gate-client
12-02
2021-07-26更新 网络技术研究，用于中继服务器架设测试。 注意：请连接自己创建的中继站，不要连接未知服务器
C540001_TLE7240SL_2021-07-26.PDF
10-21
TLE7240SL 8通道保护式低侧继电器开关数据手册 本文将对TLE7240SL 8通道保护式低侧继电器开关芯片进行详细介绍，涵盖其Overview、Block Diagram、Pin Configuration、General Product Characteristics、Input and ...
室内最后100米配送机器人[2021-07-26]（15页）.pdf
05-23
【室内最后100米配送机器人】是一种专为解决商业场所内部最后阶段的物品递送问题而设计的高科技设备，尤其在餐饮业和快递行业中应用广泛。这些机器人旨在缓解人力资源短缺，降低配送成本，提高效率，并确保在无接触...
Visual Studio C# WPF 2017鼠标滚轮实现放大缩小源码大全2021-07-26.rar
08-12
在本文中，我们将深入探讨如何在Visual Studio 2017中使用C#和WPF（Windows Presentation Foundation）框架通过鼠标滚轮实现图形或界面的放大与缩小功能。这一技术在许多应用程序中都非常实用，例如图像查看器、地图...
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 424
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
spring-boot 整合 mybatis
m0_72168501的博客
09-29 530
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 793
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1247
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 328
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
有一个表A ，有字段date，值是 2023-01-31,2023-02-28,2023-03-06， 还有一个表B，有金额和日期两个字段，值是2023-03-09 00:00:00.000000 47260 2022-12-29 00:00:00.000000 28566 2022-08-01 00:00:00.000000 3378.7 2023-03-29 00:00:00.000000 4296 2023-03-06 00:00:00.000000 2369 2022-12-26 00:00:00.000000 51100 2023-02-07 00:00:00.000000 33057 2021-08-11 00:00:00.000000 11500 2022-04-14 00:00:00.000000 23219.8 2022-02-09 00:00:00.000000 100010 2021-12-31 00:00:00.000000 59100 写一个oracle sql 计算B表的日期分别在表A中的每个日期的前一年到该日期时间的B表的金额的总和
06-07
可以使用Oracle的日期函数和子查询来解决这个问题。以下是一个可能的SQL语句： ``` SELECT A.date, SUM(B.amount) AS total_amount FROM A, B WHERE B.date BETWEEN ADD_MONTHS(A.date, -12) AND A.date ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值