Java集合之List集合_java list 多元-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_48281736/article/details/118226451

本文详细介绍了Java中List集合的特点及使用方法，包括ArrayList、Vector和LinkedList等实现类的区别与应用场景，并通过实例展示了如何进行添加、删除、遍历等操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Java集合之List集合

List子接口

特点：有序、有下标、元素可以重复。

方法：

void add(int index,Object o) //在index位置插入对象o

boolean addAll(int index,Collection c) //将一个集合中的元素添加到此集合中的index位置

Object get (int index) //返回集合中指定位置的元素

List subList (int fromIndex,int toIndex) //返回fromIndex 和toIndex之间的集合元素

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

/*
List子接口的使用
特点1.有序有下标2可以重复
 */
public class Demo01 {
    public static void main(String[] args){
        //先创建集合对象
        List list = new ArrayList<>();
        //添加元素
        list.add("苹果");
        list.add("小米");
        list.add(0,"华为");//在最前面添加
        System.out.println("元素个数:"+list.size());
        System.out.println(list.toString());
        //删除元素
        //list.remove("苹果");
        list.remove(0);
        System.out.println("删除之后"+list.size());
        System.out.println(list.toString());
        //遍历操作
        //使用for进行遍历
        System.out.println("=====使用for遍历=====");
        for(int i=0;i<list.size();i++)
        {
            System.out.println(list.get(i));
        }
        //使用增强for
        System.out.println("=====使用增强for=====");
        for (Object object:list) {
            System.out.println(object);
        }
        //使用迭代器
        System.out.println("=====使用迭代器=======");
        Iterator it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        //使用列表迭代器和Iterator的区别，ListIterator可以向前或向后遍历、添加、删除、修改元素
        System.out.println("=====使用列表迭代器从前往后=====");
        ListIterator lit = list.listIterator();
        while(lit.hasNext())
        {
            System.out.println(lit.nextIndex()+":"+lit.next());
        }
        System.out.println("=====使用列表迭代器从后往前=====");
        while(lit.hasPrevious())
        {
            System.out.println(lit.previousIndex()+":"+lit.previous());
        }
        //判断
        System.out.println(list.contains("苹果"));
        System.out.println(list.isEmpty());
        //获取位置
        System.out.println(list.indexOf("小米"));
    }
}
元素个数:3
[华为, 苹果, 小米]
删除之后2
[苹果, 小米]
=====使用for遍历=====
苹果
小米
=====使用增强for=====
苹果
小米
=====使用迭代器=======
苹果
小米
=====使用列表迭代器从前往后=====
0:苹果
1:小米
=====使用列表迭代器从后往前=====
1:小米
0:苹果
true
false
1

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

/**
 * List的使用
 */
public class Demo02 {
    public static void main(String[] args){
        //创建集合
        List list = new ArrayList<>();
        //1添加数字数据(隐含自动装箱)
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        list.add(60);
        System.out.println("元素个数:"+list.size());
        System.out.println(list.toString());
        //2删除操作
        //list.remove(20);//会出现错误 里面应该填写下标
        //list.remove(0);
        //如果要移除里面填写值则需以下操作
        list.remove((Object)20);//或者list.remove(new Integer(20));
        System.out.println("元素个数:"+list.size());
        System.out.println(list.toString());
        //3补充方法subList 返回子集合 含头不含尾
        List subList = list.subList(1,3);//1包含 3不包含
        System.out.println(subList.toString());
    }
}
元素个数:5
[20, 30, 40, 50, 60]
元素个数:4
[30, 40, 50, 60]
[40, 50]

List实现类

ArrayList 重点：

数组结构实现，查询快、增删慢

JDK1.2版本，运行效率快、线程不安全

Vector :（不怎么使用，有可能面试会遇到）

数据结构实现，铲鲟快、增删慢

JDK1.0版本，运行效率慢、线程安全

LinkedList :

链表结构实现，增删快，查询慢

import JavaCollection.Student;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
//学生类在前面的Collection中存在
/**
 * ArrayList的使用
 * 存储结构:数组，查找遍历速度快，增删慢
 */
public class Demo03 {
    public static void main(String[] args){
        //创建集合
        ArrayList arrayList = new ArrayList<>();
        //1添加元素
        Student s1 = new Student("刘德华",20);
        Student s2 = new Student("郭富城",22);
        Student s3 = new Student("梁朝伟",18);
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        System.out.println("元素个数:"+arrayList.size());
        System.out.println(arrayList.toString());
        //2删除元素
        arrayList.remove(s1);//下标或者元素
        System.out.println("删除之后元素个数:"+arrayList.size());
        //3遍历元素【重点】
        //3.1使用迭代器
        System.out.println("=====用迭代器=======");
        Iterator it = arrayList.iterator();
        while (it.hasNext()){
            Student s = (Student) it.next();
            System.out.println(s.toString());
        }
        //3.2列表迭代器
        System.out.println("======列表迭代器======");
        ListIterator lit = arrayList.listIterator();
        while (lit.hasNext()){
            Student s = (Student) lit.next();
            System.out.println(s.toString());
        }
        System.out.println("======逆序列表迭代器======");
        while(lit.hasPrevious()){
            Student s = (Student) lit.previous();
            System.out.println(s.toString());
        }
        //4判断
        System.out.println(arrayList.contains(s2));
        System.out.println(arrayList.isEmpty());
        //5查找
        System.out.println(arrayList.indexOf(s2));
    }
}
元素个数:3
[Student{name='刘德华', age=20}, Student{name='郭富城', age=22}, Student{name='梁朝伟', age=18}]
删除之后元素个数:2
=====用迭代器=======
Student{name='郭富城', age=22}
Student{name='梁朝伟', age=18}
======列表迭代器======
Student{name='郭富城', age=22}
Student{name='梁朝伟', age=18}
======逆序列表迭代器======
Student{name='梁朝伟', age=18}
Student{name='郭富城', age=22}
true
false
0

import java.util.Enumeration;
import java.util.Vector;

/**
 * 演示Vector集合的使用
 * 存储结构:数组
 */
public class DemoVector {
    public static void main(String[] args) {
        //创建集合
        Vector<Object> vector = new Vector<>();
        //添加元素
        vector.add("草莓");
        vector.add("芒果");
        vector.add("西瓜");
        System.out.println("元素个数是"+vector.size());
        //2删除
//        vector.remove("西瓜");
//        vector.remove(0);
//        vector.clear();
        //3遍历
        //使用枚举器  其他方法一样适用
        Enumeration en = vector.elements();
        while(en.hasMoreElements()){
            String str = (String)en.nextElement();
            System.out.println(str);
        }
        //4判断
        System.out.println(vector.contains("西瓜"));
        System.out.println(vector.isEmpty());
    }
}
元素个数是3
草莓
芒果
西瓜
true
false

LinkedList

链表结构实现，增删快，查询慢

import JavaCollection.Student;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;

/**
 * LinkedList的使用
 * 存储结构:双向链表
 */
public class DemoLinkedList {
    public static void main(String[] args) {
        //创建集合
        LinkedList linkedList= new LinkedList<>();
        //添加元素
        Student s1 = new Student("张三",20);
        Student s2 = new Student("张无忌",18);
        Student s3 = new Student("王二",22);
        linkedList.add(s1);
        linkedList.add(s2);
        linkedList.add(s3);
        System.out.println("元素个数个数"+linkedList.size());
        System.out.println(linkedList.toString());
        //2删除
        //linkedList.remove(s1);
        //System.out.println("删除之后个数"+linkedList.size());
        //linkedList.clear();

        //3遍历
        //3.1for遍历
        System.out.println("=====for=======");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.get(i));
        }
        //3.2增强for
        System.out.println("=====增强for====");
        for (Object object : linkedList){
            Student s = (Student)object;
            System.out.println(s.toString());
        }
        //3.3使用迭代器
        System.out.println("=====使用迭代器======");
        Iterator it = linkedList.iterator();
        while(it.hasNext()){
            Student s =(Student)it.next();
            System.out.println(s.toString());
        }
        System.out.println("=====使用列表迭代器=====");
        ListIterator lit = linkedList.listIterator();
        while(it.hasNext()){
            Student s =(Student)lit.next();
            System.out.println(s.toString());
        }
        //4判断
        System.out.println(linkedList.contains(s1));
        System.out.println(linkedList.isEmpty());
        //5获取
        System.out.println(linkedList.indexOf(s1));
    }
}
元素个数个数3
[Student{name='张三', age=20}, Student{name='张无忌', age=18}, Student{name='王二', age=22}]
=====for=======
Student{name='张三', age=20}
Student{name='张无忌', age=18}
Student{name='王二', age=22}
=====增强for====
Student{name='张三', age=20}
Student{name='张无忌', age=18}
Student{name='王二', age=22}
=====使用迭代器======
Student{name='张三', age=20}
Student{name='张无忌', age=18}
Student{name='王二', age=22}
=====使用列表迭代器=====
true
false
0

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nbQ6MZFZ-1624616791064)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\image-20210625182444017.png)]