Java面向对象——集合工具类（Collections）

欢迎光临新长城博客中心

面向对象

集合框架的工具类。

Collections:集合框架的工具类。里面定义的都是静态方法。（相信Java的新手们都知道，如果一个类全都是静态方法的话，那么这个类肯定不能创建对象，也不需要给你提供对象的获取方法，因为静态都是优先于对象存在的）

Collections和Collection有什么区别？

Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。

它有两个常用的子接口，

List：对元素都有定义索引。有序的。可以重复元素。

Set：不可以重复元素。无序。

Collections是集合框架中的一个工具类。该类中的方法都是静态的。
提供的方法中有可以对List集合进行排序，二分查找等方法。
通常常用的集合都是线程不安全的。因为要提高效率。
如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。

Collections：静态方法

static > void

sort(List list)           根据元素的自然顺序 对指定列表按升序进行排序。

 /*

一个学校，每个学校都有学科，班级的名字就是对应的学科。

对每门学科进行自然排序。

*/

import java.util.List;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

public class Test{

public static void main(String[] args){

List<String> list =new ArrayList<String>();

list.add("程序员");

list.add("程序员——云计算");

list.add("程序员——android");

list.add("程序员——.Net");

list.add("程序员——iso");

for(Iterator <String>it = list.iterator();it.hasNext();){

sop(it.next());

}

Collections.sort(list);

for(Iterator <String>iter = list.iterator();iter.hasNext();){

sop(iter.next());

}

}

public static void sop(Object obj){

System.out.println(obj);

}

}

Collections：静态方法

static int	binarySearch(List> list, T key)           使用二分搜索法搜索指定列表，以获得指定对象。
static int	binarySearch(List list, T key,Comparator c)           使用二分搜索法搜索指定列表，以获得指定对象。

一个是按照Java指定的比较器进来二分查找，一个是自己指定比较器对集合进行二分查找。

这种思想跟我们之前学数组的时候是一样的，二分查找，所以了解了数组的二分查找，再去看看Java的Src源代码，就基本了解了二分查找的算法，建议使用Java默认的二分查找，因为我们写的不一定比它的效率高。

Collections：静态方法 （排序）（自动反转比较器）（自定义反转比较器）

static void

sort(List list,Comparator c)           根据指定比较器产生的顺序对指定列表进行排序。

static void

sort(List list,Comparator c)           根据指定比较器产生的顺序对指定列表进行排序。

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

 /*

一个学校，每个学校都有学科，班级的名字就是对应的学科。

对每门学科进行长度排序。从短到长，从长到短。

这时候就可以使用Collections里面的sort方法，并指定比较器进去。

也可以在构造器里面直接比较器进行反转。

*/

import java.util.List;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

import java.util.Comparator;

public class Test{

public static void main(String[] args){

List<String> list = new ArrayList<String>();

list.add("程序员");

list.add("程序员——云计算");

list.add("程序员——android");

list.add("程序员——.Net");

list.add("程序员——iso");

sop("原集合");

for(Iterator <String>it = list.iterator();it.hasNext();){

sop(it.next());

}

sop("排序后的集合");

Collections.sort(list,new Comparator(){

public int compare(Object obj1,Object obj2){

String s1 =  (String)obj1;

String s2 =  (String)obj2;

int len = s1.length()-s2.length();

if(len==0)

return s1.compareTo(s2);

return len;

}

});

for(Iterator <String>iter = list.iterator();iter.hasNext();){

sop(iter.next());

}

sop("排序后再逆转的集合");

Collections.sort(list,Collections.reverseOrder(new Comparator(){

public int compare(Object obj1,Object obj2){

String s1 =  (String)obj1;

String s2 =  (String)obj2;

int len = s1.length()-s2.length();

if(len==0)

return s1.compareTo(s2);

return len;

}

}));

for(Iterator <String>iter = list.iterator();iter.hasNext();){

sop(iter.next());

}

}

public static void sop(Object obj){

System.out.println(obj);

}

}

Collections：静态方法

static void

swap(List list, int i, int j)           在指定列表的指定位置处交换元素。

/*

对List集合的俩个元素进行互换。

并获取集合中元素的最值。

*/

import java.util.List;

import java.util.ArrayList;

import java.util.Collections;

public class Test{

public static void main(String[] args){

List<Integer>list = new ArrayList<Integer>();

list.add(7);

list.add(1);

list.add(8);

list.add(5);

//打印原集合。

sop(list);

Collections.swap(list,list.indexOf(5),list.indexOf(7));

//打印新集合。

sop(list);

sop("最大值："+Collections.max(list));

sop("最小值："+Collections.min(list));

}

public static void sop(Object obj){

System.out.println(obj);

}

}

Collections：静态方法

static void

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

static void

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

static boolean

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

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

注意：此方法是替换集合所有元素的值。

import java.util.List;

import java.util.ArrayList;

import java.util.Collections;

public class Test{

public static void main(String[] args){

List<Integer>list = new ArrayList<Integer>();

list.add(7);

list.add(1);

list.add(8);

list.add(5);

sop("原集合："+list);

Collections.shuffle(list);

sop("随机集合："+list);

Collections.reverse(list);

sop("反转后的集合"+list);

Collections.replaceAll(list,1,2);

//打印出现值被替换后的集合

sop("替换出现值的集合："+list);

Collections.fill(list,0);

//打印新集合。

sop("统一集合值的集合："+list);

}

public static void sop(Object obj){

System.out.println(obj);

}

}

同步集合：貌似同步Set集合和同步Map还可以对集合进行有序的排序。

static Collection	synchronizedCollection(Collection c)           返回指定 collection 支持的同步（线程安全的）collection。
static List	synchronizedList(List list)           返回指定列表支持的同步（线程安全的）列表。
static Map	synchronizedMap(Map m)           返回由指定映射支持的同步（线程安全的）映射。
static Set	synchronizedSet(Set s)           返回指定 set 支持的同步（线程安全的）set。
static SortedMap	synchronizedSortedMap(SortedMap m)           返回指定有序映射支持的同步（线程安全的）有序映射。
static SortedSet	synchronizedSortedSet(SortedSet s)           返回指定有序 set 支持的同步（线程安全的）有序 set。

Arrays：用于操作数组的工具类，里面都是静态方法。

static List	asList(T... a)           返回一个受指定数组支持的固定大小的列表。
static int	binarySearch(byte[] a, byte key)           使用二分搜索法来搜索指定的 byte 型数组，以获得指定的值。

static boolean[]

copyOf(boolean[] original, int newLength)           复制指定的数组，截取或用 false 填充（如有必要），以使副本具有指定的长度。

static boolean[]

copyOfRange(boolean[] original, int from, int to)           将指定数组的指定范围复制到一个新数组。

static void

sort(byte[] a)           对指定的 byte 型数组按数字升序进行排序。

static String

toString(boolean[] a)           返回指定数组内容的字符串表示形式。

数组变成集合（Arrays）

import java.util.Arrays;

import java.util.List;

public class Test{

public static void main(String[] args){

String str [] = {"程序员","CSDN","论坛"};

List<String>list =Arrays.asList(str);

sop(list);

//list.add("新长城");会发生异常。

int arr[] = {1,2,3,4};

List <Integer> list =Arrays.asList(arr);

sop(list);//打印的是哈希值,因为集合把数组中基本数据类型的元素都是当成一个数组存在。

}

public static void sop(Object obj){

System.out.println(obj);

}

}

将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的，如果你增删了，会发生不支持操作异常。

如果数组中的元素，都是都像，变成集合时，数组中的元素就直接转换成集合中的元素
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

集合变成数组

当我们不希望调用者对我们的集合进行操作时，这时候就要把集合变成数组，让操作者不能对其进行基本的操作，但是数组的功能还是可以使用的，比如获取。

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

import java.util.List;

import java.util.ArrayList;

public class Test{

public static void main(String[] args){

List<String>list =new ArrayList<String>();

list.add("程序员");

list.add("CSDN");

list.add("论坛");

Object[] arr = list.toArray();

for(int x=0;x

System.out.print(arr[x]);

}

}

}

指定类型的数组到底要定义多长呢？

当指定类型的数组长度小于了集合的size，那么该方法内部都会创建一个新的数组，长度为集合的size

当指定类型的数组长度大于了集合的size，就不会新创建数组，而是使用传递进来的数组，

所以应该创建一个刚刚好的。

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

为什么要将集合变数组？

为了限定对元素的操作。不需要进行增删。

集合(增强for循环)

1.5JDK的新特性

高级 for 循环（简化书写）
格式：
for(数据类型 变量名 ： 被变量的集合（Collection）或者数组){

}

对集合进行遍历，只能获取集合元素，但是不能对集合进行操作。

迭代器出了遍历，还可以进行remove集合中元素的动作。

如若果使用ListIterator，还可以在遍历过程中对集合进行增删改查动作。

传统for和高级for有什么区别呢？

高级for有一个局限性，必须有便利的目标

建议在遍历数组的时候，还是希望使用传统for，因为传统for可以定义脚标。

import java.util.List;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Map;

import java.util.Set;

public class Test{

public static void main(String[] args){

List<String>list = new ArrayList<String>();

list.add("程序员");

list.add("CSDN");

list.add("论坛");

sop("高级for循环遍历list");

for(String s:list){

sop(s);

}

Map<Integer,String>map = new HashMap<Integer,String>();

map.put(1,"程序员——张三");

map.put(2,"程序员——李四");

map.put(3,"程序员——王五");

map.put(4,"程序员——赵六");

Set< Integer>keySet = map.keySet();

sop("高级for循环遍历第一种获取方式map获取键,用键获取map值");

for(Integer i :keySet){

sop(i+","+map.get(i));

}

Set<Map.Entry<Integer,String>>entrySet = map.entrySet();

sop("高级for循环遍历第二种获取方式map的键和值");

for(Map.Entry<Integer,String> me : entrySet){

sop(me.getKey()+","+me.getValue());

}

}

public static void sop(Object obj){

System.out.println(obj);

}

}

集合(可变参数)

JDK 1.5 版本出现的新特性
方法的可变参数（简化书写）
注意：可变参数一定要定义在函数参数的末尾，另外是三个点不是二个。

比如要调用一个函数，传入的参数格式类型，一样，但是个数不一样，普通方式是重载，很麻烦。

所以应该传入一个数组，但是自己定义一个数组也麻烦，所以Java有了这种函数参数定义方法接收。

public class Test{

public static void main(String... args){

int sum = method(1,2,3,4,5);

int num = method(1,2,3,4,5,6,7,8,9,10);

System.out.println(sum);

System.out.println(num);

}

public static int method(int ...arr){

int sum =0;

for(int i : arr)

sum+=i;

return sum;

}

}

可变数组，其实就是上一种数组参数的简写形式。

不用每一次都手动的建立数组对象，只要将操作的元素作为参数传递即可，

隐式将这些参数封装成数组，可以传入空参数，0长度数组。

集合(静态导入)

JDK 1.5 版本出现的新特性
StaticImport  集合(静态导入) （简化书写）

当类名重名时，需要指定具体的包名。
当方法重名是，指定具备所属的对象或者类。

import static java.util.Arrays.*;//导入Arrays类中的所有静态成员。

public class Test{

public static void main(String... args){

int []arr = {1,7,3,5,2};

for(int i:arr){

System.out.print(i);

}

System.out.println();

sort(arr);//由于该方法是静态的，而Arrays里面的静态成员全部导入进来了，就可以省略类名.调用。

for(int i:arr){

System.out.print(i);

}

}

}