黑马程序员技术交流社区

标题: 集合框架的工具类总结 [打印本页]

作者: vermouth    时间: 2015-1-17 17:02
标题: 集合框架的工具类总结
        Collections 包含的都是静态方法
                        排序:
                                static <T extends Comparable<? super T>> void sort(List<T> list)
                                                根据元素的自然顺序 对指定列表按升序进行排序。
                                static <T> void sort(List<T> list, Comparator<? super T> c)
                                                根据指定比较器产生的顺序对指定列表进行排序。
                        查找:
                                static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
                                static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
                                                使用二分搜索法搜索指定列表,以获得指定对象。
                                                如果搜索键包含在列表中,则返回搜索键的索引;
                                                否则返回 (-(插入点) - 1)。插入点 被定义为将键插入列表的那一点
                                max min等同上
                        替换:
                                static <T> void  fill(List<? super T> list, T obj)  使用指定元素替换指定列表中的所有元素。
                                static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) 使用另一个值替换列表中出现的所有某一指定值
                        反转:
                                static void reverse(List<?> list)  反转指定列表中元素的顺序
                                static void swap(List<?> list, int i, int j)  在指定列表的指定位置处交换元素。
                        置换(洗牌,骰子)
                                static void shuffle(List<?> list) 使用默认随机源对指定列表进行置换。
                                static void shuffle(List<?> list, Random rnd)  使用指定的随机源对指定列表进行置换。

                               
                        逆转比较器:
                                static <T> Comparator<T> reverseOrder()
                                                返回一个比较器,它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
                                static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
                                                返回一个比较器,它强行逆转指定比较器的顺序。
                                       
                                               
                        线程问题:
                                自己加锁好麻烦  以下使用时一定要查API看建议
                                static <T> Collection<T> synchronizedCollection(Collection<T> c)
                                                  返回指定 collection 支持的同步(线程安全的)collection。
                                static <T> List<T> synchronizedList(List<T> list)
                                                  返回指定列表支持的同步(线程安全的)列表。
                                static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)
                                                  返回由指定映射支持的同步(线程安全的)映射。
                                static <T> Set<T>  synchronizedSet(Set<T> s)
                                                  返回指定 set 支持的同步(线程安全的)set。
                                static <K,V> SortedMap<K,V>  synchronizedSortedMap(SortedMap<K,V> m)
                                                  返回指定有序映射支持的同步(线程安全的)有序映射。
                                static <T> SortedSet<T>  synchronizedSortedSet(SortedSet<T> s)
                                                  返回指定有序 set 支持的同步(线程安全的)有序 set。

                               
        Arrays 用于操作数组的工具类
                       
                                对应的是
                        查找:       
                                各种二分查找方法
                        截取:
                                copyOf
                                copyOfRange
                        比较:
                                equals
                                deepEquals 不光比较数组 还比较元素内容
                        替换:       
                                fill
                        哈希码
                                hashCode
                        排序
                                sort
                                还能局部排序
                        变成字符串:
                                toString
       
===================================================================       
        数组变集合,
                        Arrays:static <T> List<T>   asList(T... a)
                                返回一个受指定数组支持的固定大小的列表。
                        原因: 把数组转变为集合,可以用一些集合方法,比如contains
                       
                        注意:因为数组长度是固定的,所以不能使用集合中的增删,否则发生UnsupportedOperationException
                        泛型特点:
                                        如果数组中的元素都是对象,那么变成集合时,那么数组中的元素直接转变为集合中的对象,比如String
                                        如果数组中的元素都是基本数据类型,那么会将该数组作为集合中的元素存在,如果是int数组,泛型写int[]
                                       
        集合变数组:Collection.toArray();
                        Object[] toArray()
                        <T> T[] toArray(T[] a)  返回包含此 collection 中所有元素的数组;
                                返回数组的运行时类型与指定数组的运行时类型相同。
                                        如果指定的数组能容纳该 collection,则返回包含此 collection 元素的数组。
                                        否则,将分配一个具有指定数组的运行时类型和此 collection 大小的新数组。
                                String[] y = x.toArray(new String[0]);
                        原因:集合变数组,为了限定对元素的操作,就不能增删了
       
===================================================================       
1.5新特性
        public static void show(int... arr){  
                System.out.println(arr.length);
        }
        main(){
                show(2,3,4,5,6,7,8,9);  //只要传元素就行了,不用new一个数组,隐世封装
        }
       
集合静态导入
        StaticImport
        每次使用工具类,都要写Collections. 或者Arrays.等等
        import static java.util.Arrays.*; 静态导入Arrays这个类中的所有静态成员
                当类名重名时,需要指定具体的包名
                当方法重名时,需要制定所属的对象或者类
作者: Awizard    时间: 2015-1-17 23:56
看起来略费劲。。基础还是不好。。马克一下,继续努力




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