java 单列集合List 万字详解（通俗易懂）

已于 2023-12-10 17:34:38 修改
阅读量2.1k 收藏 13
点赞数 10
分类专栏： # 核心基础 Java基础 文章标签： java 开发语言 jvm list ArrayList LinkedList Vector
于 2022-11-20 19:39:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TYRA9/article/details/127916263
版权

目录

前言 : 

一、概述

二、特点：

三、使用集合的经典四部曲：

四、List接口的常用成员方法：

        前言:直接看汇总也可以，含讲解。

        1.常用十个成员方法及代码演示:

                Δ准备工作1：

                Δ准备工作2：

                ①.public boolean add(E e)

                代码演示①：

                ②.public void add(int index, E element)

                代码演示②：

                ③.public E remove(int index)

                代码演示③：

                ④.public boolean remove(Object o)

                代码演示④：

                ⑤.public E get(int index)

                代码演示⑤：

                ⑥.public int indexOf(Object o)

                代码演示⑥：

                ⑦.public int size()

                代码演示⑦：

                ⑧.public boolean contains(Object o)

                代码演示⑧：

                ⑨.public boolean isEmpty()

                代码演示⑨：

                ⑩.public E set(int index, Object element)

                代码演示⑩：

        2.代码汇总(含讲解，也可直接看这里):

五、List接口实现类——ArrayList

六、List接口实现类——Vector

七、List接口实现类——LinkedList

八、完结撒❀：

前言 : 

  • 回忆一下我们的集合框架体系图。List接口属于单列集合Collection接口下的其中一条分支，它最常用的三个实现类分别是——ArrayList，Vector，以及LinkedList。这三个实现类各有各的特点，但又有着一些相同的特性。
  • 本篇博文将带大家从List集合的介绍，特点，使用，再到它的三个常用实现类的底层源码分析，完完整整地给大家梳理清楚。
  • 注意 : ①代码中的注释也很重要；②不要眼高手低，自己跟着过一遍才算有收获；③点击文章的侧边栏目录或者文章开头的目录可以进行跳转。
  • 良工不示人以朴，所有文章都会适时补充完善。大家如果有问题都可以在评论区进行交流或者私信up。感谢阅读！

一、概述

                List集合属于java.base模块，java.util包下，是单列集合Collection接口的一个子接口。之前在面向对象专题我们讲过，接口不能直接被实例化。因此需要通过创建其子类对象来完成该接口的实例化（即多态）。List接口的常用子类有ArrayList类，LinkedList类等，我们先以ArrayList类为栗来演示List接口中的常用方法。eg：

                List list = new ArrayList();  （多态的方式保证了编译类型为List接口类型）

二、特点：

                1.List集合是有序集合，即元素的存取顺序是一致的。List集合中的元素可通过索引的形式来访问。
                如何理解此处的“存取顺序一致”呢？
                比如说你将某个元素添加进去集合时，它在索引为3的位置，也就是在当前集合中的第四个元素，那么，在当前集合无改动的情况下，你想取出该元素就必须从索引为3的位置去取，大白话就是——一个元素原来是在哪儿放的，现在就是从哪儿取的。

                2.List集合具有可重复的特点，即一个集合中可以有相同的元素。

三、使用集合的经典四部曲：

                1.创建集合对象

                2.创建元素对象

                3.将元素对象添加到集合对象中

                4.遍历集合

四、List接口的常用成员方法：

        前言:直接看汇总也可以，含讲解。

        1.常用十个成员方法及代码演示:

                Δ准备工作1：

                我们先创建一个Student类，作为将来要实例化的JavaBean类，之后可以将创建的Student类的对象添加到集合中。Student类代码如下：

package knowledge.API.gather.list;

public class Student {
    //私有的成员变量
    private String name;
    private int age;

    //公共的空参构造
    public Student() { }

    //公共的带参构造
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //getter，setter方法
    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;
    }

    //重写toString() 方法，以便于遍历集合时可以打印出学生对象。
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

                Δ准备工作2：

                up在Student类的同一包下创建ListTest类作为演示类，来演示List接口的常用成员方法。

                ①.public boolean add(E e)

                 //将数据添加到集合的末尾，这里的E是泛型的意思，目前可以先理解为Object类。

                代码演示①：

package knowledge.API.gather.list;

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

public class ListTest {
    public static void main(String[] args) {
//requirement : Test ①.public boolean add(E e)
    //1.创建集合对象
        List list = new ArrayList();    //此时集合list为空

        boolean bool = list.add(100);   //将第一个元素100添加到集合list中
        System.out.println("100这个元素成功添加到了集合list中了吗：" + bool);
        System.out.println("--------------------------------------------");

        //实际开发中，往往省略用boolean类型作接收的步骤，而是直接添加，如下:
        list.add(100);                  //再次添加一个元素100到集合list中，验证了list集合的可重复性。
        list.add("CSDN");               //添加一个字符串类型的元素到集合list中
        list.add("Cyan");

    //2.创建元素对象
        //接下来我们创建Student类对象(利用带参构造)，并将Student类对象的元素添加到集合对象中
        Student st1 = new Student("Cyan", 20);
        Student st2 = new Student("Five", 100);
        Student st3 = new Student("Ice", 30);

    //3.将元素对象添加到集合对象中    
        list.add(st1);
        list.add(st2);
        list.add(st3);

    //4.遍历集合
        //遍历一下集合，看看元素究竟添加进去没有:(get方法我们下面会讲到的，这里简单提一嘴，无非就是根据索引获取元素，功能上类似于数组)
        //size()方法用于获取集合的长度，我们后面也会演示到。
        for (int i = 0; i < list.size(); ++i) {
            System.out.println("集合中索引为" + i + "的元素是" + list.get(i));
        }

        System.out.println("--------------------------------------------");
    }
}

                输出结果①：

                ②.public void add(int index, E element)

                 //将指定的元素添加到该集合指定的位置。
                2023.12.10 17:12补充——看过up写的ArrayList源码分析后，大家可以自行去Debug，看看底层究竟是如何实现的😆。

                代码演示②：

                为了更好地展示出方法②与方法①的区别，我们在方法①的基础上进行演示，如下：

package knowledge.API.gather.list;

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

public class ListTest {
    public static void main(String[] args) {
//requirement : Test ②.public void add(int index, E element)
    //1.创建集合对象
        List list = new ArrayList();    //此时集合list为空

    //2.创建元素对象
        Student st1 = new Student("Cyan", 20);
        Student st2 = new Student("Five", 100);
        Student st3 = new Student("Ice", 30);

        Student stu1 = new Student("Cyan", 200);
        Student stu2 = new Student("Five", 1000);
        Student stu3 = new Student("Ice", 300);

    //3.将集合对象添加到元素对象中
        list.add(st1);
        list.add(st2);
        list.add(st3);

        /*
            我们已经将st1，st2和st3三个Student类对象添加到了集合中，它们对应的索引自然是0，1，2
            这时如果我们想在任意位置添加元素，就可以用到add的另一个重载方法，如下：
         */
        list.add(0, stu1);
        list.add(1, stu2);
        list.add(2, stu3);  //我们在集合的前面插入了三个Student对象元素

    //4.遍历集合
        for (int i = 0; i < list.size(); ++i) {
            System.out.println("集合中索引为" + i + "的元素是" + list.get(i));
        }

        System.out.println("--------------------------------------------");
    }
}

                输出结果②： 

                ③.public E remove(int index)

                 //将指定索引处的元素从该集合中删除 

                代码演示③：

//2023/12/10 17:24 对输出语句中错误的提示信息进行了修改.
package csdn.knowledge.api_tools.gather.list;

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

public class ListTest {
    public static void main(String[] args) {
//requirement : Test ③.public E remove(int index)
        //1.创建集合对象
        List list = new ArrayList();    //此时集合list为空

        //2.创建元素对象
        Student st1 = new Student("Cyan", 20);
        Student st2 = new Student("Five", 100);
        Student st3 = new Student("Ice", 30);

        //3.将集合对象添加到元素对象中
        list.add(st1);
        list.add(st2);
        list.add(st3);
        list.add(11);// 添加三个相同的元素11到集合list中
        list.add(11);
        list.add(11);

        //4.遍历集合
        System.out.println("删除元素前的集合如下：");
        for (int i = 0; i < list.size(); ++i) {
            System.out.println("集合中索引为" + i + "的元素是" + list.get(i));
        }
        System.out.println("----------------------------------------------");

        //现在我们调用remove() 方法，删除集合中的第一个元素及最后一个元素。
        list.remove(0);
        list.remove(list.size() - 1);
        /*
            特别注意，如果要连续删除集合中的前三个元素，只需要写三次list.remove(0);就可以了。
            错误写法：
            list.remove(0);
            list.remove(1);
            list.remove(2);
            这么写的后果就是，并不会删除原集合中前三个元素，而是会跳着删除，
            这是因为每次删除元素后，都是一个新的集合，下次删除传入的索引，只会在新集合中生效！
        */

        System.out.println("删除集合的首尾元素后，集合如下：");
        for (int i = 0; i < list.size(); ++i) {
            System.out.println("集合中索引为" + i + "的元素是" + list.get(i));
        }

        System.out.println("--------------------------------------------");
    }
}

                输出结果③:

                ④.public boolean remove(Object o)

                 //若该集合中存在该元素，则删除第一个指定的元素。

                代码演示④：

package knowledge.API.gather.list;

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

public class ListTest {
//requirement : Test ④.public boolean remove(Object o)
    public static void main(String[] args) {
    //1.创建集合对象
        List list = new ArrayList();
    //2.创建元素对象
        Student student1 = new Student("Bob", 11);
        Student student2 = new Student("Alice", 18);
    //3.将元素对象添加到集合对象中
        list.add(student1);
        list.add(student2);
        list.add(student2);
        list.add(122);
        list.add(122);
        list.add(122);
    //4.遍历集合
        System.out.println("删除元素前，集合如下:");
        for (int i = 0; i < list.size(); ++i) {
            System.out.println("集合中索引为" + i + "的元素为" + list.get(i));
        }
        System.out.println("-----------------------------------");

        //现在我们调用remove(Object o)方法来删除指定值的第一个元素(前提是该集合中要存在该元素才行)
        list.remove((Object)122);
        list.remove((Object)122);//删去了集合中的前两个值等于122的元素。
        /*
            list.remove(122);
            不能直接这样写，122会被当成索引，造成下标越界异常。
            IndexOutOfBoundsException: Index 122 out of bounds for length 4
         */


        System.out.println("删除元素后，集合如下；");
        for (int i = 0; i < list.size(); ++i) {
            System.out.println("索引:" + i + "元素：" + list.get(i));
        }
    }
}

                输出结果④：

                ⑤.public E get(int index)

                 //根据索引，获取其对应的元素。

                代码演示⑤：

package knowledge.API.gather.list;

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

public class ListTest {
//requirement : Test ⑤.public E get(int index)
    public static void main(String[] args) {
    //1.创建集合对象
        List list = new ArrayList();
    //2.创建元素对象
        Student kong = new Student("Aether", 19);
        Student ying = new Student("Lumine", 19);
        Student laoye = new Student("Diluc", 23);
    //3.将元素对象添加到集合对象中
        list.add(kong);
        list.add(ying);
        list.add(laoye);
    //4.遍历集合
        for (int i = 0; i < list.size(); ++i) {
            Object o = list.get(i);     //i代表索引，利用get方法获取指定索引处的元素
            System.out.println("索引为" + i + "的元素是:" + o);
        }
    }
}

                 输出结果⑤：

                ⑥.public int indexOf(Object o)

                 //获取集合中第一个指定元素的索引，若集合中没有该元素，则返回-1。

                代码演示⑥：

package knowledge.API.gather.list;

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

public class ListTest {
//requirement : Test ⑥.public int indexOf(Object o) 
    public static void main(String[] args) {
    //1.创建集合对象
        List list = new ArrayList();
    //2.创建元素对象
        Student kong = new Student("Aether", 19);
        Student ying = new Student("Lumine", 19);
        Student laoye = new Student("Diluc", 23);
    //3.将元素对象添加到集合对象中
        list.add(kong);
        list.add(ying);
        list.add(laoye);

        int index1 = list.indexOf(kong);
        int index2 = list.indexOf(ying);
        int index3 = list.indexOf(laoye);
        
        System.out.println("kong元素对应的索引是：" + index1);
        System.out.println("ying元素对应的索引是：" + index2);
        System.out.println("laoye元素对应的索引是：" + index3);
    //4.遍历集合
        //遍历个j8...
    }
}

                输出结果⑥：

                ⑦.public int size()

                 //获取集合的长度。

                代码演示⑦：

package knowledge.API.gather.list;

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

public class ListTest {
//requirement : Test ⑦.public int size()
    public static void main(String[] args) {
    //1.创建集合对象
        List list = new ArrayList();
    //2.创建元素对象
        //懒得建了。。。
    //3.添加元素对象到集合对象中
        //直接加不行吗
        list.add(1);
        list.add(1);
        list.add(1);
        list.add(1);

        int length = list.size();
        System.out.println("集合的长度为：" + length);
        System.out.println("集合的长度为：" + list.size());    //直接用方法就可以

    //4.遍历集合
        //遍历个p
    }
}

                输出结果⑦：

                ⑧.public boolean contains(Object o)

                 //判断该集合中是否有指定的元素。

                代码演示⑧：

package knowledge.API.gather.list;

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

public class ListTest {
//requirement : Test ⑧.public boolean contains(Object o)
    public static void main(String[] args) {
    //1.创建集合对象
        List list = new ArrayList();
    //2.创建元素对象
        Student student = new Student("SB", 250);
        Student student2 = new Student("Low", 11);
    //3.添加元素对象到集合对象中
        list.add(student);
        list.add(student2);

        boolean bool1 = list.contains(student); //判断集合中是否含有Student元素
        boolean bool2 = list.contains(student2); //判断集合中是否含有Student2元素
        boolean bool3 = list.contains(100);     //传入一个集合中不存在的元素，作为对照
        System.out.println("集合中含有student元素吗? " + bool1);
        System.out.println("集合中含有student2元素吗? " + bool2);
        System.out.println("集合中含有100元素吗? " + bool3);
    //4.遍历集合
        //遍历个p
    }
}

                输出结果⑧：

                ⑨.public boolean isEmpty()

                 //判断集合是否为空。

                代码演示⑨：

package knowledge.API.gather.list;

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

public class ListTest {
//requirement : Test ⑨.public boolean isEmpty()
    public static void main(String[] args) {
    //1.创建集合对象
        List list = new ArrayList();
        boolean bool1 = list.isEmpty();

        System.out.println("刚创建集合，集合目前是否为空呢:" + bool1);
        System.out.println("刚创建集合，集合目前是否为空呢:" + list.isEmpty());    //同样也可直接输出
        System.out.println("---------------------------------------\n");
    //2.创建元素对象
        Student student = new Student("SB", 250);
        Student student2 = new Student("Low", 11);
    //3.添加元素对象到集合对象中
        list.add(student);
        list.add(student2);

        System.out.println("添加了几个元素之和，集合现在还为空吗?" + list.isEmpty());
    //4.遍历集合
        //遍历个p
    }
}

                输出结果⑨：

                ⑩.public E set(int index, Object element)

                 //可用来修改对应索引处的元素。

                代码演示⑩：

package knowledge.API.gather.list;

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

public class ListTest {
//requirement : Test ⑩.public E set(int index, Object element)
    public static void main(String[] args) {
    //1.创建集合对象
        List list = new ArrayList();
    //2.创建元素对象
        Student st1 = new Student("Tom", 12);
        Student st2 = new Student("Tom's Dad", 35);
    //3.将元素对象添加到集合对象中
        list.add(st1);
        list.add(st1);
        list.add(st1);
        list.add(0, 11);
        list.add(0, 12);
        list.add(0, 13);
        /*
            每次添加元素后，集合都会更新，所以，若以固定索引添加元素时，每次都会以新集合
            为出发点，这样我们连续以0为索引添加，就可以在集合的开头连续添加元素
         */
    //4.遍历集合
        System.out.println("更改元素前，数组如下：");
        for (int i = 0; i < list.size(); ++i) {
           System.out.println("索引：" + i + "元素：" + list.get(i));
        }
        System.out.println();

        /*
           利用set方法更改指定索引出的元素。
         */
        list.set(0, 111);
        list.set(1, 122);
        list.set(2, 133);
        list.set(3, st2);
        list.set(4, st2);

        System.out.println("更改元素后，数组如下：");
        for (int i = 0; i < list.size(); ++i) {
           System.out.println("索引：" + i + "元素：" + list.get(i));
        }

    }
}

                输出结果⑩：

        2.代码汇总(含讲解，也可直接看这里):

                不想一个一个看代码，有一定基础的小伙伴儿们可以直接看这里，每个方法都演示到了。如下:

package knowledge.API.gather.list;

import java.util.ArrayList;
import java.util.List;//别忘了导包

/**
 * 单链集合（Collection）之List集合：
 *      1.特点
 *          有序（元素的存取顺序一致）， 可重复
 *      2.注意:
 *          List是接口，所以可以通过创建其子类ArrayList对象来完成该接口的实例化
 *          eg : List list = new ArrayList();            //(多态)
 *      3.List接口中的常用成员方法：
 *          ①.public boolean add(E e)                 //将数据添加到集合的末尾，这里的E是泛型的意思，目前可以先理解为Object类
 *          ②.public void add(int index, E element)   //将指定的元素添加到该集合指定的位置。
 *
 *          ③.public E remove(int index)              //将指定索引处的元素从该集合中删除
 *          ④.public boolean remove(Object o)         //若该集合中存在该元素，则删除第一个指定的元素。
 *
 *          ⑤.public E get(int index)                 //根据索引，获取其对应的元素
 *          ⑥.public int indexOf(Object o)            //获取集合中第一个指定元素的索引，若集合中没有该元素，则返回-1.
 *          ⑦.public int size()                       //获取集合的长度
 *
 *          ⑧.public boolean contains(Object o)       //判断该集合中是否有指定的元素。
 *          ⑨.public boolean isEmpty()                //判断集合是否为空。
 *
 *          ⑩.public E set(int index, Object element); //可用来修改对应索引处的元素
 *      4.使用集合的步骤：
 *          创建集合对象
 *          创建元素对象
 *          将元素对象添加到集合对象中
 *          遍历集合
 *
 */
public class CodeSum {
    public static void main(String[] args) {
    //1.创建集合对象
        List list = new ArrayList();
        /* 测试方法⑩isEmpty()，判断此时集合是否为空 */
        boolean bool1 = list.isEmpty();
        System.out.println("集合此时为空吗：" + bool1);
        System.out.println("---------------------------------");

    //2.创建元素对象
        Student student1 = new Student("Kyrie", 33);
        Student student2 = new Student("Five", 22);
        Student student3 = new Student("Ice", 44);
        Student student4 = new Student("Cyan", 44);
        Student student5 = new Student("Cyan", 19);
        Student student6 = new Student("Cyan", 19);

    //3.将元素对象添加到集合对象中
        /* 测试方法①add(E e)和②add(int index, E element)，对集合添加元素 */
        boolean b = list.add(student1);     //添加Kyrie到list集合中
        System.out.println("student1对象成功添加到集合list中了吗？" + b);
        System.out.println("---------------------------------");

        /* 对于方法①，实际开发中我们都会省略前面的booelan b = ，而是直接调用方法 */
        list.add(student2);                 //添加Five到list集合中
        list.add(student3);                 //添加Ice到list集合中
        list.add(0, student4);        //添加第一个Cyan（44岁）到list集合中
        list.add(1, student5);        //添加第二个Cyan（19岁）到list集合中
        list.add(2, student6);        //添加第三个Cyan（19岁）到list集合中

        /* 测试一下list集合的可重复性 */
        list.add(10);
        list.add(10);
        /*
            本来student1，student2，student3，分别对应索引0，1，2
            但我们此处可以调用方法②将student4 ，student5 和 student6分别插入到索引为0，1，2的位置，
            这样，集合中的结果应该如下：
            索引 ----->  对应元素
            0   ----->   Cyan, 44
            1   ----->   Cyan, 19
            2   ----->   Cyan, 19
            3   ----->   Kyrie, 33
            4   ----->   Five, 22
            5   ----->   Ice, 44
            6   ----->   10
            7   ----->   10

         */
    //4.遍历集合
        /* 测试方法⑤get(int index), 遍历一下集合 */
        for (int i = 0; i < list.size(); ++i) {
            System.out.println("list集合的第" + i + "个元素为：" + list.get(i));
        }
        System.out.println("---------------------------------");

        /* 测试方法⑥indexOf(Object o) */
        int index1 = list.indexOf(student4);
        System.out.println("student4元素在集合list中的索引为：" + index1);
        int index2 = list.indexOf(10);
        System.out.println("10的第一个元素在集合list中的索引为：" + index2);
        int index3 = list.indexOf(100);
        System.out.println("如果没有100这个元素，请返回-1" + index3);

        /* 测试方法⑦size() */
        int length = list.size();
        System.out.println("添加了六个学生对象元素后，集合目前的长度为" + length);
        System.out.println("---------------------------------");

        /* 测试方法⑧contains(Object) 和 再次测试方法⑨isEmpty() */
        boolean b2 = list.isEmpty();
        System.out.println("添加了六个学生对象元素后，集合目前还为空吗？" + b2);
        System.out.println("---------------------------------");

        boolean b3_1 = list.contains("Cyan");
        System.out.println("集合list中有Cyan这个元素吗？" + b3_1);
        boolean b3_2 = list.contains(student1);
        System.out.println("集合list中有student1这个元素吗？" + b3_2);
        boolean b3_3 = list.contains(22);
        System.out.println("集合list中有22这个元素吗？" + b3_3);
        System.out.println("---------------------------------");

        /* 测试方法⑩set(int index, Object o) */
        System.out.println("修改之前，list集合的索引为6的元素是:" + list.get(6));
        list.set(6, 11);
        System.out.println("修改之后，list集合的索引为6的元素是:" + list.get(6));

        System.out.println("修改之前，list集合的索引为5的元素是:" + list.get(5));
        list.set(5, student1);
        System.out.println("修改之后，list集合的索引为5的元素是:" + list.get(5));

        /* 测试方法③remove(int index) 和 方法④remove(Object o)*/
        list.remove(list.size() - 1);
        list.remove(student1);
        System.out.println("看看删除最后一个元素和第一个元素后集合成什么样子了：");
        for (int i = 0; i < list.size(); ++i) {
            System.out.println(list.get(i));
        }
        System.out.println("---------------------------------");
    }
}

                输入结果如下gif图: 

五、List接口实现类——ArrayList

                链接如下 : 

https://blog.csdn.net/TYRA9/article/details/129478037icon-default.png?t=N7T8https://blog.csdn.net/TYRA9/article/details/129478037

                ArrayList主要内容包括 : 

                ①ArrayList类简介
                ②ArrayLIst类的底层实现
                ③ArrayList类的源码解读

六、List接口实现类——Vector

                链接如下 : 

https://blog.csdn.net/TYRA9/article/details/129522104icon-default.png?t=N7T8https://blog.csdn.net/TYRA9/article/details/129522104

                Vector类主要内容包括 : 

                ①Vector类简介

                ②Vector类的底层实现

                ③Vector类 VS ArrayLIst类

                ④Vector类的源码解读

七、List接口实现类——LinkedList

                链接如下 : 

https://blog.csdn.net/TYRA9/article/details/129578222icon-default.png?t=N7T8https://blog.csdn.net/TYRA9/article/details/129578222

                LinkedList类主要内容包括 : 

                ①LinkedList类简介

                ②LinkedList类的底层实现

                ③LinkedList类 VS ArrayList类

                ④LinkedList类源码解读

八、完结撒❀：

        🆗，以上就是单列集合List接口的全部内容了。单列集合Collection接口除了List外，还有一个Set接口，因此接下来up将会开始Set接口系列的博文讲解。不过在讲Set接口之前，建议大家先去看看up写得"增强for和迭代器 万字详解"一文，如果学过的可以不看。好的，我们Set接口不见不散😆。感谢阅读！

                System.out.println("END-------------------------------------------------------------------");

Cyan_RA9
关注
  • 10
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
Java集合之单列集合
qq_52146944的博客
05-06 1050
迭代器源码分析。
Java实现单链表
xaiobit_hl的博客
05-16 4546
目录 单链表的实现 ArrayList的缺陷和与单链表的区别 1.单链表的实现 首先我们和ArrayList一样，将MySingleList单独定义为一个Java文件，然后每一个结点我们将它定义成一个静态内部类，这样就方便我们访问结点的成员，，还是和ArrayList一样，我们再定义一个Test类用来测试我们的单链表，写一个函数可以测试一下，这样在最后就不会眼麻手乱了，， 无头单向非循环链表的实现： 1.1MySingleList的大概实现框架 public class MySingleLis
Java集合进阶——单列集合
m0_74808313的博客
04-08 855
数组+链表+红黑树⑴引用构造方法时，方法底层会创建一个默认长度为16，加载因子为0.75的数组⑵添加元素时，方法会根据元素的哈希值跟数组的长度计算出应存入的位置⑶判断当前位置是否有元素如果没有元素则直接存入;如果有元素则会通过equals方法比较元素属性值是否一样，一样的话表示元素重复，不存;不一样的话存入数组，形成链表细节:当链表长度超过8且数组长度大于等于64时，链表会自动转换为红黑树，从而提高查找效率LinkedHashSet是HashSet的子类，其完全继承了父类中的方法。
JAVA 单链表的实现
LYE_LYE的博客
08-29 365
JAVA单链表的实现
Java中List的详细用法
热门推荐
qq_41439608的博客
11-12 4万+
Java中List的详细用法 定义：List name = new ArrayList<>() 具体方法如下： 1.list中添加，获取，删除元素； 添加方法是：.add(e)；　　获取方法是：.get(index)；　　删除方法是：.remove(index)； 按照索引删除；　　.remove(Object o)； 按照元素内容删除； List<String> person = new ArrayList<>(); person.add("jackie");
Java 简单算法——单链表的使用
Jiashun Hao的博客
06-05 442
x
Java集合类史上最细讲解 - List篇
大河之犬的博客
07-21 1667
链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。Java的设计者在这里获取了链表头节点的地址，以备后续进行删除，随后检查了一个头节点为空的异常，在。的变量出现，它的作用就是记录当前集合被修改的次数。原理操作和上面类似，只不过它初始的容量为指定的容量，需要扩容时扩容为原容量的1.5倍。先获取一下头节点后面的节点的地址，保存下来，然后将头节点的数据和。的增加和删除的操作效率更高，而查找和修改的操作效率较低。
【问题解决】vue中，向一个List内添加单个对象； 向一个List内添加另一个List（拼接两个List）。
我梦
04-01 7524
文章目录问题：解决方案：向一个List内添加单个对象向一个List内添加另一个List（拼接两个List） 我是一名立志把细节都说清楚的博主，欢迎关注🎉 ~ 原创不易，如果有帮助，还请鼓励个【赞】哦~ ❥(^_-)~ 问题： Vue中： - 向一个List内添加单个对象。 - 向一个List内添加另一个List（拼接两个List） 解决方案： 向一个List内添加单个对象 使用push命令即可。 ListC = ListA.push({ObjB}); 用法展示： ListA = [{name:A;a
java中List集合及其遍历详解
09-03
在Java编程语言中，List集合是一个重要的数据结构，它继承自Collection接口，允许存储有序的、可重复的元素，并提供了索引来访问集合中的特定位置。本文将深入探讨List集合及其遍历方法。 首先，让我们了解一下List...
java集合 collection-list-LinkedList详解
08-31
在Java集合框架中，`List`接口是`Collection`接口的一个子接口，它代表了有序的元素列表，其中元素可以重复，并且可以通过索引来访问。`LinkedList`类是实现`List`接口的一个具体类，它提供了链表结构的数据存储方式...
Java中对List集合的常用操作详解
09-02
在Java编程中，List集合是Java集合框架的重要组成部分，它是一种有序的集合，可以存储重复的元素。本文将深入解析Java中对List集合的常用操作，帮助开发者更好地理解和使用List接口。 1. **添加、获取和删除元素** ...
详解Java 集合类 List 的那些坑
08-24
详解 Java 集合类 List 的那些坑 Java 集合类 List 是 Java 编程语言的集合框架中的一种常用的数据结构，提供了各种实现，然而在使用过程中可能会遇到一些坑，影响开发效率和代码质量。本节将详细介绍 Java 集合类 ...
java中List集合及其实现类的方法详解
08-25
Java 中 List 集合及其实现类的方法详解 List 集合是 Java 中最基本的集合类型之一，它提供了许多方法来操作和管理集合中的元素。在 Java 中，List 集合有多种实现类，例如 ArrayList、LinkedList、Vector 等，每种...
Java中的List集合
qq_41657790的博客
04-11 1075
开发工具与关键技术：MyEclipse 10、Java 作者：曾浩源 撰写时间：2019年04月08日 在学习C#时，经常使用的list集合，在java中也有而且还比C#更简单更方便。 首先，实现一个简单的list集合，在main方法内直接实例化ArrayList集合： public static void main(String[] args) { List<String> lis...
Java List 详解
最新发布
小橘子的博客
04-16 1444
Java的List是一个功能强大的集合类型，它提供了许多用于操作有序元素集合的方法。选择正确的List实现类以及正确地使用这些方法对于编写高效且可靠的Java代码至关重要。通过理解List的主要特点、常用实现类、常用方法以及性能考虑，可以更好地利用Java的集合框架来构建复杂的数据结构和算法。
Java中 List集合接口及其主要的实现类ArrayList，Vector，LinkedList的详解
路宇的博客
05-16 1639
一、ArrayList:作为list接口的主要实现类；线程不安全，效率高；底层使用Object[] elementData存储 二、list接口中的常用方法： @Test public void test1(){ ArrayList list=new ArrayList(); list.add(45); list.add("aa"); list.add("你好"); list.add("456"); S
Java - List（泛型、包装类、List）
旧时言的博客
11-25 9032
本节目标 学习一个新的 java 语法泛型的使用 学习一个新的 java 概念，包装类 List / ArrayList / LinkedList 的基本使用 ArrayList 类的使用 LinkedList 类的使用 1. 预备知识-泛型(Generic) 1.1 泛型的引入 问题：我们之前实现过的顺序表，只能保存 int 类型的元素，如果现在需要保存 指向 Person 类型对象的引用的顺序表，请问应该如何解决？如果又需要保存指向 Book 对象类型的引用呢？ 回答： 首先，我们在学习多态过程中
Collection,单例集合 List,Set 特点及应用场景
FengTianXu0509的博客
11-14 58
之前是学过集合遍历，但是之前学习过的遍历方式，只能遍历List集合，不能遍历Set集合，因为以前的普通for循环遍历需要索引，只有List集合有索引，而Set集合没有索引。但是，我们学习时会对这些集合进行分类学习，如下图所示：一类是单列集合元素是一个一个的，另一类是双列集合元素是一对一对的。假如，现在想要把D节点删除，只需要让C节点指向E节点的地址，然后把D节点指向E节点的地址断掉。假如，现在要在B节点和D节点中间插入一个元素，只需要把B节点指向D节点的地址断掉，重新指向新的节点地址就可以了。
java实现单链表的创建，查询与显示(按id显示)
yuanchangliang的博客
06-26 374
数据结构之单链表的创建，查询与显示(按id显示) package cn.ycl.dataStructures; public class singleListdemo { public static void main(String[] args) { singleList list = new singleList(); heroNode hero1 = new heroNode("张三", 1, "大哥"); heroNode hero2 = new heroNode("李四", 2, "二哥");
java面经通俗易懂
03-03
Java面经是指在面试过程中常被问到的与Java相关的问题和知识点。下面是一些常见的Java面经问题及其解答： 1. Java的特点是什么？ Java是一种面向对象的编程语言，具有跨平台性、简单性、可靠性、安全性和高性能等特点。 2. 什么是Java虚拟机（JVM）？ JVM是Java程序运行的环境，它负责将Java源代码编译成字节码，并在不同的操作系统上执行。 3. 什么是面向对象编程（OOP）？ 面向对象编程是一种编程范式，它将数据和操作数据的方法封装在一起，通过创建对象来实现程序的功能。 4. Java中的四种访问修饰符分别是什么？ Java中的四种访问修饰符分别是public、protected、default和private，用于控制类、方法和变量的访问权限。 5. 什么是Java中的异常处理机制？ 异常处理机制是Java中用于处理程序运行过程中出现的异常情况的一种机制，通过try-catch-finally语句块来捕获和处理异常。 6. 什么是Java中的多线程？ 多线程是指在一个程序中同时执行多个线程，每个线程都可以独立执行不同的任务，提高程序的并发性和效率。 7. 什么是Java中的集合框架？ 集合框架是Java中用于存储和操作一组对象的类库，包括List、Set、Map等常用的数据结构和算法。 8. 什么是Java中的反射机制？ 反射机制是指在运行时动态地获取和操作类的信息，可以通过反射来创建对象、调用方法和访问属性等。 9. 什么是Java中的IO流？ IO流是Java中用于输入和输出数据的一种机制，包括字节流和字符流，用于读取和写入文件、网络等数据源。 10. 什么是Java中的设计模式？ 设计模式是一种解决常见软件设计问题的经验总结，包括单例模式、工厂模式、观察者模式等常用的设计模式。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Cyan_RA9

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值