黑馬程序員——集合（三）

原創 a982541919 2018-09-05 13:51

　——- 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);
    }
}
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

黑馬程序員——集合（二）

a982541919 2018-09-05 13:51:04

黑馬程序員——集合（一）

a982541919 2018-09-05 13:51:04

黑馬程序員——集合（上）（Collection及子類）

masai158 2018-09-01 09:41:17

黑馬程序員——集合（下）（Map及工具類）

masai158 2018-09-01 09:41:13