泛型

复习到反射，奇怪为什么有时候是

ArrayList<String> al=new ArrayList<String>();
List<String> l=new ArrayList<String>();

于是试了下他们的区别，顺便总结了下java容器

package fanxing;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Vector;
interface d<T>{}
class bean{
    int a=10;
    int b=100;
    public String toString(){
    return "first:"    +a+"\tsecond:"+b;
    }
}
class bean0{
    int a=10;
    int b=100;
    
}
class bean1 extends java.util.HashMap{
     int a=10;
     int b=100;
    
}
class bean2 implements java.util.Map{
     int a=10;
     int b=100;
    @Override
    public int size() {
        // TODO 自动生成的方法存根
        return 0;
    }
    @Override
    public boolean isEmpty() {
        // TODO 自动生成的方法存根
        return false;
    }
    @Override
    public boolean containsKey(Object key) {
        // TODO 自动生成的方法存根
        return false;
    }
    @Override
    public boolean containsValue(Object value) {
        // TODO 自动生成的方法存根
        return false;
    }
    @Override
    public Object get(Object key) {
        // TODO 自动生成的方法存根
        return null;
    }
    @Override
    public Object put(Object key, Object value) {
        // TODO 自动生成的方法存根
        return null;
    }
    @Override
    public Object remove(Object key) {
        // TODO 自动生成的方法存根
        return null;
    }
    @Override
    public void putAll(Map m) {
        // TODO 自动生成的方法存根
        
    }
    @Override
    public void clear() {
        // TODO 自动生成的方法存根
        
    }
    @Override
    public Set keySet() {
        // TODO 自动生成的方法存根
        return null;
    }
    @Override
    public Collection values() {
        // TODO 自动生成的方法存根
        return null;
    }
    @Override
    public Set entrySet() {
        // TODO 自动生成的方法存根
        return null;
    }
    
}
class test<T> implements d{    }
public class FanXing {
    public static void main(String[] args) {
HashMap<String,String> hm=new HashMap<String, String>();
//Map<String,String> m=new Map<String, String>();  不能实例化类型Map,List,Set,这些是接口，具体查看api
Map<String,String> m=new HashMap<String, String>();
ArrayList<String> al=new ArrayList<String>();
List<String> l=new ArrayList<String>();
HashSet<String> hs=new HashSet<String>();
Set<String> s=new HashSet<String>();
test<String> t=new test<String>();//List与ArrayList关系类似d与test
d<String> d=new test<String>();
Vector<String> v=new Vector<String>();
List<String> list=new Vector<String>();
hm.put("hm1", "1");
hm.put("hm2", "2");
//hm.put("hm2", "3");
m.put("m1", "1");
m.put("m2", "2");
//m.put("m2", "3");
al.add("al1");
al.add("al2");
al.add("al2");
l.add("l1");
l.add("l2");
l.add("l2");
hs.add("hs1");
hs.add("hs2");
hs.add("hs2");
s.add("s1");
s.add("s2");
s.add("s2");
v.add("v");
v.add("v1");
list.add("list");
list.add("list1");
System.out.println(hm);
System.out.println(m);//顺序是倒序，向上转型同名父方法应该被重写的，猜测是tostring()不同,hashmap重写了tostring()
System.out.println(al);
System.out.println(l);
System.out.println(hs);//顺序是倒序
System.out.println(s);//顺序是倒序
System.out.println(v);
System.out.println(list);//实现Collection接口的都是数组结构，实现map接口的是a=value的键值对类型
StringBuffer sb = new StringBuffer();
sb.append(hm);

sb.append("\n"+m);
bean be=new bean();

sb.append("\n"+be);//说明StringBuffer是调用tostring来完成的
//不知道怎么证明tostring了（*'.'*）
bean0 be0=new bean0();
bean1 be1=new bean1();
bean2 be2=new bean2();
sb.append("\n"+be0);//正常的返回
sb.append("\n"+be1);//可以看出是hashmap重写了tostring()
sb.append("\n"+be2);//正常的返回
System.out.println(sb);
/*Collection
  ├List
  │├LinkedList
  │├ArrayList
  │└Vector
  │　└Stack
  └Set
   ├TreeSet
   └HashSet
  Map
  ├Hashtable
  ├HashMap
  └WeakHashMap
  一些常用的
*/
    }

}

输出：

{hm2=2, hm1=1}
{m1=1, m2=2}
[al1, al2, al2]
[l1, l2, l2]
[hs2, hs1]
[s2, s1]
[v, v1]
[list, list1]
{hm2=2, hm1=1}
{m1=1, m2=2}
first:10    second:100
fanxing.bean0@324f0f97
{}
fanxing.bean2@64889c4e

总结就是注释里的，只写了部分类

Collection
  ├List
  │├LinkedList
  │├ArrayList
  │└Vector
  │　└Stack
  └Set
   ├TreeSet
   └HashSet
  Map
  ├Hashtable
  ├HashMap
  └WeakHashMap

其中实现Collection接口的都是数组结构，实现map接口的是a=value的键值对类型

顺序不同应该是重写ToString()的原因

下面是反射的特殊使用

public class test1<T extends List>//限制泛型类类型

public class test2<? >//类型通配符

public class test3<? extends List>//类型通配符+限制

使用通配符的对象，例如List<?> list

只能获取或删除，不能加入新的信息