【数据结构】java实现数据结构单循环双向链表类，泛型能添加任意类型，增删查改，头插法和尾插法

最近在自学java，刚写了C++的双链表，试着实现一下java版本的。话说C++程序员学java不得不感慨，不用释放内存是真方便。java和C++写起来感觉差不多，java的new出来的类对象是引用类型，实际上也就等于C++的指针，把它当作指针用就好了。还有JAVA居然不能运算符重载，泛型也不能传递int这样的基本类型，太坑。。。。
完整代码如下
节点类：

public class Node <T>{
	
	public Node() {
		m_nextNode =null;
		m_preNode = null;
	}
	public T m_data; //数据域
	public Node<T> m_nextNode;
	public Node<T> m_preNode;
}

链表类：

public class dbList<Type> {
	public dbList() {
		m_head = new Node<Type>();
		m_head.m_nextNode=m_head;
		m_head.m_preNode=m_head;
	}
	public void push_back(Type value)
	{
		Node<Type> node = new Node<Type>();
		node.m_data=value;
		node.m_preNode = m_head.m_preNode;//后继节点指向头节点的后继节点指向的节点
		node.m_nextNode = m_head;     //前驱节点指向头节点
		//头节点的后继节点也就是当前链表的尾部节点，将尾部节点的前驱节点指向node
		m_head.m_preNode.m_nextNode= node;  
		m_head.m_preNode = node; //头节点的后继节点指向node
	}
	//从头部插入元素
	public void push_front(Type value)
	{
		Node<Type> node = new Node<Type>();
		node.m_data = value;
		node.m_nextNode = m_head.m_nextNode;  //当前新增节点的前驱节点指向头节点的前驱节点
		node.m_preNode = m_head;    //当前新增节点的后继节点指向头节点

		m_head.m_nextNode.m_preNode = node; //头节点的前驱节点的后继节点指向当前新增节点
		m_head.m_nextNode = node;           //头节点的前驱节点指向当前新增节点	
	}
	//从双向循环链表中删除元素，删除第一个出现的指定元素
	public void deleteFirst(Type value)
		{
			Node<Type> node = m_head.m_nextNode;
			while (node!= m_head)
			{
				if (node.m_data==value)
				{
					//待删除节点的后继节点的前驱节点指向待删除节点的前驱节点
					node.m_preNode.m_nextNode = node.m_nextNode;  
					//待删除节点的前驱节点的后继节点指向待删除节点的后继节点
					node.m_nextNode.m_preNode = node.m_preNode;
					return;
				}
				node = node.m_nextNode;
			}
		}	
		//从双向循环链表中删除所有指定元素
	public void deleteAll(Type value) 
		{
			Node<Type> node = m_head.m_nextNode;
			while (node != m_head)
			{
				if (node.m_data == value)
				{
					//待删除节点的后继节点的前驱节点指向待删除节点的前驱节点
					node.m_preNode.m_nextNode = node.m_nextNode; 
						//待删除节点的前驱节点的后继节点指向待删除节点的后继节点
					node.m_nextNode.m_preNode = node.m_preNode;
					node = node.m_preNode;   //将node移动到上一节点
				}
				node = node.m_nextNode;
			}
		}
	public int size() 
		{
			Node<Type> node = m_head.m_nextNode;
			int listSize = 0;
			while (node != m_head)
			{
				node = node.m_nextNode;
				listSize++;
			}
			return listSize;
		}
	public int findFirst(Type value, int pos)
		{
			if (pos < 0 || pos>= this.size() ) return -1;
			Node<Type> posNode = m_head.m_nextNode; //指向pos所在位置的指针
			for (int i=0;i<=pos;i++)
			{
				posNode = posNode.m_nextNode;
			}
			int valuePos = 0;
			while (posNode != m_head)
			{
				if (posNode.m_data == value)
				{
					return valuePos+1;
				}
				valuePos++;
				posNode = posNode.m_nextNode;
			}
			return -1;

		}
	public void printfAll()
		{
			Node<Type> node = m_head.m_nextNode;
			String str=new String();
			while (node != m_head)
			{
				str+=node.m_data.toString();
				str+=" ";
				node = node.m_nextNode;
			}
			System.out.println(str);
		}
	private Node<Type> m_head;
}

测试类

dbList<Integer> list =new dbList<Integer>();
		
		list.push_back(22);
		list.push_back(222);
		list.push_back(212);
		list.push_back(32);
		list.push_back(32);
		list.push_back(22);
		list.push_front(112);
		list.printfAll();
		System.out.println("32第一次出现的位置是："+list.findFirst(32, 0));
		list.deleteFirst(222);
		list.printfAll();
		list.deleteAll(22);
		list.printfAll();