Collections
是集合框架的工具类,里面的方法都是静态的。
此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。它包含在 collection 上操作的多态算法,即“包装器”,包装器返回由指定 collection 支持的新 collection,以及少数其他内容。
排序
Collections.sort
默认的情况:
public static void demo_1(){
List<String> list = new ArrayList<String>();
list.add("abcde");
list.add("cba");
list.add("aa");
list.add("zzz");
list.add("cba");
list.add("nbaa");
System.out.println(list);
//对list集合进行指定顺序的排序。
Collections.sort(list);
//对字符串类型来说,是通过自带的比较器进行比较的,也就是按字母顺序
System.out.println(list);
自定义比较器:
现在自定义一个比较器,实现按照字符串的长度来排序:
import java.util.Comparator;
public class ComparatorByLength implements Comparator<String> {
@Override
public int compare(String o1, String o2) {
int temp = o1.length() - o2.length();
return temp==0?o1.compareTo(o2): temp;
}
}
接下来向sort方法中传入这个自定义的比较器:
Collections.sort(list,new ComparatorByLength());
运行结果:
成功实现了按照字符串的长度来排序。
折半
必须要保证元素有序的前提下才能使用折半查找。
Collections.binarySearch
public static void demo_2(){
List<String> list = new ArrayList<String>();
list.add("abcde");
list.add("cba");
list.add("aa");
list.add("zzz");
list.add("cba");
list.add("nbaa");
Collections.sort(list);
System.out.println(list);
int index = Collections.binarySearch(list, "aaa");
System.out.println("index="+index);
以上的例子是查找元素不存在的情况。返回负号就表示没有查到,此时的index为插入点-1(-1是为了保证插入点为0的情况仍为负数)。本例中即为-1-1=-2。
此时将“aaa”添加到集合中再次运行:
同样,也可以给Collections.binarySearch指定比较器。
最值
不要求有序。
public static void demo_2(){
List<String> list = new ArrayList<String>();
list.add("abcde");
list.add("cba");
list.add("aaa");
list.add("aa");
list.add("zzz");
list.add("cba");
list.add("nbaa");
System.out.println(list);
//获取最大值。
String max = Collections.max(list);
System.out.println("max="+max);
同样也可以传入比较器:
String max = Collections.max(list,new ComparatorByLength());
最小值将max改为min即可。
逆序
Collections.reverseOrder()
返回一个比较器,它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
public static void demo_3() {
TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());
ts.add("abc");
ts.add("hahaha");
ts.add("zzz");
ts.add("aa");
ts.add("cba");
System.out.println(ts);
}
这个逆序实现的原理如下:
TreeSet<String> ts = new TreeSet<String>(new Comparator<String>(){
@Override
public int compare(String o1, String o2) {
int temp = o2.compareTo(o1); //將o1与o2的位置替换就实现了逆序
return temp;
}
});
对已经有的比较器进行逆转:
Collections.reverseOrder(比较器)
将上面的例子改动一下:
TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new ComparatorByLength()));
就实现了基于长度的逆序排列。
替换
Collections.replaceAll()
public static void demo_4() {
List<String> list = new ArrayList<String>();
list.add("abcde");
list.add("cba");
list.add("zhangsan");
list.add("zhaoliu");
list.add("xiaoqiang");
System.out.println(list);
Collections.replaceAll(list, "cba", "nba");// 原理:set(indexOf("cba"),"nba");
System.out.println(list);
}
其他方法
Collections.fill()
能将集合中的所有元素初始化一次。
public static void demo_4() {
List<String> list = new ArrayList<String>();
list.add("abcde");
list.add("cba");
list.add("zhangsan");
list.add("zhaoliu");
list.add("xiaoqiang");
System.out.println(list);
Collections.fill(list, "cc");
System.out.println(list);
}
Collections.shuffle()
对集合中的元素乱序排列。
还是用上面的例子:
Collections.shuffle(list);
每次运行结果都是不同的,这体现了随机的特点。
将非同步集合转成同步集合的方法
若想要自己实现,可以这么写:
//给非同步的集合加锁。
class MyCollections{
public static List synList(List list){
return new MyList(list);
}
private class MyList implements List{ //内部类,用来返回一个同步的list
private List list;
private static final Object lock = new Object();//创建一个锁对象
MyList(List list){ //构造函数
this.list = list;
}
public boolean add(Object obj){
synchronized(lock)
{
return list.add(obj);//方法还是用原来的,只不过加上了同步
}
}
public boolean remove(Object obj){
synchronized(lock)
{
return list.remove(obj);
}
}
}
}
List list = new ArrayList();//非同步的。
list = MyCollections.synList(list);//返回一个同步的list.
如果觉得自己实现比较麻烦,那么恭喜你, Collections这个工具类中已经提供了现成的方法:
那就是synchronizedXXX()。
Arrays
集合框架的工具类。里面的方法都是静态的。
此类包含用来操作数组(比如排序和搜索)的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。
除非特别注明,否则如果指定数组引用为 null,则此类中的方法都会抛出 NullPointerException。
常用的方法直接查询API即可:
binarySearch
copyOf
copyOfRange
deepEquals(Object[] a1, Object[] a2)
如果两个指定数组彼此是深层相等 的,则返回 true。
equals
fill
hashCode
sort(升序)
toString
数组->集合 :Arrays.asList( )
重点:List **asList(数组)**将数组转成集合。
好处:其实可以使用集合的方法操作数组中的元素。
public static void demo_1() {
String[] arr = {"abc","haha","xixi"};
boolean b = myContains(arr, "xixi"); //数组的方法
System.out.println("contains:"+b);
List<String> list = Arrays.asList(arr);
boolean b1 = list.contains("xixi");//集合的方法
System.out.println("list contaisn:="+b1);
}
注意:
(1)数组的长度是固定的,所以对于集合的增删方法是不可以使用的
否则会发生UnsupportedOperationException。
list.add("hiahia");//UnsupportedOperationException
(2)
- 如果数组中的元素是对象,那么转成集合时,直接将数组中的元素作为集合中的元素进行集合存储。
- 如果数组中的元素是基本类型数值,那么会将该数组作为集合中的元素进行存储。(此时集合中只有一个数组对象)
public static void demo_2() {
int[] arr = {31,11,51,61};
List<int[]> list = Arrays.asList(arr);
System.out.println(list);
}
集合->数组 :XXX.toArray( )
集合转成数组 使用的就是Collection接口中的toArray方法。
可以对集合中的元素操作的方法进行限定。不允许对其进行增删。
List<String> list = new ArrayList<String>();
list.add("abc1");
list.add("abc2");
list.add("abc3");
/*
* toArray方法需要传入一个指定类型的数组。
* 长度该如何定义呢?
* 如果长度小于集合的size,那么该方法会创建一个同类型并和集合相同size的数组。
* 如果长度大于集合的size,那么该方法就会使用指定的数组,存储集合中的元素,其他位置默认为null。
*
* 所以建议,最后长度就指定为,集合的size。
*/
String[] arr = list.toArray(new String[list.size()]);
System.out.println(Arrays.toString(arr));