当前位置：首页 > article >正文

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

article 2024/11/9 17:59:42

一、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.向集合中添加单个元素

    /**
     * 在集合中添加单个元素
     * @return 返回集合列表
     */
    private List<String>  add(){
        List<String> list = new ArrayList<String>();
        list.add("01_贷款");
        list.add("02_贴现");
        list.add("03_承兑");
        list.add("04_保函");
        list.add("05_信用证");
        return list;
    }

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

    /**
     * 在集合的指定下标处添加单个元素
     * @param list 集合对象
     * @param index 索引位置
     * @param obj 需要添加的元素对象
     * @return  变更后的集合对象
     */
    private List<String>  addForIndex(int index,List<String> list,String obj){
        list.add(index,obj);
        return list;
    }

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

    /**
     * 在集合的尾部添加子集合
     * @param list 集合对象
     * @return 返回合并后的集合对象
     */
    private List<String>  addSubListDemo(List<String> list){
        //定义一个子集合列表
        List<String> subList = new ArrayList<>();
        subList.add("06_委托贷款");
        subList.add("07_垫款");
        subList.add("08_贷款承诺");
        subList.add("09_担保");
        //将定义的子集合添加到已知集合的末尾
        list.addAll(subList);
        return list;
    }

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

    /**
     * 在集合的指定索引位置添加子集合列表
     * @param list 集合对象
     * @param index 索引位置
     * @return 返回合并后的集合对象
     */
    private List<String>  addSubListForIndexDemo(List<String> list,int index){
        //定义一个子集合列表
        List<String> subList = new ArrayList<>();
        subList.add("06_委托贷款");
        subList.add("07_垫款");
        subList.add("08_贷款承诺");
        subList.add("09_担保");
        //将定义的子集合添加到已知集合的指定索引位置
        list.addAll(index,subList);
        return subList;
    }

5.获取集合的元素数量

    /**
     * 获取集合元素的数量大小
     * @param list 集合对象
     * @return 返回集合中元素的数量
     */
    private Integer  getListSize(List<String> list){
        return list.size();
    }

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

    /**
     * 获取集合中指定元素对象的索引位置
     * @param list 集合对象
     * @param obj 元素对象
     * @return 返回元素的索引位置
     */
    private Integer  getIndexForElement(List<String> list,String obj){
        return list.indexOf(obj);
    }

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

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

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

    /**
     * 将指定元素对象从集合中移除
     * @param list 集合对象
     * @param obj  需要移除的元素
     * @return 是否移除成功
     */
    private boolean  removeListElement(List<String> list,String obj){
        return list.remove(obj);
    }

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

    /**
     * 将集合中指定索引位置的元素替换为新的元素对象
     * @param list 集合对象
     * @param index 指定的索引位置
     * @param obj 替换的新元素
     * @return   返回被替换的元素
     */
    private String  getSetElementForIndex(List<String> list,Integer index,String obj){
        return list.set(index,obj);
    }

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

    /**
     * 从已知集合中根据指定索引范围截取一个新的集合返回
     * @param list 集合对象
     * @param startIndex 起始索引
     * @param endIndex 结束索引
     * @return 返回获取的子集合
     */
    private List<String>   getSetElementForIndex(List<String> list,Integer startIndex,Integer endIndex){
        return  list.subList(startIndex, endIndex);
    }

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

    /**
     * 从已知集合中转换为一个对象数组返回
     * @param list 集合对象
     * @return 返回集合的数组对象
     */
    private Object[]  getToArrayForList(List<String> list){
        return  list.toArray();
    }

四、LinkedList类

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

其特点包括

优点

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

2. 缺点：

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

五、Linkedist常用方法实例

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

addFirst、offerFirst：将元素添加到集合的头部，并返回true

import java.util.LinkedList;

public class LinkedListDemo {

    public static void main(String[] args) {

        LinkedList linkedList =  new LinkedList<String>();
        LinkedListDemo listDemo = new LinkedListDemo();
        linkedList =  listDemo.addLinkedList();
        System.out.println("初始集合元素包括："+linkedList);
        linkedList.addFirst("05_信用证");
        linkedList.offerFirst("06_电票");
        System.out.println("头部添加后的集合元素包括："+linkedList);
 
    }

    private LinkedList addLinkedList(){
        LinkedList linkedList =  new LinkedList<String>();
        linkedList.add("01_贷款");
        linkedList.add("02_贴现");
        linkedList.add("03_承兑");
        linkedList.add("04_保函");
        return linkedList;

    }
}

执行结果：
   初始集合元素包括：[01_贷款, 02_贴现, 03_承兑, 04_保函]
   头部添加后的集合元素包括：[06_电票, 05_信用证, 01_贷款, 02_贴现, 03_承兑, 04_保函]

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

add(E e)、offer(E e)、offerLast(E e)：将元素添加到集合的尾部，并返回true
addLast(E e)：将元素添加到集合的尾部，无返回值

import java.util.LinkedList; 
public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList linkedList =  new LinkedList<String>();
        LinkedListDemo listDemo = new LinkedListDemo();
        listDemo.addElement(linkedList,"01_贷款");
        listDemo.addElementForOffer(linkedList,"02_贴现");
        listDemo.addElementForOfferLast(linkedList,"03_承兑");
        listDemo.addElementForAddLast(linkedList,"04_保函");
        System.out.println("集合元素包括："+linkedList);
    }

    private boolean addElement(LinkedList<Object> linkedList,Object obj){
        return linkedList.add(obj);
    }

    private boolean addElementForOffer(LinkedList<Object> linkedList,Object obj){
        return linkedList.add(obj);
    }

    private boolean addElementForOfferLast(LinkedList<Object> linkedList,Object obj){
        return linkedList.offerLast(obj);
    }

    private void addElementForAddLast(LinkedList<Object> linkedList,Object obj){
        linkedList.addLast(obj);
    }
}

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

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

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

 //若不做空判断将会抛NoSuchElementException
    private String getElementForElement(LinkedList<String> linkedList){
        String element = linkedList==null||linkedList.size()==0?"":linkedList.element();
        return element;
    }
    //若不做空判断将会抛NoSuchElementException
    private String getElementForFirst(LinkedList<String> linkedList){
        String element = linkedList==null||linkedList.size()==0?"":linkedList.getFirst();
        return element;
    }
    //若不做空判断将返回null
    private String getElementForPeek(LinkedList<String> linkedList){
        String element =  linkedList.peek();
        return element;
    }
    //若不做空判断将返回null
    private String getElementForPeekFirst(LinkedList<String> linkedList){
        String element =  linkedList.peekFirst();
        return element;
    }

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

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

public class LinkedListDemo {

    public static void main(String[] args) {

        LinkedListDemo listDemo = new LinkedListDemo();
        LinkedList linkedList =  listDemo.addLinkedList();
        System.out.println("集合元素列表："+linkedList +
                           "\n根据索引获取指定元素："+listDemo.getElementForGet(linkedList,2) +
                           "\n获取集合头元素："+listDemo.getElementForFirst(linkedList)+
                           "\n获取集合尾元素："+listDemo.getElementForLast(linkedList) ); 

    }

    private LinkedList addLinkedList(){
        LinkedList linkedList =  new LinkedList<String>();
        linkedList.add("01_贷款");
        linkedList.add("02_贴现");
        linkedList.add("03_承兑");
        linkedList.add("04_保函");
        return linkedList;

    }


    public String getElementForGet(LinkedList<String> linkedList,Integer index){
        return linkedList!=null&&linkedList.size()>0?linkedList.get(index):"";
    }


    public String getElementForFirst(LinkedList<String> linkedList){
        return linkedList!=null&&linkedList.size()>0?linkedList.getFirst():"";
    }


    public String getElementForLast(LinkedList<String> linkedList){
        return linkedList!=null&&linkedList.size()>0?linkedList.getLast():"";
    }
}

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

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

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

public class LinkedListDemo {

    public static void main(String[] args) {
        LinkedListDemo listDemo = new LinkedListDemo();
        LinkedList linkedList =  listDemo.addLinkedList();

        System.out.println("原始集合元素列表："+linkedList +
                "\nPoll方法获取集合头元素："+listDemo.getElementForPoll(linkedList) +
                "\nPollFirst获取集合头元素："+listDemo.getElementForPollFirst(linkedList)+
                "\nPollLast获取集合尾元素："+listDemo.getElementForPollLast(linkedList) +"" +
                "\n检索集合元素后集合中的元素列表："+ linkedList);

    }

    private LinkedList addLinkedList(){
        LinkedList linkedList =  new LinkedList<String>();
        linkedList.add("01_贷款");
        linkedList.add("02_贴现");
        linkedList.add("03_承兑");
        linkedList.add("04_保函");
        linkedList.add("05_电票");
        return linkedList;

    }
 
    public String getElementForPoll(LinkedList<String> linkedList){
        return linkedList.poll();
    }
    public String getElementForPollFirst(LinkedList<String> linkedList){
        return linkedList.pollFirst();
    }
    public String getElementForPollLast(LinkedList<String> linkedList){
        return linkedList.pollLast();
    }
}

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

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

public class LinkedListDemo {
    
    public static void main(String[] args) {


        LinkedListDemo listDemo = new LinkedListDemo();
        LinkedList linkedList =   listDemo.addLinkedList();

        System.out.println("原始集合元素列表："+linkedList +
                        "\nremove方法删除集合头元素："+listDemo.removeElementForRemove(linkedList,2) +
                        "\nremove方法删除集合指定元素："+listDemo.removeElementForRemoveObj(linkedList,"05_电票") +
                        "\nremoveFirst方法删除集合头元素："+listDemo.removeElementForRemoveFirst(linkedList) +
                        "\nremoveLast方法删除集合尾元素："+listDemo.removeElementForRemoveLast(linkedList) +
                        "\n删除集合元素后集合中的元素列表："+ linkedList); 

    }

    private LinkedList addLinkedList(){
        LinkedList linkedList =  new LinkedList<String>();
        linkedList.add("01_贷款");
        linkedList.add("02_贴现");
        linkedList.add("03_承兑");
        linkedList.add("04_保函");
        linkedList.add("05_电票");
        linkedList.add("06_垫款");
        return linkedList;

    }


    public String removeElementForRemove(LinkedList<String> linkedList,int index){
        return linkedList!=null&&linkedList.size()>0? linkedList.remove(index):"";
    }

    public boolean removeElementForRemoveObj(LinkedList<String> linkedList,Object obj){
        return linkedList!=null&&linkedList.size()>0?linkedList.remove(obj):false;
    }

    public String removeElementForRemoveFirst(LinkedList<String> linkedList){
        return linkedList!=null&&linkedList.size()>0?linkedList.removeFirst():"";
    }
    public String removeElementForRemoveLast(LinkedList<String> linkedList){
        return linkedList!=null&&linkedList.size()>0?linkedList.removeLast():"";
    }

}

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

查看全文

http://www.kler.cn/a/108985.html