黑马程序员——集合（三）

　——- 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<String> al = new ArrayList<String>();
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<String> al = new ArrayList<String>();
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<String> al = new ArrayList<String>();
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<String> 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<String> al = new ArrayList<String>();
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<String> list = new ArrayList<String>();
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<String> list = new ArrayList<String>();
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<String> list = new ArrayList<String>();
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<String> ts = new TreeSet<String>(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<String> ts = new TreeSet<String>(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<String> list = new ArrayList<String>();
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<String> list = new ArrayList<String>();
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> 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<String> al = new ArrayList<String>();
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<String> 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<Integer> 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<String> al = new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
for(String s : al){
print(s);
/*
结果：
abc1
abc2
abc3
*/
}

HashMap<Integer,String> hm = new HashMap<Integer, String>();
hm.put(1, "abc1");
hm.put(3, "abc3");
hm.put(2, "abc2");

//      Iterator<Integer> 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<Map.Entry<Integer, String>> it = hm.entrySet().iterator();
//      while(it.hasNext()){
//          Map.Entry<Integer, String> me = it.next();
//          Integer key = me.getKey();
//          String value = me.getValue();
//          print("Integer = "+key+"...String = "+value);
//      }
//第二种方式
for(Map.Entry<Integer, String> 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;i<arr.length;i++)
System.out.print(arr[i]+" ");
System.out.println();
}

//可变参数数组。这种方式最好，想传多少个数就传多少个数。
public static void function3(int... arr){
for(int i=0;i<arr.length;i++)
System.out.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);
}
}