java.util.Collections 空集合

Collections.EMPTY_LIST,Collections.emptyList()——返回只读

 

的空LIST 集合

Collections.EMPTY_MAP,Collections.emptyMap()——返回只读

 

的空MAP集合

Collections.EMPTY_SET,Collections.emptySet()返回只读

 

的空SET集合

所谓的空集合指的是没有元素在这些集合中,特别需要主要的是返回的集合都是只读的。以下代码会抛出UnsupportedOperationException异常。

-------------------------------------------------------

Public static void main(String[] args) {
  List children  = Collections.EMPTY_LIST;
  children.add(new HashMap());

}

-------------------------------------------------------

Collections.emptyList(),Collections.emptySet(),Collections.emptyMap()由于支持泛型使用起来会更方便,例如

--------------------------------------------------------------

List s = Collections.emptyList();

---------------------------------------------------------------
单元素集合

Collections中的单元素集合指的是集合只有一个元素而且集合只读。

Collections.singletonList——用来生成只读

 

的单一元素的List

Collections.singletonMap——用来生成只读

 

的单Key和Value组成的Map

Collections.singleton——用来生成只读

 

的单一元素的Set

只读集合

Collections提供了生成几种生成只读集合的方法unmodifiableCollection,unmodifiableList,unmodifiableMap,unmodifiableSet,

unmodifiableSortedMap,unmodifiableSortedSet。这些集合一旦初始化以后就不能修改,任何修改这些集合的方法都会抛出

UnsupportedOperationException异常。

Checked集合(Checked Collections)

Checked集合具有检查插入集合元素类型的特性,例如当我们设定checkedList中元素的类型是String的时候,如果插入起来类型的元素就会抛出

ClassCastExceptions异常,Java5中提供泛型的功能,泛型功能能够在代码编译阶段就约束集合中元素的类型,但有些时候声明的集合可能是raw集合,

编译阶段的类型约束就不起作用了,这个时候Checked集合就能起到约束集合中元素类型的作用。

Collections中提供了以下生成Checked集合的方法

checkedCollection,checkedList,checkedMap,checkedSet,checkedSortedMap,checkedSortedSet

同步集合(Synchronized Collections

Collections的synchronizedXxxxx系列方法顾名思义会返回同步化集合类(SynchronizedMap,

SynchronizedList等等)。这些集合类内部实现都是通过一个mutex(互斥体)来实现对这些集合操作的同步化。

Enumeration接口

从JDK1.0开始Java就提供了Enumeration

接口。Collections中list和enumeration和Enumeration接口相关。

list(Enumeration e) 方法用于有Enumeration接口中产生一个List

———————————————————————————————————————

 public void demonstrateEnumerationToList()  

 {  

    log("===== Demonstrate Collections.list(Enumeration) =====", System.out);  

    final Enumeration properties = System.getProperties().propertyNames();  

    final List propertiesList = Collections.list(properties);  

    log(propertiesList.toString(), System.out);  

 }  

————————————————————————————————————————

enumeration(Collection c) 方法用于基于Collection返回Enumeration。

——————————————————————————————————————

 public void demonstrateCollectionToEnumeration()  

 {  

    log("===== Demonstrate Collections.enumeration(Collection) =====", System.out);  

    final Enumeration books = Collections.enumeration(this.favoriteBooks);  

   while (books.hasMoreElements())  

    {  

       log(books.nextElement().toString(), System.out);  

    }  

————————————————————————————————————————————

 }  

查找替换

fill——使用指定元素替换指定列表中的所有元素。

frequency——返回指定 collection 中等于指定对象的元素数。

indexOfSubList—— 返回指定源列表中第一次出现指定目标列表的起始位置,如果没有出现这样的列表,则返回 -1。

lastIndexOfSubList——返回指定源列表中最后一次出现指定目标列表的起始位置,如果没有出现这样的列表,则返回-1。

max—— 根据元素的自然顺序,返回给定 collection 的最大元素。

min——根据元素的自然顺序 返回给定 collection 的最小元素。

replaceAll——使用另一个值替换列表中出现的所有某一指定值。

集合排序

Collections还提供了集中对集合进行排序的方法。

reverse——对List中的元素倒序排列

shuffle——对List中的元素随即排列,这个方法让我想到了Apple的iPod Shuffle

sort——对List中的元素排序

swap——交换List中某两个指定下标位元素在集合中的位置。

rotate——循环移动。循环移动这个方法让人比较难以理解,下面的例子就会让你一下子就理解这个方法的含义。

——————————————————————————————————————————————————————————————————————

假设 list

 包含  [t, a, n, k, s]

。在调用 Collections.rotate(list, 1)

(或 Collections.rotate(list, -4)

)之后,list

 将包含 [s, t, a, n, k]


——————————————————————————————————————————————————————————————————————

其他方法

binarySearch——使用二进制搜索算法来搜索指定列表,以获得指定对象。

addAll——将所有指定元素添加到指定 collection 中。

copy——将所有元素从一个列表复制到另一个列表。

disjoint——如果两个指定 collection 中没有相同的元素,则返回 true。

nCopies——返回由指定对象的 n 个副本组成的不可变列表。

 

------------------------------------清晰记法

 

1. 描述:

    1.1 概述

    java.util.Collections类包含很多有用的方法,可以使程序员的工作变得更加容易,但是这些方法通常都没有被充分地利用。Javadoc给出Collections类最完整的描述

    例子:

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class CollectionsSort {
public CollectionsSort() {

}

public static void main(String[] args) {
double array[] = {111, 111, 23, 456, 231 };
List list = new ArrayList();
List li = new ArrayList();
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
//list.add(""+array[i]);
}
double arr[] = {111};
for(int j=0;j li.add(new Double(arr[j]));
}
}

    2. 具体操作

    1) 排序(Sort)

    使用sort方法可以根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。此列表内的所有元素都必须是使用指定比较器可相互比较的

double array[] = {112, 111, 23, 456, 231 };
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.sort(list);
for (int i = 0; i < array.length; i++) {
   System.out.println(li.get(i));

//结果:112,111,23,456,231

    2) 混排(Shuffling)

    混排算法所做的正好与 sort 相反: 它打乱在一个 List 中可能有的任何排列的踪迹。也就是说,基于随机源的输入重排该 List, 这样的排列具有相同的可能性(假设随机源是公正的)。这个算法在实现一个碰运气的游戏中是非常有用的。例如,它可被用来混排代表一副牌的 Card 对象的一个 List .另外,在生成测试案例时,它也是十分有用的。

Collections.Shuffling(list)
double array[] = {112, 111, 23, 456, 231 };
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.shuffle(list);
for (int i = 0; i < array.length; i++) {
   System.out.println(li.get(i));
}
//结果:112,111,23,456,231

3) 反转(Reverse)

    使用Reverse方法可以根据元素的自然顺序 对指定列表按降序进行排序。

Collections.reverse(list)
double array[] = {112, 111, 23, 456, 231 };
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections. reverse (list);
for (int i = 0; i < array.length; i++) {
   System.out.println(li.get(i));
}
//结果:231,456,23,111,112

    4) 替换所以的元素(Fill)

    使用指定元素替换指定列表中的所有元素。

String str[] = {"dd","aa","bb","cc","ee"};
for(int j=0;j li.add(new String(str[j]));
}
Collections.fill(li,"aaa");
for (int i = 0; i < li.size(); i++) {
System.out.println("list[" + i + "]=" + li.get(i));

}
//结果:aaa,aaa,aaa,aaa,aaa

    5) 拷贝(Copy)

    用两个参数,一个目标 List 和一个源 List, 将源的元素拷贝到目标,并覆盖它的内容。目标 List 至少与源一样长。如果它更长,则在目标 List 中的剩余元素不受影响。

    Collections.copy(list,li): 后面一个参数是目标列表 ,前一个是源列表

double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
List li = new ArrayList();
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
double arr[] = {1131,333};
String str[] = {"dd","aa","bb","cc","ee"};
for(int j=0;j li.add(new Double(arr[j]));
}
Collections.copy(list,li);
for (int i = 0; i System.out.println("list[" + i + "]=" + list.get(i));
}
//结果:1131,333,23,456,231

    6) 返回Collections中最小元素(min)

    根据指定比较器产生的顺序,返回给定 collection 的最小元素。collection 中的所有元素都必须是通过指定比较器可相互比较的

Collections.min(list)
double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.min(list);
for (int i = 0; i System.out.println("list[" + i + "]=" + list.get(i));
}
//结果:23

7) 返回Collections中最小元素(max)

    根据指定比较器产生的顺序,返回给定 collection 的最大元素。collection 中的所有元素都必须是通过指定比较器可相互比较的

Collections.max(list)
double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.max(list);
for (int i = 0; i System.out.println("list[" + i + "]=" + list.get(i));
}
//结果:456

    8) lastIndexOfSubList

    返回指定源列表中最后一次出现指定目标列表的起始位置

int count = Collections.lastIndexOfSubList(list,li);
double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
List li = new ArrayList();
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
double arr[] = {111};
String str[] = {"dd","aa","bb","cc","ee"};
for(int j=0;j li.add(new Double(arr[j]));
}
Int locations = Collections. lastIndexOfSubList (list,li);
System.out.println(“===”+ locations);
//结果 3

    9) IndexOfSubList

    返回指定源列表中第一次出现指定目标列表的起始位置

int count = Collections.indexOfSubList(list,li);
double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
List li = new ArrayList();
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
double arr[] = {111};
String str[] = {"dd","aa","bb","cc","ee"};
for(int j=0;j li.add(new Double(arr[j]));
}
Int locations = Collections.indexOfSubList(list,li);
System.out.println(“===”+ locations);
//结果 1

    10) Rotate

    根据指定的距离循环移动指定列表中的元素

    Collections.rotate(list,-1);

    如果是负数,则正向移动,正数则方向移动

double array[] = {112, 111, 23, 456, 231 };
List list = new ArrayList();
for (int i = 0; i < array.length; i++) {
list.add(new Double(array[i]));
}
Collections.rotate(list,-1);
for (int i = 0; i System.out.println("list[" + i + "]=" + list.get(i));
}
//结果:111,23,456,231,112

 

 

你可能感兴趣的:(集合,Collections,空集合)