2014-10-12 每日一记

今天

（1）看了clone方法

首先要使用object的clone方法首先要实现Cloneable接口才行，也就是说得覆盖clone方法，单纯地仅仅调用super.clone（如下）只能实现浅复制，也就是说只做基本数据类型的拷贝，而对象还是共享的。

  public Object clone(){
        Object obj = null;
        try{
            obj = super.clone();
        }catch(CloneNotSupportedException ex){
            ex.printStackTrace();
        }
        return obj;
    }

要实现深复制，需要在clone函数中处理对象变量

//如 DeepCopyClass类中的对象为Date对象
 public Object clone(){
        DeepCopyClass obj = null;
        try{
            obj = (DeepCopyClass)super.clone();
        }catch(CloneNotSupportedException e){
            e.printStackTrace();
        }
        obj.setObject((Date)this.getObject().clone());
        return obj;
    }

（2）动手写了写linkedlist类

package mylinkedlist;

import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class MyLinkedList<E> implements Iterable<E>{
    private int size;
    private int modCount;
    private Node<E> header;
    private Node<E> tail;
    
    private static class Node<E>{
        public E data;
        public Node<E> previous;
        public Node<E> next;
        
        public Node(E d, Node<E> p,Node<E> n){
            this.next = n;
            this.previous=p;
            this.data=d;    
        }
    }
    public MyLinkedList(){
        size=0;
        header = new Node<E>(null,null,null);
        tail =new Node<E>(null,header,null);
        header.next=tail;
        modCount++;//这里也要使modCount+1
    }
    public int size(){
        return size;
    }
    public boolean isEmpty(){
        return size==0;
    }
    public E get(int index){
        return getNode(index).data;
    }
    public E set(int index, E ele){
        Node<E> temp = getNode(index);
        E old = temp.data;
        temp.data = ele;
        return old;
    }
 
    public void add(E element){
        add(size(),element);
    }
    public void add(int index, E element){
        Node<E> temp=getNode(index-1);
        Node<E> newEle= new Node<E>(element,temp,temp.next);
        temp.next=newEle;
        temp.next.previous=newEle;
        size++;
        modCount++;
    }
    //remove的方法这样写完全是为了让迭代器也能使用remove的方法，因为迭代器获取的不是要删除元素的具体位置而是要删除元素本身
    private E remove(Node<E> temp){
        temp.previous.next = temp.next;
        temp.next.previous=temp.previous;
        size--;
        modCount++;
        return  temp.data;
    }
    public E remove(int index){
        return remove(getNode(index));
    }
    
    
    private Node<E> getNode(int index){
        if(index<0|index>=size())
            throw new IndexOutOfBoundsException();
        Node<E> temp;
        if(size()/2>index){
            temp=header.next;
            for(int i=0;i<index;i++){
                temp=temp.next;
            }
        }else{
            temp=tail.previous;
            for(int i=size();i>index;i--){
                temp=temp.previous;
            }
        }
        return temp;
    }
    @Override
    public java.util.Iterator<E> iterator() {//你这个实现了Iterable的接口就要实现这个方法
        return new LinkedListIterator();
    }
    
    private class LinkedListIterator implements Iterator<E>{
        private int expectedModCount=modCount;
        private Node<E> current=header.next;
        private boolean okToMove = false;
        @Override
        public boolean hasNext() {
            // TODO Auto-generated method stub
            return current!=tail;
        }

        @Override
        public E next() {
            // TODO Auto-generated method stub
            if(!hasNext())
                throw new NoSuchElementException();
            if(expectedModCount!=modCount)
                throw new  ConcurrentModificationException();
            E temp = current.data;
            current=current.next;
            okToMove=true;
            return temp;
        }

        @Override
        public void remove() {
            // TODO Auto-generated method stub
            if(expectedModCount!=modCount)
                throw new  ConcurrentModificationException();
            if(!okToMove)
                throw new IllegalStateException();
            MyLinkedList.this.remove(current.previous);
            okToMove=false;
            expectedModCount++;//调用了外部类的remove会在那里面将modCount++;
            
        }
        
    }

}