Java基础-17-集合4

Java基础-集合

集合进阶3

1、集合（Collections-sort）

集合框架的工具类Collections

java.util.Collections
public class Collections：
此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。它包含在 collection 上操作的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其他内容。

如果为此类的方法所提供的 collection 或类对象为 null，则这些方法都将抛出 NullPointerException。

static void sort(List<T> list);//根据元素的自然顺序 对指定列表按升序进行排序。
static <T> void sort(List<T> list,Comparator<? super T> c);//根据指定比较器产生的顺序对指定列表进行排序。

测试代码：

import java.util.*;
class CollectionsDemo
{
    public static void main(String []   args)
    {
        sortDemo();
    }
    public static void sortDemo()
    {
        List<String> list = new ArrayList<String>();
        list.add("abcd");
        list.add("aaa");
        list.add("zzz");
        list.add("kkkkk");
        list.add("qq");
        list.add("z");
        list.add("z");
        System.out.println("自然存储序列："+list);

        //使用Collections.sort()输出排序结果
        Collections.sort(list);
        System.out.println("使用Collections.sort()输出排序结果:"+list);

        //使用Collections.sort(List<T> list,Comparator<? super T> c)
        Collections.sort(list,new StrLenComparator());
        System.out.println("使用Collections.sort(List<T> list,Comparator<? super T> c)输出排序结果:"+list);

    }
}
class StrLenComparator implements Comparator<String>
{
    public int compare(String s1,String s2)
    {
        int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
        if(num ==0)
        {
            return s1.compareTo(s2);
        }
        return num;
    }
}

输出：

2、集合（Collections-max）

static <T> T max(Collection<? extends T> coll);//根据元素的自然顺序，返回给定 collection 的最大元素。
static <T> T max(Collection<? extends T>,Comparator<? super T> comp);//根据指定比较器产生的顺序，返回给定 collection 的最大元素。

测试代码：

import java.util.*;
class CollectionsDemo1
{
    public static void main(String []   args)
    {
        //sortDemo();
        maxDemo();
    }
    public static void sortDemo()
    {
        List<String> list = new ArrayList<String>();
        list.add("abcd");
        list.add("aaa");
        list.add("zzz");
        list.add("kkkkk");
        list.add("qq");
        list.add("z");
        list.add("z");
        System.out.println("自然存储序列："+list);

        //使用Collections.sort()输出排序结果
        Collections.sort(list);
        System.out.println("使用Collections.sort()输出排序结果:"+list);

        //使用Collections.sort(List<T> list,Comparator<? super T> c)
        Collections.sort(list,new StrLenComparator());
        System.out.println("使用Collections.sort(List<T> list,Comparator<? super T> c)输出排序结果:"+list);

    }
    public static void maxDemo()
    {
        List<String> list = new ArrayList<String>();
        list.add("abcd");
        list.add("aaa");
        list.add("zzz");
        list.add("kkkkk");
        list.add("qq");
        list.add("z");
        list.add("z");
        System.out.println("自然存储序列："+list);

        String max = Collections.max(list);
        System.out.println("使用了Collection.max(list)方法的结果："+max);

        String max_1 = Collections.max(list,new StrLenComparator());
        System.out.println("使用了Collection.max(list,new StrLenComparator())方法的结果："+max_1);
    }
}
class StrLenComparator implements Comparator<String>
{
    public int compare(String s1,String s2)
    {
        int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
        if(num ==0)
        {
            return s1.compareTo(s2);
        }
        return num;
    }
}

输出：

3、集合（Collections-binarySearch）

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);//使用二分搜索法搜索指定列表，以获得指定对象。
用代码展现一下binarySearch的实现原理。
用public static int halfSearch(List<String> list,String key)表示。

Demo

public static int halfSearch(List<String> list ,String key)//二分查找法
{
    int max ,min , mid;
    max = list.size()-1;
    min = 0;
    while (min<=max)
    {
        mid = (max+min)>>1;//  /2
        String str = list.get(mid);
        int num = str.compareTo(key);
        if(num > 0)
        {
            max = mid-1;
        }
        else if(num < 0)
        {
            min = mid+1;
        }
        else return mid;
    }
    return mid -1;
}

以上功能相当于直接调用：

public static void main(String [] args)
{ int index = Collections.binarySearch(list,"aaaa");}

若担心存入的list中的数据不具备比较性，上面的halfSearch功能可以改进。如下：

public static int halfSearch_2(List<String> list ,String key,Comparator<String> cmp)//加上了比较器
{
    int max ,min , mid;
    max = list.size()-1;
    min = 0;
    while (min<=max)
    {
        mid = (max+min)>>1;//  /2
        String str = list.get(mid);
        int num = cmp.compare(str,key);
        if(num > 0)
        {
            max = mid-1;
        }
        else if(num < 0)
        {
            min = mid+1;
        }
        else return mid;
    }
    return mid -1;
}

测试代码如下：

import java.util.*;
class CollectionsDemo2
{
    public static void main(String []   args)
    {
        List<String> list = new ArrayList<String>();
        list.add("abcd");
        list.add("aaa");
        list.add("zzz");
        list.add("kkkkk");
        list.add("qq");
        list.add("z");
        list.add("z");
        System.out.println("自然存储序列："+list);
        int index = halfSearch_2(list,"aaa",new StrLenComparator());
        System.out.println("halfSearch_2下aaa的index是"+index);
        int index2 = Collections.binarySearch(list,"zzz",new StrLenComparator());
        System.out.println("Collections.binarySearch下zzz的index是"+index2);
    }
    public static int halfSearch_2(List<String> list ,String key,Comparator<String> cmp)//加上了比较器
    {
        int max ,min , mid=0;
        max = list.size()-1;
        min = 0;
        while (min<=max)
        {
            mid = (max+min)>>1;//  /2
            String str = list.get(mid);
            int num = cmp.compare(str,key);
            if(num > 0)
            {
                max = mid-1;
            }
            else if(num < 0)
            {
                min = mid+1;
            }
            else return mid;
        }
        return mid-1;
    }
}
class StrLenComparator implements Comparator<String>
{
    public int compare(String s1,String s2)
    {
        int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
        if(num ==0)
        {
            return s1.compareTo(s2);
        }
        return num;
    }
}

输出结果：

4、集合（Collections-替换反转）

fill方法可以将List集合中所有元素替换成指定元素。
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);//反转指定列表中元素的顺序。

测试代码：

import java.util.*;
class CollectionsDemo3
{
    public static void main(String []   args)
    {
        List<String> list = new ArrayList<String>();
        list.add("abcd");
        list.add("aaa");
        list.add("zzz");
        list.add("kkkkk");
        list.add("qq");
        list.add("z");
        list.add("z");
        System.out.println("自然存储序列："+list);

        Collections.replaceAll(list,"z","wo");
        System.out.println("replaceAll(list,\"z\",\"wo\")下的list是"+list);

        Collections.reverse(list);
        System.out.println("reverse(list)下的list是"+list);

        Collections.fill(list,"heihei");
        System.out.println("fill(list,\"heihei\")下的list是"+list);
    }
}

输出：

5、集合（Collections-reverseOrder）

在不使用Collections类的情况下，如果想正逆序排列集合的话，使用Comparator比较器。代码如下：

import java.util.*;
class CollectionsDemo4
{
    public static void main(String []   args)
    {
        TreeSet<String> list = new TreeSet<String>(new StrLenComparator());
        list.add("abcd");
        list.add("aaa");
        list.add("zzz");
        list.add("kkkkk");
        list.add("qq");
        list.add("z");
        list.add("z");
        System.out.println("使用比较器排序后的序列："+list);

    }
}
class StrLenComparator implements Comparator<String>
{
    public int compare(String s1,String s2)
    {

        //这是按长度排序，逆排序如下，如果想正排序就把下面的s1和s2互换。
        int num = new Integer(s2.length()).compareTo(new Integer(s1.length()));
        if(num ==0)
        {

            return s2.compareTo(s1);
        }
        return num;
    }
}

输出：

但如果使用Collections工具类就方便多了，直接调用就可。测试代码如下：

import java.util.*;
class CollectionsDemo4
{
    public static void main(String []   args)
    {
        TreeSet<String> list = new TreeSet<String>(Collections.reverseOrder());
        list.add("abcd");
        list.add("aaa");
        list.add("zzz");
        list.add("kkkkk");
        list.add("qq");
        list.add("z");
        list.add("z");

        System.out.println("使用Collections.reverseOrder()排序后的序列："+list);

    }
}

图：

如果想按照长度来排序，而且想倒序，也可以这样。

import java.util.*;
class CollectionsDemo4
{
    public static void main(String []   args)
    {
        TreeSet<String> list = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));//把比较器放到对象里
        list.add("abcd");
        list.add("aaa");
        list.add("zzz");
        list.add("kkkkk");
        list.add("qq");
        list.add("z");
        list.add("z");
        System.out.println("使用比较器排序后的序列："+list);

    }
}
class StrLenComparator implements Comparator<String>
{
    public int compare(String s1,String s2)
    {

        //这是按长度排序，逆排序如下，如果想正排序就把下面的s1和s2互换。
        int num = new Integer(s2.length()).compareTo(new Integer(s1.length()));
        if(num ==0)
        {

            return s2.compareTo(s1);
        }
        return num;
    }
}

输出：

6、集合（Collections-shuffle）

Collections.shuffle(list);//把之前排序好的list随机再排过，应用：扑克洗牌
static void shuffle(List <？> list);//使用默认随机源对指定列表进行置换。

7、集合（Arrays）

java.util

Arrays类：public class Arrays 此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。

Arrays：用于操作数组的工具类，里面都是静态方法。

static<T> List<T> asList(T... a);//返回一个受指定数组支持的固定大小的列表。

• 把数组变成List有什么好处？

可以使用集合的思想和方法来操作数组中的元素。注意：将数组变成集合不可以使用集合的增删方法，因为数组的长度是固定的。如果增删，那么会发生UnsupportedOperationException。

如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素，如果数组中的元素都是基本数组类型，那么会将该数组作为集合中的元素存在。

测试：

import java.util.*;
class ArraysDemo
{
    public static void main(String []   args)
    {
        int [] arr ={1,2,3};
        System.out.println(Arrays.toString(arr));

        String [] arr1 = {"abc","sa","kk"};
        List<String> list = Arrays.asList(arr1);
        System.out.println(list);
        System.out.println("contains:"+list.contains("kk"));

        int [] nums = {2,4,5};//里面的元素不是对象
        List<int []> li = Arrays.asList(nums);
        System.out.println(li);

        Integer [] nums_1 = {2,4,5};//里面的元素是对象
        List<Integer> li_1 = Arrays.asList(nums_1);
        System.out.println(li_1);
    }
}

输出：

8、集合（集合转成数组）

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

（2）、为什么要将集合变成数组？ 为了限定对元素的操作，不需要进行增删了。

集合变数组测试代码：

import java.util.*;
class CollectionToArray
{
    public static void main(String []   args)
    {
        ArrayList<String> al = new ArrayList<String>();
        al.add("abc1");
        al.add("abc2");
        al.add("abc3");
        String [] arr = al.toArray(new String[2]);//集合变数组
        System.out.println(Arrays.toString(arr));

        ArrayList<String> al1 = new ArrayList<String>();
        al1.add("abc1");
        al1.add("abc2");
        al1.add("abc3");
        String [] arr1 = al.toArray(new String[5]);//集合变数组
        System.out.println(Arrays.toString(arr1));
    }
}

输出：

9、集合（增强for循环）

高级for循环 格式：

for(数据类型 变量名 : 被遍历的集合（Collection）或者数组){}

高级for循环特点：对集合进行遍历，只能获取元素，但是不能对集合进行操作 Iterator迭代器：除了遍历，还可以进行remove集合中元素的功能。

ListIterator：还可以在遍历过程中对集合进行增删改查的动作。

• 传统for和高级for有什么区别呢？

  高级for有一个局限性，必须有被遍历的目标，建议在遍历数组的时候，还是希望是用传统for，因为传统for可以定义角标。
  

Demo

import java.util.*;
class ForEachDemo
{
    public static void main(String [] args)
    {
        ArrayList<String> al = new ArrayList<String>();
        al.add("abc1");
        al.add("abc2");
        al.add("abc3");
        for(String s : al)
        {
            System.out.println(s);
        }
        System.out.println(al);

        int [] arr = {3,5,11};
        for(int x = 0 ; x < arr.length;x++)
        {
            System.out.println(arr[x]);
        }
        for(int i : arr)
        {
            System.out.println(i);
        }

        HashMap<Integer,String>hm = new HashMap<Integer,String>();
        hm.put(1,"a");
        hm.put(2,"b");
        hm.put(3,"c");
        Set<Integer> keySet = hm.keySet();
        for(Integer i : keySet)
        {
            System.out.println(i+"::"+hm.get(i));
        }

        for(Map.Entry<Integer,String> me : hm.entrySet())
        {
            System.out.println(me.getKey()+"....."+me.getValue());
        }
    }
}

输出：

10、集合（可变参数）

JDK1.5版本出现的新特性：方法的可变参数 在使用时注意：可变参数一定要定义在参数列表的最后面。

public static void main(String [] args){show ("haha",2,3,4,6);} public show(String str,Integer... arr){.........}

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

测试代码：

import java.util.*;
class ParamMethodDemo
{
    public static void main(String [] args)
    {
        show(3,4,5);
        show(1,2,3,4,5);
        show();
    }
    public static void show(int... arr)
    {
        System.out.println(arr.length);
    }
}

输出：

11、集合（静态导入）

• 什么时候适合静态导入？

  （1）、当类名重名时，需要指定具体的报名。
  （2）、当方法重名时，指定具体所属的对象或者类。
  

测试代码：

import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员
import java.util.*;
import static java.lang.System.*;
class StaticImportDemo 
{
    public static void main(String[] args) 
    {

        out.println("Hello World!");
        int [] arr = {3,1,5};
        sort(arr);//Arrays.sort()
        int index = binarySearch(arr,1);
        out.println("Index:"+index);
        out.println(Arrays.toString(arr));

    }
}

输出：