[学习笔记]Java集合框架之List集合

List集合详解
最新推荐文章于 2025-09-24 22:35:00 发布
原创 最新推荐文章于 2025-09-24 22:35:00 发布 · 746 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #集合

本文详细介绍了List集合的特点、继承关系及其实现类，包括ArrayList、LinkedList和Vector等，并提供了丰富的示例代码来展示如何使用这些集合。

List集合

特点

  • List集合支持修改方法，该方法Collection不具备。
  • List集合中元素按存取顺序存储，即保持存取顺序。
  • List集合是自带索引的，所以除了迭代器获取元素方法外，还可以使用遍历+get(int index)方法来获取元素。
  • List集合元素可重复。

继承关系

Collection
    |--List
        |--ArrayList：数组结构，非线程安全，查询较快，增删较慢。
        |--LinkedList：双向链表结构，非线程安全，增删较快，查询较慢（按序号索引数据需要进行向前或向后遍历）。
        |--Vector：数组结构，线程安全，效率较低，已被ArrayList替代。
            |--Stack：栈

常用方法

  1. 插入元素
    void  add(int index, E element)
    boolean  addAll(int index, Collection<? extends E> c)
  2. 按索引获取元素
    E  get(int index)
  3. 获取指定元素的索引
    int  indexOf(Object o)
    int  lastIndexOf(Object o)
  4. 获取ListIterator迭代器
    ListIterator<E>  listIterator()
  5. 按索引删除元素
    E  remove(int index)
  6. 修改元素
    E  set(int index, E element)
  7. 对元素排序，需要元素实现Comparator接口以具有可比性
    default void  sort(Comparator<? super E> c)
  8. 按索引获取子集合
    List<E>  subList(int fromIndex, int toIndex)

示例

Person.java
package bean;
 
public class Person {
  private String name;
  private int age;
 
  public Person(String name, int age) {
    super();
    this.name = name;
    this.age = age;
  }
 
  @Override
  public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + age;
    result = prime * result + ((name == null) ? 0 : name .hashCode());
    return result;
  }
 
  @Override
  public boolean equals(Object obj ) {
    if (this == obj) return true ;
    if (obj == null) return false;
    if (getClass() != obj.getClass()) return false ;
    Person other = (Person) obj;
    if (age != other.age) return false;
    if (name == null) {
      if (other.name != null) return false;
    } else if (!name.equals(other.name)) return false;
    return true;
  }
 
  @Override
  public String toString() {
    return "Person [name=" + name + ", age=" + age + "]" ;
  }
 
}
ListDemo.java
package Collection;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
import bean.Person;
 
public class ListDemo {
 
  public static void main(String[] args) {
    List<Person> list = new ArrayList<Person>();
    list.add(new Person( "Jacob" , 25));
    list.add(new Person( "Meteor" , 24));
    list.add(new Person( "Rose" , 23));
    list.add(new Person( "Jacob" , 25));
    // 判断重复，取决于元素类型中的equals()方法，并非是对象的引用是否一致。
 
    printList(list );
 
    // 1. 添加元素。
    list.add(new Person( "Jacob" , 25));
 
    // 2. 插入元素。
    list.add(2, new Person( "hanlin" , 26));
 
    // 3. 删除元素。
    list.remove(4); // throws IndexOutOfBoundsException
 
    // 4. 修改元素。
    list.set(1, new Person( "Jacoblx" , 25));
 
    printList(list );
    removeSameElements(list );
    printList(list );
  }
 
  public static void removeSameElements(List<Person> list ) {
    /*
     * 移除集合中的重复元素。
     * 额外建立一个集合，将不重复的元素放到这个集合中，然后原集合清空并将该集合元素再全部加入到原集合中即可。
     */
    List<Person> single = new ArrayList<Person>();
    for (Iterator<Person> it = list.iterator(); it .hasNext();) {
      Person temp = it.next();
      if (!single.contains( temp)) {
        single.add( temp);
      }
    }
    list.clear();
    list.addAll(single);
  }
 
  private static void printList(List<Person> list) {
    for (Person person : list) {
      System.out.println( person);
    }
    System.out.println( "-----------------------" );
  }
 
}

运行结果

Person [name=Jacob, age=25]
Person [name=Meteor, age=24]
Person [name=Rose, age=23]
Person [name=Jacob, age=25]
-----------------------
Person [name=Jacob, age=25]
Person [name=Jacoblx, age=25]
Person [name=hanlin, age=26]
Person [name=Rose, age=23]
Person [name=Jacob, age=25]
-----------------------
Person [name=Jacob, age=25]
Person [name=Jacoblx, age=25]
Person [name=hanlin, age=26]
Person [name=Rose, age=23]
-----------------------

非迭代器遍历

List c = new ArrayList ();
b = c.add( "Java1");
b = c.add( "Java2");
b = c.add( "Java3");
   
for (int i = 0; i < c.size(); i++) {
  String str = (String) c.get( i);
  System.out.println( str + " ");
}

ListIterator迭代器

常用方法

  1. 添加元素
    void  add(E e)
  2. 判断集合中是否有下一个元素
    boolean  hasNext()
  3. 判断集合中是否有上一个元素
    boolean  hasPrevious()
  4. 获取下一个元素
    E  next()
  5. 获取下一个元素的索引
    int  nextIndex()
  6. 获取上一个元素
    E  previous()
  7. 获取上一个元素的索引
    int  previousIndex()
  8. 移除元素
    void  remove()
  9. 修改元素
    void  set(E e)

注意

  • Iterator迭代器中只有获取方法，没有增删改方法。而ListIterator支持增删改操作，并支持向前遍历。
  • 在迭代过程中，使用了集合的方法对元素进行操作，导致迭代器并不知道集合中的变化，引发数据的不确定性。
    例如
     
    for (Iterator it = list.iterator(); it.hasNext();) {
      if ("heima2".equals(it.next())) {
        list.add("java");
      }
    }
    报java.util.ConcurrentModificationException异常。
    所以在迭代时，不要使用集合的方法操作元素，可以使用迭代器的方法操作。ListIterator支持增删改可以解决该问题。
    注意：该列表迭代器只有List接口有，而且这个迭代器可以完成在迭代过程中的增删改查动作。
  • 迭代过程中，增删改动作最多只能有1个，不可以两个同时进行。否则迭代器迭代序列可能出错，报java.lang.IllegalStateException异常。

示例

package collection;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
 
public class List_ListIterator {
 
  public static void main(String[] args) {
    List<String> list = new ArrayList<String>();
    list.add("Java1");
    list.add("Java3");
    list.add("Java2");
 
    for (ListIterator<String> it = list.listIterator(); it.hasNext();) {
      if ("Java3".equals( it.next())) {
        it.add( "java");
        // it.remove();
        // it.set("Hello");
        // 可以增删改查，但是不可两者同时。否则报java.lang.IllegalStateException异常
      }
    }
    printList(list );
  }
 
  public static void printList(List<String> list) {
    for (Iterator<String> it = list.iterator(); it.hasNext();) {
      System.out.println( it.next());
    }
  }
}

ArrayList集合

特点

是List接口的实现类，用以替代Vector集合，并且具有比后者更高的效率，但是不保证线程安全。

注意

  • List是接口，ArrayList是实现类。
  • 一般使用多态的方式创建集合，如：
    List<E> list = new ArrayList<E>();
    这样使得集合具有更高的适用性。

LinkedList集合

特点

  • 是List接口的实现类，双向链表结构，所以增删效率较高，可以用以实现队列或栈的数据结构。
  • LinkedList动作特点均可以围绕头和尾展开。

队列实现

特点是先进先出FIFO数据结构，可以选择头插尾取，也可以选择尾插头取。
package collection.structure;
 
import java.util.LinkedList;
import java.util.ListIterator;
 
public class Queue<E> {
  private LinkedList<E> link;
 
  public Queue() {
    link = new LinkedList<E>();
  }
 
  public boolean isEmpty() {
    return link.isEmpty();
  }
 
  public void print() {
    for (ListIterator<E> it = link.listIterator(link .size()); it .hasPrevious();) {
      System.out.println( it.previous());
    }
  }
 
  public void enQueue(E obj) {
    link.addFirst( obj);
  }
 
  public E deQueue() {
    return link.removeLast();
  }
}

栈实现

特点是先进后出FILO数据结构，可以选择头插头取，也可以选择尾插尾取。
package collection.structure;
 
import java.util.LinkedList;
import java.util.ListIterator;
 
public class Stack<E> {
    private LinkedList<E> link;
 
    public Stack() {
        link = new LinkedList<E>();
    }
   
    public boolean isEmpty() {
        return link .isEmpty();
    }
   
    public void print() {
        for (ListIterator<E> it = link.listIterator(link .size()); it .hasPrevious();) {
            System. out.println(it .previous());
        }
    }
   
    public void push(E obj) {
        link.addFirst( obj);
    }
   
    public E pop() {
        return link.removeFirst ();
    }
}

程序调用

package collection;
 
import collection.structure.Queue;
import collection.structure.Stack;
 
public class List_LinkedList {
 
  public static void main(String[] args) {
 
    Queue<String> q = new Queue<String>();
    Stack<String> s = new Stack<String>();
    q.enQueue("q1");
    q.enQueue("q2");
    q.enQueue("q3");
    s.push("s1");
    s.push("s2");
    s.push("s3");
 
    System.out.println( "Queue:");
    while (! q.isEmpty()) {
      System.out.println( q.deQueue());
    }
    System.out.println( "------------------------");
 
    System.out.println( "Stack:");
    while (! s.isEmpty()) {
      System.out.println( s.pop());
    }
  }
}

运行结果

Queue:
q1
q2
q3
------------------------
Stack:
s3
s2
s1

Vector集合

示例

package collection;
 
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;
 
public class List_Vector {
 
  public static void main(String[] args) {
    Vector<String> v = new Vector<String>();
 
    // 添加元素
    v.addElement("java1");
    v.addElement("java2"); // 相当于无返回值的add(E e)
 
    // 获取元素
    String str1 = v.elementAt(1); // "java2"，相当于v.get(1);
    String str2 = v.firstElement(); // "java1"
    String str3 = v.lastElement(); // "java2"
 
    // 插入元素
    v.insertElementAt( "java", 1);
    // ["java1", "java", "java2"]，相当于add( int index, E element)
 
    // 移除元素
    v.removeElement( "java"); // 相当于remove(Object o)
    v.removeElementAt(1); // 相当于无返回值的remove( int index)
   
    // 修改元素
    v.setElementAt( "Hello Java", 0); // 相当于无返回值的set( int index, E element)
 
    // 使用枚举遍历元素
    for (Enumeration<String> en = v.elements(); en.hasMoreElements();) {
      System.out.println( "enumeration: " + en.nextElement());
    }
 
    for (Iterator<String> it = v.iterator(); it.hasNext();) {
      System.out.println( "iterator: " + it .next());
    }
 
    for (Object obj : v) {
      System.out.println( "foreach iterator: " + obj );
    }
  }
}

jacob各个版本集合
09-25
jacob各个版本的javadoc,dll，jar包含32位和64系统的
集合框架学习笔记
04-02
这篇学习笔记将深入探讨Java集合框架的基础概念、主要类库以及常见应用场景。 首先，Java集合框架分为两种基本类型：List（列表）和Set（集）。List接口代表有序的集合，允许重复元素，如ArrayList和LinkedList；而...
Java 集合框架，List，Set，Map学习笔记（自存）
Svjs_jkngs的博客
05-10 1141
解答：Java是面向对象的语言，所有的代码都必须写在类（class）里面。Java不像Python或C那样可以直接定义一个独立函数，函数（方法）必须属于某个类。是为了创建对象，以便调用containsDuplicate。
Java集合框架（Collection Framework）学习笔记
weixin_52528537的博客
09-24 1888
集合框架是Java中用于存储和操作一组对象的统一架构，它提供了：一系列接口（定义行为）多个实现类（具体数据结构）各种算法（排序、查找等）集合类添加删除查找备注ArrayListO(1)摊销O(n)O(1)动态数组LinkedListO(1)O(1)O(n)双向链表HashSetO(1)O(1)O(1)哈希表TreeSetO(log n)O(log n)O(log n)红黑树HashMapO(1)O(1)O(1)哈希表TreeMap。
学习笔记069——Java集合框架
code__bee的博客
12-14 1181
LinkedList 实现了链表的数据结构，“先进先出”，元素的存储空间是不连续的，随机分散在内存中的，元素和元素之间通过存储彼此的位置信息来形成连接关系，通过位置信息找到前后节点的关系。ArrayList 实现了长度可变的数组，可以在内存中分配连续的空间，底层是基于索引的数据结构，所以查询效率很高，缺点是添加或删除数据效率较低，需要完成元素的移动。优势是增删效率高，缺点是查询效率低，与 ArrayList 形成对比，它们的特性都是由于底层的存储结构决定的。
Java集合框架学习笔记：List和Set的实现类
2302_77756558的博客
09-13 867
在Java中，集合框架提供了处理对象数组的基本结构。Collection是Java集合框架的根接口，而List和Set是两个最常用的子接口。每个接口都有多个不同的实现类，这些类在功能、性能使用以及场景方面存在显着的差异。
【JAVA学习笔记】集合：List、Set、Map
weixin_48272591的博客
04-29 1964
Java 集合框架提供了丰富的数据存储与操作工具，数组与集合各有优势，需根据实际需求合理选择。List、Set、Map 等接口的实现类在增删改查等操作中各具特色，适用于不同场景。迭代器确保了集合遍历的安全性，Comparator 提供了灵活的排序方式，而泛型则大幅提升了代码的类型安全性和复用性。深入理解并熟练运用这些组件，能够帮助开发者编写出高效、稳定且易维护的 Java 程序。在实际项目中，巧妙结合这些技术，将有力提升软件开发的质量与效率。
Java 集合框架详解
mailangduoduo的博客
10-04 1643
在 Java 编程中，集合框架是一个非常重要的组成部分。它提供了一组用于存储和操作集合的接口和类，使得开发者能够更加高效地处理数据。本文将详细介绍 Java 集合框架的各个方面。接口：定义了各种集合的行为和操作，如CollectionListSetMap等。实现类：实现了接口中定义的方法，提供了具体的集合实现，如ArrayListLinkedListHashSetTreeSetHashMapTreeMap等。算法：提供了一些用于对集合进行操作的算法，如排序、搜索等。
JAVA学习笔记（十四）——集合框架
qq_53911368的博客
04-16 602
PS：Hashset集合默认不能对内容一样的两个不同对象去重复！（因为不同对象的哈希值一般不同），解决办法：重写hashCode和equals方法。经典代码：Map<String, Integer> m = new HashMap<>();PS：如何获取Map集合的Stream流？PS：流只能收集一次！
JavaSE学习笔记 Java集合框架以及Collection集合的学习
qq_41537102的博客
02-21 933
Java集合框架以及Collection集合的学习前言（案例引入集合概念）1.集合的由来2.Java集合的框架3.Collection接口常见方法 前言（案例引入集合概念） 案例演示：我有3个学生，请把这个学生的信息存储到数组中，并遍历数组，获得每一个学生信息。 下面是给定学生类的具体信息： 学生:Student 成员变量：name，age 构造方法：无参构造，有参构造 成员方法：get()以及set()方法 数组实现学生信息的存储： //Student学生类 public
Java集合框架
10-18 1198
本文主要介绍了Java集合框架，Java集合框架通过 Collection 和 Map 接口，为我们提供了多种数据结构的实现，以满足不同的需求。理解这些集合类型的特点和适用场景，能够帮助我们在实际开发中选择合适的数据结构，从而提高代码的效率和可维护性。
JAVA学习Java集合框架.pptx
11-21
JAVA集合框架学习笔记 JAVA集合框架是Java语言中提供的一种数据结构，用于存储和管理大量数据。它提供了多种接口和实现类，例如Collection、List、Map等，帮助开发者更方便地处理数据。 什么是异常？ 在Java中，...
Java编程基于面向对象与集合框架的核心技术解析：从基础语法到Stream流处理的系统化应用设计-学习笔记
最新发布
11-05
本文档系统地介绍了Java基础的核心知识点，涵盖数据类型、数组、面向对象编程（类与对象、封装、继承、多态）、static关键字、final常量、抽象类、接口、枚举、单例设计模式、异常处理机制、集合框架（List、Set、...
[学习笔记]Java集合框架以及Collection顶层接口
Jacob专栏
12-14 6751
集合框架 概述 数组容器由于无法扩展容量，也没有更多的功能可以使用，而Java中的另一种容器：集合，就能满足这些要求。 特点 集合中的每一个元素都是对象，存储的实际上是对象的引用。集合长度可扩展，并且是自动的。根据数据结构的不同，集合分为很多种，每一种都有各自的特点。集合的最上层是Collection接口，集合最基本的增删改查方法均在该接口中有所体现。集合中
[学习笔记]Java集合框架之Set集合
Jacob专栏
12-14 2678
Set集合 特点 Set集合中的元素是唯一的，不可重复（取决于hashCode和equals方法），也就是说具有唯一性。Set集合中元素不保证存取顺序，并不存在索引。 继承关系 Collection     |--Set：元素唯一，不保证存取顺序，只可以用迭代器获取元素。         |--HashSet：哈希表结构，非线程安全，查询速度较快。元素唯一性
[学习笔记]Java常用工具类
Jacob专栏
12-19 2652
工具类 1. 概述 工具类的出现是为了在不用创建对象的前提下更方便地使用一些固定的方法。 2. 特点 工具类的方法一般全是静态方法。工具类的使用一般直接用类名调用方法。Java 5以及更新版本中，可以使用静态导入，这样可以免除类名的输入。 Collections类 1. 概述 Collections类是集合框架中的一个工具类，用于操作集合对象，它的方法全都是静
[学习笔记]Java集合框架之Map集合
Jacob专栏
12-19 2248
Map集合 1. 概述 Map集合是一个接口，和Collection集合不同的是，它是双列集合，也就是说它所存储的是键值对。 2. 特点 Map集合存储的是键值对，其中键要求唯一。Map集合的键对应一个值，值不要求唯一，但是一个键不能对应对个值。Map集合没有Iterator迭代器，如果需要迭代需要转化为单列集合间接迭代。 3. 继承关系 Map   |--Has
[学习笔记]Java构造器和static关键字
Jacob专栏
12-08 2110
构造器（构造函数） 特点 1. 构造器的名字和类名相同。 2. 不用定义返回值类型。 3. 不可以写return语句。 作用 给对象进行初始化。 注意 1. 默认构造器的特点。 2. 多个构造器是以重载的形式存在的。 3. 注解类不可以有构造器。 4. 接口不可以有构造器。 this和sup
[学习笔记]Java多线程
Jacob专栏
12-12 1977
概述 1. 概念 进程：程序在一个数据集合上运行的过程，是系统进行资源分配的独立单位。 线程：是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 简而言之，进程是系统进行资源分配的最小单位，而线程是系统进行调度的最小单位。 2.
Java源码学习笔记：集合框架与小程序案例
标题中的“实验,java程序源码,java集合源码笔记汇总”表明本文档是一份针对Java程序和Java集合框架源码的实验记录和学习笔记。这份文档可以作为学习Java编程语言，特别是Java集合框架的学习资源。 描述中提到的“几...
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值