List详解

List介绍

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

/*
* java.util.list接口 extends Collection接口
* list接口的特点：
*   1.有序的集合，存储元素和取出元素的顺序是一致的（存储123 取出123）
*   2.有索引，包含了一些带索引的方法
*   3.允许存储重复的元素
* list接口中带索引的方法（特有）
*   1.public void add (int index,E element):将指定的元素，添加到指定位置
*   2.public E get(int index):返回集合中指定位置的元素
*   3.public E remove(int index):移除列表中指定位置的元素，返回的是被移除的元素
*   4.public E set(int index,E element):用指定元素替换集合中指定位置的元素，返回值是更新前的元素
* 注意：
*   操作索引的时候，一定要防止索引越界异常
*   IndexOutOfBoundsException:索引越界异常，集合会报
*   ArrayIndexOutOfBoundsException:数组索引越界异常
*   StringIndexOutOfBoundsException:字符串索引越界异常
* */
public class demo03List {
    public static void main(String[] args) {
        //创建一个list集合对像，多态
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        System.out.println(list);

        list.add(3,"itheima");
        System.out.println(list);

        String removeE = list.remove(2);
        System.out.println("被移除的元素："+removeE);
        System.out.println(list);

        String setE = list.set(0,"A");
        System.out.println("被替换的元素："+setE);
        System.out.println(list);

        //list集合遍历的三种方式
        //1.普通的for循环
        for (int i = 0; i < list.size(); i++) {
            String getE = list.get(i);
            System.out.print(getE+" ");
        }
        System.out.println();
        System.out.println("------------------------");
        //2.使用迭代器
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.print(s+" ");
        }
        System.out.println();
        System.out.println("------------------------");
        //3.使用增强for循环
        for (String s : list) {
            System.out.print(s+" ");
        }



    }
}

运行结果：

[a, b, c, d, e]
[a, b, c, itheima, d, e]
被移除的元素：c
[a, b, itheima, d, e]
被替换的元素：a
[A, b, itheima, d, e]
A b itheima d e 
------------------------
A b itheima d e 
------------------------
A b itheima d e 

ArrayList集合

1. 如果查询操作比较多，则建议使用ArrayList，因为它底层是数组结构，所以如果增删比较多，就不太适用，因为它地址是连续的，增删操作会非常慢。

LinkedList集合

1. 底层是一个链表结构：查询慢，但是增删快

2. 里边包含了大量操作首尾元素的方法

3. 注意：使用LinkedList，不能使用多态

4. 几个方法的实例：

   import java.util.LinkedList;
   public class Demo03LinkedList {
       public static void main(String[] args) {
          show01();
          show02();
           show03();
       }
   
       /*
       * public E removeFirst():移除并返回此列表的第一个元素
       * public E removeLast():移除并返回此列表的最后一个元素
       * public E pop():从列表所表示的堆栈处弹出一个元素，此方法相当于removeFirst
       * */
       private static void show03() {
           LinkedList<String> linkedList = new LinkedList<>();
           //使用add方法往集合中添加元素
           linkedList.add("张三");
           linkedList.add("李四");
           linkedList.add("王五");
           System.out.println("show03:");
           System.out.println(linkedList);
   
           System.out.println("被移除的第一个元素："+linkedList.pop());
           System.out.println("被移除的最后一个元素："+linkedList.removeLast());
       }
   
       /*
       * public E getFirst():返回列表的第一个元素
       * public E getLast():返回列表的最后一个元素
       * */
       private static void show02() {
           //创建LinkedList集合对象，不可使用多态
           LinkedList<String> linkedList = new LinkedList<>();
           //使用add方法往集合中添加元素
           linkedList.add("张三");
           linkedList.add("李四");
           linkedList.add("王五");
           System.out.println("show02:");
           System.out.println(linkedList);
   
           //清空集合中的元素，在获取集合中的元素的时候会抛出：java.util.NoSuchElementException
           //linkedList.clear();
   
           //public boolean isEmpty():如果列表不包含元素，则返回true
           if (!linkedList.isEmpty()) {
               System.out.println("获取第一个元素：" + linkedList.getFirst());
               System.out.println("获取最后一个元素：" + linkedList.getLast());
           }
       }
   
       /*
       * public void addFirst(E e):将指定元素插入此列表的开头
       * public void addLast(E e):将指定元素插入此列表的结尾
       * public void push(E e):将元素推入此列表所表示的堆栈
       * */
       private static void show01(){
           //创建LinkedList集合对象，不可使用多态
           LinkedList<String> linkedList = new LinkedList<>();
           //使用add方法往集合中添加元素
           linkedList.add("张三");
           linkedList.add("李四");
           linkedList.add("王五");
           System.out.println("show01:");
           System.out.println(linkedList);
   
           linkedList.addFirst("xiaobai");
           System.out.println("往列表头添加元素："+linkedList);
   
           linkedList.addLast("dabai");
           System.out.println("往集合结尾添加元素："+linkedList);
       }
   }
   
   

   运行结果：

   show01:
   [张三, 李四, 王五]
   往列表头添加元素：[xiaobai, 张三, 李四, 王五]
   往集合结尾添加元素：[xiaobai, 张三, 李四, 王五, dabai]
   show02:
   [张三, 李四, 王五]
   获取第一个元素：张三
   获取最后一个元素：王五
   show03:
   [张三, 李四, 王五]
   被移除的第一个元素：张三
   被移除的最后一个元素：王五
   

Vector集合

与上两种集合不同，它是单线程的，比较慢