容器与数据结构

一：容器

分类：

增：

c.add("123");
c.add("456");
c.add("456");
//c=["123","456","456"]

这两个456字符串是不是一个对象呢
这里是否是一个对象还是遵循字符串是否是一个对象的原则，如果是字符串字面量则是一个对象，如果是字面量拼接也是，但是如果是变量的拼接就不是了。
ArrayList:数组，查询效率高 增删效率低 线程不安全
LinkedList 链表 增删效率高 查询效率低 线程不安全
Vector 线程安全

删：

c.remove("456")

这里两个456字符串对象虽然是同一个对象，但是如图源码里的remove，当找到一个就return了，如果想要删除所有的456，可以使用removeAll

c1=["456"];
c.removeAll(c1);

改：

c.set(1,"789");

查：

c.get(1);

ArrayList

可变长（数组扩容 要溢出了时创建更大的数组，把老数组copy过去覆盖新数组）

二：实现简单的ArrayList：

package 容器实现;

public class CszArrayList<T> {
//    这不能定于成T 定义时需要明确，因此使用Object
    private Object[] data;
    private int size;
    private int capaticy=10;


//    无参构造
   public CszArrayList(){
//       默认初始长度10,长度0
       data = new Object[capaticy];
       size = 0;
    };
//   打印
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("(");
        for (int i=0;i<size;i++){
            sb.append(data[i]+" ");
        }
        sb.append(")");
        return sb.toString();
    }
//增
    public void add(T o){
       if(capaticy==size){
//           扩容
           capaticy = capaticy+capaticy/2;
           Object[] tmp = new Object[capaticy];
           System.arraycopy(data,0,tmp,0,capaticy);
           data = tmp;
       }
       data[size++]=o;
   }
//   删(根据jindex)
    public void remove(int index){
//        index范围判断
        rangeCheck(index);
        System.arraycopy(data,index+1,data,index,size-index);
        size--;
    }
//    根据对象删除（删除所有equal的对象）
    public void removeObj(T t){
        for (int i=0;i<size;i++){
            if(data[i].equals(t)){
                System.arraycopy(data,i+1,data,i,size-i);
                size--;
            }
        }

    }
//    修改
    public void set(int index,T t){
        rangeCheck(index);
        data[index]=t;
    }
//    查询
    public T get(int index){
        rangeCheck(index);
        return (T)data[index];
    }
//    index判断
    private void rangeCheck(int index){
        if(index>size-1 || index <0){
            throw new RuntimeException("下标违法");
        }
    }

    
    
}

三：实现简单的LinkList

package 容器实现;

public class CszLinkedList<T> {
    Node first;
    Node last;
    int size;

    public CszLinkedList(){
        first=last=null;
        size = 0;
    };

    @Override
    public String toString() {
        Node t = first;
        StringBuilder sb = new StringBuilder("(");
       while (t!=null){
           sb.append(t.data+" ");
           t = t.next;
       }
       sb.append(")");
       return sb.toString();
    }

    //    增
    public void add(T t){
//        第一个元素
        if(first==null){
            Node tmp = new Node();
            tmp.previous=tmp.next=null;
            tmp.data=t;
            first=last=tmp;
        }else {
            Node tmp = new Node();
            tmp.previous=last;
            tmp.next=null;
            tmp.data=t;
            last.next=tmp;
            last=tmp;
        }
        size++;
    }
//    删
    public void remove(int index){
        rangeCheck(index);

        if(index==0){
            first=first.next;
            if(size!=1) {
                first.previous = null;
            }
        }else if(index==size-1){
            last=last.previous;
            last.next=null;
        }else{
            Node t = get(index);
            t.next.previous=t.previous;
            t.previous.next=t.next;
        }
        size--;


    }
//        index判断
    private void rangeCheck(int index){
        if(index>size-1 || index <0){
            throw new RuntimeException("下标违法");
        }
    }
//  修改值
    public void set(int index,T t){
        rangeCheck(index);
       Node tmp=get(index);
        tmp.data=t;

    }
//    查找
    public Node get(int index){
        Node tmp = first;
        for(int i=0;i<index;i++){
            tmp = tmp.next;
        }
        return tmp;
    }
}
class Node{
    public Node previous;
    public Node next;
    public Object data;

    @Override
    public String toString() {
        return data.toString();
    }
}

四：实现简单的HashMap

package 容器实现;

import com.sun.corba.se.spi.ior.ObjectKey;

public class CszHashMap<K,V> {
    private HashNode[] table;
    private int capacity=16;
    public CszHashMap(){
        table = new HashNode[capacity];
    }
//    增
    public void put(K key, V value){
        int hash = myhash(key,capacity);
        HashNode tmp = new HashNode();
        tmp.key=key;
        tmp.value=value;
        tmp.next=null;
        if(table[hash]==null){
            table[hash]=tmp;
        }else{
            HashNode t = table[hash];
            while (t.next!=null)
            {

                if(t.key==key){
                    System.out.println("key重复了");
                    t.value=value;
                   return;
                }
                t=t.next;
            }
            t.next=tmp;


        }

    }
//    删
    public void remove(K key){
        int hash = myhash(key,capacity);
        if(table[hash]==null)
            return;
        else if(table[hash].next==null)
            table[hash]=null;
        else {
            HashNode t = table[hash];
            HashNode pre=null;
            while(t.next!=null && t.key!=key){
                pre = t;
                t = t.next;
            }
            if(t==table[hash]){
                table[hash]=t.next;
            }
            else if(t.next==null)
                pre.next=null;
            else {
                pre.next = t.next;
            }
        }
    }

//    改
    public void set(K key,V value){
        int hash = myhash(key,capacity);
        HashNode t = table[hash];
        while (t!=null && t.key!=key){
            t=t.next;
        }
        if(t==null)
            return;
        else
            t.value=value;

    }
//    查
    public Object get(K key){
        int hash = myhash(key,capacity);
        HashNode t=table[hash];
        if (t==null)
            return null;
        while (t.next!=null){
            t=t.next;
        }

        return t.value;
    }
//

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("(");
        for(int i=0;i<capacity;i++){
            HashNode t=table[i];
            while(t!=null){
                sb.append(t.key+","+t.value+" ");
                t=t.next;
            }
            if(table[i]!=null)
                sb.append("\n");
        }
        sb.append(")");
        return sb.toString();
    }

    public int myhash(K key, int length){
        return key.hashCode()&(length-1);
    }
}
class HashNode{
    public Object key;
    public Object value;
    public HashNode next;


}