为什么使用泛型:参数化类型 最大的优点是能在编译时检测出错误 。从jdk1.5开始
它的类型必须的引用类型的 List<
int> list=new ArrayList<
int>();
int double char这类的就不行
原理: List<String> list2=new ArrayList<String>();
list2.add("this"); // 实际上是=> list2.add(new String("this"));
来看看泛型类
public class generic_2<E> {
private java.util.ArrayList<E> list=new java.util.ArrayList<E>();
public int getSize(){
return list.size();
}
public E peek(){
return list.get(getSize()-1);
}
public void push(E o){
list.add(o);
}
public E poop(){
E o=list.get(getSize()-1);
list.remove(getSize()-1);
return o;
}
public boolean isEmpty(){
return list.isEmpty();
}
}
如果有多个参数的话这样<E1,E2,E3>
泛型方法
public static void main(String[] args) {
Integer[] integers={1,2,5,6,6,8};
String[] strings={"2fs","23fds","fdsf","dfd"};
generic_1.<Integer>print(integers); //这样就是受限的
generic_1.<String>print(strings);
}
public static <E> void print(E[] list){
for(int i=0;i<list.length;i++){
System.out.println(list[i]+"");
}
}
其实不加也行的 类似于这样
generic_1.print(integers);
<E> 和 <E extends Object> 是一样的
原始类型和向后兼容
什么是原始类型: 说白了就是Object 向后兼容是它的子类型
List list=new ArrayList();
list.add("dadsfdddddddddddda");
System.out.println(list.get(0));
通配泛型 ? , ? extends T , ? super T
? : 和 ? extends Object 是一样的 非受限泛型类型
? extends T : 受限通配 例如 Integer 是 Number 的子类型
? super T : 下限通配 T 表示一个未知父类型 Object是String的父类
public static <T> void add( generic_2<T> stack1 , generic_2<? super T> stack2 ){
while(!stack1.isEmpty()){
stack2.push(stack1.poop());
}
}
深入原理: 例如 ArrayList<String> list1=new ArrayList<String>();
ArrayList<Integer> list2=new ArrayList<Integer>();
尽管是俩种类型 但是是运行的时候只有一个ArrayList类会加载到JVM中 list1和list2都是ArrayList的实例
但是 (
list1 instanceof ArrayList) 和 (
list2 instanceof ArrayList) 都是正确的 ·
泛型在运行时被消除
但
是
不能new E()
不能new E[]
在静态环境下不允许类的参数是泛型类型的
异常类不能是泛型的
编程练习: 代码在SWT那个Eclipse中
1.修改程序清单的GenericStack类,使用数组而不是ArrayList来实现它。 在给栈添加新元素前检查数组的大小,如果满了就创建一个新的数组,为当前的俩倍,然后复制到新数组中去。
2.(泛型二分查找法) 使用二分查找法实现下面的方法 public static <E extends Comparable<E>> int binarySearch(E[] list , E key)
3.(泛型选择排序) 使用排序法实现下面的方法 public static <E extends Comparable<E>> void selectionSort(E[] list)
4.(泛型插入排序法) 使用插入排序法实现下面方法 public static <E extends Comparable<E>> void insertionSort(E[] list);
5.(数组最大元素) 返回最大元素 public static <E extends Comparable<E>> E max(E[] list);
6.(二维数组最大元素) public static <E extends Comparable<E>> E max(E[][] list);
package generic_21;
import java.util.Arrays;
public class ZHomework {
public static void main(String[] args) {
/*二分查找
Integer[] list=new Integer[]{1,4,5,6,7,8,12};
Double[] list2=new Double[]{2.4,3.4,5.6,6.7};
Integer key=6;
Double key2=3.4;
Integer answer=ZHomework.<Integer>binarySearch(list, key);
Integer answer2=ZHomework.<Double>binarySearch(list2, key2);
if(answer!=-1){
System.out.println("the key of "+ key + " in array location is "+answer);
}
if(answer2!=-1){
System.out.println("the key of "+ key2 + " in array location is "+answer2);
}
*/
/*选择排序
Integer[] list=new Integer[]{11,4,55,6,7,18,2};
ZHomework.<Integer>selectionSort(list);
System.out.println(Arrays.asList(list));
*/
/**插入排序
Integer[] list2=new Integer[]{11,4,55,6,7,18,2};
ZHomework.<Integer>insertionSort(list2);
System.out.println(Arrays.asList(list2));
*/
/*一位数组最大值
Integer[] list=new Integer[]{11,4,55,6,7,18,2};
Integer max=ZHomework.<Integer>max(list);
System.out.println(max);
*/
Double[][] list=new Double[][]{{11.3,45.4,56.2,45.2},{13.3,45.4,6.2,45.2},{1.3,45.4,6.2,45.2},{11.3,5.4,6.2,4.2}};
System.out.println(ZHomework.<Double>max(list));
}
/**
* 泛型二分法查找 针对排序好的
* @param <E>
* @param list
* @param key
* @return
*/
public static <E extends Comparable<E>> int binarySearch(E[] list,E key){
int start=0;
int end =list.length-1;
while(start<=end){
int middle=(start+end)/2;
if(key.compareTo(list[middle])>0){
start=middle+1;
}else if(key.compareTo(list[middle])<0){
end=middle-1;
}else{
return middle;
}
}
return -1;
}
/**
* 泛型选择排序法
* @param <E>
* @param list
*/
public static <E extends Comparable<E>> void selectionSort(E[] list){
if(list.length<=0||list==null){
return ;
}
for(int i=0;i<list.length;i++){
int min=i;
for(int j=i+1;j<list.length;j++){
if(list[min].compareTo(list[j])>0){
min=j;
}
}
if(min!=i){
E tem=list[i];
list[i]=list[min];
list[min]=tem;
}
}
}
/**
* 泛型插入排序法
* @param <E>
* @param list
*/
public static <E extends Comparable<E>> void insertionSort(E[] list){
if(list==null||list.length<=0){
return;
}
for(int i=1;i<list.length;i++){
E tem=list[i];
int position=i; //记录点
for(int j=i-1;j>=0;j--){ //将当前位置之前的数组做处理
if(tem.compareTo(list[j])<0){
list[j+1]=list[j];
position--;
}else{
break;
}
}
list[position]=tem;
}
}
/**
* 一位数组最大值
* @param <E>
* @param list
* @return
*/
public static <E extends Comparable<E>> E max(E[] list){
E max=list[0];
for(int i=1;i<list.length;i++){
if(max.compareTo(list[i])<0){
max=list[i];
}
}
return max;
}
/**
* 二维数组最大值
* @param <E>
* @param list
* @return
*/
public static <E extends Comparable<E>> E max(E[][] list){
E max=list[0][0];
for(int i=0;i<list.length;i++){
for(int j=0;j<list[i].length;j++){
if(max.compareTo(list[i][j])<0){
max=list[i][j];
}
}
}
return max;
}
}
还有一些不是很懂,说不出来的感觉。 不过还好 。 参照书籍《Java语言程序设计·进阶篇》
我是菜鸟,我在路上。