Java中的List集合

最新推荐文章于 2024-04-05 18:29:42 发布
最新推荐文章于 2024-04-05 18:29:42 发布
阅读量1w 收藏 59
点赞数 7
分类专栏： java 文章标签： java list 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41571224/article/details/121990386
版权

List

2.1 List集合概述和特点

public interface List<E> extends Collection<E>

~List有序集合也称为序列。该界面的用户可以精确的控制列表中每个元素的插入位置。用户可以通过整数索引访问元素。并搜索列表中的元素。
~与Set集合不同，列表通常允许重复元素。
List集合特点：
有序：存储和取出的元素顺序一致；
可重复：存储的元素可以重复。

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

public class ListDemo {
    public static void main(String[] args) {
        List<String> l = new ArrayList<String>();
        l.add("hello");
        l.add("world");
        l.add("java");
        l.add("java");

        System.out.println(l);
        
        Iterator<String> it = l.iterator();
        while (it.hasNext()){
            String s = it.next()
            System.out.println(s);
        }
    }
}

2.2List集合特有方法

void add(int index,E element)在此集合中的指定位置插入指定的元素
E remove(int index)删除此集合中指定索引处的元素，返回被删除的元素
E set(int index,E element)修改指定索引处的元素，返回被修改的元素
E get(int index)返回指定索引处的元素

package daily_collection;

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

public class ListDemo02 {
    public static void main(String[] args) {
        List<String> l=new ArrayList<String>();
        l.add("hello");
        l.add("world");
        l.add("java");
        l.add("java");
        l.add(0,"oh");
        System.out.println(l.get(0));
        System.out.println(l.remove(0));
        System.out.println(l.get(0));
        System.out.println(l.set(0,"good"));
        System.out.println(l.get(0));
    }
}

循环遍历：

        for(int i=0;i<l.size();i++)
            System.out.println(l.get(i));

案例：List集合存储学生对象并遍历

需求：创建一个存储学生对象的集合，存储个学生对象，使用程序实现在控制台遍历该集合。
思路：
1.定义学生类
2.创建List集合对象
3.创建学生对象
4.把学生添加到集合
5.遍历集合（迭代器、for循环）

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

public class ListDemo03 {
    public static void main(String[] args) {
        List<Student> ls=new ArrayList<Student>();
        Student s1=new Student("AA",23);
        Student s2=new Student("BB",24);
        Student s3=new Student("CC",16);
        ls.add(s1);
        ls.add(s2);
        ls.add(s3);

        Iterator<Student> it=ls.iterator();
        while(it.hasNext()){
            Student ss=it.next();
            System.out.println(ss.getName()+"="+ss.getAge());
        }
        for (int i=0;i<ls.size();i++){
            Student s = ls.get(i);
            System.out.println(s.getName()+"-"+s.getAge());
        }
    }
}

2.3并发修改异常

通过迭代器获取next的值的时候，都会去判断预期修改值和实际修改值是否相等。如果不同，会抛出并发修改异常。

用for循环，get方法去获取要修改的值，然后使用list.add去修改。因为get方法中并没有判断的条件，所以就不会出发并发修改异常。

2.4ListIterator

ListIterator：列表迭代器
1.通过List集合的listIterator()方法得到，所以说它是List集合特有的迭代器。
2.该方法允许从任一方向遍历列表的列表迭代器，在迭代器修改列表，并获得列表中迭代器的当前位置。

ListIterator的常用方法：
1.E next()：返回迭代器中的下一个元素；
2.boolean hasNext()：如果迭代具有更多元素，则返回true；
3.E previous()：返回列表中的上一个元素；
4.boolean hasPrevious()：如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true；
5.void add(E e)：将指定的元素插入列表。

package daily_collection;

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

public class ListDemo04_listIterator {
    public static void main(String[] args) {
        List<String> l=new ArrayList<String>();
        l.add("hello");
        l.add("world");
        l.add("java");

        ListIterator<String> listit=l.listIterator();
        while(listit.hasNext()){
            String s = listit.next();
            System.out.println(s);
        }
        System.out.println("------------------------------");

        while (listit.hasPrevious()){
            String sp=listit.previous();
            System.out.println(sp);
        }
        System.out.println("------------------------------");
        ListIterator<String> listit2=l.listIterator();
        while (listit2.hasNext()){
            String s2 = listit2.next();
            if(s2.equals("world")){
                listit2.add("jjjjjj");
            }
        }
        System.out.println(l);
    }
}

输出结果：

hello
world
java
------------------------------
java
world
hello
------------------------------
[hello, world, jjjjjj, java]

notes：ListIterator里面的add方法会将实际修改值赋值给预期修改值，所以在迭代的next方法做判断的时候，不会出现并发异常。

2.5增强for循环

增强for：简化数组和Collection集合的遍历
1.实现Iterable接口的类允许其对象称为增强for语句的目标
2.它是JDK5之后出现的，其内部原理是一个Iterator迭代器
增强for的格式：

for(元素数据类型的变量名：数组或者Collection集合){
	//在此使用变量即可，该变量就是元素
}

示例：

int[] arr={1,2,3,4};
for(int i:arr){
	System.out.println(i);
}

package daily_collection;

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

public class ListDemo05_for {
    public static void main(String[] args) {
        int[] arr= {1,2,4,5};
        for (int i:arr){
            System.out.println(i);
        }
        System.out.println("-----------------");
        List<String> l=new ArrayList<String>();
        l.add("hello");
        l.add("world");
        l.add("java");
        for (String s:l){
            System.out.println(s);
        }
    }
}

案例：List集合存储学生对象用三种方式遍历

需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合
普通for循环（带有索引的遍历方式）
迭代器：集合特有的遍历方式
增强for循环（最方便）
思路：
1、定义学生类
2、创建List集合对象
3、创建学生对象
4、将学生添加到集合
5、遍历集合

package daily_collection;

public class Student {
    private String name;
    private int age;

    public Student(){
    }

    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}


package daily_collection;

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

public class ListDemo05_demo {
    public static void main(String[] args) {
        List<Student> l=new ArrayList<Student>();
        Student s1=new Student("A",1);
        Student s2=new Student("B",2);
        Student s3=new Student("C",3);

        l.add(s1);
        l.add(s2);
        l.add(s3);

        Iterator<Student> it=l.iterator();
        while(it.hasNext()){
            Student s = it.next();
            System.out.println(s.getName()+"-"+s.getAge());
        }
        System.out.println("---------------");
        for(int i=0;i<l.size();i++) {
            Student s = l.get(i);
            System.out.println(s.getName()+"-"+s.getAge());
        }
        System.out.println("---------------");
        for(Student s:l){
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

2.6数据结构

数据结构是计算存储、组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合。
通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。

2.7常见数据结构之栈

先进后出、后进先出。
最后进栈的元素称为栈顶元素，最先进栈的元素称为栈底元素。

2.8常见数据结构之队列

先进先出、后进后出。

2.9常见数据结构之数组

查询数据通过索引定位，查询任意数据耗时相同，查询速度快。
删除数据时，要将原始数据删除，同时后面每个数据前移，删除效率低。
添加数据时，添加位置后的每个数据后移，再添加元素，添加效率低。
note：所以数组时一种查询快、增删慢的模型。

2.10常见数据结构之链表

链表中有结点的概念，结点分为数据域和指针域。
链表相对于数组是一种增删快，查询慢的模型。链表增删只需要修改指针域的指向即可，但是链表的查询每次都需要从head头指针开始查询，所以查询效率相对于数组较慢。

2.11List集合子类特点

List集合常用子类：ArrayList，LinkedList

2.11.1ArrayList（extends AbstractList implements List）

Array’List底层数据结构是数组
ArrayList是List接口的可调整大小的数组实现。所以ArrayList类的查询快、增删慢。

2.11.2LinkedList（extends AbstractSequentialList implements List）

LinkedList底层数据结构是链表
LinkedList是双链表实现List和Deque接口。所以LinkedList类是查询慢、增删快。

2.11.3分别使用ArrayList和LinkedList完成存储字符串并遍历

ArrayList：

import java.util.ArrayList;
import java.util.Iterator;

public class ListDemo06_arrayList {
    public static void main(String[] args) {
        ArrayList<String> array=new ArrayList<String>();
        array.add("hello");
        array.add("world");
        array.add("java");

        Iterator<String> it =array.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        for(int i=0;i<array.size();i++) {
            String s=array.get(i);
            System.out.println(s);
        }
        for(String s:array) {
            System.out.println(s);
        }
    }
}

输出结果：

hello
world
java
hello
world
java
hello
world
java

LinkedList：

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

public class ListDemo06_linkedList {
    public static void main(String[] args) {
        LinkedList<String> linkedlist=new LinkedList<String>();
        linkedlist.add("hello");
        linkedlist.add("world");
        linkedlist.add("JAVA");

        Iterator<String> it=linkedlist.listIterator();
        while(it.hasNext()){
            String s=it.next();
            System.out.println(s);
        }
        for(int i=0;i<linkedlist.size();i++){
            String s=linkedlist.get(i);
            System.out.println(s);
        }
        for(String s:linkedlist){
            System.out.println(s);
        }
    }

输出结果：

hello
world
java
hello
world
java
hello
world
java

2.11.4案例：ArrayList集合存储学生对象用三种方式遍历

需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现控制台遍历该集合
思路：
1、定义学生类
2、创建ArrayList集合对象
3、创建学生类对象
4、将学生对象添加到ArrayList集合中
5、遍历集合
迭代器：集合特有的遍历方式
普通for循环：带有索引的遍历方式
增强for循环：最方便的遍历方式
Student类：

package daily_collection;

public class Student {
    private String name;
    private int age;

    public Student(){
    }

    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}


import java.util.ArrayList;
import java.util.Iterator;

public class ListDemo06_arrayList_obj {
    public static void main(String[] args) {
        ArrayList<Student> arrayList=new ArrayList<Student>();
        Student s1=new Student("A",1);
        Student s2=new Student("B",2);
        Student s3=new Student("C",3);
        arrayList.add(s1);
        arrayList.add(s3);
        arrayList.add(s2);

        Iterator<Student> it=arrayList.iterator();
        while(it.hasNext()){
            Student s=it.next();
            System.out.println(s.getName()+"_"+s.getAge());
        }
|  |  |
|--|--|
|  |  |

        for(int i=0;i<arrayList.size();i++){
            Student s=arrayList.get(i);
            System.out.println(s.getName()+"-"+s.getAge());
        }
        for(Student s:arrayList){
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

2.12 LinkedList集合的特有功能

方法名说明
public void addFirst(E e)在该链表开头插入指定元素
public void addLast(E e)在该链表末尾添加指定元素
public E getFirst()返回该链表的第一个元素
public E getLast()返回该链表的最后一个元素
public E removeFirst()删除列表中第一个元素，并返回
public E removeLast()从此列表中删除最后一个元素，并返回
import java.util.LinkedList;

public class ListDemo_linkedList_class {
    public static void main(String[] args) {
        LinkedList<String> linkedList=new LinkedList<String>();
        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("JAVA");

        linkedList.addFirst("first word!");
        linkedList.addLast("last word!");

        System.out.println(linkedList.removeFirst());
        System.out.println(linkedList.removeLast());
        System.out.println(linkedList.getFirst());
        System.out.println(linkedList.getLast());
        System.out.println(linkedList);
    }
}


first word!
last word!
hello
JAVA
[hello, world, JAVA]
鹿上的程序媛
关注
  • 7
    点赞
  • 踩
  • 59
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java list随机抽取元素的案例
09-07
主要介绍了java list随机抽取元素的案例，具有很好的参考，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
【Java基础】Java中List集合的常用方法
yubao0723的专栏
04-22 1万+
本文介绍了Java List集合的常用方法，包括创建和初始化List对象、添加、删除、修改和查询List中的元素以及遍历List集合
Java集合详解（一）-- List集合
最新发布
Beau Wang
04-05 999
java集合可分为Set、List、Queue和Map四种体系。Java集合就像一种容器，可以把多个对象（实际上是对象的引用，但习惯上都称对象）“丢进”该容器中。从Java 5 增加了泛型以后，Java集合可以记住容器中对象的数据类型，使得编码更加简洁、健壮。 ④.add(int index, Object element) 在列表的指定位置（从0开始）插入指定元素 ⑤.set(int i, Object element) 使用元素element替换索引i位置的元素，并返回被替换的元素。
Java基础之List
qq_45344586的博客
04-08 2415
Java基础之List
Java中List的简述
热门推荐
m0_47087822的博客
05-07 1万+
什么是 List 什么是集合 什么是 List List的继承、实现关系 List的种类 List的简单实用
javaList用法
12-10
javaList的用法
Java集合-List
weixin_43200566的博客
11-30 1万+
java.util.List接口继承自Collection接口，是单列集合的一个重要分支，习惯性地会将实现了List接口的对象称为List集合，在List集合中允许出现重复的元素，所有的元素是以一种线性方式进行存储的，在程序中可以通过索引来访问集合中的指定元素，另外List集合还有一个特点就是元素有序，即元素的存入顺序和取出顺序一致
java基础语法（二十二）List
Apikaqiu的博客
04-27 1万+
List接口常用方法 1、List集合存储元素特点：有序可重复 有序：List集合中的元素有下标，从0开始，依次递增 可重复：存储的元素可以重复 2、List既然是Collection接口的子接口，那么肯定List接口有自己"特色"的方法; 以下只列出List接口特有的常用的方法 void add(int index,E element) 在列表的指定位置插...
【Java 基础篇】Java List 详解
繁依Fanyi的博客
06-25 1万+
List接口继承自Collection接口，并添加了一些针对有序列表的操作。它允许元素的重复，并提供了根据索引访问、添加、删除和替换元素的方法。在Java中，List接口有几个常见的实现类，每个实现类都具有不同的性能和用途。ArrayList：基于动态数组实现，支持随机访问和快速遍历，适用于读取和修改操作较多的场景。LinkedList：基于双向链表实现，支持高效的插入和删除操作，适用于频繁的插入和删除操作。Vector：与ArrayList类似，但是线程安全，适用于多线程环境。
Java之List详解
三木易的博客
12-01 7101
第一篇技术博客，为了照顾阅读源码经验少的同学，讲的很详细，并分享了静态阅读源码的一些经验。总结与提炼出了一些源码中的亮点，方便同学们提高自己的代码水平，能在业务中更好的运用。我一直秉承着业务驱动技术，技术服务于业务的思维来讲解一些真正能实践的技术点。
Java集合之List集合
TestXzing的博客
06-14 6688
学Java集合之List集合，这一篇不看我替你遗憾
java 中List使用方法
05-04
关于讲解在java 中List使用方法
java中List集合及其实现类的方法详解
08-25
本篇文章给大家带来的内容是关于java中List集合及其实现类的方法介绍（附代码），有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。下面我们就来学习一下吧
java中List集合及其遍历详解
09-03
主要介绍了java中List集合及其遍历详解的相关资料,需要的朋友可以参考下
java中List集合分页的方法
10-21
java中List集合分页的方法
Java中List集合的遍历实例详解
08-26
主要介绍了Java中List集合遍历实例详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java中对List集合的常用操作详解
09-02
下面小编就为大家带来一篇Java中对List集合的常用操作详解。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Java中List集合的三种遍历实现 迭代器 普通for循环 增强for循环 使用时如何选择
qq_53130059的博客
04-08 5771
遍历实现1.迭代器遍历2.普通for循环遍历2.增强for遍历 给出了如何选择遍历方式的些许建议
Java：list接口，迭代器，Linklist集合
qq_63531507的博客
02-11 696
概述： 继承自Collection接口 1、List集合中的元素是有序的； 2、List集合中的元素可以重复； 3、List集合包含了索引概念； package day17; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class List1 { public static void main(String[] args) { List li
java中list集合
05-29
使用List集合，我们可以进行以下操作： 1. 添加元素：使用add()方法可以将元素添加到List中。 2. 获取元素：可以使用get()方法获取List中指定位置的元素。 3. 移除元素：使用remove()方法可以移除List中指定位置的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值