黑马程序员——Java基础——集合类_3

集合类

collections——sort、max、binarySreach

public static<T extends Comparable<? super T>> void sort(List<T> list){
//此泛型表示，限定类型需继承Comparable类具备比较性
//比较器限定为可接受T类型或T的父类
}
public class CollectionsDemo {
    public static void main(String[] args){
        sortDemo();
        maxDemo();
        binarySearchDemo();
    }
    public static void sortDemo(){
        List<String> list = new ArrayList<String>();
        list.add("abcd");
        list.add("kkkkk");
        list.add("aaaa");
        list.add("z");
        list.add("kkkkk");
        list.add("qq");

        sop(list);
        Collections.sort(list);
        sop(list);

        Collections.sort(list, new StrLenComparator());
        sop(list);
    }
    public static void maxDemo(){
        List<String> list = new ArrayList<String/*new StrLenComparator()*/>();
        list.add("abcd");
        list.add("kkkkk");
        list.add("aaaa");
        list.add("z");
        list.add("kkkkk");
        list.add("qq");

        String max = Collections.max(list);
        sop(max);
    }
    public static void binarySearchDemo(){
        List<String> list = new ArrayList<String/*new StrLenComparator()*/>();
        list.add("abcd");
        list.add("kkkkk");
        list.add("aaaa");
        list.add("z");
        list.add("kkkkk");
        list.add("qq");
        Collections.sort(list);
        sop(list);
        //使用binarySearch进行二维查找必须是有序集合
        int index = Collections.binarySearch(list, "aaaa");
        sop("index=" + index);
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
    //自定义binarySearch方法
    public static int halfSerch(List<String> list, String key){
        int max,min,mid;
        max = list.size() - 1;
        min = 0;
        while(min <= max){
            mid = (max + min) >> 1;
            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 -min - 1;
    }
}
class StrLenComparator 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);
    }
}

collections——替换反转fill、replaceAll、reverse

Collections.fill(list, object)方法：将集合中的所有元素替换成object元素

public class CollectionsDemo2 {
    public static void main(String[] args){
        fillDemo();
        replaceAllDemo();
    }
    public static void fillDemo(){
        List<String> list = new ArrayList<String>();
        list.add("abcd");
        list.add("aaaa");
        list.add("zz");
        list.add("kkkkk");
        sop(list);
        Collections.fill(list, "pp");
        sop(list);
    }
    public static void replaceAllDemo(){
        List<String> list = new ArrayList<String>();
        list.add("abcd");
        list.add("aaaa");
        list.add("zz");
        list.add("kkkkk");
        sop(list);
        Collections.replaceAll(list, "aaaa", "p");
        sop(list);
        Collection.reverse(list);
        sop(list);
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

练习：fill方法可以将集合中的所有元素替换成制定元素，请实现将集合中的部分元素替换成制定元素

public static void fillDemo(List, start, end){

}

Collections——reverseOrder

Collections.reverseOder();
1. 返回一个逆向自然序比较器

public class CollectionsDemo3 {
    public static void main(String[] args){
        orderDemo();
    }
    public static void orderDemo(){
        TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());
        ts.add("abcde");
        ts.add("aaa");
        ts.add("kkk");
        ts.add("ccc");
        Iterator<String> it = ts.iterator(); 
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

1. 强行逆转一个已有比较器

public class CollectionsDemo3 {
    public static void main(String[] args){
        orderDemo();
    }
    public static void orderDemo(){
        TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));
        ts.add("abcd");
        ts.add("abc");
        ts.add("a");
        ts.add("ab");
        Iterator<String> it = ts.iterator(); 
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}
class StrLenComparator 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);
    }
}

Collections——SynList

//将集合中的角标对应的值互换
Collections.swap(list, 1, 2);
//随机排列集合中的元素(模拟洗牌动作、掷骰子动作)
Collections.shuffle(list);
Arrays
用于操作数组的工具类
asList：将数组变成List集合
如果数组中的元素都是对象，那么变成集合是，数组中的元素就直接转成集合中的元素
如果数组中的元素都是基本数据类型，那么会将该数据作为集合中的元素存在

public class ArraysDemo {
    public static void main(String[] args){
        String[] arr = {"abc", "cc", "kkkk"};
        /*
         * 把数组变成List集合的好处
         * 可以使用集合的思量和方法来操作数据中的元素
         */
        List<String> list = Arrays.asList(arr);
        sop(list.contains("cc"));
        /*
         * list.add("qq");
         * 抛出：UnsupportedOperationException
         * 强数组变成集合，不能使用集合的增删方法，因为数组的长度是固定的
         * 如果增删，会抛出不支持操作异常
         */
        sop(list);
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

增强for循环

for(数据类型 变量名： 被遍历的集合(Collection)或者数据){
**;
}
//增强for循环的局限性，只能取出不能修改值

public class ForEachDemo { 
    public static void main(String[] args){
        ArrayList<String> al = new ArrayList<String>();
        al.add("abc1");
        al.add("abc2");
        al.add("abc3");
        Iterator<String> it = al.iterator();

        for(String temp: al){
            System.out.println(temp);
        }
    }
}

//传统for循环和高级for循环的区别
高级for有一个局限性，必须有一个被遍历的目标
在遍历数组的时候，还是使用传统for，因为传统for可以指定脚标

可变参数

在使用可变参数新特性的时候要注意，可变参数要定义在参数列表的最后面

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

public class ParamMethodDemo {
    public static void main(String[] args){
        //show(3,4);    
        /*
        int[] arr1 = {3, 4};
        show(arr1);
        int[] arr2 = {3, 4, 5};
        show(arr2);
        */  
        //可变参数，是上一种数组参数的简写形式，不用每一次都手动的简历数组对象
        //只要将要操作的元素作为参数传递即可，隐式将这些参数封装成了数组
        show(2,3,4,5,7,6);
    }
    /*
    public static void show(int a, int b){
        System.out.println(a + "::" + b);
    }
    public static void show(int a, int b, int c){
        System.out.println(a + "::" + b + "::" + c);
    }
    */
    //新特性虽然少定义了多个方法，但是每次都要定义一个数组作为实际参数  
    /*
    public static void show(int[] arr){
        System.out.println(arr);
    }
    */
    public static void show(int... arr){
        System.out.println(arr);
    }
}

静态导入

当类名重名时，需要指定具体的包名
当方法重名时，指定具备所属的对象或者类

import java.util.*;
import static java.util.Arrays.*;
import static java.lang.System.*;

public class StaticImport {
    public static void main(String[] args){
        int[] arr = {1, 3, 5};
        //Arrays.sort(arr);未静态导入
                sort(arr);//静态导入
        //int index = Arrays.binarySearch(arr, 1);未静态导入
        int index = binarySearch(arr, 1);//静态导入
        //System.out.println(Arrays.toString(arr));未静态导入
        System.out.println(Arrays.toString(arr));//静态导入，但是不同类中有相同名称的方法
        System.out.println("Index =" + index);
    }
}