JavaSE 集合进阶

最新推荐文章于 2021-02-22 13:27:12 发布
最新推荐文章于 2021-02-22 13:27:12 发布
阅读量1.1k 收藏 7
点赞数 2
分类专栏： JavaSE 文章标签： java javase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46651512/article/details/111656485
版权

JavaSE 集合进阶

1. Collection

1.1 集合知识回顾

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

1.2 集合类体系结构

在这里插入图片描述

1.3 Collection 集合概述和使用

Collection 集合概述：

  • 是单列集合的顶层接口，它表示一组对象，这些对象也被称为Collection 的元素
  • JDK 不提供此接口的任何直接实现，它提供更具体的子接口（如Set和List）实现

创建Collection 集合的对象

  • 多态的方式
  • 具体的实现类ArrayList
package com.Collection;

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

public class Demo01 {
   
    public static void main(String[] args){
   
        //创建Collection集合对象
        Collection<String> c = new ArrayList<String>();
        //添加元素：boolean add(E e)
        c.add("cappuccino");
        c.add("love");
        c.add("bug");
        System.out.println(c);
    }
}

在这里插入图片描述

1.4 Collection 集合常用方法

在这里插入图片描述

1.5 Collection 集合的遍历

Iterator:迭代器，集合的专用遍历方式

  • Iterator <E> iterator():返回此集合中元素的迭代器，通过集合的iterator()方法得到
  • 迭代器是通过集合的iterator()方法得到的，所以我们说它是依赖于集合而存在的

Iterator中的常用方法：

  • E next():返回迭代中的下一个元素
  • boolean hasNext():如果迭代具有更多元素，则返回true
package com.Collection;

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

public class Demo02 {
   
    public static void main(String[] args){
   
        //创建Collection集合对象
        Collection<String> c = new ArrayList<String>();
        //添加元素：boolean add(E e)
        c.add("cappuccino");
        c.add("love");
        c.add("bug");
        /*
        Iterator <E> iterator():返回次集合中元素的迭代器，
        通过集合的iterator()方法得到
         */
        Iterator<String> it = c.iterator();
        /*boolean hasNext():如果迭代具有更多元素，则返回true
          E next():返回迭代中的下一个元素
         */
        while(it.hasNext()){
   
            String s = it.next();
            System.out.println(s);
        }
    }
}

在这里插入图片描述

1.6 案例

  • 需求：
    创建一个存储学生对象的集合，存储三个学生对象，使用程序实现在控制台遍历该集合

  • 思路：

    1. 定义学生类
    2. 创建Collection集合对象
    3. 创建学生对象
    4. 把学生添加到集合
    5. 遍历集合（迭代器方式）
package com.Collection;

public class Student {
   
    private String name;
    private int age;
    public Student(){
   }
    public Student(String name, int age) {
   
        this.name = name;
        this.age = age;
    }
    public String getName() {
   
        return name;
    }

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

    public int getAge() {
   
        return age;
    }

    public void setAge(int age) {
   
        this.age = age;
    }
}

package com.Collection;

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

/*
  需求：
    创建一个存储学生对象的集合，存储三个学生对象，使用程序实现在控制台遍历该集合
  思路：
    1.定义学生类
    2.创建Collection集合对象
    3.创建学生对象
    4.把学生添加到集合
    5.遍历集合（迭代器方式）
 */
public class CollectionTest {
   
    public static void main(String[] args){
   
        //创建Collection集合对象
        Collection<Student> c = new ArrayList<Student>();
        //创建学生对象
        Student s1 = new Student("苦瓜",21);
        Student s2 = new Student("半仙儿",22);
        Student s3 = new Student("研",23);
        //把学生添加到集合
        c.add(s1);
        c.add(s2);
        c.add(s3);
        //遍历集合（迭代器方式）
        Iterator<Student> it = c.iterator();
        while(it.hasNext()){
   
            Student s = it.next();
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

在这里插入图片描述

2. List

2.1 List 集合概述和特点

  • List 集合概述

    1. 有序集合（也成为了序列），用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素
    2. 与 set 集合不同，列表通常允许重复的元素

  • List 集合的特点

    1. 有序：存储和取出元素顺序一致
    2. 可重复：存储的元素可以重复
package com.List;

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

/*
    List 集合的特点:
        有序：存储和取出元素顺序一致
        可重复：存储的元素可以重复
 */
public class Demo01 {
   
    public static void main(String[] args){
   
        //创建集合对象
        List<String> list = new ArrayList<String>();
        //添加元素
        list.add("研");
        list.add("半仙儿");
        list.add("苦瓜");
        list.add("研");
        //输出集合
        System.out.println(list);

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

在这里插入图片描述

2.2 List 集合特有的方法

在这里插入图片描述

2.3 并发修改异常

  • 并发修改异常：ConcurrentModificationException
  • 产生原因：
    迭代器遍历的过程中，通过集合对象修改了集合中元素的长度，造成了迭代器获取元素中预期修改值和实际修改值不一致
  • 解决方案：
    用for循环遍历，然后用集合对象做相应的操作即可
package com.List;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/*
    需求：
        集合里面有三个元素，遍历集合，得到每一个元素，看有没有"研"这个元素；
        如果有，就添加一个"粉色匡威"元素
    ConcurrentModificationException：并发修改异常
    当不允许这样的修改时，可以通过检测到对象的并发修改的方法来抛出此异常
 */

public class ConcurrentModificationException {
   
    public static void main(String[] args){
   
        List<String> list = new ArrayList<String>();
        list.add("苦瓜");
        list.add("半仙儿");
        list.add("研");
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
   
            String s = it.next();
            if(s.equals("研")){
   
                list.add("粉色匡威");
            }
        }
//        for(int i=0;i<list.size();i++){
   
//            String s = list.get(i);
//            if(s.equals("研")){
   
//                list.add("粉色匡威");
//            }
//        }
        System.out.println(list);
    }
}

在这里插入图片描述

/*
	并发修改异常的源码分析
*/
public interface List<E>{
   
    Iterator<E> iterator();
    boolean add(E e);
}

public abstract class AbstractList<E>{
   
    protected int modCount = 0;
}

public class ArrayList<E> extends AbstractList<E> implements List<E>{
   

        public E get(int index) {
   
            rangeCheck(index);
            return elementData(index);
        }

        public boolean add(E e) {
   
            ensureCapacityInternal(size + 1);  /* Increments modCount!!
                                                  modCount++
                                               */
            elementData[size++] = e;
            return true;
        }

        public Iterator<E> iterator() {
   
           return new Itr();
        }

        private class Itr implements Iterator<E> {
   
            int expectedModCount = modCount;

            /*
                modCount:实际修改集合的次数
                expectedModCount:预期修改集合的次数
            */


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

            final void checkForComodification() {
   
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
            }
        }
}

2.4 ListIterator

ListIterator: 列表迭代器

  • 通过List集合的 ListIterator() 方法获得，所以说它是List集合特有的迭代器
  • 允许程序员沿任意方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

ListIterator中常用方法：

  • E next():返回迭代中的下一个元素
  • boolean hasNext():如果迭代具有更多元素，则返回 true
  • E previous():返回列表中的上一个元素
  • boolean hasPrevious():如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回 true
  • void add(E e):将指定的元素插入列表
package com.ListIterator;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
/*
    ListIterator: 列表迭代器
        通过List集合的 listIterator() 方法获得，所以说它是List集合特有的迭代器
        允许程序员沿任意方向遍历列表的列表迭代器，在迭代期间修改列表，
        并获取列表中迭代器的当前位置
    ListIterator中常用方法：
        E next():返回迭代中的下一个元素
        boolean hasNext():如果迭代具有更多元素，则返回 true
        E previous():返回列表中的上一个元素
        boolean hasPrevious():如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回 true
        void add(E e):将指定的元素插入列表
 */
public class Demo01 {
   
    public static void main(String[] args){
   
        //创建集合对象
        List<String> list = new ArrayList<String>();
        //添加元素
        list.add("苦瓜");
        list.add("粉色");
        list.add("匡威");
        //通过List集合的 listIterator() 方法获得
//        ListIterator<String> lit = list.listIterator();
//        while(lit.hasNext()){
   
//            String s = lit.next();
//            System.out.println(s);
//        }
//        System.out.println("--------");
//        //逆向遍历（很少用）
//        while(lit.hasPrevious()){
   
//            String s = lit.previous();
//            System.out.println(s);
//        }
        ListIterator<String> lit = list.listIterator();
        while(lit.hasNext()){
   
            String s = lit.next();
            if(s.equals("苦瓜")){
   
                lit.add("研");
            }
        }
        System.out.println(list);
    }
}

在这里插入图片描述

/*
	ListIterator源码分析
*/
public interface List<E>{
   
    Iterator<E> iterator();
    ListIterator<E> listIterator();
}

public abstract class AbstractList<E>{
   
    protected int modCount = 0;
}

public class ArrayList<E> extends AbstractList<E> implements List<E>{
   


        public Iterator<E> iterator() {
   
           return new Itr();
        }

        private class Itr implements Iterator<E> {
   
            ...
        }
        public ListIterator<E> listIterator() {
   
            return new ListItr(0);
        }

        private class ListItr extends Itr implements ListIterator<E> {
   

            public void add(E e) {
   
                checkForComodification();

                try {
   
                    int i = cursor;
                    ArrayList.this.add(i, e);
                    cursor = i + 1;
                    lastRet = -1;
                    expectedModCount = modCount;  //重点
                                        /*
                                            列表迭代器的add()方法在添加元素
                                            之后会将实际修改次数赋值给预期修
                                            改次数，所有不会出现并发修改异常
                                        */
                } catch (IndexOutOfBoundsException ex) {
   
                    throw new ConcurrentModificationException();
                }
            }
        }
}

2.5 增强 for 循环

增强for循环：简化数组和 Collection 集合的遍历

  • 实现 Iterable 接口的类允许其对象成为增强型 for 语句的目标
  • 它是 JDK5 之后出现的，其内部原理是一个 Iterator 迭代器

增强 for 的格式

  • 格式：
    for(元素数据类型 变量名:数组或者Collection集合){
    //在此处使用变量即可，该变量就是数组或者集合的元素
    }
  • 范例：
int[] arr = {
   1,2,3};
for(int i:arr)
最低0.47元/天 解锁文章
苦瓜bug
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
JavaSE 字符串
苦瓜的博客
11-09 1738
JavaSE 字符串APIAPI 概述StringString 概述String 构造方法String 对象的特点字符串的比较通过帮助文档查看 String 中的方法StringBuilderStringBuild 概述StringBuild 的构造方法StringBuild 的添加和反转方法 API API 概述 API(Application Programming Interface)：应用程序编程接口 Java API:指的就是 JDK 中提供的各种功能的 Java 类 这些类将底层的实现封装了起
JavaSE 方法引用
苦瓜的博客
02-25 1074
JavaSE 方法引用1. 方法引用1.1 体验方法引用1.2 方法引用符1.3 Lambda 表达式支持的方法引用1.4 引用类方法1.5 引用对象的实例方法1.6 引用类的实例方法1.7 引用构造器 1. 方法引用 1.1 体验方法引用 在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿参数做操作 如果我们在Lambda中所指定的操作方案，已经有地方存在相同的方案，那就没必要再写重复逻辑 如何使用已经存在的方案？ 这就是我们要讲解的方法引用，通过方法引用来使用已经存在的方案 p
JavaSE 继承
苦瓜的博客
11-12 1787
JavaSE 继承继承继承概述继承的好处与弊端继承中变量的访问特点super 关键字继承中构造方法的访问特点继承中成员方法的访问特点方法重写 继承 继承概述 继承是面向对象三大特征之一。可以使得子类拥有父类的属性和方法，还可以在子类中重新定义、追加属性和方法。 继承的格式 格式：public class 子类名 extends 父类名 { } 范例：public class Zi extends Fu { } Fu ：父类，也称为基类、超类 Zi：子类，也称为派生类 继承中子类的特点： 子类可以有父类
JavaSE数组
苦瓜的博客
10-31 1354
JavaSE 数组数组定义格式数组初始化之动态初始化数组元素访问内存分配数组初始化之静态初始化数组操作常见的两个小问题数组常见操作 数组定义格式 数组初始化之动态初始化 数组元素访问 内存分配 数组初始化之静态初始化 数组操作常见的两个小问题 数组常见操作 ...
JavaSE 网络编程
苦瓜的博客
02-22 189
JavaSE 网络编程1. 网络编程入门1.1 网络编程概述1.2 网络编程的三要素1.3 IP地址1.4 InetAddress 的使用1.5 端口1.6 协议2. UDP通信程序2.1 UDP通信原理2.2 UDP发送数据2.3 UDP接收数据3. TCP通信程序 1. 网络编程入门 1.1 网络编程概述 计算机网络 是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统 网络编程
JavaSE进阶-05-集合.pdf
09-10
2020动力节点老杜javaSE进阶班-集合05教材，希望各位想学习和巩固javaSE的下载学习。楼主最近也在学习这个，配合视频感觉蛮好的。。。。。。
JavaSE进阶数组讲义
08-30
1. 数组是一组数据的集合 2. 数组作为一种引用类型 3. 数组元素的类型可以是基本类型，也可以是引用类型，但同一个数组只能是同一种类型 4. 数组作为对象，数组中的元素作为对象的属性，除此之外数组还包括一个...
JavaSE进阶每日复习与笔记.zip
11-03
课堂笔记 抽象类以及接口 集合笔记 集合的继承结构图 数组笔记 线程笔记 线程生命周期 异常笔记 异常的继承结构图 注解
7集合-List.xmind
08-26
JavaSE进阶学习图
8泛型和set集合.xmind
08-26
JavaSE进阶学习图
88SE9230 R1.1 Two-Lane PCIe 2.0 to Four-Port SATA 6 Gbps RAI.pdf
07-03
88SE9230芯片手册
J2SE1.8_JDK
01-22
j2se1.8的压缩包，懒散的同学拿去。
JavaSE 内部类
苦瓜的博客
12-24 191
JavaSE 内部类内部类内部类概述 内部类 内部类概述 内部类：就是在一个类中定义一个类。 例如：在一个类A的内部定义一个类B，类B就被称为内部类。
一百个超级值得收藏网站，确定看见不点开看看嘛
热门推荐
g1219807696的博客
12-08 4万+
1、Windows、Office等微软原版镜像下载：https://msdn.itellyou.cn/ 2、V2EX：科技宅/程序员，新奇想法聚集地：https://www.v2ex.com/ 3：计算机书籍控：汇总各类编程语言的pdf书籍下载： http://bestcbooks.com/ 4：最新版迅雷发布站：http://yangtai.xunlei.com/ 5、有趣网址之家：汇集上千个有趣网站：https://youquhome.com/ 6、书格：提供大量古籍免费下载的网站： http://pc
JavaSE 方法
苦瓜的博客
10-31 3883
JavaSE 方法方法概述方法的定义方法的定义和调用方法的定义方法的调用带参数方法的定义和调用带参数方法定义带参数方法的调用带返回值带返回值方法的定义和调用方法的注意事项方法重载方法的参数传递 方法概述 方法的定义 方法 是将具有独立功能的 代码块 组织成为一个整体，使其具有特殊功能的 代码集。 注意： 方法必须先创建才可以使用，该过程称为 方法定义。 方法创建后并不是直接运行的，需要手动使用后才执行，该过程称为 方法调用。 方法的定义和调用 方法的定义 格式： public static void
JavaSE 面向对象基础
苦瓜的博客
11-06 2891
JavaSE类和对象对象内存图成员变量和局部变量封装构造方法 类和对象 对象内存图 成员变量和局部变量 封装 构造方法
JavaSE 接口
苦瓜的博客
11-23 1096
JavaSE 接口接口接口概述 接口 接口概述
JavaSE 集合基础
苦瓜的博客
11-11 567
JavaSE 集合基础集合概述 集合概述
JavaSE运算符
苦瓜的博客
10-28 2319
运算符算术运算符运算符和表达式算术运算符字符的 " + " 操作字符串的 " + " 操作赋值运算符赋值运算符自增自减运算符自增自减运算符关系运算符逻辑运算符三元运算符 算术运算符 运算符和表达式 运算符：对常量或者变量进行操作的符号。 表达式：用运算符把常量或者变量连接起来符合Java语法的式子称为表达式。不同运算符连接的表达式体现的是不同类型的表达式。 算术运算符 加（＋） 减（－） 乘（×） 除（/） 取余（%） int a = 6; int b = 4; System.out.println
javase用map集合对图书进行增删改查
最新发布
01-11
使用JavaSE中的Map集合可以很方便地对图书进行增删改查操作。Map集合是一种键值对的集合，通过键来快速查找对应的值。 首先，我们可以创建一个Map集合来保存图书信息，其中键可以是图书的名称、编号等唯一标识，值...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值