------- android培训、java培训、期待与您交流！ ----------
Utilities中包含了很多工具类，在这里我们有两个涉及集合操作的工具类，Collections和Arrays。它们俩主要实现的是有关集合和数组的一系列繁琐操作（较之以往来说）。
Collections是隶属于Utilities的有关集合操作的工具类。如，实现查找，排序，求最值等。这些操作是Collection类与其自己锁不具备的延伸功能。其中，对集合操作比较重要的是这几个函数，由于这些函数比较有特点，我们这里做一下更详细的介绍：
sort 方法的定义：publicstatic <T extends Comparable<? super T>> void sort(List<T> list)
public static<T> void sort(List<T> list,Comparator<? super T> c)
不难看出，这两个方法对应的就是前文中的两种比较方法，值得一提的是<T extends Comparable<? super T>>，这段话主要是为了保证调用该方法的类型，是可比较的，因为，只有具有可比性，才可以调用第一种方法。
max方法的定义：max(Collection<? extends T> coll)
max(Collection<? extends T> coll, Comparator<? super T> comp)
不难看出，max方法主要和其名字是一样的，那就是返回最大，但是，这里的最大， 如果采用的是第一种方法，那么返回的就是对应单列集合中默认的比较所得的最大值 了。如果我们想要使用我们自己的比较规则来筛选最大值，那我，我们要做的同上面的 一样，就是选择比较器。当然，你也可以回对应的Collection类子类或其元素中去修改 对应的比较方式，但是，那样将严重破坏封装性和软件安全性。
binarySearch方法的定义：
binarySearch(List<? extends Comparable<? super T>> list,T key)
binarySearch(List<? extends T> list,T key, Comparator<? super T> c)
这个方法的作用是使用二分发查找所需要的数据，因此，所对应的作为参数的集合， 也必须有顺序，或者，能够进行排序。甚至说，我们有可能想要我们自己定义的排序规 则来进行，那么，我们就是用第二种元素不具备比较性的方法即可。
fill方法的定义：fill(List<? super T> list,T obj)
用指定的obj来一对一的替换所有list的元素。这里的一对一，指的就是一个list 对象中的元素，对应一个obj替换，而不是指所有元素替换成唯一的一个obj。
replaceAll方法的定义：replaceAll(List<T> list, T oldVal,T newVal)
这个方法的作用，就和我们前面总结的String类中的replace方法是一样的作用。 是用对应的newVal来替换原来list对应对象中的oldVal元素。
reverse方法的定义：reverse(List<?> list)
这个就是简单的反转list。但是会导致list原来的顺序发生改变，于是，我们常用 的是下面这种方法：
reverseOrder() ，能够强行逆转对应元素所实现的comparaTo比较方法的比较顺序；
reverseOrder(Comparator<T> cmp) ，返回的是Comparator类，能够强行将 cmp类 对象的比较规则逆序，然后作为返回值返回，不改变list，也不改变调用的Comparator 类对象
俩者用于初始化List类时，作为比较器放入。
下面，我们用例子来说明一下上述的Collections各个方法的用法：
class UtilitiesTest
{
public static void main(String[] args)
{
ArrayList<String> tl = newArrayList<String>();
testAdd(t1);
sop("t1："+t1);
//排序展示：
Collections.sort(t1);
sop("t1按字典序排序："+t1);
MyComparator comp =MyComparator();
Collections.sort(t1,comp);
sop("t1按长度排序："+t1);
//二分查找展示：
sop("二分查找前的序列："+t1);
sop("查找abc所在位置："Collections.binarySearch(t1,"abc"));
String ser = "bpx";
int m=Collections.binarySearch(t1,ser);
t1.add(-(m+1),ser);
sop("插入"+ser+"后的序列；"+t1);
//reverse、reverseOrder方法的用法：
ArrayList<String> tRev =Collections.reverse(t1);
sop(tRev);
ArrayList<String> t2 = newArrayList<String>(Collections.reverseOrder());
testAdd(t2);
sop("t2："+t2);
MyComparator compRev =Collections.reverseOrder(comp);
ArrayList<String> t3 = newArrayList<String>(compRev);
testAdd(t3);
sop("t3："+t3);
//max方法使用展示
String res = Collections.max(t1);
sop("t3中找最短："+res);
String res_2 =Collections.max(t1,comp);
sop("t1中找最长："+res_2);
//fill、replace方法展示：
Collections.fill(t3,"see");
sop(t3);
Collections.replace(t2,"aa","99");
sop(t2);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void testAdd(List<T>t)
{
t.add("aaa");
t.add("aba");
t.add("abc");
t.add("a");
t.add("eud");
t.add("pdfasfa");
}
}
class MyComparatorimplements Comparator<String>
{
public int compare(String s1,String s2)
{
returns1.length().compareTo(s2.length());
}
}Collections类还有一个重要的作用，就是将非同步类的类型对象，强制转换为一个同步类对象，这样就能够让原本不安全（相对的）但效率高的非同步类型集合，在需要的时候，实现同步、加锁。保证了程序适应性，同时可以提高源代码的安全性。这些方法有：
synchronizedCollection(Collection<T> c) ，返回指定collection 支持的同步collection。
synchronizedList(List<T> list)， 返回指定列表支持的同步（线程安全的）列表。
synchronizedMap(Map<K,V> m) ， 返回由指定映射支持的同步（线程安全的）映射。
synchronizedSet(Set<T> s) ，返回指定set 支持的同步（线程安全的）set。
由于使用方式比较简单，此处就不再赘述了，关键是在使用时，需要明确，是否要用到对应的加锁的线程安全类对象。这个判断的依据，就要根据具体的情况和实际操作，以及经验来进行了。也可以参照前文中曾提到的同步类型判断方法，来进行判断。
Arrays是隶属于Utilities的有关数组操作的工具类。主要功能是实现数组类型数据的一系列拓展操作。比如：binarySearch二分查找、copyOf可加长复制、copyOfRange范围复制、deepEquals深度比较（比较包括了数组内容在内的数组信息）、equals相等检验、fill对应数组内一定长度替换、hashCode返回哈希值、sort局部或者全局数组排序、toString转换字符串形式返回。可以看得出，这些方法都是对原有一些方法的数组加强版。能够实现的功能也变多了，当然，这是对于数组而言的专属方法集。
由于该工具集是专门针对数组类型数据的，所以，对于数组的操作，建议首先考虑该类工具集。
这个工具集中有个比较重要的方法，那就是asList(T... a) 。该方法能构将计算机中的数组类型转化为对应的List集合类。然后，就可以使其能够使用对应集合的特有方法了。我们举个例子：
import java.util.*;
class Array_asList
{
public static void main(String[] args)
{
String[] s ={"aaa","aab","abc"};
List<String> list =Arrays.asList(s); //将数组转为集合
sop(list);
sop(Collections.shuffle(list)); //调用特有集合工具方法
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
上例里面，数组本省是没有shuffle随机排列类的。我们通过转换使其变为集合List类，从而可以使用随机排序方法。
但是，这里我们需要注意的是，将数组通过Arrays。asList强制转换为List类对象后。；该对象是不能够调用集合中的增删操作的，这是因为对应的数组，是没有办法改变长度的。而且，如果强制转换为对应的集合对象的数据，它的原类型为基本数据类型，那么，asList就会把该数组，作为新集合元素，存放到集合里；如果非基本数据类型，则会按含有对象，存对应的集合元素。如下面两个例子，对应的泛型声明可以申略，此处为了说明加上：
List<int[ ]>list = Arrays.asList(i); //将基础数据类型数组转为集合
List<Integer>list = Arrays.asList(I); //将Integer数组转为集合
我们有数组变集合的方法，自然就有集合变数组的方法，这个方法就是对应Collection当中的toArray方法，该方法能够使一般集合类型图ArrayList、LinkedList类对象，转变为对应的数组对象。这样，将集合变为数组，目的是为了对原集合进行操作限定。用法如下：
String[ ] =a.toArray(new String [a.size()+5]); //a为List类及子类对象这样的用法还是比较广泛的，比如，在操作系统中，对文件数目进行固定等。
由于在数组中，定义的函数每次使用参数，如果参数较多，就会显得无比繁琐。jdk1.5版本中为了解决这个问题，采用了新的方法，如下：
class DynamicParameter
{
public static void main(String[] args)
{
show("ads","adff","e");
}
public static void show(String...a)
{
System.out.println(a.length());
}
}
这种方法使用时，可变参数必须定义在参数列表的后面。而定义的参数，都是指向对应类型数组。
静态导入是Jdk1.5版本后新增的一项功能，他能够导入对应包中的所有静态成员，包括静态方法、静态变量。具体用法，我们见下例：
import java.util.*;
import staticjava.util.Arrays.*;
import staticjava.lang.System.*;
class StaticImport
{
public static void main(String[] args)
{
int[] a = {1,2,3,4,5,6};
out.print(binarySearch(a,1,4,2));
//但是，如果反生重名，则需要带上类名：
out.println(Arrays.toString(a));
}
}这种引用，可以简化编程，提高可读性。
------- android培训、java培训、期待与您交流！ ----------
298
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
