A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© mortonnnn 中级黑马   /  2015-7-18 00:39  /  415 人查看  /  2 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

jdk5.0的新特性---泛型

泛型:参数化类型---使用<参数化类型>的方式指定该类中方法操作的数据类型
public class Example23{
        public void static main(String[] args){
                ArrayList list = new ArrayList();
                list.add("Feriosa");
                list.add("max");
                list.add(1);
                for(Object obj : list){
                        String str = (String) obj;
                }
        }
}



public class Example24{
        public void static main(String[] args){
                ArrayList<String> list = new ArrayList<String>();
                list.add("Feriosa");
                list.add("max");
                for(String str : list){
                        System.out.println(str);
                }
        }
}
使用“参数化类型”的方式指定该类中方法操作的数据类型
使用“参数化类型”的方式指定该类中方法操作的数据类型
使用“参数化类型”的方式指定该类中方法操作的数据类型
这样做的好处是:在编译的时候就可以解决错误,避免在程序运行时发生错误

自定义泛型:

在定义一个类的时候使用<T>申明参数类型,它的一些方法的参数类型或者返回值类型也都申明为T

class cachePool<T> {
        T temp;
        public void save(T temp){
                this.temp = temp;
        }
        public T get(){
                return temp;
        }
}

全类中只能出现一种数据类型---T

class Example25{
        public void static main(Sring[] args){
                cachePool<Integer> cp  = new cachePool<Integer>;                //传入Integer
                cp.savez(new Integer(111));
                Integer i  = cp.get;
        }
}


Collections工具类:

根据api文档呢,有大概这几个常用的静态方法:
排序:
(这里复习一下学习循环语句时学的那几段有关排序和选择的代码)

首先明确一下这些方法是干嘛的:
选择排序+冒泡排序---》排序
二分法---》查找(如果数组是无序的,简单遍历查找就ok,如果数组是有序的,那么二分查找就比较好)


之前见到的一个排序api:Arrays.sort()---刚看了一下下一小节,arrays工具类是专门用来操作数组的,而Collections是用来操作集合的

Collections的排序:
static<T> boolean addAll(Collection<?super T> c , T...elements)---将所有指定元素添加到指定的collection中---感觉有了addAll(),不用再一个个添加了
static void reverse(List list)---反转
static void shuffle(List list)---随机排序(“洗牌”);
static void sort(List list)---按自然顺序排序
static void swap(List list , int i , int j )---将指定集合中i处元素和j处元素进行交换

public class Example26{
        public void static main(String[] args){
                ArrayList list = new ArrayList();
                Collections.addAll(list,"feriosa","max","nux");
                Collections.reverse(list);
                Collections.shuffle(list);
                Collections..sort(list);
                Collections.swap(list,0,1);
        }
}

查找和替换操作:
static int binarySearch(List list , Object key)---使用二分法搜索指定的对象在List集合中的索引,查找的List集合中的元素必须是有序的
static Object max(Collection col)
static Object min(Collection col)
static boolean replaceAll(List list, Object oldVal , Object newVal)





ok,Arrays.sort()表示数组的排序,那么逻辑思路上有两种方法---》选择法和冒泡法
其实这两种方法是路上只差一点,代码上也只差几行
选择法:依次拿数组的每一个去与它后面的每一个去比较,用大的换小的,这样一直比下去,就是左小又大
冒泡法:左边一直两两相比,留下在右边相对最大的

直接点说就是:
选择法是右边的依次和左边的比,左边留下最小的
冒泡法是总是从左边两个两个相比,然后留在右边相对最大的


代码上for(int x = 0; x < arr.length -1 ; x++)过后:
选择法:for(int y  = x + 1 ; y < arr.length ; y++)
冒泡法:for(int y = 0 ; y < arr.length  - 1- x ; y++)

这两句代码之后:
选择法:
if(arr[x] > arr[y]){
        temp = arr[x];
        arr[x] = arr[y];
        arr[y] = temp;
}
冒泡法:
if(arr[y]>arr[y+1]){
        temp = arr[y];
        arr[y] = arr[y+1];
        arr[y+1] = temp;
}


(选择法还有一个优化版本,即先记录每一轮比较完成之后最值的角标,然后最后才用swap(int[] arr , int x, int y)来实现交换

详见代码:
public static void selectSort(int[] arr){
        for(int x = 0 ;  x < arr.length - 1 ;  x++){
                arr[x] = arrx;
                index = x;
                for(int y = x + 1; y < arr.length ; y ++){
                        if(arrx > arr[y]){
                                arrx = arr[y];
                                index= y ;        
                        }
                }
                if(index != x )                
                        swap(arr,x , index);
        }
}

public static void swap(int[] arr, int x , int y ){
        int temp;
        temp = arr[x];
        arr[x] = arr[y];
        arr[y] = temp;
}


终于搞定了这几个排序方法(两个---选择和冒泡)
还有一个binarySearch(Object[] , Object key)对应的二分法:
其实二分法超级简单(但要注意其中使用了一个while循环)

public int binarySearch(int[] arr, int x) {
                int max = arr.length -1 ;
                int min = 0 ;
                int mid  =(min + max) / 2 ;

                while(min != max){
                        if(arr[mid] > x){
                                max = mid -1 ;
                        }else if(arr[mid]< x){
                                min = mid +1 ;
                        }else if (max < min ){
                                return -1;
                        }
                        mid = (max +min)/2;
                }
                return mid;
}

或者:
public int binarySearch(int[] arr , int x ){
        int max  = arr.length -1 ;
        int min  = 0 ;
        int mid ;

        while(min < max){
                mid = (min +max)>>1;
               
                if(arr[mid] > x ){
                        max = mid -1 ;
                }else if (arr[mid] < x){
                        min = mid +1 ;
                }else{
                        return mid;
                }
        }
       
        return -1;                        //这种情况是min>= max,直接方法-1即可
}

好现在再来看Arrays类的常有静态方法:
Arrays.sort(int[] arr)---排序(类似选择法或者冒泡法)
Arrays.binarySearch(Object[] a, Object key)---查询(类似二分法)
Arrays.copyOfRange(int[] original, int from, int to)---拷贝元素(在不破环原数组的情况下)
Arrays.fill(Object[] a, Object val)---填充元素
Arrays.toString(int[] arr)---将数组转化成为字符串



这样,集合类搞定。

2 个回复

倒序浏览
谢谢分享
回复 使用道具 举报
感谢分享!!
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马