手动实现JAVA中单链表LinkedList类中常用功能

先初始化单链表类中数据，定义好成员变量，构造方法，内部类等，然后在添加常用方法 

public class SinglyLinkedListDemo {
	/**这是只是建立一个first */
	private Node first;
	/**定义一个变量保存结点个数*/
	private int size;
	/**无参构造*/
	public SinglyLinkedListDemo() {
	}
	/**有参构造，初始化一个结点*/
	public SinglyLinkedListDemo(Object value) {
		super();
		Node node = new Node(value);
		first = node;
	}
	/**定义一个结点内部类*/
	private class Node{
		/**定义两个成员变量，value保存值，next保存下一个结点的地址值*/
		Object value;
		Node next;
		/**无参构造*/
		public Node(){
		}
		/**有参构造，初始化value值*/
		public Node(Object value) {
			super();
			this.value = value;
		}
	}
}

1、可以任意添加任意类型的数据 void add(Object obj)

/**
 * 1. 可以任意添加任意类型的数据 void add(Object obj)
 * @param obj
 */
public void add(Object obj){
	//先建立一个结点
	Node node = new Node(obj);
	//判断第一个结点是否为空，如果为空，直接把新的结点地址赋值给first第一个结点
	if(first == null){
		first = node;
	}else{
		//定义一个变量temp记录遍历中的结点
		Node temp = first;
		//如果结点还有下一个结点，就继续遍历、直到最后一个结点
		while(temp.next != null){
			temp = temp.next;
		}
		//遍历到的最后一个结点保存新结点的地址值
		temp.next = node;
	}
	//链表中元素的个数加1
	size++;
}

2. 返回元素的个数 int size()

/**
 * 2. 返回当前元素的个数 int size()
 * @return
 */
public int size(){
	return size;
}

3、重写toString方法

/**
 * 3. 可以打印当前数据结构的对象 toString()，格式如下：[值1，值2.。。。。]
 * 	遍历整个链表，将链表中value值取出，字符串拼接
 */
@Override
public String toString() {
	//因为要一直要拼接字符串、为了提高效率、所以用StringBuilder
	StringBuilder sb = new StringBuilder("[ ");
	//判断如果没有元素，打印 [ ]
	if(first == null){
		sb.append("]");
	}else{
		//定义一个变量temp记录便利中的结点
		Node temp = first;
		//实现链表中的元素拼接
		while(temp.next != null){
			sb.append(temp.value + " , ");
			temp = temp.next;
		}
		sb.append(temp.value + "]");
	}
	//将StringBuilder转换为String型并返回
	return sb.toString();
}

/**
 * 写一个私有方法、用来检测调用方法时输入下标越界问题
 * @param index
 */
private void checkIndex(int index){
	if(index<0 || index>=size){
		throw new IllegalArgumentException("亲，下标范围是：[0,"+(size-1)+"]");
	}
}

/**
 * 4. 查询指定下标的元素  Object searchByIndex(int index)
 * @param index
 * @return
 */
public Object searchByIndex(int index){
	//先检测下标越界
	checkIndex(index);
	//定义一个count用来计数遍历
	int count = 0;
	//同上，定义一个temp保存遍历当前的地址
	Node temp = first;
	//定义一个对象来保存需要返回的元素值
	Object obj = null;
	//遍历链表
	while(count != index){
		temp = temp.next;
		count++;
	}
	obj = temp.value;
	//返回下标元素
	return obj;
}

/**
 * 5. 查询指定的元素第一次出现的位置  int searchByElement(Object ele);
 * @param ele
 * @return
 */
public int searchByElement(Object ele){
	Node temp = first;
	int count = 0;
	if(ele == null){
		while(temp.value != ele){//思维一：判断值等不等
			if(temp.next == null){
				return -1;
			}
			count++;
			temp = temp.next;
		}
		return count;
	}else{
		while(temp != null){//思维二：判断地址是否为空
			if(ele.equals(temp.value)){
				return count;
			}
			count++;
			temp = temp.next;
		}
	}
	return -1;
}

 自定义一个私有方法、根据下标返回此下标所对应的对象。目的：可以重复调用此方法，来更轻松地完成后面几个方法。PS：下面几个方法会调用上面写过的方法

/**
 * 根据下标查询当前的节点对象 Node searchNodeByIndex(int index)
 * @param index
 * @return
 */
private Node searchNodeByIndex(int index){
	checkIndex(index);
	Node temp = first;
	int count = 0;
	while(count<index){
		temp = temp.next;
		count++;
	}
	return temp;
}

/**
 * 6. 修改指定下标处的元素  void updateByIndex(int index,Object obj)
 * @param index
 * @param obj
 */
public void updateByIndex(int index,Object obj){
	checkIndex(index);
	Node searchNodeByIndex = searchNodeByIndex(index);
	searchNodeByIndex.value = obj;
}

/**
 * 7. 删除指定下标处的元素，返回删除的元素  Object deleteByIndex(int index)
 * @param index
 * @return
 */
public Object deleteByIndex(int index){
	checkIndex(index);
	Object obj = null;
	if(index == 0){
		obj = first.value;
		first = first.next;
		size--;
		return obj;
	}else{
		Node node1 = searchNodeByIndex(index);
		obj = node1.value;
		Node node2 = searchNodeByIndex(index-1);
		node2.next =node1.next;
		size--;
		return obj;
	}
}

/**
 * 8. 删除的首次出现的指定元素     void deleteByElement(Object ele)
 * @param ele
 */
public void deleteByElement(Object ele){
	int index = searchByElement(ele);
	if(index<0){
		return;
	}
	deleteByIndex(index);
}

/**
 * 9. 插入指定下标处一个指定元素 void insertByIndex(int index,Object obj)
 * @param index
 * @param obj
 */
public void insertByIndex(int index,Object obj){
	checkIndex(index);
	Node newNode = new Node(obj);
	//Node temp = first;
	if(index == 0){
		newNode.next = first;
		first = newNode;
		size++;
	}else{
		Node node = searchNodeByIndex(index);
		Node node2 = searchNodeByIndex(index-1);
		newNode.next = node;
		node2.next = newNode;
		size++;
	}
}

/**
 * 10.将对象中所有元素清空 void clear();
 */
public void clear(){
	first = null;
	size = 0;
}

PS：以上10个方法是单链表中常用的方法，由于注释太难写了，所以后面的方法，没什么注释，还望原谅0.0