LinkedList offerFirst() method - Syntax and Examples

Java LinkedList offerFirst() method - Syntax and Examples

This reference explains LinkedList offerFirst() method - Syntax and Examples through its syntax, examples and boundaries. Use the linked course lessons when the surrounding Java concepts are unfamiliar.

The offerFirst() method in Java's LinkedList allows you to insert an element at the beginning of the list. It’s a handy way to add items to the front, ensuring they become the first element.

    public boolean offerFirst(E e)
  

Returns true if the insertion was successful; returns false if the operation is rejected (which can happen when the list has a capacity restriction and cannot accept new elements).

Let's start with a simple example: adding a string at the beginning of a LinkedList.

    import java.util.LinkedList;

public class OfferFirstExample {

    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        
        System.out.println("Initial list: " + list);

        boolean offered = list.offerFirst("Hello");

        System.out.println("List after offerFirst('Hello'): " + list);
        System.out.println("Offer successful?: " + offered); // Will print true
    }
  

Initial list: []
List after offerFirst('Hello'): [Hello]
Offer successful?: true

In this example, the string "Hello" is added to the beginning of the LinkedList. The output shows that it's now the first element.

Now let’s see how we can use offerFirst() with integers.

    import java.util.LinkedList;

public class OfferFirstIntegerExample {

    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        
        list.offerFirst(10);
        list.offerFirst(20);
        list.offerFirst(30);

        System.out.println("List after adding integers: " + list);
    }
  

List after adding integers: [30, 20, 10]

Notice how the elements are inserted in the order they were added with offerFirst(). The last one called is placed first.

While less common, a LinkedList might have capacity restrictions if it's created using a bounded type (like a blocking queue). Let’s simulate a scenario where offerFirst() might return false. This is more conceptual since standard Linkedlists don't impose such limits.

    import java.util.LinkedList;

public class OfferFirstRejectionExample {

    public static void main(String[] args) {
        // Simulate a LinkedList with limited capacity (not actually possible with standard LinkedList)
        LinkedList<String> list = new LinkedList<>; 
        //In reality, you'd use BlockingQueue implementations for this

        list.offerFirst("Element 1");
        list.offerFirst("Element 2");
        // Assume the 'list' is now full (hypothetical)

        boolean offered = list.offerFirst("Element 3"); //Might return false if capacity is reached.

        System.out.println("List: " + list);
        System.out.println("Offer successful?: " + offered); // Could print false depending on capacity restrictions
    }

List: [Element 2, Element 1]
Offer successful?: true 

In a real-world scenario with limited capacity (like in some queue implementations), if the list is full, offerFirst() could return false. The provided code just demonstrates the potential for rejection.

Check the example’s types, inputs and documented behavior before copying it into an application. Some APIs require external libraries, files or platform services; consult their setup notes.

Related explanations: Java Data Types - Primitive and Non-Primitive, Java Class - Blueprint of Objects, Exceptions in Java Introduction.

Supporting documentation: Official Java learning guide.