集合的工具类
Collections
是专门对集合进行操作的工具类。
比如说排序：
我们知道，List集合是有序的（按照存进去的顺序进行存储），因为他底层数据结构是数组，有角标，里边有索引，所以也可以有重复元素。
现在如果我们想对List集合中的元素进行排序呢？
//Collections工具类的简单演示
import java.util.*;
public class CollectionsDemo {
public static void main(String[] args)
{
sortDemo();
}
public static void sortDemo()
{
String s1 = "dgsch";
String s2 = "aaa";
String s3 = "zz";
String s4 = "qq";
String s5 = "cdfg";
List<String> list = new ArrayList<String>();
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
list.add(s5);
sop(list);
//使用工具类进行排序
Collections.sort(list);
sop(list);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
运行结果：
结果可以看出，Collections的sort方法可以使List集合中的元素进行排序，排序方式是自然排序。
现在需求变了，我们要按照字符串的长度进行排序。
可以在Collections的sort方法里传入比较器。
//使用Collections的排序方法，但是用自己定义的排序方式
import java.util.*;
//自定义比较器
class StrLenCompartor implements Comparator<String>
{
public int compare(String s1,String s2)
{
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if (num==0)
return s1.compareTo(s2);
return num;
}
}
public class CollectionsDemo {
public static void main(String[] args)
{
sortDemo();
}
public static void sortDemo()
{
String s1 = "dgsch";
String s2 = "aaa";
String s3 = "zz";
String s4 = "qq";
String s5 = "cdfg";
List<String> list = new ArrayList<String>();
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
list.add(s5);
sop(list);
//使用工具类进行排序,将自定义比较器作为参数传递进来
Collections.sort(list,new StrLenCompartor());
sop(list);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
运行结果为：
运行结果可以看出来，集合按照自定义的方式进行排序。
还有一个方法是可以直接获取集合中元素的最大值，Collections.max(T t),这里就不进行演示了。
集合工具类的二分法查找
//Collections的二分法查找
import java.util.*;
public class CollectionsDemo2 {
public static void main(String[] args)
{
binarySearchDemo();
}
public static void binarySearchDemo()
{
String s1 = "dgsch";
String s2 = "aaa";
String s3 = "zz";
String s4 = "qq";
String s5 = "cdfg";
List<String> list = new ArrayList<String>();
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
list.add(s5);
sop(list);
Collections.sort(list,new StrLenCompartor());//先对集合中的元素进行排序
sop(list);
int index = Collections.binarySearch(list,"aaa");//调用二分法查找的时候要把集合和查找的元素都传进来
sop("aaa.index="+index);
int index2 = Collections.binarySearch(list,"aaaa");
sop("aaaa.index="+index2);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
运行结果为：
运行结果可以发现，当要找的元素不存在时，返回的值不是-1，而是-(插入点)-1; 这样的结果在数组的二分法查找中也是这样的。
而且需要注意的是，使用二分法查找的时候，集合中的元素必须是已经排好序的。
那么，要我们自己定义二分法查找元素呢？
//自定义二分法查找
import java.util.*;
public class CollectionsDemo2 {
public static void main(String[] args)
{
binarySearchDemo2();
}
public static void binarySearchDemo2()
{
String s1 = "dgsch";
String s2 = "aaa";
String s3 = "zz";
String s4 = "qq";
String s5 = "cdfg";
List<String> list = new ArrayList<String>();
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
list.add(s5);
//首先对集合进行排序,记住，在二分查找之前一定要进行排序，而且在自定义的二分法中，排序规则需要一致。
Collections.sort(list,new StrLenCompartor());
sop(list);
int index = halfSearch(list,"aaa",new StrLenCompartor());
sop(index);
}
/*
public static int halfSearch(List<String> list,String key)
{
int max,min,mid;
max = list.size()-1;
min = 0;
while (max>min)
{
mid = (max+min)>>1;
//取出最中间的元素和给定的元素进行比较
String str = list.get(mid);
if (str.compareTo(key)>0)//如果集合中的元素不具备比较性，这一步是不可以进行的。
{
max = mid-1;
}
else if (str.compareTo(key)<0)
{
min = mid+1;
}
else
{
return mid;
}
}
return -min-1;//如果集合中没有指定的元素，返回-min-1，这里的min是指定元素的插入点
}
*/
public static int halfSearch(List<String> list,String key,Comparator<String> cmpt)
{
int max,min,mid;
max = list.size()-1;
min = 0;
while (max>min)
{
mid = (max+min)>>1;
String str = list.get(mid);
//这里不能直接对元素进行比较，所以用到了参数中传进来的比较器
//直接使用比较器中的compare方法进行比较
int num = cmpt.compare(str,key);
if (num>0)
{
max = mid-1;
}
else if (num<0)
{
min = mid+1;
}
else
{
return mid;
}
}
return -min-1;//如果集合中没有指定的元素，返回-min-1，这里的min是指定元素的插入点
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
//自定义比较器
class StrLenCompartor implements Comparator<String>
{
public int compare(String s1,String s2)
{
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if (num==0)
return s1.compareTo(s2);
return num;
}
}
运行结果为：
运行结果可以看出，集合先按照元素长度进行排序，然后按照自定义二分法查表查到元素的角标位置。
注意：在进行二分法查找之前，一定要进行排序，
在以上示例代码中（假设元素自身没有比较性），二分法查找元素使用到了比较器，排序也用到了比较器，两者比较器必须相同。
集合中元素的替换和反转
//集合中元素的替换和反转
import java.util.*;
public class CollectionsDemo3 {
public static void main(String[] args)
{
String s1 = "dgsch";
String s2 = "aaa";
String s3 = "zz";
String s4 = "qq";
String s5 = "cdfg";
List<String> list = new ArrayList<String>();
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
list.add(s5);
sop(list);//[dgsch, aaa, zz, qq, cdfg]
//将集合中的元素替换成指定的元素
//fillDemo(list);
//sop(list);//[qq, qq, qq, qq, qq]
//反转集合中的元素
//reverseDemo(list);
//sop(list);//[cdfg, qq, zz, aaa, dgsch]
//用指定的元素，替换集合中指定的元素。
raplaceAllDemo(list,"aaa","haha");
sop(list);//[dgsch, haha, zz, qq, cdfg]
}
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void fillDemo(List<String> list)
{
Collections.fill(list,"qq");
}
public static void reverseDemo(List<String> list)
{
Collections.reverse(list);
}
public static void raplaceAllDemo(List<String> list,String s,String port)
{
Collections.replaceAll(list,s,port);
}
}
那么看一个练习，将集合中的指定范围的对象，全部替换成指定的对象，
//练习，已知fill方法可以将集合中的所有元素替换成指定的元素
//那么需求是，要将指定范围的元素换成指定的元素
import java.util.*;
public class CollectionsTest {
public static void main(String[] args)
{
//先创建集合，在集合中添加字符串对象
String s1 = "dgsch";
String s2 = "aaa";
String s3 = "zz";
String s4 = "qq";
String s5 = "cdfg";
List<String> list = new ArrayList<String>();
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
list.add(s5);
//定义两个变量
int start,end;
start = 1;
end = 3;
//用ListIterator方法对集合进行迭代，
for (Iterator<String> it = list.listIterator();it.hasNext() ; )
{
String s = it.next();
//只要字符串所在的角标符合条件，将该字符串对象替换成另一个对象。
if (start<=list.indexOf(s) && list.indexOf(s)<=end)
{
Collections.replaceAll(list,s,"zzzzzz");
}
}
sop(list);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
运行结果为：
反转集合中元素的方法——Collections.reverseOrder()
以上的例子中，使用Collections工具类给List集合进行排序，是可以排的，
但是不可以给Set集合进行排序，因为Set集合有自己的排序方法。
现在如果要对Set集合中已经排序的元素进行反转，该怎么办呢？
用自定义比较器的方法
//给Set集合中的元素进行顺序的转换
import java.util.*;
public class CollectionsDemo4 {
public static void main(String[] args)
{
//先创建集合，在集合中添加字符串对象
Set<String> set = new TreeSet<String>(new MyReverse());
set.add(new String("aaaaa"));
set.add(new String("bdfg"));
set.add(new String("vdfeggdc"));
set.add(new String("cc"));
set.add(new String("q"));
//打印集合中的元素
//sop(set);
//[aaaaa, bdfg, cc, q, vdfeggdc]*********原始顺序是按照自然顺序进行排序的。
sop("逆转后的集合顺序为："+set);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
//按照之前学过的传自己比较器的方式，也可以进行顺序的逆转。
//只要把s1和s2的比较顺序调换就行了。
class MyReverse implements Comparator<String>
{
public int compare(String s1,String s2)
{
int num = s2.compareTo(s1);
return num;
}
}
运行结果：
方法二： 用集合工具类的方法reverseOrder()
//给Set集合中的元素进行顺序的转换
import java.util.*;
public class CollectionsDemo4 {
public static void main(String[] args)
{
//先创建集合，在集合中添加字符串对象(在创建集合的时候就开始调用工具类的方法)
Set<String> set = new TreeSet<String>(Collections.reverseOrder());
//Collections.reverseOrder()能强行逆转集合中的自然比较方法
set.add(new String("aaaaa"));
set.add(new String("bdfg"));
set.add(new String("vdfeggdc"));
set.add(new String("cc"));
set.add(new String("q"));
//打印集合中的元素
//sop(set);
//[aaaaa, bdfg, cc, q, vdfeggdc]*********原始顺序是按照自然顺序进行排序的。
sop("逆转后的集合顺序为："+set);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
运行结果：
但是如果集合不是自然排序，而是用自己定义的比较器进行排序的呢？
//给Set集合中的元素进行顺序的转换
import java.util.*;
public class CollectionsDemo4 {
public static void main(String[] args)
{
//先创建集合，在集合中添加字符串对象(在创建集合的时候就开始调用工具类的方法，里边可以传入自定义的比较器)
Set<String> set = new TreeSet<String>(Collections.reverseOrder(new StrLenCompartor()));
//Collections.reverseOrder(new 比较器)可以逆转比较器中的排序方式
set.add(new String("aaaaa"));
set.add(new String("bdfg"));
set.add(new String("vdfeggdc"));
set.add(new String("cc"));
set.add(new String("q"));
//打印集合中的元素
//sop(set);
//[q, cc, bdfg, aaaaa, vdfeggdc]*********只使用比较器的结果是按照长度顺序进行排序的。
sop("逆转后的集合顺序为："+set);
//[vdfeggdc, aaaaa, bdfg, cc, q]**********使用工具类方法，传入比较器的结果是按照长度顺序反转过来的顺序排列的。
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
//自定义比较器，按照长度由短到长排序
class StrLenCompartor implements Comparator<String>
{
public int compare(String s1,String s2)
{
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if (num==0)
return s1.compareTo(s2);
return num;
}
}
集合中线程安全的问题
我们知道很多升级后的集合存数对象的时候，为了提高效率，都用的是线程不同步的，
那么，如果真的遇到了多线程操作集合的问题呢？
java中的集合工具类（Collections）中有专门提供的线程安全的集合：
该方法的牛逼之处在于：你给我一个线程不安全的集合，我返回一个线程安全的集合。
集合工具类中的其他方法：
Collections.swap(List list,int i,int j)将List集合中的指定两个元素交换位置。
Collections.shuffle(List list)将集合中的元素排序方式打乱，每次运行结果都不一样，就像是洗牌的一样。
//shuffle方法的演示
import java.util.*;
public class CollectionsDemo5 {
public static void main(String[] args)
{
String s1 = "dgsch";
String s2 = "aaa";
String s3 = "zz";
String s4 = "qq";
String s5 = "cdfg";
List<String> list = new ArrayList<String>();
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
list.add(s5);
sop(list);
Collections.shuffle(list);//调用shuffle方法，使集合中的元素顺序打乱
sop(list);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
运行结果为：
Arrays工具类
专门用来操作数组的工具类
里边全都是静态方法。
Arrays.toString()直接打印数组中的内容：
//Arrays工具类的基本方法演示
import java.util.*;
public class ArraysDemo {
public static void main(String[] args)
{
int[] arr = {3,6,1};
sop(Arrays.toString(arr));
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
List list Arrays.asList(arr)：传进来一个数组，返回一个List集合
//Arrays工具类的基本方法演示
import java.util.*;
public class ArraysDemo {
public static void main(String[] args)
{
String[] strs = {"haha","hehe","nhao","llala","hiahia"};
//将字符串数组变成List集合
List<String> list = Arrays.asList(strs);
sop(list);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
把数组变成集合有什么好处呢？
可以使用集合的思想和方法来操作数组中的元素。
注意：将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的。
contains()
get()
indexOf()
subList()这些方法都可以用。
如果进行增删操作的话会发生异常：UnsupportedOperationException(不支持操作异常)
sop(list.contains("haha"));
//看返回的真假来判断集合中是否存在这样的元素，如果是数组的话需要遍历整个数组。
上边代码证实，存入String类型的数据，将数组变为集合的时候，打印出来集合的元素也是字符串，但是换成int类型的数组的时候打印出来的就是哈希值。
//Arrays工具类的基本方法演示
import java.util.*;
public class ArraysDemo {
public static void main(String[] args)
{
int[] arr = {3,5,78,1,5,6};
//将字符串数组变成List集合
List list = Arrays.asList(arr);
//如果要写泛型的话应该写成这个样子。
//List<int[]> list = Arrays.asList(arr);
sop(list);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
如果想要打印出来的值不是哈希值得话，要这样写
//Arrays工具类的基本方法演示
import java.util.*;
public class ArraysDemo {
public static void main(String[] args)
{
Integer[] arr = {3,5,78,1,5,6};
//将字符串数组变成List集合
List<Integer> list = Arrays.asList(arr);
sop(list);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
**注意：**如果数组中的元素都是对象，那么变成集合的时候，数组中的元素就直接转成集合中的元素。
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素作为集合中的元素存在。
集合变数组
使用Collection接口中的toArray方法。
//将集合转变成数组
//使用Collection接口中的toArray方法
import java.util.*;
public class CollectionToArray {
public static void main(String[] args)
{
List<String> list = new ArrayList<String>();
list.add(new String("nihao"));
list.add(new String("shijie"));
list.add(new String("hello"));
list.add(new String("world"));
//开始转变，参数需要一个数组
String[] strs = list.toArray(new String[4]);
//将数组中的元素直接打印出来，可以用到Arrays中的toString方法
System.out.println(Arrays.toString(strs));
}
}
那么问题也就来了，
1，指定类型的数组到底要定义多长呢？
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组，长度为集合的size
当指定类型的数组长度小于了集合的size，就不会新创建数组，而是使用传递进来的数组。
所以创建一个刚刚好的数组最优。
2，为什么要将集合转变成数组？
为了限定对元素的操作。
数组有固定的长度，一旦确定就不可以再进行增删操作，
增强for循环
格式：
for(数据类型 变量名 ： 被便利的集合（Collection）或者数组)
{
}
jdk1.5新特性
作用：
用于对集合进行遍历
只能获取集合元素，但是不能对集合进行操作。
迭代器除了遍历，还可以进行remove集合元素的动作。
如果是用ListIterator，还可以再遍历过程中对集合进行增删改查的动作。
传统for和高级for有什么区别呢？
高级for有一个局限性，必须有被遍历的目标。
比如说打印100次hello world，还是传统for好使。
简单演示一下增强for循环的用法：
//增强for循环演示
import java.util.*;
public class ForEachDemo {
public static void main(String[] args)
{
List<String> list = new ArrayList<String>();
list.add(new String("nihao"));
list.add(new String("shijie"));
list.add(new String("hello"));
list.add(new String("world"));
//数据类型 变量名 ： 被遍历的目标
for (String s: list)
{
System.out.println(s);
}
}
}
增强for循环的应用：
//增强for循环的应用
import java.util.*;
public class ForEachTest {
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
//增强for循环遍历数组
sop("增强for循环遍历数组");
int[] arr = {2,5,3,8,4};
for(int i:arr)
{
sop("i= "+i);
}
//用增强for循环遍历set集合中的元素
sop("增强for循环遍历set集合中的元素");
Set<String> set = new HashSet<String>();
set.add(new String("abc"));
set.add(new String("dsaf"));
set.add(new String("fdfd"));
set.add(new String("ccc"));
for(String s: set)
{
sop("s....."+s);
}
//用增强for循环遍历map集合中的元素
TreeMap<Integer,String> tm = new TreeMap<Integer,String>();
tm.put(1,"a");
tm.put(2,"b");
tm.put(3,"c");
tm.put(4,"d");
//方法一，使用keySet方法
sop("用增强for循环遍历map集合中的元素(keySet方法)");
Set<Integer> keySet = tm.keySet();
for(Integer i:keySet)
{
System.out.println(i+"--------"+tm.get(i));
}
//方法二，使用entrySet方法
sop("用增强for循环遍历map集合中的元素(entrySet方法)");
Set<Map.Entry<Integer,String>> entrySet = tm.entrySet();
for(Map.Entry<Integer,String> me :entrySet)
{
System.out.println(me.getKey()+"*******"+me.getValue());
}
}
}
运行结果为：
可变参数
jdk1.5出现的心特性
使用时注意：可变参数一定要定义在参数列表的最后边。
考虑这样一种情况：
public void show(int a,int b)
{
System.out.println(a+","+b);
}
类似这样的show方法的功能，如果我需要打印三个参数的值呢？四个五个呢，创建多个重载方法是可以的，但是那样写太多了。
我们可以创建一个数组：
public void show(int[] arr)
{
System.out.println(Arrays.toString(arr));
}
这样也可以，但是不足之处在于，每次调用该方法都要定义一个数组，不太优。
可变参数方法：只要多个参数类型是同一种（int），可以让多个参数自动装箱封装进一个数组（arr）中去。
如果参数中需要其他的参数，记住可变参数一定要定义在参数列表的最后边。
//可变参数演示
public class ParamMethodDemo {
public static void main(String[] args)
{
show(2,5,7,5,8,2);
show("nihao",4,7,4,3,2,9);
}
public static void show(int...arr)//可变的参数数量，都会封装进数组中去
//格式：参数类型...数组名称
{
System.out.println(arr.length);
}
//如果参数中需要其他类型的参数,将其他类型的参数放在最前边，把可变参数放在最后边
public static void show(String s,int...arr)
{
System.out.println(s+arr.length);
}
}
静态导入
jdk1.5新特性。
使用集合工具类和数组工具类的时候，每次都要写Collections和Arrays，用很多次就写很多次。
一个一劳永逸的方法就是，静态导入，
因为Collections和Arrays里边都是静态方法，导入类之后，就可以直接调用类中的成员方法了。
具体导入方法和使用实例如下：
import java.util.*;
//在这里静态导入
import static java.util.Arrays.*;//将Arrays 中的静态的成员导入进来
public class StaticImportDemo {
public static void main(String[] args)
{
int[] arr = {3,5,8,5,3,6};
//给数组进行排序：
sort(arr);
//打印数组中的元素
System.out.println(Arrays.toString(arr));
//使用二分法查找元素
int index = binarySearch(arr,8);
System.out.println(index);
}
}
运行结果：
注意：在以上代码中，打印数组中的元素一行中，必须写Arrays.toString(),
因为Arrays类继承的是Object类，而Object里边也有toString方法，
这里认为他是使用的Object中的toString方法，
所以必须在方法前指明类名。
记住：
当雷鸣重复时，需要指定具体的包名。
当方法重名时，需要指定具体的对象或者类。
1594
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
