• java集合之List接口实现类常用方法详解

    目录

    一、List集合概述

    二、ArrayList类

    三、ArrayList常用方法实例

    四、LinkedList类

    五、Linkedist常用方法实例

    一、List集合概述

            java.util.List接口继承自Collection接口，是单列集合的一个分支，通常将实现了List接口的对象称为List集合，在List集合中允许出现重复的元素，所有的元素是以一种线性方式进行存储的，在程序中可以通过元素的索引下标来访问集合中的指定元素，另外List集合还有一个特点就是元素有序，即元素的存入顺序和取出顺序一致
           List接口常用方法列表说明详见    java集合之Collection接口体系-CSDN博客

    二、ArrayList类

            java.util.ArrayList是一个实现了List接口的单列集合实现类，底层是一个大小可变的数组的实现 
             java.util.ArrayList集合数据存储的结构本质是一个可变数组对象，其特点包括：

            1.查找快：日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是常用的集合。

            2.元素增删操作慢，一旦在某个位置增加、修改和删除数据，后面所有数据都必须往后移动

    三、ArrayList常用方法实例

            1.向集合中添加单个元素

    1.     /**
    2.      * 在集合中添加单个元素
    3.      * @return 返回集合列表
    4.      */
    5.     private List  add(){
    6.         List list = new ArrayList();
    7.         list.add("01_贷款");
    8.         list.add("02_贴现");
    9.         list.add("03_承兑");
    10.         list.add("04_保函");
    11.         list.add("05_信用证");
    12.         return list;
    13.     }

            2.在集合的指定索引下标处添加单个元素

    1.     /**
    2.      * 在集合的指定下标处添加单个元素
    3.      * @param list 集合对象
    4.      * @param index 索引位置
    5.      * @param obj 需要添加的元素对象
    6.      * @return  变更后的集合对象
    7.      */
    8.     private List  addForIndex(int index,List list,String obj){
    9.         list.add(index,obj);
    10.         return list;
    11.     }

            3.在集合的尾部添加子集合

    1.     /**
    2.      * 在集合的尾部添加子集合
    3.      * @param list 集合对象
    4.      * @return 返回合并后的集合对象
    5.      */
    6.     private List  addSubListDemo(List list){
    7.         //定义一个子集合列表
    8.         List subList = new ArrayList<>();
    9.         subList.add("06_委托贷款");
    10.         subList.add("07_垫款");
    11.         subList.add("08_贷款承诺");
    12.         subList.add("09_担保");
    13.         //将定义的子集合添加到已知集合的末尾
    14.         list.addAll(subList);
    15.         return list;
    16.     }

             4.在集合的指定索引下标位置添加子集合

    1.     /**
    2.      * 在集合的指定索引位置添加子集合列表
    3.      * @param list 集合对象
    4.      * @param index 索引位置
    5.      * @return 返回合并后的集合对象
    6.      */
    7.     private List  addSubListForIndexDemo(List list,int index){
    8.         //定义一个子集合列表
    9.         List subList = new ArrayList<>();
    10.         subList.add("06_委托贷款");
    11.         subList.add("07_垫款");
    12.         subList.add("08_贷款承诺");
    13.         subList.add("09_担保");
    14.         //将定义的子集合添加到已知集合的指定索引位置
    15.         list.addAll(index,subList);
    16.         return subList;
    17.     }

            5.获取集合的元素数量

    1.     /**
    2.      * 获取集合元素的数量大小
    3.      * @param list 集合对象
    4.      * @return 返回集合中元素的数量
    5.      */
    6.     private Integer  getListSize(List list){
    7.         return list.size();
    8.     }

            6.获取集合中指定元素对象的索引下标

    1.     /**
    2.      * 获取集合中指定元素对象的索引位置
    3.      * @param list 集合对象
    4.      * @param obj 元素对象
    5.      * @return 返回元素的索引位置
    6.      */
    7.     private Integer  getIndexForElement(List list,String obj){
    8.         return list.indexOf(obj);
    9.     }

            7.获取集合中指定元素最后一次的索引位置

    1.     /**
    2.      * 获取集合中指定元素最后一次的索引位置
    3.      * @param list 集合对象
    4.      * @param obj  元素对象
    5.      * @return 返回最后一次出现的索引位置
    6.      */
    7.     private Integer  getIndexForLastElement(List list,String obj){
    8.         return list.lastIndexOf(obj);
    9.     }

            8.将指定元素对象从集合中移除

    1.     /**
    2.      * 将指定元素对象从集合中移除
    3.      * @param list 集合对象
    4.      * @param obj  需要移除的元素
    5.      * @return 是否移除成功
    6.      */
    7.     private boolean  removeListElement(List list,String obj){
    8.         return list.remove(obj);
    9.     }

            9.将集合中指定索引下标位置的元素替换为新的元素对象

    1.     /**
    2.      * 将集合中指定索引位置的元素替换为新的元素对象
    3.      * @param list 集合对象
    4.      * @param index 指定的索引位置
    5.      * @param obj 替换的新元素
    6.      * @return   返回被替换的元素
    7.      */
    8.     private String  getSetElementForIndex(List list,Integer index,String obj){
    9.         return list.set(index,obj);
    10.     }

            10.将集合中的元素根据指定索引范围截取一个新的集合返回

    1.     /**
    2.      * 从已知集合中根据指定索引范围截取一个新的集合返回
    3.      * @param list 集合对象
    4.      * @param startIndex 起始索引
    5.      * @param endIndex 结束索引
    6.      * @return 返回获取的子集合
    7.      */
    8.     private List   getSetElementForIndex(List list,Integer startIndex,Integer endIndex){
    9.         return  list.subList(startIndex, endIndex);
    10.     }

            11.集合中的元素转换为一个对象数组返回

    1.     /**
    2.      * 从已知集合中转换为一个对象数组返回
    3.      * @param list 集合对象
    4.      * @return 返回集合的数组对象
    5.      */
    6.     private Object[]  getToArrayForList(List list){
    7.         return  list.toArray();
    8.     }

    四、LinkedList类

          java.util.LinkedList是一个实现了List接口的单列集合实现类，底层是一个双向链表，同时实现了实现了List和Deque接口

         其特点包括

    1. 优点
    • 由于LinkedList底层实现是双向链表，所以在进行插入和删除操作方面具有高效性。
    • 由于LinkedList是动态的数据结构，因此在使用时不需要预先分配空间
    • 由于LinkedList实现了Deque接口 在集合的队首和队尾可以进行高效的插入和删除操作

          2. 缺点：

    • 由于LinkedList底层实现是双链表，所以从集合中访问某个元素时需要从头开始遍历整个链表，所以其查询操作慢
    •  由于LinkedList在进行元素对象存储时，需要将指向下一个元素和上一个元素的指针同时进行存储，其占用的内存空间相比ArrayList数组要更多。
    • 由于LinkedList是基于链表实现的，因此不支持随机访问，只能通过遍历整个链表来访问元素

    五、Linkedist常用方法实例

    1.将指定元素添加到集合的头部，方法包括2个

    • addFirst、offerFirst：将元素添加到集合的头部，并返回true
    1. import java.util.LinkedList;
    2.  
    3. public class LinkedListDemo {
    4.  
    5.     public static void main(String[] args) {
    6.  
    7.         LinkedList linkedList =  new LinkedList();
    8.         LinkedListDemo listDemo = new LinkedListDemo();
    9.         linkedList =  listDemo.addLinkedList();
    10.         System.out.println("初始集合元素包括："+linkedList);
    11.         linkedList.addFirst("05_信用证");
    12.         linkedList.offerFirst("06_电票");
    13.         System.out.println("头部添加后的集合元素包括："+linkedList);
    14.  
    15.     }
    16.  
    17.     private LinkedList addLinkedList(){
    18.         LinkedList linkedList =  new LinkedList();
    19.         linkedList.add("01_贷款");
    20.         linkedList.add("02_贴现");
    21.         linkedList.add("03_承兑");
    22.         linkedList.add("04_保函");
    23.         return linkedList;
    24.  
    25.     }
    26. }
    1. 执行结果：
    2.    初始集合元素包括：[01_贷款, 02_贴现, 03_承兑, 04_保函]
    3.    头部添加后的集合元素包括：[06_电票, 05_信用证, 01_贷款, 02_贴现, 03_承兑, 04_保函]

    2.将指定的元素添加到集合的尾部，方法包括4个

    • add(E e)、offer(E e)、offerLast(E e)：将元素添加到集合的尾部，并返回true
    • addLast(E e)：将元素添加到集合的尾部，无返回值
    1. import java.util.LinkedList; 
    2. public class LinkedListDemo {
    3.     public static void main(String[] args) {
    4.         LinkedList linkedList =  new LinkedList();
    5.         LinkedListDemo listDemo = new LinkedListDemo();
    6.         listDemo.addElement(linkedList,"01_贷款");
    7.         listDemo.addElementForOffer(linkedList,"02_贴现");
    8.         listDemo.addElementForOfferLast(linkedList,"03_承兑");
    9.         listDemo.addElementForAddLast(linkedList,"04_保函");
    10.         System.out.println("集合元素包括："+linkedList);
    11.     }
    12.  
    13.     private boolean addElement(LinkedList linkedList,Object obj){
    14.         return linkedList.add(obj);
    15.     }
    16.  
    17.     private boolean addElementForOffer(LinkedList linkedList,Object obj){
    18.         return linkedList.add(obj);
    19.     }
    20.  
    21.     private boolean addElementForOfferLast(LinkedList linkedList,Object obj){
    22.         return linkedList.offerLast(obj);
    23.     }
    24.  
    25.     private void addElementForAddLast(LinkedList linkedList,Object obj){
    26.         linkedList.addLast(obj);
    27.     }
    28. }
    29.  
    30.  
      31.  

      执行结果：集合元素包括：[01_贷款, 02_贴现, 03_承兑, 04_保函]
       

      3.获取集合的头元素方法包括4个
       

      • element()、getFirst()：获取集合列表的头元素对象，若集合列表中无元素对象时抛出异常
      • peek()、peekFirst()：获取集合列表的头元素对象，若集合列表中无元素对象时返回null
       

      1.  //若不做空判断将会抛NoSuchElementException
      2.     private String getElementForElement(LinkedList linkedList){
      3.         String element = linkedList==null||linkedList.size()==0?"":linkedList.element();
      4.         return element;
      5.     }
      6.     //若不做空判断将会抛NoSuchElementException
      7.     private String getElementForFirst(LinkedList linkedList){
      8.         String element = linkedList==null||linkedList.size()==0?"":linkedList.getFirst();
      9.         return element;
      10.     }
      11.     //若不做空判断将返回null
      12.     private String getElementForPeek(LinkedList linkedList){
      13.         String element =  linkedList.peek();
      14.         return element;
      15.     }
      16.     //若不做空判断将返回null
      17.     private String getElementForPeekFirst(LinkedList linkedList){
      18.         String element =  linkedList.peekFirst();
      19.         return element;
      20.     }
       

      4.检索集合中的元素可分为两类即
       

      • 检索但不删除元素，包括三个方法，即get(int  index)、getFirst()、getLast(),使用该类方法获取集合中的元素，若集合不存在元素对象时，将抛出被请求的元素不存在异常，其中get(int Index)抛出数组越界异常，getFirst()和getLast()抛出空指针异常，所以在使用该类方法时需要注意空指针判断
       

      1. public class LinkedListDemo {
      2.  
      3.     public static void main(String[] args) {
      4.  
      5.         LinkedListDemo listDemo = new LinkedListDemo();
      6.         LinkedList linkedList =  listDemo.addLinkedList();
      7.         System.out.println("集合元素列表："+linkedList +
      8.                            "\n根据索引获取指定元素："+listDemo.getElementForGet(linkedList,2) +
      9.                            "\n获取集合头元素："+listDemo.getElementForFirst(linkedList)+
      10.                            "\n获取集合尾元素："+listDemo.getElementForLast(linkedList) ); 
      11.  
      12.     }
      13.  
      14.     private LinkedList addLinkedList(){
      15.         LinkedList linkedList =  new LinkedList();
      16.         linkedList.add("01_贷款");
      17.         linkedList.add("02_贴现");
      18.         linkedList.add("03_承兑");
      19.         linkedList.add("04_保函");
      20.         return linkedList;
      21.  
      22.     }
      23.  
      24.  
      25.     public String getElementForGet(LinkedList linkedList,Integer index){
      26.         return linkedList!=null&&linkedList.size()>0?linkedList.get(index):"";
      27.     }
      28.  
      29.  
      30.     public String getElementForFirst(LinkedList linkedList){
      31.         return linkedList!=null&&linkedList.size()>0?linkedList.getFirst():"";
      32.     }
      33.  
      34.  
      35.     public String getElementForLast(LinkedList linkedList){
      36.         return linkedList!=null&&linkedList.size()>0?linkedList.getLast():"";
      37.     }
      38. }
       

      1. 执行结果：
      2.     集合元素列表：[01_贷款, 02_贴现, 03_承兑, 04_保函]
      3.     根据索引获取指定元素：03_承兑
      4.     获取集合头元素：01_贷款
      5.     获取集合尾元素：04_保函
       

      • 检索的同时将检索的元素从集合中删除，包括六个方法 即poll()、pollFirst()、pollLast()、remove(int  index)、removeFirst()、removeLast()、​​​​​​​remove(Object obj)
       

             其中poll*() : 使用该类方法删除集合中的元素同时返回被删除的元素对象，若集合不存在元素对象时，则返回null，不会抛出异常
       

      1. public class LinkedListDemo {
      2.  
      3.     public static void main(String[] args) {
      4.         LinkedListDemo listDemo = new LinkedListDemo();
      5.         LinkedList linkedList =  listDemo.addLinkedList();
      6.  
      7.         System.out.println("原始集合元素列表："+linkedList +
      8.                 "\nPoll方法获取集合头元素："+listDemo.getElementForPoll(linkedList) +
      9.                 "\nPollFirst获取集合头元素："+listDemo.getElementForPollFirst(linkedList)+
      10.                 "\nPollLast获取集合尾元素："+listDemo.getElementForPollLast(linkedList) +"" +
      11.                 "\n检索集合元素后集合中的元素列表："+ linkedList);
      12.  
      13.     }
      14.  
      15.     private LinkedList addLinkedList(){
      16.         LinkedList linkedList =  new LinkedList();
      17.         linkedList.add("01_贷款");
      18.         linkedList.add("02_贴现");
      19.         linkedList.add("03_承兑");
      20.         linkedList.add("04_保函");
      21.         linkedList.add("05_电票");
      22.         return linkedList;
      23.  
      24.     }
      25.  
      26.     public String getElementForPoll(LinkedList linkedList){
      27.         return linkedList.poll();
      28.     }
      29.     public String getElementForPollFirst(LinkedList linkedList){
      30.         return linkedList.pollFirst();
      31.     }
      32.     public String getElementForPollLast(LinkedList linkedList){
      33.         return linkedList.pollLast();
      34.     }
      35. }
       

      1. 执行结果：
      2.     原始集合元素列表：[01_贷款, 02_贴现, 03_承兑, 04_保函, 05_电票]
      3.     Poll方法获取集合头元素：01_贷款
      4.     PollFirst获取集合头元素：02_贴现
      5.     PollLast获取集合尾元素：05_电票
      6.     检索集合元素后集合中的元素列表：[03_承兑, 04_保函]
       

         其中remove*() ： 使用该类方法删除集合中的元素同时返回被删除的元素对象(其中​​​​​​​remove(Object obj)方法返回是否删除成功的boolean值，成功返回true,否则返回false)，若集合为空时则抛出空指针异常，若集合不存在元素对象时， 抛出被请求的元素不存在异常
       

      1. public class LinkedListDemo {
      2.     
      3.     public static void main(String[] args) {
      4.  
      5.  
      6.         LinkedListDemo listDemo = new LinkedListDemo();
      7.         LinkedList linkedList =   listDemo.addLinkedList();
      8.  
      9.         System.out.println("原始集合元素列表："+linkedList +
      10.                         "\nremove方法删除集合头元素："+listDemo.removeElementForRemove(linkedList,2) +
      11.                         "\nremove方法删除集合指定元素："+listDemo.removeElementForRemoveObj(linkedList,"05_电票") +
      12.                         "\nremoveFirst方法删除集合头元素："+listDemo.removeElementForRemoveFirst(linkedList) +
      13.                         "\nremoveLast方法删除集合尾元素："+listDemo.removeElementForRemoveLast(linkedList) +
      14.                         "\n删除集合元素后集合中的元素列表："+ linkedList); 
      15.  
      16.     }
      17.  
      18.     private LinkedList addLinkedList(){
      19.         LinkedList linkedList =  new LinkedList();
      20.         linkedList.add("01_贷款");
      21.         linkedList.add("02_贴现");
      22.         linkedList.add("03_承兑");
      23.         linkedList.add("04_保函");
      24.         linkedList.add("05_电票");
      25.         linkedList.add("06_垫款");
      26.         return linkedList;
      27.  
      28.     }
      29.  
      30.  
      31.     public String removeElementForRemove(LinkedList linkedList,int index){
      32.         return linkedList!=null&&linkedList.size()>0? linkedList.remove(index):"";
      33.     }
      34.  
      35.     public boolean removeElementForRemoveObj(LinkedList linkedList,Object obj){
      36.         return linkedList!=null&&linkedList.size()>0?linkedList.remove(obj):false;
      37.     }
      38.  
      39.     public String removeElementForRemoveFirst(LinkedList linkedList){
      40.         return linkedList!=null&&linkedList.size()>0?linkedList.removeFirst():"";
      41.     }
      42.     public String removeElementForRemoveLast(LinkedList linkedList){
      43.         return linkedList!=null&&linkedList.size()>0?linkedList.removeLast():"";
      44.     }
      45.  
      46. }
       

      1. 执行结果：
      2.     原始集合元素列表：[01_贷款, 02_贴现, 03_承兑, 04_保函, 05_电票, 06_垫款]
      3.     remove方法删除集合头元素：03_承兑
      4.     remove方法删除集合指定元素：true
      5.     removeFirst方法删除集合头元素：01_贷款
      6.     removeLast方法删除集合尾元素：06_垫款
      7.     删除集合元素后集合中的元素列表：[02_贴现, 04_保函]
       

      
                
                    
                

                
    31. 

                    相关阅读:
      
                    
WebRTC视频采集模块                            
      
期货开户前先判定期货公司正规性                            
      
Flutter系列文章-Flutter应用优化                            
      
代码随想录 Day-45｜#139 单词拆分                            
      
麒麟KYLINOS命令行设置系统静音                            
      
信息中心网络提出的背景、研究现状及研究内容                            
      
Azure Service Fabric 踩坑日志                            
      
合并两个有序数组（美团面试）                            
      
Vue3 实现一个自定义toast（小弹窗）                            
      
JUC并发编程：Monitor和对象结构                            
      
                          
                
      32. 
                
    32. 
                    原文地址：https://blog.csdn.net/Calvex880714/article/details/133895903
                
      33.