자바 로 단일 체인 테이블 구조 와 기본 데이터 조작 실현

링크 구조
링크 는 물리 적 저장 장치 에서 비 연속 적 이 고 비 순서 적 인 저장 구조 로 데이터 요소 의 논리 적 순 서 는 링크 순 서 를 통 해 이 루어 진다.체인 시 계 는 결점 으로 구성 되 어 있다.각 노드 의 구성: 요소 (데이터 요소 의 이미지) + 참조 (후계 요소 의 저장 위 치 를 표시) 요 소 는 데 이 터 를 저장 하 는 저장 장치 이 고 인용 은 각 노드 를 연결 하 는 주소 데이터 입 니 다.
무엇이 단일 체인 시계 입 니까?
단일 체인 시트 는 체인 액세스 의 구조 로 특정한 데이터 요 소 를 찾 으 려 면 첫 번 째 또는 특별히 가리 키 는 특정한 요소 에서 뒤로 찾 아야 합 니 다.
코드 구현
기능 은 데이터 add 추가, 데이터 업데이트 수정, 데이터 remove 삭제, 교체 기 구현, toString 재 작성 방법 을 포함 합 니 다.주의: 이 링크 구조 디자인 시 중복 요소 가 나타 나 지 않 습 니 다.

package com.it;

import java.util.Iterator;

import com.it.SingleLink.Node;

/**
 *        
 * @author Administrator
 *
 */
public class SingleLink<T> implements Iterable<T>{

    class Node{//     
        private T date;
        private Node next;
        public Node(T date){
            this.date = date;
        }
    }
    private Node head;//   
    /**
     *     
     * @param date
     *      T  
     * @return
     *      Boolean     ，true      
     *                      false      
     */
    public boolean add(T date){//      
        boolean flag = false;
        Node newNode = new Node(date);//     
        //      
        if(head==null){//   ，         ，     
            head = newNode;
            flag = true;
        }else{//   ，       ，next        
            Node tailNode = findTailNode();
            tailNode.next = newNode;
            flag = true;
        }
        return flag;

    }
    /**
     *     
     * @param date
     * @return
     */
    public boolean remove(T date){
        boolean flag = false;
        //    ，         
        Node dateNode = findNode(date);
        //             
        Node prevNode = findPrevNode(date);
        Node nextNode = dateNode.next;
        if(prevNode==null){//         
            if(nextNode==null){//          
                //       
                head = null;
                flag = true;
            }
            //           
            head = nextNode;
            flag = true;
        }else if(nextNode==null){//         
            //       next    null
            prevNode.next = null;
            flag = true;
        }else{//          
            //       next    nextNode
            prevNode.next = nextNode;
            flag = true;
        }
        return flag;
    }
    /**
     *     
     * @param old
     * @param newDate
     * @return
     */
    public boolean update(T old,T newDate){
        boolean flag = false;
        Node target = findNode(old);//        （           ）
        if(target==null){
            throw new RuntimeException("     ");
        }else{//        
            Node existNode = findNode(newDate);
            if(existNode!=null){//      
                throw new RuntimeException("       ，         ");
            }
            //      date 
            target.date = newDate;
            flag = true;

        }
        return flag;
    }

    /**
     *        
     * @param date
     *          
     * @return
     *      Node
     */
    private Node findPrevNode(T date) {
        //      
        Node temp = head;
        while(temp!=null){
            if(temp.next!=null){
                T dat = temp.next.date;
                if(date.equals(dat)){
                    return temp;
                }else{
                    temp = temp.next;//       
                }
            }
        }
        return null;
    }
    /**
     *           
     * @param date
     * @return
     */
    private Node findNode(T date) {
        //      
        Node temp = head;
        while(temp!=null){
            T dat = temp.date;
            if(date.equals(dat)){
                return temp;
            }else{
                if(temp.next!=null){//        
                    temp = temp.next;//       
                }else{//       
                    return null;
                }
            }
        }
        return null;
    }
    /**
     *      
     * @return
     *          
     */
    private Node findTailNode() {
        //      
        Node temp = head;
        Node tailNode = null;
        while(temp!=null){
            if(temp.next!=null){//        
                temp = temp.next;//       
            }else{//       
                tailNode = temp;
                break;//    ，      
            }
        }
        return tailNode;
    }

    @Override
    /**
     *   toString  
     */
    public String toString() {
        StringBuffer sb = new StringBuffer();
        sb.append('[');
        if(head!=null){
            Node temp = head;
            while(temp!=null){
                if(temp.next!=null){//        
                    sb.append(temp.date).append(',');
                    temp = temp.next;//       
                }else{//       
                    sb.append(temp.date).append(']');
                    break;
                }
            }
        }else
            sb.append(']');
        return sb.toString();
    }
    @Override
    /**
     *       
     * @return
     */
    public Iterator iterator() {

        return new Iterator() {
            Node node = head;//        
            T date = null;//       
            @Override
            public boolean hasNext() {

                return node!=null;
            }

            @Override
            public T next() {
                //      
                date = node.date;
                node = node.next;
                return date;
            }

            @Override
            public void remove() {
        SingleLink.this.remove(date);
            }
        };
    }
}