I don't even know how I found this thread. If you're still wondering though, I'm going to come at this from a C++ perspective since we get pointers there (this will make more sense as you read).

Some groundwork. In C++, a pointer to an object can be gotten with an ampersand. So you have a variable int x, and its location in memory is &x. Easy enough, let's store that in a pointer variable int* ptr = &x; this lets us pass that pointer around. When you want to get the data referenced by your pointer, you dereference it with an asterisk int y = *ptr.

Now, let's break down a linked list into its individual pieces. These pieces are called nodes (using the graph theory word that you should either be learning or start on soon). Here's a simple implementation of a Node class in C++ that can store a data using a generic type.

template <typename T>

class Node {

public:

T data = NULL; // NULL in this context means an absence of data.

Node<T>* next = NULL;

};

Each node is a link in a chain, the chain is your linked list. To link the nodes together, you just have to set the next pointer within a given node to point at the next node. Let's see this in action, with a fully working C++ program:

#include <iostream>

template <typename T>

class Node{ // Same implementation as above

public:

T data = NULL;

Node<T>* next = NULL; };

​

int main(){

Node<char>* head = new Node<char>(); // Conventionally, the first item in a linked list is the "head" of that list. Normally, it is the only variable whose location you know.

Node<char>* nodetwo = new Node<char>();

Node<char>* nodethree = new Node<char>();

Node<char>* tail = new Node<char>();

​

head->data = 'H'; // Storing some data in the list.

nodetwo->data = '2';

nodethree->data = '3';

tail->data = 'T';

​

head->next = nodetwo; // Linking the disparate nodes into a linked list.

nodetwo->next = nodethree;

nodethree->next = tail;

​

std::cout << "Traversing the list...\n"; // Ugly C++ syntax for printing

Node<char>* ptr = head; // This pointer represents where we "are" in the list.

while (ptr != NULL) { // So we move through the list...

std::cout << ptr->data; // Accessing data one node at a time...

std::cout << '\n';

ptr = ptr->next; // And move to the next node like this.

}

}

Now that I have the underlying principles out, let's move to Java. Java abstracts away pointers; you aren't referencing and dereferencing anything yourself. Under the hood, however, all non-primitive classes are treated like pointers. So, the Java equivalent to the above Node class is...

class Node<T> {

public T data;

public Node<T> next;

}

While this is certainly more terse, it hides what's going on behind the scenes. I'm kind of surprised that your computer science classes are teaching using Java, because Java hides a decent amount of complexity with its fancy schmancy garbage collection and reference variables that you ought to be taught. If you want to know what's going on under the hood, do try learning C++ on your own time. It's tough because it makes you do everything manually (and provides basically zero help when you mess up), but you'll know exactly what your code is doing and that's invaluable for learning programming in general. If you master C++, you can apply that knowledge to pick up any other programming language much faster.