黑马程序员---集合框架工具类Collections,数组工具类Arrays常见方法以及1.5版本新特性（高级for，可变参数和静态导入）

------- android培训、java培训、期待与您交流！ ----------

集合框架工具类：Collections
通过程序练习常用方法：

import java.util.*;
public class CollectionsDemo 
{
	public static void main(String[] args)
	{

		//fill(l,"x");将l集合内元素替换成x
		//replaceAll(l,old,new);将l内的old值替换成new值
		//reverse(l);将l集合顺序反转
		//swap(l,1,2);将集合的1,2角标元素互换。
		sortDemo();
		
		//MaxDemo();
		
		//binarySearchDemo();
	}
	//sort();不能给Set排序，因为Set有TreeSet
	public static void sortDemo()
	{
		List<String> l=new ArrayList<String>();
		
		l.add("rgdsh");
		l.add("dg");
		l.add("gfdhth");
		l.add("dsggr");
		l.add("nhm");
				
		sop(l);
		Collections.sort(l);//重复的也能存。因为ArrayList是数组结构。
		sop(l);
		Collections.shuffle(l);//随机顺序
		sop(l);
		Collections.sort(l,new LengthComparator());//将自定义的比较器传入sort方法
		sop(l);
	}
	
	//max()
	public static void MaxDemo()
	{
		List<String> l=new ArrayList<String>();
		
		l.add("rgdsh");
		l.add("dg");
		l.add("gfdhth");
		l.add("dsggr");
		l.add("nhm");
				
		sop(Collections.max(l));
		//将自定义长度比较器传入max方法，结果是最大长度
		sop(Collections.max(l,new LengthComparator()));//注意要“new”对象
	}
	
	//binarySearch();要用到此方法，集合必须是有序的。
	public static void binarySearchDemo()
	{
		List<String> l=new ArrayList<String>();
		
		l.add("rgdsh");
		l.add("dg");
		l.add("gfdhth");
		l.add("dsggr");
		l.add("nhm");
		
		Collections.sort(l);//先让集合有序
		int index= Collections.binarySearch(l,"dg");
		sop(index);
	}
	
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}




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

 

集合变数组：

import java.util.*;

public class CollectionsToArray 
{
	public static void main(String[] args)
	{
		//为什么要将集合变成数组？ 为了限制操作，不让增删。
		ArrayList<String> al=new ArrayList<String>();
		
		al.add("123");
		al.add("eg");
		al.add("tre");
		al.add("er");
		String[] arr=al.toArray(new String[al.size()]);
		System.out.println(Arrays.toString(arr));
	}
}

 reverseOrder()方法

import java.util.*;
//其实reverseOrder()返回的比较器就是将接口颠倒后，如下

class mfreverseOrder implements Comparator<String>
{
	public int compare(String s1,String s2)
	{
		return s2.compareTo(s1);//此处颠倒
	}
}

public class CollectionsDemo2 
{
	public static void main(String[] args)
	{
		orderDemo();
	}
	

	
	public static void orderDemo()
	{
		//如果TreeSet传入自定义的长度比较器则按长度排序完成后还按照TreeSet的默认自然顺序次排序。
		//还可以将自定义的比较器传入reverseOrder(),如Collections.reverseOrder(new LengthComparator());将自定义的比较器反转
		TreeSet<String> t=new TreeSet<String>(Collections.reverseOrder());//此处传入reverseOrder();返回的比较器会反转顺序
		
		t.add("fagh");
		t.add("adrfgr");
		t.add("cvd");
		t.add("egh");
		t.add("h");
		//TreeSet用迭代器是自然顺序。
		Iterator<String> it=t.iterator();
		while(it.hasNext())
		{
			sop(it.next());
		}
	}
	
	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,42,5};
		sop(Arrays.toString(arr));//直接用Arrays里的toString()实现打印，以前使用StringBuffer实现。
		
		//asList();将数组变成集合
		//好处：可以用集合的方法操作数组，但不可以增删，其他不影响长度的方法都可以使用。
		List<Integer> l=Arrays.asList(arr);//数组元素是对象则变成集合元素，是基本数据类型则该数组变成元素。
		sop(l);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

}

 

高级for循环：

public class ForEachDemo 
{
	public static void main(String[] args)
	{
		ArrayList<String> al=new ArrayList<String>();
		
		al.add("123");
		al.add("eg");
		al.add("tre");
		al.add("er");
		
		
		//ArrayList集合取出元素有两种方式：Set只有一种取出方式
		/*
		 *用高级for只能获取不能操作
		 *用iterator可以进行remove
		 *用ListIterator可以进行增删改查 */
		//1.Iterator
		Iterator<String> it=al.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
		//2.for循环
		for(int x=0;x<100;x++)//可以定义初始化值和条件，在数组遍历时使用传统for，可以定义数组角标
		
		//1.5以后 高级for   不改变集合中的元素  也可以操作数组
		for(String s: al)
		{
			System.out.println(s);
		}
		
		
		HashMap<Integer,String> h=new HashMap<Integer, String>();
		h.put(1,"a");
		h.put(2,"d");
		h.put(3,"f");
		//取出HashMap先变成Set
		
		Set<Integer> keySet=h.keySet();
		//keySet()
		for(Integer i: keySet)
		{
			System.out.println(i+h.get(i));
		}
		//entrySet()
		for(Map.Entry<Integer,String> e: h.entrySet())
		{
			System.out.println(e.getKey()+e.getValue());
		}
		
	}
}

 

1.5版本新特性

1，可变参数

public class ParamMethodDemo 
{
	public static void main(String[] args)
	{
		show(1,3,5);
	}
	public static void show(int... arr)//可变参数的，不用new了，简化书写。可以写成(String str,int... arr)可变参数定义在后边
	{
		System.out.println(arr.length);
	}
}

 

2，静态导入

import java.util.*;
import static java.util.Arrays.*;
public class StaticImport 
{
	public static void main(String[] args)
	{
		int[] arr={2,44,6};
		
		/*Arrays.*/sort(arr);
		int index=/*Arrays.静态导入后就可以不写了*/binarySearch(arr,44);
		System.out.println(Arrays./*这个得写，为了区分*/toString(arr));
	}
}