LinkedList底层原理实现

LinkedList底层原理实现
1.底层
1.LinkedList的底层是通过链表来实现的。
2.链表的单元
链表的单元是节点（Node）
链表是由多个节点构成，每个节点都包含三个部分，头部指向上一个节点，中部指向该节点，尾部指向下一个节点
双向链表：

2.优缺点
缺点：添加慢，因为需要遍历找到到最后一个指向为null的节点
优点：插入和删除快 因为可以直接改变下一个节点的指向

3.源码实现（单链）
package test2;

//节点类
public class Node {

// 数据值
private Object obj;
// 下一个节点的内存地址
private Node nextnode;

public Node getNextnode() {
	return nextnode;
}

public void setNextnode(Node nextnode) {
	this.nextnode = nextnode;
}

public Object getObj() {
	return obj;
}

// 无参构造
public Node() {
	super();
}

// 有参构造
public Node(Object obj) {

	this.obj = obj;
}

@Override
public String toString() {
	return "Node [obj=" + obj + ", next=" + nextnode + "]";
}

}

package test2;

//实现类
public class MyLinkedList {

// 第一个节点
private Node firstNode;
// 节点的个数
private int size;

// 添加节点
public void add(Object obj) {

	// 封装一个节点
	Node node = new Node(obj);

	// 1.判断是否第一个节点

	if (firstNode == null) {
		// 2.为空，直接把封装好的节点传入
		firstNode = node;
	} else {

		// 3.不为空，说明里面有节点 就遍历 拿到nextNode为空的节点
		Node nextnode2 = firstNode;
		while (nextnode2.getNextnode() != null) {
			nextnode2 = nextnode2.getNextnode();
		}

		// 4.拿到之后传值
		nextnode2.setNextnode(node);
	}

	// 记录节点个数
	size++;
	// System.out.println("进来了" + size);
}

// 删除节点
// a.删除指定索引处的元素
public void deleteByIndex(int index) {
	// 判空
	if (index < 0 || index > size - 1) {
		throw new RuntimeException("索引值不正确,请重新输入!");
	}

	// 获取正在被干掉的节点的前一个节点
	Node pronode = null;
	// 获取正在执行的节点
	Node node = firstNode;

	for (int i = 0; i < index; i++) {
		pronode = node;
		node = node.getNextnode(); // 获取正在被干掉的节点
	}
	// 索引为0
	if (index == 0) {
		firstNode.setNextnode(node.getNextnode());
	} else {
		// 索引不为0
		pronode.setNextnode(node.getNextnode());
	}
}

// b.删除指定的元素
public void deleteByObj(Object obj) {

	deleteByIndex(getIndexByObj(obj));

}

// 按照索引查出对应的元素
public Object findObjByIndex(int index) {
	// 判空
	if (index < 0 || index > size - 1) {
		throw new RuntimeException("索引值不正确,请重新输入!");
	}
	Node node = firstNode;
	for (int i = 0; i < index; i++) {
		node = node.getNextnode();
	}
	return node.getObj();
}

// 指出指定元素的第一次出现的索引
public int getIndexByObj(Object obj) {
	Node node = firstNode;
	int index = 0;// 定义索引
	while (node != null) {
		if (node.getObj().equals(obj)) {
			return index;
		}
		node = node.getNextnode();
		index++;
	}

	return -1;

}

// 查询节点个数
public int list() {
	return size;
}

@Override
public String toString() {
	// 字符串拼接
	StringBuilder sb = new StringBuilder("[");
	// 创建一个临时变量
	Node node = firstNode;
	while (node.getNextnode() != null) {
		sb.append(node.getObj());
		sb.append(",");
		node = node.getNextnode();
	}
	sb.append(node.getObj());
	sb.append("]");
	return sb.toString();
}

}

package test2;

//测试类
public class Test {

public static void main(String[] args) {

	MyLinkedList list = new MyLinkedList();
	list.add(1);
	list.add("hello");
	list.add(2);
	list.add(3);
	list.add(2);
	list.add(2);
	list.add(2);

	list.deleteByIndex(2);

	System.out.println(list.findObjByIndex(1));
	System.out.println(list.getIndexByObj(2));
	System.out.println("节点个数为：" + list.list());
	System.out.println(list.getIndexByObj(3));

	System.out.println(list);
	list.deleteByObj(3);
	System.out.println(list);
}

}