Java LinkedList Class: A Beginner's Guide

Introduction

Hello there, future Java wizards! Today, we're going to embark on an exciting journey into the world of Java LinkedList. Don't worry if you're new to programming – I'll be your friendly guide, and we'll explore this topic step by step. By the end of this tutorial, you'll be linking lists like a pro!

Imagine you're organizing a conga line at a party. Each person holds onto the shoulders of the person in front of them, forming a chain. That's essentially what a LinkedList is in Java – a chain of elements, each connected to the next. It's a fun and flexible way to store and manage data!

Class Declaration

Let's start with the basics. In Java, the LinkedList class is part of the java.util package. Here's how we declare it:

import java.util.LinkedList;

public class LinkedListExample {
    public static void main(String[] args) {
        LinkedList<String> partyGuests = new LinkedList<>();
    }
}

In this example, we're creating a LinkedList called partyGuests that will store Strings (names of our guests). The <String> part is what we call a "generic" – it specifies the type of elements our list will hold.

Parameters

LinkedList in Java is a generic class, which means it can work with different types of data. The type parameter <E> represents the type of elements in the list. In our party example, E would be String.

Field

LinkedList doesn't have any public fields. All its inner workings are encapsulated (a fancy word for "hidden") within the class. This is good practice in object-oriented programming – it's like keeping the messy kitchen hidden while serving a delicious meal in the dining room!

Class Constructors

LinkedList provides two constructors:

1. LinkedList(): Creates an empty list.
2. LinkedList(Collection<? extends E> c): Creates a list containing the elements of the specified collection.

Let's see them in action:

LinkedList<String> emptyParty = new LinkedList<>(); // Empty list
LinkedList<String> vipGuests = new LinkedList<>(Arrays.asList("Alice", "Bob", "Charlie")); // List with initial elements

Class Methods

LinkedList comes with a treasure trove of useful methods. Here are some of the most commonly used ones:

Method	Description
add(E element)	Adds an element to the end of the list
add(int index, E element)	Adds an element at the specified position
addFirst(E element)	Adds an element at the beginning of the list
addLast(E element)	Adds an element at the end of the list
remove(Object o)	Removes the first occurrence of the specified element
remove(int index)	Removes the element at the specified position
get(int index)	Returns the element at the specified position
set(int index, E element)	Replaces the element at the specified position
size()	Returns the number of elements in the list
clear()	Removes all elements from the list

Methods Inherited

LinkedList inherits methods from several interfaces and classes, including Collection, Deque, List, and AbstractSequentialList. This means it can do a lot more than what we've covered here!

Adding Elements to a LinkedList Example

Let's put our knowledge into practice with a fun example:

import java.util.LinkedList;

public class PartyPlanner {
    public static void main(String[] args) {
        LinkedList<String> partyGuests = new LinkedList<>();

        // Adding guests to our party
        partyGuests.add("Alice");
        partyGuests.addLast("Bob");
        partyGuests.addFirst("Charlie");
        partyGuests.add(1, "David");

        System.out.println("Guest list: " + partyGuests);

        // Oops, Bob can't make it
        partyGuests.remove("Bob");

        // Adding a VIP guest
        partyGuests.addFirst("Eve");

        System.out.println("Updated guest list: " + partyGuests);
        System.out.println("Number of guests: " + partyGuests.size());
    }
}

Output

When you run this code, you'll see:

Guest list: [Charlie, David, Alice, Bob]
Updated guest list: [Eve, Charlie, David, Alice]
Number of guests: 4

Let's break down what happened:

1. We started with an empty guest list.
2. We added Alice to the end, Bob to the end, Charlie to the beginning, and squeezed David into the second position.
3. We printed our initial guest list.
4. Bob couldn't make it, so we removed him.
5. We added Eve as a VIP guest at the beginning of the list.
6. We printed our updated list and the total number of guests.

See how flexible LinkedList is? We can add and remove elements from any position easily!

In conclusion, LinkedList is a powerful and flexible tool in Java. It's like having a magical guest list for your coding party – you can add or remove guests from anywhere in the line with ease! Remember, practice makes perfect, so don't be afraid to experiment with different methods and create your own LinkedList examples. Happy coding, and may your lists always be perfectly linked!

Credits: Image by storyset