黑马程序员--Java面向对象——集合工具类（Collections）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！

面向对象

集合框架的工具类。

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

Collections和Collection有什么区别？

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

它有两个常用的子接口，

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

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

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

Collections：静态方法

static<T extends Comparable<? super T>> 
voidsort(List<T> 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<T> intbinarySearch(List<? extendsComparable<? super T>> list, T key)
          使用二分搜索法搜索指定列表，以获得指定对象。static<T> intbinarySearch(List<? extends T> list, T key,Comparator<? super T> c)
          使用二分搜索法搜索指定列表，以获得指定对象。

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

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

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

static<T> voidsort(List<T> list,Comparator<? super T> c)
          根据指定比较器产生的顺序对指定列表进行排序。

static<T> voidsort(List<T> list,Comparator<? super T> c)
          根据指定比较器产生的顺序对指定列表进行排序。static<T> Comparator<T>reverseOrder()
          返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。static<T> Comparator<T>reverseOrder(Comparator<T> 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 voidswap(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<T> voidfill(List<? super T> list, T obj)
          使用指定元素替换指定列表中的所有元素。

static voidreverse(List<?> list)
          反转指定列表中元素的顺序。

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

static voidshuffle(List<?> list) 
          使用默认随机源对指定列表进行置换。static voidshuffle(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<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：用于操作数组的工具类，里面都是静态方法。

static<T> List<T>asList(T... a)
          返回一个受指定数组支持的固定大小的列表。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 voidsort(byte[] a)
          对指定的 byte 型数组按数字升序进行排序。

static StringtoString(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> 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<arr.length;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);

}

}

}