（1）链表是以节点的方式来存储
    （2）每个节点包含data域和next域：指向下一个节点
    （3）链表的各个节点不一定是连续存储
    （4）链表分带头节点的和没有头节点的链表，根据实际需求来定

    1. /**
    2.  * 单向链表节点
    3.  */
    4. public class Node {
    6.     /**
    7.      * 节点id
    8.      */
    9.     private Integer id;
    11.     /**
    12.      * 节点数据
    13.      */
    14.     private String data;
    16.     /**
    17.      * 指向下一个节点
    18.       */
    19.     private Node next;
    21.     public Node(Integer id, String data) {
    22.         this.id = id;
    23.         this.data = data;
    24.     }
    26.     public Integer getId() {
    27.         return id;
    28.     }
    30.     public void setId(Integer id) {
    31.         this.id = id;
    32.     }
    34.     public String getData() {
    35.         return data;
    36.     }
    38.     public void setData(String data) {
    39.         this.data = data;
    40.     }
    42.     public Node getNext() {
    43.         return next;
    44.     }
    46.     public void setNext(Node next) {
    47.         this.next = next;
    48.     }
    50.     @Override
    51.     public String toString() {
    52.         return "Node{" + "id=" + id + ", data='" + data + '\'' + '}';
    53.     }
    54. }
    1. /**
    2.  * 单向链表
    3.  */
    4. public class LinkedList {
    6.     /**
    7.      * 初始化一个头节点
    8.      */
    9.     private Node head = new Node(null, null);
    11.     /**
    12.      * 新增节点
    13.      */
    14.     public void add(Node node) {
    15.         Node temp = head;
    16.         // 遍历链表，找到最后一个节点
    17.         while(true) {
    18.             if (temp.getNext() == null) {
    19.                 break;
    20.             }
    21.             temp = temp.getNext();
    22.         }
    23.         // 当退出while循环时，temp指向了最后一个节点
    24.         temp.setNext(node);
    25.     }
    27.     /**
    28.      * 修改节点
    29.      * @param node
    30.      */
    31.     public void update(Node node) {
    32.         if (head.getNext() == null) {
    33.             System.out.println("链表为空，修改失败！");
    34.         }
    35.         Node temp = head.getNext();
    36.         // 遍历链表
    37.         while(temp != null) {
    38.             if (Objects.equals(temp.getId(), node.getId())) {
    39.                 temp.setData(node.getData());
    40.             }
    41.             temp = temp.getNext();
    42.         }
    43.     }
    45.     /**
    46.      * 删除节点
    47.      */
    48.     public void del(Integer id) {
    49.         if (head.getNext() == null) {
    50.             System.out.println("链表为空，删除失败！");
    51.         }
    52.         Node temp = head;
    53.         // 遍历链表
    54.         while(temp != null) {
    55.             // 表示到链表最后，直接退出
    56.             if (temp.getNext() == null) {
    57.                 break;
    58.             }
    60.             // 找到待删除节点的前一个节点
    61.             if (Objects.equals(temp.getNext().getId(), id)) {
    62.                 temp.setNext(temp.getNext().getNext());
    63.             }
    64.             temp = temp.getNext();
    65.         }
    66.     }
    68.     /**
    69.      * 获取节点
    70.      */
    71.     public Node get(Integer id) {
    72.         if (head.getNext() == null) {
    73.             System.out.println("链表为空");
    74.             return null;
    75.         }
    76.         Node temp = head.getNext();
    77.         while(temp != null) {
    78.             if (Objects.equals(temp.getId(), id)) {
    79.                 return temp;
    80.             }
    81.             temp = temp.getNext();
    82.         }
    83.         return null;
    84.     }
    86.     /**
    87.      * 查看所有节点
    88.      */
    89.     public void list() {
    90.         if (head.getNext() == null) {
    91.             System.out.println("链表为空");
    92.             return;
    93.         }
    94.         Node temp = head.getNext();
    95.         while(temp != null) {
    96.             System.out.println(temp);
    97.             temp = temp.getNext();
    98.         }
    99.     }
    101.     /**
    102.      * 链表节点反转
    103.      * @return
    104.      */
    105.     public void reverse() {
    106.         if (head.getNext() == null) {
    107.             return;
    108.         }
    109.         LinkedList tempList = new LinkedList();
    110.         // 遍历原链表，依次放在临时链表的最前面
    111.         Node temp = head.getNext();
    112.         while(temp != null) {
    113.             // 1、首先找到原链表当前节点的下一个节点
    114.             Node nextNode = temp.getNext();
    115.             // 2、把新链表的第一个节点插入到当前节点的后面
    116.             temp.setNext(tempList.head.getNext());
    117.             // 3、把当前节点插入新链表的第一个节点中
    118.             tempList.head.setNext(temp);
    119.             // 4、继续寻找下一个节点
    120.             temp = nextNode;
    121.         }
    122.         head.setNext(tempList.head.getNext());
    123.     }
    125.     /**
    126.      * 反向打印
    127.      */
    128.     public void reversePrint() {
    129.         reversePrint2(head.getNext());
    130.     }
    132.     /**
    133.      * 反向输出(递归)
    134.      */
    135.     private void reversePrint2(Node node) {
    136.         if (node != null) {
    137.             reversePrint2(node.getNext());
    138.             System.out.println(node);
    139.         }
    140.     }
    142.     public static void main(String[] args) {
    143.         LinkedList linked = new LinkedList();
    144.         Scanner scanner = new Scanner(System.in);
    145.         boolean loop = true;
    146.         while (loop) {
    147.             System.out.print("【单向链表】新增(1)、查找(2)、修改(3)、删除(4)、反转(5)、反向打印(6)、打印(7)、退出(0)：");
    148.             Integer key = scanner.nextInt();
    149.             switch (key) {
    150.                 case 1:
    151.                     System.out.print("新增Id：");
    152.                     int id = scanner.nextInt();
    153.                     System.out.print("新增Data：");
    154.                     String data = scanner.next();
    155.                     Node node = new Node(id, data);
    156.                     linked.add(node);
    157.                     break;
    158.                 case 2:
    159.                     System.out.print("查找Id：");
    160.                     int id2 = scanner.nextInt();
    161.                     System.out.println(linked.get(id2));
    162.                     break;
    163.                 case 3:
    164.                     System.out.print("修改Id：");
    165.                     int updateId = scanner.nextInt();
    166.                     System.out.print("修改Data：");
    167.                     String updateData = scanner.next();
    168.                     Node updateNode = new Node(updateId, updateData);
    169.                     linked.update(updateNode);
    170.                     break;
    171.                 case 4:
    172.                     System.out.print("删除Id：");
    173.                     int deleteId = scanner.nextInt();
    174.                     linked.del(deleteId);
    175.                     break;
    176.                 case 5:
    177.                     linked.reverse();
    178.                     System.out.println("反转完成！");
    179.                     break;
    180.                 case 6:
    181.                     linked.reversePrint();
    182.                     break;
    183.                 case 7:
    184.                     linked.list();
    185.                     break;
    186.                 case 0:
    187.                     scanner.close();
    188.                     loop = false;
    189.                     break;
    190.                 default: break;
    191.             }
    192.         }
    193.         System.out.println("程序退出。。。");
    194.     }
    195. }