源码解析系列：ArrayList(4) - set、get、clear、contains、toString方法和迭代器

已于 2022-07-11 00:54:23 修改
阅读量395 收藏 1
点赞数 1
分类专栏： 源码分析 文章标签： java 算法 数据结构 list
于 2022-07-10 23:23:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/laohuangaa/article/details/125679700
版权

文章目录

前言

这一部分将会介绍源码中set、get、clear、contains、toString方法和迭代器，参考视频: ArrayList源码解析

ArrayList源码解析(1)：ArrayList源码解析(1)
ArrayList源码解析(2)：ArrayList源码解析(2)
ArrayList源码解析(3)：ArrayList源码解析(3)
ArrayList源码解析(4)：ArrayList源码解析(4)
ArrayList源码解析(5)：ArrayList源码解析(5)

1. set方法

public E set(int index, E element)：根据下标修改元素

public E set(int index, E element) {
	//检查下标是否越界
    rangeCheck(index);
	//通过下标获取元素
    E oldValue = elementData(index);
    //设置新的元素
    elementData[index] = element;
    //返回旧的值
    return oldValue;
}

private void rangeCheck(int index) {
	//下标越界就抛出异常
 	if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

总结流程：

  1. 检查下标是否越界
  2. 通过下标获取元素
  3. 设置新的元素
  4. 返回旧的值



2. get方法

public E get(int index)：根据索引获取元素

public E get(int index) {
	//检查下标越界
    rangeCheck(index);
    //返回元素
    return elementData(index);
}

E elementData(int index) {
    return (E) elementData[index];
}

总结流程：

  1. 检查下标是否越界
  2. 通过下标查找返回值



3. toString()方法

public String toString()：打印字符串方法

public String toString() {
	 //获取迭代器
     Iterator<E> it = iterator();
     //如果没有下一个，返回空
     if (! it.hasNext())
         return "[]";
	 //创建初一个StringBuilder
     StringBuilder sb = new StringBuilder();
     //下面使用append方法进行凭借，StringBuilder拼接的方式比使用 + 号拼接要快
     sb.append('[');
     for (;;) {
         E e = it.next();
         sb.append(e == this ? "(this Collection)" : e);
         if (! it.hasNext())
             return sb.append(']').toString();
         sb.append(',').append(' ');
     }
 }



4. 迭代器

public Iterator iterator() 普通迭代器。下面在进行迭代器的源码分析的时候我们先通过两个案例来看看迭代器的用法和一些特殊的地方

4.1 使用迭代器遍历集合

public class sourceTest {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("aaa");
        arrayList.add("bbb");
        arrayList.add("ccc");
        final Iterator<String> iterator = arrayList.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

输出结果：
在这里插入图片描述


那么在这个基础上我们进行迭代器的方法的分析：

1、基础的源码

public Iterator<E> iterator() {
	//在iterator方法中是new了一个ArrayList自己的迭代器
	return new Itr();
}

//迭代器
private class Itr implements Iterator<E> {
        int cursor;       // 光标，用于指向数组
        int lastRet = -1; // 一开始记录为-1
        int expectedModCount = modCount; 	//把集合的修改次数赋值给预期修改次数	

        Itr() {}
}

2、hasNext和next方法

public boolean hasNext() {
	//判断光标有没有等于size，如果不等于证明此时还没有遍历完成
  	return cursor != size;
}

public E next() {
	//判断预期修改次数和实际修改次数
    checkForComodification();
    //获取光标的位置，光标是从0开始的
    int i = cursor;
    //如果i>-=size, 证明到达了结尾了
    if (i >= size)
        throw new NoSuchElementException();
    //获取集合中的数据元素
    Object[] elementData = ArrayList.this.elementData;
    //如果 i >= 元素的长度，证明产生了并发修改异常
    //上面既然 i < size 但是 i >= elementData.length, 证明了此时elementData已经其他线程被修改了，导致长度对不上
    if (i >= elementData.length)
        throw new ConcurrentModificationException();
    //都正常情况下，就光标指向下一个
    cursor = i + 1;
   	//然后获取当前的这一个元素，并且对lastRet赋值为i
    return (E) elementData[lastRet = i];
}

final void checkForComodification() {
	//如果预期修改次数不等于实际修改次数，发生并发修改异常
	//正常情况下遍历是不会出现这种情况的
 	if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}



4.2 使用迭代器遍历删除指定元素

public class sourceTest {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<String>();
        //添加元素
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        //获取迭代器
        Iterator<String> it = list.iterator();
        //遍历集合
        while(it.hasNext()) {
            String s = it.next();
            if(s.equals("aaa")) {
                list.remove("aaa");
            }
        }
    }
}

结果输出：
在这里插入图片描述

可以看到发生了并发修改异常，那么为什么会发生这种异常呢？我们到源码中去看看

//首先要知道执行到list.iterator();的时候modCount也就是实际修改次数 = 3
//因为add方法每调用一次这个变量就+1
modCount++;

//在调用到list.iterator()的时候期望修改次数被修改为了3
expectedModCount = modCount = 3

//然后来到了next方法中
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();
}

上面都是迭代器中的一些基本的代码，下面就是最关键的remove方法，这个方法在前面的文章也有介绍，就不详细说了，关键是fastRemove，在fastRemove中对modCount进行++了

public boolean remove(Object o) {
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}

private void fastRemove(int index) {
	//在fastRemove中对实际修改次数++了
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work
}

在fastRemove中对modCount++之后，到了下一次判断的时候modCount=4，而expectedModCount=3，自然就不相等了，就会抛出异常。



4.3 使用迭代器遍历删除指定元素

还是和上面4.2的一样，只不过这里我们删除倒数第二个元素

public class sourceTest {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<String>();
        //添加元素
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        //获取迭代器
        Iterator<String> it = list.iterator();
        //遍历集合
        while(it.hasNext()) {
            String s = it.next();
            if(s.equals("bbb")) {
                list.remove("bbb");
            }
        }
        System.out.println(list);
    }
}

结果输出：
在这里插入图片描述

其实源码和上面的一样，不同的地方就在当遍历到第二个的时候，由于使用了remove方法，这时候size从3变成了2，然后光标 cursor = 2，那么这时候hasNext方法就返回false了，直接退出。也就是说根本不会遍历到最后一行。我们可以做个测试，往list里面加入两个bbb，然后删除倒数第二个：

list.add("aaa");
list.add("bbb");
list.add("bbb");

结果输出：
在这里插入图片描述

可以看到最后一个根本不会遍历到。



4.4 使用迭代器自带的删除元素的方法

public class sourceTest {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<String>();
        //添加元素
        list.add("aaa");
        list.add("bbb");
        list.add("bbb");
        //获取迭代器
        Iterator<String> it = list.iterator();
        //遍历集合
        while(it.hasNext()) {
            String s = it.next();
            if(s.equals("bbb")) {
                it.remove();
            }
        }
        System.out.println(list);
    }
}

输出结果：
在这里插入图片描述

可以看到，使用迭代器自带的remove方法就可以安全删除，再来看看源码：

public void remove() {
	//如果lastRet<0, 那么证明没有遍历到，抛异常
    if (lastRet < 0)
        throw new IllegalStateException();
    //查看期望修改次数是否等于实际修改次数
    checkForComodification();

    try {
    	//调用ArrayList的remove方法
        ArrayList.this.remove(lastRet);
        //然后lastRet赋值给光标
        cursor = lastRet;
        //重置为-1
        lastRet = -1;
        //关键一步来了，这里重新对expectedModCount进行赋值了，所以checkForComodification
        //方法中是不会不相同的，也就没有并发修改异常了
        expectedModCount = modCount;
    } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
    }
}

里面关键的地方就是重新赋值了expectedModCount = modCount，所以后面判断就不会成立。



5. clear方法

public void clear() {
	//修改次数++
	modCount++;
	
	// 赋值为null等待GC请理
	for (int i = 0; i < size; i++)
	    elementData[i] = null;
	//设置size = 0
	size = 0;
}

总结流程：

  1. 修改次数++
  2. 赋值为null等待GC清理
  3. size设置为0



6. contains方法

public boolean contains(Object o) {
	//求出下标
 	return indexOf(o) >= 0;
}

//求出下标
public int indexOf(Object o) {
 	 if (o == null) {
 	 	//遍历全部求
        for (int i = 0; i < size; i++)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = 0; i < size; i++)
        	//也是遍历全部使用equals方法来判断
            if (o.equals(elementData[i]))
                return i;
    }
    //如果都没有找到就返回-1
    return -1;
}

总结：

  1. 求出下标
  2. 如果下标 >= 0, 就是找到了，如果等于-1就是没找到





如有错误，欢迎指出！！！！

JWASX
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中Arraylist源码分析
Palpitate_fx的博客
03-26 1195
一：ArrayList的成员变量 private static final long serialVersionUID = 8683452581122892189L; //序列版本号 private static final int DEFAULT_CAPACITY = 10;//默认数组元素的初始容量为10 private static final Object[] EMPTY_ELEMENTDATA = {};//空元素对象数组 private static fi
ArrayList重写（4）ArrayList实现set和get方法
古道西风
12-19 1840
package Study.Collection; /** * &amp;amp;amp;lt;p&amp;amp;amp;gt;Description: &amp;amp;amp;lt;/p&amp;amp;amp;gt; * 增加set和get方法 * 增加：数组边界的检查 * @author zhangyan * @date 2018/12/19 12:50 */ public class YanArrayList03&amp;amp;amp;
从源码角度彻底搞懂ArrayList(4)
wang688699的博客
04-06 637
分享一份工作1到5年以上的Android程序员架构进阶学习路线体系，希望能对那些还在从事Android开发却还不知道如何去提升自己的，还处于迷茫的朋友！阿里P7级Android架构师技术脑图；查漏补缺，体系化深入学习提升**全套体系化高级架构视频；**七大主流技术模块，视频+源码+笔记有任何问题，欢迎广大网友一起来交流《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门即可获取！
Java_集合_ArrayList(4)
ylineyline的专栏
03-19 173
1，储存方式public class ArrayList&lt;E&gt; extends AbstractList&lt;E&gt; implements List&lt;E&gt;, RandomAccess, Cloneable, java.io.Serializable{ private static final Object[] EMPTY_ELEMENTD...
Java源码阅读之ArrayList（4）
国世的博客
01-24 831
/**      * AbstractList.ListItr的优化版本      */     private class ListItr extends Itr implements ListIterator {                  /**          * 构造函数，必须指定初始句柄位置          */   ListItr(int index) {
自定义ArrayList(三)-增加set()、get()方法
小沐CA
05-14 1239
自定义ArrayList(三) 此次增加增加set()、get()方法来操作变量，保证其严密性。 public E get(int index) { // TODO Auto-generated method stub checkRange(index); return (E)elementData[index]; } public void set(E element,int...
Java中Set&List的迭代器实现步骤解析
08-25
Java中Set和List的迭代器实现步骤解析是Java编程语言中一个重要的知识点。迭代器是一种设计模式，用于遍历集合中的元素。在Java中，Set和List是两种常用的集合类型，它们都可以使用迭代器来遍历其元素。 在Java中，...
cs源码java-CsvFileSource:Java2-4-2
05-19
"Cs源码java-CsvFileSource:Java2-4-2"可能是指这个项目的一个版本号或迭代号，暗示了其基于Java 2到4.2的某些特性。 首先，我们需要理解CSV文件的基本结构。CSV文件由一行行的数据组成，每行数据由逗号分隔的值...
源码解析jdk7.0集合：ArrayList的底层实现原理.pdf
03-11
源码解析jdk7.0集合：ArrayList的底层实现原理.pdf
解析Java的迭代器中的fast-fail错误检测机制
09-02
2. **使用迭代器的`remove()`方法删除元素**：在迭代过程中，如果需要删除元素，应该使用迭代器的`remove()`方法，而不是直接调用集合的`remove()`方法。 3. **复制集合**：在修改集合前，可以先复制一份集合，然后...
Java中ArrayList类的源码解析
08-31
Java中ArrayList类的源码解析 ArrayList是Java中最常用的集合类之一，它实现了List接口，继承自AbstractList抽象类。在ArrayList中，我们可以看到它的源码实现了Iterable接口、List接口和Collection接口。下面我们...
ArrayList源码解读二之add、set、get、remove
weixin_40743551的博客
03-27 468
ArrayList源码解读二之add、set、get、remove 在看add、set源码之前，我们先看几个重要的函数，add、set、remove、get都会调用它。 private static int calculateCapacity(Object[] elementData, int minCapacity) {//获取数组大小 if (elementData == DEFAUL...
java迭代器添加string,java String、迭代器解释】、集合
weixin_39693295的博客
03-12 185
java 的数据类型：引用数据类型 基本数据类型(8种)int 、Integer: Ineger是int的封装类：integer i = 5；integer b=5， 则a==b，a.equals(b)//jdk1.5之后如果装箱的是一个字节，则该字节被共享。String：是一个final类在使用String类的时候，如果频繁的去进行字串的拼接，会产生大量的对象，可以使用StringBuffer...
ArrayList源码分析
SHUIHAN_007的博客
04-06 1295
ArrayList的数据结构 ArrayList的底层数据结构就是一个数组，数组元素的类型为Object类型，对ArrayList的所有操作底层都是基于数组的。 ArrayList的线程安全性 对ArrayList进行添加元素的操作的时候是分两个步骤进行的 第一步先在object[size]的位置上存放需要添加的元素； 第二步将size的值增加1 由于这个过程在多线程的环境下是不能保证具有原子性的，因此ArrayList在多线程的环境下是线程不安全的。 具体举例说明 在单线程运行的情况下，如果Size =
get 迭代器
AaronWang0920的博客
09-06 408
package cn.itcast.list;import java.util.ArrayList;/*集合的体系： ----------| Collection 单列集合的根接口 ----------------| List 如果实现了List接口的集合类，具备的特点： 有序，可重复。 --------------------| ArrayList ArrayList 底层是维护了一个Obj
iterator方法，toString方法实现与add方法的测试
zhanghongxian123的专栏
10-22 925
3.iterator方法。跟上个ArrayList类似，为了更方便测试。这个实现所有人都知道了哈。   （1）      创建一个Interator的类   private class LinkedListIteratorT> implementsIterator{        Node curr = head;//注意这一行不是最终版。向下看        @Overrid
手动实现ArrayList 增加set和get方法，以及边界越界检查(4)
weixin_40072979的博客
09-27 912
package com.jianshun; /** * 增加：set和get方法 * 增加：数组边界的检查 * @author 凡凡 * */ public class SxtArrayList04&lt;E&gt; { private Object[] elementData; private int size; private static final int DEF...
乱披风锤法锤炼ArrayList源码中的get、set、contains、isEmpty方法！！！肝起来
Coding Earth Engine
07-06 551
点赞在看，养成习惯。 点赞收藏，人生辉煌。 点击关注【微信搜索公众号：编程背锅侠】，防止迷路。 转载请标注来源出处，谢谢合作。共同学习，共同进步。 前言 看源码血泪史 乱披风锤法，这个自创魂技可是唐三非常强烈的一个技能，将昊天锤的九九八十一锤以和自己的鬼影迷踪步结合在了一起，缺陷弥补了，而且将优势发挥得更大，最后的一锤的吴天锤更是所向披靡，无敌的存在。看源码也一样要经历九九八十一难，才能够真正理解其中的奥妙。 看源码是一个比较耗费时间和精力的过程，可能会要看很多遍才能够真正的看懂。看源码也是一个很.
JDK8集合基础.pdf
最新发布
04-19
JDK8集合基础是Java编程中不可或缺的一部分，本文档详细介绍了Java集合框架的基础知识，包括集合体系图的理解、迭代器的使用、以及List接口及其重要子类ArrayList的特点和操作。以下是对这些内容的深入解析： 1. **...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值