- 浏览: 3368985 次
- 性别:
- 来自: 珠海
文章分类
- 全部博客 (1633)
- Java (250)
- Android&HTML5 (111)
- Struts (10)
- Spring (236)
- Hibernate&MyBatis (115)
- SSH (49)
- jQuery插件收集 (55)
- Javascript (145)
- PHP (77)
- REST&WebService (18)
- BIRT (27)
- .NET (7)
- Database (105)
- 设计模式 (16)
- 自动化和测试 (19)
- Maven&Ant (43)
- 工作流 (36)
- 开源应用 (156)
- 其他 (16)
- 前台&美工 (119)
- 工作积累 (0)
- OS&Docker (83)
- Python&爬虫 (28)
- 工具软件 (157)
- 问题收集 (61)
- OFbiz (6)
- noSQL (12)
最新评论
-
HEZR曾嶸:
你好博主,这个不是很理解,能解释一下嘛//左边+1,上边+1, ...
java 两字符串相似度计算算法 -
天使建站:
写得不错,可以看这里,和这里的这篇文章一起看,有 ...
jquery 遍历对象、数组、集合 -
xue88ming:
很有用,谢谢
@PathVariable映射出现错误: Name for argument type -
jnjeC:
厉害,困扰了我很久
MyBatis排序时使用order by 动态参数时需要注意,用$而不是# -
TopLongMan:
非常好,很实用啊。。
PostgreSQL递归查询实现树状结构查询
Java高质量代码系列文章
泛型与反射 http://ray-yui.iteye.com/blog/1933127
面向对象篇:http://ray-yui.iteye.com/blog/1926984
数据类型篇:http://ray-yui.iteye.com/blog/1927251
字符串篇:http://ray-yui.iteye.com/blog/1927647
数组与集合(1):http://ray-yui.iteye.com/blog/1928170
数组与集合(2):http://ray-yui.iteye.com/blog/1930155
枚举与注解:http://ray-yui.iteye.com/blog/1931408
泛型与发射:http://ray-yui.iteye.com/blog/1933127
异常:http://ray-yui.iteye.com/blog/1938946
杂:http://ray-yui.iteye.com/blog/1942591
Java泛型拾遗 http://my.oschina.net/scipio/blog/298717
1、泛型编程
实际使用的类型在代码中只是以参数形式出现的占位符(称为形式类型参数),在具体实例化时,用实际类型替代其中的类型占位符(参数化类型),这种方式被称为泛型编程。
可以阻止向一个集合类的对象中添加不正确类型的对象,也可以提升抽象层度,减少不同类型的重复代码。
2、参数化类型
(1)不带通配符的类型
比如ObjectHolder<String>
(2)带通配符的类型
有界通配符:T extends Comparable<T> & Serializable,多个用&连接,没有指定上界时默认是Object,没有下界直说。
无界通配符:ObjectHolder<?>
3、形式参数类型
不能用来创建对象和数组、不能作为父类、不能使用instanceof表达式、不能使用其类型字面量、不能出现在异常处理中、不能出现在静态上下文中。
new T(),new T[],class MyClass extends T,instanceof T,T.class,catch(T),static T等这些都是不允许的。
4、类型擦除
泛型是在编译器这个层次实现的,在编译过程中会被擦除(包括泛型类型,泛型方法声明时的形式类型参数,以及实际类型参数),字节码不知道泛型,但为了反射API的需要,保留了相关信息,但这些信息在字节码执行时不被使用。
类型擦除后如下:
同一泛型类型的所有实例化形式在运行时的表示形式是相同的,比如List<String>和List<Integer>对虚拟机来说是相同的,都是List接口,无法通过List<String>.class形式来获取参数化类型的类对象的字面量,只能使用List.class,另外运行时不存在List<String>类型,只有List类型。
5、通配符
通配符的含义是一组类型的集合。用?表示,分有界和无界两种。
无界通配符用?表示,有界通配符如? extends/super
通配符一般做引用类型,比如返回Class<?>
6、数组允许协变
数组是由Java虚拟机根据类型创建出来的,如果一个数组的元素类型是另一个数组元素类型的子类型,则这个数组的类型也是对应数组类型的子类型。
比如String[]是Object[]的子类型。其中的原因是数组的元素类型信息在运行时仍然是被保留的。
变参通过数组传递:
7、类型系统
ArrayList<Number>是List<Number>的子类型
ArrayList<Number>与ArrayList<Integer>不存在父子类型关系
List<?>是所有List泛型类的实例化形式的父类型,比如List<String>,List<? extends Number>,List<? super Integer>等
? extends Integer 是 ? extends Number的子类型
List<? extends Integer>是List<? extends Number>的子类型
? super Number是? super Integer的子类型
List<? super Number>是List<? super Integer>的子类型
一个泛型的所有实例化形式是其对应的原始类型的子类型,比如List<String>和List<? extends Number>是List的子类型
8、覆写和重载
(1)覆写
包括方法类型签名(方法名称、参数类型)、返回值类型、异常抛出的类型。
A、要求方法参数类型是相同的或者父类类型擦除之后与子类参数类型是相同的。
B、子类型中的返回值类型必须可以替代父类型中对应方法的返回值类型。
C、子类型的方法声明中不能抛出父类型中对应方法没有声明的受检异常。
(2)重载
重载只考虑方法的类型签名,不考虑返回值类型和声明的受检异常。
9、类型推断和<>操作符
可以通过两种方式类判断所使用的实际类型:显示指定类型、编译器根据上下文信息进行推断
(1)显示指定类型
(2)类型推断
一般不需要显示指定类型,编译器可根据上下文进行推断
A、根据方法调用时的实际参数的静态类型进行推断(优先级较高)
B、当方法调用的结果被赋值给另外一个变量时,可以根据该变量的静态类型进行推断
10、泛型与反射API
JDK5对Java字节码的格式进行了修改,把泛型相关的信息添加到字节码中,不过字节码中的泛型相关内容只是提供相关信息,不会对字节码的运行造成影响,可以使用反射API获取。
全面总结Java泛型 http://www.cnblogs.com/rickie4you/p/3488551.html
本文对Java泛型进行了全面的总结。文章内容包括普通泛型、通配符、受限泛型、泛型接口、泛型方法、返回泛型类型实例等等。
虽然Scala创始人Martin Odersky说当年正是因为Java泛型的丑陋,所以才想到要创建一个新的语言,不过这仍然不妨碍我们学习Java泛型。毕竟即使听说Java泛型不好用,但好不好用还是得会用了才知道。下面是一些有关Java泛型的总结:
普通泛型
----------------------------------------------------------
通配符
受限泛型
----------------------------------------------------------
Java泛型无法向上转型
Java泛型接口
----------------------------------------------------------
Java泛型方法
通过泛型方法返回泛型类型实例
使用泛型统一传入的参数类型
Java泛型数组
Java泛型的嵌套设置
JAVA 泛型接口和泛型方法 http://wwwiteye.iteye.com/blog/1849917
接口:如果一个类或接口上有一个或多个类型变量,那它就是泛型。类型变量由尖括号界定,放在类或接口名的后面
方法:如果方法和构造器上声明了一个或多个类型变量,它们也可以泛型化。
泛型与反射 http://ray-yui.iteye.com/blog/1933127
面向对象篇:http://ray-yui.iteye.com/blog/1926984
数据类型篇:http://ray-yui.iteye.com/blog/1927251
字符串篇:http://ray-yui.iteye.com/blog/1927647
数组与集合(1):http://ray-yui.iteye.com/blog/1928170
数组与集合(2):http://ray-yui.iteye.com/blog/1930155
枚举与注解:http://ray-yui.iteye.com/blog/1931408
泛型与发射:http://ray-yui.iteye.com/blog/1933127
异常:http://ray-yui.iteye.com/blog/1938946
杂:http://ray-yui.iteye.com/blog/1942591
Java泛型拾遗 http://my.oschina.net/scipio/blog/298717
1、泛型编程
实际使用的类型在代码中只是以参数形式出现的占位符(称为形式类型参数),在具体实例化时,用实际类型替代其中的类型占位符(参数化类型),这种方式被称为泛型编程。
可以阻止向一个集合类的对象中添加不正确类型的对象,也可以提升抽象层度,减少不同类型的重复代码。
public class ObjectHolder<T> { private T obj; public T getObject() { return obj; } public void setObject(T obj) { this.obj = obj; } public static void main(String[] args){ ObjectHolder<String> holder = new ObjectHolder<String>(); holder.setObject("Hello"); String str = holder.getObject(); } }
2、参数化类型
(1)不带通配符的类型
比如ObjectHolder<String>
(2)带通配符的类型
有界通配符:T extends Comparable<T> & Serializable,多个用&连接,没有指定上界时默认是Object,没有下界直说。
无界通配符:ObjectHolder<?>
3、形式参数类型
不能用来创建对象和数组、不能作为父类、不能使用instanceof表达式、不能使用其类型字面量、不能出现在异常处理中、不能出现在静态上下文中。
new T(),new T[],class MyClass extends T,instanceof T,T.class,catch(T),static T等这些都是不允许的。
4、类型擦除
泛型是在编译器这个层次实现的,在编译过程中会被擦除(包括泛型类型,泛型方法声明时的形式类型参数,以及实际类型参数),字节码不知道泛型,但为了反射API的需要,保留了相关信息,但这些信息在字节码执行时不被使用。
类型擦除后如下:
public class ObjectHolder { private Object obj; public Object getObject() { return obj; } public void setObject(Object obj) { this.obj = obj; } }
同一泛型类型的所有实例化形式在运行时的表示形式是相同的,比如List<String>和List<Integer>对虚拟机来说是相同的,都是List接口,无法通过List<String>.class形式来获取参数化类型的类对象的字面量,只能使用List.class,另外运行时不存在List<String>类型,只有List类型。
5、通配符
通配符的含义是一组类型的集合。用?表示,分有界和无界两种。
无界通配符用?表示,有界通配符如? extends/super
通配符一般做引用类型,比如返回Class<?>
Class<?> clazz = Class.forName(className);
6、数组允许协变
数组是由Java虚拟机根据类型创建出来的,如果一个数组的元素类型是另一个数组元素类型的子类型,则这个数组的类型也是对应数组类型的子类型。
比如String[]是Object[]的子类型。其中的原因是数组的元素类型信息在运行时仍然是被保留的。
变参通过数组传递:
public void varargsMethod(List<String>... values) { Object[] array = values; List<Integer> list = (List<Integer>) array[0]; list.add(1); }
7、类型系统
ArrayList<Number>是List<Number>的子类型
ArrayList<Number>与ArrayList<Integer>不存在父子类型关系
List<?>是所有List泛型类的实例化形式的父类型,比如List<String>,List<? extends Number>,List<? super Integer>等
? extends Integer 是 ? extends Number的子类型
List<? extends Integer>是List<? extends Number>的子类型
? super Number是? super Integer的子类型
List<? super Number>是List<? super Integer>的子类型
一个泛型的所有实例化形式是其对应的原始类型的子类型,比如List<String>和List<? extends Number>是List的子类型
8、覆写和重载
(1)覆写
包括方法类型签名(方法名称、参数类型)、返回值类型、异常抛出的类型。
A、要求方法参数类型是相同的或者父类类型擦除之后与子类参数类型是相同的。
B、子类型中的返回值类型必须可以替代父类型中对应方法的返回值类型。
C、子类型的方法声明中不能抛出父类型中对应方法没有声明的受检异常。
(2)重载
重载只考虑方法的类型签名,不考虑返回值类型和声明的受检异常。
9、类型推断和<>操作符
可以通过两种方式类判断所使用的实际类型:显示指定类型、编译器根据上下文信息进行推断
(1)显示指定类型
public class TypeInference { public <T> T method(T obj) { return obj; } public static void main(String[] args){ TypeInference typeInference = new TypeInference(); typeInference.<Serializable>method("Hello"); } }
(2)类型推断
一般不需要显示指定类型,编译器可根据上下文进行推断
A、根据方法调用时的实际参数的静态类型进行推断(优先级较高)
B、当方法调用的结果被赋值给另外一个变量时,可以根据该变量的静态类型进行推断
public class TypeInference { public <T> T method(T obj) { return obj; } public static void main(String[] args){ TypeInference typeInference = new TypeInference(); //根据参数静态类型推断 typeInference.method("Hello"); //通过引用类型进行推断 List<Integer> list2 = typeInference.createList(); List<String> list = new ArrayList<>(); } }
10、泛型与反射API
JDK5对Java字节码的格式进行了修改,把泛型相关的信息添加到字节码中,不过字节码中的泛型相关内容只是提供相关信息,不会对字节码的运行造成影响,可以使用反射API获取。
public class GenericReflection { public void reflect() throws Exception { Class<?> clazz = Target.class; Method method = clazz.getMethod("create", new Class<?>[] {Object.class}); //参数类型 Type paramType = method.getGenericParameterTypes()[0]; TypeVariable<?> typeVariable = (TypeVariable<?>) paramType; System.out.println("parameter type:"+typeVariable.getName()); //值为 T //返回值类型 Type returnType = method.getGenericReturnType(); ParameterizedType pType = (ParameterizedType) returnType; //返回值实际类型 Type actualType = pType.getActualTypeArguments()[0]; System.out.println("actual return type:"+actualType); //使用通配符情况 Type[] bounds = ((WildcardType) actualType).getUpperBounds(); ParameterizedType boundType = (ParameterizedType) bounds[0]; System.out.println("generic raw type:"+boundType.getRawType()); //Comparable接口的Class类对象 } public static void main(String[] args) throws Exception { GenericReflection gf = new GenericReflection(); gf.reflect(); } } class Target <T> { public List<? extends Comparable<T>> create(T obj) { return null; } }
全面总结Java泛型 http://www.cnblogs.com/rickie4you/p/3488551.html
本文对Java泛型进行了全面的总结。文章内容包括普通泛型、通配符、受限泛型、泛型接口、泛型方法、返回泛型类型实例等等。
虽然Scala创始人Martin Odersky说当年正是因为Java泛型的丑陋,所以才想到要创建一个新的语言,不过这仍然不妨碍我们学习Java泛型。毕竟即使听说Java泛型不好用,但好不好用还是得会用了才知道。下面是一些有关Java泛型的总结:
普通泛型
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) ; } };
受限泛型
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 GenericsDemo17{ public static void main(String args[]){ Info< Integer> i1 = new Info< Integer>() ; // 声明Integer的泛型对象 Info< Float> i2 = new Info< Float>() ; // 声明Float的泛型对象 i1.setVar(30) ; // 设置整数,自动装箱 i2.setVar(30.1f) ; // 设置小数,自动装箱 fun(i1) ; fun(i2) ; } public static void fun(Info< ? extends Number> temp){ // 只能接收Number及其Number的子类 System.out.print(temp + "、") ; } };
----------------------------------------------------------
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 GenericsDemo21{ public static void main(String args[]){ Info< String> i1 = new Info< String>() ; // 声明String的泛型对象 Info< Object> i2 = new Info< Object>() ; // 声明Object的泛型对象 i1.setVar("hello") ; i2.setVar(new Object()) ; fun(i1) ; fun(i2) ; } public static void fun(Info< ? super String> temp){ // 只能接收String或Object类型的泛型 System.out.print(temp + "、") ; } };
Java泛型无法向上转型
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 GenericsDemo23{ public static void main(String args[]){ Info< String> i1 = new Info< String>() ; // 泛型类型为String Info< Object> i2 = null ; i2 = i1 ; //这句会出错 incompatible types } };
Java泛型接口
interface Info< T>{ // 在接口上定义泛型 public T getVar() ; // 定义抽象方法,抽象方法的返回值就是泛型类型 } class InfoImpl< T> implements Info< T>{ // 定义泛型接口的子类 private T var ; // 定义属性 public InfoImpl(T var){ // 通过构造方法设置属性内容 this.setVar(var) ; } public void setVar(T var){ this.var = var ; } public T getVar(){ return this.var ; } }; public class GenericsDemo24{ public static void main(String arsg[]){ Info< String> i = null; // 声明接口对象 i = new InfoImpl< String>("汤姆") ; // 通过子类实例化对象 System.out.println("内容:" + i.getVar()) ; } };
----------------------------------------------------------
interface Info< T>{ // 在接口上定义泛型 public T getVar() ; // 定义抽象方法,抽象方法的返回值就是泛型类型 } class InfoImpl implements Info< String>{ // 定义泛型接口的子类 private String var ; // 定义属性 public InfoImpl(String var){ // 通过构造方法设置属性内容 this.setVar(var) ; } public void setVar(String var){ this.var = var ; } public String getVar(){ return this.var ; } }; public class GenericsDemo25{ public static void main(String arsg[]){ Info i = null; // 声明接口对象 i = new InfoImpl("汤姆") ; // 通过子类实例化对象 System.out.println("内容:" + i.getVar()) ; } };
Java泛型方法
class Demo{ public < T> T fun(T t){ // 可以接收任意类型的数据 return t ; // 直接把参数返回 } }; public class GenericsDemo26{ public static void main(String args[]){ Demo d = new Demo() ; // 实例化Demo对象 String str = d.fun("汤姆") ; // 传递字符串 int i = d.fun(30) ; // 传递数字,自动装箱 System.out.println(str) ; // 输出内容 System.out.println(i) ; // 输出内容 } };
通过泛型方法返回泛型类型实例
class Info< T extends Number>{ // 指定上限,只能是数字类型 private T var ; // 此类型由外部决定 public T getVar(){ return this.var ; } public void setVar(T var){ this.var = var ; } public String toString(){ // 覆写Object类中的toString()方法 return this.var.toString() ; } }; public class GenericsDemo27{ public static void main(String args[]){ Info< Integer> i = fun(30) ; System.out.println(i.getVar()) ; } public static < T extends Number> Info< T> fun(T param){//方法中传入或返回的泛型类型由调用方法时所设置的参数类型决定 Info< T> temp = new Info< T>() ; // 根据传入的数据类型实例化Info temp.setVar(param) ; // 将传递的内容设置到Info对象的var属性之中 return temp ; // 返回实例化对象 } };
使用泛型统一传入的参数类型
class Info< T>{ // 指定上限,只能是数字类型 private T var ; // 此类型由外部决定 public T getVar(){ return this.var ; } public void setVar(T var){ this.var = var ; } public String toString(){ // 覆写Object类中的toString()方法 return this.var.toString() ; } }; public class GenericsDemo28{ public static void main(String args[]){ Info< String> i1 = new Info< String>() ; Info< String> i2 = new Info< String>() ; i1.setVar("HELLO") ; // 设置内容 i2.setVar("汤姆") ; // 设置内容 add(i1,i2) ; } public static < T> void add(Info< T> i1,Info< T> i2){ System.out.println(i1.getVar() + " " + i2.getVar()) ; } };
Java泛型数组
public class GenericsDemo30{ public static void main(String args[]){ Integer i[] = fun1(1,2,3,4,5,6) ; // 返回泛型数组 fun2(i) ; } public static < T> T[] fun1(T...arg){ // 接收可变参数 return arg ; // 返回泛型数组 } public static < T> void fun2(T param[]){ // 输出 System.out.print("接收泛型数组:") ; for(T t:param){ System.out.print(t + "、") ; } } };
Java泛型的嵌套设置
class Info< T,V>{ // 接收两个泛型类型 private T var ; private V value ; public Info(T var,V value){ this.setVar(var) ; this.setValue(value) ; } public void setVar(T var){ this.var = var ; } public void setValue(V value){ this.value = value ; } public T getVar(){ return this.var ; } public V getValue(){ return this.value ; } }; class Demo< S>{ private S info ; public Demo(S info){ this.setInfo(info) ; } public void setInfo(S info){ this.info = info ; } public S getInfo(){ return this.info ; } }; public class GenericsDemo31{ public static void main(String args[]){ Demo< Info< String,Integer>> d = null ; // 将Info作为Demo的泛型类型 Info< String,Integer> i = null ; // Info指定两个泛型类型 i = new Info< String,Integer>("汤姆",30) ; // 实例化Info对象 d = new Demo< Info< String,Integer>>(i) ; // 在Demo类中设置Info类的对象 System.out.println("内容一:" + d.getInfo().getVar()) ; System.out.println("内容二:" + d.getInfo().getValue()) ; } };
JAVA 泛型接口和泛型方法 http://wwwiteye.iteye.com/blog/1849917
接口:如果一个类或接口上有一个或多个类型变量,那它就是泛型。类型变量由尖括号界定,放在类或接口名的后面
package tik4.generic; public interface Generator<T> { T next(); }
package tik4.generic; public class Fibonacci implements Generator<Integer> { private int count; // 参数类型用Integer,使用int将不能编译 // public int next() { // return 0; // } public Integer next() { return fib(count++); } private int fib(int n) { if (n < 2) return 1; return fib(n - 2) + fib(n - 1); } public static void main(String[] args) { Fibonacci gen = new Fibonacci(); for (int i = 0; i <= 17; i++) System.out.print(gen.next() + " "); } /* * Output: 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 */ }
方法:如果方法和构造器上声明了一个或多个类型变量,它们也可以泛型化。
package tik4.generic; public class GenericMothod { public <T,M,N> void getTType(T t,M m,N n){ /* * 传入int,long ,double等基本类型时,自动打包机制 * 会将基本类型包装成相应的对象 */ System.out.println(t.getClass().getName()); System.out.println(m.getClass().getName()); System.out.println(n.getClass().getName()); } public static void main(String[] args) { //泛型类在创建对象时必须指定参数类型,而泛型方法则不需要在创建对象时指定参数类型T GenericMothod gm = new GenericMothod(); gm.getTType("", 1, 1.0); gm.getTType(1.0F, 'c', gm); }/* *Output: java.lang.String java.lang.Integer java.lang.Double java.lang.Float java.lang.Character tik4.generic.GenericMothod */ }
发表评论
-
Java Comparable和Comparator
2016-06-26 08:52 663http://my.oschina.net/android52 ... -
Java集合框架之fastutil & koloboke
2016-06-23 14:04 2420Java集合框架之fastutil http://rensan ... -
ehcache 分布式支持
2016-06-05 22:26 1061原文 http://my.oschina.net/glenxu ... -
Intellij IDEA插件开发入门
2016-05-26 11:42 2850原文: http://blog.csdn.net/dc_726 ... -
阿里巴巴Druid数据源的配置与使用
2016-05-24 17:42 1503http://my.oschina.net/wjme/blog ... -
mysql中间件研究(Atlas,cobar,TDDL), 分库分表插件
2016-05-09 14:15 3396http://www.guokr.com/blog/47576 ... -
Java集合: Queue和Deque
2016-05-09 09:49 1831Queue http://my.oschina.net/kev ... -
使用gzip优化web应用(filter实现)
2016-05-07 01:45 1005使用gzip优化web应用(filter实现) http:// ... -
Byteman 3.0.5 发布,Java 字节码注入工具
2016-04-23 10:29 1730Byteman 3.0.5 发布,Java 字 ... -
RandomStringUtils的说明和生成随机汉字
2016-04-20 15:21 1324更多参考: http://my.oschina.net/wil ... -
通过IP地址获取地理位置
2016-04-20 15:19 861http://my.oschina.net/githubhty ... -
Java编程中使用正则表达式过滤非数字字符串
2016-04-14 13:51 1679/** * * @param str ... -
非对称加密DH算法,DH代码实现
2016-04-13 11:33 1322RSA算法原理(一)http:// ... -
企业支付宝账号开发接口教程
2016-03-31 14:52 1200企业支付宝账号开发接口教程--JAVA-UTF-8(实际操作- ... -
java double类型数据操作工具类
2016-03-28 17:36 1183http://my.oschina.net/yxwblog/b ... -
double转换到BigDecimal
2016-03-28 17:11 1509BigDecimal b = new BigDecimal(d ... -
Java 生成好看的验证码
2016-03-23 10:52 3314http://www.oschina.net/code/sni ... -
Linux环境安装配置Swftools
2016-03-22 21:01 1059http://tetop.blog.51cto.com/188 ... -
java压缩与解压缩文件
2016-03-20 22:03 1436http://www.oschina.net/code/sni ... -
java图像压缩
2016-03-19 23:20 924http://my.oschina.net/686991/bl ...
相关推荐
JAVA泛型教程(帮你解决学习泛型的苦恼). Java 泛型编程可能会碰到很多问题,本教程可能会对你有帮助哦。
Java泛型简明教程,对java中泛型的讲解较为全面,建议下载查看
Java SE编程入门教程 java泛型(共11页).pptx Java SE编程入门教程 java封装继承多态(共56页).pptx Java SE编程入门教程 java集合(共38页).pptx Java SE编程入门教程 java接口(共21页).pptx Java SE编程入门...
Java 泛型教程
TutorialsPoint Java 泛型教程.epub
本课程为传智播客《张孝祥Java高新技术》视频教程,教程采用的AVI方式发布,所以看起来很流畅,大家可以通过本套视频第一集包中附带的CamPlay.exe(拖入即可)观看和学习。
完整版 Java高级教程 Java语言程序设计 第4章 Java泛型(共10页).ppt 完整版 Java高级教程 Java语言程序设计 第5章 Java反射(共9页).ppt 完整版 Java高级教程 Java语言程序设计 第6章 常用设计模式(共25页).ppt...
Java语言程序设计教程课件第五章泛型和枚举,教程选用清华大学雍俊海编写的Java程序设计教程第三版
Java 反射与泛型教程 资源为视频教程资源 希望对你的 Java 学习有所帮助。
Java泛型和反射机制的理论介绍,出自清华大学的讲义, 不错的一偏教程
Java泛型简明教程 泛型是Java SE 5.0中引入的一项特征,自从这项语言特征出现多年来,我相信,几乎所有的Java程序员不仅听说过,而且使用过它。关于Java泛型的教程,免费的,不免费的,有很多。我遇到的最好的教材有...
无涯教程网(learnfk)整理提供:Java泛型方法使程序可以使用单个方法声明来指定一组相关方法来指定一组相关类型。
java泛型源码Java泛型用法 步骤1 原始类型有问题。 第2步 使用泛型类型。 第三步 车库和车辆。 原始类型。 第四步 首先尝试生成车库。 木星在我的车库里。 第5步 泛型上限。 第6步 TripleGarage 步骤7 试图使用泛型...
下面是那种典型用法: List myIntList = new ArrayList();// 1 myIntList.add(new Integer(0));// 2 Integer x = (Integer) myIntList.iterator().next();// 3 第3 行的类型转换有些烦人。通常情况下,程序员知道一...
Java编程详细教程Java集合与泛型PPT教案学习.pptx
java经典教程-JDK1.5的泛型实现
推荐优质Java课程 疯狂Java语言编程 Java入门到进阶教程 01.Java语言概述(共21页).ppt 推荐优质Java课程 疯狂Java语言编程 Java入门到进阶教程 02.理解结构化程序设计_理解面向对象(共25页).ppt 推荐优质Java...
完整版 Java高级教程 Java语言程序设计 第4章 Java泛型(共10页).ppt 完整版 Java高级教程 Java语言程序设计 第5章 Java反射(共9页).ppt 完整版 Java高级教程 Java语言程序设计 第6章 常用设计模式(共25页).ppt...
完整超详细版 耿祥义 Java大学实用教程(第2版)PPT课件 第05章 继承 接口与泛型 (共104页).ppt 完整超详细版 耿祥义 Java大学实用教程(第2版)PPT课件 第06章 字符串和正则表达式 (共62页).ppt 完整超详细版 ...
完整版 Java高级教程 Java语言程序设计 第4章 Java泛型(共10页).ppt 完整版 Java高级教程 Java语言程序设计 第5章 Java反射(共9页).ppt 完整版 Java高级教程 Java语言程序设计 第6章 常用设计模式(共25页).ppt...