[编程语言][java][java se][java.util.ArrayList]List ArrayList用法学习记录

最新推荐文章于 2022-01-06 10:00:00 发布

camel4123

最新推荐文章于 2022-01-06 10:00:00 发布

阅读量404

点赞数

分类专栏： JAVA

本文链接：https://blog.csdn.net/john_camel/article/details/19083191

版权

JAVA 专栏收录该内容

27 篇文章 0 订阅

订阅专栏

首先看这两类都实现List接口，而List接口一共有三个实现类，分别是ArrayList、Vector和LinkedList。List用于存放多个元素，能够维护元素的次序，并且允许元素的重复。3个具体实现类的相关区别如下：

ArrayList(非线程安全,获取线程安全的Collections.synchronizedList())是最常用的List实现类，内部是通过数组实现的，它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要增加存储能力，就要讲已经有数组的数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时，需要对数组进行复制、移动、代价比较高。因此，它适合随机查找和遍历，不适合插入和删除。
Vector(线程安全)与ArrayList一样，也是通过数组实现的，不同的是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但实现同步需要很高的花费，因此，访问它比访问ArrayList慢。
LinkedList(非线程安全,获取线程安全的Collections.synchronizedList())是用链表结构存储数据的，很适合数据的动态插入和删除，随机访问和遍历速度比较慢。另外，他还提供了List接口中没有定义的方法，专门用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用。

查看Java源代码，发现当数组的大小不够的时候，需要重新建立数组，然后将元素拷贝到新的数组内，ArrayList和Vector的扩展数组的大小不同。

ArrayList中：

  
  
   
    1 
   
   public
   
    
   
   boolean
   
    add(E e) {

   
    2 
   
   

   
    3 
   
       ensureCapacity(size 
   
   +
   
    
   
   1
   
   );  
   
   //
   
    增加元素，判断是否能够容纳。不能的话就要新建数组
   
   

   
    4 
   
    
   
   

   
    5 
   
       elementData[size
   
   ++
   
   ] 
   
   =
   
    e;

   
    6 
   
   

   
    7 
   
       
   
   return
   
    
   
   true
   
   ;

   
    8 
   
   

   
    9 
   
   }

   
   10 
   
   

   
   11 
   
    
   
   public
   
    
   
   void
   
    ensureCapacity(
   
   int
   
    minCapacity) {

   
   12 
   
   

   
   13 
   
       modCount
   
   ++
   
   ; 

   
   14 
   
   

   
   15 
   
       
   
   int
   
    oldCapacity 
   
   =
   
    elementData.length;

   
   16 
   
   

   
   17 
   
       
   
   if
   
    (minCapacity 
   
   >
   
    oldCapacity) {

   
   18 
   
   

   
   19 
   
           Object oldData[] 
   
   =
   
    elementData; 
   
   //
   
    此行没看出来用处，不知道开发者出于什么考虑
   
   

   
   20 
   
    
   
   

   
   21 
   
           
   
   int
   
    newCapacity 
   
   =
   
    (oldCapacity 
   
   *
   
    
   
   3
   
   )
   
   /
   
   2
   
    
   
   +
   
    
   
   1
   
   ; 
   
   //
   
    增加新的数组的大小
   
   

   
   22 
   
    
   
   

   
   23 
   
           
   
   if
   
    (newCapacity 
   
   <
   
    minCapacity)

   
   24 
   
   

   
   25 
   
          newCapacity 
   
   =
   
    minCapacity;

   
   26 
   
   

   
   27 
   
               
   
   //
   
    minCapacity is usually close to size, so this is a win:
   
   

   
   28 
   
    
   
   

   
   29 
   
               elementData 
   
   =
   
    Arrays.copyOf(elementData, newCapacity);

   
   30 
   
   

   
   31 
   
       }

   
   32 
   
   

   
   33 
   
   }

   
   34 
   
   

   
   35

Vector中：

  
  
   
    1 
   
   private
   
    
   
   void
   
    ensureCapacityHelper(
   
   int
   
    minCapacity) {

   
    2 
   
   

   
    3 
   
       
   
   int
   
    oldCapacity 
   
   =
   
    elementData.length;

   
    4 
   
   

   
    5 
   
       
   
   if
   
    (minCapacity 
   
   >
   
    oldCapacity) {

   
    6 
   
   

   
    7 
   
           Object[] oldData 
   
   =
   
    elementData;

   
    8 
   
   

   
    9 
   
           
   
   int
   
    newCapacity 
   
   =
   
    (capacityIncrement 
   
   >
   
    
   
   0
   
   ) 
   
   ?
   
   

   
   10 
   
   

   
   11 
   
          (oldCapacity 
   
   +
   
    capacityIncrement) : (oldCapacity 
   
   *
   
    
   
   2
   
   );

   
   12 
   
   

   
   13 
   
           
   
   if
   
    (newCapacity 
   
   <
   
    minCapacity) {

   
   14 
   
   

   
   15 
   
          newCapacity 
   
   =
   
    minCapacity;

   
   16 
   
   

   
   17 
   
           }

   
   18 
   
   

   
   19 
   
            elementData 
   
   =
   
    Arrays.copyOf(elementData, newCapacity);

   
   20 
   
   

   
   21 
   
       }

   
   22 
   
   

   
   23 
   
   }

   
   24 
   
   

   
   25

关于ArrayList和Vector区别如下：

ArrayList在内存不够时默认是扩展50% + 1个，Vector是默认扩展1倍。
Vector提供indexOf(obj, start)接口，ArrayList没有。
Vector属于线程安全级别的，但是大多数情况下不使用Vector，因为线程安全需要更大的系统开销。

两个线程操作同一个ArrayList变量，那么一个线程这一时刻读的数据可能在下一刻要改变。
一般在类似于下面的情景下考虑线程安全的问题：
ArrayList products=new ArrayList ();
products用来存放生产出来的产品。
现在假设：有3个消费者线程，2个生产者线程。
每个生产者线程生产出一个产品，执行
products.add(new Product（）);
每个消费者线程消费一个产品执行
if(products.size()>=1){ products.remove(0);}
如果products里现在只有一个产品可以消费，但是有2个消费者线程请求消费，那么就有可能出现一个产品被同时消费的问题，而这是和实际不符的。
但是不同的线程访问Vector的时候不会发生这种错误，因为java会有相应的机制是同一时刻只有一个线程对这个变量操作。
这就是所谓的：
Vector：是线程安全的
ArrayList：不是线程安全的

即

线程安全的就是不同的线程访问Vector的时候不会发生错误，也就是一些不一致问题，如丢失修改，读脏数据，不可重复读等！Vector的实现保证了多个线程的互斥。不安全就是多个线程操作ArrayList的时候会发生错误

List是一个接口，而ListArray是一个类。
ListArray继承并实现了List。
所以List不能被构造，但可以向上面那样为List创建一个引用，而ListArray就可以被构造。
List list; //正确 list=null;
List list=new List(); // 是错误的用法

List list = new ArrayList();这句创建了一个ArrayList的对象后把上溯到了List。此时它是一个List对象了，有些ArrayList有但是List没有的属性和方法，它就不能再用了。
而ArrayList list=new ArrayList();创建一对象则保留了ArrayList的所有属性。

这是一个例子：
import java.util.*;

public class TestList{
public static void main(String[] args){
List list = new ArrayList();
ArrayList arrayList = new ArrayList();

list.trimToSize(); //错误，没有该方法。
arrayList.trimToSize(); //ArrayList里有该方法。
}
}

List的用法
List包括List接口以及List接口的所有实现类。因为List接口继承了Collection接口，所以List接口拥有Collection接口提供的所有常用方法，又因为List是列表类型，所以List接口还提供了一些适合于自身的常用方法，如表1所示。

表1 List接口定义的常用方法及功能
从表1可以看出，List接口提供的适合于自身的常用方法均与索引有关，这是因为List集合为列表类型，以线性方式存储对象，可以通过对象的索引操作对象。
List接口的常用实现类有ArrayList和LinkedList，在使用List集合时，通常情况下声明为List类型，实例化时根据实际情况的需要，实例化为ArrayList或LinkedList，例如：
List<String> l = new ArrayList<String>();// 利用ArrayList类实例化List集合
List<String> l2 = new LinkedList<String>();// 利用LinkedList类实例化List集合
1．add(int index, Object obj)方法和set(int index, Object obj)方法的区别
在使用List集合时需要注意区分add(int index, Object obj)方法和set(int index, Object obj)方法，前者是向指定索引位置添加对象，而后者是修改指定索引位置的对象，例如执行下面的代码：

srccommwqTestCollection.java关键代码：

public static void main(String[] args) {
String a = "A", b = "B", c = "C", d = "D", e = "E";
List<String> list = new LinkedList<String>();
list.add(a);
list.add(e);
list.add(d);
list.set(1, b);// 将索引位置为1的对象e修改为对象b
list.add(2, c);// 将对象c添加到索引位置为2的位置
Iterator<String> it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
在控制台将输出如下信息：
A
B
C
D

因为List集合可以通过索引位置访问对象，所以还可以通过for循环遍历List集合，例如遍历上面代码中的List集合的代码如下：

srccommwqTestCollection.java关键代码：
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));// 利用get(int index)方法获得指定索引位置的对象
}
srccommwqTestCollection.java完整代码如下：
package com.mwq;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Iterator;
import java.util.List;
public class TestCollection {
public static void main(String[] args) {
System.out.println("开始：");
String a = "A", b = "B", c = "C", d = "D", e = "E";
List<String> list = new LinkedList<String>();
list.add(a);
list.add(e);
list.add(d);
list.set(1, b);// 将索引位置为1的对象e修改为对象b
list.add(2, c);// 将对象c添加到索引位置为2的位置
Iterator<String> it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
//                 for (int i = 0; i < list.size(); i++) {
//                       System.out.println(list.get(i));// 利用get(int index)方法获得指定索引位置的对象
//          }
System.out.println("结束！");
}
}

编译一下就知道结果了。

如果这个样子：
List a=new ArrayList();
则a拥有List与ArrayList的所有属性和方法，不会减少
如果List与ArrayList中有相同的属性（如int i),有相同的方法（如void f()),
则a.i是调用了List中的i
a.f()是调用了ArrayList中的f();

---------------------------------------------------------------
问题的关键:
为什么要用 List list = new ArrayList() ,而不用 ArrayList alist = new ArrayList()呢？
问题就在于List有多个实现类，现在你用的是ArrayList，也许哪一天你需要换成其它的实现类，如 LinkedList或者Vector等等，这时你只要改变这一行就行了：
List list = new LinkedList(); 其它使用了list地方的代码根本不需要改动。
假设你开始用 ArrayList alist = new ArrayList(), 这下你有的改了，特别是如果你使用了 ArrayList特有的方法和属性。

地区用 List arr = new ArrayList();定义;行业用 ArrayListarr = new ArrayList();定义;则说明,行业里用到了ArrayList的特殊的方法.

另外的例子就是,在类的方法中,如下声明:
private void doMyAction(List list){}
这样这个方法能处理所有实现了List接口的类,一定程度上实现了泛型函数.

如果开发的时候觉得ArrayList,HashMap的性能不能满足你的需要,可以通过实现List,Map(或者Collection)来定制你的自定义类

camel4123

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
[编程语言][java][java se][java.util.ArrayList]List ArrayList用法学习记录

List是一个接口，而ListArray是一个类。 ListArray继承并实现了List。所以List不能被构造，但可以向上面那样为List创建一个引用，而ListArray就可以被构造。 List list; //正确 list=null; List list=new List(); // 是错误的用法List list = new ArrayL
复制链接

扫一扫