伙伴们，这篇主要介绍集合框架工具类，讲解和分享的主要有2个类，分别是：Collections和Arrays。特点是这两个类里的方法几乎全部都是静态的，好吧，开始吧。
一、Collections类
1、概述
<span style="font-size:14px;">/**
（1）、定义：
Collections是一种集合框架的工具类，其里面定义的都是静态方法。
（2）、Collections和Collection有什么区别？
a、Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。
它有两个常用的子接口，
（a）List：对元素都有定义索引。有序的。可以重复元素。
（b）Set：不可以重复元素。无序。
b、Collections是集合框架中的一个工具类。该类中的方法都是静态的
（a）提供的方法中有可以对list集合进行排序，二分查找等方法。
（b）通常常用的集合都是线程不安全的。因为要提高效率。
（c）如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。
*/</span>2、常见方法
/**
（1）查找
Tmax(Collection<? extends T> coll);//根据集合的自然顺序，获取coll集合中的最大元素
Tmax(Collection<? extends T> coll,Comparator<? super T> comp);//根据指定比较器comp的顺序，获取coll集合中的最大元素
intbinarySearch(Lsit<? extends Comparable<? super T>> list,Tkey);//二分法搜索list集合中的指定对象
（2）替换
voidfill(List<? super T> list, T obj);//将list集合中的全部元素替换成指定对象obj
booleanreplaceAll(List<T> lsit,T oldVal,T newVal);//用newVal替换集合中的oldVal值
void swap(Listlist,int i,int j);/在指定列表的指定位置处交换元素
（3）排序
void shuffle(List<?> list);//使用默认随机源对list集合中的元素进行随机排序
void sort(Lsit<T> list);//根据自然顺序对list集合中的元素进行排序
voidsort(List<T> lsit,Comparator<? super T> c);//根据指定比较器c的排序方式对list集合进行排序
（4）反转
reverse(List<?> list);//反转list集合中元素的顺序
Comparator reverseOrder();//返回一个比较器，强行逆转了实现Comparable接口的对象的自然顺序
（5）同步的集合
List<T>synchronizedList(List<T> list);//返回支持的同步（线程安全的）List集合
Map<K,V>synchronizedList(Map<K,V> m);//返回支持的同步（线程安全的）Map集合
*/3、方法演示练习
/**
需求：使用Collections中的方法fill对List集合中的部分元素进行替换
思路：
1、将List集合中要替换的部分元素取出,并存入另一集合中
2、将原集合中的要替换元素移除
3、用fill将要替换的元素进行替换
4、将取出的部分增加进集合
*/
import java.util.*;
class FillTest
{
public static void main(String[] args)
{
List<String> list = new ArrayList<String>();
list.add("abc");
list.add("ab");
list.add("abcd");
list.add("a");
list.add("abcde");
try
{
fillSome(list,1,5,"shenma");
}
catch (InputException e)
{
System.out.println(e.toString());
}
System.out.println(list);
}
//替换部分元素方法
public static void fillSome(List<String> list,int start,int end,String s)throws InputException
{
if(start>=end)
throw new InputException("没有要替换的元素");//如果输入的end小于或者等于start，则抛出异常
//定义一个新集合
List<String> li=new ArrayList<String>();
//因为每移除一次，后面的元素就会补上，所以这里用y来控制次数
for (int x=start,y=start;y<end ; y++)
{
li.add(list.get(x));//将需要替换的元素增加到新集合
list.remove(x);//移除需要替换的元素
}
Collections.fill(li,s);//替换成需要的元素s
list.addAll(start,li);//将替换的部分增加进原集合
}
}
//自定义异常
class InputException extends Exception
{
InputException(String Massage)
{
super(Massage);
}
} 二、Arrays类
1、概述
/**
Arrays是用于操作数组的工具类，里边的方法也全是静态的，不需要创建对象。
把数组变成List集合的好处：可以使用集合的思想和方法来操作数组中的元素。如：contains，get，indexOf，subList等方法。
*/2、常见方法
/**
（1）Lsit<T> asList(T... a)//将数组转换为集合
注意：
a、将数组转换成集合，不可使用集合的增删方法，因为数组的长度是固定的。如果进行增删操作，则会产生UnsupportedOperationException的编译异常。
b、如果数组中的元素都是对象，则变成集合时，数组中的元素就直接转为集合中的元素。
c、如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
（2）binarySearch()：二分查找方法，fill()：替换方法，sort()：排序方法等
特点：可对数组元素进行相应操作，可以接受除boolean之外的其他各种基本数据类型及有序的引用类型数组的参数，且还可以对指定元素的范围，并可根据指定比较器进行相应的操作。
如：sort(T[]a,Comparator<? super T> c)
fill(int[]a,int from,int to)等
（3）String toString();//可以接收各种数组类型参数，并返回指定数组内容的字符串表现形式。
*/3、方法练习
class ArraysDemo //数组变集合
{
public static void main(String[] args)
{
int[] arr = {2,4,5};
System.out.println(Arrays.toString(arr));//转换为字符串形式
String[] arr = {"abc","cc","kkkk"};//字符串数组
List<String> list = Arrays.asList(arr); //字符串数组转换成集合
sop("contains:"+list.contains("cc"));//判断是否存在"cc"这个元素
Integer[] nums = {2,4,5};
List<Integer> li = Arrays.asList(nums);// 整数数组转换成集合
sop("asList--Integer[]转集合:" + li);
}
//打印方法
public static void sop(Object obj)
{
System.out.println(obj);
}
}4、集合变数组
/**
Collection接口中的toArray方法。
<T> T[]toArray(T[] a);将集合变为指定类型的数组。
（1）指定类型的数组到底要定义多长呢？
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组，所以创建一个刚刚好的数组最优。
（2）为什么要将集合变数组？
为了限定对元素的操作，不需要进行增删了。
*/
class CollectionToArray //集合转变成数组
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
//将集合变为String数组
String[] arr = al.toArray(new String[al.size()]);
//利用Arrays操作数组的方法
System.out.println(Arrays.toString(arr));
}
} 三、小知识点
1、高级for循环
/**
（1）格式
for(数据类型 变量名 : 被遍历的集合（Collection）或数组){执行语句}
（2）说明
a、对集合进行遍历，只能获取集合的元素，但是不能对集合进行操作。
b、迭代器除了遍历外，还可进行remove集合中元素的操作，如果使用ListIterator，还可在遍历过程中，对集合进行增删改查的操作。
（3）传统for循环和高级for循环区别：
高级for循环有局限性，必须有被遍历的目标；而传统for循环有索引，所以建议在遍历数组时，使用传统for循环。
*/示例：
<pre name="code" class="java">class ForEachDemo
{
//打印方法
public static void sop(Object obj)
{
System.out.println(obj);
}
//测试
public static void main(String[] args)
{
//创建集合
ArrayList<String> as = new ArrayList<String>();
as.add("01-a");
as.add("02-b");
as.add("03-c");
System.out.println("原集合" + as);
//增强for循环取出元素
for (String s : as)
{
System.out.println(s);
}
System.out.println("-------------------------");
//创建HashMap集合
HashMap<Integer,String> hm = new HashMap<Integer,String>();
hm.put(1,"a");
hm.put(2,"b");
hm.put(3,"c");
hm.put(4,"d");
System.out.println("hm原集合：" + hm);
//增强for循环的两种方式测试
//keySet方法
sop("keySet方法:|--");
for(Integer i : hm.keySet())
{
sop(i + ":-" + hm.get(i));
}
//entrySet方法
sop("entrySet方法--");
for(Map.Entry<Integer,String> me : hm.entrySet())// Map.Entry也是一种数据类型
{
sop(me.getKey() + "-->" + me.getValue());
}
}
}2、可变参数
<pre name="code" class="java"><span style="font-size:14px;">/**
一个方法在参数列表中传入多个参数，个数不确定，那么每次都要复写该方法。这时可以用数组作为形式参数。但是在传入时，每次都需要定义一个数组对象，作为实际参数。
在JDK1.5版本后，就提供了一个新特性：可变参数。
可变参数其实就是数组参数的简写形式。不用每一次都手动的建立数组对象。只要将要操作的元素作为参数传递即可。隐式将这些参数封装成了数组。
在使用时注意：可变参数一定要定义在参数列表的最后面。
*/</span><pre name="code" class="java">class ParamMethodDemo
{
public static void main(String[] args)
{
show("haha",2,3,4,5,6);
}
public static void show(String str,int... arr)//...就表示可变参数
{
System.out.println(arr.length);
}
}3、静态导入
<pre name="code" class="java">/**
（1）写法
import staticjava.util.Arrays.*;//导入的是Arrays这个类中的所以静态成员。
import staticjava.lang.System.*//导入了Ssytem类中所以静态成员。
没加static导入的是类，加上static导入的全是某一个类中所以的静态成员。这样写在调用该类的静态方法时可以不用再写类名。如：Arrays.sort(数组);就可以直接写sort(数组);
*/<span style="font-size:14px;">import static java.util.Arrays.*;
import static java.lang.System.*;
class StaticImport //extends Object
{
public static void main(String[] args)
{
out.println("haha");//打印输出时就可以直接省略书写System.
int[] arr = {3,1,5};
sort(arr);//使用Arrays工具类的方法sort时就可以省略书写Array.
int index = binarySearch(arr,1);//半分查找也是一样可以省略
out.println("Index="+index);
//当没有指定继承时，所以类默认继承了Object，
//因为toString方法都具备，所以为了区分，必须写上具体调用者
out.println(Arrays.toString(arr));
}
}
/**
注意：
当导入的两个类中有同名成员时，需要在成员前加上相应的类名。
当类名重名时，需要指定具体的包名。当方法重名时，指定具体所属的对象或者类。
*/</span>这篇就到这里了，伙伴们，过瘾了吗？如果没有，ok，next篇，come on！
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
