如何使用Java中的List接口?代码实例

2021年3月19日13:40:16 发表评论 720 次浏览

本文概述

List接口提供了一种存储有序集合的方法。它是采集。它是对象的有序集合, 可以在其中存储重复值。由于List保留插入顺序, 因此它允许元素的位置访问和插入。

列表和数组Java集合框架中的列表

宣言:List接口声明为:

公共抽象接口List扩展Collection

列表示例:

// Java program to demonstrate a List
  
import java.util.*;
  
public class ListDemo {
     public static void main(String[] args)
     {
         // Creating a list
         List<Integer> l1
             = new ArrayList<Integer>();
  
         // Adds 1 at 0 index
         l1.add( 0 , 1 );
  
         // Adds 2 at 1 index
         l1.add( 1 , 2 );
         System.out.println(l1);
  
         // Creating another list
         List<Integer> l2
             = new ArrayList<Integer>();
  
         l2.add( 1 );
         l2.add( 2 );
         l2.add( 3 );
  
         // Will add list l2 from 1 index
         l1.addAll( 1 , l2);
         System.out.println(l1);
  
         // Removes element from index 1
         l1.remove( 1 );
         System.out.println(l1);
  
         // Prints element at index 3
         System.out.println(l1.get( 3 ));
  
         // Replace 0th element with 5
         l1.set( 0 , 5 );
         System.out.println(l1);
     }
}

输出如下:

[1, 2]
[1, 1, 2, 3, 2]
[1, 2, 3, 2]
2
[5, 2, 3, 2]

使用执行各种操作列表界面和ArrayList类

由于List是一个接口, 因此只能与实现此接口的类一起使用。现在, 让我们看看如何在列表上执行一些常用的操作。

1.添加元素:为了将元素添加到列表中, 我们可以使用add()方法。重载此方法可根据不同的参数执行多项操作。他们是:

  • 添加(对象):此方法用于在列表末尾添加元素。
  • add(int index, Object):此方法用于在列表中的特定索引处添加元素。
// Java program to add elements
// to a List
  
import java.util.*;
  
public class GFG {
  
     public static void main(String args[])
     {
         List<String> al = new ArrayList<>();
  
         al.add( "Geeks" );
         al.add( "Geeks" );
         al.add( 1 , "For" );
  
         System.out.println(al);
     }
}

输出如下:

[Geeks, For, Geeks]

2.改变要素:添加元素后, 如果我们希望更改元素, 则可以使用组()方法。由于List已建立索引, 因此我们希望更改的元素由该元素的索引引用。因此, 此方法采用索引和需要在该索引处插入的更新元素。

// Java program to change elements
// in a List
  
import java.util.*;
  
public class GFG {
  
     public static void main(String args[])
     {
         List<String> al = new ArrayList<>();
  
         al.add( "Geeks" );
         al.add( "Geeks" );
         al.add( 1 , "Geeks" );
  
         System.out.println( "Initial ArrayList " + al);
  
         al.set( 1 , "For" );
  
         System.out.println( "Updated ArrayList " + al);
     }
}

输出如下:

Initial ArrayList [Geeks, Geeks, Geeks]
Updated ArrayList [Geeks, For, Geeks]

3.删除元素:为了从列表中删除一个元素, 我们可以使用remove()方法。重载此方法可根据不同的参数执行多项操作。他们是:

  • remove(Object):此方法仅用于从列表中删除对象。如果存在多个此类对象, 则将删除对象的第一个匹配项。
  • remove(int index):由于列表已建立索引, 因此此方法采用整数值, 该整数值会简单地删除列表中该特定索引处存在的元素。删除元素后, 所有元素都将向左移动以填充空间, 并且对象的索引将更新。
// Java program to remove elements
// in a List
  
import java.util.*;
  
public class GFG {
  
     public static void main(String args[])
     {
         List<String> al = new ArrayList<>();
  
         al.add( "Geeks" );
         al.add( "Geeks" );
         al.add( 1 , "For" );
  
         System.out.println(
             "Initial ArrayList " + al);
  
         al.remove( 1 );
  
         System.out.println(
             "After the Index Removal " + al);
  
         al.remove( "Geeks" );
  
         System.out.println(
             "After the Object Removal " + al);
     }
}

输出如下:

Initial ArrayList [Geeks, For, Geeks]
After the Index Removal [Geeks, Geeks]
After the Object Removal [Geeks]

4.迭代列表:有多种方法可以遍历列表。最著名的方法是使用基本for循环结合get()方法使元素处于特定索引处, 并且先进的循环.

// Java program to iterate the elements
// in an ArrayList
  
import java.util.*;
  
public class GFG {
  
     public static void main(String args[])
     {
         List<String> al
             = new ArrayList<>();
  
         al.add( "Geeks" );
         al.add( "Geeks" );
         al.add( 1 , "For" );
  
         // Using the Get method and the
         // for loop
         for ( int i = 0 ; i < al.size(); i++) {
  
             System.out.print(al.get(i) + " " );
         }
  
         System.out.println();
  
         // Using the for each loop
         for (String str : al)
             System.out.print(str + " " );
     }
}

输出如下:

Geeks For Geeks 
Geeks For Geeks

创建列表对象

以来list是一个接口, 无法创建类型列表的对象。我们总是需要一个扩展此列表的类以创建一个对象。而且, 在引入泛型在Java 1.5中, 可以限制可以存储在List中的对象的类型。此类型安全列表可以定义为:

// Obj是要存储在List中的对象的类型List <Obj> list = new ArrayList <Obj>();

实现List接口的类

1.数组列表:在集合框架中实现的ArrayList类为我们提供了Java动态数组。虽然, 它可能比标准数组要慢, 但是在需要大量操作数组的程序中会很有帮助。让我们看看如何使用此类创建列表对象。

// Java program to demonstrate the
// creation of list object using the
// ArrayList class
  
import java.io.*;
import java.util.*;
  
class GFG {
     public static void main(String[] args)
     {
         // Size of ArrayList
         int n = 5 ;
  
         // Declaring the List with initial size n
         List<Integer> arrli
             = new ArrayList<Integer>(n);
  
         // Appending the new elements
         // at the end of the list
         for ( int i = 1 ; i <= n; i++)
             arrli.add(i);
  
         // Printing elements
         System.out.println(arrli);
  
         // Remove element at index 3
         arrli.remove( 3 );
  
         // Displaying the list after deletion
         System.out.println(arrli);
  
         // Printing elements one by one
         for ( int i = 0 ; i < arrli.size(); i++)
             System.out.print(arrli.get(i) + " " );
     }
}

输出如下:

[1, 2, 3, 4, 5]
[1, 2, 3, 5]
1 2 3 5

2.向量:Vector是在收集框架中实现的类, 该类实现可增长的对象数组。 Vector实现了动态数组, 这意味着它可以根据需要增长或缩小。像数组一样, 它包含可以使用整数索引访问的组件。向量基本上属于传统类, 但现在与集合完全兼容。让我们看看如何使用此类创建列表对象。

// Java program to demonstrate the
// creation of list object using the
// Vector class
  
import java.io.*;
import java.util.*;
  
class GFG {
     public static void main(String[] args)
     {
         // Size of the vector
         int n = 5 ;
  
         // Declaring the List with initial size n
         List<Integer> v = new Vector<Integer>(n);
  
         // Appending the new elements
         // at the end of the list
         for ( int i = 1 ; i <= n; i++)
             v.add(i);
  
         // Printing elements
         System.out.println(v);
  
         // Remove element at index 3
         v.remove( 3 );
  
         // Displaying the list after deletion
         System.out.println(v);
  
         // Printing elements one by one
         for ( int i = 0 ; i < v.size(); i++)
             System.out.print(v.get(i) + " " );
     }
}

输出如下:

[1, 2, 3, 4, 5]
[1, 2, 3, 5]
1 2 3 5

3.堆栈:Stack是一个在集合框架中实现的类, 它扩展了向量类模型并实现了堆栈数据结构。该课程基于后进先出的基本原则。除了基本的推入和弹出操作外, 该类还提供了空, 搜索和查看的三个功能。让我们看看如何使用此类创建列表对象。

// Java program to demonstrate the
// creation of list object using the
// Stack class
  
import java.io.*;
import java.util.*;
  
class GFG {
     public static void main(String[] args)
     {
         // Size of the stack
         int n = 5 ;
  
         // Declaring the List
         List<Integer> s = new Stack<Integer>();
  
         // Appending the new elements
         // at the end of the list
         for ( int i = 1 ; i <= n; i++)
             s.add(i);
  
         // Printing elements
         System.out.println(s);
  
         // Remove element at index 3
         s.remove( 3 );
  
         // Displaying the list after deletion
         System.out.println(s);
  
         // Printing elements one by one
         for ( int i = 0 ; i < s.size(); i++)
             System.out.print(s.get(i) + " " );
     }
}

输出如下:

[1, 2, 3, 4, 5]
[1, 2, 3, 5]
1 2 3 5

4.链表:LinkedList是在收集框架中实现的类, 该框架固有地实现了链表数据结构。它是一种线性数据结构, 其中元素没有存储在连续的位置, 并且每个元素都是具有数据部分和地址部分的单独对象。元素使用指针和地址链接。每个元素称为一个节点。由于动态性以及插入和删除的简便性, 它们比阵列更可取。让我们看看如何使用此类创建列表对象。

// Java program to demonstrate the
// creation of list object using the
// LinkedList class
  
import java.io.*;
import java.util.*;
  
class GFG {
     public static void main(String[] args)
     {
         // Size of the LinkedList
         int n = 5 ;
  
         // Declaring the List with initial size n
         List<Integer> ll = new LinkedList<Integer>();
  
         // Appending the new elements
         // at the end of the list
         for ( int i = 1 ; i <= n; i++)
             ll.add(i);
  
         // Printing elements
         System.out.println(ll);
  
         // Remove element at index 3
         ll.remove( 3 );
  
         // Displaying the list after deletion
         System.out.println(ll);
  
         // Printing elements one by one
         for ( int i = 0 ; i < ll.size(); i++)
             System.out.print(ll.get(i) + " " );
     }
}

输出如下:

[1, 2, 3, 4, 5]
[1, 2, 3, 5]
1 2 3 5

现在让我们来看看深入列出界面 为了更好的理解:

List-Array深度学习Java中的列表

在上图中, 摘要清单, CopyOnWriteArrayList和AbstractSequentialList是实现列表接口的类。在每个提到的类中实现了单独的功能。他们是:

  1. 摘要清单:此类用于实现不可修改的列表, 对于该列表只需扩展此AbstractList类并仅实现得到()和尺寸()方法。
  2. CopyOnWriteArrayList:此类实现列表接口。它是的增强版本数组列表其中所有修改(添加, 设置, 删除等)都是通过制作列表的新副本来实现的。
  3. AbstractSequentialList:此类实现采集界面和AbstractCollection类。此类用于实现不可修改的列表, 对于该列表只需扩展此AbstractList类并仅实现得到()和尺寸()方法。

列表界面的方法

由于不同类型的列表背后的主要概念相同, 因此列表接口包含以下方法:

方法 描述
add(int index, element) 此方法用于在列表中的特定索引处添加元素。传递单个参数时, 它只是将元素添加到列表的末尾。
addAll(int index, Collection collection) 此方法用于将给定集合中的所有元素添加到列表中。传递单个参数时, 它将给定集合的所有元素添加到列表的末尾。
尺寸() 此方法用于返回列表的大小。
明确() 此方法用于删除列表中的所有元素。但是, 创建的列表的引用仍被存储。
remove(int index) 此方法从指定的索引中删除一个元素。它将后继元素(如果有)向左移动并将其索引减小1。
删除(元素) 此方法用于删除列表中给定元素的第一次出现。
get(int索引) 此方法返回指定索引处的元素。
set(int index, element) 此方法将给定索引处的元素替换为新元素。此函数返回刚刚被新元素替换的元素。
indexOf(element) 此方法返回给定元素的第一次出现;如果列表中不存在该元素, 则返回-1。
lastIndexOf(element) 此方法返回给定元素的最后一次出现;如果列表中不存在该元素, 则返回-1。
等于(元素) 此方法用于比较给定元素与列表元素的相等性。
哈希码() 此方法用于返回给定列表的哈希码值。
是空的() 此方法用于检查列表是否为空。如果列表为空, 则返回true, 否则返回false。
包含(元素) 此方法用于检查列表是否包含给定元素。如果列表包含元素, 则返回true。
containsAll(Collection collection) 此方法用于检查列表是否包含所有元素集合。
排序(比较器comp) 此方法用于根据给定的比较器对列表中的元素进行排序。
木子山

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: