java中List集合要点分析

最新推荐文章于 2024-11-04 22:26:34 发布

田北

最新推荐文章于 2024-11-04 22:26:34 发布

阅读量138

点赞数 7

文章标签： java list 开发语言

本文链接：https://blog.csdn.net/z122899/article/details/134967602

版权

List集合概念：
是一个容器,作用为存放多个数据,通常用来替代数组

特点

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

List , Set , Map都是接口

List的存储特点

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

List的常用实现类

ArrayList (常用)
- JDK1.2 底层数组实现查询快,增删慢线程不安全,效率高
LinkedList
- JDK1.2 底层链表实现查询慢,增删快线程不安全,效率高
Vector
- JDK1.0 底层数组实现都慢线程安全,效率低

创建

建议使用多态

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

常用方法

集合名.方法名(实参列表)

boolean add(元素): 往集合末尾添加一个元素
void add(下标, 元素): 将元素添加至指定下标位置
boolean addAll(集合名)：将指定集合元素添加至当前集合末尾
boolean addAll(下标，集合名)：将指定集合元素添加至当前集合指定下标位置
int size()：获取集合长度
元素 get(下标)：获取指定下标位置的元素
- 下标不可超出使用范围，否则报出下标越界异常
boolean contains(元素)：判断是否包含指定元素
boolean containsAll(集合名)：判断当前集合中是否包含指定集合的所有元素
下标 indexOf(元素)：获取指定元素第一次出现的下标
下标 lastIndexOf(元素)：获取指定元素最后一次出现的下标
boolean isEmpty()：判断集合元素是否为空，不可判比null值
被删除的元素 remove(下标):删除指定下标位置的元素
boolean remove(元素)：删除指定元素
- 如果集合元素为整数值，则会优先认定值为下标。所以删除整数值元素时只能通过下标删除
旧元素 set(下标，新元素)：将指定下标位置的值替换为新元素值
Object[] toArray()：将集合转换为数组

遍历

下标遍历

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();

迭代器遍历

获取集合的迭代器：集合名.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();

外遍历forEach

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

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

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

自遍历forEach

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

list.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 + "  "));

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

泛型

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

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

使用

存放类型为基本类型时，需要将泛型类型声明为对应包装类型
前后泛型声明必须一致
前边泛型不可省略

后边泛型<>内容可省

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+"  "));
        
    }
}