小东吖 之 java List 接口以及 ArrayList集合 LinkedList集合

一.List接口

List接口是Collection接口的子接口，List有一个重要的实现类–ArrayList类，List中的元素是有序排列的而且可重复，所以被称为是序列。

List可以精确的控制每个元素的插入位置，或删除某个位置元素，它的实现类ArrayList底层是由数组实现的。

List中有增删改查的方法，我们可以通过例子演示：
1, 测试List接口中 特有的方法
1.add(E e)
向列表的尾部添加指定的元素（可选操作）
2.add(int index, E element)
在列表的指定位置插入指定元素（可选操作）。
3.set(int index, E element)
用指定元素替换列表中指定位置的元素（可选操作）
4.get(int index)
返回列表中指定位置的元素。
5.remove(int index)
移除列表中指定位置的元素（可选操作）。

        //add 添加
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        // 向指定索引添加元素 (相当于插入)(不能越界添加)
        //list.add(4, "w");
        // 替换指定索引的元素(不能越界 不能替换超出集合长度的索引)
        //list.set(4, "m");
        // 获取指定下标位置的元素(不能越界)
        //Object object = list.get(1);
        // 利用List遍历
        for (int i = 0; i < list.size(); i++) {
            Object object2 = list.get(i);
            System.out.println(object2);
        // 指定位置删除
        Object remove = list.remove(1);
        Iterator iterator = list.iterator();

二.ArrayList集合

1.什么是ArrayList?
可以简单的认为是一个动态数组；实际上ArrayList就是用数组实现的

Java.util.ArrayList类是一个动态数组类型，也就是说，ArrayList对象既有数组的特征，也有链表的特征。可以随时从链表中添加或删除一个元素。ArrayList实现了List接口。

大家知道，数组是静态的，数组被初始化之后，数组长度就不能再改变了。ArrayList是可以动态改变大小的。那么，什么时候使用Array（数组），什么时候使用ArrayList?答案是：当我们不知道到底有多少个数据元素的时候，就可使用ArrayList；如果知道数据集合有多少个元素，就用数组。

2.下面是总结了一些比较常用的ArrayList类成员方法：

增加元素到集合中
    boolean add(Element e)
    增加指定元素到列表尾部.
    void add(int index, Element e)
    增加指定元素到列表指定位置.

从列表中删除元素
    void clear()
    从列表中删除所有元素.
    E remove(int index)
    删除列表中指定位置的元素.
    protected void removeRange(int start, int end)
    删除列表中从某一个位置开始到某一个位置结束的元素。

获取链表中的元素
    E get(int index)
    获取链表中指定位置处的元素.
    Object[] toArray()
    获取一个数组，数组中所有元素是列表中的元素.（即将列表转换为一个数组）

修改某个元素
    E set(int index, E element)
    将列表中指定位置上的元素替换成新元素。

搜索元素
    boolean contains(Object o)
    如果列表包含指定元素，返回true.
    int indexOf(Object o)
    返回元素在链表中第一次出现的位置，如果返回-1，表示列表中没有这个元素。
    int lastIndexOf(Object o)
    返回元素在列表中最后一次出现的位置，如果返回-1，表示列表中没有这个元素。

检查链表是否为空
    boolean isEmpty()
    返回true表示列表中没有任何元素.

获取列表大小
    int size()
    返回列表长度（链表包含元素的个数）

以上是ArrayList类中使用比较多的成员方法。每个方法的更详细的说明或其它没有提及到的方法，读者可以参考java官方api

3.代码来实现一下:

public class Test {

    public static void main(String args[]) {
        // 创建一个空的list集合
        ArrayList list = new ArrayList();

        // 增加元素到list对象中
        list.add("a");
        list.add("b");
        list.add(2, "c"); // 此条语句将会把“c”字符串增加到list的第3个位置。
        list.add("d");

        // 通过元素找索引
        int index = list.indexOf("b");
        System.out.println("index = " + index);

        // 检查集合是否为空
        boolean check = list.isEmpty();
        System.out.println(check);

        // 获取集合的大小
        int size = list.size();
        System.out.println(size);

        // 检查集合中是否包含某元素
        boolean b1 = list.contains("b");
        System.out.println(element);

        // 获取指定位置上的元素
        String index = list.get(0);
        System.out.println(index);

        // 遍历arraylist中的元素

        // 使用迭代器
        // hasNext(): 返回true表示集合中还有元素
        // next(): 返回下一个元素
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
        System.out.println(list);
        }

        // 替换元素
        list.set(1, "Newa");
        System.out.println(list);

        // 移除元素
        // 移除第0个位置上的元素
        list.remove(0);

        // 移除第一次找到的 "b"元素
        list.remove("b");

        System.out.println(list);

        // 转换 ArrayList 为 Array
        // 集合转为数组
        String[] simpleArray = list.toArray(new String[list.size()]);
        System.out.println(Arrays.toString(simpleArray));
    }
}

三.LinkedList集合

LinkedList也和ArrayList一样实现了List接口，但是它执行插入和删除操作时比ArrayList更加高效，因为它是基于链表的。基于链表也决定了它在随机访问方面要比ArrayList逊色一点。
1.一些常用方法

LinkedList linkedList = new LinkedList();
        // 添加元素
        linkedList.add("a");
        linkedList.add("b");
        linkedList.add("c");

        // 从集合 头 和 集合 尾 进行添加
        linkedList.addFirst("d");
        linkedList.addLast("e");
        System.out.println(linkedList);
        // 获取 集合第一个值 和 集合最后一个值
        System.out.println(linkedList.getFirst());
        System.out.println(linkedList.getLast());
        // 获取指定位置的元素
        Object object = linkedList.get(1);
        System.out.println(object);

2.查找元素

LinkedList List = new LinkedList();  
    List.add("1");  
    List.add("2");  
    List.add("3");  
    List.add("4");  
    List.add("5");  
    List.add("2");  
    // 根据索引查找元素
    System.out.println(lList.indexOf("2"));  
    // 查找集合的最后一位元素
    System.out.println(lList.lastIndexOf("2"));  

3.替换元素

LinkedList List = new LinkedList();  
    List.add("1");  
    List.add("2");  
    List.add("3");  
    List.add("4");  
    List.add("5");  
    System.out.println(lList);  
    lList.set(3, "a");//使用set方法替换元素，方法的第一个参数是元素索引，后一个是替换值  
    System.out.println(lList);  

4.利用LinkedList 模拟栈的 出栈 和 入栈
首先知道栈和队列的区别
// 入栈就是添加 出栈 删除
// 栈和队列 什么是栈 和 什么是队列
// 栈结构 : 先入后出(main函数最后弹栈 程序结束)
// 队列结果: 先入先出(比如排队买早点 先买先走)

        // 模拟栈的 入栈 和 出栈
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.addFirst("a");
        linkedList.addFirst("b");
        linkedList.addFirst("c");
        while (!linkedList.isEmpty()) {
            System.out.println(linkedList.removeFirst());
        }

        // 模拟队列的 入栈 和 出栈
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.addFirst("a");
        linkedList.addFirst("b");
        linkedList.addFirst("c");
        while (!linkedList.isEmpty()) {
            System.out.println(linkedList.removeLast());
        }

四.总结

数组实现 ArrayList
特点:查询快 增删慢
查询: 依赖下标查询
增删: 把要插入位置后面的所有元素 向后移一位
(或者删除时 向前移一位)
数组在创建时 默认有10个位置 当要保存11个值时
系统会自动创建一个新数组 长度为原来数组长度1.5倍

链表实现 LinkedList
特点:查询慢 增删快
1.链表中的元素 保存了上一个元素和下一个元素的地址
通过这个地址 可以找到上一个元素 和 下一个元素
2.在进行查找的时候 先判断出 要查找的元素 距离头近还是尾近
3.例如头近 就从头位置 一个一个向下查询(通过保存的地址)
4.增删时 直接找到插入的位置 重新保存下 上一个元素 和下一个元素的地址 就可以

什么时候使用 ArrayList和LinkedList?

功能是 查询多(建议用ArrayList)
还是增删多(建议用LinkedList)

五.练习

1.遍历集合(使用迭代器) 如果数组中 有”b”这个元素 就添加”s”这个元素

// 创建集合
List<String> list = new ArrayList<>();
// 添加元素
        list.add("a");
        list.add("b");
        list.add("c");
        // 用List独有的迭代器
        ListIterator<String> listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            if (listIterator.next().equals("b")) {
                listIterator.add("s");
            }
        }
        System.out.println(list);

结果

[a, b, s, c]

2.在集合中存储 a a a b b c c 要求 去除重复元素

ArrayList arrayList = new ArrayList();

        arrayList.add("a");
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("b");
        arrayList.add("c");
        arrayList.add("c");
        //创建新集合
        ArrayList arrayList2 = new ArrayList();
        // 遍历原集合
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()) {
            // 取出每一个元素
            Object next = iterator.next();
            // 判断包不包括
            if (!arrayList2.contains(next)) {
                // 不包括就添加进去新集合里
                arrayList2.add(next);
            }

        }
        System.out.println(arrayList2);

结果

[a, b, c]