• List-有序集合

    List本是豪门少爷。
    在新婚前夜却发现未婚妻和兄弟Collection在喜床上翻滚。
    她深夜买醉却撞上醉酒的List。
    一夜痴缠List醒来后不见她的踪影。
    只见床头压着一张纸：
    今天是肯德基疯狂星期四吮指原味鸡+黄金脆皮鸡才九块九,我是真的不想错过!

    目录

    List

    List集合概述和特点

    List集合特有方法

    并发修改异常

    ListIterator

    增强for循环

    List集合子类特点

    LinkedList集合的特有功能

    List

    List集合概述和特点

    先到帮助文档中查看:

    它在java.util包下,使用它需要导包。<E>是泛型，是List集合中的类型。往下看List是一个接口它继承自Collection接口，所以Collection接口中有的功能List都可以使用。

    List被称为有序集合也被称为序列。

    用户可以精确控制列表中每个元素的插入位置。 用户可以通过整数索引（列表中的位置）访问元素，并搜索列表中的元素（这句话带表List是有索引的）。

    与Set集合不同，列表通常允许重复元素。

    看完之后我们总结一下：

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

    List集合特点：

    1. 有序：存储和取出的元素顺序一致。
    2. 可重复：存储的元素可以重复。

    程序演示特点：

    1. import java.util.ArrayList;
    2. import java.util.Iterator;
    3. import java.util.List;
    4.  
    5. /*
    6.     List集合特点：
    7.         	有序：存储和取出的元素顺序一致。
    8.         	可重复：存储的元素可以重复。
    10.  */
    11. public class ListDemo01 {
    12.     public static void main(String[] args) {
    13.         //创建集合对象
    14.         List<String> list = new ArrayList<String>();
    15.  
    16.         //添加元素
    17.         list.add("hello");
    18.         list.add("java");
    19.         list.add("hello");
    20.  
    21.         //输出集合对象
    22. //        System.out.println(list);//[hello, java]
    23.  
    24.         //遍历List结合,采用迭代器的方式遍历
    25.         Iterator<String> iterator = list.iterator();
    26.         while(iterator.hasNext()){
    27.             String next = iterator.next();
    28.             System.out.println(next);//hello java hello
    29.         }
    30.     }
    31. }

    List集合特有方法

    List方法Collection是没有的，但是它的子类ArrayList是有的。这几个方法在学习集合基础的时候已经使用过了，再来看一遍。

    程序演示：

    1. import java.util.ArrayList;
    2. import java.util.Iterator;
    3. import java.util.List;
    4. /*
    5.     List集合特有方法:
    6.         void add(int index, E element) 将指定元素插入此集合中的指定位置.
    7.         E remove(int index) 删除此集合中指定位置的元素.
    8.         E get(int index) 返回此集合中指定位置的元素.
    9.         E set(int index,E element) 修改指定索引处的元素,返回被修改的元素.
    10.  */
    11. public class ListDemo02 {
    12.     public static void main(String[] args) {
    13.         //创建集合对象
    14.         List<String> list = new ArrayList<String>();
    15.  
    16.         //添加元素
    17.         list.add("hello");
    18.         list.add("java");
    19.         list.add("hello");
    20.  
    21.         //void add(int index, E element) 将指定元素插入此集合中的指定位置.
    22.         list.add(2,"is");
    23.         list.add(3,"my");
    24.         list.add(4,"favourite");
    25.         System.out.println(list);//[hello, java, is, my, favourite, hello]
    26. //        list.add(11, "List");//IndexOutOfBoundsException(索引越界异常)
    27.         //上面这一句代码,因为集合中没有这么多个元素所以,使用这个索引是有问题的.try一下或者注释掉
    28.         System.out.println("---------------");
    29.  
    30.         //E remove(int index) 删除此集合中指定位置的元素.
    31.         System.out.println(list.remove(5));//返回hello,表示索引为5的hello元素被删除掉了
    32.         System.out.println(list);
    33. //        System.out.println(list.remove(13));//IndexOutOfBoundsException索引越界
    34.         //上面一条输出语句报错,注释掉
    35.         System.out.println("---------------");
    36.  
    37.         //E get(int index) 返回此集合中指定位置的元素.
    38.         System.out.println(list.get(3));//my
    39. //        System.out.println(list.get(11));//报错IndexOutOfBoundsException
    40.         //List是有索引的,注意带索引操作的时候索引不要越界
    41.         System.out.println("---------------");
    42.         //E set(int index,E element) 修改指定索引处的元素,返回被修改的元素.
    43.         System.out.println(list.set(1,"javaweb"));//java被修改为javaweb
    44.         //验证
    45.         System.out.println(list);//[hello, javaweb, is, my, favourite]
    46.         System.out.println("---------------");
    47.         //遍历集合
    48.         Iterator<String> iterator = list.iterator();
    49.         while(iterator.hasNext()){
    50.             String next = iterator.next();
    51.             System.out.println(next);
    52.         }
    53.         System.out.println("---------------");
    54.  
    55.         //不使用迭代器遍历List集合,此处size会返回最大索长度.
    56.         for (int x = 0; x < list.size();x++){
    57.             String s = list.get(x);
    58.             System.out.println(s);
    59.         }//这两种方式都是可以的.
    60.  
    61.  
    62.     }
    63. }

     

    并发修改异常

    先到程序中演示：

    到帮助文档中查看这个异常类的详细信息:

    这个异常继承自RunTimeException所以这个异常是一个运行时异常。

    接着来看详细解释：

    当不允许这样的修改时，检测到对象的并发修改的方法可能抛出此异常（这个就是我们说的并发修改异常）。

    继续分析异常产生的原因：

    问题出现在第二十五行代码，然后就因该是在这一行的next方法这里出现的问题，接着往上看，at java.base/java.util.ArrayList$Itr.next(ArrayList.java:996)这是java.util包下ArrayList这个集合里面的，Itr是一个内部类，它里面的next方法出现了问题，二next方法在里面又调用了这样一个方法：checkForComodification，最终就是在checkForComodification这里出现的问题，我们想把问题清楚的看到我们就得去看一下源码：

    首先跟进List方法：

    1. public interface List<E> extends Collection<E> {
    2.         Iterator<E> iterator();
    3.         boolean add(E e);
    4. }
    5.  
    6. public abstract class AbstractList<E>{
    7.     protected int modCount = 0;//这个变量是protected修饰的,所以它的两个子类都可以访问到
    8. }
    9.  
    10. public class ArrayList<E> extends AbstractList<E>implements List<E>{
    11.     /*10.get方法并没有做实际修改集合和预期修改集合的次数判断,他只是做了一个获取这个元素.
    12.     虽然add方法会对实际修改集合的次数做++但是get方法不会做这个判断所以不会出现并发修改异常
    13.     */
    14.     public E get(int index) {
    15.         Objects.checkIndex(index, size);
    16.         return elementData(index);
    17.     }
    18.  
    19.     public boolean add(E e) {//6.在add方法里面做了一个操作
    20.         modCount++;//7.对实际修改集合的次数做了一个++,但是预期修改集合的次数没有做++
    21.         add(e, elementData, size);
    22.         return true;
    23.     }
    24.         //实现接口就得实现接口中的方法
    25.         public Iterator<E> iterator() {
    26.                 return new Itr();
    27.         }
    28.         //然后new了一个Itr,吧Itr也拿过来,(吧用不上的删掉了)
    29. private class Itr implements Iterator<E> {
    30.         int expectedModCount = modCount;//1.一开始这两个值都是0
    31.         /*
    32.         modCount:实际修改集合的次数
    33.         expectedModCount:预期修改集合的次数
    36.         */
    37.         @SuppressWarnings("unchecked")
    38.         public E next() {//2.这里list调用list方法
    39.             checkForComodification();
    40.             int i = cursor;
    41.             if (i >= size)
    42.                 throw new NoSuchElementException();
    43.             Object[] elementData = ArrayList.this.elementData;
    44.             if (i >= elementData.length)
    45.                 throw new ConcurrentModificationException();
    46.             cursor = i + 1;
    47.             return (E) elementData[lastRet = i];
    48.         }
    49.  
    50.         final void checkForComodification() {//3.每次调用next方法的时候
    51.         /*
    52.         8.然后到下一次调用checkForComodification()方法的时候,然后进入if判断,判定
    53.         这两发变量的值是否一样,那肯定是不一样的,不一样的话就会抛出并发修改异常.
    54.         */
    55.             if (modCount != expectedModCount)//4.都会判定这了两个变量的值是否一致
    56.                 throw new ConcurrentModificationException();
    57.                 /*
    58.                 5.
    59.                 从正常来看这两个变量的值都是一致的,但是我们做了一个操作,一旦字符串s的值和world
    60.                 相等,就会通过list调用add方法.
    61.                 */
    62.         }
    63.     }
    64. }
    65. /*
    66. 9.
    67. 所以说并发修改异常的原因就是通过迭代器遍历的过程中,我通过集合去添加了元素,那么就造成了
    68. 我这个迭代器在获取元素的时候,里面在进行判断预期修改集合的次数和实际修改集合的次数不一致的清空
    69. 这样就造成了并发修改异常.
    70. */

     然后对代码进行修改：

    1. /*
    2.     需求:
    3.         我有一个集合:List<String> list = new ArrayList<String>();
    4.         里面有三个元素:list.add("hello"); list.add("world"); list.add("java");
    5.         遍历集合,得到每一个元素,看看有没有"world"这个元素,如果由,我就添加一个"javaee"元素,请写代码实现
    7.         ConcurrentModificationException:
    8.         当不允许这样的修改时，检测到对象的并发修改的方法可能抛出此异常（这个就是我们说的并发修改异常）。
    9.  */
    10. public class ListDemo {
    11.     public static void main(String[] args) {
    12.         List<String> list = new ArrayList<String>();
    13.         list.add("hello");
    14.         list.add("world");
    15.         list.add("java");
    16.  
    17.         //1.遍历集合
    18.         Iterator<String> iterator = list.iterator();
    19. //        while (iterator.hasNext()) {
    20. //            String next = iterator.next();
    21. //            if (next.equals("world")) {
    22. //                list.add("javaee");
    23. //            }
    24. //        }
    25.         //3.看完源码后解决问题(不使用迭代器),使用for循环遍历
    26.         for (int x =0;x < list.size();x++){
    27.             if (list.get(x).equals("world")){
    28.                 list.add("javaee");
    29.             }
    30.         }
    31.         System.out.println(list);
    32.         /*
    33.         使用next方法他会使用判断,我们使用get方法不会使用判断吗?
    34.         跟进一下get方法
    35.          */
    36.  
    37.         //2.输出集合
    38.             System.out.println(list);//执行就报错：ConcurrentModificationException（并发修改异常）
    39.     }
    40. }

    并发修改异常：

    1. ConcurrentModificationException

    产生原因：

    1. 迭代器遍历过程中，通过集合对象修改了集合中元素的长度，造成了迭代器获取元素中判断预期修改次数和实际修改次数的值不一致。

    解决方案：

    使用for循环遍历，然后用集合对象做对应的操作即可。

    ListIterator

    先到帮助文档中查看：

    它在java.util包下，所以使用它是需要导包的。它是一个接口，继承自Iterator接口。所以ListIterator可以直接使用hasnext方法和next方法的。因为Iterator里面有这两个方法的定义。

    前面用Iterator它只能从前面往后面遍历，ListIterator是可以从任意方向遍历列表的迭代器（可以从后往前遍历），这就是ListIterator和Iterator的区别。ListIterator还可以在迭代期间修改列表（也就是增删元素）；并获取列表中迭代器的当前位置。

    再往下看：

    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)：将指定的元素插入列表

    程序演示：

    1. import java.util.ArrayList;
    2. import java.util.List;
    3. import java.util.ListIterator;
    4.  
    5. /*
    6.     ListIterator:列表迭代器
    7.         	通过List集合的listIterator()方法得到,所以说它是List集合特有的迭代器。
    8.         	允许程序员在任一方向上遍历列表，在迭代期间修改列表，并获取迭代器在列表中的当前位置。
    10.     ListIterator中的常用方法：
    11.         	E next()：返回迭代中的下一个元素。
    12.         	boolean hasNext()：如果迭代具有更多元素，则返回true。
    13.         	E previous()：返回列表中的上一个元素。
    14.         	boolean hasPrevious()：如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true。
    15.         	void add(E e)：将指定的元素插入列表
    17.  */
    18. public class ListIteratorDemo {
    19.     public static void main(String[] args) {
    20.         //1.创建集合对象
    21.         List<String> list = new ArrayList<String>();
    22.  
    23.         //2.添加元素
    24.         list.add("hello");
    25.         list.add("world");
    26.         list.add("java");
    27.  
    28.         /*5.1注释掉3和4的代码
    29.         //3.通过List集合的listIterator()方法得到,所以说它是List集合特有的迭代器。
    30.         ListIterator<String> stringListIterator = list.listIterator();
    31.         while(stringListIterator.hasNext()){
    32.             String next = stringListIterator.next();
    33.             System.out.println(next);//hello world java
    34.         }
    35.         System.out.println("--------------");
    37.         //4.反向遍历
    38.         while (stringListIterator.hasPrevious()){
    39.             String previous = stringListIterator.previous();
    40.             System.out.println(previous);// java world hello
    41.         }
    42.         */
    43.  
    44.         //5.注释掉3和4的代码,我们来重点演示add
    45.  
    46.         //6.获取列表迭代器
    47.         ListIterator<String> stringListIterator = list.listIterator();
    48.         //7.遍历集合,如果集合中存在元素world则往结合中添加 "javaee" 元素
    49.         while(stringListIterator.hasNext()){
    50.             String next = stringListIterator.next();
    51.             if (next.equals("world")){
    52.                 stringListIterator.add("javaee");//这一次不是通过集合添加,而是通过列表迭代器调add方法来添加的
    53.             }
    54.         }
    55.         /*
    56.         8.研究完底层代码只之后了解了
    57.         我们通过列表迭代器也可以实现往集合中添加元素,用的是列表迭代器的add方法,他不会产生并发修改异常,因为它的底层
    58.         最终会把实际修改次数的值赋值给预期修改次数变量.
    59.          */
    60.         System.out.println(list);//[hello, world, javaee, java]
    61.     }
    62. }

    底层源码分析：

    1. public interface List<E> extends Collection<E> {
    2.         Iterator<E> iterator();
    3.  
    4.         //1.这里应该会有这个方法
    5.         ListIterator<E> listIterator();
    6. }
    7.  
    8. public abstract class AbstractList<E>{
    9.     protected int modCount = 0;//这个变量是protected修饰的,所以它的两个子类都可以访问到
    10. }
    11.  
    12. public class ArrayList<E> extends AbstractList<E>implements List<E>{
    13.     //2.同样在ArrayList里也应该有同样的方法
    14.     public ListIterator<E> listIterator() {
    15.         return new ListItr(0);//3.这里new了一个ListItr我们就要去找到它
    16.         /*
    17.         6.LIstIterator方法返回的是ListIterator,
    18.         new的是ListItr,然后来看ListItr类
    19.         */
    20.     }
    21.  
    22.  
    23.  
    24.     private class Itr implements Iterator<E> {
    25.     //5.这里Itr的实现被我省略掉了
    26.     }
    27.  
    28.      //4.Iterator返回的是Iterator,new的是Itr.
    29.     public Iterator<E> iterator() {
    30.             return new Itr();
    31.     }
    32. }
    33.     //7.继承自Itr实现了ListIterator接口
    34.     /*
    35.     8.所以说在我们代码中ListIterator<String> stringListIterator = list.listIterator();
    36.     得到的其实是ListIterator实现类对象,也就是我们这个ListItr的对象,因为ListItr实现了ListIterator接口
    37.     */
    38. private class ListItr extends Itr implements ListIterator<E> {
    39.     //9.其他方法删掉,就看一个方法就好了
    40.     public void add(E e) {
    41.         checkForComodification();
    42.  
    43.         try {
    44.             int i = cursor;
    45.             ArrayList.this.add(i, e);
    46.             cursor = i + 1;
    47.             lastRet = -1;
    48.             expectedModCount = modCount;//10.主要看着一句,会把实际修改次数,赋值给预期修改次数
    49.             //11.这样我们在调用next方法做判断的时候,这两个变量的值就是一致的,所以它就不会出现并发修改异常
    50.         } catch (IndexOutOfBoundsException ex) {
    51.             throw new ConcurrentModificationException();
    52.         }
    53.     }
    54. }
    55. }

    增强for循环

    我们先到帮助文档中再来查看一下Collection：

    它继承自Iterable接口，接着来看Iterable接口：

    所以Collection体系的集合都可以成为增强for语句的目标。

    在Iterable里面有一个iterator方法，所以说增强for语句其底层就是包装一个迭代器。

    概述：

    增强for循环：简化数组和Collection集合的遍历

    1. 实现Iterable接口的类允许其对象称为增强型for语句的目标
    2. 它是JDK5之后出现的，其内部原理是一个Iterator迭代器。

    增强for的格式：

    1. 格式：

    for（元素数据类型 变量名：数组或者Collection集合）{

    //在此处使用变量即可，该变量就是元素

    }

    格式：

    int[] arr = {1,2,3,4,5};

    for(int i : arr){

         System.out.println(i);

    }

    程序演示

    1. import java.util.ArrayList;
    2. import java.util.List;
    3.  
    4. /*
    5.     增强for循环：简化数组和Collection集合的遍历
    6.         	实现Iterable接口的类允许其对象称为增强型for语句的目标
    7.         	它是JDK5之后出现的，其内部原理是一个Iterator迭代器。
    9.     增强for的格式:
    10.         for（元素数据类型 变量名：数组或者Collection集合）{
    11.             //在此处使用变量即可，该变量就是元素
    12.         }
    14.  */
    15. public class ForDemo {
    16.     public static void main(String[] args) {
    17.         //定义一个int类型数组
    18.         int[] arr = {1,2,3,4,5};
    19.         for (int i : arr){
    20.             System.out.println(i);//1 2 3 4 5
    21.         }
    22.         System.out.println("-----------------");
    23.  
    24.         String[] strArray = {"hello","world","java"};
    25.         for (String str : strArray){
    26.             System.out.println(str);//hello world java
    27.         }
    28.         System.out.println("-----------------");
    29.  
    30.         //定义集合
    31.         List<String> list = new ArrayList<String>();
    32.         list.add("hello");
    33.         list.add("world");
    34.         list.add("java");
    35.         for (String str1 : list){
    36.             System.out.println(str1);
    37.         }
    38.         System.out.println("-----------------");
    39.         /*验证for增强循环内部是一个Iterator迭代器
    40.         如果for增强循环是一个迭代器,那么就相当于迭代器
    41.         遍历集合,然后判断里面有没有元素为world,如果有
    42.         通过集合调用add方法,往集合内添加一个元素,这个时候
    43.         就会抛出一个并发修改异常.如果这里抛出了并发修改异常,
    44.         那就说明它的内部就是一个迭代器.
    45.          */
    46.         for (String s : list){
    47.             if (s.equals("world")){
    48.                 list.add("javaee");
    49.             }
    50.             System.out.println(s);//ConcurrentModificationException
    51.         }
    52.     }
    53. }

    List集合子类特点

    List集合常用子类:ArrayList，LinkedList。

    先到帮助文档中查看ArrayList：

    ArrayList实现了List接口，看下面描述，List接口可调整大小的数组实现，也就是说ArrayList集合底层数据结构是数组，数组的特点是查询快增删慢。

    然后再来查看LinkedList：

    LinkedList实现了List接口

    它是链表实现了List接口，由此可见LinkedList的底层结构是链表，链表的结构是查询慢，增删快。

    1. ArrayList：底层数据结构是数组，查询快，增删慢。
    2. LinkedList：底层数据结构是链表，增删快，查询慢。

    关于ArrayList它们的一些功能，不再学习，因为List有的它们都有；它们的用法和List是一模一样的，所以我们就不分别去学习它们的基本使用，但是我们以后在使用的时候要根据做查询还是做增删来选择集合。

    我们来做一个ArrayList集合的案例：

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

    思路：

    • 定义学生类
    • 创建集合
    • 创建学生对象
    • 将学生对象添加进集合
    • 使用三种方式遍历集合

    程序演示：

    1. import java.util.ArrayList;
    2. import java.util.Iterator;
    3.  
    4. public class Student {
    5.     String name;
    6.     int age;
    7.  
    8.     public Student() {
    9.     }
    10.  
    11.     public Student(String name, int age) {
    12.         this.name = name;
    13.         this.age = age;
    14.     }
    15.  
    16.     public String getName() {
    17.         return name;
    18.     }
    19.  
    20.     public void setName(String name) {
    21.         this.name = name;
    22.     }
    23.  
    24.     public int getAge() {
    25.         return age;
    26.     }
    27.  
    28.     public void setAge(int age) {
    29.         this.age = age;
    30.  
    31.     }
    32. }
    33.  
    34. /*
    35.     需求：创建一个存储学生对象的集合，存储三个学生对象，实用程序实现在控制台遍历该集合。
    37.     思路：
    38.         ①	定义学生类
    39.         ②	创建集合
    40.         ③	创建学生对象
    41.         ④	将学生对象添加进集合
    42.         ⑤	使用三种方式遍历集合
    44.  */
    45. class ArrayListDemo {
    46.     public static void main(String[] args) {
    47.         //创建ArrayList集合
    48.         ArrayList<Student> arrayList = new ArrayList<>();
    49.         //创建学生对象
    50.         Student s1 = new Student("林青霞", 26);
    51.         Student s2 = new Student("张曼玉", 24);
    52.         Student s3 = new Student("王祖贤", 31);
    53.         //讲学生对象添加到集合中
    54.         arrayList.add(s1);
    55.         arrayList.add(s2);
    56.         arrayList.add(s3);
    57.  
    58.         //增强for循环
    59.         for (Student student : arrayList) {
    60.             System.out.println(student.getName() + "." + student.getAge());
    61.         }
    62.         System.out.println("----------");
    63.  
    64.         //普通for循环
    65.         for (int x = 0; x < arrayList.size(); x++) {
    66.             Student student = arrayList.get(x);
    67.             System.out.println(student.getName() + "." + student.getAge());
    68.         }
    69.         System.out.println("----------");
    70.  
    71.         //迭代器遍历
    72.         Iterator<Student> iterator = arrayList.iterator();
    73.         while (iterator.hasNext()) {
    74.             Student student = iterator.next();
    75.             System.out.println(student.getName() + "." + student.getAge());
    76.         }
    77.     }
    78. }

    LinkedList集合的特有功能

    程序演示：

    1. import java.util.LinkedList;
    2.  
    3. /*
    4.     LinkedList集合的特有功能:
    5.         void addFirst(E e) 在此列表的开头插入指定的元素。
    6.         void addLast(E e) 将指定的元素追加到此列表的末尾。
    8.         E getFirst() 返回此列表中的第一个元素。
    9.         E getLast() 返回此列表中的最后一个元素。
    11.         E removeFirst() 从此列表中删除并返回第一个元素。
    12.         E removeLast() 从此列表中删除并返回最后一个元素。
    13.  */
    14. public class LInkedListDemo {
    15.     public static void main(String[] args) {
    16.         //1.创建LinkedList集合对象
    17.         LinkedList<String> linkedList = new LinkedList<>();
    18.  
    19.         //2.添加元素
    20.         linkedList.add("hello");
    21.         linkedList.add("world");
    22.         linkedList.add("java");
    23.  
    24.  
    25.         //3.void addFirst(E e) 在此列表的开头插入指定的元素。
    26.         linkedList.addFirst("javaweb");
    27.         System.out.println(linkedList);//[javaweb, hello, world, java]
    28.  
    29.         //4.E getLast() 返回此列表中的最后一个元素。
    30.         linkedList.addLast("favourite");
    31.         System.out.println(linkedList);//[javaweb, hello, world, java, favourite]
    32.  
    33.         //5.E getFirst() 返回此列表中的第一个元素。
    34.         String first = linkedList.getFirst();
    35.         System.out.println(first);//javaweb
    36.  
    37.         //6.E getLast() 返回此列表中的最后一个元素。
    38.         String last = linkedList.getLast();
    39.         System.out.println(last);
    40.         System.out.println("---------------------");
    41.  
    42.         //7.E removeFirst() 从此列表中删除并返回第一个元素。
    43.         String s = linkedList.removeFirst();
    44.         System.out.println("删除了:"+ s);//删除了:javaweb
    45.         System.out.println(linkedList);//[hello, world, java, favourite]
    46.         System.out.println("---------------------");
    47.  
    48.         //8.E removeLast() 从此列表中删除并返回最后一个元素。
    49.         String s1 = linkedList.removeLast();
    50.         System.out.println("删除了:"+ s1);//删除了:favourite
    51.         System.out.println(linkedList);//[hello, world, java]
    52.     }
    53. }

     --欢迎大家与我一起交流java知识

     

  • 相关阅读:
    “U锂融合”——双碳新标兵
    配电网稳定性的分析（Python代码实现）
    java学到什么程度才算是精通？
    pg_test_fsync的使用说明
    PIC16C程序调用汇编程序的问题
    计算机硬件和软件
    AYIT嵌入式实验室2023级C语言训练1-4章训练题
    【每日一题】50. Pow(x, n)
    基于springboot服饰电商平台的设计与开发-计算机毕业设计源码+LW文档
    MMICCI2015- U-Net: Convolutional Networks for Biomedical Image Segmentation
  • 原文地址：https://blog.csdn.net/weixin_67796933/article/details/125436937