Collections 常用方法
此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。它包含在 collection上操作的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其他内容
如果为此类的方法所提供的 collection 或类对象为 null，则这些方法都将抛出NullPointerException。
首先定义一个工具类：
public class UtilTools {
publicstatic void printCollection(Collection c){
Iterator it= c.iterator();
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,Random rnd)
使用指定的随机源对指定列表进行置换。同上
5.binarySearch(List<?extends Comparable<? superT>> list,T key)
使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据列表元素的自然顺序对列表进行升序排序（通过sort(List)方法）。如果没有对列表进行排序，则结果是不确定的。如果列表包含多个等于指定对象的元素，则无法保证找到的是哪一个。
binarySearch(List<? extendsT> list, T key,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());//有比较器的时候最大为Y a b B c d e f Y
//String s =Collections.max(l);//没有比较器的话最大为f B 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,T oldVal, T newVal)
使用另一个值替换列表中出现的所有某一指定值。
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,int distance)
根据指定的距离轮换指定列表中的元素。
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(T o)
返回一个只包含指定对象的不可变set。此对象可以是任意对象
singletonList(T o)
返回一个只包含指定对象的不可变列表。
singletonMap(K key,V value)
返回一个不可变的映射，它只将指定键映射到指定值。
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,int i, int j)
在指定列表的指定位置处交换元素。
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,T obj)
使用指定元素替换指定列表中的所有元素。
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,Object o)
返回指定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
Collections 常用方法相关推荐
- java中Collections常用方法总结（包括sort，copy，reverse等）
1.sort(Collection)方法的使用(含义:对集合进行排序). 例:对已知集合c进行排序public class Practice {public static void main(Stri ...
- Collections常用方法总结
public class CollectionsTest {public static void main(String[] args) {List<Integer> list = new ...
- 014_Collections常用方法
1. Collections常用方法 import java.util.ArrayList; import java.util.Arrays; import java.util.Collections ...
- Java Collections工具类
Collections工具类 Collections 是一个操作 Set.List 和 Map 等集合的工具类 Collections 中提供了一系列静态的方法对集合元素进行排序.查询和修改等操作,还 ...
- Java集合篇：Map接口、Map接口的实现类、Collections集合工具类
目录 一.Map接口 1.1 Map接口概述 1.2 Map接口常用功能 二.Map接口的实现类 2.1 Map实现类之一:HashMap 2.1.1 HashMap概述 2.1.2 HashMap的 ...
- Java——Collections工具类
Collections工具类 Collections 是一个操作 Set.List 和 Map 等集合的工具类 Collections 中提供了一系列静态的方法对集合元素进行排序.查询和修改等操作,还 ...
- Java基础篇：Java集合
文章目录 1.概述 2.Collection接口 2.1 Collection接口方法 2.2 Iterator迭代器接口 2.3 Collection子接口之:List接口 2.4 Collecti ...
- java集合代码_Java-集合(示例代码)
一.Java集合框架概述 ●一方面,面向对象语言对事物的体现都是以对象的形式,为了方便对多个对象的操作,就要对对象进行存储.另一方面,使用Array存储对象方面具有一些弊端,而Java集合就像一种容器 ...
- java中集合的模型特点_Java 学习笔记（十四）集合
集合 在开发的时候,如果需要存储多个数据,可以使用数组,不过数据是固定长度的,如果需要存储可变长度的多个数据,可以使用集合.集合提供存储空间可变的存储类型,存储的容量可以实时改变 集合分类 Colle ...
- Thinking in java基础之集合框架
Thinking in java基础之集合框架 大家都知道我的习惯,先上图说话. 集合简介(容器) 把具有相同性质的一类东西,汇聚成一个整体,就可以称为集合,例如这里有20个苹果,我们把每一个苹果当成 ...
最新文章
- JavaScript——易班优课YOOC课群在线测试自动答题解决方案(九)ID标签
- boost :: dynamic_bitset时序测试
- OpenGL PN三角形的分化
- mysql 的 外连查询
- 基站建设（三元环计数+根号分治 / bitset）
- 我们应该学习什么 java、C#还是C++(VC)
- c++ 01_02 study note
- 低代码开发平台是什么
- matlab fread每隔,matlab 中关于fread函数的用法
- 天勤数据结构代码——双链表
- 使用vue开发的网页游戏
- 同城门户同城分类信息网站源码+小程序端+49款插件
- arduino 实现时钟和计算器
- 6G概念及愿景白皮书
- PyCharm专业版破解
- linux怎么停止ping命令
- Java基础汇总（二十二）——行为模式
- 为什么使用Stelnet与sftp协议，而不用telnet与ftp协议
- 十分钟清除西门子C65手机密码
- SW3516中文资料书