Coffee break #129. What is the difference between LinkedList and ArrayList? New features coming in Java 19

What is the difference between LinkedList and ArrayList?

Source: Rrtutors.com If you are new to Java programming, you must be wondering which is better to use when working with collections: LinkedList or ArrayList. Both of these classes perform similar functions, so it can sometimes be difficult to decide which one is better to use in your work. In this post, we'll define the differences between the two classes and discuss where and when to use them.

Difference between ArrayList and LinkedList in Java

Let's compare ArrayList and LinkedList based on their criteria:

Manipulation

In both cases there is a difference in the speed of array manipulation. ArrayList is slower to manipulate arrays than LinkedList. This is due to the fact that LinkedList is node-based and does not require much bit shifting.

Access

ArrayList stores and retrieves data faster. On the other hand, LinkedList supports faster data processing.

Implementation

ArrayList implements only a list, while LinkedList implements both a list and a queue. LinkedList is also often used as a queue.

Internal implementation

An ArrayList stores its elements in a dynamic array, while a LinkedList uses a doubly-linked list.

When to use ArrayList and LinkedList?

ArrayList is suitable for working with a read-only collection, while LinkedList is suitable for working with a collection that allows various data modifications, such as adding and deleting.

LinkedList example:

import java.util.LinkedList;

import java.util.List;

public class LinkeddExample {

    public static void main(String[] args) {

        List<String> myGroup=new LinkedList<>();

        myGroup.add("Pohekar");

        myGroup.add("Sumedh");

        myGroup.add("Nikir");

        System.out.println("Create Group: "+myGroup);

        myGroup.remove("Pohekar");

        System.out.println("Remove Group element: "+myGroup);

        myGroup.set(1,"Niha");

        System.out.println("Modify Group: "+myGroup);

    }

}

ArrayList example:

import java.util.ArrayList;

import java.util.List;

public class ArrayListExca {

    public static void main(String[] args) {

        List<String> Pro=new ArrayList<>();

        Pro.add("PythonPro");

        Pro.add("JavaPro");

        Pro.add("C#Pro");



        System.out.println("Traversing ArrayList...");

        for(String s:Pro){

            System.out.println(s);


    }

    }

}

JDK 19: New features coming in Java 19

Source: InfoWorld Virtual threads, pattern matching for switch statements, a vector API, and a Linux/RISC-V port are all coming this September in Java 19, a new release of the language with short-term support. Additionally, Java Development Kit 19 recently introduced another feature: previewing Record patterns for data navigation and processing. As part of the ongoing plan to improve the Java language, JDK 19, or simply Java 19, has the potential to contain a huge number of features, from generics to value objects. JDK 19 will be the next update following JDK 18, introduced on March 22, 2022. The standard version of Java is released every six months. The OpenJDK developers have published the official release schedule for JDK 19. According to it, the stable release will appear on September 20. Before this, developers will be able to familiarize themselves with the preliminary builds, which will be released on June 9 and July 21. Release candidates will be published on August 11 and August 25. Early access builds of JDK 19 are available at jdk.java.net/19 . Features offered in JDK 19 include:

• Preview record templates to parse record values. Record templates and type templates can be nested to provide a declarative, powerful, and composable form of navigation and data processing. The idea behind this feature is to add a pattern matching extension to express more complex compound data queries without changing the syntax or semantics of type patterns. This proposal is based on the pattern matching for instanceof introduced in JDK 16 in March 2021. Further, future plans may require extending record templates with features such as array templates and vararg templates. The templates entry is part of Project Amber , which aims to explore and develop small, performance-oriented Java features.

• Alien Function Preview and Memory API . It will introduce an API that allows Java programs to interact with code and data outside the Java runtime.

  By efficiently calling external functions (code outside the Java runtime) and securely accessing external memory (memory not managed by the JVM), the API will allow Java programs to call native libraries and process native data without any threat to the Java Native Interface (JNI).

• Preview of virtual threads. This offering introduces lightweight threads that greatly reduce the effort of writing, maintaining, and monitoring high-performance parallel applications. The idea of ​​the proposal is to provide the ability to scale server applications written in a simple thread-per-request style with optimal use of hardware. This will allow you to implement virtual threads into code that uses the java.langThread API with minimal changes, and allow you to troubleshoot, debug, and profile virtual threads using existing JDK tools.

• Third preview of pattern matching for expressions and switch statements. It extends pattern matching to switch to allow an expression to be tested against a number of patterns, each of which has a specific action. This allows complex data-centric queries to be expressed concisely and safely. This feature was previously previewed in JDK 17 and JDK 18. The third preview will add improvements, including replacing protected when patterns with clauses in switch blocks. The idea of ​​the proposal is to expand the expressiveness and applicability of switch expressions and operators.

• The fourth incubation of the vector API will express vector computations that reliably compile at runtime into optimal vector instructions on supported processor architectures. This will provide better performance than equivalent scalar calculations. Developers using the new API will be able to write complex vector algorithms in Java using HotSpot's autovectorizer, but with a custom model that makes vectorization more predictable and reliable. The Vector API was previously incubated in JDK 16, JDK 17, and JDK 19.

  As another addition to the vector API, bitwise integral lanewide operations will be expanded to include operations such as counting the number of one bits, reversing bit order, and bit compression and expansion.

• With the Linux/RISC-V port , Java will gain hardware instruction set support that is already supported by a wide range of language toolkits. RISC-V is a family of related ISAs. The Linux/RISC-V port will only support the RV64GV RISC-V configuration, a 64-bit general purpose ISA that includes vector instructions.

  The port will support the following HotSpot virtual machine options: template interpreter, JIT compiler C1 (client), JIT compiler C2 (server), and all current major garbage collectors, including ZGC and Shenandoah.

Like JDK 18, JDK 19 will be a short-term release with six months of support. The previous release, JDK 17, was an LTS release with support guaranteed for several years. It was introduced on September 14, 2021.