开发者社区> 丁国华> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

【Java集合系列】---ArrayList

简介: 开篇前言--ArrayList中的基本方法 前面的博文中,小编主要简单介绍java集合的总体架构,在接下来的博文中,小编将详细介绍里面的各个类,通过demo、对比,来对java集合类进行更加深入的理解和认识,希望可以帮助有有需要的小伙伴们`(*∩_∩*)′,不足之处,还请小伙伴们多多指教哦`(*∩_∩*)′。
+关注继续查看

开篇前言--ArrayList中的基本方法

前面的博文中,小编主要简单介绍java集合的总体架构,在接下来的博文中,小编将详细介绍里面的各个类,通过demo、对比,来对java集合类进行更加深入的理解和认识,希望可以帮助有有需要的小伙伴们`(*∩_∩*)′,不足之处,还请小伙伴们多多指教哦`(*∩_∩*)′。今天这篇博文,小编主要介绍List接口中的ArrayList集合,ArrayList即数组列表,so,她肯定和数组有一定的关系,我们知道List集合的特征有两个,一个是有序;第二个List里面的集合可以重复,既然ArrayList实现了List接口,那么毫无疑问,她肯定也存在这两个特征,我们来看一个简单的demo。新建一个class,命名为ArrayListTest,编写相关代码,如下所示:

package j2se.demo;

import java.util.ArrayList;

public class ArrayListTest {
	public static void main(String[] args) {
		ArrayList arrayList = new ArrayList();
		arrayList.add("hello");
		arrayList.add("world");
		arrayList.add("java");
		
		
		String s1=(String) arrayList.get(0);
		String s2=(String)arrayList.get(1);
		String s3=(String)arrayList.get(2);
	
		
		System.out.println(s1);
		System.out.println(s2);
		System.out.println(s3);
	
	}

}
运行效果如下所示:

以上是ArrayList的基本用法,接着,我们来修改代码,ArrayList可以添加重复的元素,我们来看下面的代码部分:

package j2se.demo;

import java.util.ArrayList;

public class ArrayListTest {
	public static void main(String[] args) {
		ArrayList arrayList = new ArrayList();
		arrayList.add("hello");
		arrayList.add("world");
		arrayList.add("java");
		arrayList.add("java");
		
		String s1=(String) arrayList.get(0);
		String s2=(String)arrayList.get(1);
		String s3=(String)arrayList.get(2);
		String s4=(String)arrayList.get(3);
	
		
		System.out.println(s1);
		System.out.println(s2);
		System.out.println(s3);
		System.out.println(s4);
	
	}

}
运行效果如下所示:

通过运行结果我们知道,说明第二个“java”已经添加进去了,我们发现,ArrayList是通过add进行添加的操作,通过get方法取出来;我们接着来看,size这个方法,返回列表中元素的个数;可是呢,取数据的时候一个一个取,非常的麻烦,所以,我们可以写一个循环,如下所示:

package j2se.demo;

import java.util.ArrayList;

public class ArrayListTest {
	public static void main(String[] args) {
		ArrayList arrayList = new ArrayList();
		arrayList.add("hello");
		arrayList.add("world");
		arrayList.add("java");
		arrayList.add("java");
		
		String s1=(String) arrayList.get(0);
		String s2=(String)arrayList.get(1);
		String s3=(String)arrayList.get(2);
		String s4=(String)arrayList.get(3);
	
		
		System.out.println(s1);
		System.out.println(s2);
		System.out.println(s3);
		System.out.println(s4);
		
		System.out.println("----------");
		
		for(int i = 0 ;i<arrayList.size();i++){
			System.out.println(arrayList.get(i));
		}
	
	}

}
运行效果如下所示:

size方法,用于获取集合中元素的个数,接着我们来看Clear()方法,编写相关代码,如下所示:

package j2se.demo;

import java.util.ArrayList;

public class ArrayListTest {
	public static void main(String[] args) {
		ArrayList arrayList = new ArrayList();
		arrayList.add("hello");
		arrayList.add("world");
		arrayList.add("java");
		arrayList.add("java");
		
		String s1=(String) arrayList.get(0);
		String s2=(String)arrayList.get(1);
		String s3=(String)arrayList.get(2);
		String s4=(String)arrayList.get(3);
	
		
		System.out.println(s1);
		System.out.println(s2);
		System.out.println(s3);
		System.out.println(s4);
		
		System.out.println("----------");
		
		for(int i = 0 ;i<arrayList.size();i++){
			System.out.println(arrayList.get(i));
		}
		
		arrayList.clear();
		System.out.println(arrayList.size());
	
	}

}
运行效果如下所示:

接着,我们来看一下isEmpty这个方法,这个方法是用来判断集合中是否有内容的一个方法,编写相关代码,如下所示:

package j2se.demo;

import java.util.ArrayList;

public class ArrayListTest {
	public static void main(String[] args) {
		ArrayList arrayList = new ArrayList();
		arrayList.add("hello");
		arrayList.add("world");
		arrayList.add("java");
		arrayList.add("java");
		
		String s1=(String) arrayList.get(0);
		String s2=(String)arrayList.get(1);
		String s3=(String)arrayList.get(2);
		String s4=(String)arrayList.get(3);
	
		
		System.out.println(s1);
		System.out.println(s2);
		System.out.println(s3);
		System.out.println(s4);
		
		System.out.println("----------");
		
		for(int i = 0 ;i<arrayList.size();i++){
			System.out.println(arrayList.get(i));
		}
		
		arrayList.clear();
		System.out.println(arrayList.isEmpty());
	
	}

}
运行效果如下所示:

接着看,如何删除一个元素呢,remove,删除一个根据元素,我们可以根据索引删除,还可以根据具体的对象进行删除,编写相关代码,如下所示:

package j2se.demo;

import java.util.ArrayList;

public class ArrayListTest {
	public static void main(String[] args) {
		ArrayList arrayList = new ArrayList();
		arrayList.add("hello");
		arrayList.add("world");
		arrayList.add("java");
		arrayList.add("java");
		
		String s1=(String) arrayList.get(0);
		String s2=(String)arrayList.get(1);
		String s3=(String)arrayList.get(2);
		String s4=(String)arrayList.get(3);
	
		
		System.out.println(s1);
		System.out.println(s2);
		System.out.println(s3);
		System.out.println(s4);
		
		System.out.println("----------");
		
		for(int i = 0 ;i<arrayList.size();i++){
			System.out.println(arrayList.get(i));
		}
		
//		arrayList.clear();
//		System.out.println(arrayList.isEmpty());
		
		arrayList.remove(0);
		System.out.println("----------");
		for(int i = 0 ;i<arrayList.size();i++){
			System.out.println(arrayList.get(i));
		}
	
	}

}
运行,如下所示:

除此之外,我们还可以根据索引进行删除,编写相关代码,如下所示:

package j2se.demo;

import java.util.ArrayList;

public class ArrayListTest {
	public static void main(String[] args) {
		ArrayList arrayList = new ArrayList();
		arrayList.add("hello");
		arrayList.add("world");
		arrayList.add("java");
		arrayList.add("java");
		
		String s1=(String) arrayList.get(0);
		String s2=(String)arrayList.get(1);
		String s3=(String)arrayList.get(2);
		String s4=(String)arrayList.get(3);
	
		
		System.out.println(s1);
		System.out.println(s2);
		System.out.println(s3);
		System.out.println(s4);
		
		System.out.println("----------");
		
		for(int i = 0 ;i<arrayList.size();i++){
			System.out.println(arrayList.get(i));
		}
		
//		arrayList.clear();
//		System.out.println(arrayList.isEmpty());
		
		arrayList.remove(0);
		arrayList.remove("java");
		System.out.println("----------");
		for(int i = 0 ;i<arrayList.size();i++){
			System.out.println(arrayList.get(i));
		}
	
	}

}
效果如下所示:


接着,我们添加两个元素,打印,indexOf某个对象的索引在哪个位置上,代码如下所示:

package j2se.demo;

import java.util.ArrayList;

public class ArrayListTest {
	public static void main(String[] args) {
		ArrayList arrayList = new ArrayList();
		arrayList.add("hello");
		arrayList.add("world");
		arrayList.add("java");
		arrayList.add("java");
		
		String s1=(String) arrayList.get(0);
		String s2=(String)arrayList.get(1);
		String s3=(String)arrayList.get(2);
		String s4=(String)arrayList.get(3);
	
		
		System.out.println(s1);
		System.out.println(s2);
		System.out.println(s3);
		System.out.println(s4);
		
		System.out.println("----------");
		
		for(int i = 0 ;i<arrayList.size();i++){
			System.out.println(arrayList.get(i));
		}
		
//		arrayList.clear();
//		System.out.println(arrayList.isEmpty());
		
		arrayList.remove(0);
		arrayList.remove("java");
		System.out.println("----------");
		for(int i = 0 ;i<arrayList.size();i++){
			System.out.println(arrayList.get(i));
		}
		
		System.out.println("----------");
		arrayList.add("aaa");
		arrayList.add("bbb");
		System.out.println(arrayList.indexOf("aaa"));
	
	}

}
运行,效果如下所示:


接着,我们新建一个类ArrayListTest1,编写相关代码:

package j2se.demo;

import java.util.ArrayList;

public class ArrayListTest1 {
	
	public static void main(String[] args) {
		ArrayList list = new ArrayList();
		
		list.add("hello");
		list.add(new Integer(2));
		
		String str=(String)list.get(0);
		Integer in = (Integer)list.get(1);
		
		System.out.println(str);
		System.out.println(in);
		
	}

}
运行效果如下所示:

ArrayList本身接收的是对象,取出来的时候我们需要把他转换成我们放进去的相应的类型。再来新建一个类ArrayListTest2,如何把集合转成数组呢?编写代码,如下所示:

package j2se.demo;

import java.util.ArrayList;

public class ArrayListTest2 {
	public static void main(String[] args) {
		
		ArrayList list = new ArrayList();
		list.add(new Integer(1));
		list.add(new Integer(2));
		list.add(new Integer(3));
		list.add(new Integer(4));
		list.add(new Integer(5));		
		list.add(new Integer(6));
		
		/**
		 * 不能将Object[]转换成Integer[]
		 */
		Object[] in = list.toArray();
		for(int i = 0 ;i<in.length;i++){
			System.out.println(((Integer)in[i]).intValue());
		}
	}

}
运行如下所示:

ArrayList底层部分源码实现

前面介绍的都是ArrayList的基本方法,小伙伴们可以查询API文档,接着,我们来看ArrayList她自己本身是如何实现的,首先:

a、对于任何一个集合来说,集合中存放的是对象的引用,而不是对象本身。
b、ArrayList底层采用数组实现,当使用不带参数的构成方法生成ArrayList对象的时候,实际上会在底层生成一个长度为10的Object类型数组。简单来说ArrayList内部实现是数组。
c、如果增加的元素个数超过了10个,那么ArrayList底层会新生成一个数组,长度为原来数组的1.5倍,然后将原数组的内容复制到新数组中,并且后续增加的内容都会放到新数组当中,当新数组无法容纳增加的元素时,重复该过程。集合中不能放入原生数据类型,只能放置对象的引用,我们需要使用原生数据类型的包装类才能加入到集合当中。我们来看看ArrayList底层的部分源码:

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private static final long serialVersionUID = 8683452581122892189L;

    //设置arrayList默认容量
    private static final int DEFAULT_CAPACITY = 10;

    //空数组,当调用无参数构造函数的时候默认给个空数组
    private static final Object[] EMPTY_ELEMENTDATA = {};

    //这才是真正保存数据的数组
    private transient Object[] elementData;

    //arrayList的实际元素数量
    private int size;

    //构造方法传入默认的capacity 设置默认数组大小
    public ArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
    }

    //无参数构造方法默认为空数组
    public ArrayList() {
        super();
        this.elementData = EMPTY_ELEMENTDATA;
    }

    //构造方法传入一个Collection, 则将Collection里面的值copy到arrayList
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        size = elementData.length;
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    }
    
    //下面主要看看ArrayList 是如何将数组进行动态扩充实现add 和 remove
    

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

    
    public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }
    
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }
    
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        //超出了数组可容纳的长度,需要进行动态扩展
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    
    //这才是动态扩展的精髓,看到这个方法,ArrayList瞬间被打回原形
    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        //设置新数组的容量扩展为原来数组的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //再判断一下新数组的容量够不够,够了就直接使用这个长度创建新数组, 
        //不够就将数组长度设置为需要的长度
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //判断有没超过最大限制
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        //将原来数组的值copy新数组中去, ArrayList的引用指向新数组
        //这儿会新创建数组,如果数据量很大,重复的创建的数组,那么还是会影响效率,
        //因此鼓励在合适的时候通过构造方法指定默认的capaticy大小
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
    

}

so,小伙伴们发现了没有,ArrayList 她骨子里面的本质就是数组, ArrayList就是对数组进行动态的扩展,其add, get , remove 等等操作就是对数组的操作。 ArrayList的一些特性都来源于数组:有序、元素可重复、插入慢、 索引快 等等一系列神马所谓的属性, 有没有一种被欺骗了的赶脚`(*∩_∩*)′。

ArrayList中的遍历

我们来看一下ArrayList中的遍历,ArrayList支持三种遍历方式。

第一种:通过迭代器遍历,即通过Iterator去遍历
Integer value = null;
Iterator iter = list.iterator();
while (iter.hasNext()) {
    value = (Integer)iter.next();
}
第二种:随机访问,通过索引值去遍历,因为ArrayList实现了RandomAccess接口,so,她支持通过索引值去随机访问元素:
Integer value = null;
int size = list.size();
for (int i=0; i<size; i++) {
    value = (Integer)list.get(i);        
}

第三种:for循环遍历,如下所示:

Integer value = null;
for (Integer integ:list) {
    value = integ;
}
接着,我们通过一个demo比较一下这三种遍历方式:

package j2se.demo;
import java.util.*;
import java.util.concurrent.*;

/*
 * @desc ArrayList遍历方式和效率的测试程序。
 *
 * @author 丁国华
 */
public class ArrayListRandomAccessTest {

    public static void main(String[] args) {
        List list = new ArrayList();
        for (int i=0; i<100000; i++)
            list.add(i);
        iteratorThroughRandomAccess(list) ;
        iteratorThroughIterator(list) ;
        iteratorThroughFor2(list) ;
    
    }

    private static void isRandomAccessSupported(List list) {
        if (list instanceof RandomAccess) {
            System.out.println("RandomAccess implemented!");
        } else {
            System.out.println("RandomAccess not implemented!");
        }

    }

    public static void iteratorThroughRandomAccess(List list) {

        long startTime;
        long endTime;
        startTime = System.currentTimeMillis();
        for (int i=0; i<list.size(); i++) {
            list.get(i);
        }
        endTime = System.currentTimeMillis();
        long interval = endTime - startTime;
        System.out.println("iteratorThroughRandomAccess:" + interval+" ms");
    }

    public static void iteratorThroughIterator(List list) {

        long startTime;
        long endTime;
        startTime = System.currentTimeMillis();
        for(Iterator iter = list.iterator(); iter.hasNext(); ) {
            iter.next();
        }
        endTime = System.currentTimeMillis();
        long interval = endTime - startTime;
        System.out.println("iteratorThroughIterator:" + interval+" ms");
    }


    public static void iteratorThroughFor2(List list) {

        long startTime;
        long endTime;
        startTime = System.currentTimeMillis();
        for(Object obj:list);
        endTime = System.currentTimeMillis();
        long interval = endTime - startTime;
        System.out.println("iteratorThroughFor2:" + interval+" ms");
    }
}

运行效果,如下所示:


由此可见,遍历ArrayList时,使用随机访问(即,通过索引序号访问)效率最高,而使用迭代器的效率最低!

ArrayList的优缺点

接着,我们来看一下ArrayList的优缺点:

从上面的几个过程总结一下ArrayList的优缺点。ArrayList的优点如下:
a、ArrayList底层以数组实现,是一种随机访问模式,再加上它实现了RandomAccess接口,因此查找速度快;
b、ArrayList在顺序添加一个元素的时候非常方便,只是往数组里面添加了一个元素而已;
ArrayList的缺点:
a、删除元素的时候,涉及到一次元素复制,如果要复制的元素很多,那么就会比较耗费性能
b、插入元素的时候,涉及到一次元素复制,如果要复制的元素很多,那么就会比较耗费性能
因此,ArrayList比较适合顺序添加、随机访问的场景。在后面的博文中,小编将介绍LinkedList,等介绍完LinkedList之后,我们把她们两个放在一起进行对比。

     ArrayList线程问题

再说ArrayList线程问题之前,我们需要了解一下,什么是线程安全?什么是线程不安全?线程安全就是多线程访问的时候,采用了加锁机制,当一个线程访问该类的某个数据的时候,进行保护,其他线程不能进行访问直到该线程读取完,其他线程才可以使用,不会出现数据不一致或者数据污染。

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
用java实现云计算的两种趋势性方法
本文讲的是用java实现云计算的两种趋势性方法,最近,人们在思考如何使用Java来实现云计算,我看到了两种趋势性的方法。它们存在交叉重叠处而并非互相排斥,但总体而言它们在项目方面有着非常不同的表现
766 0
java集合之ConcurrentSkipListSet源码分析——Set大汇总
java集合之ConcurrentSkipListSet源码分析——Set大汇总问题(1)ConcurrentSkipListSet的底层是ConcurrentSkipListMap吗? (2)ConcurrentSkipListSet是线程安全的吗? (3)ConcurrentSkipListSet是有序的吗? (4)ConcurrentSkipListSet和之前讲的Set有何不同? 简介ConcurrentSkipListSet底层是通过ConcurrentNavigableMap来实现的,它是一个有序的线程安全的集合。
679 0
死磕 java集合之PriorityQueue源码分析
死磕 java集合之PriorityQueue源码分析问题(1)什么是优先级队列? (2)怎么实现一个优先级队列? (3)PriorityQueue是线程安全的吗? (4)PriorityQueue就有序的吗? 简介优先级队列,是0个或多个元素的集合,集合中的每个元素都有一个权重值,每次出队都弹出优先级最大或最小的元素。
711 0
死磕 java集合之ArrayDeque源码分析
死磕 java集合之ArrayDeque源码分析问题(1)什么是双端队列? (2)ArrayDeque是怎么实现双端队列的? (3)ArrayDeque是线程安全的吗? (4)ArrayDeque是有界的吗? 简介双端队列是一种特殊的队列,它的两端都可以进出元素,故而得名双端队列。
712 0
Java入门系列之集合HashMap源码分析
HashMap在Java中是使用比较频繁的键值对数据类型,所以我们非常有必要详细去分析背后的具体实现原理
0 0
Java集合源码分析之Set概述与总结
Java集合源码分析系列到此就结束了,关于Set的知识会在这里进行简单的总结,除此之外,则是学习之后的一些感受。 Set概述 Set是一个包含不可重元素的集合,也就是所有的元素都是唯一的。文档说明如下: A collection that contains no duplicate elements. More formally, sets contain no pair of elements e1 and e2 such that e1.equals(e2), and at most one null element. As implied by its name, this inte
0 0
Java集合源码分析之Iterable概述
前言 当我们想要遍历集合时,Java为我们提供了多种选择,通常有以下三种写法: 写法1:for循环 for (int i = , len = strings.size(); i < len; i++) { System.out.println(strings.get(i)); } 写法2:foreach循环 for (String var : strings) { System.out.println(var); } 写法3:Iterator Iterator iterator = strings.iterator(); while (iterator.hasNext(
0 0
Java集合源码分析之开篇
初衷 Java集合是我们使用最频繁的工具,也是面试的热点,但我们对它的理解仅限于使用上,而且大多数情况没有考虑过其使用规范。本系列文章将跟随源码的思路,分析实现的每个细节,以期在使用时避免各种不规范的坑。在这里,我们会惊艳于开发者优秀的设计,也会感激先辈们付出的艰辛努力,更重要的是知其所以然,少犯错误,写出优秀的代码。 许多人对集合类的理解是暴力的,当需要保存对象时就使用ArrayList,当需要保存键值对时就使用HashMap,当需要不可重复时就使用HashSet,等等。而且使用方式也比较单一:
0 0
+关注
丁国华
你只管努力,剩下的交给时光!
文章
问答
文章排行榜
最热
最新
相关电子书
更多
Java基础入门(四)-泛型、反射、注解
立即下载
Java开发手册1.4.0
立即下载
Java开发手册1.3.0
立即下载