黑马程序员——Java要点笔记——工具类Collections&Arrays

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

工具类Collections&Arrays——Collections

day19 13-常用对象API（集合框架-工具类-Collections-常用功能1-排序）

1、类Collections

    此类完全由在Collection上进行操作或返回Collection的静态方法组成。（也就是说这个类里面全是静态方法）

2、Collections集合中常用功能1-排序

（来一个List集合，但你还要排序，就用它）排序就就两个根据——自然排序、比较器

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

3、代码示例，按照自然排序方法，排列List集合中的元素

public classDemo39 {
    public static voidmain(String[] args) {
       List<String>list = new ArrayList<String>();
       list.add("abcde");
       list.add("cba");
       list.add("aa");
       list.add("zzz");
       System.out.println("排序前："+list);
       Collections.sort(list);
       System.out.println("排序后："+list);
    }
}

运行结果：排序前：[abcde, cba, aa, zzz]

排序后：[aa, abcde, cba,zzz]

4、代码示例，按照字符串长度（新建一个比较器），排列List集合中的元素

class ComparatorByLength implementsComparator{
    public intcompare(Object obj1,Object obj2){
       String s1 =(String)obj1;
       String s2 =(String)obj2;
       returns1.length()-s2.length();
    }
}
 
public classDemo39 {
    public static voidmain(String[] args) {
       List<String>list = new ArrayList<String>();
       list.add("abcde");
       list.add("cba");
       list.add("aa");
       list.add("zzz");
       System.out.println("排序前："+list);
       Collections.sort(list,new ComparatorByLength());
       System.out.println("排序后："+list);
    }
}

运行结果：排序前：[abcde, cba, aa, zzz]

排序后：[aa, cba, zzz,abcde]

day19 14-常用对象API（集合框架-工具类-Collections-常用功能2、3-折半查找、最值）

1、Collections集合中常用功能2-折半查找

    要注意，折半查找只能对有序的序列使用。

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)           使用二分搜索法搜索指定列表，以获得指定对象。

2、代码示例1——用二分法去查找无比较根据（既无自然比较，又无比较器）的对象

class Demo{
   
}
public classDemo39 {
    public static voidmain(String[] args) {
       List<Demo> list= new ArrayList<Demo>();
       list.add(newDemo());
       list.add(newDemo());
       list.add(newDemo());
       list.add(newDemo());
       System.out.println(Collections.binarySearch(list,new Demo()));
    }
}

报错：类型不符Exception in thread "main" java.lang.Error:Unresolved compilation problem:

    The methodbinarySearch(List<? extends Comparable<? super T>>, T) in the typeCollections is not applicable for the arguments (List<Demo>, Demo)

 

    at com.itheima.Demo39.main(Demo39.java:25)

3、代码示例2——用二分查找去查找具有自然排序的集合

public classDemo39 {
    public static voidmain(String[] args) {
       List<String>list = new ArrayList<String>();
       list.add("abcde");
       list.add("cba");
       list.add("aa");
       list.add("zzz");
       System.out.println(Collections.binarySearch(list,"bb"));
    }
}

运行结果：-2

其中负号代表没有在该集合中找到。2代表，如果把”bb”插入到“该集合排好序的集合”中，应该放到第2个位置，即2-1号角标处。（为啥不直接用角标？因为角标有0，你返回-0，就废了）

另外由结果可以看出。你不指定比较器，他会先以自然排序为基准。而且不用你先排。

4、代码示例3——用二分查找，并在二分查找方法内传入比较器（按照字符串长度排）

class ComparatorByLength implementsComparator{
    public intcompare(Object obj1,Object obj2){
       String s1 =(String)obj1;
       String s2 = (String)obj2;
       returns1.length()-s2.length();
    }
}
public classDemo39 {
    public static voidmain(String[] args) {
       List<String>list = new ArrayList<String>();
       list.add("abcde");
       list.add("cba");
       list.add("aa");
       list.add("zzz");
       System.out.println(Collections.binarySearch(list,"b",newComparatorByLength()));
    }
}

运行结果：-1

5、Collections集合中常用功能3-元素最值

    同样也是根据自然排序或比较器，得出的最值。

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

6、代码示例1——获取最大值（自然排序）

public classDemo39 {
    public static voidmain(String[] args) {
       List<String> list = newArrayList<String>();
       list.add("abcde");
       list.add("cba");
       list.add("aa");
       list.add("zzz");
       System.out.println(Collections.max(list));
    }
}

运行结果：zzz

7、代码示例2——获取最大值（比较器）

class ComparatorByLength implementsComparator{
    public intcompare(Object obj1,Object obj2){
       String s1 =(String)obj1;
       String s2 = (String)obj2;
       returns1.length()-s2.length();
    }
}
public classDemo39 {
    public static voidmain(String[] args) {
       List<String>list = new ArrayList<String>();
       list.add("abcde");
       list.add("cba");
       list.add("aa");
       list.add("zzz");
       System.out.println(Collections.max(list,newComparatorByLength()));
    }
}

运行结果：abcde

day19 15-常用对象API（集合框架-工具类-Collections-常用功能4、5、6-逆序、逆排、替换）

1、Collections集合中常用功能4-逆序（把List集合中的元素进行个反转）

static void

reverse(List<?> list)           反转指定列表中元素的顺序。

2、代码示例1：

public classDemo39 {
    public static voidmain(String[] args) {
       List<String>list = new ArrayList<String>();
       list.add("abcde");
       list.add("cba");
       list.add("aa");
       list.add("zzz");
       Collections.reverse(list);
       System.out.println(list);
    }
}

运行结果：[zzz, aa, cba,abcde]

3、Collections集合中常用功能5-逆排（这个指的是，把原有的排序方式逆掉）

static <T> Comparator<T>	reverseOrder()           返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
static <T> Comparator<T>	reverseOrder(Comparator<T> cmp)           返回一个比较器，它强行逆转指定比较器的顺序。

4、代码示例1：——逆排“自然排序”

public classDemo39 {
    public static voidmain(String[] args) {
       List<String>list = new ArrayList<String>();
       list.add("abcde");
       list.add("cba");
       list.add("aa");
       list.add("zzz");
       Collections.sort(list,Collections.reverseOrder());
       System.out.println(list);
    }
}

运行结果：[zzz, cba,abcde, aa]

5、代码示例2：逆排“比较器”

class ComparatorByLength implementsComparator{
    public intcompare(Object obj1,Object obj2){
       String s1 = (String)obj1;
       String s2 =(String)obj2;
       returns1.length()-s2.length();
    }
}
public classDemo39 {
    public static voidmain(String[] args) {
       List<String>list = new ArrayList<String>();
       list.add("abcde");
       list.add("cba");
       list.add("aa");
       list.add("zzz");
       System.out.println(list);
       Collections.sort(list,Collections.reverseOrder(newComparatorByLength()));
       System.out.println(list);
    }
}

运行结果：[abcde, cba, zzz, aa]

6、凡是涉及到对象排序的，想逆排序规则都可以用Collections集合里的两个reserveOrder方法。

7、Collections集合中常用功能6-替换

static <T> boolean

replaceAll(List<T> list, T oldVal, T newVal)           使用另一个值替换列表中出现的所有某一指定值。

8、代码示例1

public classDemo39 {
    public static voidmain(String[] args) {
       List<String>list = new ArrayList<String>();
       list.add("abcde");
       list.add("cba");
       list.add("aa");
       list.add("zzz");
       System.out.println(list);
       Collections.replaceAll(list,"cba","nba");
       System.out.println(list);
    }
}

运行结果：[abcde, cba, aa, zzz]

[abcde, nba, aa,zzz]

day19 16-常用对象API（集合框架-工具类-Collections-常用功能7、8、9、10-全部装满、洗牌、集合与枚举的互转、将非同步集合转成同步集合的方法）

1、Collections集合中常用功能7-全部装满（fill：装满）

static <T> void

fill(List<? super T> list, T obj)           使用指定元素替换指定列表中的所有元素。

2、代码示例1：

public classDemo39 {
    public static voidmain(String[] args) {
       List<String>list = new ArrayList<String>();
       list.add("abcde");
       list.add("cba");
       list.add("aa");
       list.add("zzz");
       System.out.println(list);
       Collections.fill(list,"XX");
       System.out.println(list);
    }
}

运行结果：[abcde, cba, aa, zzz]

[XX, XX, XX, XX]

3、Collections集合中常用功能8-洗牌（此方法随机把元素放到集合的任意位置上）

static void	shuffle(List<?> list)           使用默认随机源对指定列表进行置换。
static void	shuffle(List<?> list, Random rnd)           使用指定的随机源对指定列表进行置换

4、代码示例1：

 public static voidmain(String[] args) {
       // TODOAuto-generated method stub
       ArrayList<String>list = new ArrayList<String>();
       list.add("abcde");
       list.add("cba");
       list.add("xxx");
       list.add("qwerty");
       System.out.println(list);
       Collections.shuffle(list);
       System.out.println(list);
    }

运行结果：[abcde, cba, xxx, qwerty]

         [cba, qwerty, abcde, xxx]

5、Collections集合中常用功能9-集合与枚举的互转

static <T> Enumeration<T>	enumeration(Collection<T> c)           返回一个指定 collection 上的枚举
static <T> ArrayList<T>	list(Enumeration<T> e)           返回一个数组列表，它按返回顺序包含指定枚举返回的元素。

6、Collections集合中常用功能10-将非同步集合转成同步集合的方法

static <T> Collection<T>	synchronizedCollection(Collection<T> c)           返回指定 collection 支持的同步（线程安全的）collection。
static <T> List<T>	synchronizedList(List<T> list)           返回指定列表支持的同步（线程安全的）列表。
static <K,V> Map<K,V>	synchronizedMap(Map<K,V> m)           返回由指定映射支持的同步（线程安全的）映射。
static <T> Set<T>	synchronizedSet(Set<T> s)           返回指定 set 支持的同步（线程安全的）set。

    从Collections提供的方法可以看到，Collection、List、Set、Map都可以从非同步的变成同步的。

7、如果我们向手动给非同步的集合加锁，怎么做？（这是原理，需要懂）

class MyCollection
{
    private classMyList implements List{
       private Listlist;
       //定义一个同步锁
       private static finalObject lock = newObject();
       MyList(List list){
           this.list =list;
       }
       public booleanadd(Object obj){
           synchronized(lock){
              return list.add(obj);
           }
       }
       public booleanremove(Object obj){
           synchronized(lock){
              return list.remove(obj);
           }
       }
       ……
       ……
    }
    public static ListsynList(List list){
       return newMyList(list);
    }
}

这样之后，只要在外面List  list = new ArrayList();//非同步的

                    list =MyCollections.synList(list);//返回一个同步的list

工具类Collections&Arrays——Arrays

day19 17-常用对象API（集合框架-工具类-Arrays-方法介绍&常用功能1-把数组变成字符串）

1、java.util

    类Arrays

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

2、Arrays集合中常用功能1-将数组转成字符串

static String	toString(boolean[] a)           返回指定数组内容的字符串表示形式。
static String	toString(byte[] a)           返回指定数组内容的字符串表示形式。
static String	toString(char[] a)           返回指定数组内容的字符串表示形式。
static String	toString(double[] a)           返回指定数组内容的字符串表示形式。
static String	toString(float[] a)           返回指定数组内容的字符串表示形式。
static String	toString(int[] a)           返回指定数组内容的字符串表示形式。
static String	toString(long[] a)           返回指定数组内容的字符串表示形式。
static String	toString(Object[] a)           返回指定数组内容的字符串表示形式。
static String	toString(short[] a)           返回指定数组内容的字符串表示形式。

    由以上这些方法看出，所有类型的数组均可转换成字符串。

3、代码示例1

 public static voidmain(String[] args) {
       // TODOAuto-generated method stub
       int[]array = new int[5];
       for(int i =0;i<array.length;i++){
           array[i] = i;
       }
       System.out.println(Arrays.toString(array));
    }

运行结果：[0, 1, 2, 3, 4]

4、toString方法经典实现（Arrays类中toString方法的源码）这种代码优化方式要学习

 

  public static StringmyToString(int[] arr){
       int iMax= arr.length - 1;
       if(iMax== -1){
           return"[]";
       }
       StringBuilder b = newStringBuilder();
       b.append('[');
       for(int i=0;;i++){
           b.append(a[i]);
           if(i ==iMax){
              returnb.append(']').toString();
           }
           b.append(",");
       }
    }

day19 18-常用对象API（集合框架-工具类-Arrays-常用功能2-把数组变成List集合）

1、Arrays集合中常用功能2-将数组转成List集合

static <T> List<T>

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

2、为什么要将数组转成List集合？因为可以使用集合的方法操作数组。

3、代码示例1：使用数组来查找某个key是否在数组中

public static booleanmyContains(String[] arr,String key){
       for(inti=0;i<arr.length;i++){
           if(key.equals(arr[i])){
              return  true;
           }
       }
       return false;
    }
    public static voidmain(String[] args) {
       // TODOAuto-generated method stub
       String[] arr = {"abc","haha","xixi"};
       System.out.println(myContains(arr,"xixi"));
    }

运行结果：true

4、代码示例2：把数组转成List集合来查找某个key是否在数组中，可见此操作的方便性

<pre name="code" class="java">public static void main(String[] args) {
       // TODOAuto-generated method stub
       String[] arr = {"abc","haha","xixi"};
       List<String>list = Arrays.asList(arr);
       System.out.println(list.contains("xixi"));
    }

运行结果：true

5、把数组转成集合的注意点，2点

    ①、由于数组的长度是固定的，所以对于集合的增删方法是不可以使用的。否则会发生“不支持的操作异常”——UnsupportedOperationException。List中，凡是改长度的方法，全完蛋！

代码示例1：

public static voidmain(String[] args) {
       // TODOAuto-generated method stub
       String[] arr = {"abc","nba","qwe"};
       List list = Arrays.asList(arr);
       list.add("xxx");
    }

报错：Exception in thread "main" java.lang.UnsupportedOperationException

        at java.util.AbstractList.add(AbstractList.java:148)

        at java.util.AbstractList.add(AbstractList.java:108)

        at AwtDemo.AwtDemo15.main(AwtDemo15.java:15)

    ②、如果数组中的元素是对象，那么转成集合时，直接将数组中的元素作为集合中的元素进行存储。如果数组中的元素师几门数据类型，那么会将该数组作为集合中的元素进行存储。

代码示例1：

   

 public static voidmain(String[] args) {
       // TODOAuto-generated method stub
       String[] arr1 = {"abc","nba","qwe"};
       List list1 = Arrays.asList(arr1);
       System.out.println(list1);
      
       int[]arr2 = {1,2,3};
       List list2 = Arrays.asList(arr2);
       System.out.println(list2);
 
       Integer[] arr3 ={4,5,6};
       List list3 = Arrays.asList(arr3);
       System.out.println(list3);
    }

运行结果：[abc, nba, qwe]

         [[I@18b3364]

         [4, 5, 6]

day19 19-常用对象API（集合框架-工具类-Collection接口-toArray方法-把集合变成数组）

 

1、Collection接口（注意不是Collections工具类！）中的toArray方法：

Object[]	toArray()           返回包含此 collection 中所有元素的数组。
<T> T[]	toArray(T[] a)           返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

2、集合转成数组

    使用的就是Collection接口中的toArray方法。好处：是可以对集合中的元素操作方法进行限定，不允许进行增删。（集合本身是支持增删的，你转完后，他就不支持了）。

    举例：我有一堆元素，操作完之后产生了一个集合。我把这集合就返回给你了。你拿到之后，仍然可以对这里增加、删除元素。但我不希望你增删，就要这么做。

3、这两个方法用哪一个呢？

    第一个返回一个Object类型的数组，所有元素都被向上转型了。

    第二个，你给我一个指定类型数组，我就转成该类型数组。所以第二个更靠谱。

4、代码示例1

   public static voidmain(String[] args) {
       // TODOAuto-generated method stub
       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));
    }

    运行结果：[abc1,abc2, abc3]

    我上面写的是newString[2]，怎么出来3个了？

5、集合转成数组的注意事项：toArray方法需要传入一个指定类型的数组，长度如何定义呢？

    ①如果长度小于集合的size，那么该方法会创建一个同类型，并和集合相同size的数组。

    ②如果长度大于集合的size，那么该方法会使用指定的数组，存储集合中的元素，其他位置默认为null。

    所以，建议最后长度就指定为集合的size。

6、所以上例中应该这么写：

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

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

    运行结果仍然是：[abc1,abc2, abc3]