黑马程序员——集合（三）

最新推荐文章于 2021-03-01 22:14:58 发布

a982541919

最新推荐文章于 2021-03-01 22:14:58 发布

阅读量473

点赞数

分类专栏：黑马程序员——集合

本文链接：https://blog.csdn.net/a982541919/article/details/46582745

版权

黑马程序员——集合专栏收录该内容

2 篇文章 0 订阅

订阅专栏

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

集合工具类Collections

常用方法：
static void sort(List) 根据元素的自然顺序对指定列表按升序进行排序。
static void sort(List, Comparator) 根据指定比较器产生的顺序对指定列表进行排序。

static String max(List); 获取集合中自然顺序的最大值
static String max(List, Comparator); 获取集合中按照比较器排序的最大值

static int binarySearch(List,String); 获取集合中某个元素的角标（前提：集合是有序的）

static boolean replaceAll(List, T oldVal, T newVal);使用另一个值替换列表中出现的所有某一指定值。
static void fill(List, T obj); 使用指定元素替换指定列表中的所有元素

static void reverse(List); 将List集合取反，怎么存入的就怎么反向，此方法接受List集合
static Comparator reverseOrder() 将TreeSet集合或者TreeMap集合中的元素按自然顺序取反，此方法返回一个比较器
static Comparator reverseOrder(Comparator) 将自定义的比较器取反，此方法返回一个比较器

static void swap(List ,int start,int end) 将List集合中的statr和end角标的元素互相交换

static List synchronizedList(List); 将不同步的List传入方法中，返回一个同步的List
static Map synchronizedMap(Map);
static Set synchronizedSet(Set);

static void shuffle(List); 使用默认随机源对指定列表进行置换。

T[] toArray(T[] a) 集合变数组。

代码示例：

/*
 * 集合框架的工具类：Collections
 *
 * 演示
 *  static void sort(List) 根据元素的自然顺序 对指定列表按升序进行排序。
 */
import java.util.*;
public class Demo {
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<String>();
        al.add("aaa");
        al.add("abc");
        al.add("sdfff");
        al.add("qq");
        al.add("asdffff");

        print(al);//[aaa, abc, sdfff, qq, asdffff]

        Collections.sort(al);//使用工具类，对ArrayList集合进行自然顺序排序

        print(al);//[aaa, abc, asdffff, qq, sdfff]

    }
    public static void print(Object obj){
        System.out.println(obj);
    }
}

/*
 * 集合框架的工具类：Collections
 *
 * 演示
 *  static void sort(List, Comparator) 根据指定比较器产生的顺序对指定列表进行排序。
 *
 *  static void swap(List,int,int)  交换集合中两个元素的位置
 */
import java.util.*;
class StrLengComparator implements Comparator<String>{//定义一个比较器，将字符串的长度进行排序
    public int compare(String o1, String o2) {
        int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
        if(num == 0)
            return o1.compareTo(o2);
        return num;
    }
}
public class Demo {
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<String>();
        al.add("aaa");
        al.add("abc");
        al.add("sdfff");
        al.add("qq");
        al.add("asdffff");

        print(al);//[aaa, abc, sdfff, qq, asdffff]

        Collections.sort(al,new StrLengComparator());//使用工具类，将字符串的长度进行排序

        print(al);//[qq, aaa, abc, sdfff, asdffff]

        Collections.swap(al, 1, 3);//交换集合中两个元素的位置

        print(al);//[qq, sdfff, abc, aaa, asdffff]
    }
    public static void print(Object obj){
        System.out.println(obj);
    }
}

/*
 * 集合框架的工具类：Collections
 * 
 * 演示
 * 
 * static String max(List);
 * static String max(List, Comparator);
 * 
 * static int binarySearch(List,String); 
 * binarySearch的原理（了解）
 */
import java.util.*;

//定义一个比较器，将字符串的长度进行排序
class StrLengComparator implements Comparator<String> {
    public int compare(String o1, String o2) {
        int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
        if (num == 0)
            return o1.compareTo(o2);
        return num;
    }
}

public class Demo {
    public static void main(String[] args) {
        // sort();//演示max(List); 和 max(List, Comparator);
        binarySearchDemo();// 演示 binarySearch(List,String);
    }

    public static void binarySearchDemo() {
        ArrayList<String> al = new ArrayList<String>();
        al.add("sdfff");
        al.add("aaa");
        al.add("abc");
        al.add("qq");
        al.add("asdffff");

        print("原来的排序" + al);// 原来的排序[sdfff, aaa, abc, qq, asdffff]

        Collections.sort(al, new StrLengComparator());// 将字符串按长度进行排序

        print("按长度顺序排序" + al);// 按长度顺序排序[qq, aaa, abc, sdfff, asdffff]

        int index = Collections.binarySearch(al, "abc");// 二元搜索"abc"的角标。其实就是折半排序查找角标

        print("集合按长度排序后，字符串abc的角标：" + index);// 集合按长度排序后，字符串abc的角标：2

        print(myBinarySearch(al, "abc"));// 结果：2。调用自定义的myBinarySearch，结果和binarySearch一样。
    }

    // binarySearch方法的原理演示（了解就行）
    public static int myBinarySearch(List<String> list, String str) {
        int start = 0, end = list.size() - 1, mid;
        while (start <= end) {
            mid = (start + end) / 2;
            String s = list.get(mid);
            int num = s.compareTo(str);
            if (num > 0)
                end = mid - 1;
            else if (num < 0)
                start = mid + 1;
            else
                return mid;
        }
        return -start - 1;
    }

    public static void sort() {
        ArrayList<String> al = new ArrayList<String>();
        al.add("sdfff");
        al.add("aaa");
        al.add("abc");
        al.add("qq");
        al.add("asdffff");

        print("原来的顺序" + al);// 原来的顺序[sdfff, aaa, abc, qq, asdffff]

        Collections.sort(al);// 将字符串按自然顺序进行排序
        print("自然排序后的顺序" + al);// 自然排序后的顺序[aaa, abc, asdffff, qq, sdfff]

        String max = Collections.max(al);
        print("自然顺序中最大的字符串" + max);// 自然顺序中最大的字符串sdfff

        Collections.sort(al, new StrLengComparator());// 将字符串按长度进行排序
        print("按长度排序后的顺序" + al);// 按长度排序后的顺序[qq, aaa, abc, sdfff, asdffff]

        String max1 = Collections.max(al, new StrLengComparator());
        print("最长的字符串" + max1);// 最长的字符串asdffff
    }

    public static void print(Object obj) {
        System.out.println(obj);
    }
}

/*
 * 集合框架的工具类：Collections
 * 
 * 演示
 *  replaceAll(List, T oldVal, T newVal);使用另一个值替换列表中出现的所有某一指定值。
 *  fill(List, T obj);  使用指定元素替换指定列表中的所有元素
 */
import java.util.*;

public class Demo {
    public static void main(String[] args) {
        // function1();
        // LianXi();
         function2();

    }

    public static void function2() { // 演示replaceAll
        List<String> list = new ArrayList<String>();
        list.add("abcd");
        list.add("aaa");
        list.add("aaa");
        list.add("aaa");
        list.add("zz");
        list.add("kkkkk");

        print(list);// [abcd, aaa, aaa, aaa, zz, kkkkk]
        Collections.replaceAll(list, "aaa", "qq");// 将集合中所有aaa修改为qq
        print(list);// [abcd, qq, qq, qq, zz, kkkkk]
    }

    public static void function1() {// 演示 fill
        List<String> list = new ArrayList<String>();
        list.add("abcd");
        list.add("aaa");
        list.add("zz");
        list.add("kkkkk");

        print(list);// [abcd, aaa, zz, kkkkk]
        Collections.fill(list, "haha");// 将集合中的所有元素替换成指定元素
        print(list);// [haha, haha, haha, haha]

    }

    /*
        练习：fill是将所有元素替换成指定元素，现在要求，将部分元素替换成指定元素
     */
    public static void LianXi() {
        List<String> list = new ArrayList<String>();
        list.add("abcd");
        list.add("aaa");
        list.add("zz");
        list.add("kkkkk");

        System.out.println("原集合：：" + list);
        for (int i = 2; i < 4; i++)
            // 将角标为2~3的元素替换成qq
            list.set(i, "qq");
        System.out.println("替换部分元素的集合" + list);
    }

    public static void print(Object obj) {
        System.out.println(obj);
    }
}

/*
 * 集合框架的工具类：Collections
 * 
 * 演示
 *      static void reverse(List);  将List集合取反，怎么存入的就怎么反向，此方法接受List集合
 *      static Comparator reverseOrder() 将TreeSet集合或者TreeMap集合中的元素按自然顺序取反，此方法返回一个比较器
 *      static Comparator reverseOrder(Comparator) 将自定义的比较器取反，此方法返回一个比较器
 */
import java.util.*;
//定义一个字符串长度比较器，将字符串由短到长输出
class StrLenComparator implements Comparator<String>{
    public int compare(String o1, String o2) {
        int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
        if(num == 0){
            return o1.compareTo(o2);
        }
        return num;
    }
}
public class Demo {
    public static void main(String[] args) {
        myReverseOrderDemo();
//      reverseOrderDemo();
//      reverseDemo();
    }

    //将TreeSet集合中按字符串由长到短的顺序排序
    public static void myReverseOrderDemo(){
        //强制将自定义的比较器取反
        TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));
        ts.add("abcdefg");
        ts.add("aaa");
        ts.add("qq");
        ts.add("shsdfgsdfg");
        print(ts);//[shsdfgsdfg, abcdefg, aaa, qq]
    }

    //将TreeSet集合中的自然顺序取反
    public static void reverseOrderDemo(){
        TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());
        ts.add("abcdefg");
        ts.add("aaa");
        ts.add("qq");
        ts.add("shsdfgsdfg");
        print(ts);//[shsdfgsdfg, qq, abcdefg, aaa]
    }
    //将List集合中的元素取反，怎么存入的就怎么反向取出
    public static void reverseDemo(){
        List<String> list = new ArrayList<String>();
        list.add("abcdefg");
        list.add("aaa");
        list.add("qq");
        list.add("shsdfgsdfg");
        print(list);//[abcdefg, aaa, qq, shsdfgsdfg]
        Collections.reverse(list);
        print(list);//[shsdfgsdfg, qq, aaa, abcdefg]


    }

    public static void print(Object obj) {
        System.out.println(obj);
    }
}


/*
 * 集合框架的工具类：Collections
 * 
 * 演示
 *      static void shuffle(List list); 使用默认随机源对指定列表进行置换。
 */
import java.util.*;

public class Demo {
    public static void main(String[] args) {
        shuffleDemo();
    }

    public static void shuffleDemo(){
        List<String> list = new ArrayList<String>();
         list.add("abcd");
         list.add("aaa");
         list.add("zz");
         list.add("kkkkk");
         list.add("ASDFASD");
         list.add("fgsdhgffg");
         print(list);//[abcd, aaa, zz, kkkkk, ASDFASD, fgsdhgffg]
         Collections.shuffle(list);
         print(list);//[abcd, aaa, zz, kkkkk, ASDFASD, fgsdhgffg]。此处每次打印的结果都不一样，是随机排序的
    }
    public static void print(Object obj) {
        System.out.println(obj);
    }
}


/*
 * 集合变数组。
 *      Collection接口中的toArray方法 
 *          <T> T[] toArray(T[] a) 
 *  1，指定类型的数组到底要定义多长呢？
 *       当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组，长度为集合的size。
 *       当指定类型的数组长度大于了集合的size，就不会新创建数组了。而是使用传递进来的数组。
 *      所以创建一个刚刚好的数组最优
 *              
 *  2，为什么要将集合变成数组？
 *       为了限定对元素的操作。不需要进行增删的操作。
 */
import java.util.*;

public class Demo {
    public static void main(String[] args) {
        arraysDemo();
    }

    public static void arraysDemo(){
        ArrayList<String> al = new ArrayList<String>();
        al.add("abc1");
        al.add("abc2");
        al.add("abc3");

        String[] arr1 = al.toArray(new String[0]);//指定类型数组长度小于了size，该方法内部会创建一个新的数组，长度为集合的size
        String[] arr2 = al.toArray(new String[5]);//指定类型的数组长度大于了集合的size，使用传递进来的数组
        String[] arr3 = al.toArray(new String[al.size()]);//指定类型的数组长度等于集合的size。推荐使用这种方式

        print(Arrays.toString(arr1));//[abc1, abc2, abc3]
        print(Arrays.toString(arr2));//[abc1, abc2, abc3, null, null]
        print(Arrays.toString(arr3));//[abc1, abc2, abc3]
    }

    public static void print(Object obj) {
        System.out.println(obj);
    }
}

数组工具类Arrays

常用方法：
static List Arrays.asList(T…a) 将某个数组变成List集合

static int binarySearch(int[] ,int key) 查找key在int数组中的位置（前提是排序好的）
static int binarySearch(Object[] ,Object key) 查找对象的位置

static T[] copyOfRange(T[] ,int start ,int end) 将数组中从start开始到end的角标复制给另一个数组

static void sort(int[] a) 对int类型数组升序排序

static String toString(int[] a) 将数组变成字符串
代码示例：

/*
 * 将某个数组变成List集合
 *      static List Arrays.asList(T...a)    
 * 
 * 数组工具类：Arrays 
 * 
 * 将数组变集合由什么好处呢？
 *      可以使用集合的思想和方法来操作集合中的元素
 * 
 * 注意：将数组变成集合，不可以使用集合的增删方法。因为数组的长度是固定的。
 *      如果执行了增删方法。那么会发生UnsupportedOperationException:不支持操作异常
 * 
 * 可以使用如下等方法：
 *      contains、get、indexOf、subList等
 * 
 */
import java.util.*;

public class Demo {
    public static void main(String[] args) {
        arraysDemo();
    }

    public static void arraysDemo(){
        String[] arr = {"abc","abcccd","kk"};
        List<String> list = Arrays.asList(arr);//将数组变集合
        print(list);//输出list集合中的元素。结果：[abc, abcccd, kk]
        print(list.contains("abcccd"));//结果：true
        print(list.indexOf("abcccd"));//结果：1
        //list.add("aaa"); //此方法会出现错误。注意：数组变集合，不可以使用集合的增删方法。因为数组的长度是固定的。



        /*
         * 如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。
         * 如果数组中的元素是基本数据类型。那么会将该数组作为集合中的元素存在。
         */
        int[] int_arr = {1,4,6,78,8};
        List<int[]> list_int = Arrays.asList(int_arr);  //因为直接将数组作为集合的元素存入，所以集合所存入的类型为int[]
        print(list_int);//结果：[[I@527c6768]，因为数组是基本数据类型，所以直接将数组作为集合中的元素，打出出数组的哈希码

        Integer[] integer_arr = {1,4,6,78,8};//此数组是对象
        List<Integer> int_integer = Arrays.asList(integer_arr);
        print(int_integer);//结果：[1, 4, 6, 78, 8]


    }

    public static void print(Object obj) {
        System.out.println(obj);
    }
}

高级for循环的使用

代码示例：

/*
 * 高级for循环  
 *  格式：
 *      for(数据类型 变量名 ： 被遍历的集合(Collection)或者数组)
 *      {
 * 
 *      }
 * 
 * 高级for循环缺点：
 *      对集合进行遍历。只能获取元素。但是不能对集合进行操作。
 * 
 * 迭代器除了遍历，还可以对集合中的元素进行remove操作。
 * 如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的操作
 * 
 * 传统for和高级for有什么区别？
 *      高级for有一个局限性：必须有被遍历的目标。比如：输出100个hello，很明显，用高级for循环不行
 */
import java.util.*;

public class Demo {
    public static void main(String[] args) {
        forDemo();
    }

    public static void forDemo(){
        ArrayList<String> al = new ArrayList<String>();
        al.add("abc1");
        al.add("abc2");
        al.add("abc3");
        for(String s : al){
            print(s);
            /*
             结果：
                abc1
                abc2
                abc3
             */
        }

        HashMap<Integer,String> hm = new HashMap<Integer, String>();
        hm.put(1, "abc1");
        hm.put(3, "abc3");
        hm.put(2, "abc2");

//      Iterator<Integer> it = hm.keySet().iterator();
//      while(it.hasNext()){
//          Integer key = it.next();
//          String value = hm.get(key);
//          print("Integer = "+key+"...String = "+value);
//      }
        //第一种方式
        for(Integer i : hm.keySet()){
            print("key = "+i+"....value = "+hm.get(i));
            /*
                key = 1....value = abc1
                key = 2....value = abc2
                key = 3....value = abc3
             */
        }
//      Iterator<Map.Entry<Integer, String>> it = hm.entrySet().iterator();
//      while(it.hasNext()){
//          Map.Entry<Integer, String> me = it.next();
//          Integer key = me.getKey();
//          String value = me.getValue();
//          print("Integer = "+key+"...String = "+value);
//      }
        //第二种方式
        for(Map.Entry<Integer, String> me : hm.entrySet()){
            print("Integer = "+me.getKey()+"...String = "+me.getValue());
            /*
                Integer = 1...String = abc1
                Integer = 2...String = abc2
                Integer = 3...String = abc3
             */
        }
    }

    public static void print(Object obj) {
        System.out.println(obj);
    }
}

JDK1.5特性：可变参数

代码示例：

/*
 * JDK1.5 版本出现的新特性
 * 
 * 可变参数：
 *      实际上是一种数组参数的简写形式。
 *      不要用每一次都手动的建立数组对象。
 *      只要将要操作的元素作为参数传递即可。
 *      隐式将这些参数封装成了数组
 * 
 * 在使用时注意：可变参数一定要定义在参数列表的最后面
 */
import java.util.*;

public class Demo {
    public static void main(String[] args) {

        int[] arr1 = {1,5,6,8,5};
        function2(arr1);//1 5 6 8 5 

        int[] arr2 = {1,2,3};
        function2(arr2);//1 2 3


        function3(1,5,6,8,5);//1 5 6 8 5 
        function3(1,2,3);//1 2 3
    }

    //如果参数类型都相同，这种方式定义重载太麻烦
    //public static void function1(int a){}
    //public static void function1(int a,int b){}
    //public static void function1(int a,int b,int c){}

    //这种方式虽然简化了上面的方式，但是每次都得创建一个数组。还是很麻烦
    public static void function2(int[] arr){
        for(int i=0;i<arr.length;i++)
            System.out.print(arr[i]+" ");
        System.out.println();
    }

     //可变参数数组。这种方式最好，想传多少个数就传多少个数。
    public static void function3(int... arr){
        for(int i=0;i<arr.length;i++)
            System.out.print(arr[i]+" ");
        System.out.println();
    }

    public static void print(Object obj) {
        System.out.println(obj);
    }
}

静态导入

代码示例：

/*
 * 静态导入：
 * 
 *      当类同名时，需要指定具体的包名
 *      当方法同名时，指定具备所属的对象或者类
 */
import java.util.*;
import static java.util.Arrays.*;//静态导入，导入的是Arrays类中的所有静态成员
public class Demo {
    public static void main(String[] args) {
        int[] arr = {1,5,6,3};

//      Arrays.sort(arr);//此处太麻烦，每次都得写Arrays
//      int index = Arrays.binarySearch(arr,3);//此处太麻烦，每次都得写Arrays
//      print(index);// 1

        sort(arr);//因为静态导入了Arrays，所以此处不需要写Arrays.sort(arr);
        int index = binarySearch(arr,3);//因为静态导入了Arrays，所以此处不需要写Arrays.binarySearch(arr,3);
        print(index);// 1

        print(Arrays.toString(arr));//[1, 3, 5, 6]

//      print(toString());//此处不能执行，因为Object类中也有toString方法，执行toString方法时，不知道调用哪个类中的toString
                            //所以必须加上类名才可以执行
    }

    public static void print(Object obj) {
        System.out.println(obj);
    }
}