Chp12-List集合

List集合

概念：是一个容器，作用为存放多个数据，通常用来替代数组。
特点：

1. 只能存放引用类型
2. 所有集合都来自java.util包

List，Set，Map都是接口

List的存储特点

有序，有下标，元素可以重复

List的常用实现类

1. Arraylist（常用）

• JDK1.2 底层数组实现 查询快，增删慢 线程不安全，效率高

2. LinkedList

• JDK1.2 底层链表实现 查询慢，增删快 线程不安全，效率高

3. Vector

• JDK1.0 底层数组实现 都慢 线程安全，效率低

创建

• 建议使用多态

List 集合名=new 实现类();

• 集合名.方法名（实参列表）

1. boolean add（元素）：往集合末尾添加一个元素
2. void add（下标，元素）：将元素添加至指定下标位置
3. boolean addAll（集合名）：将指定集合元素添加至当前集合末尾
4. boolean addAll（下标，集合名）：将指定集合元素添加至当前集合指定下标位置
5. int size（）：获取集合长度
6. 元素 get（下标）：获取指定下标位置的元素

• 下标不可超出使用范围，否则报出下标越界异常

7. boolean contains（元素）:判断是否包含指定元素
8. boolean containsAll（集合名）：判断当前集合中是否包含指定集合的所有元素
9. 下标 indexOf（元素）：获取指定元素第一次出现的下标
10. 下标 lastIndexof（元素）：获取指定元素最后一次出现的下标
11. boolean isEmpty（）：判断集合元素是否为空，不可判比null值
12. 被删除的元素 remove（下标）：删除指定下标位置元素
13. boolean remove（元素）：删除指定元素

• 如果集合元素为整数值，则会优先认定值为下标。所以删除整数值元素时只能通过下标删除

14. 旧元素 set（下标，新元素）将指定下标位置的值替换为新元素值
15. Object[] toArray（）：将集合转换为数组

遍历

1. 下标遍历

for(int i=0;i<集合名.size();i++){
       //通过集合名.get(i)的方式获取当前元素
   }

 List list = new ArrayList();
           list.add(10);
           list.add(20);
           list.add(30);
           list.add(40);
           list.add(50);
   
           //下标遍历
           for (int i = 0; i < list.size(); i++) {
               System.out.print(list.get(i)+" ");
           }
           System.out.println();

2. 迭代器遍历
   获取集合的迭代器：集合名.iterator
   操作迭代器：

• boolean hasNext（）：判断是否存在下一元素
• 元素 next（）：使指针后移一位，获取下一元素
  使用：
• 迭代过程中不可增删元素
• 一次迭代只能调用一次next方法，否则迭代与操作元素数量不一致

//获取迭代器
           Iterator it = list.iterator();
           //利用循环操作迭代器
           while(it.hasNext()){
               Object o = it.next();
               if (o != null) {
                   System.out.print(o+"  ");
               }
           }
           System.out.println();

3. 外遍历forEach

for(数据类型 元素名:集合名){
       //元素名就代表正在被遍历的元素
   }

 for (Object o : list) {
               System.out.print(o+"  ");
           }
           System.out.println();

• 遍历器过程中无法增删元素
• JDK5.0

4. 自遍历

• JDK8.0
• 集合名.forEach(Consumer接口实现类对象）

ist.forEach(new Consumer() {
               @Override
               public void accept(Object o) {
                   //参数o就表示当前元素
                   System.out.print(o+"  ");
               }
           });
           System.out.println();
           //自遍历forEach-lambda
           list.forEach(o -> System.out.print(o + "  "));

• 由于创建Cionsumer实现类对象的匿名内部类也是局部内部类，所以无法使用累加器和标识变量

泛型

• 用于集合：约束集合可存放的数据类型

List<泛型类型> 集合名=new 实现类名<泛型类型>();

使用

1. 存放类型为基本类型时，需要将泛型类型声明为对应包装类型
2. 前后泛型声明必须一致
3. 前边泛型不可省略
4. 后边泛型<>内容可省

  List<泛型类型> 集合名=new 实现类名<>();

package com.by.test;

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

public class Test4 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
       /* list.add(5.5);
        list.add("abc");*/
        //四种遍历方式
        //下标遍历
        for (int i = 0; i < list.size(); i++) {
            //接收当前元素
            Integer n = list.get(i);
            System.out.print(n+"  ");
        }
        System.out.println();
        //迭代器遍历
        Iterator<Integer> it = list.iterator();
        while (it.hasNext()) {
            Integer n = it.next();
            System.out.print(n+"  ");
        }
        System.out.println();
        //外遍历
        for (Integer i : list) {
            System.out.print(i+"  ");
        }
        System.out.println();
        //自遍历
        list.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer i) {
                System.out.print(i+"  ");
            }
        });
        System.out.println();
        //lambda
        list.forEach(i-> System.out.print(i+"  "));
        
    }
}

今日掌握

1. 集合的特点
2. List的存储特点
3. List的常用实现类和特点
4. List的遍历方式
5. 泛型在集合创建中的作用