Easy to Learn Java: Programming Articles, Examples and Tips

Start with Java in a few days with Java Lessons or Lectures

Home

Code Examples

Java Tools

More Java Tools!

Java Forum

All Java Tips

Books

Submit News
Search the site here...
Search...
 

LinkedList Example Java code example - Click here to copy ->>>

   Can't find what you're looking for? Try our search:

Really working examples categorized by API, package, class. You can compile and run our examples right away! Not from source code for Java projects - only working examples! Copy, compile and run!
------------------

LinkedList is replacement for Java Vector class. Classical doubly linked list. Faster that Vector for insert/ delete, but slower for indexed access. The interface is modeled on java. util. Vector.

LinkedList is replacement for Java Vector class. Classical doubly linked list. Faster that Vector for insert/ delete, but slower for indexed access. The interface is modeled on java. util. Vector.

The measurements and the other factors we've considered clearly indicate that ArrayLists and Vectors usually provides better performance than LinkedLists and synchronized wrapped LinkedLists . Even in cases where you might have thought that the LinkedList would provide better performance, you may be able to coax superior performance from ArrayList by altering how elements are added, for example by reversing the collection order.

There are situations where LinkedLists will provide better performance; with, for example, very large collections where many elements need to be added to both the beginning and end of the collection. But in general, I recommend using ArrayList / Vector as the default and using LinkedList only where there is an identified performance problem in which a LinkedList improves the performance.

Code:

 
 // -----------------------------------------------------------------------------
// LinkedListExample.java
// -----------------------------------------------------------------------------

/*
 * =============================================================================
 * Copyright (c) 1998-2005 Jeffrey M. Hunter. All rights reserved.
 *
 * All source code and material located at the Internet address of
 * http://www.idevelopment.info is the copyright of Jeffrey M. Hunter, 2005 and
 * is protected under copyright laws of the United States. This source code may
 * not be hosted on any other site without my express, prior, written
 * permission. Application to host any of the material elsewhere can be made by
 * contacting me at jhunter@idevelopment.info.
 *
 * I have made every effort and taken great care in making sure that the source
 * code and other content included on my web site is technically accurate, but I
 * disclaim any and all responsibility for any loss, damage or destruction of
 * data or any other property which may arise from relying on it. I will in no
 * case be liable for any monetary damages arising from such loss, damage or
 * destruction.
 *
 * As with any code, ensure to test this code in a development environment
 * before attempting to run it in production.
 * =============================================================================
 */
 
import java.util.List;
import java.util.LinkedList;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.Collections;
import java.util.Random;

/**
 * -----------------------------------------------------------------------------
 * The following class provides an example of storing and retrieving objects
 * from a LinkedList.
 *
 * A List corresponds to an "ordered" group of elements where duplicates are
 * allowed.
 *
 * A LinkedList is based on a double linked list where elements of the List are
 * typically accessed through add() and remove() methods.
 *
 * LinkedList's give great performance on add() and remove() methods, but do not
 * perform well on get() and set() methods when compared to an ArrayList.
 *
 * @version 1.0
 * @author  Jeffrey M. Hunter  (jhunter@idevelopment.info)
 * @author  http://www.idevelopment.info
 * -----------------------------------------------------------------------------
 */

public class LinkedListExample {

    /**
     * Provides an example of how to work with the LinkedList container.
     */
    public void doLinkedListExample() {

        final int MAX = 10;
        int counter = 0;

        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Create/Store objects in an LinkedList container.                    |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        List listA = new LinkedList();
        List listB = new LinkedList();

        for (int i = 0; i < MAX; i++) {
            System.out.println("  - Storing Integer(" + i + ")");
            listA.add(new Integer(i));
        }

        System.out.println("  - Storing String(Alex)");
        listA.add("Alex");

        System.out.println("  - Storing String(Melody)");
        listA.add("Melody");

        System.out.println("  - Storing String(Jeff)");
        listA.add("Jeff");

        System.out.println("  - Storing String(Alex)");
        listA.add("Alex");

        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Retrieve objects in an LinkedList container using an Iterator.      |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        Iterator i = listA.iterator();
        while (i.hasNext()) {
            System.out.println(i.next());
        }


        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Retrieve objects in an LinkedList container using a ListIterator.   |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        counter = 0;
        ListIterator li = listA.listIterator();
        while (li.hasNext()) {
            System.out.println("Element [" + counter + "] = " + li.next());
            System.out.println("  - hasPrevious    = " + li.hasPrevious());
            System.out.println("  - hasNext        = " + li.hasNext());
            System.out.println("  - previousIndex  = " + li.previousIndex());
            System.out.println("  - nextIndex      = " + li.nextIndex());
            System.out.println();
            counter++;
        }


        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Retrieve objects in an LinkedList container using index.            |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        for (int j=0; j < listA.size(); j++) {
            System.out.println("[" + j + "] - " + listA.get(j));
        }


        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Search for a particular Object and return its index location.       |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        int locationIndex = listA.indexOf("Jeff");
        System.out.println("Index location of the String \"Jeff\" is: " + locationIndex); 


        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Search for an object and return the first and last (highest) index. |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        System.out.println("First occurance search for String \"Alex\".  Index =  " + listA.indexOf("Alex"));
        System.out.println("Last Index search for String \"Alex\".       Index =  " + listA.lastIndexOf("Alex"));


        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Extract a sublist from the main list, then print the new List.      |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        List listSub = listA.subList(10, listA.size());
        System.out.println("New Sub-List from index 10 to " + listA.size() + ": " + listSub);


        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Sort the Sub-List created above.                                    |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        System.out.println("Original List   : " + listSub);
        Collections.sort(listSub);
        System.out.println("New Sorted List : " + listSub);
        System.out.println();


        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Reverse the Sub-List created above.                                 |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        System.out.println("Original List     : " + listSub);
        Collections.reverse(listSub);
        System.out.println("New Reversed List : " + listSub);
        System.out.println();


        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Check to see if the Lists are empty.                                |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        System.out.println("Is List A empty?   " + listA.isEmpty());
        System.out.println("Is List B empty?   " + listB.isEmpty());
        System.out.println("Is Sub-List empty? " + listSub.isEmpty());


        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Clone the initial List.                                             |");
        System.out.println("| NOTE: The contents of the List are object references, so both       |");
        System.out.println("|       of the List's contain the same exact object reference's.      |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        System.out.println("List A   (before) : " + listA);
        System.out.println("List B   (before) : " + listB);
        System.out.println("Sub-List (before) : " + listSub);
        System.out.println();
        System.out.println("Are List's A and B equal? " + listA.equals(listB));
        System.out.println();
        listB = new LinkedList(listA);
        System.out.println("List A   (after)  : " + listA);
        System.out.println("List B   (after)  : " + listB);
        System.out.println("Sub-List (after)  : " + listSub);
        System.out.println();
        System.out.println("Are List's A and B equal? " + listA.equals(listB));


        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Shuffle the elements around in some Random order for List A.        |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        System.out.println("List A   (before) : " + listA);
        System.out.println("List B   (before) : " + listB);
        System.out.println("Sub-List (before) : " + listSub);
        System.out.println();
        System.out.println("Are List's A and B equal? " + listA.equals(listB));
        System.out.println();
        Collections.shuffle(listA, new Random());
        System.out.println("List A   (after)  : " + listA);
        System.out.println("List B   (after)  : " + listB);
        System.out.println("Sub-List (after)  : " + listSub);
        System.out.println();
        System.out.println("Are List's A and B equal? " + listA.equals(listB));


        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Convert a List to an Array.                                         |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        Object[] objArray = listA.toArray();
        for (int j=0; j < objArray.length; j++) {
            System.out.println("Array Element [" + j + "] = " + objArray[j]);
        }


        System.out.println();
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println("| Remove (clear) Elements from List A.                                |");
        System.out.println("+---------------------------------------------------------------------+");
        System.out.println();

        System.out.println("List A   (before) : " + listA);
        System.out.println("List B   (before) : " + listB);
        System.out.println();
        listA.clear();
        System.out.println("List A   (after)  : " + listA);
        System.out.println("List B   (after)  : " + listB);
        System.out.println();

    }


    /**
     * Sole entry point to the class and application.
     * @param args Array of String arguments.
     */
    public static void main(String[] args) {
        LinkedListExample listExample = new LinkedListExample();
        listExample.doLinkedListExample();
    }

}

 
 



References.

The list of classes which were used on this page you can find below. The links to Java API contain official SUN documentation about all used classes.

  java.util.LinkedList

  java.awt.List

  java.lang.Integer

  java.util.Iterator

  java.util.ListIterator

  javax.swing.text.Element

  java.lang.Object

  java.util.Random

  java.lang.reflect.Array




[ Go Back ]



Home Code Examples Java Forum All Java Tips Books Submit News, Code... Search... Offshore Software Tech Doodling

RSS feed Java FAQ RSS feed Java FAQ News     

    RSS feed Java Forums RSS feed Java Forums

All logos and trademarks in this site are property of their respective owner. The comments are property of their posters, all the rest 1999-2006 by Java FAQs Daily Tips.

Interactive software released under GNU GPL, Code Credits, Privacy Policy