ArrayList的add(Object obj)和remove(Object obj)和remove(index)和get(index)的源码分析

最新推荐文章于 2023-03-13 20:46:41 发布
最新推荐文章于 2023-03-13 20:46:41 发布
阅读量595 收藏
点赞数
分类专栏： JavaSE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29963323/article/details/77435060
版权

1.add(Object obj)


ArrayList list1 = new ArrayList();
		list1.add("a");
		list1.add(2);
		list1.add(3);
		list1.add(4);
		list1.add(5);	
		list1.add(6);	
		list1.add(7);	
		list1.add(8);	
		list1.add(9);	
		list1.add(10);
		list1.add(11);
		System.out.println(list1);
	
	public boolean add(E e) {//
		//size为int类型的,初值为默认类型.所以此时size的值为0
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
	

		
	 private void ensureCapacityInternal(int minCapacity) {
		 //此时minCapacity=1
		 //elementData和DEFAULTCAPACITY_EMPTY_ELEMENTDATA都为初值,所以相等
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
			//DEFAULT_CAPACITY：值为10,
			//minCapacity:值为1
			//DEFAULT_CAPACITY： private static final int DEFAULT_CAPACITY = 10;
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }




	  //传入的值 minCapacity=10,
	  private void ensureExplicitCapacity(int minCapacity) {
        modCount++;//位计数器,没有实质的作用

		//elementData.length=0.
		//minCapacity=10
		//minCapacity - elementData.length > 0成立,
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
	
	//minCapacity=10
	 private void grow(int minCapacity) {
		//elementData.length = 0;故 oldCapacity=0
        int oldCapacity = elementData.length;
		//newCapacity值也为0
        int newCapacity = oldCapacity + (oldCapacity >> 1);
		// newCapacity - minCapacity = -10 < 0成立,所以newCapacity = 10；
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
		//private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
		//newCapacity - MAX_ARRAY_SIZE > 0不成立.若newCapacity - MAX_ARRAY_SIZE > 0成立,会内存溢出
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        //newCapacity = 10,所以此时的elementData长度为10,数组的长度为10,此时的elementData内的是个元素都为null
        elementData = Arrays.copyOf(elementData, newCapacity);

		//这里的方法就是数组扩容.此时数组的长度变为10,之后在往上返回
    }

	//此时,add的方法源码分析完毕,这是会把“a”这个元素添加到数组中,之后进行分析再添加一个元素

	
	//添加第二个元素时
	//若添加的元素的int类型,会把int类型装箱,变为Integer类型
	 public static Integer valueOf(int i) {
			if (i >= IntegerCache.low && i <= IntegerCache.high)
				return IntegerCache.cache[i + (-IntegerCache.low)];
			return new Integer(i);
		}

	
	 public boolean add(E e) {
		 //此时size为1
        ensureCapacityInternal(size + 1);  // Increments modCount!!

        elementData[size++] = e;
        return true;
    }

	private void ensureCapacityInternal(int minCapacity) {
		//此时minCapacity=2
		//此时elementData=[a, null, null, null, null, null, null, null, null, null]
		//DEFAULTCAPACITY_EMPTY_ELEMENTDATA 还是为0个长度
		//所以不成立
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
		//此时minCapacity=2
        ensureExplicitCapacity(minCapacity);
    }
	
	 private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

		//minCapacity = 2,elementData.length > 0不成立,所以，数组的不扩容
        
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);//数组的扩容
    }

    //当数组的元素个数小于等于10时,数组都不扩容
	.
	.
	.
	.
	.
	.
	//当添加到11个元素时
	
	//第11个元素还未int类型,所以进行装箱
	 public static Integer valueOf(int i) {
			if (i >= IntegerCache.low && i <= IntegerCache.high)
				return IntegerCache.cache[i + (-IntegerCache.low)];
			return new Integer(i);
		}

	//添加元素
	 public boolean add(E e) {
		 //此时size为10
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

	private void ensureCapacityInternal(int minCapacity) {
		//minCapacity = 11

		//elementData = [a, 2, 3, 4, 5, 6, 7, 8, 9, 10]
		//DEFAULTCAPACITY_EMPTY_ELEMENTDATA = []
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
		
        ensureExplicitCapacity(minCapacity);
    }
	
	private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

		//minCapacity：11
		//elementData.length = 10
		//此时成立,执行数组的扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
	
	//数组扩容
	 private void grow(int minCapacity) {
       //minCapacity = 11
	   //elementData.length = 10
        int oldCapacity = elementData.length;
		//oldCapacity >> 1: 右移1位,所以为5
		//newCapacity = 15
        int newCapacity = oldCapacity + (oldCapacity >> 1);
		//newCapacity = 15   minCapacity = 11,不成立
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
		//不成立
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        //此时新的数组的长度为15,数组长度变大
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

	//新数组的长度为15



	//综上分析:当初始化ArrayList时,底层数组的长度为0《当向里面添加第一个元素时,数组的长度变为10,当
	//数组长度大于10时,数组会进行扩容.经分析,每次扩容新的长度为原来的1.5倍  所以第二次扩容为15,第三次为22
	//到此,ArrayList的add(Object) 源码分析完

2.get(index) 

//构造器ArrayList()
   public ArrayList() {
		//1.elementData是一个Object[]的数组.
		//2.private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};是一个空的数组
       this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;													
    }

		ArrayList list1 = new ArrayList();
		list1.add("a");
		list1.add(2);
		list1.add(3);
		list1.add(4);
		list1.add(5);	
		list1.add(6);	
		list1.add(7);	
		list1.add(8);	
		list1.add(9);	
		list1.add(10);
		list1.add(11);
		
		Object value = list1.get(2);
		System.out.println(value);

//1.get(index)

	public E get(int index) {
		//检查下标是否越界,否则会抛出数组下标越界异常
        rangeCheck(index);

		//返回下标为index的元素
        return elementData(index);
    }

	 private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
	
	//返回下标为index的元素
	E elementData(int index) {
        return (E) elementData[index];
    }


3..remove(index),返回值为Object类型


//构造器ArrayList()
   public ArrayList() {
		//1.elementData是一个Object[]的数组.
		//2.private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};是一个空的数组
       this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;													
    }


//1.remove(index),返回值为Object类型


		public E remove(int index) {
				//index:传入要删除元素的位置,假设下标为2,即index=2

				//检查index是否越界
				rangeCheck(index);

				modCount++;//计数器

				//得到下标为index的元素,值为oldValue
				E oldValue = elementData(index);

				//此时数组的长度为11,size=11,index=2,所以numMoved=8
				int numMoved = size - index - 1;

				 //arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 
				 //从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
				 //第一个elementData:原数组
				 //第二个elementData：目标数组
				 //源数组中位置在 srcPos 到 srcPos+length-1 之间的组件被分别复制到目标数组中的 destPos 到 destPos+length-1 位置。 
				 //public static void arraycopy(Object src,int srcPos,Object dest,int destPos, int length)
				if (numMoved > 0)
					System.arraycopy(elementData, index+1, elementData, index,
									 numMoved);
				//此时最后的一个元素设为nul，这是数组的长度就减1了
				elementData[--size] = null; // clear to let GC do its work

				//返回删除的元素
				return oldValue;
			}

			
			 private void rangeCheck(int index) {
				 //当index大于数组的长度时,会抛出数组下标越界异常.
				if (index >= size)
				throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
			 }

4.remove(Object obj),当遇到要删除的对象为int类型时,要把该int类型的值进行装箱,变为Integer类型 

//构造器ArrayList()
   public ArrayList() {
		//1.elementData是一个Object[]的数组.
		//2.private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};是一个空的数组
       this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;													
    }

		ArrayList list1 = new ArrayList();
		list1.add("a");
		list1.add(2);
		list1.add(3);
		list1.add(4);
		list1.add(5);	
		list1.add(6);	
		list1.add(7);	
		list1.add(8);	
		list1.add(9);	
		list1.add(10);
		list1.add(11);
		
		Object value =  list1.remove(new Integer(2));
		System.out.println(value);



//1.remove(Object obj),当遇到要删除的对象为int类型时,
//要把该int类型的值进行装箱,变为Integer类型

  public boolean remove(Object o) {
		
		//当传入的对象为null值是.
        if (o == null) {
			//遍历数组elementData
            for (int index = 0; index < size; index++)
				//如果遍历到值为null的时
                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) {
        modCount++;

		//要移动的长度
        int numMoved = size - index - 1;
		  //arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 
		 //从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
		 //第一个elementData:原数组
		 //第二个elementData：目标数组
		 //源数组中位置在 srcPos 到 srcPos+length-1 之间的组件被分别复制到目标数组中的 destPos 到 destPos+length-1 位置。 
		 //public static void arraycopy(Object src,int srcPos,Object dest,int destPos, int length)
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
		//最后一个位置上的元素设置为null
        elementData[--size] = null; // clear to let GC do its work
    }



New灬soul
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ArrayList.add()源码浅析
DramaLifes的博客
05-17 808
文章目录addensureCapacityInternalcalculateCapacityensureExplicitCapacitygrowhugeCapacitycopyOfcopyOfgetComponentTypeJVM_GetComponentTyperesolve_non_nullarray_component_typeas_Klassmetadata_fieldcastbasic_type_arrayklass_to_mirrornewInstancenewArrayJava_java_la
java arraylist .get_Java ArrayList get(index)用法及代码示例
weixin_42322686的博客
02-23 858
Java中ArrayList的get()方法用于获取列表中指定索引的元素。用法:get(index)参数：index：要返回的元素的索引。它是int类型。返回值：它返回给定列表中指定索引处的元素。错误和异常：IndexOutOfBoundsException-如果索引超出范围(index = size())示例1:演示get()工作原理的程序// Java code to demonstrate ...
ArrayList的add方法get新技能
wenyunick的博客
11-20 191
package com.ethjava; import java.util.ArrayList; import java.util.Scanner; public class bianpaifanli { public static void main(String[] args) { ArrayList<String> list = new ArrayLi...
java arraylist 添加对象,如何在Java中将对象添加到ArrayList
weixin_42333370的博客
02-13 1097
I want to add an object to an ArrayList, but each time I add a new object to an ArrayList with 3 attributes: objt(name, address, contact), I get an error.import java.util.ArrayList;import java.util.Sc...
关于ArrayList的add方法
幻想的天空
08-19 2805
当泛型为引用类型时，add(Object obj)方法，是将对象obj的引用（即obj的内存地址）加入到了arraylist中进行存储； 同理，get(index)方法返回的是对象的引用，对对象的属性进行修改，会同步修改ArrayList中对象的属性值，以及对象obj中的值。 ...
从源码角度分析ArrayList和LinkedList的区别
JasonGaoH的专栏
05-31 444
List代表一种线性表的数据结构，ArrayList则是一种顺序存储的线性表。ArrayList底层采用数组来保存每个集合的元素，LinkedList则是一种链式存储的线性表。其本质上就是一个双向链表，但它不仅实现了List接口，还是想了Deque接口。也就是说LinkedList既可以当成双向链表使用，也可以当成队列使用，还可以当成栈来适用于（Deque代表双端队列，即具有队列的特征，也具有栈的...
java 集合之实现类ArrayList和LinkedList的方法
08-29
"java 集合之实现类ArrayList和LinkedList的方法" Java 集合框架中，ArrayList 和 LinkedList 是两种常用的实现类，分别实现了 List 接口。下面我们将详细介绍这两种实现类的方法。 ArrayList ArrayList 是一个...
ArrayList源码分析
03-30
### ArrayList源码分析 #### 一、概述 `ArrayList` 是 Java 集合框架中的一个重要的类，它实现了 `List` 接口，并且内部使用动态数组来存储元素。由于其灵活的特性（比如可以方便地增加或删除元素），`ArrayList` ...
Java 中模仿源码自定义ArrayList
08-31
添加元素的方法`add(Object obj)`是ArrayList的核心功能之一。当数组已满时，我们需要进行扩容操作。这里采用的扩容策略是创建一个新的数组，大小为原数组的1.5倍（size*2+1），然后使用`System.arraycopy()`方法将...
ArrayList中的remove方法(对集合底层的分析)
My_liuying0901
04-26 1580
remove源码 ArrayList集合底层存储结构是数组，所以ArrayList中的remove删除方法，其实就是数组的删除 源码： public boolean remove(Object o) { if (o == null) { for (int index = 0; index < size; index++) ...
ArrayList中add(Object obj)方法的注意事项
笨小孩的博客
03-18 2515
当方法al.add()中传入对象时，涉及到 Object obj=new Person("list01",30); 的向上转型故下面的it.next().getName()的getName（）方法Object类无法找到此时应该进行向下转型 即 Person p=(Person) it.next();
教你手写一个ArrayList集合
YunWQ的博客
03-06 598
ArrayList集合源码解析 ArrayList底层是数组结构，每次添加元素的时候就会创建一个新的数组，把原来数组中的元素复制到新的数组中。每次删除元素的时候，就会把数组后面的元素往前挪动,并且把最后一个元素置为null,等待垃圾回收器回收。 按照ArrayList集合的原理，我们自己也可以写一个简化版的ArrayList集合，我取名为MyArrayList 添加元素的原理 删除元素的原理 ...
自定义ArrayList
ZhangYaohui专栏
10-20 3496
实现ArrayList类中的以下功能： size()：列表的大小 isEmpty()：判断列表是否为空 clear()：清空整个列表 get(int index)：获取下标为index的值 set(int index,Object value)：修改下标为index的值 add(Object value)：向列表中（也就是在列表的最后）添加数据 remove(int index)：删除下标为inde
List.add（index,Object）
weixin_30883777的博客
02-07 681
1 ArrayList<String> list = new ArrayList<>(); 2 list.add("1"); 3 list.add("2"); 4 list.add("3"); 5 list.add("4"); 6 list.add(0,"5"); ...
java Arrarlist中的add(int index,Object ojb)
evilcry2012的专栏
09-28 6863
java Arrarlist中的add(int index,Object ojb) 怎么自己用代码实现这个功能啊？ 求讲解 askdjklas3 | 浏览 11337 次  2012-02-29 19:52 2012-02-29 20:49 最佳答案 import java.util.ArrayList; public class F {
一个非常有用的关于集合的例子，实现集合的add,remove和this[index]方法
weixin_30699235的博客
05-24 80
Animals.cs using System; using System.Collections; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace DictionaryAnimals { ...
ArrayList中set（index，object）与add（index，object）方法的区别
vbbbbbbbbbbb的博客
06-30 411
set：将原来index位置上的object的替换掉 add：将原来index位置上的 向后移动 List list=new ArrayList(); list.add(index,obj); 把第index+1个以及第index+1个以后的元素都往后移一位，类似elementData[i+1]=elementData[i]; 然后再把obj放到index的位置。 当然，这个过程需要考虑index的合理性以及是否会溢出等问题。 ...
List集合常用方法java与c#
不积跬步，无以至千里；不积小流，无以成江海；千里之行，始于足下
03-13 858
List 是工作中最常用的集合类型之一，在工作中经常把两种集合的方法搞混，这里列举一下java与c#一些常用的方法。
ArrayList源码解读之remove(Object o)和remve(int index)
u014344668的专栏
03-27 477
ArrayList源码解读之remove(Object o)和remve(int index) 样例 /** * 2.测试remove和fastRemove区别 * E remove(int index) */ public static void test2(){ ArrayList list1 = new ArrayList(); ...
使用ArrayList实现栈这种数据结构(弹栈和压栈)
最新发布
05-12
可以使用Java中的ArrayList来实现栈，ArrayList是一个可以动态增长和收缩的数组，可以方便地实现栈的弹栈和压栈操作。 具体实现如下： ```java import java.util.ArrayList; public class MyStack { private ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值