首页 > 代码库 > 黑马程序员-集合工具类和1.5新特性

黑马程序员-集合工具类和1.5新特性

集合框架的工具类:collecttions

Collections 的方法全是静态的

       List没有排序功能,所以java定义了Collections工具类。

       比较器无法传给list,只能传给Set.但是集合工具类有此方法

1.排序:

       comparable:    sort(List<T> list) 根据元素的自然顺序 对指定列表按升序进行排序。

       comparator:    sort(List<T> list, Comparator<? super T> c) 根据比较器产生的顺序对指定列表进行排序。

       swap(List<?> list, int i, int j)  在指定列表的指定位置处交换元素。

2.获取一堆对象中的最值:

       comparable:    max(Collection<? extends T> coll) 根据元素的自然顺序,返回给定 collection 的最大元素。

       comparator:    max(Collection<? extends T> coll, Comparator<? super T> comp)

              根据指定比较器产生的顺序,返回给定 collection 的最大元素。

3.二分法://元素必须有脚标,集合必须有序 返回脚标

       comparable:    binarySearch(List<? extends Comparable<? super T>> list, T key)

              使用二分搜索法搜索指定列表,以获得指定对象。

       comparator:    binarySearch(List<? extends T> list, T key, Comparator<? super T> c)

               使用二分搜索法搜索指定列表,以获得指定对象。

4.复制

       void copy(List<? super T> dest, List<? extends T> src) 将所有元素从一个列表复制到另一个列表。

5.替换

       void fill(List<? super T> list, T obj) 使用指定元素替换指定列表中的所有元素。

   一替换多: boolean       replaceAll(List<T> list, T oldVal, T newVal)

        使用另一个值替换列表中出现的所有某一指定值。

        replaceAll(List<T> list, T oldVal, T newVal)

         用指定值替换列表中所有的oldValue 又是list

6.反转

       reverse(List<?> list) 又是集合

         反转指定列表中元素的顺序。                    

    反转比较器(相对于comparable)。代替了以前改变的obj>obj的“>”符号的方法。

        Comparator   reverseOrder();  逆转一个 实现comparable的对象的自然顺序。返回一个比较器。将它当做参数在传给treeSet即可      

       反转自定义的比较器(相对于compatator)。

              Comparator   reverseOrder(mycomp);将自定义的比较器进行强行逆转。

7.同步

       synchronizedSet(Set<T> s)  返回指定 set 支持的同步(线程安全的)set。

       原理:传入的集合的方法都被一个同步代码块(mutex),有用一个锁。

       可以对:Collction List Map Set等集合进行同步。

8.置换

       void swap(List<?> list, int i, int j) 在指定列表的指定位置(角标)处交换元素。

       shuffle(List<?> list) 使用默认随机源对指定列表进行置换。

       shuffle(List<?> list, Random rnd) 使用指定的随机源对指定列表进行置换。

       应用:对扑克牌的随机洗牌。

集合工具类:

Arrays:用于操作数组的工具类。全是静态方法。

         1.二分查找:binarySearch(T[] Key)

                    在指定范围内查找:binarySearch(double[],fromIndes,toIndes,Key);

         2.复制(截取)数组:copyOf(T[],int new length),角标对应,数组相同,角标

         3.复制指定范围的数组。copyOfRangle(T[] original,int from,int to)

         4.asList(T...a):将数组变成集合(大小固定)。支持可变参数             

         5.toString(T[] t) :返回字符串形式

         6.sort(T[] t)

                    sort(T[] t,fromindex,toindex):局部排序

         8.equals(T[] T,E[] e);元素数量相等,且对应的元素相同。

         7.deepEquasl和deepHashCode():还比较元素的内容的元素。

数组变List集合

       static <T> List<T>  asList(T... a) :注意是List

              返回一个指定数组支持的固定大小的List集合。

       数组变成list集合的好处?

可以通过集合的思想和方法来操作数组中的元素,如:比如。list.contains(xxx);如果数组则要for循环判断,很麻烦。直接打印,替换,还有:get(),index,sublist等等。

       注意:将数组变成集合,不可以使用集合增删方法。 因为数组的长度是固定的。

              如果增删,则报unsupportedOperationException.

       如果数组中的元素都是对象,那么变成集合时,数组中的元素就直接转成集合中的元素。

       如果数组中的元素都是基本的数据类型,那么会将该数组作为集合中的元素存在。

集合变数组。

Collection 接口中的的toArray

        Object[] toArray()     返回包含此 collection 中所有元素的数组。

        <T> T[]  toArray(T[] a)  返回包含此 collection 中所有元素的数组;

        两种的区别。第二种可以限定元素类型,常用    

       数组变字符串:toString

 高级for:foreach

        格式:for(变量类型 变量 名:集合或数组){} ;高级for可以操作集合和数组。   

        2.与迭代器的区别:高级for无法对集合中的元素进行改变。这也是与iterator 和listIterator的本质区别

        2.与传统for的区别:高级for必须有被遍历的目标(它本质仍是从集中或数组取出来,仍是一个取出的动作),

              所以高级for无法进行打印"hello java"100次的等操作。。

        3.Map集合的高级for

        前提:先转成Set

        建议在遍历数组的时候,建议使用传统for,因为可以定义角标。

可变参数:jdk1.5版本出现的新特性。

       注意:可变参数一定要定义在参数列表的后面,后面不可以有别的参数。

       其实就是一种数组参数的简写形式,不用每一次都手动的建立数组对象。

       只要将要操作的元素作为了参数即可,隐式的将这些参数封装成了数组。

 

 public static void main(String[] args) {

              // TODO Auto-generated method stub

              show("a",1,6,5,6,7);

       }

       public static void show(String str,int in ,int...a){

              //System.out.println(a);//a是一个数组,其实就是封装了一个数组

              //怎么用 既然可变参数是数组,则调用数组的方法。

                     for(int x:a){

                     System.out.println("x"+x);

              }

              System.out.println(str+" "+in);//String不能放在最后。因为它会把后面的都打包,容易混乱。

              //System.out.println(Arrays.asList(a));忘了asList的条件。

              //记住;这两个例子是有区别的,有什么区别?没报错a,存储都是数组对象。 

              List li = Arrays.asList(a);

              List<int[]> li1 = Arrays.asList(a);

              //异常System.out.println(li.subList(0, 2));只有一个元素,角标越界。

              System.out.println(li1.size());