标签：泛型
为什么使用泛型:参数化类型 最大的优点是能在编译时检测出错误 。从jdk1.5开始
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]+"");
}
}原始类型和向后兼容
什么是原始类型： 说白了就是Object 向后兼容是它的子类型
List list=new ArrayList();
list.add("dadsfdddddddddddda");
System.out.println(list.get(0));
public static <T> void add( generic_2<T> stack1 , generic_2<? super T> stack2 ){
while(!stack1.isEmpty()){
stack2.push(stack1.poop());
}
}
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语言程序设计·进阶篇》
我是菜鸟，我在路上。
标签：泛型
原文地址：http://blog.csdn.net/cjvs9k/article/details/45643089
