Day18

增加小的封装

增加泛型

因为异常手动抛出，对索引的检查经常要使用到，所以我们把异常抛出单独的拿出来，做了分装，在要用的地方直接调用checkRange方法检查索引就好了。

增加泛型，只能输入特定的类型，获取起来也更加方便了

package cn.sxt.mycollection;

import static java.lang.System.*;

/**
 * 自定义一个链表
 * 增加get方法
 * 增加remove方法
 * 增加插入节点
 * 增加小的封装，泛型
 * @param <E>
 */

public class SexLinkedList05<E> {
    private Node first;
    private Node last;
    private  int size;



    public void add(int index,E element) {
        checkRange(index);
        Node newNode = new Node(element);
        Node temp = getNode(index);

        if (index==0){
            first=newNode;
            newNode.next=temp;
            temp.previous=newNode;
        }else if (index>0&&index<size-1) {
            Node up = temp.previous;
            up.next = newNode;
            newNode.previous = up;

            newNode.next = temp;
            temp.previous = newNode;
        }else if (index==size-1){
            last=newNode;
            Node up=temp;
            up.next=newNode;
            newNode.previous=up;
        }
        size++;

    }


    public void remove(int index){
        checkRange(index);
        Node temp=getNode(index);
        if (temp!=null){
            Node up=temp.previous;
            Node down=temp.next;
            if (up!=null){
                up.next=down;
            }
            if (down!=null){
                down.previous=up;
            }//被删除的元素是第一个元素时
            if (index==0){
                first=down;
            }//被删除的元素是最后一个元素时
            if (index==size-1){
                last=up;
            }
        }
        size--;
    }


    //[]
    //["a","b","c","e","f"]
    public E get(int index){
        checkRange(index);

        Node temp=getNode(index);

        return temp!=null?(E) temp.element:null;
    }

    private void checkRange(int index){
        if (index<0||index>size-1){
            throw new RuntimeException("索引数字不合法"+index);
        }
    }

    private Node getNode(int index){
        checkRange(index);
        Node temp;
        if(index<=(size>>1)){//size>>1相当于除以2
            temp=first;
            for(int i=0;i<index; i++){
                temp=temp.next;
            }
        }else{
            temp=last;
            for(int i=size-1;i>index;i--){
                temp=temp.previous;
            }
        }
        return temp;
    }



    public void add(E element ){
        Node node = new Node(element);
        if (first==null){
            // node.previous=null;
            //node.next=null;
            first=node;
            last=node;
        }else{
            node.previous=last;
            node.next=null;
            last.next=node;
            last=node;
        }
        size++;
    }

    @Override
    public String toString() {

        //[a,b,c]  first=a   last=c
        //a,b,c

        StringBuilder sb = new StringBuilder();
        sb.append( ""+"[");
        Node temp=first;

        while (temp!=null){
            sb.append(temp.element+",");
            temp = temp.next;
        }

        sb.setCharAt(sb.length()-1,']');

        return sb.toString();
    }

    public static void main(String[] args) {

        SexLinkedList05<String> list = new SexLinkedList05<>();

        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");

        out.println(list);
        //System.out.println(list.get(5));
        //list.remove(3);
        // System.out.println(list);
        // list.remove(0);
        //System.out.println(list);
        list.add(5,"小宝");

       System. out.println(list);
       System. out.println(list.get(6));
    }

}

Vector

底层实现也是数组

**特点：**线程安全，效率低。

相关的方法都添加了同步检查(synchronized)

public synchronized int indexOf(){}

方法的运行需要持有锁，持有锁才能运行，没有就需要等待，这样就意味着效率变低了。

需要线程安全的时候用Vector

一般都不存在线程安全的问题，并且查找较多所以一般都用ArrayList

Map

Map就是用来存储“键(key)-值(value）对”的（键找值）

Map存储中时通过键来标识的，所以“键对象”不能重复

Map常用的方法:get，isEmpty，size，containsKey，containValue，putAll等方法发

package cn.sxt.collection;

import java.util.HashMap;
import java.util.Map;

/**
 * 测试HashMap的使用
 */

public class TestMap {
    public static void main(String[] args) {
        Map<Integer,String> m1=new HashMap<>();
        m1.put(1,"one");
        m1.put(2,"two");
        m1.put(3,"three");

        System.out.println( m1.get(1));
        System.out.println(m1.isEmpty());
        System.out.println(m1.size());
        System.out.println(m1.containsKey(2));
        System.out.println(m1.containsValue("four"));

        Map<Integer,String> m2=new HashMap<>();

        m2.put(4,"四");
        m2.put(5,"五");

        m1.putAll(m2);
        System.out.println(m1);

        //键不能重复，如果重复(是否重复根据equals方法判断),新的键会覆盖老的键
        m1.put(3,"三");
        System.out.println(m1);
    }
}