Java Day 18

泛型
 提高了安全性，由运行时期出现的问题转移到编译时期
 应用场景
  当操作的引用数据类型不确定的时候，就是用<>。
  其实<>就是一个用于接收具体引用数据类型的参数范围。
 
擦除与补偿
 泛型技术是给编译器使用的技术，用于编译时期。确保了类型的安全。
 运行时，会将泛型去掉，生成的class文件中是不带泛型的，这个称为泛型的擦除。
 兼容运行的类加载器。
 补偿：在运行时，获取元素的类型进行转换，无须强制类型转换。

package com.company.Day018;


/**
 * Created by junius on 2016/10/8.
 */
class Tool<T>{
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

    public void show(T str){ //泛型方法
        System.out.println("show:"+str);//str.length()支持么？
    }

    public <w> void show1(w str){
        System.out.println("show1:"+str);
    }

    public static <ww> void show2(ww str){
        System.out.println("show2:"+str);
    }
    /*
    public static  void show2(T str){
        System.out.println("show2:"+str);
    }
    */

    public void print(String str){
        System.out.println("print:"+str);
    }
}
/*public class Tool{
    private Person person;

    public Person getPerson() {
        return person;
    }

    public void setPerson(Person person) {
        this.person = person;
    }
}*/
public class GenericClassDemo {
    public static void main(String[] args){

    }
}

泛型应用
  TreeSet:
 
自定义泛型类
 
泛型方法
 public <w> void show(w str){ }//不是所有的字符串方法都支持
 
 如果是静态方法，不能访问 类 上定义的泛型。
 如果静态方法要使用泛型，只能将泛型定义在方法上。

 public static <w> void show(w obj){ } 

泛型接口

package com.company.Day018;

/**
 * Created by junius on 2016/10/8.
 */

interface Inter<T>{
    public void show(T t);
}

class InterImpl2<Q> implements Inter<Q>{
    public void show(Q  q){
        System.out.println("show:"+q);
    }
}

class InterImpl implements Inter<String>{
    public void show(String str){
        System.out.println("show :"+str);
    }
}

public class GenericInterfaceDemo {
    public static void main(String[] args){
        InterImpl in = new InterImpl();
        in.show("abc");
        InterImpl2<Integer> in2 = new InterImpl2<Integer>();
        in2.show(5);
    }
}

泛型限定-上限
 通配符:? 未知类型
 ? extends E 接收 E 类型或子类型对象

package com.company.Day018;

import java.util.*;

/**
 * Created by junius on 2016/10/9.
 */
public class GenericAdvanceDemo {
    public static void main(String[] args){
        ArrayList<String> al = new ArrayList<String>();
        al.add("abc");
        al.add("aaa");

        List<Integer> al2 = new ArrayList<Integer>();
        al2.add(22);
        al2.add(33);

        printCollection(al);
        printCollection(al2);
    }

    public static void printCollection(Collection<?> al) {
        Iterator<?> it = al.iterator();

        while(it.hasNext()){
//            ? str = it.next();
            System.out.println(it.next());
        }
    }
}

package com.company.Day018;

import com.company.Java_Bean.Person;
import com.company.Java_Bean.Student;
import com.company.Java_Bean.Worker;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

/**
 * Created by junius on 2016/10/9.
 */
public class GenericAdvanceDemo2 {
    public static void main(String[] args){
        ArrayList<Worker> al = new ArrayList<Worker>();
        al.add(new Worker("zhangsan",23));
        al.add(new Worker("lisi",24));

        ArrayList<Student> al2 = new ArrayList<Student>();
        al2.add(new Student("zhangsan",13));
        al2.add(new Student("lisi2",14));

        printCollection(al);
        printCollection(al2);
    }

    public static void printCollection(Collection<? extends Person> al) {
        Iterator<? extends Person> it = al.iterator();

        while(it.hasNext()){
            Person p = it.next();
            System.out.println(p.getName());
        }
    }
}

泛型限定-下限
 ? super E :接收 E 或 父类型

上限的体现
 存元素

下限的体现
 

集合技巧
 set
 TreeSet
 HashSet LinkedHashSet
 List
 
Map集合
 value put(key value)
 
 void clear()
 value remove(key)

 value get(key)

keySet
 
entrySet
 返回May.Entry类型
 
方法value
 Collection values()

常见子类
 Hashtable 哈希表 同步 null不允许作为键、值
   Properties 配置文件--> I/O 技术
 HashMap null 允许作为键、值
 TreeMap

package com.company.Day018.Map;

import java.util.*;
import java.util.zip.Inflater;

/**
 * Created by junius on 2016/10/9.
 */
public class MapDemo {
    public static void main(String[] args){
        Map<Integer,String> map = new HashMap<Integer,String>();
        //method(map);
        method_2(map);
    }
    public static void method_2(Map<Integer,String> map){
        map.put(8,"wanli1");
        map.put(9,"wanli2");
        map.put(12,"wanli23");
        map.put(18,"wanli3");

        Set<Integer> keyset = map.keySet();

        Iterator<Integer> it = keyset.iterator();
        while(it.hasNext()){
            Integer key = it.next();
            System.out.println(key+":"+map.get(key));
        }

        Set<Map.Entry<Integer,String>> entrySet = map.entrySet();
        Iterator<Map.Entry<Integer,String>> it2 = entrySet.iterator();

        while(it2.hasNext()){
            Map.Entry<Integer,String> me = it2.next();
            Integer key = me.getKey();
            String value = me.getValue();
            System.out.println(key+":-:"+value);


        }

    }
    public static void method(Map<Integer,String> map){
        System.out.println(map.put(1,"lisi"));
        System.out.println(map.put(11,"lisi2"));
        System.out.println(map.put(11,"lisi3"));
        System.out.println(map.put(13,"lisi4"));
        System.out.println(map);

        System.out.println(map.remove(11));
        System.out.println(map);


    }
}