Java学习笔记===》15.List集合

List系列集合

1.List系列集合的特点

2.List集合的特有方法

★Collection的方法都继承了

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

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

package com_06Gather._01gatherStructure;

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

public class CollectionTest06_List {
    public static void main(String[] args) {
/*
| 方法名称                    | 说明                                                 |
| --------------------------- | ---------------------------------------------------- |
| void add（int index , E e） | 在此集合中的指定位置插入指定的元素（默认添加在末尾） |
| E remove(int index)         | 删除指定索引处的元素，返回被删除的元素               |
| E set(int index , E e)      | 修改指定索引处的元素，返回被修改的元素               |
| E get(int index)            | 返回指定索引处的元素                                 |
 */
        //1.创建一个集合
        List<Student> list = new ArrayList<>();

        //2.void add（int index , E e） | 在此集合中的指定位置插入指定的元素（默认添加在末尾）
        list.add(0,new Student("zhangsan",11));     //在0索引处添加Student对象
        list.add(1,new Student("lisi",22));     //在1索引处添加Student对象
        //细节：如果这个索引处本来就有元素，那么继续在此索引处添加元素，原来的元素会依次往后移动
        list.add(1,new Student("wangwu",23));
        list.add(new Student("xiaohuihui",23));     //不设置索引默认添加在末尾）
        System.out.println(list);


        //3.Evremove(int index)         | 删除指定索引处的元素，返回被删除的元素
        Student remove = list.remove(2);//返回被删除的元素
        System.out.println(remove);
        System.out.println(list);

        //4.E set(int index , E e)      | 修改指定索引处的元素，返回被修改的元素
        Student set = list.set(1, new Student("xiaoshishi", 18));   //返回被修改的元素
        System.out.println(set);	//返回的是修改之前的元素
        System.out.println(list);

        //5.E get(int index)            | 返回指定索引处的元素
        Student stu = list.get(2);
        System.out.println(stu);
    }
}

3.List系列集合中两个删除的方法

public class test{
    public stativ void main(String [] args){}
//List系列集合中两个删除的方法
//1.直接删除元素
//2.通过索引进行删除

//1.创建集合并添加元素
List<Integer> list = new ArraysList<>();

list.add(1);
list.add(2);
list.add(3);

//2.删除元素
//请问：此时要删除的 是 1 这个元素，还是1索引上的元素
//其实删除的是1索引上的元素
//因为在调用方法的时候，如果方法出现了重载现象
//优先调用，实参和形参一致的哪个方法

list.remove(1);  //删除的是1索引的元素

//如果要删除1这个元素，就要进行手动装箱，变成Integer类型
Integer i= Integer.valueOf(1);

list.remove(i);  //此时删除的就是1这个元素
	}
}

4.List集合独有的遍历方式

①迭代器遍历

②列表迭代器遍历

③增强for遍历

④Lambda表达式遍历

⑤普通for循环（因为List集合中存在索引）

package com_06Gather._01gatherStructure;

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

public class CollectionTest07_List {
    public static void main(String[] args) {
/*
 ①迭代器遍历
 ②列表迭代器遍历
 ③增强for遍历
 ④Lambda表达式遍历
 ⑤普通for循环（因为List集合中存在索引）
*/
        //创建集合并添加元素
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");

        //1.迭代器遍历
        //获取迭代器对象
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String str1 = it.next();
            System.out.print(str1 + ", ");
        }

        System.out.println();
        System.out.println("-------------------------------------------------");

        //2.增强for循环遍历
        //变量str就是一个第三方变量，在循环的过程中，以此表示集合中的每一个元素
        for (String str2 : list) {
            System.out.print(str2 + ", ");
        }

        System.out.println();
        System.out.println("-------------------------------------------------");

        //3.Lambda表达式遍历
        list.forEach(str3 -> System.out.print(str3 + ", "));

        System.out.println();
        System.out.println("-------------------------------------------------");

        //4.普通for循环遍历
        for (int i = 0; i < list.size(); i++) {
            //i:依次表示结合中的每一个索引
            String str4 = list.get(i);
            System.out.print(str4 + ", ");
        }

        System.out.println();
        System.out.println("-------------------------------------------------");


        //5.列表迭代器遍历
        //获取一个列表迭代器的对象,里面的指针默认指向0索引
        //在迭代器的基础上额外添加了一个方法：在遍历的过程中可以添加元素
        ListIterator<String> lit = list.listIterator();
        while(lit.hasNext()){
            String str5 = lit.next();
            if ("bbb".equals(str5)){
                lit.add("qqq");
            }
            
        }
        System.out.print(list);
    }
}

5.五种遍历方式对比

★迭代器遍历：在遍历的过程中需要删除元素，请使用迭代器

★列表迭代器：在遍历的过程需要添加元素，请使用列表迭代器

★增强for遍历：仅仅想遍历，那么使用增强for或Lambda表达式

★Lambda表达式：仅仅想遍历，那么使用增强for或Lambda表达式

★普通for：如果在比哪里的时候想要操作索引，可以使用普通for

6.ArraysList集合

（1）底层原理：

①ArraysList底层是数据结构的，

②利用空参创建的集合，在底层会创建一个默认长度为0的数组（数组的名字叫做elementData）

③添加第一个元素时，底层会场建一个新的长度为10的数组（数组的名字叫做elementData）

④当数组存满时，数组会扩容1.5倍，也就是创建一个新的数组长度是原来的1.5倍，并将数据拷贝到新的数组中

⑤如果一次添加多个元素，1.5被的数组也放不下，则新创建的数组的长度以实际为准

//空参构造
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

//elementData  就是一个最开始的数组的名称
transient Object[] elementData; // non-private to simplify nested class access

//DEFAULTCAPACITY_EMPTY_ELEMENTDATA;的实质就是一个长度为0的数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

（2） ArraysList添加第一个数据的底层原理

（3）ArraysList添加第十一个数据（开始扩容）的底层原理

7.LinkedList集合

★LinkedList集合底层就是双向链表，查询慢增删快，但是如果操作的是首尾元素，速度也是极快的

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

（1）LinkedList独有的方法

特有方法	说明
public void addFirst(E e)	在该列表开头插入指定的元素
public void addLast(E e)	在该列表末尾插入指定的元素
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表中的最后一个元素
public E removeFirst()	从此列表中删除并返回第一个元素
public E removeLast()	从此列表中删除并返回最后一个元素

（2）LinkedList底层原理

（3）迭代器的底层原理