黑马程序员技术交流社区

标题: 集合类（下） [打印本页]

---

作者: mortonnnn    时间: 2015-7-18 00:39
标题: 集合类（下）
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 +ｍin)/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)---将数组转化成为字符串



这样，集合类搞定。

---

作者: eayonh    时间: 2015-7-18 02:18
谢谢分享

---

作者: 雏鹰起飞    时间: 2015-7-18 08:04
感谢分享！！

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2