ArrayList实现类的总结

Java ArrayList总结

 

ArrayList也是我们集合中最最重要的一个实现类，也是我们必须要掌握的集合类。本文将对ArrayList做比较全面的总结，

一个是从概念上理解，第二个是ArrayList的使用，这里使用ArrayList基本上是结合泛型来讲解使用，因为实际运用也是结合泛型使用的。

一．ArrayList是什么？

  根据MSDN文档介绍，ArrayList是动态数组，是Array的子类，也是List接口的实现类。具有数组特点，也有自身的特点。

（一）ArrayList可以动态改变大小，动态增，删元素

（二）实现了Collection和List接口，可以使用其中的方法

二．ArrayList常用的使用方法

扫描二维码关注公众号，回复： 2792094 查看本文章

（一）public intsize();

返回此列表中的元素数。

（二）  public boolean isEmpty();

如果此列表中没有元素，则返回 true

（三）public boolean contains(Object o);

如果此列表中包含指定的元素，则返回 true

（四）public int indexOf(Object o)

返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。

（五）public int lastIndexOf(Object o)

返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。

（六）public Object[] toArray();

按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。 

（七）public E get(int index);

返回此列表中指定位置上的元素

（八）public E set(int index, E element);

 用指定的元素替代此列表中指定位置上的元素。返回值为以前位于该指定位置上的元素

（九）public boolean add(E element);

 将指定的元素添加到此列表的尾部。添加成功返回true

（十）public void add(int index, E element)

 将指定的元素插入此列表中的指定位置。向右移动当前位于该位置的元素（如果有）以及所有后续元素（将其索引加 1）。

（十一）public E remove(int index)

 移除此列表中指定位置的元素，返回从列表中移除的元素

（十二）public boolean remove(Object o)

 移除此列表中首次出现的指定元素（如果存在）。如果列表不包含此元素，则列表不做改动。

（十三）public void clear()

移除此列表中的所有元素。此调用返回后，列表将为空

（十四）public boolean addAll(Collection c)

按照指定collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部

（十五）publicboolean addAll(int index, Collection c)

 从指定的位置开始，将指定 collection中的所有元素插入到此列表中。

 

三．ArrayList增删改查基本操作

示例一

[plain]  view plain  copy

1. package com.xykj.arraylist;  
2. import java.util.ArrayList;  
3. import java.util.Iterator;  
4. public class MainClass {  
5.     /**  
6.      * ArrayList增删改查的操作  
7.      * */  
8.     public static void main(String[] args) {  
9.        //实例化ArrayList，泛型是基本类型String，添加的数据只能是String，否者报错  
10.        ArrayListlist=new ArrayList<>();  
11.         
12.        //添加操作  
13.        list.add("123");  
14.        //list.add(12);//会报错  
15.        list.add("小明");  
16.        list.add("meizi");  
17.        list.add("shuaige");  
18.         
19.        //删除操作  
20.        list.remove(1);//以游标的方式，删除第二个数据“小明”  
21.        list.remove("meizi");//以实际集合的内容，删除第三个数据“meizi”  
22.         
23.        //数据修改  
24.        list.set(0, "222");//把第一个元素的内容改为“222”了  
25.         
26.        //显示集合内的数据  
27.        //集合剩下“222”、“shuaige”这两页元素了  
28.         
29.        //显示方法1:  
30.        //System.out.println(list);//最简单的显示方法  
31.         
32.        //显示方法2:  
33.        /*for (int i = 0; i  iterator=list.iterator();  
34.        while (iterator.hasNext()) {  
35.            System.out.println(iterator.next());  
36.        }  
37.     }  
38.    
39. }  

显示结果：

 

对于示例1的简单说明：

示例1对ArrayList进行了增删改查的基本操作，其中添加和修改的方法基本是固定的，但是删除和查找的方法是比较多，本示例列举了所有的显示List方法，

其中第二个方法是java基础时经常用的，

第三个方法是一个特殊的for结构，叫foreach语句，这个语句没有显式的游标值，但是能遍历后面集合（数组）的所有元素，

第四个方法是java集合专门使用的方法，需要迭代器Iterator接口的使用，后面要加泛型（要接收的数据类型），使用hasNext方法判断下一个游标位置是否存在元素，再用next方法获取集合的元素。

值得说一下的是，删除很多个集合元素时，基本是用迭代器Iterator接口的remove方法来删除元素，其他办法都有可能导致程序崩溃。

示例二

本示例使用自定义的数据类型作为泛型，同样是增删改查的操作实现，但是重点是删除操作。

1．先建一个自定义数据类User

[plain]  view plain  copy

1. package com.xykj.arraylist2;  
2. public class User {  
3.     //为一个用户定义三个基本属性  
4.     String name="";  
5.     String sex="";  
6.     int age=0;  
7.      
8.     //利用构造方法传递参数   
9.     public User(Stringname, Stringsex,intage) {  
10.        super();  
11.        this.name =name;  
12.        this.sex =sex;  
13.        this.age =age;  
14.     }  
15.      
16.     //各个参数的get和set方法  
17.     public String getName() {  
18.        returnname;  
19.     }  
20.     public void setName(String name) {  
21.        this.name =name;  
22.     }  
23.     public String getSex() {  
24.        returnsex;  
25.     }  
26.     public void setSex(String sex) {  
27.        this.sex =sex;  
28.     }  
29.     public int getAge() {  
30.        returnage;  
31.     }  
32.     public void setAge(intage) {  
33.        this.age =age;  
34.     }  
35.      
36.        
37. }  
38.    

2．再建主方法调用类

[plain]  view plain  copy

1. packagecom.xykj.arraylist2;  
2.    
3. importjava.util.ArrayList;  
4. importjava.util.Iterator;  
5.    
6. publicclass MainClass {  
7.     /**  
8.      * 本示例对泛型是自定义类的情况做增删改查  
9.      *  
10.      * */  
11.     public static void main(String[] args) {  
12.    
13.        // 这里存入集合的不是基本数据类型了，而是上面创建的User类的对象了  
14.        ArrayList list = newArrayList<>();  
15.    
16.        // 添加User类的对象10个  
17.        for (int i = 0; i < 10; i++) {  
18.            list.add(new User("name" +i, "女", 10 + i));  
19.        }  
20.    
21.        // 删除前面的五个User的对象  
22.    
23.        /*使用for循环删除  
24.         *for (int i = 0; i < 5; i++) { //虽然程序没有崩掉，但是得到的结果不对  
25.         *list.remove(i); }//得到结果：剩下name1、name3、name5、name7、name9  
26.         */  
27.         
28.        // 使用迭代器Iterator删除  
29.        Iterator iterator =list.iterator();  
30.        int num = 0;  
31.        while (iterator.hasNext()) {  
32.            iterator.next();//游标指向下一个，这个很重要，没有就报错  
33.            iterator.remove();  
34.            num++;  
35.            if (num == 5) { // 删除前面0到4个，马上退出循环  
36.               break;  
37.            }  
38.        }  
39.         
40.        //创建一个User对象  
41.        User meizi=new User("meizi","女",18);  
42.        //改变集合里面第一个元素的值  
43.        list.set(0, meizi);  
44.         
45.        //显示集合里面的元素的具体属性  
46.        // System.out.println(list);//直接打印出现的是类名和地址，不是我们想要的结果  
47.        for (User user : list) {  
48.            System.out.println(user.getName()+"\t"+user.getSex()+"\t"+user.getAge());  
49.        }  
50.    
51.     }  
52.    
53. }  

运行结果：

 

示例2的简单说明：

   本示例主要是泛型的扩展使用，这个在以后数据存储也是很常用的。

   还有一个就是list列表的删除多个元素的方法，迭代器Iterator接口类的使用，这个也是重点要掌握的知识。

 

从上面两个例子，可以看到ArrayList在实际的应用的具体代码，要熟练掌握这两种存储方式。相关知识的储备也是要的。