黑马程序员_JAVA笔记17——集合

-------  android培训、 java培训、期待与您交流！ ----------

1、类Collections     ，专门用于对集合collection操作，里面全是静态方法。

    其中static <T extends Comparable<? super T>> void sort(List<T> list>方法，根据元素额自然顺序，对指定列表按升序排序。

    public static <T> void sort(List<T> list,Comparator<? super T> c)方法，根据指定比较器产生的顺序对指定列表进行排序，此列表内的所有元素都必须课使用指定比较器相互比较。也就是说，对于列表中的任意e1  e2元素，c.compare(e1,e2)不得抛出ClassCastException

    public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll);根据元素的自然顺序，返回给定collection的最大元素。

import java.util.*;

class CollectionsDemo

{

        public static void main(String[] args)

        {

                sortDemo();

                maxDemo();

        }

          public static void maxDemo()

        {

                List<String> list = new List<String>();

                list.add("abcfd");

                list.add("ebsscd");

                list.add("abcfd");//List 数组结构，能有重复元素

                list.add("gbcsfsdd");

                list.add("rbd");

                String max = Collections.max(list);//按自然顺序

                String max = Collections.max(list. new StrLenComparator());//按指定比较器获取

        }

        public static void sortDemo()

        {

                List<String> list = new List<String>();

                list.add("abcfd");

                list.add("ebsscd");

                list.add("abcfd");//List 数组结构，能有重复元素

                list.add("gbcsfsdd");

                list.add("rbd");

                sop(list);

                 Collections.sort(list);

                Collections.sort(list,new StrLenComparator());

                sop(list);

        }

        public static void sop(Object obj)

        {

                System.out.println(obj);

        }

}

class StrLenComarator implements Comparator<String>

{

        public int compare(String s1,String s2)

        {

                if(s1.length()>s2.length())

                        return 1;

                if(s1.length()<s2.length())

                        return -1;

                return s1.compareTo(s2);//表示在长度一致时，按自然顺序比较

        }

}

2、binarySearch,二分查找对象，这里list必须是有序的

static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key);

        使用二分搜索法搜索指定列表，根据key获取指定对象

static <T> int binarySearch(List<? extends T> list,T key,Comparator<? super T> c);

        使用二分搜索法搜索指定列表，根据key按照指定比较器获取指定对象

import java.util.*;

class CollectionsDemo

{

        public static void main(String[] args)

        {

              

        }

          public static void bnsDemo()

        {

                List<String> list = new List<String>();

                list.add("abcfd");

                list.add("bbsscd");

                list.add("cbcfd");//List 数组结构，能有重复元素

                list.add("gbcsfsdd");

                list.add("rbd");

                Collections.sort(list);

               int i =  Collections.binarySearch(list,"rbd");//返回rbd的角标

        }

        public static void sop(Object obj)

        {

                System.out.println(obj);

        }

}

class StrLenComarator implements Comparator<String>

{

        public int compare(String s1,String s2)

        {

                if(s1.length()>s2.length())

                        return 1;

                if(s1.length()<s2.length())

                        return -1;

                return s1.compareTo(s2);//表示在长度一致时，按自然顺序比较

        }

}

3，   fill方法可以将list集合中的所有元素替换成指定元素。

        static boolean replaceAll(List<T> list,T oldVal,T newVal);在list中用newVal替换所有oldVal。

        reverse(List<T> list>:将list中元素反序排列

        public static<T> Comparator reverseorder();返回一个比较器，它强行逆转实现了Comparable接口的对象collection的自然书序。

        public static <T> Comparator<T> reverseOrder(Comparator<T> cmp);返回一个比较器，它强行逆转指定比较器的顺序，如果指定比较器为null那么，逆转默认比较器。

        swap(List<T> list  ,int i,int y);交换list 中角标i  y 位置的元素。

        shuffle(List<?> list);将list中元素顺序打乱，随机排序

import java.util.*;

class CollectionsDemo

{

        public static void main(String[] args)

        {

              

        }

          public static void bnsDemo()

        {

                List<String> list = new List<String>();

                List<String> list = new List<String>(Collections.reverseOrder());

                List<String> list = new List<String>(Collections.reverseOrder(new StrLenComparator()));

                list.add("abcfd");

                list.add("ebsscd");

                list.add("abcfd");//List 数组结构，能有重复元素

                list.add("gbcsfsdd");

                list.add("rbd");

                Collections.sort(list);

                Collections.fill(list,"pp");//将list中所有元素都替换为pp

                sop(Collections.replaceAll(list,"pp","fddfd");

                

       

        }

        public static void sop(Object obj)

        {

                System.out.println(obj);

        }

}

class StrLenComarator implements Comparator<String>

{

        public int compare(String s1,String s2)

        {

                if(s1.length()>s2.length())

                        return 1;

                if(s1.length()<s2.length())

                        return -1;

                return s1.compareTo(s2);//表示在长度一致时，按自然顺序比较

        }

}

4、Arrays用于操作数组的工具类，里面全是静态方法

    public static<T> List<T> asList(T... a):返回一个受指定数组支持的固定大小的列表。对返回列表的更改会直接作用到数组。（将数组变成list集合）

    把数组变成集合的好处：可以使用集合的思想和方法来操作书中的元素

    注意：将数组变成集合，不可以使用集合的 增删方法，因为数组长度固定，其他方法可以用。如果增删了，就出现不支持操作异常

    

import java.util.*;

class ArraysDemo

{

        public static void main(String[] args)

        {

             // int[] arr = {2,43,4};

              //System.out.println(Arrays.toString(arr));

            String[] arr = {"fdfd","fdfdggee","wwe"};

            List<String> list = Arrays.asList(arr);

            sop(list.contains("fdf"));

        /*

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

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

        */

        int[] arrayint ={1,2,3}

        List< int[]> li = Arrays.asList(arrayint);//此时存放的是数组arrayint的地址

        Integer[] in2= {1,2,3}

        List<Integer> in2= Arrays.asList(in2);//此时存放的是Integer型对象：1,2,3，

        }

         public static void sop(Object obj)

        {

                System.out.println(obj);

        }

}

5、集合变数组，用<T> T[] toArray(<T>t[]);

import java.util.*;

class ArraysDemo

{

        public static void main(String[] args)

        {

      ArrayList<String> al = new ArrayList<String>();

al.add("fdf");

al.add("f122f");

al.add("fggg");

/*

指定类型的数组到底要定义多长，当指定类型的数组长度小于集合的size，那么该方法内部会常见一个新的数组，长度为集合的size。当指定类型的数组长度大于集合的size，就不会新创建数组，而是使用传递进来的饿数组。所以创建一个刚刚好长度的数组最优。

为什么将集合变数组，是为了限定对元素的操作，不需要进行增删

*/

      Stirng[] arr = al.toArray(new String[ al.size()]);

      sop(Arrays.toString(arr));

        }

         public static void sop(Object obj)

        {

                System.out.println(obj);

        }

}

6、1.5后新特性，增强for循环

格式：

for(数据类型  变量名：被遍历的集合（Collection)或数组。。其实底层就是迭代器

好处：简化书写

弊端：只能对集合进行获取操作，不能对集合进行操作

迭代器：可以遍历，也可以remove集合中元素

如果使用ListIterator，还可以在遍历过程中进行增删改查的操作。

传统for与高级for区别：高级for有一个局限性，必须有被遍历的目标。

建议：在遍历数组时，希望时候传统for，因为传统for可以定义角标

class ArraysDemo

{

        public static void main(String[] args)

        {

ArrayList<String> al = new ArrayList<String>();

al.add("fdf");

al.add("f122f");

al.add("fggg");

for(String s:all)//注意数据类型，ArrayList<String> al   必须加泛型，若不加，for里String  需用Object。因为for需要知道数据类型

{

sop(s);

}

int[] arr= {3,4,2};

for(int i:arr)

{

sop(i);

}

HashMap<Integer ,String> hm = new HashMap<Integer,String>();

hm.put(1,"a");

hm.put(2,"b");

//方式一：

Set<Integer> keySet = hm.keySet();

for(Integer i:keySet)

{

sop(i+"fffffff"+ht.get(i));

}

//方式二：

for(Map.Entry<Integer,String> me:hm.entrySet())

{

sop(me.getKey()+me.getValue());

}

        }

         public static void sop(Object obj)

        {

                System.out.println(obj);

        }

}

7、JDK1.5出现的新特性，可变参数

class Demo

{

        public static void main(String[] args)

        {

                show(2,3);

                show(1,3,8);

        }

        /*

        public static void show(int a,int b)

        {

                sop(a+b);

        }

        public static void show(int a,int b,int c)

        {

                sop(a+b+c);

        }

         public static void show(int[] in)

        {

        

        }

       */

        /*

        可变参数，其实就是一种数组参数的简写形式。不用每一次都手动的建立数组对象，只要将要操作的元素作为参数传递即可。隐式的将这些参数封装成数组。

        格式：函数名(数据类型... 数组名)

        方法的可变参数在使用时，可变参数一定定义在参数列表的最后面。

        读取过程：当读到int... arr时，会默认把该参数及后面的参数全部封装进数组，因此，可变参数后面不要写参数，但是可以在可变参数前些其他参数，因为系统只有读到...时才封装从...开始的参数列表。

        */

        public static void show( int... arr)

        {

                sop(arr)

        }

        public static void show( String str,int... arr)

        {

                sop(arr)

        }

          public static void show(int... arr,String str)//这种方式是错误的，系统会把参数全都封装，出异常

        {

                sop(arr)

        }

        public static void sop(Object obj)

        {

                System.out.println(obj);

        }

}

8、1.5后新特性，静态导入。注意导入的必须是静态的。

import java.util.*;

import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。这样调用Arrays中的静态方法时，Arrays可以省略不写。但当出现类名重名时，包名需指定；当方法重名时，需指定所属对象或类。

import static java.lang.System.*;//导入System类中所有静态成员，而out也是System中静态成员，因此导入此后，输出语句的System.out.println()中System可以不写了

class Demo

{

        public static void main(String[] args)

        {

               int[] arr = {1,3,4};

                  Arrays.sort(arr);//可以省略

                int index =   Arrays.binarySearch(arr,1);//可以省略

                sop (Arrays.toString(arr));//不可以省略，因为：Arrays继承Object，二者都有toString方法，需要指定哪个类调用的该方法。

                sop(index)

        }

        public static void sop(Object obj)

        {

                System.out.println(obj);

        }

}