菜鸟学JAVA之——数据结构，单链表实现、泛型（部分）

一、数据结构，单链表的实现（这里实现了增、删、查功能）

public class Node {

    private String content;

    private Node next; //用以指向下一节点

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
}

public class MyList {
    //root这个节点是头节点，只有我能操作，不向外公开
    private final Node root = new Node(); //这个节点没有保存任何内容，没有指向任何一个节点，但并不代表它不存在。把他当作头节点

    private int size = 0;
    //添加节点,改变链表的结构
    public void add(Node node) {
        Node temp = root;//注意根节点一定不能动，要是动了马上就找不回来了（所以我上面把root设置为private final的，防止被修改），所以用temp来动

        while (temp.getNext()!=null) { //只要temp的下一个不为空，就一直向后遍历
            temp = temp.getNext();
        }
        temp.setNext(node);
        size++;
    }
	//add方法的重载，这个方法便于添加节点，不用想上面那个方法，每次添加节点都需要先创建
    public void add(String content) {
        Node node = new Node();
        node.setContent(content);
        this.add(node);
    }
    //获取节点，不改变节点的结构
    public Node get(int index) {
        Node result = root;//临时节点，用以遍历
        if(index < 0 || index > size) {
            System.out.println("下标有误！");
        }
        for(int i = 0; i < index+1; i++) {
            result = result.getNext();
        }
        return  result;
    }
    //删除尾节点，并返回值
    public Node remove() {
        Node temp = root;
        Node tail = temp.getNext();
        if(tail == null) {//先判断链表是否为空，如果为空直接返回，不需要再做后续的size--工作了
            return = null;
        }
        whlie(tail.getNext() != null) {
            temp = tail; //1.temp后移
            tail = tail.getNext();//2.tail后移，注意1和2的顺序不能能变
        }
        temp.setNext(null);
        size--;
        return tail;
    }

    public int size() {
        return size;
    }
}

这时我们发现，自己做的这个容器比数组好在可以任意变长，劣势是这里只能保存String类型的数据。如果要存其他类型数据，就需要改Node类里面的content的类型。很麻烦，所以这时就引入了泛型。

二、泛型（部分）

这里先对泛型做以了解，方便理解马上要学习的容器

泛型：用来对类型进行约束，并且进行统一化管理。具体的这个类的类型不知道，创建对象传什么类型他就是什么类型
泛型名一般为：E(element)、T(type)、K (key)、V(value)

普通泛型：

class Point<T>{       // 此处可以随便写标识符号，T是type的简称  
    private T var ; // var的类型由T指定，即：由外部指定  
    public T getVar(){  // 返回值的类型由外部决定  
        return var ;  
    }  
    public void setVar(T var){  // 设置的类型也由外部决定  
        this.var = var ;  
    }  
};  
public class GenericsDemo06{  
    public static void main(String args[]){  
        Point<String> p = new Point<String>() ; // 里面的var类型为String类型  
        p.setVar("it") ;        // 设置字符串  
        System.out.println(p.getVar().length()) ;   // 取得字符串的长度  
    }  
};  
----------------------------------------------------------  
class Notepad<K,V>{       // 此处指定了两个泛型类型  
    private K key ;     // 此变量的类型由外部决定  
    private V value ;   // 此变量的类型由外部决定  
    public K getKey(){  
        return this.key ;  
    }  
    public V getValue(){  
        return this.value ;  
    }  
    public void setKey(K key){  
        this.key = key ;  
    }  
    public void setValue(V value){  
        this.value = value ;  
    }  
};  
public class GenericsDemo09{  
    public static void main(String args[]){  
        Notepad<String,Integer> t = null ;        // 定义两个泛型类型的对象  
        t = new Notepad<String,Integer>() ;       // 里面的key为String，value为Integer  
        t.setKey("汤姆") ;        // 设置第一个内容  
        t.setValue(20) ;            // 设置第二个内容  
        System.out.print("姓名；" + t.getKey()) ;      // 取得信息  
        System.out.print("，年龄；" + t.getValue()) ;       // 取得信息  
  
    }  
}; 

通配符

class Info<T>{  
    private T var ;     // 定义泛型变量  
    public void setVar(T var){  
        this.var = var ;  
    }  
    public T getVar(){  
        return this.var ;  
    }  
    public String toString(){   // 直接打印  
        return this.var.toString() ;  
    }  
};  
public class GenericsDemo14{  
    public static void main(String args[]){  
        Info<String> i = new Info<String>() ;       // 使用String为泛型类型  
        i.setVar("it") ;                            // 设置内容  
        fun(i) ;  
    }  
    public static void fun(Info<?> temp){     // 可以接收任意的泛型对象  
        System.out.println("内容：" + temp) ;  
    }  
};  

泛型学习引自：https://www.cnblogs.com/sunwei2012/archive/2010/10/08/1845938.html