Announcement
My office hours are in 779 Soda:
Come talk about anything.
DLLists and Basic ALists
2
Lecture 5 (Lists 3)
CS61B, Fall 2025 @ UC Berkeley
Summary of SLLists So Far
Lecture 5, CS61B, Fall 2025
SLLists:
ALists:
Summary of Last Time (From IntList to SLList)
Methods | Non-Obvious Improvements | |
addFirst(int x) | #1 | Rebranding: IntList → IntNode |
getFirst() | #2 | Bureaucracy: SLList |
addLast(int x) | #3 | Access Control: public → private |
size() | #4 | Nested Class: Bringing IntNode into SLList |
| #5 | Caching: Saving size as an int. |
| #6 | Generalizing: Adding a sentinel node to allow representation of the empty list. |
addFirst()
sentinel
getFirst()
item
next
63
5
15
10
3
size
size()
addLast()
One Downside of SLLists
Inserting at the back of an SLList is much slower than the front.
public void addFirst(int x) {
sentinel.next = new IntNode(x, sentinel.next);
}
public void addLast(int x) {
size += 1;
IntNode p = sentinel;
while (p.next != null) {
p = p.next;
}
p.next = new IntNode(x, null);
}
Improvement #7: (???) Goal: Fast addLast
How could we modify our list data structure so that addLast is also fast?
addFirst()
sentinel
getFirst()
item
next
??
3
50
9
3
size
size()
addLast()
Why a Last Pointer Isn’t Enough
Lecture 5, CS61B, Fall 2025
SLLists:
ALists:
Is .last enough? www.yellkey.com/today
Suppose we want to support addLast, getLast, and removeLast, will having a last pointer make these methods fast, even on long lists?
addLast()
sentinel
getLast()
item
next
??
3
9
50
3
size
size()
removeLast()
last
.last Is Not Enough
Suppose we want to support addLast, getLast, and removeLast, will having a last pointer make these methods fast, even on long lists?
removeLast requires two actions:
sentinel
item
next
??
3
9
3
size
addLast()
getLast()
size()
removeLast()
last
50
i.e. slow because we have to find the “9” node.
.last Is Not Enough
Suppose we want to support addLast, getLast, and removeLast, will having a last pointer make these methods fast, even on long lists?
removeLast requires two actions:
sentinel
item
next
??
3
9
3
size
addLast()
getLast()
size()
removeLast()
last
50
i.e. slow because we have to find the “9” node.
Note, this purple arrow (last) is pointing at the entire Node containing 9, not the second box of the Node containing 9.
Improvement #7: .last and ??? Goal: Fast operations on last.
We added .last, which will speed up addLast and removeLast. What other changes might we make so that removeLast is also fast?
sentinel
item
next
??
3
9
3
size
addLast()
getLast()
size()
removeLast()
last
50
Doubly Linked Lists
Lecture 5, CS61B, Fall 2025
SLLists:
ALists:
Improvement #7: .last and .prev
We added .last. What other changes might we make so that removeLast is also fast?
sentinel
item
next
??
3
2
size
last
prev
addLast()
getLast()
size()
removeLast()
9
item
next
prev
item
next
prev
Note: Arrows point at entire nodes, not fields!
Example: last holds the address of the last node, not the item field of the sentinel node.
Doubly Linked Lists (Naive)
Reverse pointers allow all operations (add, get, remove) to be fast.
sentinel
item
next
??
3
2
size
last
prev
addLast()
getLast()
size()
removeLast()
9
0
sentinel
??
size
last
addLast()
getLast()
size()
removeLast()
item
next
prev
item
next
prev
Doubly Linked Lists (Naive)
Non-obvious fact: This approach has an annoying special case: last sometimes points at the sentinel, and sometimes points at a ‘real’ node.
sentinel
item
next
??
3
2
size
last
prev
addLast()
getLast()
size()
removeLast()
9
item
next
prev
item
next
prev
0
sentinel
??
size
last
addLast()
getLast()
size()
removeLast()
Doubly Linked Lists (Double Sentinel)
One solution: Have two sentinels.
sentFront
item
next
??
3
2
size
sentBack
prev
9
??
0
sentFront
??
size
sentBack
??
addLast()
getBack()
size()
removeLast()
addLast()
getBack()
size()
removeLast()
This is one reasonable approach for Project 1.
Doubly Linked Lists (Circular Sentinel)
Even better topology (IMO):
0
sentinel
??
size
sentinel
3
2
size
9
??
next
item
prev
addLast()
getLast()
size()
removeLast()
addLast()
getLast()
size()
removeLast()
Note: arrows are pointing at entire nodes, not specific fields of nodes.
Examples:
Doubly Linked Lists (Circular Sentinel)
Even better topology (IMO):
0
sentinel
??
size
sentinel
3
2
size
9
??
next
item
prev
addLast()
getLast()
size()
removeLast()
addLast()
getLast()
size()
removeLast()
This is the required approach for Project 1.
Examples:
Note: arrows are pointing at entire nodes, not specific fields of nodes.
Improvement #8: Fancier Sentinel Node(s)
While fast, adding .last and .prev introduces lots of special cases.
To avoid these, either:
DLList Summary
Still many steps before we have an industrial strength data structure. Will discuss over next two weeks.�
Methods | Non-Obvious Improvements | |
addFirst(int x) | #1 | Rebranding: IntList → IntNode |
getFirst() | #2 | Bureaucracy: SLList |
size() | #3 | Access Control: public → private |
addLast(int x) | #4 | Nested Class: Bringing IntNode into SLList |
removeLast() | #5 | Caching: Saving size as an int. |
| #6 | Generalizing: Adding a sentinel node to allow representation of the empty list. |
| #7 | Looking back:.last and .prev allow fast removeLast |
| #8 | Sentinel upgrade: Avoiding special cases with sentBack or circular list. |
Generic Lists
Lecture 5, CS61B, Fall 2025
SLLists:
ALists:
Integer Only Lists
One issue with our list classes: They only support integers.
SLListLauncher.java:6: error: incompatible types: String cannot be converted to int
SLList s2 = new SLList("hi");
Works fine!
public class SLList {
private IntNode sentinel;
private int size;
public class IntNode {
public int item;
public IntNode next;
...
}
...
}
SLList s1 = new SLList(5);
s1.addFirst(10);
SLList s2 = new SLList("hi");
s2.addFirst("apple");
Coding Demo: Generic Lists
public class SLList {
private IntNode sentinel;
private int size;
private class IntNode {
public int item;
public IntNode next;
public IntNode(int i, IntNode n) {
item = i;
next = n;
}
}
}
SLList.java
In this demo, we'll modify our SLList to support lists of any data type, not just lists of integers.
Coding Demo: Generic Lists
public class SLList<LochNess> {
private IntNode sentinel;
private int size;
private class IntNode {
public int item;
public IntNode next;
public IntNode(int i, IntNode n) {
item = i;
next = n;
}
}
}
SLList.java
A placeholder name, which will get replaced by the true data type each time a new SLList is created.
Coding Demo: Generic Lists
public class SLList<LochNess> {
private IntNode sentinel;
private int size;
private class IntNode {
public LochNess item;
public IntNode next;
public IntNode(LochNess i, IntNode n) {
item = i;
next = n;
}
}
}
SLList.java
Items are no longer integers, but the LochNess placeholder data type.
Coding Demo: Generic Lists
public class SLList<LochNess> {
private StuffNode sentinel;
private int size;
private class StuffNode {
public LochNess item;
public StuffNode next;
public StuffNode(LochNess i, StuffNode n) {
item = i;
next = n;
}
}
}
SLList.java
Renaming IntNode to StuffNode to be more descriptive.
Coding Demo: Generic Lists
public class SLList<LochNess> {
private StuffNode sentinel;
private int size;
public SLList(LochNess x) {
sentinel = new StuffNode(null, null);
sentinel.next = new StuffNode(x, null);
size = 1;
}
public SLList() {
sentinel = new StuffNode(null, null);
size = 0;
}
}
SLList.java
Replaced int x with LochNess x, the placeholder data type.
Coding Demo: Generic Lists
public class SLList<LochNess> {
private StuffNode sentinel;
private int size;
public void addFirst(LochNess x) {
sentinel.next = new StuffNode(x, sentinel.next);
size += 1;
}
public LochNess getFirst() {
return sentinel.next.item;
}
}
SLList.java
Replaced int x with LochNess x, the placeholder data type.
Return type is LochNess, not int.
Coding Demo: Generic Lists
public class SLList<LochNess> {
private StuffNode sentinel;
private int size;
public void addLast(LochNess x) {
size += 1;
StuffNode p = sentinel;
/** Move p until it reaches the end of the list. */
while (p.next != null) {
p = p.next;
}
p.next = new StuffNode(x, null);
}
}
SLList.java
Replaced int x with LochNess x, the placeholder data type.
SLists
Java allows us to defer type selection until declaration.
public class SLList<BleepBlorp> {
private IntNode sentinel;
private int size;
public class IntNode {
public BleepBlorp item;
public IntNode next;
...
}
...
}
SLList<Integer> s1 = new SLList<>(5);
s1.addFirst(10);
SLList<String> s2 = new SLList<>("hi");
s2.addFirst("apple");
Generics
We won’t get into the various complexities around generics in 61B. Here are the rules of thumb you’ll need for our course:
DLList<Double> s1 = new DLList<>(5.3);
double x = 9.3 + 15.2;
s1.addFirst(x);
Linked Lists Are Bad at Get
Lecture 5, CS61B, Fall 2025
SLLists:
ALists:
Doubly Linked Lists
Good news: We’ve designed a linked list that can handle the following operations efficiently.
??
3
5
size
17
next
value
prev
addLast()
getLast()
get(int i)
removeLast()
38
sentinel
Arbitrary Retrieval
Bad news: Can’t efficiently implement get(int i).
Suppose we added get(int i), which returns the ith item from the list.
Why would get be slow for long lists compared to getLast()? For what inputs?
??
3
5
size
17
next
value
prev
addLast()
getLast()
get(int i)
removeLast()
38
sentinel
Arbitrary Retrieval
Suppose we added get(int i), which returns the ith item from the list.
Why would get be slow for long lists compared to getLast()? For what inputs?
??
3
5
size
17
next
value
prev
addLast()
getLast()
get(int i)
removeLast()
38
sentinel
Arbitrary Retrieval
Suppose we added get(int i), which returns the ith item from the list.
Why would get be slow for long lists compared to getLast()? For what inputs?
??
3
5
size
17
next
value
prev
addLast()
getLast()
get(int i)
removeLast()
38
sentinel
Note
At this point we’ve covered everything you need to know to complete Mini-Project 1.
Array Overview
Lecture 5, CS61B, Fall 2025
SLLists:
ALists:
Our Long Term Goal (next two lectures): The AList
In the last three lectures, we’ve seen how we can harness a recursive class definition to build an expandable list, ie. the IntList, the SLList, and the DLList.
In this lecture and in lecture 7 (Friday), we’ll talk about a totally different way to implement lists that is based on an array.
x = [3, 4, 5]
x.append(6)
AList
Getting Memory Boxes
To store information, we need memory boxes, which we can get in Java by declaring variables or instantiating objects. Examples:
Arrays are a special kind of object which consists of a numbered sequence of memory boxes.
Gives us a memory box of 32 bits that stores ints.
Gives us a memory box of 64 bits that stores Walrus references.
Gives us a memory box of 64 bits that stores Walrus references, and also gives us 96 bits for storing the int size (32 bits) and double tuskSize (64 bits) of our Walrus.
Arrays
Arrays consist of:
Like instances of classes:
Unlike classes, arrays do not have methods.
Basic ArrayList Implementation
Lecture 5, CS61B, Fall 2025
SLLists:
ALists:
Random Access in Arrays
Retrieval from any position of an array is very fast.
Our Goal: AList.java
Want to figure out how to build an array version of a list:
addLast()
getLast()
get(int i)
removeLast()
???
Let’s try it out...
??
3
5
size
17
next
value
prev
addLast()
getLast()
get(int i)
removeLast()
38
sentinel
DLList
AList
Coding Demo: Basic ArrayList Constructor
public class AList {
/** Creates an empty list. */
public AList() {
}
}
AList.java
Coding Demo: Basic ArrayList Constructor
public class AList {
private int size;
/** Creates an empty list. */
public AList() {
}
}
AList.java
Coding Demo: Basic ArrayList Constructor
public class AList {
private int[] items;
private int size;
/** Creates an empty list. */
public AList() {
}
}
AList.java
Coding Demo: Basic ArrayList Constructor
public class AList {
private int[] items;
private int size;
/** Creates an empty list. */
public AList() {
items = new int[100];
}
}
AList.java
The choice of array size (100) was arbitrary. We'll fix this limitation later.
Coding Demo: Basic ArrayList Constructor
public class AList {
private int[] items;
private int size;
/** Creates an empty list. */
public AList() {
items = new int[100];
size = 0;
}
}
AList.java
Coding Demo: Basic ArrayList addLast
public class AList {
private int[] items;
private int size;
/** Inserts x into the back of the list. */
public void addLast(int x) {
}
}
AList.java
Let's write a small example to help us think about addLast.
Coding Demo: Basic ArrayList addLast
0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | … |
6 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | … |
6 | 9 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | … |
6 | 9 | -1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | … |
size=0
size=1
size=2
size=3
What patterns do we spot?
The next item we want to add will go into position size.
Call constructor to get empty array.
addLast(6)
addLast(9)
addLast(-1)
Coding Demo: Basic ArrayList addLast
/** Invariants:
addLast: The next item we want to add, will go into position size
*/
public class AList {
private int[] items;
private int size;
/** Inserts x into the back of the list. */
public void addLast(int x) {
}
}
AList.java
Coding Demo: Basic ArrayList addLast
/** Invariants:
addLast: The next item we want to add, will go into position size
*/
public class AList {
private int[] items;
private int size;
/** Inserts x into the back of the list. */
public void addLast(int x) {
items[size] = x;
}
}
AList.java
Coding Demo: Basic ArrayList addLast
/** Invariants:
addLast: The next item we want to add, will go into position size
*/
public class AList {
private int[] items;
private int size;
/** Inserts x into the back of the list. */
public void addLast(int x) {
items[size] = x;
size += 1;
}
}
AList.java
Coding Demo: Basic ArrayList getLast
/** Invariants:
addLast: The next item we want to add, will go into position size
*/
public class AList {
private int[] items;
private int size;
/** Returns the item from the back of the list. */
public int getLast() {
}
}
AList.java
Coding Demo: Basic ArrayList getLast
/** Invariants:
addLast: The next item we want to add, will go into position size
getLast: The item we want to return is in position size - 1.
*/
public class AList {
private int[] items;
private int size;
/** Returns the item from the back of the list. */
public int getLast() {
}
}
AList.java
Coding Demo: Basic ArrayList getLast
/** Invariants:
addLast: The next item we want to add, will go into position size
getLast: The item we want to return is in position size - 1.
*/
public class AList {
private int[] items;
private int size;
/** Returns the item from the back of the list. */
public int getLast() {
return items[size - 1];
}
}
AList.java
Coding Demo: Basic ArrayList get
/** Invariants:
addLast: The next item we want to add, will go into position size
getLast: The item we want to return is in position size - 1.
*/
public class AList {
private int[] items;
private int size;
/** Gets the ith item in the list (0 is the front). */
public int get(int i) {
}
}
AList.java
Coding Demo: Basic ArrayList get
/** Invariants:
addLast: The next item we want to add, will go into position size
getLast: The item we want to return is in position size - 1.
*/
public class AList {
private int[] items;
private int size;
/** Gets the ith item in the list (0 is the front). */
public int get(int i) {
return items[i];
}
}
AList.java
Coding Demo: Basic ArrayList size
/** Invariants:
addLast: The next item we want to add, will go into position size
getLast: The item we want to return is in position size - 1.
*/
public class AList {
private int[] items;
private int size;
/** Returns the number of items in the list. */
public int size() {
}
}
AList.java
Coding Demo: Basic ArrayList size
/** Invariants:
addLast: The next item we want to add, will go into position size
getLast: The item we want to return is in position size - 1.
size: The number of items in the list should be size.
*/
public class AList {
private int[] items;
private int size;
/** Returns the number of items in the list. */
public int size() {
}
}
AList.java
Coding Demo: Basic ArrayList size
/** Invariants:
addLast: The next item we want to add, will go into position size
getLast: The item we want to return is in position size - 1.
size: The number of items in the list should be size.
*/
public class AList {
private int[] items;
private int size;
/** Returns the number of items in the list. */
public int size() {
return size;
}
}
AList.java
Naive AList Code
AList Invariants:
We could also add error checking code, e.g.
public class AList {
private int[] items;
private int size;
public AList() {
items = new int[100]; size = 0;
}
public void addLast(int x) {
items[size] = x;
size += 1;
}
public int getLast() {
return items[size - 1];
}
public int get(int i) {
return items[i];
}
public int size() {
return size;
}
}
From SLList lecture: “things that must be true”.
public int get(int i) {
if (i >= items.length) {
throw new IllegalArgumentException();
}
return items[i];
}
Naive AList Code
AList Invariants:
Let’s now discuss delete operations.
From SLList lecture: “things that must be true”.
public class AList {
private int[] items;
private int size;
public AList() {
items = new int[100]; size = 0;
}
public void addLast(int x) {
items[size] = x;
size += 1;
}
public int getLast() {
return items[size - 1];
}
public int get(int i) {
return items[i];
}
public int size() {
return size;
}
}
removeLast and the Allegory of the Cave
Lecture 5, CS61B, Fall 2025
SLLists:
ALists:
The Abstract vs. the Concrete
When we removeLast(), which memory boxes need to change? To what?-
User’s mental model: [5, 3, 1, 7, 22, -1] → [5, 3, 1, 7, 22]
0
0
...
addLast()
getLast()
get(int i)
removeLast()
items
5
3
1
7
22
-1
0
0
6
size
0 1 2 3 4 5 6 7 98 99
Actual truth:
Deletion: yellkey.com/east
When we removeLast(), which memory boxes need to change? To what?
addLast()
getLast()
get(int i)
removeLast()
items
5
3
1
7
22
-1
0
0
0
0
0
...
6
size
0 1 2 3 4 5 6 7 97 98 99
AList invariants.
removeLast Implementation
Lecture 5, CS61B, Fall 2025
SLLists:
ALists:
Deletion Debrief
When we removeLast(), which memory boxes need to change? To what?
AList invariants.
addLast()
getLast()
get(int i)
removeLast()
items
5
3
1
7
22
-1
0
0
0
0
0
...
6
size
0 1 2 3 4 5 6 7 97 98 99
Deletion Debrief
When we removeLast(), which memory boxes need to change? To what?
AList invariants.
addLast()
getLast()
get(int i)
removeLast()
items
5
3
1
7
22
-1
0
0
0
0
0
...
5
size
0 1 2 3 4 5 6 7 97 98 99
Coding Demo: Basic ArrayList removeLast
/** Invariants:
addLast: The next item we want to add, will go into position size
getLast: The item we want to return is in position size - 1.
size: The number of items in the list should be size.
*/
public class AList {
private int[] items;
private int size;
/** Deletes item from back of list and returns deleted item. */
public int removeLast() {
}
}
AList.java
Coding Demo: Basic ArrayList removeLast
/** Invariants:
addLast: The next item we want to add, will go into position size
getLast: The item we want to return is in position size - 1.
size: The number of items in the list should be size.
*/
public class AList {
private int[] items;
private int size;
/** Deletes item from back of list and returns deleted item. */
public int removeLast() {
int x = getLast();
}
}
AList.java
Coding Demo: Basic ArrayList removeLast
/** Invariants:
addLast: The next item we want to add, will go into position size
getLast: The item we want to return is in position size - 1.
size: The number of items in the list should be size.
*/
public class AList {
private int[] items;
private int size;
/** Deletes item from back of list and returns deleted item. */
public int removeLast() {
int x = getLast();
return x;
}
}
AList.java
Coding Demo: Basic ArrayList removeLast
/** Invariants:
addLast: The next item we want to add, will go into position size
getLast: The item we want to return is in position size - 1.
size: The number of items in the list should be size.
*/
public class AList {
private int[] items;
private int size;
/** Deletes item from back of list and returns deleted item. */
public int removeLast() {
int x = getLast();
size = size - 1;
return x;
}
}
AList.java
Naive AList Code
AList Invariants:
public int removeLast() {
int x = items[size - 1];
items[size - 1] = 0;
size -= 1;
return x;
}
Setting deleted item to zero is not necessary to preserve invariants, and thus not necessary for correctness.
public class AList {
private int[] items;
private int size;
public AList() {
items = new int[100]; size = 0;
}
public void addLast(int x) {
items[size] = x;
size += 1;
}
public int getLast() {
return items[size - 1];
}
public int get(int i) {
return items[i];
}
public int size() {
return size;
}
}
Note
What about get?
addLast()
getLast()
get(int i)
removeLast()
items
5
3
1
7
22
-1
0
0
0
0
0
...
5
size
0 1 2 3 4 5 6 7 97 98 99
Naive AList Code
What’s missing from our implementation?
public int removeLast() {
int x = items[size - 1];
items[size - 1] = 0;
size -= 1;
return x;
}
public class AList {
private int[] items;
private int size;
public AList() {
items = new int[100]; size = 0;
}
public void addLast(int x) {
items[size] = x;
size += 1;
}
public int getLast() {
return items[size - 1];
}
public int get(int i) {
return items[i];
}
public int size() {
return size;
}
}
Naive AList Code
What’s missing from our implementation?
public int removeLast() {
int x = items[size - 1];
items[size - 1] = 0;
size -= 1;
return x;
}
public class AList {
private int[] items;
private int size;
public AList() {
items = new int[100]; size = 0;
}
public void addLast(int x) {
items[size] = x;
size += 1;
}
public int getLast() {
return items[size - 1];
}
public int get(int i) {
return items[i];
}
public int size() {
return size;
}
}
Naive AList Code
In Lecture 7 (Friday), we’ll cover:
However, in lecture 6, we’ll take a detour to cover the idea of software testing (which is also covered on mini-project 1).�
public int removeLast() {
int x = items[size - 1];
items[size - 1] = 0;
size -= 1;
return x;
}
public class AList {
private int[] items;
private int size;
public AList() {
items = new int[100]; size = 0;
}
public void addLast(int x) {
items[size] = x;
size += 1;
}
public int getLast() {
return items[size - 1];
}
public int get(int i) {
return items[i];
}
public int size() {
return size;
}
}
Attendance Link
Attendance link: https://www.yellkey.com/offline
To-do: If you haven’t finished it, complete the Stacks homework.
In Stacks:
Bonus Topic: Arrays vs. Classes
Lecture 5, CS61B, Spring 2025
Arrays vs. Classes
Arrays vs. Classes
Arrays and Classes can both be used to organize a bunch of memory boxes.
public class Planet {
public double mass;
public String name;
...
}
int[] x = new int[]{100, 101, 102, 103};
Planet p = new Planet(6e24, "earth");
Arrays vs. Classes
Array indices can be computed at runtime.
jug ~/Dropbox/61b/lec/lists3
$ javac ArrayDemo.java
$ java ArrayDemo
What index do you want? 2
102
int[] x = new int[]{100, 101, 102, 103};
int indexOfInterest = askUser();
int k = x[indexOfInterest];
System.out.println(k);
Arrays vs. Classes
Class member variable names CANNOT be computed and used at runtime.
jug ~/Dropbox/61b/lec/lists3
$ javac ClassDemo.java
ClassDemo.java:5: error: array required,
but Planet found.
double mass = earth[fieldOfInterest]; ^
String fieldOfInterest = "mass";
Planet earth = new Planet(6e24, "earth");
double mass = earth[fieldOfInterest];
System.out.println(mass);
… if you reallllly want to do this, you can: https://goo.gl/JxpyLq
Arrays vs. Classes
Class member variable names CANNOT be computed and used at runtime.
jug ~/Dropbox/61b/lec/lists3
$ javac ClassDemo.java
ClassDemo.java:5: error: cannot find Symbol
double mass = earth.fieldOfInterest; ^
symbol: variable fieldOfInterest
location: variable earth of type Planet
… if you reallllly want to do this, you can: https://goo.gl/JxpyLq
String fieldOfInterest = "mass";
Planet earth = new Planet(6e24, "earth");
double mass = earth.fieldOfInterest;
System.out.println(mass);
Another view
The only (easy) way to access a member of a class is with hard-coded dot notation.
The Java compiler does not treat text on either side of a dot as an expression, and thus it is not evaluated.
int k = x[indexOfInterest]; /* no problem */
double m = p.fieldOfInterest; /* won't work */
double z = p[fieldOfInterest]; /* won't work */
/* No (sane) way to use field of interest */
double w = p.mass; /* works fine */
*: There is something called the “reflections” library which will let you access a field of a class using a String name, but it is not intended for casual use.