Java链接列表，创建无名节点

Question

my question is perhaps too simple: maybe that's the reason i didn't manage to find a written answer. i am trying to understand the way linked lists are built, and there is one thing i can't understand: usually, when i create an object of some kind of class, i need to give it a name, like that:

 cat kitten =new cat();

at the same time when i do that, the computer gives it an address, something like dfe@fggv3444. when i want to use the created object in some method, i address it by the name i gave it: in our case :"cat". the logic is that if i name 2 objects in the same name "cat", the computer wouldn't know which object to access- or perhaps, both. and now the question: when we use a linked list, the number of used nodes changes a lot throughout the program. so how this objects of node class type are getting their names? obviously they must have a name, but i am not there to give each node its name...

how it works?!

thanks in advance. i am sure that something in this question must be silly, but can't figure out what.

Answer 1

Each cat name is essentially (as @Turing85 pointed out in the comments) just a memory address to a cat instance in a human-readable format.

A linked list at its core is a set of nodes, each with a value and the next node ( next being the variable that connects the nodes to form the list). Each cat would be referred to as simply node.value , where value is the "name" pointing to the address of the node's cat. Each node's next variable points to the next node, which has its own value .

You can't name two objects the same thing within the same scope - you can have cat1 and cat2 both of type cat , and each points to the memory address of a different cat . The reason linked lists can do this is because each node has its own scope, that no other node sees. Hence all nodes can have a next and a value , referred to as node.next and node.value .

      node1        +--------> node2        +--------> node3
+--------------+   |    +--------------+   |    +--------------+
| value = cat1*|   |    | value = cat2 |   |    | value = cat3 |
| next = node2-|---+    | next = node3-|---+    | next = null  |
+--------------+        +--------------+        +--------------+

*---> cat1
+--------------+
| name = "tom" |
| col = "grey" |  ...and likewise for the other nodes
| ............ |

Answer 2

Java has a built in class for linked lists java.util.LinkedList When you instantiate this object ie.

LinkedList<Node> list = new LinkedList<Node>();

You are creating a reference , or in your case name "list" to the object (your linked list)

The entire list has a name "list" which can act as a starting point for your traversal. There are no "names" for each node in the linked list. In java, you can traverse the list somewhat similar to how you would an array; through an index.

list.get(someIndex)

This method basically traverses the list until someIndex, and returns the node there. You can manually set a name for that node by doing;

Node node = list.get(someIndex)

But in general, they do not have a "name", instead you can access them through their index, or many other methods.

Check https://docs.oracle.com/javase/7/docs/api/java/util/LinkedList.html for more details on the built in class

Answer 3

In linked list, each element is represented by nodes. Those nodes hold onto the other elements by their addresses in memory. This could be pseudo-name, but in reality it's just a way to represent where it is in memory.

What might make it confusing is that you do not define the object directly like you would do in this code.

Animal cow = new Animal();

In this instance we have assigned the address of new object's data in the variable cow . This allows us to easily access it.

In contrast to that, linked list node objects hold the address of the next node, but just like any other object, they are a contained as just that node's attribute.

Answer 4

You cannot give the same name to any two variables in Java, within the same scope of visibility (while both variables still exist, and not trashed by the Java Garbage collector. more info : http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01/index.html ), otherwise the compiler wouldn't know which value or object you're referring to.

To answer the second part of your question, an object exists as long as it has a reference (way to access the object). You are right to understand that obviously, an object added to the linked list will have to be accessed. Suppose the first node is named head, and you have to find a reference to the third node in a linked list. head.next.next will be a reference to the third node in the linked list, it does not necessarily have to have a name like 'head', but will exist as long as it has a reference.

Hope this answers your question!

Answer 5

A variable name is only for readability. Java compiler translates source code into "machine-readable" code, which contains no variable name. Values are stored in memory with specific addresses, such as 0x00000000 in hexdecimal.

Each node contains a value and the memory address of the next node. When you call cat.next(); , your computer gets the address of the next node instead of a variable name, and it knows where this address is.

Note:

1. Values may also be stored in register, cache, or disk. They also refer to addresses for data.
2. Java LinkedList is actually doubly-linked, where each node contains address of its previous node as well. We use singly-linked list here for simplification.