Java集合—List系列集合

18.3 List系列集合

List集合特点：

• 有序：存和取的顺序是一致的
• 有索引：可以通过索引操作元素
• 可重复：存储的元素可以重复

List集合中的特有方法

• Collection的方法List都继承了

  （Collection中的方法List都可以用）

• List集合因为有索引，多以多了很多索引操作的方法

List系列集合独有的方法：

方法名称	说明
void add(int index , E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索引处的元素

public class ListTest01 {
    public static void main(String[] args) {
        // 创建集合
        // 因为List为接口，不能直接创建对象，因此创建实现类的对象
        List<String> list = new ArrayList<>();
        // 添加元素
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        System.out.println(list);//[aaa, bbb, ccc]

        //1.在此集合中的指定位置插入指定的元素
        //原来的元素会依次往后移动。
        list.add(1,"AAA");
        System.out.println(list);//[aaa, AAA, bbb, ccc]

        // 2.删除指定索引处的元素，返回被删除的元素
        String remove = list.remove(0);
        System.out.println(remove);//aaa
        System.out.println(list);//[AAA, bbb, ccc]

        // 3.修改指定索引处的元素，返回被修改的元素
        String res = list.set(1, "BBB");
        System.out.println(res);//bbb
        System.out.println(list);//[AAA, BBB, ccc]

        //4.返回指定索引处的元素
        String s = list.get(2);
        System.out.println(s);//ccc
    }
}

注意：remove删除方法，如下：

public class ListRemove {
    public static void main(String[] args) {
        //1. 创建集合并添加元素
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        System.out.println(list);//[1, 2]

        //2.删除元素
        //请问：此时删除的是1这个元素，还是1索引上的元素？为什么？
        //因为在调用方法的时候，如果方法出现了重载现象
        //优先调用，实参跟形参类型一致的那个方法。
        // list.remove(1);//删除的是1索引上的元素
        //System.out.println(list);//[1]

        // 如果要删除1这个元素，而不是1索引上的元素
        //需要手动装箱，手动把基本数据类型的1，变成Integer类型
        Integer integer = Integer.valueOf(1);
        list.remove(integer);
        System.out.println(list);//[2]

    }
}

18.4List集合遍历方式

五种遍历方式：

• 迭代器遍历
• 增强for遍历
• Lambda表达式遍历
• 列表迭代器
• 普通for循环

五种遍历方式区别：

• 迭代器遍历：在遍历过程中要删除元素，使用迭代器
• 列表迭代器：在遍历过程中需要添加元素，使用列表迭代器
• 增强for和Lambda表达式：仅想遍历，就使用这俩
• 普通for:遍历时想操作索引，用普通for遍历

public class ListBianli {
    public static void main(String[] args) {
        // 创建集合并添加元素
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        // 1.迭代器遍历
        Iterator<String> it  = list.iterator();
        while (it.hasNext()){
            String str = it.next();
            System.out.println(str);//aaa bbb ccc
        }

        // 2.增强for遍历
        // s:表示第三方变量而已，循环中，依次表示集合中的每一个元素
        for (String s : list) {
            System.out.println(s);//aaa bbb ccc
        }

        //3.Lambda表达式
        //forEach方法的底层其实就是一个循环遍历，依次得到集合中的每一个元素
        //并把每一个元素传递给下面的accept方法
        //accept方法的形参s，依次表示集合中的每一个元素
        list.forEach(s-> System.out.println(s));

        // 4.普通for循环
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);//aaa bbb ccc
        }
       
        // 5.迭代器遍历
        //获取迭代器对象，里面指针默认指向0索引
        //另外，listIterator迭代器额外添加了一个方法，可以在遍历过程中添加元素
        ListIterator<String> itList = list.listIterator();
        while (itList.hasNext()){
            String s = itList.next();
            if("bbb".equals(s)){
                itList.add("BBB");
            }
            System.out.println(s);//aaa bbb ccc
        }
        System.out.println(list);//[aaa, bbb, BBB, ccc]

    }
}

18.5LinkedList集合

• 底层数据结构是双链表，查询慢，增删块，但是如果操作的是首尾元素，速度极快。

• LinkedList本身多了很多直接操作首尾元素的特有的API

LinkedList常用方法

方法名	说明
void addFirst(Object o)	在列表的首部添加元素
void addLast(Object o)	在列表的末尾添加元素
Object getFirst()	返回列表中的第一个元素
Object getLast()	返回列表中的最后一个元素
Object removeFirst()	删除并返回列表中的第一个元素
Object removeLast()	删除并返回列表中的最后一个元素

同List系列中的方法（即 List中的方法都可以用），加上LinkedList独有的方法....

18.6ArrayList集合

集合概述：

• 集合可以直接存储引用数据类型，不能直接存储基本数据类型，如果要存储基本数据类型，需要将基本数据类型变成对应的包装类再存储在集合里面。

• 集合可根据存储的内容的长度 自动扩容，即集合长度可变。

方法名	说明
boolean add(E e)	添加元素，返回值true添加成功
void add(int index , Object obj)
Boolean remove（E e）	删除指定元素，返回值表示是否删除成功
E remove（int index ）	删除指定索引元素，返回被删除的元素
E set(int index ，E e)	修改指定索引下的元素，返回原来的元素
E get ( int index)	获取指定索引的元素
int size()	集合长度，也就是集合中的元素个数
boolean contains(Object o)	判断列表中是否存在指定元素

public static void main(String[] args) {
        //< > 泛型：限定集合中存储数据的类型
        // 打印对象不是地址值，而是集合中存储数据内容
        //在展示的时候会拿[]把所有的数据进行包裹

        // 创建集合对象
        ArrayList<String> list  = new ArrayList<>();
        // 1.添加元素，返回值true添加成功
        boolean aa = list.add("aa");
        System.out.println(aa);//true
        list.add("bb");
        list.add("cc");
        list.add("dd");
        System.out.println(list);//[aa,bb,cc,dd]

        // 删除指定索引的元素,返回被删的元素
        String remove = list.remove(0);
        System.out.println(remove);//aa
        System.out.println(list);//[bb,cc,dd]

        // 删除指定元素，返回是否成功
        boolean remove1 = list.remove("bb");
        System.out.println(remove1);// true
        System.out.println(list);//[cc,dd]

        // 修改指定索引下的元素，返回原来的元素
        String s = list.set(0, "你好");
        System.out.println(s);//cc
        list.set(1,"张三");
        System.out.println(list);//[你好, 张三]

        // 查询元素
        String s1 = list.get(0);
        System.out.println(s1);//你好

        // 集合长度 list.size()
  			// 遍历集合
        for (int i = 0; i < list.size(); i++) {
          //i表示索引
        	//list.get(i)表示元素
            String s2 = list.get(i);
            System.out.println(s2);// 你好  张三
        }
 }