List集合及ArrayList的用法

List集合

List集合的主要实现有ArrayList和LinkedList，分别是数据结构中顺序表和链表的实现。另外还包括栈和队列的实现类：Deque和Queue。

List：有序，不唯一（可重复）

ArrayList：

• 在内存中分配了连续的空间，实现了长度可变的数组（StringBuilder）

• 优点：遍历元素和随机访问元素的效率高

• 缺点：添加，删除需大量移动元素，效率低

LinkedList：

• 采用双向链表存储方式

• 优点：添加，删除效率高（直接修改指针即可）

• 缺点：遍历元素和随机访问元素的效率低

ArrayList和LinkedList按照内容查找时，都需要逐个查找，效率都不高

1.ArrayList

1.1ArrayList的创建和遍历

• List list = new ArrayList();
• ArrayList:不唯一，索引有序
• 集合中只能放引用数据类型；基本数据类型需要使用包装类包装，然后再放入集合
• 缺点：宽进严出-->添加元素可以添加任何类型，不安全，取出元素时需强转

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * ArrayList:不唯一，索引有序
 * 数组中既可以放基本数据类型，也可以放引用数据类型
 * 集合中只能放引用数据类型；基本数据类型需要使用包装类包装，然后再放入集合
 * 缺点：宽进严出-->添加元素可以添加任何类型，不安全，取出元素时需强转
 */
public class ArrayListDemo01 {
    public static void main(String[] args) {
        //创建集合
        List list = new ArrayList();
        //在末尾添加元素
        list.add(30);//自动装箱  int->Integer
        list.add(60);
        list.add(20);
        //在指定索引添加元素
        list.add(1, 100);//底层发生了大量元素的后移，并可能发生数组的扩容
        //集合的个数
        System.out.println("集合的个数::" + list.size());//集合中真实存储的元素个数，并不是底层数组的长度
        //查找指定索引的元素
        int element = (int) list.get(1);
        System.out.println("查找指定索引的元素::" + element);
        //遍历元素
        System.out.println(list);
        System.out.println("=======遍历方法一==============");
        //遍历方法一：for循环
        for (int i = 0; i < list.size(); i++) {
            int element2 = (int) list.get(i);
            System.out.println("遍历方法一::" + element2);
        }
        System.out.println("=======遍历方法二==============");
        //遍历方法二：for each
        for (Object element3 : list) {
            System.out.println("遍历方法二::" + element3);
        }
        System.out.println("=======遍历方法三==============");
        //遍历方法三：迭代iterator
        Iterator iterator = list.iterator();
        //iterator.hasNext()：查看是否有下一个元素
        while (iterator.hasNext()) {
            int ite = (int) iterator.next();//iterator.next() 取出元素
            System.out.println("遍历方法三::" + ite);
        }
        System.out.println("=======遍历方法四==============");
        //遍历方法四：Lambda表达式+流式编程（jdk1.8新增）
        list.forEach(item -> System.out.println(item));
        list.forEach(System.out::println);
    }
}

执行结果：
集合的个数::4
查找指定索引的元素::100
[30, 100, 60, 20]
=======遍历方法一==============
遍历方法一::30
遍历方法一::100
遍历方法一::60
遍历方法一::20
=======遍历方法二==============
遍历方法二::30
遍历方法二::100
遍历方法二::60
遍历方法二::20
=======遍历方法三==============
遍历方法三::30
遍历方法三::100
遍历方法三::60
遍历方法三::20
=======遍历方法四==============
30
100
60
20
30
100
60
20

Process finished with exit code 0

1.2ArrayList的创建和遍历（优化）

• 创建集合时使用泛型(generic)，严进宽出，安全

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * 创建集合时使用泛型(generic)，严进宽出，安全
 */
public class ArrayListDemo02 {
    public static void main(String[] args) {
        //创建集合
        List<Integer> list = new ArrayList();
        //在末尾添加元素
        list.add(30);//自动装箱  int->Integer
        list.add(60);
        list.add(20);
        //在指定索引添加元素
        list.add(1, 100);//底层发生了大量元素的后移，并可能发生数组的扩容
        //集合的个数
        System.out.println("集合的个数::" + list.size());//集合中真实存储的元素个数，并不是底层数组的长度
        //查找指定索引的元素
        int element = list.get(1);
        System.out.println("查找指定索引的元素::" + element);
        //遍历元素
        System.out.println(list);
        System.out.println("=======遍历方法一==============");
        //遍历方法一：for循环
        for (int i = 0; i < list.size(); i++) {
            int element2 = list.get(i);
            System.out.println("遍历方法一::" + element2);
        }
        System.out.println("=======遍历方法二==============");
        //遍历方法二：for each
        for (Object element3 : list) {
            System.out.println("遍历方法二::" + element3);
        }
        System.out.println("=======遍历方法三==============");
        //遍历方法三：迭代iterator
        Iterator<Integer> iterator = list.iterator();
        //iterator.hasNext()：查看是否有下一个元素
        while (iterator.hasNext()) {
            int ite = iterator.next();//iterator.next() 取出元素
            System.out.println("遍历方法三::" + ite);
        }
        System.out.println("=======遍历方法四==============");
        //遍历方法四：Lambda表达式+流式编程（jdk1.8新增）
        list.forEach(item -> System.out.println(item));
        list.forEach(System.out::println);
    }
}

执行结果：
集合的个数::4
查找指定索引的元素::100
[30, 100, 60, 20]
=======遍历方法一==============
遍历方法一::30
遍历方法一::100
遍历方法一::60
遍历方法一::20
=======遍历方法二==============
遍历方法二::30
遍历方法二::100
遍历方法二::60
遍历方法二::20
=======遍历方法三==============
遍历方法三::30
遍历方法三::100
遍历方法三::60
遍历方法三::20
=======遍历方法四==============
30
100
60
20
30
100
60
20

Process finished with exit code 0

1.3ArrayList的方法

import java.util.ArrayList;
import java.util.List;

/**
 * ArrayList的方法
 */
public class ArrayListDemo03 {
    public static void main(String[] args) {
        //创建集合
        List<Integer> list = new ArrayList();
        list.add(30);//在末尾添加元素 自动装箱  int->Integer
        list.add(40);
        list.add(30);
        list.add(1, 100);//在指定索引添加元素，底层发生了大量元素的后移，并可能发生数组的扩容
        //遍历元素
        System.out.println("list::" + list);//list::[30, 100, 40, 30]
        List<Integer> list2 = new ArrayList();
        list2.add(40);
        list2.add(50);
        System.out.println("list2::" + list2);//list2::[40, 50]
        // list.addAll(list2);//在list末尾添加集合list2  list::[30, 100, 40, 30, 40, 50]
        //list.addAll(1, list2);//在list指定下标添加集合list2  list::[30, 40, 50, 100, 40, 30]
        //list.remove(1);///删除指定下标的元素  list::[30, 40, 30]
        // list.remove(new Integer(30));//删除第一次出现该值的元素  list::[100, 40, 30]
        //list.removeAll(list2);//删除两个集合重复的元素  list::[30, 100, 30]
        //list.retainAll(list2);//保留两个集合重复的元素  list::[40]
        //list.set(3, 70);//修改指定下标的值为指定元素  list::[30, 100, 40, 70]
        System.out.println(list.contains(30));//是否包含30  true
        System.out.println(list.indexOf(new Integer(40)));//指定值的下标  2
        System.out.println("list::" + list);//list::[30, 100, 40, 30]
        System.out.println(list.isEmpty());//false
        list.clear();//删除list中的所有元素
        System.out.println("list::" + list);//list::[]
        System.out.println(list.isEmpty());//true
    }
}