黑马程序员-----------JAVA基础---------集合框架工具类

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

集合框架的工具类

1.Collections类

Collections是java集合框架的工具类，没有构造函数，全是静态方法。

1.1.问题一：Collections和Collection有什么区别？

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

它有两个常用的子接口，

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

Set：元素没有索引，不可以重复，无序。

Collections是java集合框架的工具类，没有构造函数，全是静态方法。

提供的方法中有可以对list集合进行排序，二分查找等方法。

因为要提高效率，通常常用的集合都是线程不安全的，

如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。

1.2 Collections中的方法概要：

排序：

返回类型 方法体方法说明

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

static <T> void sort(List<T> list, Comparator<? super T> c)传入一个比较器，用指定比较器比较元素

import java.util.*;

public class CollectionsDemo {

public static void main(String[] args){
methedDemo();
}

public static void methedDemo(){
List<String> list = new ArrayList<String>();

list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");

Collections.sort(list);
System.out.println(list);

}
}

输出：

[aaa, abcd, kkkkk, qq, z, zz]

可以看出，sort方法依照字典顺序进行排序（String），其中必须保证list中的对象具有比较性，即需要实现Comparable接口并覆写compareTo方法，如果传入的对象没有比较性或者比较方式不是所需要的，此时就可以使用带比较器的sort方法。

//自定义一个比较器：
class LenComparator 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);
}
}

System.out.println(list);
//		Collections.sort(list);
Collections.sort(list,new LenComparator());  //把比较器传入sort方法

System.out.println(list);

输出：

[abcd, aaa, zz, kkkkk, qq, z]//排序之前
[z, qq, zz, aaa, abcd, kkkkk]//排序之后

二分查找：（使用二分查找必须先实现排序）

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

static <T> int  binarySearch(List<? extends T> list, T key, Comparator<? super T> c) 传入一个比较器，用指定比较器比较元素，来查找需要的元素。

//排序之前：
public static void methedDemo(){
List<String> list = new ArrayList<String>();

list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");

System.out.println(list);
//	Collections.sort(list);
//		Collections.sort(list,new LenComparator()); //把比较器传入sort方法
int index1 = Collections.binarySearch(list,"aaa");
int index2 = Collections.binarySearch(list,"abcd");
int index3 = Collections.binarySearch(list,"kkkkk");
int index4 = Collections.binarySearch(list,"qq");
System.out.println("index1: " + index1);
System.out.println("index2: " + index2);
System.out.println("index3: " + index3);
System.out.println("index4: " + index4);

输出：

[abcd, aaa, zz, kkkkk, qq, z]
index1: -1
index2: 0
index3: -3
index4: -3

同样的查找在排序之后：

System.out.println(list);
Collections.sort(list);
System.out.println(list);

输出

[abcd, aaa, zz, kkkkk, qq, z]
[aaa, abcd, kkkkk, qq, z, zz]
index1: 0
index2: 1
index3: 2
index4: 3

使用自定义比较器也会出现问题：

System.out.println(list);
//		Collections.sort(list);
Collections.sort(list,new LenComparator()); //把比较器传入sort方法
System.out.println(list);

输出：

[abcd, aaa, zz, kkkkk, qq, z]
[z, qq, zz, aaa, abcd, kkkkk]
index1: -1
index2: -1
index3: -1
index4: -1

如果需要按照自己的比较器进行排序来查找的话，可以重新定义的一个查找方法。使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据列表元素的自然顺序对列表进行升序排序（通过 sort(List) 方法）。

max和min方法：

static T max(Collection<? extends T> coll)  

static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)

static T  min(Collection<? extends T> coll)  

static <T> T  min(Collection<? extends T> coll, Comparator<? super T> comp)

System.out.println("-----默认比较器------------");
System.out.println(list);
Collections.sort(list);
System.out.println(list);
String max1 = Collections.max(list);
System.out.println("max1: " + max1);

System.out.println("-----自定义比较器------------");
Collections.sort(list,new LenComparator());
System.out.println(list);
String max2 = Collections.max(list,new LenComparator());
System.out.println("max2: " + max2);

输出：

-----默认比较器------------
[abcd, aaa, zz, kkkkk, qq, z]
[aaa, abcd, kkkkk, qq, z, zz]
max1: zz
-----自定义比较器------------
[z, qq, zz, aaa, abcd, kkkkk]
max2: kkkkk

reverseOrder方法：

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

public static void main(String[] args){

orderDemo();
}
public static void orderDemo()
{
TreeSet<String> ts = new TreeSet<String>(new LenComparator());

ts.add("abcde");
ts.add("aaa");
ts.add("k");
ts.add("cc");

Iterator it = ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}

}
输出：

<pre name="code" class="java">k
cc
aaa
abcde

//使用reverseOrder方法：

<pre name="code" class="java">{
TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new LenComparator()));
//		TreeSet<String> ts = new TreeSet<String>(new LenComparator());

ts.add("abcde");
ts.add("aaa");
ts.add("k");
ts.add("cc");

Iterator it = ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}

}

输出：

abcde
aaa
cc
k

其他方法：

static void shuffle(List<?> list)
使用默认随机源对指定列表进行置换。

static <T> void fill(List<? super T> list, T obj)使用指定元素替换指定列表中的所有元素。

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

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

public static void methedDemo(){
List<String> list = new ArrayList<String>();

list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
Collections.sort(list);

System.out.println("--------shuffle方法---------");
System.out.println(list);
Collections.shuffle(list);
System.out.println(list);

System.out.println("-------reverse方法---------");
System.out.println(list);
Collections.reverse(list);
System.out.println(list);

System.out.println("------replaceAll方法------------");
System.out.println(list);
Collections.replaceAll(list, "zz", "haha");
System.out.println(list);
System.out.println("------reverseOrder方法----------");

System.out.println("------fill方法------------");
System.out.println(list);
Collections.fill(list, "a");
System.out.println(list);

输出：

--------shuffle方法---------
[aaa, abcd, kkkkk, qq, z, zz]
[qq, abcd, kkkkk, z, zz, aaa]
-------reverse方法---------
[qq, abcd, kkkkk, z, zz, aaa]
[aaa, zz, z, kkkkk, abcd, qq]
------replaceAll方法------------
[aaa, zz, z, kkkkk, abcd, qq]
[aaa, haha, z, kkkkk, abcd, qq]
------reverseOrder方法----------
------fill方法------------
[aaa, haha, z, kkkkk, abcd, qq]
[a, a, a, a, a, a]

2.Arrays:用于操作数组的工具类，拥有（比如排序和搜索）的各种方法。

其中大部分在List都存在，它只是把它封装成了一个全是静态方法的工具类，便于操作数组。

其中asList是将数组变成list集合：

static <T> List<T> asList(T... a)
返回一个受指定数组支持的固定大小的列表。

把数组变成list集合有什么好处？

可以使用集合的思想和方法来操作数组中的元素。

contains()

get()

indexOf()

subList();等等

注意：将数组变成集合，不可以使用集合的增删方法,因为数组的长度是固定。

如果你增删，那么会反生UnsupportedOperationException。

如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。

如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

集合变数组：toArray（）方法：

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

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

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

所以创建一个刚刚好的数组最优。

2,为什么要将集合变数组？

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

public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();

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

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

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

}
}

3.java1.5的三个新特性：高级for循环；静态导入;可变参数。

3.1 高级for循环：（实现Iterable接口的类都可以使用foreach循环）

//格式：
for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)
{

}

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

foreach 和迭代器的区别：

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

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

传统for循环和foreach的区别：

foreach有一个局限性，必须有被遍历的目标。

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

import java.util.*;

public class ForeachDemo
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();

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

for(String s : al)
{
s = "kk"; //改完后打印还是原来数组，foreach不能用于修改；
// System.out.println(s);
}

System.out.println(al);

Iterator<String> it = al.iterator(); //迭代器在书写上比foreach麻烦，但他可以用于修改；

while(it.hasNext())
{
System.out.println(it.next());
}

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

for(int x=0; x<arr.length; x++) //传统for循环可以定义角标。
{
System.out.println(arr[x]);
}
for(int i : arr)
{
System.out.println("i:"+i);
}

//用foreach获取HashMap集合的所有元素。
HashMap<Integer,String> hm = new HashMap<Integer,String>();

hm.put(1,"a");
hm.put(2,"b");
hm.put(3,"c");

Set<Integer> keySet = hm.keySet();
for(Integer i : keySet)
{
System.out.println(i+"::"+hm.get(i));
}

for(Map.Entry<Integer,String> me : hm.entrySet())
{
System.out.println(me.getKey()+"------"+me.getValue());
}

}
}输出：
[abc1, abc2, abc3]
abc1
abc2
abc3
3
5
1
i:3
i:5
i:1
1::a
2::b
3::c
1------a
2------b
3------c3.2 Staticimport   静态导入 

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

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

3.3 可变参数（可变参数一定要定义在函数参数列表最后面）：

一个方法如果有多个不同参数的同名方法：首先想到，可以用重载，每一个参数列表写一个方法；

但重复代码太多，就想到了数组（int[] a）,但数组也有弊端，需要手动生成数组在调用方法，如果把生成参数数组隐藏起来，就变成了可变参数：

可变参数其实就是上一种数组参数的简写形式，不用每一次都手动的建立数组对象。

只要将要操作的元素作为参数传递即可，隐式将这些参数封装成了数组。

public static void main(String[] args){
show("haha",1,2,3,4,5,6);
show("haha",1,2,3,4,5,6,7,8,9,11);

}
public static void show(String str,int... arr)
{
System.out.println(arr.length);
}输出：
6

10