黑马程序员——Java基础——集合框架工具类(Collections类和Arrays类)

------- android培训、java培训、期待与您交流！
----------

个人小结：集合框架工具类中常用的有Collections和Arrays，他们提供了很多封装好的静态方法，专门用于对集合数据的操作，非常方便快捷。

一、Collections

Collections是对集合框架的一个工具类。它的出现给集合操作提供了更多的功能。这个类不需要创建对象，内部提供的都是静态方法。

常见方法：
1、max(Collection<? extends T> coll) ：根据元素的自然顺序，返回给定 collection 的最大元素。

2、max(Collection<? extends T> coll, Comparator<? super T> comp) ： 根据指定比较器产生的顺序，返回给定 collection 的最大元素。

3、binarySearch(List<? extends Comparable<? super T>> list, T key) ： 使用二分搜索法搜索指定列表，以获得指定对象。
4、binarySearch(List<? extends T> list, T key, Comparator<? super T> c) ：使用二分搜索法搜索指定列表，以获得指定对象。
5、fill(List<? super T> list, T obj) ：使用指定元素替换指定列表中的所有元素。
6、replaceAll(List<T> list, T oldVal, T newVal) ：使用另一个值替换列表中出现的所有某一指定值
7、swap(List<?> list, int i, int j) ： 在指定列表的指定位置处交换元素
8、sort(List<T> list) ：根据元素的自然顺序 对指定列表按升序进行排序
9、sort(List<T> list, Comparator<? super T> c) ：根据指定比较器产生的顺序对指定列表进行排序
10、reverse(List<?> list) ：反转指定列表中元素的顺序。
11、reverseOrder() ：返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
12、reverseOrder(Comparator<T> cmp) ：返回一个比较器，它强行逆转指定比较器的顺序。
Collections与Collection的区别：
1、Collection是java.util包下的集合接口，是多种集合结构的根接口。Collection提供了对集合对象进行基本操作的通用接口方法，JDK
不提供此接口的任何直接实现，但它提供更具体的子接口（如 Set和 List）的实现。Collection的意义在于为各种具体的集合对象提供最大化的统一操作方式，如插入、删除、判断一个元素是否其成员、遍历等基本操作。
2、Collections是java.util包下一个类，此类完全由在 collection 上进行操作或返回
collection 的静态方法组成。这些方法可以实现对各类集合对象的搜索,排序,线程安全化等操作。它包含在 collection上操作的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其他内容。

示例：

import java.util.*;
class  CollectionsDemo
{
public static void main(String[] args)
{
//sortDemo();//排序
//maxDemo();//求最大值
binarySearchDemo();//二分查找
}
<span style="white-space:pre">	</span>//<span style="font-family: Arial, Helvetica, sans-serif;">二分查找</span>
public static void binarySearchDemo()
{
List<String> list = new ArrayList<String> ();

list.add("abcd");
list.add("aaaa");
list.add("z");
list.add("kkkkh");
list.add("ggg");
list.add("a");
Collections.sort(list,new StrLenComparator());

sop(list);
//int index  = Collections.binarySearch(list,"ggg");
//sop("index="+index);

//int index2 = halfSearch(list,"ggg");
//sop("index2="+index2);

int index3 = halfSearch2(list,"aaaa",new StrLenComparator());
sop("index3="+index3);

}
<span style="white-space:pre">	</span>//求最大值<span style="white-space:pre">		</span>
public static void maxDemo()
{
List<String> list = new ArrayList<String> ();

list.add("abcd");
list.add("aaaa");
list.add("z");
list.add("kkkkh");
list.add("ggg");
list.add("a");

sop(list);
String max = Collections.max(list/*,new StrLenComparator()*/);
sop("max="+max);
}
<span style="white-space:pre">	</span>//排序
public static void sortDemo()
{
List<String> list = new ArrayList<String> ();

list.add("abcd");
list.add("aaaa");
list.add("z");
list.add("kkkk");
list.add("ggg");
list.add("a");

sop(list);

//Collections.sort(list);
Collections.sort(list,new StrLenComparator());

sop(list);
}
<span style="white-space:pre">	</span>//封装打印功能
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);
}
}

练习：

import java.util.*;
class StrComparator implements Comparator<String>//实现比较器接口
{
public int compare(String s1,String s2)
{
/*
int num = s1.compareTo(s2);
if(num>0)
return -1;
if(num<0)
return 1;
return num;
*/
return s2.compareTo(s1);
}
}
//自定义一个比较字符串长度的比较器
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);

}
}
class CollectionsDemo2
{
public static void main(String[] args)
{
fillDemo();//替换

replaceAllDemo();//<span style="font-family: Arial, Helvetica, sans-serif;">新字符子串替换旧字符子串</span>

orderDemo();//排序
}
<span style="white-space:pre">	</span>//排序
public static void orderDemo()
{
//TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());  //new StrComparator

TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));

ts.add("abcd");
ts.add("aaaa");
ts.add("z");
ts.add("kkkkh");
ts.add("ggg");
ts.add("a");

Iterator it = ts.iterator();

while (it.hasNext())
{
sop(it.next());
}
}
<span style="white-space:pre">	</span>//新字符子串替换旧字符子串
public static void replaceAllDemo()
{
List<String> list = new ArrayList<String> ();

list.add("abcd");
list.add("aaaa");
list.add("z");
list.add("kkkkh");
list.add("ggg");
list.add("a");

sop(list);
Collections.replaceAll(list,"ggg","pp");

Collections.reverse(list);

sop(list);

}
/*
练习。fill方法可以将list集合中所有元素替换成指定元素，
将list集合中部分元素替换成指定元素。
*/
public static void fillDemo()
{
List<String> list = new ArrayList<String> ();

list.add("abcd");
list.add("aaaa");
list.add("z");
list.add("kkkkh");
list.add("ggg");
list.add("a");

sop(list);
Collections.fill(list,"pp");
sop(list);
}
<span style="white-space:pre">	</span>//封装打印功能
public static void sop(Object obj)
{
System.out.println(obj);
}
}

运行结果：



二、Arrays
Arrays是用于操作数组的工具类。里边的方法也全是静态的。
常见方法：
asList方法：将数组转换成list集合。

String[] arr = {"abc","kk","qq"};

List<String> list = Arrays.asList(arr);//将arr数组转成list集合。

将数组转换成集合的好处：可以通过list集合中的方法来操作数组中的元素：isEmpty()、contains、indexOf、set；

注意（局限性）：数组是固定长度，不可以使用集合对象增加或者删除等会改变数组长度的功能方法。比如add、remove、clear。（会报不支持操作异常UnsupportedOperationException）；

如果数组中存储的是引用数据类型，作为集合的元素可以直接用集合方法操作。

如果数组中存储的是基本数据类型，asList会将数组实体作为集合元素存在。
示例：

import java.util.*;
class ArraysDemo
{
public static void main(String[] args)
{
//int[] arr = {2,4,5};

//sop(Arrays.toString(arr));

String [] arrStr = {"abc","cc","kkkk"};

//把数组变成list集合有什么好处？
/*
可以使用集合的思想和方法来操作数组中的元素。
*/
List<String> list =Arrays.asList(arrStr);
//sop("contains:"+list.contains("cc"));
//list.add("qq"); //UnsupportedOperationException,
//sop(list);

int[] nums = {2,4,5};

List<int[]> li = Arrays.asList(nums);

Integer[] in = {3,4,5};

List<Integer> li2 = Arrays.asList(in);

/*
如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接
转成集合中的元素。
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的
元素存在。
*/
sop(li);
sop(li2);
}
public static boolean myContains(String[] arr,String key)
{
for (int x=0; x<arr.length ;x++ )
{
if (arr[x].equals(key))
return true;
}
return false;
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

运行结果：



集合变数组：

用的是Collection接口中的方法：toArray();

注意：
如果给toArray传递的指定类型的数组长度小于了集合的size，那么toArray方法，会自动再创建一个该类型的数据，长度为集合的size。

如果传递的指定的类型的数组的长度大于了集合的size，那么toArray方法，就不会创建新数组，直接使用该数组即可，并将集合中的元素存储到数组中，其他为存储元素的位置默认值null。所以，在传递指定类型数组时，最好的方式就是指定的长度和size相等的数组。

将集合变成数组的好处：为了限定对元素的操作。不需要进行增删了。

示例：

import java.util.*;
class CollectionToArray
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();

al.add("abc1");
al.add("abc2");
al.add("abc3");
<span style="white-space:pre">		</span>//指定长度和size相等的数组
String [] arr = al.toArray(new String[al.size()]);

System.out.println(Arrays.toString(arr));
}
}

运行结果：



三、Jdk5.0新特性：

Collection在jdk1.5以后，有了一个父接口Iterable，这个接口的出现的将iterator方法进行抽取，提高了扩展性。

1、高级for循环：for each语句，for each简化了迭代器。

格式：// 增强for循环括号里写两个参数，第一个是声明一个变量，第二个就是需要迭代的容器

for( 元素类型 变量名 : Collection集合 & 数组 ) { …}

1.1 高级for循环和传统for循环的区别：

高级for循环在使用时，必须要明确被遍历的目标（可以是Collection集合或者数组），在遍历过程中不能对元素进行操作。
如果遍历Collection集合，在遍历过程中还需要对元素进行操作，比如删除，需要使用迭代器。

如果遍历数组，还需要对数组元素进行操作，建议用传统for循环因为可以定义角标通过角标操作元素。如果只为遍历获取，可以简化成高级for循环，它的出现为了简化书写。

1.2 高级for循环可以遍历map集合吗？不可以。但是可以将map转成set后再使用for each语句。

1.3 增强for循环迭代数组：

String [] arr = {"a", "b", "c"};//数组的静态定义方式，只试用于数组首次定义的时候

for(String s : arr) {

System.out.println(s);
}

1.4 单列集合 Collection：

List list = new ArrayList();

list.add("aaa");

// 增强for循环, 没有使用泛型的集合能不能使用增强for循环迭代？能

for(Object obj : list) {

String s = (String) obj;

System.out.println(s);

}

1.5 双列集合 Map：

Map map = new HashMap();

map.put("a", "aaa");

// 传统方式：必须掌握这种方式

Set entrys = map.entrySet(); // 1.获得所有的键值对Entry对象

iter = entrys.iterator(); // 2.迭代出所有的entry

while(iter.hasNext()) {

Map.Entry entry = (Entry) iter.next();

String key = (String) entry.getKey(); // 分别获得key和value

String value = (String) entry.getValue();

System.out.println(key + "=" + value);

}

// 增强for循环迭代：原则上map集合是无法使用增强for循环来迭代的，因为增强for循环只能针对实现了Iterable接口的集合进行迭代；Iterable是jdk5中新定义的接口，就一个方法iterator方法，只有实现了Iterable接口的类，才能保证一定有iterator方法，java有这样的限定是因为增强for循环内部还是用迭代器实现的，而实际上，我们可以通过某种方式来使用增强for循环。

for(Object obj : map.entrySet()) {

Map.Entry entry = (Entry) obj; // obj 依次表示Entry

System.out.println(entry.getKey() + "=" + entry.getValue());

}

1.6 增强for循环注意问题：在使用增强for循环时，不能对元素进行赋值；

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

for(int num : arr) {

num = 0; //不能改变数组的值

}

System.out.println(arr[1]); //2

示例：

import java.util.*;
class ForEachDemo
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();

al.add("abc1");
al.add("abc2");
al.add("abc4");

for (String s : al)
{
s = "kk";
System.out.println(s);
}
//System.out.println(al);
/*
Iterator<String> it = al.iterator();

while (it.hasNext())
{
System.out.println(it.next());
}
*/
//高级for循环对数组的操作
int[] arr = {3,5,1};
for (int i : arr )
{
System.out.println("i:"+i);
}

HashMap<Integer,String> hm = new HashMap<Integer,String>();

hm.put(1,"a");
hm.put(2,"b");
hm.put(3,"c");
//高级for循环对map集合的操作1
Set<Integer> keySet = hm.keySet();
for (Integer i : keySet)
{
System.out.println(i+"::"+hm.get(i));
}
//高级for循环对map集合的操作2
Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();
for (Map.Entry<Integer,String> me : entrySet )
{
System.out.println(me.getKey()+":::"+me.getValue());
}
}
}

运行结果：



2、可变参数（...）：

用到函数的参数上，当要操作的同一个类型元素个数不确定的时候，可是用这个方式，这个参数可以接受任意个数的同一类型的数据。

和以前接收数组不一样的是：

以前定义数组类型，需要先创建一个数组对象，再将这个数组对象作为参数传递给函数。现在，直接将数组中的元素作为参数传递即可。底层其实是将这些元素进行数组的封装，而这个封装动作，是在底层完成的，被隐藏了。所以简化了用户的书写，少了调用者定义数组的动作。

如果在参数列表中使用了可变参数，可变参数必须定义在参数列表结尾(也就是必须是最后一个参数，否则编译会失败。)。

示例：

import java.util.*;
class ParamMethodDemo
{
public static void main(String[] args)
{
//show(3,4);

//虽然少定义了多个方法，
//但是每次都要定义一个数组，作为实际参数。
/*
int[] arr = {3,4};
show(arr);

int[] arr1 = {3,4,5};
show(arr1);
*/
/*
可变参数，其实就是上一种数组参数的简写形式。
不用每次都手动的建立数组对象。只要将操作的元素
作为参数传递即可。
隐式滴将这些参数封装成了数组。
*/
show("haha",2,2,3,4,5,6);
//show(2,2,3,4,5,6,4,5,6,75);

}
public static void show(String str,int... arr)//使用可变参数
{
System.out.println(str);
<span style="white-space:pre">		</span>for(int i : arr)
<span style="white-space:pre">		</span>{
<span style="white-space:pre">			</span>System.out.println(i);
<span style="white-space:pre">		</span>}
}
}

运行结果：



3、静态导入：

就是导入类中的所有静态成员，简化静态成员的书写。

写法：

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

没加static导入的是类，加上static导入的全是某一个类中所以的静态成员。这样写在调用该类的静态方法时可以不用再写类名。如：Arrays.sort(数组);就可以直接写sort(数组);

注意：

当导入的两个类中有同名成员时，需要在成员前加上相应的类名。

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

示例：

import java.util.*;
import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。
import static java.lang.System.*;//导入了System类中所有的静态成员。
class StaticImport  extends Object
{
public static void main(String[] args)
{
int[] arr = {3,1,5};

sort(arr);//省略了Arrays.
int index = binarySearch(arr,1);

/*System.*/out.println(Arrays.toString(arr));//省略了System.
System.out.println("index="+ index);
}
}

运行结果：



------- android培训、java培训、期待与您交流！
----------