工具类 Collections Arrays asList 数组变集合 集合变数组 高级for循环 可变参数 。。。 静态导入

Collections

专门用于对集合操作的工具类，里面都是静态方法。

import java.util.*;
class Test
{
	public static void main(String[] args) 
	{
		sort();
	}
	public static void sort()
	{
		List<String> list = new ArrayList<String>();

		list.add("abbv");
		list.add("dgr");
		list.add("acf");
		list.add("bv");
		list.add("drwe");
//
	    sop(list);
		Collections.sort(list);		//a b c自然排序
		sop(list);
		
		int index = Collections.binarySearch(list,"dgr");//binarySeach前提示有序的
		sop("intex="+index);
		
		sop( Collections.max(list));//最大值的list
//
		sop(list);
		Collections.sort(list,new StrLenComparator());//按字符长度比较
		sop(list);
		sop( Collections.max(list));//最大值长度的list
		sop(list);
///
		sop(list);
		//Collections.fill(list,"aaa"); //替换list全部元素为 aaa。
		sop(list);
/练习，fill方法可以将list集合中的所有元素替换成制定元素
//将list集合中部分元素替换成制定元素。
		sop(list);
		Collections.replaceAll(list,"acf","abb");//替换指定元素为 abb；
		sop(list);
//
		sop(list);
		Collections.reverse(list); //反转list
		sop(list);
//
		sop(list);
		Collections.swap(list,2,3);//调换2个指定脚标元素的位置
		sop(list);
//
		sop(list);
		Collections.shhuffle(list);//随机打乱元素位置
		sop(list);

	}
	public static void sop( Object obj)
	{
		System.out.println(obj);
	}
}
 
class StrLenComparator 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.*;
class Test
{
	public static void main(String[] args) 
	{
		sort();
	}
	public static void sort()
	{
		TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());
		//Collections.reversOrder()  强行反转自然排序
		ts.add("abbv");
		ts.add("dgr");
		ts.add("acf");
		ts.add("bv");
		ts.add("drwe");

		Iterator it = ts.iterator();
		while (it.hasNext())
		{
			sop(it.next());
		}

	}
	public static void sop( Object obj)
	{
		System.out.println(obj);
	}
}

Arrays

Arrays 用于操作数组的工具类
里面都是静态方法！！！

asList 将数组变成list集合

数组变集合

把数组变成list集合的好处？
可以使用集合的思想和方式来操作数组中的元素
注意：
将数组变成集合后，不可以使用集合的增删方法
因为数组的长度是固定的。不能使用增删命令。

 ------------------------------------------------------------------

如果数组中的元素是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。

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

int[] arr={2,4,5}

List <int[]> li2=Arrays.asList(arr);

sop-->[[I@15db9742]

Integer[] arr={2,4,5}

List <Integer[]> li2=Arrays.asList(arr);

sop-->[ 2 ,  4  , 5 ]

import java.util.*;

class Test  
{
	
	public static void main(String[] args) 
	{
///
		int[] arr = {3,4,2};
		sop(Arrays.toString(arr));  //转化成字符串
///
		String[] arr1 = {"fasdf","werwer","vcv"};
		List <String> li=Arrays.asList(arr1);//将数组转化成集合
		sop(li);
		sop("contains="+li.contains("vcv"));//查询数组中的元素
///
		int[] arr2 ={3,4,2};
		List <int[]> li2=Arrays.asList(arr2);//将数组转化成集合
		sop(li2);	//[[I@15db9742]
		//如果数组中的元素都是对象。
	}
	public static void sop( Object obj)
	{
		System.out.println(obj);
	}
}

集合变数组

Collection 接口中的toArray方法

1指定类型的数组到底要定义多长呢。

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

String[] arr=al.toArray(new String[al.size()]);

2，为什么要将集合变数组？
为了限定对元素的操作。不需要进行增删了。

import java.util.*;
class Test
{
	public static void main(String[] args) 
	{
		ArrayList<String>  al=  new ArrayList<String>();
		al.add("aba");
		al.add("df");
		al.add("sav");
		al.add("dfdfe");
/*1指定类型的数组到底要定义多长呢。
 当指定类型的数组长度小于了集合size，那么该方法内部会创建一个新的数组，长度为size。
 当制定类型的数组长度大于类集合size，就不会新创建数组，而是使用传递进来的数组
 所以创建一个刚刚好的数组最为优。
*/
		String[] arr=al.toArray(new String[al.size()]);
		sop(Arrays.toString(arr));
	}
	public static void sop( Object obj)
	{
		System.out.println(obj);
	}
}

高级for循环

底层是Iterator

格式：

for（数据类型变量名：被遍历的集合或数组）

高级for 迭代器 ListIterator 区别

高级for：对集合进行遍历，只能获取结合中的元素，但是不能对集合进行修改。

迭代器：除了遍历，还可以进行remove集合中元素的动作。

ListIterator：可以在遍历的过程中，对集合进行增删改查的动作。

高级for和 传统for循环 区别

高级for有一个局限性，必须有被遍历的对象。

遍历数组的时候，还是建议用传统for，因为传统for能进行脚标的操作。

public class test 
{
	public static void main(String[] args) 
	{
		ArrayList<String> list = new ArrayList<String>();

		list.add("abbv");
		list.add("dgr");
		list.add("acf");
		list.add("bv");
		list.add("drwe");

		for(String s : list )
		{
			sop(s);
		}
	}
	public static void sop(Object obj)
	{System.out.println(obj);}

}

<span style="font-size:10px;">import java.util.*;
public class test 
{
	public static void main(String[] args) 
	{
		HashMap<Integer,String> hm = new HashMap<Integer,String>();

		hm.put(23,"abbv");
		hm.put(41,"dgr");
		hm.put(12,"acf");
		hm.put(24,"bv");

		Set<Integer> keySet = hm.keySet();
		for(Integer i : keySet )
		{
			sop(i);
		}
		
		Set<Map.Entry<Integer, String>> entrySet = hm.entrySet();
		for(Map.Entry<Integer, String> me:  hm.entrySet())
		{
			sop(me.getKey()+"=="+me.getValue());
		}
	}
	public static void sop(Object obj)
	{System.out.println(obj);}
}</span>

JDK1.5版本出现的新特性

可变参数  。。。
其实就是上一种数组参数的简写形式
不用每一次都手动的建立数组对象。
只要将要操作的元素作为参数传递即可
隐式将这种参数封装成了数组。
在使用时注意：可变参数，一定要定义在参数列表的最后面

import java.util.*;
class Test
{
        public static void main(String[] args) 
        {
             sop("haha",1,2,4,3,53,55,4,3,2);
        }
        public static void sop(String str, int... arr)
        {
              System.out.println(arr.length);
        }
}

JDK1.5版本出现的新特性
静态导入
Static Import 

当类名重名时，需要指定具体的包名

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

import java.util.*;
import static java.util.Array.*; //导入的是Arrays这个类中的所有静态成员。
import static java.lang.System.*; //导入System类中所有静态成员。
class Test
{
	public static void main(String[] args) 
	{
	   int [] arr = {1,4,3,5};
	   sort(arr);
	   int index = binarySearch(arr,3);
	   sop("index="+index);
	   sop(Arrays.toString(arr)); //因为Object和Arrays都有toString，所以需要注明。
	}
	public static void sop( Object obj)
	{
		out.println(obj);
	}
}