Java基础详解之集合框架工具Collections

一、Collections

说明：Collcetions是集合框架中的工具，特点是方法都是静态的。

二、Collections中的常见方法

1，对list进行二分查找：前提该集合一定要有序。
int binarySearch(list,key);//要求list集合中的元素都是Comparable的子类。
int binarySearch(list,key,Comparator);
2，对list集合进行排序。
sort(list);
sort(list,comaprator);
3，对集合取最大值或者最小值。
max(Collection)
max(Collection,comparator)
min(Collection)
min(Collection,comparator)
4，对list集合进行反转。
reverse(list);
5，对比较方式进行强行逆转。
Comparator reverseOrder();
Comparator reverseOrder(Comparator);
6，对list集合中的元素进行位置的置换。
swap(list,x,y);
7，对list集合进行元素的替换。如果被替换的元素不存在，那么原集合不变。
replaceAll(list,old,new);

三、Aarrays：用于对数组操作的工具类

1，binarySearch(int[])
  binarySearch(double[])...
2，sort(int[])
  sort(char[])....
3，toString(int[]).....:将数组变成字符串。
4，copyOf();复制数组。
5，copyOfRange():复制部分数组。
6，equals(int[],int[]);比较两个数组是否相同。

7，List asList(T[]);将数组变成集合。
这样可以通过集合的操作来操作数组中元素，
但是不可以使用增删方法，add，remove。因为数组长度是固定的，会出现UnsupportOperationExcetion。
可以使用的方法：contains，indexOf。。。
如果数组中存入的基本数据类型，那么asList会将数组实体作为集合中的元素。
如果数组中的存入的应用数据类型，那么asList会将数组中的元素作为集合中的元素。

如果想要将集合变数组：
可以使用Collection中的toArray方法。
传入指定的类型数组即可，该数组的长度最好为集合的size。

四、二分查找过程中的默认比较器

// 在二分查找中设定默认的比较器
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class binarySerach {

public static void main(String[] args)
   {
       sortDemo();
   }

public static void sortDemo()
   {
       List<String> list = new ArrayList<String>(); // List集合没有比较方法
       list.add("abcd");
       list.add("aaa");
       list.add("bbb");
       list.add("abcdcdc");
       list.add("z");
       list.add("zz");
       list.add("qq");

sop("原集合为："+list);
       int index = Collections.binarySearch(list,"bbb",new StrLenComparator2());
       sop("自定义比较器的index: "+index);
       int index2 = Collections.binarySearch(list,"abcd");
       sop("不传入比较器index："+index2);

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

class StrLenComparator2 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);
   }
}

五、集合转化为数组

// 集合变数组
// 为什么需要这样做？为了对元素进行限定操作，不需要进行增删。
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;

public class CollectionToArray {
   public static void main(String[] args)
   {
       ArrayList<String> al = new ArrayList<String>();
       al.add("ABC1");
       al.add("ABC2");
       al.add("ABC3");
       al.add("ABC4");
       al.add("ABC5");

System.out.println(al);

String[] arr = al.toArray(new String[al.size()]);  // toArray 方法把集合转换为数组
       System.out.println(Arrays.toString(arr));//打印内容
   }
}

六、增强for循环

// 增强for循环的出现是为了解决总是使用迭代器方法进行元素提取

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class ForEachDemo {
   public static void main(String[] args)
   {
       // 例子一：
       ArrayList<String> al = new ArrayList<String>();
       al.add("ABC1");
       al.add("ABC2");
       al.add("ABC3");
       al.add("ABC4");

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

// 例子二：HashMap的增强for循环，使用entrySet()
       System.out.println("例子二：HashMap的增强for循环,使用entrySet()");
       HashMap<Integer,String> hm = new HashMap<Integer, String>();
       hm.put(1,"Wzy1");
       hm.put(2,"Wzy2");
       hm.put(3,"Wzy3");
       hm.put(4,"Wzy4");

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

// 例子三：HashMap的增强for循环，使用KeySet()
       System.out.println("例子三：HashMap的增强for循环,使用KeySet()");
       Set<Integer> keySet = hm.keySet();
       for(Integer i : keySet)
       {
           System.out.println("Key: "+i+"--- Value："+hm.get(i));
       }
   }
}

七、关于可变参数的方法

一般的，在java中使用重载的方法应对不同的数据对象，让它们都可以使用方法，但是还有一种写法，可以只写一个方法来接收数据，也不需要建立新的对象。

// 例子一：
public class mutilMethod {
   public static void main(String[] args)
   {
       show(1,2,3,4,5);

}
   public static void show(int...a) // 可变参数写法，数组的特殊值放在开头
   {
       System.out.println(a.length);
   }
}

//例子二：数组有特殊的
public class mutilMethod {
   public static void main(String[] args)
   {
       show("字符串",2,3,4,5); // 特殊字符String与int发生组合

}
   public static void show(String c, int...a) // 可变参数写法，数组的特殊值放在开头
   {
       System.out.println(a.length);
   }
}

八、关于reverseOrder函数使用

（1）Collections提供的比较器作为新比较器
（2）强行逆转现有比较器

import java.util.*;

public class reverseOrder {
   public static void main(String[] args)
   {
       sortDemo();
   }

public static void sortDemo()
   {
       TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder()); // 传入reverseOrder()将集合倒序排列
       ts.add("aaa");// 或者手写一个自定义比较器，之后使用reverseOrder()函数强行逆转
       ts.add("abc");
       ts.add("a");
       ts.add("aa");
       ts.add("bbb");
       ts.add("cccc");
       ts.add("ddddd");
       ts.add("eeeeee");

Iterator it = ts.iterator();
       while (it.hasNext())
       {
           sop(it.next());
       }
   }
   public static void sop(Object obj)
   {
       System.out.println(obj);
   }

九、静态类导入

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

public class StaticImport extends Object {

public static void main(String[] args)
   {
       int[] arr = {3,1,5};
       sort(arr); // 去掉了Arrays.
       int index = binarySearch(arr,1);// 去掉了Arrays.
       System.out.println(Arrays.toString(arr)); // 不能去掉Arrays.
       out.println("index = "+index);// 去掉System.
   }
}

来源：https://blog.csdn.net/Wang_Pro/article/details/108147679