Collections类常用方法总结 排列组合常用方法总结

此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。它包含在 collection上操作的多态算法,即“包装器”,包装器返回由指定 collection 支持的新 collection,以及少数其他内容

如果为此类的方法所提供的 collection 或类对象为 null,则这些方法都将抛出NullPointerException。

首先定义一个工具类:

public class UtilTools {

publicstatic void printCollection(Collection c){
Iterator it= c.iterator();
Collections类常用方法总结 排列组合常用方法总结
while(it.hasNext()){
Object o = it.next();
System.out.println(o);
}
}

publicstatic void printMap(Map m){
Set<Map.Entry<Object,Object>> me = m.entrySet();
printCollection(me);
}

publicstatic void printMapKey(Map m){
Set me = m.keySet();
printCollection(me);
}

publicstatic void printMapValue(Map m){
Collection me = m.values();
printCollection(me);
}
}

1.addAll(Collection<?super T>c,T...elements)
将所有指定元素添加到指定 collection 中。可以分别指定要添加的元素,或者将它们指定为一个数组。此便捷方法的行为与c.addAll(Arrays.asList(elements))的行为是相同的,但在大多数实现下,此方法运行起来可能要快得多。

eg:

public class CollectionsTest {
publicstatic void main(String[] args) {
List<String> l =new ArrayList<String>();
CollectionsTest.add(l);
String[] s = {"s1","s2"};
Collections.addAll(l, s);
Collections.addAll(l, "a1","a2");
UtilTools.printCollection(l);
}

publicstatic void add(Collection<String>c){
for(char i='a';i<'g';i++){
c.add(String.valueOf(i));
}
}
}

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

eg:

public class CollectionsTest {
publicstatic void main(String[] args) {
List<String> l =new ArrayList<String>();
CollectionsTest.add(l) ;
Collections.sort(l);
UtilTools.printCollection(l);
}

publicstatic void add(Collection<String>c){
for(char i='a';i<'g';i++){
c.add(String.valueOf(i));
}
}
}

3.sort(List<T>list,Comparator<? superT>c)
根据指定比较器产生的顺序对指定列表进行排序。

public class CollectionsTest {
publicstatic void main(String[] args) {
List<String> l =new ArrayList<String>();
CollectionsTest.add(l);
Collections.addAll(l, "S");
Collections.sort(l);
//UtilTools.printCollection(l);
Collections.sort(l,Comparator1.getComparator());
UtilTools.printCollection(l);
}

publicstatic void add(Collection<String> c){
for (char i = 'a'; i < 'g'; i++){
c.add(String.valueOf(i));
}
}
}

class Comparator1 {
publicstatic Comparator getComparator() {
return new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof String&& o2 instanceof String) {
String s1 = ((String)o1).toLowerCase();
String s2 = ((String)o2).toLowerCase();
return s1.compareTo(s2);
}else{
System.err.println("未找到合适的比较器");
return 1;
}
}
};
}
}

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

eg:

public class CollectionsTest {
publicstatic void main(String[] args) {
List<String> l =new ArrayList<String>();
CollectionsTest.add(l);
Collections.addAll(l, "S");
Collections.shuffle(l);
UtilTools.printCollection(l);
}

publicstatic void add(Collection<String> c){
for (char i = 'a'; i < 'g'; i++){
c.add(String.valueOf(i));
}
}
}

4.shuffle(List<?>list,Randomrnd)
使用指定的随机源对指定列表进行置换。同上

5.binarySearch(List<?extends Comparable<? superT>>list,Tkey)
使用二分搜索法搜索指定列表,以获得指定对象。在进行此调用之前,必须根据列表元素的自然顺序对列表进行升序排序(通过sort(List)方法)。如果没有对列表进行排序,则结果是不确定的。如果列表包含多个等于指定对象的元素,则无法保证找到的是哪一个。

binarySearch(List<? extendsT>list, Tkey,Comparator<? superT>c)
使用二分搜索法搜索指定列表,以获得指定对象。在进行此调用之前,必须根据指定的比较器对列表进行升序排序(通过sort(List, Comparator)方法)。如果没有对列表进行排序,则结果是不确定的。如果列表包含多个等于指定对象的元素,则无法保证找到的是哪一个。

eg:public class CollectionsTest {
publicstatic void main(String[] args) {
List<String> l =new ArrayList<String>();
CollectionsTest.add(l);
Collections.addAll(l,"Y","B");
Collections.sort(l,Comparator1.getComparator());
int num =Collections.binarySearch(l,"B",Comparator1.getComparator());
System.out.println(num);
UtilTools.printCollection(l);
}

publicstatic void add(Collection<String> c){
for (char i = 'a'; i < 'g'; i++){
c.add(String.valueOf(i));
}
}
}

class Comparator1 {
publicstatic Comparator getComparator() {
return new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof String&& o2 instanceof String) {
String s1 = ((String)o1).toLowerCase();
String s2 = ((String)o2).toLowerCase();
return s1.compareTo(s2);
}else{
System.err.println("未找到合适的比较器");
return 1;
}
}
};
}
}

注意binarySearch使用比较器的时候,前面的sort也必须使用,如果list里有重复的情况(不分大小写),则结果不确定,看上例查找B和 b的情况都是返回1

6.max(Collection<?extends T>coll)
根据元素的自然顺序,返回给定collection 的最大元素。

max(Collection<? extendsT>coll, Comparator<? superT>comp)
根据指定比较器产生的顺序,返回给定collection 的最大元素。

eg:

public class CollectionsTest {
publicstatic void main(String[] args) {
List<String> l =new ArrayList<String>();
CollectionsTest.add(l);
Collections.addAll(l,"Y","B");
String s =Collections.max(l,Comparator1.getComparator());//有比较器的时候最大为Ya b B c d e f Y

//String s =Collections.max(l);//没有比较器的话最大为fB Y a b c d e f

System.out.println(s);
UtilTools.printCollection(l);
}

publicstatic void add(Collection<String> c){
for (char i = 'a'; i < 'g'; i++){
c.add(String.valueOf(i));
}
}
}

class Comparator1 {
publicstatic Comparator getComparator() {
return new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof String&& o2 instanceof String) {
String s1 = ((String)o1).toLowerCase();
String s2 = ((String)o2).toLowerCase();
return s1.compareTo(s2);
}else{
System.err.println("未找到合适的比较器");
return 1;
}
}
};
}
}

7.min(Collection<?extends T>coll)
根据元素的自然顺序返回给定 collection 的最小元素。

min(Collection<? extendsT>coll, Comparator<? superT>comp)
根据指定比较器产生的顺序,返回给定collection 的最小元素。

同上

8.indexOfSubList(List<?>source,List<?>target)
返回指定源列表中第一次出现指定目标列表的起始位置;如果没有出现这样的列表,则返回-1。

eg:

public class CollectionsTest {
publicstatic void main(String[] args) {
List<String> l =new ArrayList<String>();
CollectionsTest.add(l);
List<String> l2 =new ArrayList<String>();
l2.add("c");
l2.add("d");
List<String> l3 =new ArrayList<String>();
l3.add("d");
l3.add("c");
int num1 = Collections.indexOfSubList(l,l2);
int num2 = Collections.indexOfSubList(l,l3);
System.out.println(num1+"/"+num2);
UtilTools.printCollection(l);
}

publicstatic void add(Collection<String> c){
for (char i = 'a'; i < 'g'; i++){
c.add(String.valueOf(i));
}
}
}

9.lastIndexOfSubList(List<?>source,List<?>target)
返回指定源列表中最后一次出现指定目标列表的起始位置;如果没有出现这样的列表,则返回-1。

同上

10.replaceAll(List<T>list,ToldVal, TnewVal)
使用另一个值替换列表中出现的所有某一指定值。

eg:

public class CollectionsTest {
publicstatic void main(String[] args) {
List<String> l =new ArrayList<String>();
CollectionsTest.add(l);
Collections.addAll(l, "c","c");
Collections.replaceAll(l, "c", "c1");
UtilTools.printCollection(l);
}

publicstatic void add(Collection<String> c){
for (char i = 'a'; i < 'g'; i++){
c.add(String.valueOf(i));
}
}
}

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

12.rotate(List<?>list,intdistance)
根据指定的距离轮换指定列表中的元素。

eg:

public class CollectionsTest {
publicstatic void main(String[] args) {
List<String> l =new ArrayList<String>();
CollectionsTest.add(l);
Collections.rotate(l, 1);//(i - distance) %list.size()
UtilTools.printCollection(l);
}

publicstatic void add(Collection<String> c){
for (char i = 'a'; i < 'g'; i++){
c.add(String.valueOf(i));
}
}
}

13.reverseOrder()
返回一个比较器,它强行逆转实现了Comparable 接口的对象 collection 的自然顺序。返回反序排列的比较器

reverseOrder(Comparator<T>cmp)
返回一个比较器,它强行逆转指定比较器的顺序。指定比较器的反序比较器

eg:

public class CollectionsTest {
publicstatic void main(String[] args) {
List<String> l =new ArrayList<String>();
CollectionsTest.add(l);
Collections.addAll(l, "Y","B");
Comparator ca =Collections.reverseOrder(Comparator1.getComparator());
Collections.sort(l, ca);
UtilTools.printCollection(l);
}

publicstatic void add(Collection<String> c){
for (char i = 'a'; i < 'g'; i++){
c.add(String.valueOf(i));
}
}
}

class Comparator1 {
publicstatic Comparator getComparator() {
return new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof String&& o2 instanceof String) {
String s1 = ((String)o1).toLowerCase();
String s2 = ((String)o2).toLowerCase();
return s1.compareTo(s2);
}else{
System.err.println("未找到合适的比较器");
return 1;
}
}
};
}
}

14.singleton(To)
返回一个只包含指定对象的不可变set。此对象可以是任意对象

singletonList(To)
返回一个只包含指定对象的不可变列表。

singletonMap(Kkey,Vvalue)
返回一个不可变的映射,它只将指定键映射到指定值。

eg:

public class CollectionsTest {
publicstatic void main(String[] args) {
Set<String> s = newHashSet<String>();
List<String> l =new ArrayList<String>();
Map<String,String>m = newHashMap<String,String>();
CollectionsTest.add(s);
CollectionsTest.add(l);
CollectionsTest.addMap(m);
//返回不可变的单一元素的set
Set<String> s1 =Collections.singleton("a");//参数是单个对象。这里"a"自动转化为String对象
//s1.add("b");//针对set的改动操作会导致java.lang.UnsupportedOperationException
Set<Set<String>>s2 = Collections.singleton(s);//也可以是一个set句柄或其他任意对象
s.add("g");//这里单一不变指的是此对象句柄不变,但是里面的元素可以更改,比如这个就是合法的

List<String> l1 =Collections.singletonList("a");
Map<String,String>m1 = Collections.singletonMap("A->","A");

UtilTools.printCollection(l1);
}

publicstatic void add(Collection<String> c){
for (char i = 'a'; i < 'g'; i++){
c.add(String.valueOf(i));
}
}

publicstatic void addMap(Map<String,String>m) {
for (char i = 'a'; i < 'g'; i++){
m.put(i+"->", i+"");
}
}
}

15:swap(List<?>list,inti, intj)
在指定列表的指定位置处交换元素。

eg:

public class CollectionsTest {
publicstatic void main(String[] args) {
List<String> l =new ArrayList<String>();
CollectionsTest.add(l);
Collections.swap(l, 1, 2);

UtilTools.printCollection(l);
}

publicstatic void add(Collection<String> c){
for (char i = 'a'; i < 'g'; i++){
c.add(String.valueOf(i));
}
}

}

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

eg:

public class CollectionsTest {
publicstatic void main(String[] args) {
List<String> l =new ArrayList<String>();
CollectionsTest.add(l);
Collections.fill(l, "b");

UtilTools.printCollection(l);
}

publicstatic void add(Collection<String> c){
for (char i = 'a'; i < 'g'; i++){
c.add(String.valueOf(i));
}
}

}

输出:b b b b b

17:frequency(Collection<?>c,Objecto)
返回指定collection 中等于指定对象的元素数。指定object o在c中出现的次数

eg:

public class CollectionsTest {
publicstatic void main(String[] args) {
List<String> l =new ArrayList<String>();
CollectionsTest.add(l);
l.add("a");
int num = Collections.frequency(l, "a");
System.out.println(num);
UtilTools.printCollection(l);
}

publicstatic void add(Collection<String> c){
for (char i = 'a'; i < 'g'; i++){
c.add(String.valueOf(i));
}
}

}

输出:2

18:disjoint(Collection<?>c1,Collection<?>c2)
如果两个指定collection 中没有相同的元素,则返回 true。

19:

  

爱华网本文地址 » http://www.413yy.cn/a/25101016/285806.html

更多阅读

排列组合怎么算 排列组合c的计算方法

排列组合怎么算——简介数学中的排列组合怎么算呢?排列组合怎么算——工具/原料数学排列组合怎么算——方法/步骤排列组合怎么算 1、首先要记住排列组合的公式:排列组合怎么算 2、看案例1:排列组合怎么算 3、

排列组合例题详解 概率论中的排列组合

1、“IMO”是国际数学奥林匹克的缩写,把这3个字母用3种不同颜色来写,现有5种不同颜色的笔,问共有多少钟不同的写法?分析:从5个元素中取3个的排列:P(5、3)=5×4×3=602、从数字0、1、2、3、4、5中任意挑选5个组成能被5除尽且各位数字互异的五

聚类分析方法 分类方法 数据挖掘

分类:系统聚类方法(Hierarchical Cluster过程):直观、易懂快速聚类(K-means Cluster过程):快速、动态有序聚类:时间顺序or大小顺序相似性度量:一。变量测量尺度的类型

声明:《Collections类常用方法总结 排列组合常用方法总结》为网友无关痛痒分享!如侵犯到您的合法权益请联系我们删除