黑马程序员——集合（三）
——- android培训、java培训、期待与您交流！ ———-
集合工具类Collections
常用方法：
static void sort(List) 根据元素的自然顺序 对指定列表按升序进行排序。
static void sort(List, Comparator) 根据指定比较器产生的顺序对指定列表进行排序。
static String max(List); 获取集合中自然顺序的最大值
static String max(List, Comparator); 获取集合中按照比较器排序的最大值
static int binarySearch(List,String); 获取集合中某个元素的角标（前提：集合是有序的）
static boolean replaceAll(List, T oldVal, T newVal);使用另一个值替换列表中出现的所有某一指定值。
static void fill(List, T obj); 使用指定元素替换指定列表中的所有元素
static void reverse(List); 将List集合取反，怎么存入的就怎么反向，此方法接受List集合
static Comparator reverseOrder() 将TreeSet集合或者TreeMap集合中的元素按自然顺序取反，此方法返回一个比较器
static Comparator reverseOrder(Comparator) 将自定义的比较器取反，此方法返回一个比较器
static void swap(List ,int start,int end) 将List集合中的statr和end角标的元素互相交换
static List synchronizedList(List); 将不同步的List传入方法中，返回一个同步的List
static Map synchronizedMap(Map);
static Set synchronizedSet(Set);
static void shuffle(List); 使用默认随机源对指定列表进行置换。
T[] toArray(T[] a) 集合变数组。
代码示例：
/*
* 集合框架的工具类：Collections
*
* 演示
* static void sort(List) 根据元素的自然顺序 对指定列表按升序进行排序。
*/
import java.util.*;
public class Demo {
public static void main(String[] args) {
ArrayList al = new ArrayList();
al.add("aaa");
al.add("abc");
al.add("sdfff");
al.add("qq");
al.add("asdffff");
print(al);//[aaa, abc, sdfff, qq, asdffff]
Collections.sort(al);//使用工具类，对ArrayList集合进行自然顺序排序
print(al);//[aaa, abc, asdffff, qq, sdfff]
}
public static void print(Object obj){
System.out.println(obj);
}
} /*
* 集合框架的工具类：Collections
*
* 演示
* static void sort(List, Comparator) 根据指定比较器产生的顺序对指定列表进行排序。
*
* static void swap(List,int,int) 交换集合中两个元素的位置
*/
import java.util.*;
class StrLengComparator implements Comparator<String>{//定义一个比较器，将字符串的长度进行排序
public int compare(String o1, String o2) {
int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
if(num == 0)
return o1.compareTo(o2);
return num;
}
}
public class Demo {
public static void main(String[] args) {
ArrayList al = new ArrayList();
al.add("aaa");
al.add("abc");
al.add("sdfff");
al.add("qq");
al.add("asdffff");
print(al);//[aaa, abc, sdfff, qq, asdffff]
Collections.sort(al,new StrLengComparator());//使用工具类，将字符串的长度进行排序
print(al);//[qq, aaa, abc, sdfff, asdffff]
Collections.swap(al, 1, 3);//交换集合中两个元素的位置
print(al);//[qq, sdfff, abc, aaa, asdffff]
}
public static void print(Object obj){
System.out.println(obj);
}
} /*
* 集合框架的工具类：Collections
*
* 演示
*
* static String max(List);
* static String max(List, Comparator);
*
* static int binarySearch(List,String);
* binarySearch的原理（了解）
*/
import java.util.*;
//定义一个比较器，将字符串的长度进行排序
class StrLengComparator implements Comparator<String> {
public int compare(String o1, String o2) {
int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
if (num == 0)
return o1.compareTo(o2);
return num;
}
}
public class Demo {
public static void main(String[] args) {
// sort();//演示max(List); 和 max(List, Comparator);
binarySearchDemo();// 演示 binarySearch(List,String);
}
public static void binarySearchDemo() {
ArrayList al = new ArrayList();
al.add("sdfff");
al.add("aaa");
al.add("abc");
al.add("qq");
al.add("asdffff");
print("原来的排序" + al);// 原来的排序[sdfff, aaa, abc, qq, asdffff]
Collections.sort(al, new StrLengComparator());// 将字符串按长度进行排序
print("按长度顺序排序" + al);// 按长度顺序排序[qq, aaa, abc, sdfff, asdffff]
int index = Collections.binarySearch(al, "abc");// 二元搜索"abc"的角标。其实就是折半排序查找角标
print("集合按长度排序后，字符串abc的角标：" + index);// 集合按长度排序后，字符串abc的角标：2
print(myBinarySearch(al, "abc"));// 结果：2。调用自定义的myBinarySearch，结果和binarySearch一样。
}
// binarySearch方法的原理演示（了解就行）
public static int myBinarySearch(List list, String str) {
int start = 0, end = list.size() - 1, mid;
while (start <= end) {
mid = (start + end) / 2;
String s = list.get(mid);
int num = s.compareTo(str);
if (num > 0)
end = mid - 1;
else if (num < 0)
start = mid + 1;
else
return mid;
}
return -start - 1;
}
public static void sort() {
ArrayList al = new ArrayList();
al.add("sdfff");
al.add("aaa");
al.add("abc");
al.add("qq");
al.add("asdffff");
print("原来的顺序" + al);// 原来的顺序[sdfff, aaa, abc, qq, asdffff]
Collections.sort(al);// 将字符串按自然顺序进行排序
print("自然排序后的顺序" + al);// 自然排序后的顺序[aaa, abc, asdffff, qq, sdfff]
String max = Collections.max(al);
print("自然顺序中最大的字符串" + max);// 自然顺序中最大的字符串sdfff
Collections.sort(al, new StrLengComparator());// 将字符串按长度进行排序
print("按长度排序后的顺序" + al);// 按长度排序后的顺序[qq, aaa, abc, sdfff, asdffff]
String max1 = Collections.max(al, new StrLengComparator());
print("最长的字符串" + max1);// 最长的字符串asdffff
}
public static void print(Object obj) {
System.out.println(obj);
}
} /*
* 集合框架的工具类：Collections
*
* 演示
* replaceAll(List, T oldVal, T newVal);使用另一个值替换列表中出现的所有某一指定值。
* fill(List, T obj); 使用指定元素替换指定列表中的所有元素
*/
import java.util.*;
public class Demo {
public static void main(String[] args) {
// function1();
// LianXi();
function2();
}
public static void function2() { // 演示replaceAll
List list = new ArrayList();
list.add("abcd");
list.add("aaa");
list.add("aaa");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
print(list);// [abcd, aaa, aaa, aaa, zz, kkkkk]
Collections.replaceAll(list, "aaa", "qq");// 将集合中所有aaa修改为qq
print(list);// [abcd, qq, qq, qq, zz, kkkkk]
}
public static void function1() {// 演示 fill
List list = new ArrayList();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
print(list);// [abcd, aaa, zz, kkkkk]
Collections.fill(list, "haha");// 将集合中的所有元素替换成指定元素
print(list);// [haha, haha, haha, haha]
}
/*
练习：fill是将所有元素替换成指定元素，现在要求，将部分元素替换成指定元素
*/
public static void LianXi() {
List list = new ArrayList();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
System.out.println("原集合：：" + list);
for (int i = 2; i < 4; i++)
// 将角标为2~3的元素替换成qq
list.set(i, "qq");
System.out.println("替换部分元素的集合" + list);
}
public static void print(Object obj) {
System.out.println(obj);
}
} /*
* 集合框架的工具类：Collections
*
* 演示
* static void reverse(List); 将List集合取反，怎么存入的就怎么反向，此方法接受List集合
* static Comparator reverseOrder() 将TreeSet集合或者TreeMap集合中的元素按自然顺序取反，此方法返回一个比较器
* static Comparator reverseOrder(Comparator) 将自定义的比较器取反，此方法返回一个比较器
*/
import java.util.*;
//定义一个字符串长度比较器，将字符串由短到长输出
class StrLenComparator implements Comparator<String>{
public int compare(String o1, String o2) {
int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
if(num == 0){
return o1.compareTo(o2);
}
return num;
}
}
public class Demo {
public static void main(String[] args) {
myReverseOrderDemo();
// reverseOrderDemo();
// reverseDemo();
}
//将TreeSet集合中按字符串由长到短的顺序排序
public static void myReverseOrderDemo(){
//强制将自定义的比较器取反
TreeSet ts = new TreeSet(Collections.reverseOrder(new StrLenComparator()));
ts.add("abcdefg");
ts.add("aaa");
ts.add("qq");
ts.add("shsdfgsdfg");
print(ts);//[shsdfgsdfg, abcdefg, aaa, qq]
}
//将TreeSet集合中的自然顺序取反
public static void reverseOrderDemo(){
TreeSet ts = new TreeSet(Collections.reverseOrder());
ts.add("abcdefg");
ts.add("aaa");
ts.add("qq");
ts.add("shsdfgsdfg");
print(ts);//[shsdfgsdfg, qq, abcdefg, aaa]
}
//将List集合中的元素取反，怎么存入的就怎么反向取出
public static void reverseDemo(){
List list = new ArrayList();
list.add("abcdefg");
list.add("aaa");
list.add("qq");
list.add("shsdfgsdfg");
print(list);//[abcdefg, aaa, qq, shsdfgsdfg]
Collections.reverse(list);
print(list);//[shsdfgsdfg, qq, aaa, abcdefg]
}
public static void print(Object obj) {
System.out.println(obj);
}
}
/*
* 集合框架的工具类：Collections
*
* 演示
* static void shuffle(List list); 使用默认随机源对指定列表进行置换。
*/
import java.util.*;
public class Demo {
public static void main(String[] args) {
shuffleDemo();
}
public static void shuffleDemo(){
List list = new ArrayList();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("ASDFASD");
list.add("fgsdhgffg");
print(list);//[abcd, aaa, zz, kkkkk, ASDFASD, fgsdhgffg]
Collections.shuffle(list);
print(list);//[abcd, aaa, zz, kkkkk, ASDFASD, fgsdhgffg]。此处每次打印的结果都不一样，是随机排序的
}
public static void print(Object obj) {
System.out.println(obj);
}
}
/*
* 集合变数组。
* Collection接口中的toArray方法
* T[] toArray(T[] a)
* 1，指定类型的数组到底要定义多长呢？
* 当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组，长度为集合的size。
* 当指定类型的数组长度大于了集合的size，就不会新创建数组了。而是使用传递进来的数组。
* 所以创建一个刚刚好的数组最优
*
* 2，为什么要将集合变成数组？
* 为了限定对元素的操作。不需要进行增删的操作。
*/
import java.util.*;
public class Demo {
public static void main(String[] args) {
arraysDemo();
}
public static void arraysDemo(){
ArrayList al = new ArrayList();
al.add("abc1");
al.add("abc2");
al.add("abc3");
String[] arr1 = al.toArray(new String[0]);//指定类型数组长度小于了size，该方法内部会创建一个新的数组，长度为集合的size
String[] arr2 = al.toArray(new String[5]);//指定类型的数组长度大于了集合的size，使用传递进来的数组
String[] arr3 = al.toArray(new String[al.size()]);//指定类型的数组长度等于集合的size。推荐使用这种方式
print(Arrays.toString(arr1));//[abc1, abc2, abc3]
print(Arrays.toString(arr2));//[abc1, abc2, abc3, null, null]
print(Arrays.toString(arr3));//[abc1, abc2, abc3]
}
public static void print(Object obj) {
System.out.println(obj);
}
}
数组工具类Arrays
常用方法：
static List Arrays.asList(T…a) 将某个数组变成List集合
static int binarySearch(int[] ,int key) 查找key在int数组中的位置（前提是排序好的）
static int binarySearch(Object[] ,Object key) 查找对象的位置
static T[] copyOfRange(T[] ,int start ,int end) 将数组中从start开始到end的角标复制给另一个数组
static void sort(int[] a) 对int类型数组升序排序
static String toString(int[] a) 将数组变成字符串
代码示例：
/*
* 将某个数组变成List集合
* static List Arrays.asList(T...a)
*
* 数组工具类：Arrays
*
* 将数组变集合由什么好处呢？
* 可以使用集合的思想和方法来操作集合中的元素
*
* 注意：将数组变成集合，不可以使用集合的增删方法。因为数组的长度是固定的。
* 如果执行了增删方法。那么会发生UnsupportedOperationException:不支持操作异常
*
* 可以使用如下等方法：
* contains、get、indexOf、subList等
*
*/
import java.util.*;
public class Demo {
public static void main(String[] args) {
arraysDemo();
}
public static void arraysDemo(){
String[] arr = {"abc","abcccd","kk"};
List list = Arrays.asList(arr);//将数组变集合
print(list);//输出list集合中的元素。结果：[abc, abcccd, kk]
print(list.contains("abcccd"));//结果：true
print(list.indexOf("abcccd"));//结果：1
//list.add("aaa"); //此方法会出现错误。注意：数组变集合，不可以使用集合的增删方法。因为数组的长度是固定的。
/*
* 如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。
* 如果数组中的元素是基本数据类型。那么会将该数组作为集合中的元素存在。
*/
int[] int_arr = {1,4,6,78,8};
List<int[]> list_int = Arrays.asList(int_arr); //因为直接将数组作为集合的元素存入，所以集合所存入的类型为int[]
print(list_int);//结果：[[I@527c6768]，因为数组是基本数据类型，所以直接将数组作为集合中的元素，打出出数组的哈希码
Integer[] integer_arr = {1,4,6,78,8};//此数组是对象
List int_integer = Arrays.asList(integer_arr);
print(int_integer);//结果：[1, 4, 6, 78, 8]
}
public static void print(Object obj) {
System.out.println(obj);
}
} 高级for循环的使用
代码示例：
/*
* 高级for循环
* 格式：
* for(数据类型 变量名 ： 被遍历的集合(Collection)或者数组)
* {
*
* }
*
* 高级for循环缺点：
* 对集合进行遍历。只能获取元素。但是不能对集合进行操作。
*
* 迭代器除了遍历，还可以对集合中的元素进行remove操作。
* 如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的操作
*
* 传统for和高级for有什么区别？
* 高级for有一个局限性：必须有被遍历的目标。比如：输出100个hello，很明显，用高级for循环不行
*/
import java.util.*;
public class Demo {
public static void main(String[] args) {
forDemo();
}
public static void forDemo(){
ArrayList al = new ArrayList();
al.add("abc1");
al.add("abc2");
al.add("abc3");
for(String s : al){
print(s);
/*
结果：
abc1
abc2
abc3
*/
}
HashMap hm = new HashMap();
hm.put(1, "abc1");
hm.put(3, "abc3");
hm.put(2, "abc2");
// Iterator it = hm.keySet().iterator();
// while(it.hasNext()){
// Integer key = it.next();
// String value = hm.get(key);
// print("Integer = "+key+"...String = "+value);
// }
//第一种方式
for(Integer i : hm.keySet()){
print("key = "+i+"....value = "+hm.get(i));
/*
key = 1....value = abc1
key = 2....value = abc2
key = 3....value = abc3
*/
}
// Iterator> it = hm.entrySet().iterator();
// while(it.hasNext()){
// Map.Entry me = it.next();
// Integer key = me.getKey();
// String value = me.getValue();
// print("Integer = "+key+"...String = "+value);
// }
//第二种方式
for(Map.Entry me : hm.entrySet()){
print("Integer = "+me.getKey()+"...String = "+me.getValue());
/*
Integer = 1...String = abc1
Integer = 2...String = abc2
Integer = 3...String = abc3
*/
}
}
public static void print(Object obj) {
System.out.println(obj);
}
} JDK1.5特性：可变参数
代码示例：
/*
* JDK1.5 版本出现的新特性
*
* 可变参数：
* 实际上是一种数组参数的简写形式。
* 不要用每一次都手动的建立数组对象。
* 只要将要操作的元素作为参数传递即可。
* 隐式将这些参数封装成了数组
*
* 在使用时注意：可变参数一定要定义在参数列表的最后面
*/
import java.util.*;
public class Demo {
public static void main(String[] args) {
int[] arr1 = {1,5,6,8,5};
function2(arr1);//1 5 6 8 5
int[] arr2 = {1,2,3};
function2(arr2);//1 2 3
function3(1,5,6,8,5);//1 5 6 8 5
function3(1,2,3);//1 2 3
}
//如果参数类型都相同，这种方式定义重载太麻烦
//public static void function1(int a){}
//public static void function1(int a,int b){}
//public static void function1(int a,int b,int c){}
//这种方式虽然简化了上面的方式，但是每次都得创建一个数组。还是很麻烦
public static void function2(int[] arr){
for(int i=0;iout.print(arr[i]+" ");
System.out.println();
}
//可变参数数组。这种方式最好，想传多少个数就传多少个数。
public static void function3(int... arr){
for(int i=0;iout.print(arr[i]+" ");
System.out.println();
}
public static void print(Object obj) {
System.out.println(obj);
}
} 静态导入
代码示例：
/*
* 静态导入：
*
* 当类同名时，需要指定具体的包名
* 当方法同名时，指定具备所属的对象或者类
*/
import java.util.*;
import static java.util.Arrays.*;//静态导入，导入的是Arrays类中的所有静态成员
public class Demo {
public static void main(String[] args) {
int[] arr = {1,5,6,3};
// Arrays.sort(arr);//此处太麻烦，每次都得写Arrays
// int index = Arrays.binarySearch(arr,3);//此处太麻烦，每次都得写Arrays
// print(index);// 1
sort(arr);//因为静态导入了Arrays，所以此处不需要写Arrays.sort(arr);
int index = binarySearch(arr,3);//因为静态导入了Arrays，所以此处不需要写Arrays.binarySearch(arr,3);
print(index);// 1
print(Arrays.toString(arr));//[1, 3, 5, 6]
// print(toString());//此处不能执行，因为Object类中也有toString方法，执行toString方法时，不知道调用哪个类中的toString
//所以必须加上类名才可以执行
}
public static void print(Object obj) {
System.out.println(obj);
}
}