Java中的ArrayList vs LinkedList

数组是在连续存储位置上存储项目的集合。思路是将相同类型的多个项目放在一起存储。但数组的限制是数组的大小是预定义和固定的。有多种方法来解决这个问题。本文讨论了两个用于解决此问题而实现的类之间的差异，分别是 ArrayList 和 LinkedList 。

ArrayList是 集合框架 中的一部分。它存在于 java.util 包中，并提供了Java中的动态数组。虽然它可能比标准数组慢，但在需要大量操作数组的程序中可能会有所帮助。我们可以动态地添加和删除项目。它自动调整大小。以下是一个示例，用于说明ArrayList的实现。

例子

// Java program to Illustrate Working of an ArrayList
 
// Importing required classes
import java.io.*;
import java.util.*;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating an ArrayList of Integer type
        ArrayList<Integer> arrli
            = new ArrayList<Integer>();
 
        // Appending the new elements
        // at the end of the list
        // using add () method via for loops
        for (int i = 1; i <= 5; i++)
            arrli.add(i);
 
        // Printing the ArrayList
        System.out.println(arrli);
 
        // Removing an element at index 3
        // from the ArrayList
        // using remove() method
        arrli.remove(3);
 
        // Printing the ArrayList after
        // removing the element
        System.out.println(arrli);
    }
}

输出：

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

LinkedList是一种线性数据结构，其中元素不存储在连续位置上，每个元素都是具有数据部分和地址部分的单独对象。使用指针和地址链接元素。每个元素称为节点。由于动态性和插入和删除的易用性，它们比数组更受欢迎。以下是一个示例，用于说明LinkedList的实现。

注意： 这个类实现了 LinkedList数据结构 。

例子

// Java program to Demonstrate Working of a LinkedList
 
// Importing required classes
import java.util.*;
 
// Main class
class GFG {
 
    // main driver method
    public static void main(String args[])
    {
 
        // Creating an object of the
        // class linked list
        LinkedList<String> object
            = new LinkedList<String>();
 
        // Adding the elements to the object created
        // using add() and addLast() method
 
        // Custom input elements
        object.add("A");
        object.add("B");
        object.addLast("C");
 
        // Print the current LinkedList
        System.out.println(object);
 
        // Removing elements from the List object
        // using remove() and removeFirst() method
        object.remove("B");
        object.removeFirst();
 
        System.out.println("Linked list after "
                           +"deletion: " + object);
    }
}

输出：

[A, B, C]
Linked list after deletion: [C]

现在，在充分了解它们之后，让我们讨论Java中ArrayList和LinkedList之间的差异

ID	ArrayList	LinkedList
1.	此类使用动态数组来存储其中的元素。随着泛型的介绍，此类支持存储所有类型的对象。	此类使用双向链表来存储其中的元素。与ArrayList类似，此类也支持存储所有类型的对象。
2.	由于内部实现，操作ArrayList需要更多时间。每当我们删除一个元素时，内部会遍历数组并移动内存位。	操作LinkedList比操作ArrayList更快，因为在双向链表中不存在移动内存位的概念。链表被遍历并且引用链接被更改。
3.	不高效的内存利用。	良好的内存利用。
4.	它可以是一维、二维或多维的。	它可以是单链表、双链表或循环链表。
5.	插入操作很慢。	插入操作很快。
6.	此类实现了List接口。因此，它充当列表。	此类同时实现了List接口和Deque接口。因此，它既可以充当列表又可以充当双端队列。
7.	当应用程序需要存储数据并访问数据时，此类效果更好。	当应用程序需要操纵存储的数据时，此类效果更好。
8.	数据访问和存储非常高效，因为它根据索引存储元素。	在LinkedList中，数据访问和存储很慢。
9.	删除操作不是非常高效。	删除操作非常高效。
10.	它仅用于存储相似类型的数据。	它用于存储任何类型的数据。
11.	使用的内存较少。	使用的内存更多。
12.	内存仅在编译时分配。	内存在运行时分配。
13.	这被称为静态内存分配。	这被称为动态内存分配。

ArrayList是实现List接口的一个类，使用数组来存储其元素。它具有快速的索引访问时间，这意味着通过索引从ArrayList检索元素非常快速。

例如，以下代码演示了如何从ArrayList检索元素：

import java.io.*;
import java.util.ArrayList;

class GFG {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        int thirdNumber = numbers.get(2);
        System.out.println("The third number is: " + thirdNumber);
    }
}

输出结果

The third number is: 3

此外，向 ArrayList中间插入或删除元素 可能会很慢，因为整个数组都需要在内存中移动来为新元素腾出空间，或者填补删除元素留下的空缺。

例如，以下代码演示了 如何在ArrayList中插入元素 ：

import java.io.*;
import java.util.ArrayList;
 
class GFG {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(2, 4);
        System.out.println("The numbers are: " + numbers);
    }
}

输出