首页 > 代码库 > Java笔记--泛型总结与详解
Java笔记--泛型总结与详解
泛型简介：
在泛型没有出来之前，编写存储对象的数据结构是很不方便的。如果要针对每类型的对象写一个数据结构，
则当需要将其应用到其他对象上时，还需要重写这个数据结构。如果使用了Object类型，编写的数据结构虽然
通用性很好，但是不能保证存入的对象的安全性。
--支持知识共享，转载请标注地址"http://www.cnblogs.com/XHJT/p/3958036.html "——和佑博客园，谢谢~~--
代码实例1：
不用泛型实现栈结构
1.用Object和自定义栈类实现的一个入栈和出栈的小case；
2.理解栈：栈是算法世界中经常要用到的一种数据结构，它可以实现元素的先进后出。常用于实现字符串反转，
· 四则运算等。
package com.xhj.generics.unused;/** * 自定义Stack类 * * @author XIEHEJUN * */public class UsedStack { private Object[] os = new Object[10]; private int index = 0; /** * 将一个元素入栈 * * @param o * 要添加的元素对象 */ public void push(Object o) { if (index != os.length) { os[index++] = o; } } /** * 元素出栈，删除一个元素对象 * * @return 返回出栈的元素对象 */ public Object pop() { if (index != -1) { return os[--index]; } return null; } public boolean isEmty() { if (index == 0) { return true; } else { return false; } } /** * 输出栈中所有元素 */ public String toString() { StringBuffer sb = new StringBuffer(); for (int i = 0; i < os.length; i++) { if (os[i] != null) sb.append(os[i]); } return sb.toString(); } public static void main(String[] args) { UsedStack us = new UsedStack(); System.out.println("===================元素入栈===================="); System.out.println("向栈添加三个元素"); String[] strs = { "您好！", "我叫和佑！", "我喜欢Java！" }; us.push(strs[0]); System.out.println("添加元素后的栈为：" + us); us.push(strs[1]); System.out.println("添加元素后的栈为：" + us); us.push(strs[2]); System.out.println("添加元素后的栈为：" + us); System.out.println("===================元素出栈===================="); for (int i = 0; i < us.os.length; i++) { if (!us.isEmty()) { System.out.println("删除元素"); System.out.println(us.pop()); } else { System.out.println(); } } }}
注：从本实例可以看出：1.要想获取到适当的值，需要对类型进行强制转换，而本实例则通过重定义toString方法实现。
2.在本实例任何类型都可入栈，这意味着若是InputStream等类型入栈，在调用toString方法时将会抛出异常。
如：将上面的代码：us.push(strs[0]);
转换成：us.push(new InputStreamReader(System.in, "xhj"));
将会抛出：Exception in thread "main" java.io.UnsupportedEncodingException: xhj
at sun.nio.cs.StreamDecoder.forInputStreamReader(StreamDecoder.java:52)
at java.io.InputStreamReader.<init>(InputStreamReader.java:83)
at com.xhj.generics.unused.UsedStack.main(UsedStack.java:67)
使用泛型实现栈结构：
1.泛型是Java中的一个重要特性，使用泛型编程可以使代码获得最大的重要。
2.在使用泛型时要指明泛型的具体类型，这样可以避免类型转换。
3.泛型类是一个参数类型可变的类；固泛型参数只能是类类型。
代码实例：
package com.xhj.generics.used;import java.util.LinkedList;/** * 使用泛型实现栈的使用 * * @author XIEHEJUN * * @param <T> */public class UsedStack<T> { private LinkedList<T> list = new LinkedList<T>(); /** * 入栈 向栈添加元素 * * @param */ public void push(T t) { list.addFirst(t); } /** * 出栈 删除元素 * * @return */ public T pop() { return list.removeFirst(); } /** * 判断栈是否为空 * * @return */ public boolean isEmty() { if (list.size() == 0) { return true; } else { return false; } } /** * 重写toString方法 */ public String toString() { StringBuffer sb = new StringBuffer(); for (int i = 0; i < list.size(); i++) { if (list.get(i) != null) sb.append(list.get(i)); } return sb.toString(); } public static void main(String[] args) { UsedStack<String> us = new UsedStack<String>(); System.out.println("===================元素入栈===================="); System.out.println("向栈添加三个元素"); String[] strs = { "您好！", "我叫和佑！", "我喜欢Java！" }; us.push(strs[0]); System.out.println("添加元素后的栈为：" + us); us.push(strs[1]); System.out.println("添加元素后的栈为：" + us); us.push(strs[2]); System.out.println("添加元素后的栈为：" + us); System.out.println("===================元素出栈===================="); for (int i = us.list.size() - 1; i >= 0; i--) { if (!us.isEmty()) { System.out.println("删除元素"); System.out.println(us.pop()); System.out.println("栈中元素还有个数为：" + i); } else { System.out.println("栈内已没有元素"); } } }}
注：泛型可以很好的解决上面出现的那两个问题，他的主要魅力就在于让程序有更好的可读性和安全性。
自定义泛型化数组类：
1.在Java虚拟机中并没有泛型类型的对象，所有有关泛型的信息都被擦除了。这虽然可以避免C++语言
的模版代码膨胀问题，但是也引起了其他问题。如：不能直接创建泛型数组等。
2.Java中的泛型不支持实例化类型变量。
3.通过Java的反射机制创建一个泛型化数组
newInstance(Class<?> componentType,int length)
代码实例：
package com.xhj.generics.used;import java.lang.reflect.Array;/** * 利用Java反射机制泛型化数组 * * @author XIEHEJUN * * @param <T>数组类型 */public class GenericsArray<T> { private T[] array; private int size; /** * 泛型化数组构造函数 * * @param type * 数组类型 * @param size * 数组长度 */ @SuppressWarnings("unchecked") public GenericsArray(Class<T> type, int size) { array = (T[]) Array.newInstance(type, size); this.size = size; } /** * 向泛型化数组添加元素 * * @param index * @param item */ public void put(int index, T item) { if (index >= 0 && index < size) { array[index] = item; } } /** * 根据数组下标获取相应值 * * @param index * @return */ public T get(int index) { if (index >= 0 && index < size) { return array[index]; } return null; } /** * 将泛型化数组打印输出 * * @param t */ public void printService(T[] t) { put(0, t[0]); System.out.println("添加的元素为：" + get(0)); put(1, t[1]); System.out.println("添加的元素为：" + get(1)); put(2, t[2]); System.out.println("添加的元素为：" + get(2)); } public static void main(String[] args) { System.out.println("向泛型化数组添加String元素"); GenericsArray<String> gStrArray = new GenericsArray<String>( String.class, 3); String[] strs = { "您好！", "我叫和佑！", "我喜欢Java！" }; gStrArray.printService(strs); System.out.println("\n向泛型化数组添加Integer元素"); GenericsArray<Integer> gIntArray = new GenericsArray<Integer>( Integer.class, 3); Integer[] arrays = { 10, 52, 32 }; gIntArray.printService(arrays); }}
总结：
Java泛型的局限性
1.不能使用基本类型作为其类型参数；
2.不能抛出或捕获泛型类型的实例、
3.不能直接使用泛型数组、
4.不能实例化类型变量
5.对于某些不足，可以通过Java的反射机制进行弥补。
泛型方法与数据查询
众所周知在使用JDBC查询数据库中数据的时候，返回的结果是ResultSet对象，这种机制，
我们在实际使用过程中是很不方便的。当然Java还提供了Commons DbUtils组件来将ResultSet
转化为Bean列表的方法，但是该在使用的时候是需要根据不同的Bean对象创建不同的查询方法的。
下面我将在此方法基础上使用泛型进行包装，以便提高它的通用性。
在Java中，不仅可以声明泛型类，还可以声明泛型方法：
1.使用<T>格式来表示泛型类型参数，参数个数可多个；
2.类型参数列表要放在访问权限修饰符、static和final之后；
3.类型参数列表要放在返回值类型、方法名称、方法参数之前。
代码实例：
对象实体类
package com.xhj.generics.used.entity;/** * 用户实体类 * * @author XIEHEJUN * */public class User { private String userName; private String userId; private int userAge; private String userAddress; private String gende; private long userTell; public User() { super(); } public User(String userName, String userId, int userAge, String userAddress, String gende, long userTell) { this.userName = userName; this.userId = userId; this.userAge = userAge; this.userAddress = userAddress; this.gende = gende; this.userTell = userTell; } public String getUserName() { return userName; } public void setUserName(String userName) { this.userName = userName; } public String getUserId() { return userId; } public int getUserAge() { return userAge; } public void setUserAge(int userAge) { this.userAge = userAge; } public String getUserAddress() { return userAddress; } public void setUserAddress(String userAddress) { this.userAddress = userAddress; } public String getGende() { return gende; } public void setGende(String gende) { this.gende = gende; } public long getUserTell() { return userTell; } public void setUserTell(long userTell) { this.userTell = userTell; } @Override public String toString() { return "User{" + "\n\tuserId =" +userId+ "\n\tuserName =" + userName + "\n\tuserAge =" + userAge + "\n\tgende =" + gende + "\n\tuserAddress =" + userAddress + "\n\tuserTell =" + userTell + "\n\t}"; }}
泛型数据访问操作类
package com.xhj.generics.used.dao;import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;import java.util.List;import org.apache.commons.dbutils.DbUtils;import org.apache.commons.dbutils.QueryRunner;import org.apache.commons.dbutils.handlers.BeanListHandler;/** * 数据库操作类，定义增删改查等操作方法 * * @author XIEHEJUN * */public class GenericQuery { private static String URL = "jdbc:oracle:thin:@192.168.100.13:1521:SIGMA"; private static String DRIVRR = "ojdbc6"; private static String USER = "PCD_Online_V2"; private static String PASSWORD = "password"; private static Connection con; /** * 获取数据库连接 * * @return */ public static Connection getConnecton() { DbUtils.loadDriver(DRIVRR); try { con = DriverManager.getConnection(URL, USER, PASSWORD); } catch (SQLException e) { System.out.println("连接失败"); } return con; } /** * 查询数据 * * @param sql * SQL语句 * @param type * 实体类类型 * @return */ @SuppressWarnings("unchecked") public static <T> List<T> query(String sql, Class<T> type) { QueryRunner qr = new QueryRunner(); List<T> list = null; try { list = (List<T>) qr.query(getConnecton(), sql, new BeanListHandler( type)); } catch (SQLException e) { System.out.println("SQL语句不正确"); e.printStackTrace(); }finally{ DbUtils.closeQuietly(con); } return list; } /** * 更新数据--增/删/改 */ public static void queryUpdate(String sql) { QueryRunner qr = new QueryRunner(); try { qr.update(getConnecton(), sql); } catch (SQLException e) { e.printStackTrace(); }finally{ DbUtils.closeQuietly(con); } }}
业务操作类
package com.xhj.generics.used.service;import java.util.List;import com.xhj.generics.used.dao.GenericQuery;import com.xhj.generics.used.entity.User;/** * 调用数据库操作方法，对数据进行增删改查等操作 * * @author XIEHEJUN * */public class Service { /** * 插入数据 * * @param user */ public static void update(User user) { String sql = "insert into XHJUSER values(‘" + user.getUserId() + "‘,‘" + user.getUserName() + "‘,‘" + user.getUserAge() + "‘,‘" + user.getGende() + "‘,‘" + user.getUserAddress() + "‘,‘" + user.getUserTell() + "‘)"; GenericQuery.queryUpdate(sql); } /** * 修改数据 * * @param sql */ public static void update(String sql) { GenericQuery.queryUpdate(sql); } /** * 查询数据 * * @param user * @param sql */ public static void select(User user, String sql) { List<User> list = GenericQuery.query(sql, User.class); System.out.println("表中数据有："); for (int i = 0; i < list.size(); i++) { System.out.println(i + "号对象属性值为：" + list.get(i)); } } /** * 删除数据 * * @param user */ public static void delete(String sql) { GenericQuery.queryUpdate(sql); }}
测试类：
package com.xhj.generics.used.main;import com.xhj.generics.used.entity.User;import com.xhj.generics.used.service.Service;/** * 测试类 * * @author XIEHEJUN * */public class Test { public static void main(String[] args) { User user = new User("B", java.util.UUID.randomUUID().toString(), 12, "湖南", "女", 1213344455); Service.update(user); String sql = "select * from XHJUser where username = ‘B‘"; Service.select(user, sql); sql = "update XHJuser set username = ‘D‘ where userid =‘1ab3ee1b-1c52-43d2-8df5-ffefb92c9c5c‘"; Service.update(sql); sql = "delete from XHJuser where username = ‘C‘"; Service.delete(sql); }}
注：泛型类与泛型方法的重要区别
1.在使用泛型类时，需要注意不能将泛型参数类型用于静态域和静态方法中，而对于泛型方法则可以是静态的。
2.这种区别主要是"擦除"产生的。由于在泛型方法中已经指明了参数的具体类型，故即使发生擦除，也不会丢失。
泛型化方法与最小值
1.在Java中除了数值可以比较大小外，任何实现了Comparable接口的类的实例，都可以比较大小。
2.在比较类的对象是，需要限制比较的对象实现Comparable接口即：<T extends Comparable>
3.当泛型参数类型被限制为接口的子类型时，也使用extends关键字。
代码实例：
package com.xhj.generics.used;/** * 利用泛型比较类对象实例大小 * * @author XIEHEJUN * */public class GenericComparable { /** * 比较并获取最小类对象实例 * * @param array * @return */ public static <T extends Comparable<T>> T getMin(T[] array) { if (array.length == 0 || array == null) { return null; } else { T min = array[0]; for (int i = 0; i < array.length; i++) { if (min.compareTo(array[i]) > 0) { min = array[i]; } } return min; } } public static void main(String[] args) { String[] strs = { "您好!我是和佑b，来自和佑博客园", "您好!我是和佑a，来自和佑博客园", "您好!我是和佑c，来自和佑博客园" }; System.out.println("最小的类对象实例为：" + getMin(strs)); }}
注：1.compareTo()方法先是逐步比较ASCII码，若是此时仍无法得出结果，再比较其长度
2.泛型类型参数的限定一般有两种情况：
a.小于某一个"范围"
b.大于某一个"范围"
范围即可以是一个类，也可以是一个接口，还可以是类和接口的组合，对于组合来说，需要将类放在第一位，并且用&分隔。
泛型化接口与最大值
1.在Java中除了可以定义类和方法，还可以定义泛型接口。泛型接口的作用和普通接口一样，只是它的实用性更强。
对于很多具体类型通用的方法，可以将其提取到一个泛型接口中，再编写一个泛型类实现这个接口即可。
2.定义泛型接口和定义泛型类是相似的，直接在接口名称后面加上<T>即可。T就是泛型类型参数，可以是多个。
3.在实现此接口时要注意，实现类的泛型参数和接口的泛型参数要相匹配。
代码实例:
泛型接口
package com.xhj.generics.used.ginterface;/** * 定义一个泛型接口 * * @author XIEHEJUN * */public interface GenericComparableInterface { public <T extends Comparable<T>> T getMax(T[] array);}实现泛型接口package com.xhj.generics.used.ginterface;public class GenericComparableImp implements GenericComparableInterface { @Override public <T extends Comparable<T>> T getMax(T[] array) { if(array==null||array.length==0){ return null; }else{ T max = array[0]; for (int i = 0; i < array.length; i++) { if(max.compareTo(array[i])<0){ max = array[i]; } } return max; } } public static void main(String[] args) { GenericComparableImp gci = new GenericComparableImp(); String[] strs = { "您好!我是和佑b，来自和佑博客园", "您好!我是和佑a，来自和佑博客园", "您好!我是和佑c，来自和佑博客园" }; System.out.println("最小的类对象实例为：" +gci.getMax(strs)); }}
注：泛型接口的应用
一个大型网站的后台往往使用多个数据表，可以将一些公共的操作如数据的增删改以及保存等放在一个泛型的DAO接口中定义，
在针对使用的持久层技术，编写此DAO的实现类，这些对于每一个持久化的对象，直接继承这个实现类，再去实现特有方法即可。
使用通配符增强泛型
1.Java中的数组支持协变类型，即如果方法参数是数组T，而S是T的子类，则方法也可以使用参数S。对于泛型类则没有这个特性。
为了弥补这个不足，Java推出了通配符类型参数。
2.使用通配符"?"可以让泛型在实际应用当中更加的灵活
3.通配符可以利用"extends"关键字来设置取值上限，如：<? extends Number>，参数类型要求继承Number
4.通配符可以设置取值下限，如：<?super Number>，参数类型要求是Number的父类
5.通配符可有多个"界限"，如：实现多个接口，在接口间用&分隔。
代码实例：
package com.xhj.generics.used;import java.util.ArrayList;import java.util.List;/** * 通配符在泛型中作用 * * @author XIEHEJUN * */public class Wildcard { /** * 获取基于Number父类下的list的中间数 * * @param list * @return */ public static Object getMiddle(List<? extends Number> list) { return list.get(list.size() / 2); } /** * 获取任何继承Object的List下的中间值 * * @param list * @return */ public static Object getMiddles(List<? extends Object> list) { return list.get(list.size() / 2); } public static void main(String[] args) { List<Integer> list = new ArrayList<Integer>(); list.add(182); list.add(0115); list.add(8); list.add(502); list.add(233); System.out.println(getMiddle(list).toString()); List<String> liststr = new ArrayList<String>(); liststr.add("您好！"); liststr.add("吃饭了吗！"); liststr.add("美女！"); liststr.add("下午有空吗！"); liststr.add("看电影去吧！"); System.out.println(getMiddles(liststr).toString()); }}
泛型化的折半查找法
1.查找就是在一组给定的数据集合中找出满足条件的数据。
2.折半查找要求数据集合中的元素必须可比较，且各元素按升序或者降序排列：
取集合的中间元素作为比较对象，则：
a.如果给定的值与比较对象相等，则查找成功，并返回中间元素的序号。
b.若大于比较对象，则在中间元素的右半段进行查找
c.若小于比较对象，则在中间元素的左半段进行查找
3.循环执行上述过程，直至查找成功，此时折半查找的平均时间复杂度是log2n
代码实例：
package com.xhj.generics.used;/** * 泛型化折半查找算法 * * @author XIEHEJUN * */public class HalfSearch { /** * 折半查找的实现方法 * * @param key * @param array * @return */ public static <T extends Comparable<? super T>> int search(T key, T[] array) { int low = 0; int high = array.length - 1; int mid = 0; while (low <= high) { mid = (low + high) / 2; if (key.compareTo(array[mid]) == 0) { return mid; } else if (key.compareTo(array[mid]) > 0) { low += 1; } else { high -= 1; } } return -1; } public static void main(String[] args) { Integer[] array = { 12, 3, 8, 45, 26, 68 }; String str = "GFISUDGHUIW"; String[] arraystr = { str, "GYFSGHFUIH", "CD" }; System.out.println("在String数组中‘GFISUDGHUIW‘的索引为：" + search(str, arraystr)); System.out.println("在整型数组中‘3‘的索引为：" + search(3, array)); }}
Java笔记--泛型总结与详解