Java的傳球用listNode問題參考

Question

我有一個類：

class ListNode { 
    int val; 
    ListNode next; 
    ListNode(int x) { val = x; } 
} 

並打印LinkedList的功能是：

public static void printLinkedNode(ListNode l){ 
     while(l != null){ 
      System.out.print(l.val+" "); 
      l = l.next; 
     } 
     System.out.println(" "); 
    } 

在我的主要功能，創建一個名爲test ListNode：

ListNode test = new ListNode(1); 
head.next = new ListNode(2); 
head.next.next = new ListNode(3); 
head.next.next.next = new ListNode(4); 

如果我做了：

ListNode fast = head, slow = head; 
fast = fast.next.next; 
printLinkedNode(head); // I get 1->2->3->4 

如果我B：

ListNode fast = head, slow = head; 
fast.next = fast.next.next; 
printLinkedNode(head); // I get 1->3->4 

我在爲什麼在A中，頭是1-> 2-> 3-> 4困惑，但不3-> 4？我看過一些帖子約Is Java 「pass-by-reference」 or 「pass-by-value」?，但仍無法弄清楚..

如果我這樣做C：

  ListNode fast = head, slow = head; 
      fast = fast.next.next; 
      printLinkedNode(fast); //3->4 
      printLinkedNode(head); //1->2->3->4 
      fast.next = new ListNode(5); 
      printLinkedNode(fast); //3->5 
      printLinkedNode(head); //1->2->3->5, why the head will change? 

我在爲什麼頭將改變迷茫的時候，我們做fast.next =新的ListNode（5）;我認爲快速不是與頭部分配？

Answer 1

當您將分配給變量時，您將它指向（引用）到特定對象。當你重新分配它，你讓點（參考）到另一個對象，你不會覆蓋它持有的參考值：

ListNode fast = head, slow = head; // fast has a reference to head. 
fast = fast.next.next;    // fast has a reference to fast.next.next. You are not overwriting head, just fast. 
printLinkedNode(head); // I get 1->2->3->4 

相反，如果你做一些修改內引用的對象，你」會編輯原始對象：

ListNode fast = head, slow = head; // fast has a reference to head 
fast.next = fast.next.next;  // by editing fast.next, you edit head.next 
printLinkedNode(head); // I get 1->3->4 

---

更新的用例C：

ListNode fast = head, slow = head; // fast = head = (1) 
fast = fast.next.next;    // fast = fast.next.next = (3). head is still (1) 
printLinkedNode(fast);    // 3->4 -> because fast points to head.next.next (3) 
printLinkedNode(head);    // 1->2->3->4 -> head wasn't modified by any of the previous instructions 

// here fast points to head.next.next. So fast.next is the same as head.next.next.next (4). 
fast.next = new ListNode(5);  // Overwrites fast.next, it was (4), becomes (5) 
printLinkedNode(fast);    // 3->5 
printLinkedNode(head);    // 1->2->3->5 

---

爲了更容易理解：

比方說，我們有對象a，b和ListNode類型的c：

ListNode a = new ListNode(1); 
ListNode b = new ListNode(2); 
ListNode c = new ListNode(3); 

ListNode d = a; // variable d now points to object a 
d.next = b;  // since d points to a, this statement modifies a.next 
d = c   // This does *not* modify a. It just makes d point to c.