泛型（Genrics）
所谓泛型就是变量类型的参数化
泛型是JDK1.5中一个最重要的特征。通过引入泛型，我们将获得编译时类型的安全和运行时更小地抛出ClassCastExceptons的可能。
在jdk1.5中，你可以声明一个集合将接收/返回的对象的类型。
泛型的ArrayList
|
public class GenericTest1 { public static void main(String[] args) { List<String> list = new ArrayList<String>(); list.add("aaa"); list.add("bbb"); list.add("ccc"); list.add("ddd"); for(Iterator<String> iter =
list.iterator(); iter.hasNext();) { String val = iter.next(); System.out.println(val); } } } |
泛型的LinkedList
|
public class GenericTest2 { public static void main(String[] args) { List<String> list = new
LinkedList<String>(); list.add("aaa"); list.add("bbb"); list.add("ccc"); list.add("ddd"); for(Iterator<String> iter =
list.iterator(); iter.hasNext();) { String val = iter.next(); System.out.println(val); } } } |
泛型的HashSet
|
public class GenericTest3 { public static void main(String[] args) { Set<String> set = new
HashSet<String>(); set.add("aaa"); set.add("bbb"); set.add("ccc"); set.add("ddd"); for(Iterator<String> iter =
set.iterator(); iter.hasNext();) { String val = iter.next(); System.out.println(val); } } } |
泛型的HashMap
|
public class GenericTest4 { public static void main(String[] args) { Map<String,String> map = new
HashMap<String,String>(); map.put("a","aaa"); map.put("b","bbb"); map.put("c","ccc"); map.put("d","ddd"); Set<String> set = map.keySet(); for(Iterator<String> iter =
set.iterator(); iter.hasNext();) { String key = iter.next(); String val = map.get(key); System.out.println(key + ":" + val); } System.out.println("-----------------------"); Set<Map.Entry<String,String>>
set2 = map.entrySet(); for(Iterator<Map.Entry<String,String>>
iter = set2.iterator(); iter.hasNext();) { Map.Entry<String,String>
entry = iter.next(); String key = entry.getKey(); String val = entry.getValue(); System.out.println(key + ":" + val); } } } |
如果使用泛型，只要代码在编译时没有出现警告，就不会遇到ClassCastException
自定义一个简单的泛型类
|
public class GenericTest { public static void main(String[] args) { Foo<Integer> f1 = new
Foo<Integer>(); Foo<Boolean> f2 = new
Foo<Boolean>(); f1.setFoo(new Integer(3)); f2.setFoo(new Boolean(true)); System.out.println(f1.getFoo()); System.out.println(f2.getFoo()); } } class Foo<T> { private T foo; public T getFoo() { return foo; } public void setFoo(T foo) { this.foo = foo; } } |
两个泛型参数的使用和一个参数的使用类似。
|
public class GenericTest2 { public static void main(String[] args) { FooTest<Integer,Boolean> foo = new
FooTest<Integer, Boolean>(); foo.setFoo1(new Integer(3)); foo.setFoo2(new Boolean(false)); System.out.println(foo.getFoo1()); System.out.println(foo.getFoo2()); } } class FooTest<T,K> { private T foo1; private K foo2; public T getFoo1() { return foo1; } public void setFoo1(T foo1) { this.foo1 = foo1; } public K getFoo2() { return foo2; } public void setFoo2(K foo2) { this.foo2 = foo2; } } |
泛型数组
|
public class Generic3<T> { private T[] foo; public T[] getFoo() { return foo; } public void setFoo(T[] foo) { this.foo = foo; } public static void main(String[] args) { Generic3<String> arr = new
Generic3<String>(); String[] str1 = {"hello","world","welcome"}; String[] str2 = null; arr.setFoo(str1); str2 = arr.getFoo(); for(String s : str2) { System.out.println(s); } } } |
用泛型定义一个简单的集合
|
@SuppressWarnings("unchecked") public class SimpleCollection<T> { private T[] arr; private int index = 0; public SimpleCollection() { arr = (T[]) new Object[10]; } public SimpleCollection(int capacity) { arr = (T[]) new Object[capacity]; } public void add(T t) { arr[index++] = t; } public int getLength() { return this.index; } public T get(int i) { return arr[i]; } public static void main(String[] args) { SimpleCollection<Integer> col = new
SimpleCollection<Integer>(); for (int i = 0; i < 10; i++) { col.add(new Integer(i)); } for (int i = 0; i < col.getLength(); i++) { System.out.println(col.get(i)); } } } |
将一个泛型对象组合到另一个类中
|
public class GenericFoo<T> { private Generic<T> warpper; public Generic<T>
getWarpper() { return warpper; } public void setWarpper(Generic<T>
warpper) { this.warpper = warpper; } public static void main(String[] args) { Generic<Integer> g1 = new
Generic<Integer>(); g1.setFoo(new Integer(20)); GenericFoo<Integer> gf = new
GenericFoo<Integer>(); gf.setWarpper(g1); Generic<Integer> g2 =
gf.getWarpper(); System.out.println(g2.getFoo()); } } class Generic<T> { private T foo; public T getFoo() { return foo; } public void setFoo(T foo) { this.foo = foo; } } |
在泛型集合中使用自定义类
|
public class Generic2 { public static void main(String[] args) { List<Person> list = new
ArrayList<Person>(); list.add(new Person("bob",20,"us")); list.add(new Person("jack",23," list.add(new Person("Mike",25,"cn")); for(Iterator<Person> iter =
list.iterator(); iter.hasNext();) { Person p = iter.next(); System.out.println(p); } } } class Person { private String name; private int age; private String address; public Person(String name, int age, String
address) { super(); this.name = name; this.age = age; this.address = address; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((address == null) ? 0 : address.hashCode()); result = prime * result + age; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Person other = (Person) obj; if (address == null) { if (other.address != null) return false; } else if (!address.equals(other.address)) return false; if (age != other.age) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } @Override public String toString() { return name + ", " + age + ", " + address; } } |
限制泛型的可用类型
在定义泛型类别时，预设可以使用任何的类型来实例泛型类型中的类型。
但是如果想要限制使用泛型类别时，只能用某个特定类型或者是其子类型才能实例化该类型时，可以在定义类型时，使用extends关键字指定这个类型必须是继承某个类，或者实现某个接口。
|
public class ListGeneric<T extends List> { private T[] objArr; public T[] getObjArr() { return objArr; } public void setObjArr(T[] objArr) { this.objArr = objArr; } public static void main(String[] args) { ListGeneric<ArrayList>
listGeneric1 = new ListGeneric<ArrayList>(); ListGeneric<LinkedList>
listGeneric2 = new ListGeneric<LinkedList>(); ArrayList[] arrList = new ArrayList[3]; listGeneric1.setObjArr(arrList); LinkedList[] linkList = new LinkedList[3]; listGeneric2.setObjArr(linkList); } } |
当没有指定泛型继承的类型或接口时，默认使用T extends Object ,所在默认情况下任何类型都可以作为参数传入。
如果想要在使用时对泛型类型进行约束，可以使用通配说明<? extends List>
|
public class GenericTest7s { public static void main(String[] args) { //把GenericTest的泛型参数类型限定为指定的类 或接口 GenericTest<? extends List>
list = null; list = new GenericTest<ArrayList>(); list = new GenericTest<LinkedList>(); //把GenericTest的泛型参数类型限定为List的基类。 GenericTest<? super List> list2= null; list2 = new GenericTest<Object>(); GenericTest<String> list3 = new
GenericTest<String>(); list3.setList("Hello"); //GenericTest<?>相当于GenericTest<? extends Object> GenericTest<?> list4 = list3; System.out.println(list4.getList()); //这行会报错，因为list4的参数类型是Object类型的，用其他类型时要强制类型转换。 //违背了使用泛型的初衷。 //list4.setList("World"); } } class GenericTest<T> { private T list; public T getList() { return list; } public void setList(T list) { this.list = list; } } |
使用<?>或是<? extends SomeClass>的声明方式，意味着你只能通过该名称来取得所参考实例的信息，或者是移除某些信息，但不能增加它的信息，因为只知道当中放置的是SomeClass的子类，但不能确定是什么类型的实例，编译器不让你加入信息，理由是，如果可以加入信息的话，那么你就得记得取回的实例是什么类型的，然后再去转换为原来的类型方可进行操作，这样就失去了泛型的意义 。
|
public class GenericTest { public static void main(String[] args) { Foo<? extends Object> f3 = new
Foo<String>(); f3.setFoo(null); //编译器会报错，因为你可以插入成功的话，那么取出来时就要进行强制类型转换，这样做就失去了泛型的意义。 f3.setFoo("hello"); } } class Foo<T> { private T foo; public T getFoo() { return foo; } public void setFoo(T foo) { this.foo = foo; } } |
<? super List> 表示泛型类型是List的基类，一般很少用。
List<? extends Object > 通常简写为List<?>
泛型的继承
|
class Parent<T, K> { private T foo1; private K foo2; public T getFoo1() { return foo1; } public void setFoo1(T foo1) { this.foo1 = foo1; } public K getFoo2() { return foo2; } public void setFoo2(K foo2) { this.foo2 = foo2; } } class Child<T, K, V> extends Parent<T, K> { private V foo3; public V getFoo3() { return foo3; } public void setFoo3(V foo3) { this.foo3 = foo3; } } |
实现泛型的接口
|
interface Father<K,V> { public void setKey(K key); public void setValue(V value); } class SubClass<K,V> implements
Father<K,V> { private K key; private V value; @Override public void setKey(K key) { this.key = key; } @Override public void setValue(V value) { this.value = value; } } |
增强for循环
|
public class ForTest { public static void main(String[] args) { int[] arr = {1,2,3,4,5,6}; for(int i : arr) { System.out.println(i); } System.out.println("----------------------"); ArrayList<String> list = new
ArrayList<String>(); list.add("aaa"); list.add("bbb"); list.add("ccc"); for(String str : list) { System.out.println(str); } System.out.println("----------------------"); int[][] arr2 = {{1,2,3},{4,5,6},{7,8,9}}; for(int[] a : arr2) { for(int i : a) { System.out.println(i); } } } } |
统计命令行中单词出现的次数
|
public class Frequency { public static void main(String[] args) { Map<String,Integer> map = new
HashMap<String,Integer>(); for(String word : args) { Integer times = map.get(word); map.put( word, (null == times) ? 1 :
(times + 1)); } System.out.println(map); } } |
自动装箱和拆箱
自动装箱：基本类型自动转为包装类：int --> Integer
自动拆箱：包装类自动转为基本类型：Integer --> int
|
public class AutoBoxingAndUnboxing { public static void main(String[] args) { int i = 3; ArrayList<Integer> list = new
ArrayList<Integer>(); list.add(i); list.add(i+3); for(int ele : list) { System.out.println(ele); } } } |
|
public class AutoBoxingTest { public static void main(String[] args) { Map<String,Integer> map = new
HashMap<String,Integer>(); for(String str : args) { if(map.containsKey(str)) { int val = map.get(str); map.put(str,(val+1)); } else { map.put(str,1); } } Set<Map.Entry<String,Integer>>
set = map.entrySet(); for(Map.Entry<String,Integer> entry :
set) { String key = entry.getKey(); int val = entry.getValue(); System.out.println(key + ":" + val); } } } |
Integer类有一个缓存，它会缓存介于-128到127之间的整数
|
public class IntCache { public static void main(String[] args) { Integer a = 100; Integer b = 100; System.out.println(a == b);//true a = 200; b = 200; System.out.println(a == b);//false } } |
可变参数
可变参数使程序员可以声明一个接受可变数目参数的方法。
注意：可变参数必须是方法声明中的最后一个参数。
|
public class TestVarArgs { //当有多个参数时， int... args必须是参数表中的最后一个 static void sum(int... args) { int sum = 0; for(int i : args) { sum += i; } System.out.println(sum); } public static void main(String[] args) { //相当于C#中的params int[]. sum(1,2); sum(1,2,3,4,5); sum(new int[]{1,2,3}); } } |
枚举
枚举在某种层次上相当于类，和类或接口处于同一级别之上，通常只是用枚举来定义一些常量。
|
public enum Color { Red, Blue, Green } public class ColorTest { public static void main(String[] args) { Color color = Color.Red; System.out.println(color); System.out.println(); for(Color col : Color.values()) { System.out.println(col); } } } |
|
public class EnumTest { public static void doOperator(OpConst opConst) { switch(opConst) { case TURN_LEFT: System.out.println("向左转"); break; case TURN_RIGHT: System.out.println("向右转"); break; case SHOOT: System.out.println("射击"); break; } } public static void main(String[] args) { doOperator(OpConst.TURN_LEFT); doOperator(OpConst.TURN_RIGHT); doOperator(OpConst.SHOOT); } } enum OpConst { TURN_LEFT, TURN_RIGHT, SHOOT } |
定义枚举类型时，本质上就是在定义一个类别，只不过很多细节由编译器帮你完成了，所以某种程序上,enum关键字的作用就是class或interface.
|
public enum Coin { //枚举的实例，默认都是public static final的 Penny("Hello"),Dime("World"),Chome("welcome"); //枚举的属性 private String value; //枚举的方法，可以被每个实例成员调用 public String getValue() { return this.value; } //枚举的构造函数 private Coin(String value) { this.value = value; } public static void main(String[] args) { Coin coin = Coin.Chome; System.out.println(coin.getValue()); } } |
|
|
我们所定义的每个枚举类型都继承自java.lang.Enum类，枚举中的每个成员默认都是public static final的。
每个枚举的成员其实就是你定义的枚举类型的实例。
EnumSet集合的使用
|
public class EnumTest4 { public static void main(String[] args) { //把指定的枚举实例添加到集合中 EnumSet<FontConst> enumSet =
EnumSet.of(FontConst.Normal, FontConst.Bold); showEnumTest(enumSet); System.out.println("-----------------"); // complementOf方法，用于获得指定集合中不包含的成员 showEnumTest(EnumSet.complementOf(enumSet)); System.out.println("-----------------"); // noneOf表示用FontConst类型创建一个空的集合 enumSet = EnumSet.noneOf(FontConst.class); enumSet.add(FontConst.Normal); enumSet.add(FontConst.Bold); showEnumTest(enumSet); } public static void
showEnumTest(EnumSet<FontConst> enumSet) { for(Iterator<FontConst> iter =
enumSet.iterator(); iter.hasNext();) { System.out.println(iter.next()); } } } enum FontConst { } |
|
|
枚举集合的拷贝
|
public class EnumSetTest { public static void main(String[] args) { ArrayList<FontConst> list = new
ArrayList<FontConst>(); list.add(FontConst.Normal); list.add(FontConst.Bold); list.add(FontConst.Italilc); //把指定的列表集合拷贝到枚举集合中去 showEnumTest(EnumSet.copyOf(list)); } public static void
showEnumTest(EnumSet<FontConst> enumSet) { for(Iterator<FontConst> iter =
enumSet.iterator(); iter.hasNext();) { System.out.println(iter.next()); } } } |
EnumMap的使用
|
public class EnumMapTest { public static void main(String[] args) { Map<Action,String> map = new
EnumMap<Action,String>(Action.class); map.put(Action.TURN_RIGHT,"向右转"); map.put(Action.SHOOT,"射击"); map.put(Action.TURN_LEFT,"向左转"); Set<Action> set = map.keySet(); for(Action key : set) { System.out.println(map.get(key)); } } } enum Action { TURN_LEFT,TURN_RIGHT,SHOOT; } |
一个使用枚举较为合适的场景
|
public class AccessControl { public static void main(String[] args) { AccessRight right = AccessRight.valueOf("MANAGE"); System.out.println(checkRight(right)); } public static Boolean checkRight(AccessRight
right) { if(right == AccessRight.MANAGE) { return true; } return false; } } enum AccessRight { MANAGE,DEPARTMENT,EMPLOYEE; } |
静态导入
在另一个包中如下这个类
|
package com.anllin.common; public class Common { public static final int AGE = 10; public static void output() { System.out.println(AGE); } } |
在当前包中，静态导入后可以象使用内部类成员一样访问common类的AGE常量。
虽然在一定程度上带来了便利，但会降低程序的可读性。
|
package com.anllin.jdk5; import static com.anllin.common.Common.AGE; import static com.anllin.common.Common.output; public class StaticImportTest { public static void main(String[] args) { int age = AGE; output(); } } |