链表+泛型+反射实现自定义的LinkedList集合类

package text; import java.lang.reflect.Field; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class Linked<T> implements Iterable<T>{ private Node head = null; //链表的头节点 //节点属性 private class Node{ private T data; //存入的数据对象 private Node next;//下一个节点 public Node(T data,Node next){ this.data = data; this.next = next; } @Override public boolean equals(Object obj) { //利用反射来判断两个泛型节点中的data是否相等 if(obj == null) return false; T compareObject = ((Node)obj).data; //得到两个比较对象的Class对象，因为Class对象只会有一个，所以可以用来做判断的条件 Class<T> compareClass = (Class<T>) compareObject.getClass(), currentClass = (Class<T>)this.data.getClass(); //判断两个对象的Class是否是同一个，不同则不相等 if(compareClass.equals(compareClass)){ //得到两个对象内的所有字段,依次进行比较是否相等 Field[] compareFields = compareClass.getDeclaredFields(),currentFields = currentClass.getDeclaredFields();; if(compareFields.length != currentFields.length){ //如果所取得的字段数量不同则不是同一个对象则直接返回false return false; } //遍历所有字段值，如果不相同则不是同一个对象，则返回false for(int i = 0; i < currentFields.length; i++){ compareFields[i].setAccessible(true); //让得到的私有属性可以取到值 currentFields[i].setAccessible(true); try { if(compareFields[i].get(compareObject) != currentFields[i].get(this.data)) return false; } catch (IllegalAccessException e) { e.printStackTrace(); } } return true; } return false; //排除以上的所有条件后，则就是相等的对象，返回true } } /** * 该构造方法表示创建一个带头节点的链表 */ public Linked(){ this(null,null); } /** * 该构造方法表示创建一个没有头节点的链表 * @param data 第一个节点中的树蕨 * @param next 第一个节点的下一个节点 */ public Linked(T data, Node next){ this.head = new Node(data,next); } /** * 向链表内添加节点 * @param object 需要向节点中添加的数据 */ public void addNode(T object){ if(this.head == null){ this.head = new Node(object,null); return; } Node temp = this.head; while(temp.next != null){ //遍历到链表的最后一个节点 temp = temp.next; } temp.next = new Node(object,null); //将最后一个节点的next指向新加入的对象 } /** * 删除链表指定位置上的数据 * @param index 指定的位置 * @return 是否删除成功 * @throws Exception */ public String deleteNode(int index) throws Exception{ if(this.head == null){ new Exception("该链表为空,无法删除指定的元素"); return "删除失败"; } int nodeIndex = 0; //两个指针，一前一后的进行移动，方便找到指定的元素后进行删除 Node before = this.head.next, after = this.head; while(before.next != null && nodeIndex != index){ after = before; before = before.next; nodeIndex++; } if(nodeIndex == linkedLength()){ //如果输入的要删除的数据在最后一个节点上，则直接舍弃最后一个节点 after.next = null; }else{ after.next = before.next; } return "删除成功"; } /** * 删除链表上指定的数据的节点 * @param data 指定的数据 * @return */ public String deleteNode(T data){ Node before = this.head.next, after = this.head; while(before.next != null){ if(before.data.equals(data)){ after.next = before.next; } after = before; before = before.next; } return "删除成功"; } /** * 得到指定节点位置的对象 * @param index 指定节点 * @return */ public T searchLinkedElement(int index){ Node temp = this.head; int nodeIndex = 0; while(temp != null){ if(nodeIndex == index){ return temp.data; } temp = temp.next; nodeIndex++; } return null; } /** * 得到链表上节点数据为data的节点 * @param data 想要得到的节点数据 * @return */ public List<T> searchLinkedElements(T data){ List<T> nodeArrays = new ArrayList<>(); //先用一个集合来存储符合条件的节点中的数据 Node temp = this.head.next, tempData = new Node(data,null); while(temp != null){ if(temp.equals(tempData)){ nodeArrays.add(temp.data); } temp = temp.next; } return nodeArrays; //将节点以数组的形式返回 } /** * 向链表内部的指定位置插入一个节点 * @param index 链表中指定的位置 * @param data 节点内存放的数据 * @return */ public String insertNode(int index,T data){ Node before = this.head.next, after = this.head; int nodeIndex = 0; //如果输入的位置大于或者等于链表的长度，则直接在链表的最后加入该节点 if(index >= linkedLength()){ addNode(data); }else{ //遍历该链表找到符合条件的位置 while(before != null && nodeIndex != index){ nodeIndex++; after = before; before = before.next; } after.next = new Node(data,before); //在合适的位置插入该节点 } return "插入元素失败"; } /** * 得到链表的长度 * @return */ public int linkedLength(){ Node temp = this.head; int length = 0; while(temp != null){ length++; temp = temp.next; } return length; } @Override public Iterator<T> iterator() { return new LinkedIterator<>(); } /** * 定义一个私有的内部类来实现链表的迭代 * @param <T> */ private class LinkedIterator<T> implements Iterator<T>{ private Node iterator = head; @Override public boolean hasNext() { iterator = iterator.next; return iterator != null; } @Override public T next() { return (T)iterator.data; } } }