精华内容
下载资源
问答
  • JAVA中ArrayList用法

    2014-10-10 20:39:00
    JAVA中ArrayList用法 2011-07-20 15:02:03|分类:计算机专业|标签:javaarraylist用法|举报|字号订阅 Java学习过程中做题时,用到ArrayList,在网上寻找到的学习资料。 摘自: ...

    JAVA中ArrayList用法  

    2011-07-20 15:02:03|  分类: 计算机专业 |  标签:java  arraylist用法  |举报|字号 订阅

     
     
    Java学习过程中做题时,用到ArrayList,在网上寻找到的学习资料。
      摘自:   

    System.Collections.ArrayList类是一个特殊的数组。通过添加和删除元素,就可以动态改变数组的长度。

    一.优点

    1. 支持自动改变大小的功能
    2. 可以灵活的插入元素
    3. 可以灵活的删除元素

    二.局限性

    跟一般的数组比起来,速度上差些

    三.添加元素

    1.publicvirtualintAdd(objectvalue);

    将对象添加到ArrayList的结尾处

    ArrayList aList = new ArrayList();
    aList.Add("a");
    aList.Add("b");
    aList.Add("c");
    aList.Add("d");
    aList.Add("e");
    内容为abcde

    2.publicvirtualvoidInsert(intindex,objectvalue);

    将元素插入ArrayList的指定索引处

    ArrayList aList = new ArrayList();
    aList.Add("a");
    aList.Add("b");
    aList.Add("c");
    aList.Add("d");
    aList.Add("e");
    aList.Insert(0,"aa");

    结果为aaabcde

    3.publicvirtualvoidInsertRange(intindex,ICollectionc);

    将集合中的某个元素插入ArrayList的指定索引处

    ArrayList aList = new ArrayList();
    aList.Add("a");
    aList.Add("b");
    aList.Add("c");
    aList.Add("d");
    aList.Add("e");
    ArrayList list2 = newArrayList();
    list2.Add("tt");
    list2.Add("ttt");
    aList.InsertRange(2,list2);

    结果为abtttttcde

    四.删除

    1. publicvirtualvoidRemove(objectobj);

    从ArrayList中移除特定对象的第一个匹配项,注意是第一个

    ArrayList aList = new ArrayList();
    aList.Add("a");
    aList.Add("b");
    aList.Add("c");
    aList.Add("d");
    aList.Add("e");
    aList.Remove("a");

    结果为bcde

    2. publicvirtualvoidRemoveAt(intindex);

    移除ArrayList的指定索引处的元素

    aList.Add("a");
    aList.Add("b");
    aList.Add("c");
    aList.Add("d");
    aList.Add("e");
    aList.RemoveAt(0);

    结果为bcde

    3.publicvirtualvoidRemoveRange(intindex,intcount);

    从ArrayList中移除一定范围的元素。Index表示索引,count表示从索引处开始的数目

    aList.Add("a");
    aList.Add("b");
    aList.Add("c");
    aList.Add("d");
    aList.Add("e");
    aList.RemoveRange(1,3);

    结果为ae

    4.publicvirtualvoidClear();

    从ArrayList中移除所有元素。

    五.排序

    a) publicvirtualvoidSort();

    对ArrayList或它的一部分中的元素进行排序。

    ArrayListaList=newArrayList();
    aList.Add("e");
    aList.Add("a");
    aList.Add("b");
    aList.Add("c");
    aList.Add("d");
    DropDownList1.DataSource=aList;//DropDownListDropDownList1;
    DropDownList1.DataBind();

    结果为eabcd

    ArrayListaList=newArrayList();
    aList.Add("a");
    aList.Add("b");
    aList.Add("c");
    aList.Add("d");
    aList.Add("e");
    aList.Sort();//排序
    DropDownList1.DataSource=aList;//DropDownListDropDownList1;
    DropDownList1.DataBind();

    结果为abcde

    b) publicvirtualvoidReverse();

    将ArrayList或它的一部分中元素的顺序反转。

    ArrayListaList=newArrayList();
    aList.Add("a");
    aList.Add("b");
    aList.Add("c");
    aList.Add("d");
    aList.Add("e");
    aList.Reverse();//反转
    DropDownList1.DataSource=aList;//DropDownListDropDownList1;
    DropDownList1.DataBind();
    结果为edcba

    六.查找

    a) publicvirtualintIndexOf(object);
    b) publicvirtualintIndexOf(object,int);
    c) publicvirtualintIndexOf(object,int,int);

        返回ArrayList或它的一部分中某个值的第一个匹配项的从零开始的索引。没找到返回-1。

        ArrayList aList = new ArrayList();
        aList.Add("a");
        aList.Add("b");
        aList.Add("c");
        aList.Add("d");
        aList.Add("e");
        intnIndex=aList.IndexOf(“a”);//1
        nIndex=aList.IndexOf(“p”);//没找到,-1
    d) publicvirtualintLastIndexOf(object);
    e) publicvirtualintLastIndexOf(object,int);
    f) publicvirtualintLastIndexOf(object,int,int);

        返回ArrayList或它的一部分中某个值的最后一个匹配项的从零开始的索引。

        ArrayList aList = new ArrayList();
        aList.Add("a");
        aList.Add("b");
        aList.Add("a");//同0
        aList.Add("d");
        aList.Add("e");
        intnIndex=aList.LastIndexOf("a");//值为2而不是0

    g) publicvirtualboolContains(objectitem);

        确定某个元素是否在ArrayList中。包含返回true,否则返回false

    七.其他

    1.publicvirtualintCapacity{get;set;}

    获取或设置ArrayList可包含的元素数。

    2.publicvirtualintCount{get;}

    获取ArrayList中实际包含的元素数。
    Capacity是ArrayList可以存储的元素数。Count是ArrayList中实际包含的元素数。Capacity总是大于或等于Count。如果在添加元素时,Count超过Capacity,则该列表的容量会通过自动重新分配内部数组加倍。
    如果Capacity的值显式设置,则内部数组也需要重新分配以容纳指定的容量。如果Capacity被显式设置为0,则公共语言运行库将其设置为默认容量。默认容量为16。
    在调用Clear后,Count为0,而此时Capacity切是默认容量16,而不是0

    3.publicvirtualvoidTrimToSize();

    将容量设置为ArrayList中元素的实际数量。
    如果不向列表中添加新元素,则此方法可用于最小化列表的内存系统开销。
    若要完全清除列表中的所有元素,请在调用TrimToSize之前调用Clear方法。截去空ArrayList会将ArrayList的容量设置为默认容量,而不是零。

    ArrayList aList = new ArrayList();
    aList.Add("a");
    aList.Add("b");
    aList.Add("c");
    aList.Add("d");
    aList.Add("e");//Count=5,Capacity=16,
    aList.TrimToSize();//Count=Capacity=5;

    转载于:https://www.cnblogs.com/NKlaus/p/4017753.html

    展开全文
  • 七.其他1.publicvirtualintCapacity{...}获取ArrayList中实际包含的元素数。Capacity是ArrayList可以存储的元素数。Count是ArrayList中实际包含的元素数。Capacity总是大于或等于Count。如果在添加元素时,Count超...

    七.其他

    1.publicvirtualintCapacity{get;set;}

    获取或设置ArrayList可包含的元素数。

    2.publicvirtualintCount{get;}

    获取ArrayList中实际包含的元素数。

    Capacity是ArrayList可以存储的元素数。Count是ArrayList中实际包含的元素数。Capacity总是大于或等于Count。如果在添加元素时,Count超过Capacity,则该列表的容量会通过自动重新分配内部数组加倍。

    如果Capacity的值显式设置,则内部数组也需要重新分配以容纳指定的容量。如果Capacity被显式设置为0,则公共语言运行库将其设置为默认容量。默认容量为16。

    在调用Clear后,Count为0,而此时Capacity切是默认容量16,而不是0

    3.publicvirtualvoidTrimToSize();

    将容量设置为ArrayList中元素的实际数量。

    如果不向列表中添加新元素,则此方法可用于最小化列表的内存系统开销。

    若要完全清除列表中的所有元素,请在调用TrimToSize之前调用Clear方法。截去空ArrayList会将ArrayList的容量设置为默认容量,而不是零。

    ArrayListaList=newArrayList();

    aList.Add("a");

    aList.Add("b");

    aList.Add("c");

    aList.Add("d");

    aList.Add("e");//Count=5,Capacity=16,

    aList.TrimToSize();//Count=Capacity=5;

    展开全文
  • System.Collections.ArrayList类是一个特殊的数组。通过添加和删除元素,就可以动态改变数组的长度。一.优点1. 支持自动改变大小的功能2. 可以灵活的插入元素3. 可以灵活的删除元素二.局限性跟一般的数组比起来,...

    System.Collections.ArrayList类是一个特殊的数组。通过添加和删除元素,就可以动态改变数组的长度。

    一.优点

    1. 支持自动改变大小的功能

    2. 可以灵活的插入元素

    3. 可以灵活的删除元素

    二.局限性

    跟一般的数组比起来,速度上差些

    三.添加元素

    1.publicvirtualintAdd(objectvalue);

    将对象添加到ArrayList的结尾处

    ArrayList aList = new ArrayList();

    aList.Add("a");

    aList.Add("b");

    aList.Add("c");

    aList.Add("d");

    aList.Add("e");

    内容为abcde

    2.publicvirtualvoidInsert(intindex,objectvalue);

    将元素插入ArrayList的指定索引处

    ArrayList aList = new ArrayList();

    aList.Add("a");

    aList.Add("b");

    aList.Add("c");

    aList.Add("d");

    aList.Add("e");

    aList.Insert(0,"aa");

    结果为aaabcde

    3.publicvirtualvoidInsertRange(intindex,ICollectionc);

    将集合中的某个元素插入ArrayList的指定索引处

    ArrayList aList = new ArrayList();

    aList.Add("a");

    aList.Add("b");

    aList.Add("c");

    aList.Add("d");

    aList.Add("e");

    ArrayList list2 = newArrayList();

    list2.Add("tt");

    list2.Add("ttt");

    aList.InsertRange(2,list2);

    结果为abtttttcde

    四.删除

    1. publicvirtualvoidRemove(objectobj);

    从ArrayList中移除特定对象的第一个匹配项,注意是第一个

    ArrayList aList = new ArrayList();

    aList.Add("a");

    aList.Add("b");

    aList.Add("c");

    aList.Add("d");

    aList.Add("e");

    aList.Remove("a");

    结果为bcde

    2. publicvirtualvoidRemoveAt(intindex);

    移除ArrayList的指定索引处的元素

    aList.Add("a");

    aList.Add("b");

    aList.Add("c");

    aList.Add("d");

    aList.Add("e");

    aList.RemoveAt(0);

    结果为bcde

    3.publicvirtualvoidRemoveRange(intindex,intcount);

    从ArrayList中移除一定范围的元素。Index表示索引,count表示从索引处开始的数目

    aList.Add("a");

    aList.Add("b");

    aList.Add("c");

    aList.Add("d");

    aList.Add("e");

    aList.RemoveRange(1,3);

    结果为ae

    4.publicvirtualvoidClear();

    从ArrayList中移除所有元素。

    五.排序

    a) publicvirtualvoidSort();

    对ArrayList或它的一部分中的元素进行排序。

    ArrayListaList=newArrayList();

    aList.Add("e");

    aList.Add("a");

    aList.Add("b");

    aList.Add("c");

    aList.Add("d");

    DropDownList1.DataSource=aList;//DropDownListDropDownList1;

    DropDownList1.DataBind();

    结果为eabcd

    ArrayListaList=newArrayList();

    aList.Add("a");

    aList.Add("b");

    aList.Add("c");

    aList.Add("d");

    aList.Add("e");

    aList.Sort();//排序

    DropDownList1.DataSource=aList;//DropDownListDropDownList1;

    DropDownList1.DataBind();

    结果为abcde

    b) publicvirtualvoidReverse();

    将ArrayList或它的一部分中元素的顺序反转。

    ArrayListaList=newArrayList();

    aList.Add("a");

    aList.Add("b");

    aList.Add("c");

    aList.Add("d");

    aList.Add("e");

    aList.Reverse();//反转

    DropDownList1.DataSource=aList;//DropDownListDropDownList1;

    DropDownList1.DataBind();

    结果为edcba

    六.查找

    a) publicvirtualintIndexOf(object);

    b) publicvirtualintIndexOf(object,int);

    c) publicvirtualintIndexOf(object,int,int);

    返回ArrayList或它的一部分中某个值的第一个匹配项的从零开始的索引。没找到返回-1。

    ArrayList aList = new ArrayList();

    aList.Add("a");

    aList.Add("b");

    aList.Add("c");

    aList.Add("d");

    aList.Add("e");

    intnIndex=aList.IndexOf(“a”);//1

    nIndex=aList.IndexOf(“p”);//没找到,-1

    d) publicvirtualintLastIndexOf(object);

    e) publicvirtualintLastIndexOf(object,int);

    f) publicvirtualintLastIndexOf(object,int,int);

    返回ArrayList或它的一部分中某个值的最后一个匹配项的从零开始的索引。

    ArrayList aList = new ArrayList();

    aList.Add("a");

    aList.Add("b");

    aList.Add("a");//同0

    aList.Add("d");

    aList.Add("e");

    intnIndex=aList.LastIndexOf("a");//值为2而不是0

    g) publicvirtualboolContains(objectitem);

    确定某个元素是否在ArrayList中。包含返回true,否则返回false

    七.其他

    1.publicvirtualintCapacity{get;set;}

    获取或设置ArrayList可包含的元素数。

    2.publicvirtualintCount{get;}

    获取ArrayList中实际包含的元素数。

    Capacity是ArrayList可以存储的元素数。Count是ArrayList中实际包含的元素数。Capacity总是大于或等于Count。如果在添加元素时,Count超过Capacity,则该列表的容量会通过自动重新分配内部数组加倍。

    如果Capacity的值显式设置,则内部数组也需要重新分配以容纳指定的容量。如果Capacity被显式设置为0,则公共语言运行库将其设置为默认容量。默认容量为16。

    在调用Clear后,Count为0,而此时Capacity切是默认容量16,而不是0

    3.publicvirtualvoidTrimToSize();

    将容量设置为ArrayList中元素的实际数量。

    如果不向列表中添加新元素,则此方法可用于最小化列表的内存系统开销。

    若要完全清除列表中的所有元素,请在调用TrimToSize之前调用Clear方法。截去空ArrayList会将ArrayList的容量设置为默认容量,而不是零。

    ArrayList aList = new ArrayList();

    aList.Add("a");

    aList.Add("b");

    aList.Add("c");

    aList.Add("d");

    aList.Add("e");//Count=5,Capacity=16,

    aList.TrimToSize();//Count=Capacity=5;

    展开全文
  • java中ArrayList用法详解,基本用法(含增删改查)

    千次阅读 多人点赞 2018-03-15 19:54:56
    1、什么是ArrayList ArrayList就是动态数组,它提供了①动态的增加和减少元素 ②实现了...它继承了AbstractList,实现了List、RandomAccess, Cloneable, java.io.Serializable。 基本的ArrayList,长于随机访问...
    1、什么是ArrayList 
    ArrayList就是动态数组,它提供了
    ①动态的增加和减少元素 
    ②实现了ICollection和IList接口 

    ③灵活的设置数组的大小

    ArrayList是一个其容量能够动态增长的动态数组。它继承了AbstractList,实现了List、RandomAccess, Cloneable, java.io.Serializable。 
    基本的ArrayList,长于随机访问元素,但是在List中间插入和移除元素时较慢。同时,ArrayList的操作不是线程安全的!
    一般在单线程中才使用ArrayList,而在多线程中一般使用Vector或者CopyOnWriteArrayList。

    2、如何使用ArrayList 

    最简单的例子:

     ArrayList<Integer> a=new ArrayList<Integer>();
    
    for(int i=0; i<n; i++){  
                a.add(sc.nextInt());  //为数组增加int型数
            }  
    	a.remove(0);//删除第一个元素;
    	m=2;  
    	a.add(m);  //在数组末尾添加
            a.add(4,2);// 在指定位置添加元素,在第5个位置添加2   
            a.remove(2); // 删除指定位置上的元素                
    	a.remove((Object)3); // 删除指定元素
    	a.clear(); // 清空ArrayList         
    	System.out.println("ArrayList contains 5 is: " + a.contains(5));// 判断arrayList是否包含5        
    	System.out.println("ArrayList is empty: " + arrayList.isEmpty()); // 判断ArrayList是否为空   

    3、ArrayList有三种遍历方式

    迭代器遍历
    Iterator<Integer> it = arrayList.iterator();
    while(it.hasNext()){
        System.out.print(it.next() + " ");
    } 
    
    索引值遍历
    for(int i = 0; i < arrayList.size(); i++){
       System.out.print(arrayList.get(i) + " ");
    }
    
    for循环遍历
    for(Integer number : arrayList){
       System.out.print(number + " ");
    }
    遍历ArrayList时,通过索引值遍历效率最高,for循环遍历次之,迭代器遍历最低
    4、toArray用法
    有时候,当我们调用ArrayList中的 toArray(),可能遇到过抛出java.lang.ClassCastException异常的情况,这是由于toArray() 返回的是 Object[] 数组,将 Object[] 转换为其它类型(如,将Object[]转换为的Integer[])则会抛出java.lang.ClassCastException异常,因为Java不支持向下转型。 

    所以一般更常用的是使用另外一种方法进行使用:

    <T> T[] toArray(T[] a)
    调用toArray(T[] a)返回T[]可通以下方式进行实现:
     // toArray用法
     // 第一种方式(最常用)
     Integer[] integer = arrayList.toArray(new Integer[0]);
    
    
     // 第二种方式(容易理解)
     Integer[] integer1 = new Integer[arrayList.size()];
     arrayList.toArray(integer1);
    
    
     // 抛出异常,java不支持向下转型
     //Integer[] integer2 = new Integer[arrayList.size()];
     //integer2 = arrayList.toArray();
    ArrayList<Integer> a = new  ArrayList<Integer>();  
    
    

    5、用法示例

    import java.util.ArrayList;
    import java.util.Iterator;
    
    public class ArrayListDemo {
    
        public static void main(String[] srgs){
             ArrayList<Integer> arrayList = new ArrayList<Integer>();
    
             System.out.printf("Before add:arrayList.size() = %d\n",arrayList.size());
    
             arrayList.add(1);
             arrayList.add(3);
             arrayList.add(5);
             arrayList.add(7);
             arrayList.add(9);
             System.out.printf("After add:arrayList.size() = %d\n",arrayList.size());
    
             System.out.println("Printing elements of arrayList");
             // 三种遍历方式打印元素
             // 第一种:通过迭代器遍历
             System.out.print("通过迭代器遍历:");
             Iterator<Integer> it = arrayList.iterator();
             while(it.hasNext()){
                 System.out.print(it.next() + " ");
             }
             System.out.println();
    
             // 第二种:通过索引值遍历
             System.out.print("通过索引值遍历:");
             for(int i = 0; i < arrayList.size(); i++){
                 System.out.print(arrayList.get(i) + " ");
             }
             System.out.println();
    
             // 第三种:for循环遍历
             System.out.print("for循环遍历:");
             for(Integer number : arrayList){
                 System.out.print(number + " ");
             }
    
             // toArray用法
             // 第一种方式(最常用)
             Integer[] integer = arrayList.toArray(new Integer[0]);
    
             // 第二种方式(容易理解)
             Integer[] integer1 = new Integer[arrayList.size()];
             arrayList.toArray(integer1);
    
             // 抛出异常,java不支持向下转型
             //Integer[] integer2 = new Integer[arrayList.size()];
             //integer2 = arrayList.toArray();
             System.out.println();
    
             // 在指定位置添加元素
             arrayList.add(2,2);
             // 删除指定位置上的元素
             arrayList.remove(2);    
             // 删除指定元素
             arrayList.remove((Object)3);
             // 判断arrayList是否包含5
             System.out.println("ArrayList contains 5 is: " + arrayList.contains(5));
    
             // 清空ArrayList
             arrayList.clear();
             // 判断ArrayList是否为空
             System.out.println("ArrayList is empty: " + arrayList.isEmpty());
        }
    }
    /**
    Before add:arrayList.size() = 0
    After add:arrayList.size() = 5
    Printing elements of arrayList
    通过迭代器遍历:1 3 5 7 9 
    通过索引值遍历:1 3 5 7 9 
    for循环遍历:1 3 5 7 9 
    ArrayList contains 5 is: true
    ArrayList is empty: true
    */

    6、ArrayList源码解析

    package java.util;
    
    public class ArrayList<E> extends AbstractList<E>
            implements List<E>, RandomAccess, Cloneable, java.io.Serializable
    {
        // 序列版本号
        private static final long serialVersionUID = 8683452581122892189L;
    
        // 默认容量大小
        private static final int DEFAULT_CAPACITY = 10;
    
        // 空数组
        private static final Object[] EMPTY_ELEMENTDATA = {};
    
        // 用于保存ArrayList中数据的数组
        private transient Object[] elementData;
    
        // ArrayList中所包含元素的个数
        private int size;
    
        // 带初始容量参数的构造函数
        public ArrayList(int initialCapacity) {
            super();
            if (initialCapacity < 0)
                throw new IllegalArgumentException("Illegal Capacity: "+
                                                   initialCapacity);
            this.elementData = new Object[initialCapacity];
        }
    
        // 默认构造函数,其默认初始容量为10
        public ArrayList() {
            super();
            this.elementData = EMPTY_ELEMENTDATA;
        }
    
        // 带Collection参数的构造函数
        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 实例的容量调整为列表的当前大小(实际元素个数)
        public void trimToSize() {
            modCount++;
            if (size < elementData.length) {
                elementData = Arrays.copyOf(elementData, size);
            }
        }
    
        // 如有必要,增加此 ArrayList 实例的容量,以确保它至少能够容纳最小容量参数所
        // 指定的元素数
        public void ensureCapacity(int minCapacity) {
            int minExpand = (elementData != EMPTY_ELEMENTDATA)
                // any size if real element table
                ? 0
                // larger than default for empty table. It's already supposed to be
                // at default size.
                : DEFAULT_CAPACITY;
    
            if (minCapacity > minExpand) {
                ensureExplicitCapacity(minCapacity);
            }
        }
    
        private void ensureCapacityInternal(int minCapacity) {
            if (elementData == EMPTY_ELEMENTDATA) {
                minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
            }
    
            ensureExplicitCapacity(minCapacity);
        }
    
        private void ensureExplicitCapacity(int minCapacity) {
            modCount++;
    
            // overflow-conscious code
            if (minCapacity - elementData.length > 0)
                grow(minCapacity);
        }
    
        private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    
    
        private void grow(int minCapacity) {
            // overflow-conscious code
            int oldCapacity = elementData.length;
            int newCapacity = oldCapacity + (oldCapacity >> 1);
            if (newCapacity - minCapacity < 0)
                newCapacity = minCapacity;
            if (newCapacity - MAX_ARRAY_SIZE > 0)
                newCapacity = hugeCapacity(minCapacity);
            // minCapacity is usually close to size, so this is a win:
            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;
        }
    
        // 返回ArrayList中的元素个数
        public int size() {
            return size;
        }
    
        // 判断ArrayList是否为空
        public boolean isEmpty() {
            return size == 0;
        }
    
        // 判断ArrayList是否包含Object(o)
        public boolean contains(Object o) {
            return indexOf(o) >= 0;
        }
    
        // 返回ArrayList中首次出现的指定元素的索引,或如果此列表不包含元素,则返回 -1
        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++)
                    if (o.equals(elementData[i]))
                        return i;
            }
            return -1;
        }
    
        // 返回ArrayList中最后一次出现的指定元素的索引,或如果此列表不包含索引,则返回 -1
        public int lastIndexOf(Object o) {
            if (o == null) {
                for (int i = size-1; i >= 0; i--)
                    if (elementData[i]==null)
                        return i;
            } else {
                for (int i = size-1; i >= 0; i--)
                    if (o.equals(elementData[i]))
                        return i;
            }
            return -1;
        }
    
        // 返回此 ArrayList 实例的浅表副本
        public Object clone() {
            try {
                @SuppressWarnings("unchecked")
                ArrayList<E> v = (ArrayList<E>) super.clone();
                // 将当前ArrayList的全部元素拷贝到v中
                v.elementData = Arrays.copyOf(elementData, size);
                v.modCount = 0;
                return v;
            } catch (CloneNotSupportedException e) {
                // this shouldn't happen, since we are Cloneable
                throw new InternalError();
            }
        }
    
        // 按适当顺序(从第一个到最后一个元素)返回包含此列表中所有元素的数组
        public Object[] toArray() {
            return Arrays.copyOf(elementData, size);
        }
    
        // 返回ArrayList的模板数组。所谓模板数组,即可以将T设为任意的数据类型
        @SuppressWarnings("unchecked")
        public <T> T[] toArray(T[] a) {
            if (a.length < size)
                // Make a new array of a's runtime type, but my contents:
                return (T[]) Arrays.copyOf(elementData, size, a.getClass());
            System.arraycopy(elementData, 0, a, 0, size);
            if (a.length > size)
                a[size] = null;
            return a;
        }
    
        // 位置访问操作   
        @SuppressWarnings("unchecked")
        E elementData(int index) {
            return (E) elementData[index];
        }
    
        // 返回ArrayList中指定位置上的元素
        public E get(int index) {
            rangeCheck(index);
    
            return elementData(index);
        }
    
        // 用指定的元素替代ArrayList中指定位置上的元素,并返回替代前的元素
        public E set(int index, E element) {
            rangeCheck(index);
    
            E oldValue = elementData(index);
            elementData[index] = element;
            return oldValue;
        }
    
        // 将指定的元素添加到ArrayList的尾部
        public boolean add(E e) {
            ensureCapacityInternal(size + 1);  // Increments modCount!!
            elementData[size++] = e;
            return true;
        }
    
        // 将指定的元素插入ArrayList中的指定位置
        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++;
        }
    
        // 移除ArrayList中指定位置上的元素,并返回该位置上的元素
        public E remove(int index) {
            rangeCheck(index);
    
            modCount++;
            E oldValue = elementData(index);
    
            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
    
            return oldValue;
        }
    
        // 移除ArrayList中首次出现的指定元素(如果存在则移除并返回true,否则返回false)
        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) {
            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
        }
    
        // 移除ArrayList中的所有元素
        public void clear() {
            modCount++;
    
            // clear to let GC do its work
            for (int i = 0; i < size; i++)
                elementData[i] = null;
    
            size = 0;
        }
    
        // 按照指定 collection 的迭代器所返回的元素顺序,
        // 将该 collection 中的所有元素添加到ArrayList的尾部
        public boolean addAll(Collection<? extends E> c) {
            Object[] a = c.toArray();
            int numNew = a.length;
            ensureCapacityInternal(size + numNew);  // Increments modCount
            System.arraycopy(a, 0, elementData, size, numNew);
            size += numNew;
            return numNew != 0;
        }
    
        // 从指定的位置开始,将指定 collection 中的所有元素插入到ArrayList中
        public boolean addAll(int index, Collection<? extends E> c) {
            rangeCheckForAdd(index);
    
            Object[] a = c.toArray();
            int numNew = a.length;
            ensureCapacityInternal(size + numNew);  // Increments modCount
    
            int numMoved = size - index;
            if (numMoved > 0)
                System.arraycopy(elementData, index, elementData, index + numNew,
                                 numMoved);
    
            System.arraycopy(a, 0, elementData, index, numNew);
            size += numNew;
            return numNew != 0;
        }
    
        // 移除列表中索引在 fromIndex(包括)和 toIndex(不包括)之间的所有元素
        protected void removeRange(int fromIndex, int toIndex) {
            modCount++;
            int numMoved = size - toIndex;
            System.arraycopy(elementData, toIndex, elementData, fromIndex,
                             numMoved);
    
            // clear to let GC do its work
            int newSize = size - (toIndex-fromIndex);
            for (int i = newSize; i < size; i++) {
                elementData[i] = null;
            }
            size = newSize;
        }
    
        // 私有方法,用于范围检测
        private void rangeCheck(int index) {
            if (index >= size)
                throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }
    
        // 私有方法,用于add和addAll
        private void rangeCheckForAdd(int index) {
            if (index > size || index < 0)
                throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }
    
    
        private String outOfBoundsMsg(int index) {
            return "Index: "+index+", Size: "+size;
        }
    
        // 移除ArrayList中Collection所包含的所有元素
        public boolean removeAll(Collection<?> c) {
            return batchRemove(c, false);
        }
    
        // 保留所有ArrayList和Collection共有的元素
        public boolean retainAll(Collection<?> c) {
            return batchRemove(c, true);
        }
    
        private boolean batchRemove(Collection<?> c, boolean complement) {
            final Object[] elementData = this.elementData;
            int r = 0, w = 0;
            boolean modified = false;
            try {
                for (; r < size; r++)
                    if (c.contains(elementData[r]) == complement)
                        elementData[w++] = elementData[r];
            } finally {
                // Preserve behavioral compatibility with AbstractCollection,
                // even if c.contains() throws.
                if (r != size) {
                    System.arraycopy(elementData, r,
                                     elementData, w,
                                     size - r);
                    w += size - r;
                }
                if (w != size) {
                    // clear to let GC do its work
                    for (int i = w; i < size; i++)
                        elementData[i] = null;
                    modCount += size - w;
                    size = w;
                    modified = true;
                }
            }
            return modified;
        }
    
        // java.io.Serializable的写入函数
        // 将ArrayList的“容量,所有的元素值”都写入到输出流中
        private void writeObject(java.io.ObjectOutputStream s)
            throws java.io.IOException{
            // Write out element count, and any hidden stuff
            int expectedModCount = modCount;
            s.defaultWriteObject();
    
            // Write out size as capacity for behavioural compatibility with clone()
            s.writeInt(size);
    
            // Write out all elements in the proper order.
            for (int i=0; i<size; i++) {
                s.writeObject(elementData[i]);
            }
    
            if (modCount != expectedModCount) {
                throw new ConcurrentModificationException();
            }
        }
    
        // java.io.Serializable的读取函数:根据写入方式读出
        // 先将ArrayList的“容量”读出,然后将“所有的元素值”读出
        private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
            elementData = EMPTY_ELEMENTDATA;
    
            // Read in size, and any hidden stuff
            s.defaultReadObject();
    
            // Read in capacity
            s.readInt(); // ignored
    
            if (size > 0) {
                // be like clone(), allocate array based upon size not capacity
                ensureCapacityInternal(size);
    
                Object[] a = elementData;
                // Read in all elements in the proper order.
                for (int i=0; i<size; i++) {
                    a[i] = s.readObject();
                }
            }
        }
    
        // 返回一个从指定位置开始遍历的ListIterator迭代器
        public ListIterator<E> listIterator(int index) {
            if (index < 0 || index > size)
                throw new IndexOutOfBoundsException("Index: "+index);
            return new ListItr(index);
        }
    
        // 返回一个ListIterator迭代器
        public ListIterator<E> listIterator() {
            return new ListItr(0);
        }
    
        // 返回一个Iterator迭代器
        public Iterator<E> iterator() {
            return new Itr();
        }
    
        // 返回一个指定范围的子List列表
        public List<E> subList(int fromIndex, int toIndex) {
            subListRangeCheck(fromIndex, toIndex, size);
            return new SubList(this, 0, fromIndex, toIndex);
        }
    }

    展开全文
  • Java中ArrayList用法

    2020-03-13 20:08:00
    Java中ArrayList用法 CircleYua 2020-03-13 20:08 31 人阅读 0 条评论 ArrayList类是一个特殊的数组--动态数组。来自于System....
  • JavaArrayList用法

    千次阅读 多人点赞 2018-04-13 19:54:36
    一、ArrayList的添加方法1. 1方法1:依次按照顺序向ArrayList中添加数据。用法:将a添加到listlist.add(&...注意:ArrayList中必须有足够多的数据,例如ArrayList中没有任何数据,这个时候使用arraylist.add(1,...
  • arraylist是动态数组,它具有三个好处分别是:动态的增加和减少元素 、实现了ICollection和IList接口、灵活的设置数组的大小,本文给大家介绍java arraylist遍历及Java arraylist 用法,感兴趣的朋友一起学习吧
  • Java ArrayList类的用法 1、什么是ArrayList ArrayList就是传说的动态数组,用MSDN的说法,就是Array的复杂版本,它提供了如下一些好处: 动态的增加和减少元素 实现了ICollection和IList接口 灵活的设置数组...
  • Java中ArrayList基本用法

    2020-10-10 19:18:24
    import java.util.ArrayList; 创建 ArrayList <泛型> list = new ArrayList<>(); 泛型特例: int(Integer) char(Character) 其余泛型均是首字母变大写 例 double(Double) 常用方法 1.添加元素...
  • List studentList = new ArrayList(); studentList.add(zlj); studentList.add(dxy); studentList.add(cjc); studentList.add(lgc); System.out.println("按照年齡排序:"); Collections.sort(studentList, new ...
  • java arrayList遍历的四种方法及Java中ArrayList类的用法package com.test;import java.util.ArrayList;import java.util.Iterator;import java.util.List;public class ArrayListDemo {public static void main...
  • 本文通过实例讲解Java中如何使用ArrayList类。Java.util.ArrayList类是一个动态数组类型,也就是说,ArrayList对象既有数组的特征,也有链表的特征。可以随时从链表中添加或删除一个元素。ArrayList实现了List接口。...
  • 主要介绍了Java中ArrayList类的用法与源码完全解析,ArrayList类通过List接口实现,是Java中引申出的一种数据结构,需要的朋友可以参考下
  • JAVA中ArrayList用法

    2016-11-06 15:47:03
    遍历的四种方法: ...import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class ArrayListDemo {  public static void main(String args[]){  List li
  • java中Arraylist用法

    2020-05-13 14:37:55
    https://www.cnblogs.com/kungfupanda/p/7357142.html
  • 1、什么是ArrayListArrayList就是传说的动态数组,用MSDN的说法,就是Array的复杂版本,它提供了如下一些好处:动态的增加和减少元素实现了ICollection和IList接口灵活的设置数组的大小2、如何使用ArrayList最...
  • java中ArrayList简单用法

    2016-05-12 11:38:24
    [java] view plain copy package test;...import java.util.ArrayList;      public class ArrayListTest {       /**   * @param args   */   public stati
  • 1、什么是ArrayListArrayList就是传说的动态数组,用MSDN的说法,就是Array的复杂版本,它提供了如下一些好处:动态的增加和减少元素实现了ICollection和IList接口灵活的设置数组的大小2、如何使用ArrayList最...
  • java ArrayList用法

    2018-04-24 15:45:28
    Java中ArrayList类详解1、什么是ArrayList ArrayList就是传说中的动态数组,用MSDN中的说法,就是Array的复杂版本,它提供了如下一些好处: 动态的增加和减少元素 实现了ICollection和IList接口 灵活的设置数组...
  • Java中ArrayList类的用法

    2017-04-11 18:16:44
    Java中ArrayList类的用法 1、什么是ArrayList ArrayList就是传说中的动态数组,用MSDN中的说法,就是Array的复杂版本,它提供了如下一些好处: 动态的增加和减少元素 实现了ICollection和IList接口 灵活的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,117
精华内容 446
关键字:

java中arraylist用法

java 订阅