21：Collections——集合框架的工具类
Collections此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。
public class Collections
extends Object此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。它包含在 collection 上操作的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其他内容。
如果为此类的方法所提供的 collection 或类对象为 null，则这些方法都将抛出 NullPointerException
<T extends Comparable<? super T>>
voidsort(List<T> list)
根据元素的自然顺序 对指定列表按升序进行排序。
列表中的所有元素都必须实现 Comparable 接口。
static<T> voidsort(List<T> list, Comparator<? super T> c)
根据指定比较器产生的顺序对指定列表进行排序
package tset1;
import java.util.*;
public class Demo {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add( “1asdf”);
list.add( “2asdfasdf”);
list.add( “43qwer”);
list.add( “3qwerqwer”);
list.add( “3qwerqwer”);
sop(list );
Collections. sort(list, new StrLenComparator());
sop(list );
}
public static void sop(Object obj) {
System. out.println( obj);
}
}
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);
}
}
×××××××××××××××××××××××××××××××××××××××××××××
static<T extends Object & Comparable<? super T>>
Tmax(Collection<? extends T> coll)
根据元素的自然顺序，返回给定 collection 的最大元素。static<T> Tmax(Collection<? extends T> coll, Comparator<? super T> comp)
根据指定比较器产生的顺序，返回给定 collection 的最大元素。static<T extends Object & Comparable<? super T>>
Tmin(Collection<? extends T> coll)
根据元素的自然顺序 返回给定 collection 的最小元素。static<T> Tmin(Collection<? extends T> coll, Comparator<? super T> comp)
根据指定比较器产生的顺序，返回给定 collection 的最小元素。
package tset1;
import java.util.*;
public class Demo {
public static void main(String[] args) {
maxDemo();
}
public static void maxDemo() {
List<String> list = new ArrayList<String>();
list.add( "1asdf");
list.add( "2asdfasdf");
list.add( "43qwer");
list.add( "3qwerqwer");
list.add( "3qwerqwer");
sop(list );
String max = Collections. max(list );
sop(max );
Collections. sort(list );
sop(list );
}
public static void sop(Object obj) {
System. out. println(obj);
}
}
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);
}
}
static<T> intbinarySearch(List<? extends Comparable<? super T>> list, T key)
使用二分搜索法搜索指定列表，以获得指定对象。static<T> intbinarySearch(List<? extends T> list, T key, Comparator<? super T> c)
使用二分搜索法搜索指定列表，以获得指定对象。
首先要求集合是有序的；
用sort方法排序；
如果T不具备比较性，则使用binarySecrch(LIst ,key,Comparator)；其中Comparator为比较器；
××××××××××××××××××××××××××××××××××××××××××××××××××××××××
static<T> voidfill(List<? super T> list, T obj)
使用指定元素替换指定列表中的所有元素。
public class Demo {
public static void main(String[] arge) {
ArrayList<String> al = new ArrayList<String>();
al.add( “csdf”);
al.add( “asdf”);
al.add( “dsdf”);
al.add( “esdf”);
al.add( “ssdf”);
sop(al );
Collections. fill(al, “biao”);
sop(al );
}
public static void sop(Object obj) {
System. out.println( obj);
}
}
结果为：
×××××××××××××××××××××××××××××××××××××××××××××
static<T> booleanreplaceAll(List<T> list, T oldVal, T newVal)
使用另一个值替换列表中出现的所有某一指定值。static voidreverse(List<?> list)
反转指定列表中元素的顺序。static<T> Comparator<T>reverseOrder()
返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。static<T> Comparator<T>reverseOrder(Comparator<T> cmp)
返回一个比较器，它强行逆转指定比较器的顺序。
××××××××××××××××××××××××××××××××××××××××
集合安全：SynList（）；
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。static<K,V> SortedMap<K,V>synchronizedSortedMap(SortedMap<K,V> m)
返回指定有序映射支持的同步（线程安全的）有序映射。static<T> SortedSet<T>synchronizedSortedSet(SortedSet<T> s)
返回指定有序 set 支持的同步（线程安全的）有序 set。
××××××××××××××××××××××××××××××××××××××××
Arrays集合工具类中，操作数组的静态方法；
java.util
类 Arraysjava.lang.Object
java.util.Arrays
public class Arrays
extends Object此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。
除非特别注明，否则如果指定数组引用为 null，则此类中的方法都会抛出 NullPointerException。
static<T> List<T>asList(T… a)
返回一个受指定数组支持的固定大小的列表。
将数组变成集合：可以使用集合的思想和方法来操作数组中的元素。
注意：将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的。如果增删会发生异常；该方法：返回一个受指定数组支持的固定大小的列表。（对返回列表的更改会“直接写”到数组。）
集合变化成数组：
Collection接口中的两个方法：
Object[]toArray()
返回包含此 collection 中所有元素的数组。<T> T[]toArray(T[] a)
返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。
指定类型的数组要定义多长？
当长度小于集合的长度size，那么方法内部会创建一个新的数组，长度为集合的size;
当指定类型的数组长度大于集合的size，就不会新建数组，而是使用传递过来的数组；
所以创建一个刚刚好的数组最优；
将集合变数组原因？
限制对元素的操作。不需增删；
static intbinarySearch(byte[] a, byte key)
使用二分搜索法来搜索指定的 byte 型数组，以获得指定的值。
《该方法重构方法很多》
static boolean[]copyOf(boolean[] original, int newLength)
复制指定的数组，截取或用 false 填充（如有必要），以使副本具有指定的长度。
《重构很多》
static boolean[]copyOfRange(boolean[] original, int from, int to)
将指定数组的指定范围复制到一个新数组。
《重构很多》
static booleandeepEquals(Object[] a1, Object[] a2)
如果两个指定数组彼此是深层相等 的，则返回 true。static intdeepHashCode(Object[] a)
基于指定数组的“深层内容”返回哈希码。static StringdeepToString(Object[] a)
返回指定数组“深层内容”的字符串表示形式。
static booleanequals(boolean[] a, boolean[] a2)
如果两个指定的 boolean 型数组彼此相等，则返回 true。
《重构很多》
static voidfill(boolean[] a, boolean val)
将指定的 boolean 值分配给指定 boolean 型数组的每个元素。
《重构很多》《填充》
static inthashCode(boolean[] a)
基于指定数组的内容返回哈希码。
《重构》
static voidsort(byte[] a)
对指定的 byte 型数组按数字升序进行排序。
《重构》
static StringtoString(boolean[] a)
返回指定数组内容的字符串表示形式。
《重构》