Java——集合工具类和jdk1.5有关集合的新特性

最新推荐文章于 2019-09-12 16:55:37 发布

Zack-Avalanche

最新推荐文章于 2019-09-12 16:55:37 发布

阅读量456

点赞数

本文链接：https://blog.csdn.net/oZackAeris/article/details/46790717

版权

Collections

首先要区别开Collection类和Collections类，前者是集合容器类的父类，后者是对集合进行操作的方法进行封装的一个工具类。它封装了大量静态方法，不用创建对象就可以使用，大部分是对List集合进行操作的。

常见操作有：

查找
T max(Collection<? extends T> coll);//根据自然顺序，获取集合中的最大元素
T max(Collection<? extends T> coll,Comparator<? super T> comp);//根据指定比较器comp的顺序，获取coll集合中的最大元素
int binarySearch(Lsit<? extends Comparable<? super T>> list,Tkey);//二分法查找list集合中的指定对象
替换
void fill(List <? super T> list, T obj);//将list集合中的全部元素替换成指定对象
boolean replaceAll(List <T> lsit,T oldVal,T newVal);//用newVal替换集合中的oldVal值
void swap(Listlist,int i,int j);/在指定列表的指定位置处交换元素
排序：
void sort(List <T> list);//根据自然顺序对list集合中的元素进行排序
void sort(List <T> list, Comparator <? super T> cmp);//根据指定比较器的排序方式对list集合进行排序
反转：
reverse(List <?> list);//反转list集合中元素的顺序
Comparator reverseOrder();//返回一个比较器，反转了实现Comparable接口的对象的自然顺序
Comparator reverseOrder(Comparator <T> cmp);//返回一个比较器，反转了指定比较器的顺序
同步集合：
List <T> synchronizedList(List <T> list);//返回支持的同步的List集合
Map <K,V> synchronizedList(Map <K,V> m);//返回支持的同步的Map集合

下面给出一段方法使用的代码示例：

import java.util.*;

class CollectionsDemo
{
	public static void main(String[] args)
	{
		//sortDemo();
		maxDemo();
	}
	
	public static void maxDemo()
	{
		List<String> list = new ArrayList<String>();
		
		list.add("asd");
		list.add("b");
		list.add("jjj");
		list.add("345");
		list.add("89sdf");
		
		String max = Collections.max(list);
		
		print("max = " + max);
		
	}
	
	public static void sortDemo()
	{
		List<String> list = new ArrayList<String>();
		
		list.add("asd");
		list.add("b");
		list.add("jjj");
		list.add("345");
		list.add("89sdf");
		
		print(list);
		
		Collections.sort(list);
		print(list);
		
		Collections.sort(list, new ListStrLenComparator());
		print(list);
		
	}
	
	public static void print(Object obj)
	{
		System.out.println(obj);
	}
}


class ListStrLenComparator implements Comparator<String>
{
	public int compare(String s1, String s2)
	{
		if(s1.length() > s2.length())
			return 1;
		if(s1.length() < s2.length())
			return -1;
		return s1.compareTo(s2);
	}
}

还有一个重要方法是toArray()：T[] toArray(T[] a)

它将集合转成指定类型的数组，然后返回。有关传入的参数数组要注意：

当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。

所以最好传入一个长度相同的数组。

将集合变成数组的目的是限制对元素的操作。

格式如下：

class  CollectionToArrayDemo  
{  
    public static void main(String[] args)   
    {  
        ArrayList<String> al = new ArrayList<String>();  
  
        al.add("abc1");  
        al.add("abc2");  
        al.add("abc3");  
        String[] arr = al.toArray(new String[al.size()]);  
        System.out.println(Arrays.toString(arr));  
    }  
}

Arrays

Arrays是用于操作数组的工具类，里边的方法也全是静态的。

常见方法有：

二分查找：binarySearch()

替换元素：fill()

排序：sort()

字符串表示：toString()

同样，Arrays也有转为集合的方法

List<T> asList(T... a)

需要注意的有：

1、将数组转换成集合，集合的size就固定了，因为数组的长度是固定的。如果进行增删操作，则会产生UnsupportedOperationException的编译异常。

2、如果数组中的元素都是对象，数组中的元素就直接转为集合中的元素。

3、如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

JDK1.5集合新特性

foreach循环（高级for循环）

格式如下：

for(数据类型变量名 :被遍历的集合或者数组) {执行语句}

特点：

对集合进行遍历，只能获取集合元素，而不能对集合元素进行操作，可以看作是迭代器的简写形式。迭代器除了遍历，还可以进行remove动作。如果使用ListIterator，还可以在遍历过程中对集合进行增删改查的操作。

局限性：

必须有被遍历的目标，而且不使用索引，所以对数组进行操作时还是建议用传统for循环。

下面给出代码示例：

import java.util.*;  
class SeniorFor  
{  
    public static void main(String[] args)   
    {  
        //定义一个HashMap集合  
        HashMap<Integer,String> hm = new HashMap<Integer,String>();  
  
        hm.put(1,"a");  
        hm.put(2,"b");  
        hm.put(3,"c");  
  
        //keySet取出方式的高级for遍历  
        Set<Integer> keySet = hm.keySet();  
        for(Integer i : keySet)  
        {  
            System.out.println(i+"::"+hm.get(i));  
        }  
  
        //entrySet取出方式的高级for遍历  
        for(Map.Entry<Integer,String> me : hm.entrySet())  
        {  
            System.out.println(me.getKey()+"------"+me.getValue());  
        }  
  
    }  
}

可变参数：

可变参数其实就是数组参数的简写形式，但是可以传入不确定长度的数组，而且不用每一次都手动的建立数组对象，只要将要操作的元素作为参数传递即可，可变参数会将这些参数封装成了数组。格式是void xx(int... arr) 同时注意一点：可变参数需要定义在参数列表的最后。

例如：

class  ParamMethodDemo  
{  
    public static void main(String[] args)   
    {  
        show("hello",1,4,5,6,);  
    }  
    public static void show(String str,int... arr)//...就表示可变参数  
    {  
        System.out.println(arr.length);  
    }  
}

静态导入：

静态导入是为了在调用类或包中的静态成员时不用再写包名和类名，方便使用。格式是：import static java.util.Arrays.*

注意：当导入的两个类中有同名成员时，需要在成员前加上相应的类名。
当类名重名时，需要指定具体的包名。

当方法重名时，指定具体所属的对象或者类。

示例：

import java.util.*;  
import static java.util.Arrays.*;  
import static java.lang.System.*;  
  
class  StaticImport //extends Object  
{  
    public static void main(String[] args)   
    {  
  
        out.println("hello");//调用静态方法可省略类名，下面的sort,binarySearch同理
        int[] arr = {3,1,5};  
  
        sort(arr);
  
        int index = binarySearch(arr,1);
        out.println("Index="+index);  
    
       //Object类也有toString方法 所以要加类名以区分 
       out.println(Arrays.toString(arr));  
    }  
}