Collections的简单学习-白红宇

                               
package
com.hanchao.test;
import
java.util.ArrayList;
import
java.util.Arrays;
import
java.util.Collections;
import
java.util.Enumeration;
import
java.util.List;
import
java.util.Vector;
/**
 
* java.util.Collections的简单学习
 
* @author liweihan (liweihan@sohu-inc.com)
 
* @version 1.0 (2016年1月13日 上午10:20:51)
 
*/
public
class
TestCollections { 
    
public
static
void
main(String[] args) { 
        
        
/**
         
* java.util.Collections 是一个包装类。它包含有各种有关集合的操作的静态多态方法。
         
* 此类不能实例化，就像一个工具类，服务于java的Collection框架。
         
* 
         
* 参考：
         
*      http://www.apihome.cn/api/java/Collections.html
         
* 
         
*/
        
        
/**
         
* 1.排序sort()
         
* 根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。
         
* 此外，列表中的所有元素都必须是可相互比较的（也就是说，
         
* 对于列表中的任何 e1 和 e2 元素，e1.compareTo(e2) 
         
* 不得抛出 ClassCastException
         
*/
        
List<Double> list = 
new
ArrayList<Double>();
        
list.add(112D);
        
list.add(113D);
        
list.add(23D);
        
list.add(456D);
        
list.add(112D);
        
list.add(231D);
        
        
Collections.sort(list);
        
for
(
int
i = 
0
; i < list.size(); i++) { 
            
System.out.println(list.get(i));
        
}
        
//结果：23.0 112.0 113.0 231.0 456.0
        
        
        
/**
         
* 2.混排
         
* 混排算法所做的正好与 sort 相反: 它打乱在一个 List 中可能有的任何排列的踪迹。
         
* 也就是说，基于随机源的输入重排该 List,这样的排列具有相同的可能性（假设随机源是公正的）。
         
* 这个算法在实现一个碰运气的游戏中是非常有用的。
         
* 例如，它可被用来混排代表一副牌的Card 对象的一个 List 。另外，在生成测试案例时，它也是十分有用的。
         
*/
        
Collections.shuffle(list);
        
System.out.println(
"混排："
);
        
for
(
int
i = 
0
; i < list.size(); i++) { 
            
System.out.println(list.get(i));
        
}
        
//结果：113.0 456.0 112.0 23.0 112.0 231.0
        
        
        
/**
         
* 3.反转reverse()
         
* 使用Reverse方法可以根据元素的自然顺序 对指定列表按降序进行排序。
         
*/
        
Collections.reverse(list);
        
System.out.println(
"反转："
);
        
for
(
int
i = 
0
; i < list.size(); i++) { 
            
System.out.println(list.get(i));
        
}
        
//结果：231.0 112.0 23.0 112.0 456.0 113.0
        
        
/**
         
* 4.fill()
         
* 使用指定元素替换指定列表中的所有元素。
         
*/
        
List<String> list2 = 
new
ArrayList<String>();
        
list2.add(
"aa"
);
        
list2.add(
"bb"
);
        
list2.add(
"cc"
);
        
list2.add(
"dd"
);
        
        
Collections.fill(list2,
"hanchao"
);
        
System.out.println(
"替换："
);
        
for
(String string : list2) { 
            
System.out.println(string);
        
}
        
//结果：hanchao hanchao hanchao hanchao
        
        
/**
         
* 5.copy()
         
* 将所有元素从一个列表复制到另一个列表。
         
* 执行此操作后，目标列表中每个已复制元素的索引将等同于源列表中该元素的索引。
         
* 目标列表的长度至少必须等于源列表。
         
* 如果目标列表更长一些，也不会影响目标列表中的其余元素。
         
* 
         
*/
        
List<String> list3 = 
new
ArrayList<String>();
        
list3.add(
"list31"
);
        
list3.add(
"list32"
);
        
list3.add(
"list33"
);
        
        
List<String> list4 = 
new
ArrayList<String>();
        
list4.add(
"copy1"
);
        
list4.add(
"copy2"
);
        
list4.add(
"copy3"
);
//      list4.add("copy4");
        
        
Collections.copy(list3, list4); 
//list4是源 ,list4的长度必须<=list3.size()
        
System.out.println(
"复制："
);
        
for
(String str : list3) { 
            
System.out.println(str);
        
}
        
        
/**
         
* 6.min()
         
* 根据元素的自然顺序 返回给定 collection 的最小元素。
         
* collection 中的所有元素都必须实现 Comparable 接口。
         
* 此外，collection 中的所有元素都必须是可相互比较的（也就是说，
         
* 对于 collection 中的任意 e1 和 e2 元素，e1.compareTo(e2) 
         
* 不得抛出 ClassCastException）。
         
* 
         
* max()
         
* 根据元素的自然顺序，返回给定 collection 的最大元素。
         
* collection 中的所有元素都必须实现 Comparable 接口。
         
* 此外，collection 中的所有元素都必须是可相互比较的（也就是说，
         
* 对于 collection 中的任意 e1 和 e2 元素，
         
* e1.compareTo(e2) 不得抛出 ClassCastException）。
         
*/
        
List<Double> list5 = 
new
ArrayList<Double>();
        
list5.add(112D);
        
list5.add(113D);
        
list5.add(23D);
        
list5.add(456D);
        
list5.add(112D);
        
list5.add(231D);
        
        
System.out.println(
"最小元素："
+ Collections.min(list5));
        
System.out.println(
"最大元素："
+ Collections.max(list5));
        
        
        
/**
         
* 7.indexOfSubList(List,list) 
         
*   返回指定源列表中第一次出现指定目标列表的起始位置；
         
*   如果没有出现这样的列表，则返回 -1。
         
*   
         
*   lastIndexOfSubList(List,list)
         
*   返回指定源列表中最后一次出现指定目标列表的起始位置；
         
*   如果没有出现这样的列表，则返回 -1。
         
*   
         
*   binarySearch(list,key)
         
*   查找指定集合中的元素，返回所查找元素的索引。
         
*   
         
*/
        
double
array[] = { 
112
, 
111
, 
23
, 
456
,
111
, 
231
};
        
List<Double> list6 = 
new
ArrayList<Double>();
        
List<Double> li = 
new
ArrayList<Double>();
        
for
(
int
i = 
0
; i < array.length; i++) { 
            
list6.add(
new
Double(array[i]));
        
}
        
double
arr[] = { 
111
};
        
for
(
int
j=
0
;j<arr.length;j++){ 
            
li.add(
new
Double(arr[j]));
        
}
        
int
locations = Collections.lastIndexOfSubList (list6,li);
        
int
locations2 = Collections.indexOfSubList(list6, li);
        
int
locations3 = Collections.binarySearch(list6, 23d);
        
System.out.println(
"=== lastIndexOfSubList:"
+ locations);
        
System.out.println(
"=== indexOfSubList:"
+ locations2);
        
System.out.println(
"=== binarySearch:"
+ locations3);
        
//结果：=== lastIndexOfSubList:4
        
//结果：=== indexOfSubList:1
        
//结果：=== binarySearch:2
        
        
/**
         
* 8.rotate()
         
* 根据指定的距离轮换指定列表中的元素。调用此方法后，
         
* 对于 0 和 list.size()-1（包括）之间的所有 i 值，
         
* 索引 i 处的元素将是以前位于索引 (i - distance) mod list.size() 处的元素。
         
* （此方法对列表的大小没有任何影响。） 
         
* 
         
*/
        
String[] str = { 
"t"
,
"a"
,
"n"
,
"k"
,
"s"
};
        
List<String> list7 = 
new
ArrayList<String>();
        
for
(
int
i = 
0
; i < str.length; i++) { 
            
list7.add(str[i]);
        
}
        
//      Collections.rotate(list7, -4);//如果是负数，则左移
        
Collections.rotate(list7, 
2
);
//如果是正数，则右移
        
System.out.println(
"位移："
);
        
for
(String s : list7) { 
            
System.out.println(s);
        
}
        
        
        
/**
         
* 9.replaceAll(list,old,new)
         
* 替换指定的元素，若要替换的值存在则返回true,反之则返回false
         
* 
         
*/
        
List<String> list8 = Arrays.asList(
"one two three four five six siven"
.split(
" "
));
        
System.out.println(list8);
        
//[one, two, three, four, five, six, siven]
        
Collections.replaceAll(list8, 
"siven"
, 
"siven eight nine"
);
        
System.out.println(
"---:"
+ list8);
        
//---:[one, two, three, four, five, six, siven eight nine]
        
        
/**
         
* 10.swap(List list,int i,int j)
         
* 在指定列表的指定位置处交换元素。
         
* （如果指定位置相同，则调用此方法不会更改列表。）
         
* 
         
*/
        
List<String> list10 = Arrays.asList(
"one two three four five six siven"
.split(
" "
));
        
System.out.println(
"***:"
+ list10);
        
//***:[one, two, three, four, five, six, siven]
        
Collections.swap(list10, 
3
, 
5
);
        
System.out.println(
"---:"
+ list10);
        
//---:[one, two, three, six, five, four, siven]
        
        
/**
         
* 
11
.nCopies(
int
n,Object 
0
)
         
* 返回大小为n的List ,List不可改变，其中的所有引用都指向o
         
*/
        
List<String> list11 = 
new
ArrayList<String>();
        
list11 = Collections.nCopies(
5
, 
"hello"
);
        
System.out.println(
"$$$:"
+ list11);
        
//$$$:[hello, hello, hello, hello, hello]
        
        
/**
         
* 12.enumeration(Collection)
         
*    返回一个指定 collection 上的枚举。
         
*    此方法提供与遗留 API 的互操作性，遗留 API 需要一个枚举作为输入。 
         
*/
        
List<String> list12 = Arrays.asList(
"I love you xiao jie !"
.split(
" "
));
        
System.out.println(
"---:"
+ list12);
        
//---:[I, love, you, xiao, jie, !]
        
Enumeration<String> e = Collections.enumeration(list12);
        
Vector<String> v = 
new
Vector<String>();
        
while
(e.hasMoreElements()) { 
            
v.addElement(e.nextElement());
        
}
        
System.out.println(
" v :"
+ v);
        
//v :[I, love, you, xiao, jie, !]
        
    
}
    
}
          
        
本文转自韩立伟 51CTO博客，原文链接：http://blog.51cto.com/hanchaohan/1734707
，如需转载请自行联系原作者