关闭

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

183人阅读 评论(0) 收藏 举报


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));  
    }  
}  



0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:4398次
    • 积分:194
    • 等级:
    • 排名:千里之外
    • 原创:15篇
    • 转载:1篇
    • 译文:0篇
    • 评论:2条
    文章分类
    最新评论