32List集合

最新推荐文章于 2024-11-04 20:33:37 发布
最新推荐文章于 2024-11-04 20:33:37 发布
阅读量140 收藏
点赞数
分类专栏： Java基础学习笔记 文章标签： java 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/honglaoliu/article/details/121454700
版权

1.1 List集合概述和特点【记忆】

  • List集合概述

    • 有序集合(也称为序列)，用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素
    • 与Set集合不同，列表通常允许重复的元素

  • List集合特点

    • 有索引
    • 可以存储重复元素
    • 元素存取有序
/*
    List集合特点
        有序：存储和取出的元素顺序一致
        可重复：存储的元素可以重复
 */
public class ListDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<String>();

        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("world");

        //输出集合对象
//        System.out.println(list);

        //迭代器的方式遍历
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }

    }
}

1.2 List集合的特有方法【应用】

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

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

代码：

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.List;

/*
    需求：
        创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

    思路：
        1:定义学生类
        2:创建List集合对象
        3:创建学生对象
        4:把学生添加到集合
        5:遍历集合(迭代器方式，for循环方式)
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建List集合对象
        List<Student> s = new ArrayList<Student>();

        //创建学生对象
        Student s1 = new Student("A",11);
        Student s2 = new Student("B",12);
        Student s3 = new Student("C",13);

        //把学生添加到集合
        s.add(s1);
        s.add(s2);
        s.add(s3);

        //遍历集合-迭代器方式
//        Iterator<Student> i = s.iterator();
//        while(i.hasNext()){
//            Student stu = i.next();
//            System.out.println(stu.getName()+","+stu.getAge());
//        }

        //遍历集合-for循环方式
        for(int i=0;i<s.size();i++){
            Student stu = s.get(i);
            System.out.println(stu.getName()+","+stu.getAge());

        }

    }
}

1.3 并发修改异常【应用】

  • 出现的原因
    迭代器遍历的过程中，通过集合对象修改了集合中的元素，造成了迭代器获取元素中判断预期修改值和实际修改值不一致，则会出现：ConcurrentModificationException
  • 解决的方案
    用for循环遍历，然后用集合对象做对应的操作即可
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/*
    需求：
        我有一个集合：List<String> list = new ArrayList<String>();
        里面有三个元素：list.add("hello");list.add("world");list.add("java");
        遍历集合，得到每一个元素，看有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现

    ConcurrentModificationException:当不允许这样的修改时，可以通过检测到对象的并发修改的方法来抛出此异常
 */
public class ListDemo {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<String>();

        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");

        //遍历集合，得到每一个元素，看有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现
//        Iterator<String> it = list.iterator();
//        while (it.hasNext()) {
//            String s = it.next();
//            if(s.equals("world")) {
//                list.add("javaee");
//            }
//        }

        for(int i=0; i<list.size(); i++) {
            String s = list.get(i);
            if(s.equals("world")) {
                list.add("javaee");
            }
        }

        //输出集合对象
        System.out.println(list);
    }
}

并发修改异常源码分析：

public interface List<E> {
    Iterator<E> iterator();
    boolean add(E e);
}

public abstract class AbstractList<E> {
    protected int modCount = 0;
}

public class ArrayList<E> extends AbstractList<E> implements List<E> {

    public E get(int index) {
        Objects.checkIndex(index, size);
        return elementData(index);
    }

    public boolean add(E e) {
        modCount++;
        add(e, elementData, size);
        return true;
    }

    public Iterator<E> iterator() {
        return new Itr();
    }

    private class Itr implements Iterator<E> {
        int expectedModCount = modCount;
        /*
            modCount:实际修改集合的次数
            expectedModCount:预期修改集合的次数
        */

        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

}

Snipaste_2021-09-20_11-22-28

1.4 列表迭代器【应用】

  • ListIterator介绍
    通过List集合的listIterator()方法得到，所以说它是List集合特有的迭代器
    用于允许程序员沿任一方向遍历的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

Snipaste_2021-09-20_11-28-32

package Heima.List.Test2;

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

/*
    ListIterator：列表迭代器
        通过List集合的listIterator​()方法得到，所以说它是List集合特有的迭代器
        用于允许程序员沿任一方向遍历列表的列表的迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

    ListIterator中的常用方法
        E next()：返回迭代中的下一个元素
        boolean hasNext()：如果迭代具有更多元素，则返回 true
        E previous​()：返回列表中的上一个元素
        boolean hasPrevious​()：如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回 true
        void add​(E e)：将指定的元素插入列表
 */
public class Demo3 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> Li = new ArrayList<String>();

        Li.add("ou");
        Li.add("uo");
        Li.add("ouo");



//        while(l.hasNext()){
//            String n = l.next();
//            System.out.println(n);
//        }
//
//
//        while(l.hasPrevious()){
//            String p = l.previous();
//            System.out.println(p);

/*
        用Iterator调用的add方法报错：ConcurrentModificationException
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String s = it.next();
            if(s.equals("world")) {
                list.add("javaee");
            }
        }*/

        //通过List集合的listIterator​()方法得到
        ListIterator<String> l = Li.listIterator();
        //获取列表迭代器
        while(l.hasNext()){
            String n = l.next();
            if(n=="ou"){
                l.add("----");
            }
        }
        System.out.println(Li);
    }
}

源码分析：

public interface List<E> {
    Iterator<E> iterator();
    ListIterator<E> listIterator();
}

public abstract class AbstractList<E> {
    protected int modCount = 0;
}

public class ArrayList<E> extends AbstractList<E> implements List<E> {
    public Iterator<E> iterator() {
        return new Itr();
    }

    private class Itr implements Iterator<E> {
        ...
    }

    public ListIterator<E> listIterator() {
        return new ListItr(0);
    }

    private class ListItr extends Itr implements ListIterator<E> {
        public void add(E e) {
            checkForComodification();

            try {
                int i = cursor;
                ArrayList.this.add(i, e);
                cursor = i + 1;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }
    }
}

1.5 增强for循环【应用】

定义格式 :

for(元素数据类型 变量名 : 数组/集合对象名) {
    循环体;
}

Snipaste_2021-09-20_11-51-46

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

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

    格式：
        for(元素数据类型 变量名 : 数组或者Collection集合) {
            //在此处使用变量即可，该变量就是元素
        }
 */
public class ForDemo {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        for(int i : arr) {
            System.out.println(i);
        }
        System.out.println("--------");

        String[] strArray = {"hello","world","java"};
        for(String s : strArray) {
            System.out.println(s);
        }
        System.out.println("--------");

        List<String> list = new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("java");

        for(String s : list) {
            System.out.println(s);
        }
        System.out.println("--------");

        //内部原理是一个Iterator迭代器
        /*
        for(String s : list) {
            if(s.equals("world")) {
                list.add("javaee"); //ConcurrentModificationException
            }
        }
        */
    }
}

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

  • 案例需求
    创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

Snipaste_2021-09-20_15-50-44

  • 创建学生类：
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;
    }
}
  • 测试类
/*
    需求：
        创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

    思路：
        1:定义学生类
        2:创建List集合对象
        3:创建学生对象
        4:把学生添加到集合
        5:遍历集合
            迭代器：集合特有的遍历方式
            普通for：带有索引的遍历方式
            增强for：最方便的遍历方式
 */
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class test {
    public static void main(String[] args) {
        //创建List集合对象
        List<Student> stu = new ArrayList<Student>();

        //创建学生类对象
        Student s1 = new Student("A",12);
        Student s2 = new Student("B",13);
        Student s3 = new Student("C",14);

        //把学生类添加到List
        stu.add(s1);
        stu.add(s2);
        stu.add(s3);


        //迭代器：集合特有的遍历方式
        Iterator<Student> it = stu.iterator();
        while(it.hasNext()){
            Student n = it.next();
            System.out.println(n.getName()+","+n.getAge());
        }
        System.out.println("-------------------");

        //普通for：带有索引的遍历方式
        for(int i=0;i<stu.size();i++){
            Student sa = stu.get(i);
            System.out.println(sa.getName()+","+sa.getAge());
        }
        System.out.println("-------------------");

        //增强for：最方便的遍历方式
        for(Student s:stu){
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

1.6 链表

Snipaste_2021-09-20_16-45-35

  • 链表添加数据

Snipaste_2021-09-20_16-46-49

  • 删除链表

Snipaste_2021-09-20_16-47-54

Snipaste_2021-09-20_16-48-52

1.7 LinkedList集合的特有功能【应用】

方法名说明
public void addFirst(E e)在该列表开头插入指定的元素
public void addLast(E e)将指定的元素追加到此列表的末尾
public E getFirst()返回此列表中的第一个元素
public E getLast()返回此列表中的最后一个元素
public E removeFirst()从此列表中删除并返回第一个元素
public E removeLast()从此列表中删除并返回最后一个元素
学无止境的菜狗
关注
专栏目录
Python基础2—变量
weixin_34417200的博客
04-14 174
一、数字 　　1、int 占32个字位4个字节，范围为-2^31~~~~2^31-1 定义 　　 定义方法：直接使用，如：num=2 　　2、long 长整数的大小与虚拟内存大小有关 　　　定义方法：直接使用，当整数超出int的范围时自动使用long 　　3、float 　　　定义方法：直接使用，如：num=2.1 　　4、complex 复数 　　　定义方法：直接使用...
HashMap存入和取出数据顺序不一致
茧如歌
11-15 2万+
       Hashmap 是一个最常用的Map,它根据键的HashCode值存储数据,根据键可以直接获取它的值，具有很快的访问速度，遍历时，取得数据的顺序是完全随机的，这样会导致按照顺序读取的时候和存入的顺序是不一样的   。 HashMap最多只允许一条记录的键为Null;允许多条记录的值为 Null;HashMap不支持线程的同步，即任一时刻可以有多个线程同时写HashMap;可能会导致数...
关于python列表的一些常用操作
weixin_61133168的博客
05-13 9164
话不多说，开搞！ 1.初始化一个列表： mylist=[] mylist=['1','a','c'] 2.输入列表： #以空格隔开输入一组整形数据 mylist=list(map(int,input().split())) #以逗号隔开输入一组字符型数据 mylist=list(map(str,input().split(","))) #输入一个完整的列表（带中括号和逗号） mylist=list(eval(input())) 3.添加元素： #在末尾添加单个元素 mylist.appe
List-有序集合
weixin_67796933的博客
06-23 1万+
目录ListList集合概述和特点List集合特有方法并发修改异常ListIterator增强for循环List集合子类特点LinkedList集合的特有功能先到帮助文档中查看:它在java.util包下,使用它需要导包。是泛型，是List集合中的类型。往下看List是一个接口它继承自Collection接口，所以Collection接口中有的功能List都可以使用。List被称为有序集合也被称为序列。用户可以精确控制列表中每个元素的插入位置。 用户可以通过整数索引（列表中的位置）访问元素，并搜索列表...
Redis数据结构详解之List（二）
weixin_34026484的博客
11-19 241
序言 思来想去感觉redis中的list没什么好写的，如果单写几个命令的操作过于乏味，所以本篇最后我会根据redis中list数据类型的特殊属性，同时对比成熟的消息队列产品rabbitmq，使用redis实现一个消息队列。  为啦让本篇更有魅力，我再介绍下redis中list的基本属性，以及为什么使用redis中list列表类型，为什么使用消息队列，为什么不用rabbitmq而使用redis实...
Java集合之List集合
TestXzing的博客
06-14 1万+
学Java集合之List集合，这一篇不看我替你遗憾
JSON转List集合
技术刘的博客
06-24 1万+
注意jar包不要导错了。 import net.sf.json.JSONArray; //第一种 JSONArray dataJson= JSONArray .fromObject(creaGathering); List<CreaUserTemplate> list = (List<CreaUserTemplate>) JSONArray.toCollection(...
List集合循环遍历
qq_42651201的博客
01-13 3572
1.增强for循环遍历 2.一般for循环遍历 3.迭代器循环遍历 package com.jpa.demo; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class Testssss { public static void main(String[] args) { List<String> list = new ArrayList&.
Object 转List集合
taoCSD的博客
10-29 6224
import com.google.gson.Gson; import com.facebook.presto.jdbc.internal.guava.reflect.TypeToken; Object propertys = map.get(“property”); List property = new Gson().fromJson(new Gson().toJson(propertys), new TypeToken<List>(){}.getType());
Java中利用Set判断List集合中是否有重复元素
热门推荐
Asurplus
12-05 21万+
在开发工作中，我们有时需要去判断List集合中是否含有重复的元素 我们不需要找出重复的元素，我们只需要返回一个Boolean类型就可以了 如果使用循环遍历的方式，将会消耗大量的性能 我们只需要将List集合转化为Set集合，再进行比较就可以实现了
java后台list集合转XML格式数据
10-21
java后台从数据库读取 数据，封装到list集合，控制层转化为XML格式数据
集合篇---List集合
weixin_42107106的博客
09-20 1519
List，ArrayList，Vector概述
java map存储list集合_Java集合类(List、map、list集合)
weixin_30706851的博客
02-13 5025
1.1集合类的概述Java.util包中提供了一些集合类，这些集合类右被称为容器。提到容器不难想到数组，集合类与数组不同之处是：数组的长度是固定长度，集合的长度是可变的；数组是用来存放基本数据类型，集合是用来存放对象的引用。常用的集合有List集合、Set集合和Map集合，其中List和Set继承了Collection接口，各接口还提供了不同的实现类。上述集合类的继承关系如图14.1所示：1.1C...
Java List集合
m0_62143653的博客
02-12 5602
Java List集合
集合框架·List集合简介
weixin_54877075的博客
05-16 2019
相信大家初学Java时对集合的概念也有一定的了解，那么java里面的集合又是什么呢？ 一、集合是什么？ 它和数组不同，数组既可以存储基本数据类型，也可以存储引用数据类型。而集合只能存储引用数据类型，比如你存入一个int型数据18放入集合中，其实它是自动转换成Integer类后存入的，Java中每一种基本数据类型都有对应的引用类型，如果存储基本数据类型，会被自动装箱。 它就像一个容器，专门用来存储java对象（实际上是对象名，即指向地址的指针），这些对象可以是任意数据类型，并且长度可变。其中，这些集..
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 633
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 1123
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
spring循环依赖解决方式
最新发布
qq_36400213的博客
11-04 776
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 456
默认对常规Session的理解和使用，如何使用Set-Cookie。
Java List集合与迭代器实战教程
"Java编程中的异常处理以及List集合与列表迭代器的使用" 在Java编程中，异常处理是一项关键技能，它能帮助我们更好地捕获和处理程序运行时可能出现的问题。异常是程序执行过程中遇到的不正常情况，可以是除数为零、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值