java如何去实现单向链表

一切皆为对像，链表本是可以看成一个对像，链表的结点同样也可以看成一个对像。

自定义异常类：

Java代码

1. public class MyException extends Exception {   
2.        
3.     public MyException(){};   
4.        
5.     public MyException(String msg){   
6.         super(msg);   
7.     }   
8.   
9. }  

public class MyException extends Exception {
	
	public MyException(){};
	
	public MyException(String msg){
		super(msg);
	}

}

链表结点对像：

Java代码

1. public class Node {   
2.   
3.     public Node next=null;   
4.     public Object value=null;   
5.        
6.     Node(Object value){   
7.         this.value=value;   
8.     }      
9. }  

public class Node {

	public Node next=null;
	public Object value=null;
	
	Node(Object value){
		this.value=value;
	}	
}

链表对像：

Java代码

1. public class SinglyLinked {   
2.        
3.     private Node head=null;   
4.        
5.     SinglyLinked(){   
6.            
7.     }   
8.     /**  
9.      * 获取链表头元素  
10.      * @return 链表头结点  
11.      * @throws MyException   
12.      */  
13.     public Node getHead() throws MyException{   
14.         if(head==null){   
15.             throw new MyException("链表为空");   
16.         }   
17.         return head;   
18.     }   
19.     /**  
20.      * 获取该结点下的下一个结点  
21.      * @param node  
22.      * @return   
23.      */  
24.     public Node getNext(Node node){   
25.         return node.next;   
26.     }   
27.     /**  
28.      * 判断该结点是否还有下一个结点  
29.      * @param node  
30.      * @return  
31.      */  
32.     public boolean hasNext(Node node){   
33.            
34.         if(node.next==null){   
35.             return false;   
36.         }   
37.         return true;   
38.     }   
39.     /**  
40.      * 获得链表的最后一个元素  
41.      * @return  
42.      * @throws MyException   
43.      */  
44.     public Node getLast() throws MyException{   
45.            
46.         Node curNode=null;   
47.         Node next=null;   
48.            
49.         if(head==null){   
50.             throw new MyException("链表为空");   
51.         }else{   
52.             curNode=head;   
53.             while(hasNext(curNode)){   
54.                 next=curNode.next;   
55.                 curNode=next;   
56.             }   
57.         }   
58.         return curNode;   
59.     }   
60.     /**  
61.      * 根据索引获得元素  
62.      * @param index  
63.      * @return  
64.      */  
65.     public Node getNode(int index)throws MyException{   
66.            
67.         Node node=null;   
68.         Node curNode=null;   
69.         Node next=null;   
70.            
71.         if(head==null){   
72.             throw new MyException("链表为空");   
73.         }else{   
74.             curNode=head;   
75.             for(int i=0;i<index;i++){   
76.                 if(curNode==null){   
77.                     throw new MyException("你要查找的元素索引超过了链表的长度");   
78.                 }   
79.                 node=curNode;   
80.                 if(hasNext(curNode)){   
81.                     next=curNode.next;   
82.                     curNode=next;   
83.                 }else{   
84.                     curNode=null;   
85.                 }   
86.             }   
87.         }   
88.         return node;   
89.     }   
90.     /**  
91.      * 在链表头添加结点  
92.      * @param node  
93.      */  
94.     public void addFirst(Node node){   
95.         if(head==null){   
96.             head=node;   
97.         }else{   
98.             Node next=head;   
99.             node.next=next;   
100.             head=node;   
101.         }   
102.     }   
103.     /**  
104.      * 在链表尾部添加元素  
105.      * @param node  
106.      * @throws MyException   
107.      */  
108.     public void addLast(Node node) throws MyException{   
109.            
110.         if(head==null){   
111.             head=node;   
112.         }else{   
113.             Node last=this.getLast();   
114.             last.next=node;   
115.         }   
116.     }   
117.     /**  
118.      * 在链表中间插入元素  
119.      * @param index 要插入的结点  
120.      * @param node  
121.      */  
122.     public void insertNode(int index,Node node)throws MyException{   
123.            
124.         Node prevNode=null;   
125.            
126.         try{   
127.             prevNode=getNode(index-1);   
128.         }catch(MyException rex){   
129.             rex.printStackTrace();   
130.             throw new MyException("插入结点的索引大于链表长度");   
131.         }   
132.   
133.         if(hasNext(prevNode)){   
134.             Node next=prevNode.next;   
135.             prevNode.next=node;   
136.             node.next=next;   
137.         }else{   
138.             prevNode.next=node;   
139.         }   
140.   
141.     }   
142.     /**  
143.      * 删除链表的第一个元素  
144.      * @return  
145.      */  
146.     public Node deleteFirst(){   
147.         Node first=null;   
148.         Node node=head.next;   
149.         first=head;   
150.         head=node;   
151.         return first;   
152.     }   
153.     /**  
154.      * 删除链表的最后一个元素  
155.      * @return  
156.      */  
157.     public Node deleteLast(){   
158.            
159.         Node last=null;   
160.         Node curNode=head;   
161.         Node next=null;   
162.         boolean flag=true;   
163.            
164.         if(!hasNext(head)){   
165.             head=null;   
166.         }else{   
167.             while(flag){   
168.                 next=curNode.next;   
169.                 if(hasNext(next)){   
170.                     curNode=next;   
171.                 }else{   
172.                     curNode.next=null;   
173.                     last=next;   
174.                     flag=false;   
175.                 }   
176.             }   
177.         }   
178.         return last;   
179.     }   
180.     /**  
181.      * 按照索引删除元素  
182.      * @param index  
183.      * @return  
184.      */  
185.     public Node deleteNode(int index)throws MyException{   
186.         Node prevNode=null;   
187.         try{   
188.             prevNode=getNode(index-1);   
189.         }catch(MyException mex){   
190.             mex.printStackTrace();   
191.             throw new MyException("你要删除的结点索引大于链表的长度");   
192.         }   
193.         Node node=null;   
194.   
195.         if(hasNext(prevNode)){   
196.             node=prevNode.next;   
197.             if(hasNext(node)){   
198.                 Node next=node.next;   
199.                 prevNode.next=next;   
200.             }else{   
201.                 prevNode.next=null;   
202.             }   
203.         }else{   
204.             throw new MyException("你要删除的结点索引大于链表的长度");   
205.         }   
206.   
207.         return node;   
208.     }      
209.   
210. }