黑马程序员----工具类和JDK1.5版本新特性

                                                     ------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

工具类和JDK1.5新特性

Collections:专门用来操作集合的工具，其中的方法全部是静态的。

1.Sort:对集合排序，public static<T extends Comparable<? super T>> void sort(List<T> list).

演示：对List集合排序，并实现特有的排序规则：

2.max:q取集合中的最大值，这个最大可以自己编写比较器来进行比较

3.binarySearch(list,k):取给定值的角标，必须是有序的集合才能操作。

package xiaobing.collection;
import java.util.*;

import org.omg.Messaging.SyncScopeHelper;
/*
 * 对一个存储字符串的List集合进行按照字符串长度的排序
 */	
class MyComparator 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);
		}
	}
public class CollectionsDemo01 {
	public static void main(String[] args)
	{
		List<String> list=new ArrayList<String>();
		list.add("a");
		list.add("bc");
		list.add("afet");
		list.add("der");
		list.add("wertf");
		list.add("dwadfg");
		System.out.println(list);
		//调用工具类方法
		Collections.sort(list, new MyComparator());
		System.out.println(list);
		//取到bc的位置
		int index=Collections.binarySearch(list, "bc");
		System.out.println(index);
		/*[a, bc, afet, der, wertf, dwadfg]
                  [a, bc, der, afet, wertf, dwadfg]
                  1
                  这个是打印出的结果
		*/

	}

}

4.fill(list,k);将集合中的所有元素替换为k

5.replace(list,old,new),将集合中的old元素替换为给定的new元素。

package xiaobing.collection;
import java.util.*;
public class CollectionsDemo03 {
	public static void main(String[] args)
	{
		List<String> list=new ArrayList();
		list.add("aa");
		list.add("bb");
		list.add("cc");
		list.add("dd");
		System.out.println(list);
		Collections.fill(list,"kk");//替换所有元素为kk
		System.out.println(list);
		Collections.replaceAll(list, "kk", "gg");//将kk替换为gg
		System.out.println(list);
         /*
          * 打印的结果是
          * [aa, bb, cc, dd]
            [kk, kk, kk, kk]
            [gg, gg, gg, gg]
          */

	}
}

6.reverseOrder(Comparator )将指定比较器强制反向排序。

package xiaobing.collection;
import java.util.*;
public class CollectionsDemo04 {
	public static void main(String[] args)
	{
		TreeSet<String> ts=new TreeSet<String>();
		ts.add("abcde");
		ts.add("aaa");
		ts.add("akk");
		ts.add("ccc");
		System.out.println(ts);
		TreeSet<String> ts1=new TreeSet<String>(Collections.reverseOrder());
		ts1.add("abcde");
		ts1.add("aaa");
		ts1.add("akk");
		ts1.add("ccc");
		System.out.println(ts1);
		/*
		 * 打印结果是：
		 * [aaa, abcde, akk, ccc]
           [ccc, akk, abcde, aaa]
		 * 
		 */

	}
}

7.synchronizedList(list),由于集合在被多线程调用，会出现不安全的情况，使用这个方法就会产生一个线程安全的集合，返回类型为集合。

Arrays：用于操作数组的类

1.asList:将数组变为list集合

package xiaobing.collection;
import java.util.*;
public class ArraysDemo01 {
	public static void main(String[] args)
	{
		String[] arr={"aa","bb","cc"};
		List<String> list=Arrays.asList(arr);
		System.out.println(list);
		//结果：[aa, bb, cc]
		/*
		 * 将数组变为集合的好处：
		 * 可以用集合的思想和方法来操作数组中的元素
		 * 将数组变为集合，不可以使用集合的增删方法，因为数组的长度是固定的
		 */
		/*
		 * 如果数组中的元素都是对象，数组中的元素就直接转成集合的元素
		 * 如果数组中的元素都是基本数据类型，会将该数组作为集合元素存在
		 */
		int[] nums={2,4,5};
		List li=Arrays.asList(nums);
		System.out.println(li);//打印结果为：[[I@659e0bfd]
		Integer[] num={2,4,5};
		List<Integer> li2=Arrays.asList(num);
		System.out.println(li2);//结果为：[2, 4, 5]
	}
}

2.toArray()将集合转换维数组。

package xiaobing.collection;
import java.util.*;
public class ArraysDemo02 {
	public static void main(String[] args)
	{
		ArrayList<String> al=new ArrayList<String>();
		al.add("abc1");
		al.add("abc2");
		al.add("abc3");
		/*
		 * 指定数组的集合需要定义长度规则:
		 * 当指定类型的数字长度小于了集合的size.那么该方法内部会创建一个新的数组，长度为集合的size
		 * 小于集合的长度时，就不会创建，而是使用传递进来的数组
		 * 所以创建一个刚刚好的数据最优
		 * 转换为数组的意义：
		 * 可以限定对元素的操作，不需要进行增删操作
		 * 
		 */
		String[] arr=al.toArray(new String[al.size()]);
		System.out.println(Arrays.toString(arr));

	}
}

扩展

JDK1.5新特性增强for循环：

package xiaobing.collection;
import java.util.*;
/*
 * 高级for循环
 * 格式：
 * for(数据类型 变量名：被遍历的集合(Collection)或数组)
 * {
 * 
 * }
 * 对集合进行遍历，只能获取元素，但是不能对集合进行操作。
 * 迭代器除了遍历还可以进行remove集合中元素的动作
 * 如果listIerator还可以进行增删改查的动作
 * 传统for和高级for的区别：
 * 高级for有一个局限性，必须有被遍历的目标
 * 建议在遍历数组时，使用传统doe，传统for可以操作角标
 */
public class ForEachDemo {
	public static void main(String[] args)
	{
		ArrayList<String> al=new ArrayList<String>();
		al.add("abc1");
		al.add("abc2");
		al.add("abc3");
		for(String str:al)
		{
			System.out.println(str);
		/*
		 * 打印结果是
		 *abc1
		 abc2
		 abc3
		 */
		}
	}
}

JDK1.5版本新特性：可变参数

package xiaobing.collection;
/*
 * 可变参数使用时可变参数一定要定义在参数列表的最后面
 * show(String str,int...arr)>>>正确可用
 * show(int... arr,String str)>>>错误
 */
public class ParamMethodDemo {
	public static void main(String[] args)
	{
		show(2,3,4,5,6);//打印结果为5
		/*
		int []arr={2,3,4};
		show(arr);
		*/
	}
	/*
	 * 可变参数，其实就是上一种数组参数的简写方式
	 * 不用每一次都手动建立数组对象
	 * 只要将操作的元素作为参数传递即可
	 * 隐式的将这些参数封装为了数组
	 */
	public static void show(int... arr)
	{
		System.out.println(arr.length);
	}
	/*
	 * public static void show(int[] arr)
	{
		System.out.println(arr.length);
	}
	 */
	/*
	 * 这个方法实现重载但是每次都需要重新写函数
	public static void show(int a,int b)
	{
		System.out.println(a+","+b);
	}
	public static void show(int a,int b,int c)
	{
		System.out.println(a+","+b+","+c);
	}*/
	
}

JDK1.5版本新特性：静态导入

package xiaobing.collection;
/*
 * 静态导入注意
 * 当类型重名时，需要制定具体的包名
 * 方法重名时，需要制定所属的对象和类
 * 举例：
 * packa中有Demo.class
 * packb中有Demo.class
 * 这时需要new packa.Demo(),指定包名
 */
import java.util.*;
import static java.util.Arrays.*;//导入的都是Arrays类中的静态成员
public class StaticImport {
	public static void main(String[] args)
	{
		int[] arr={3,1,5};
		/*Arrays.sort(arr);
		int index=Arrays.binarySearch(arr, 1);
		System.out.println(Arrays.toString(arr));
		System.out.println("index="+index);*/
		
		//静态导入后，上述可以简写为

		sort(arr);
		int index=binarySearch(arr, 1);
		System.out.println(Arrays.toString(arr));
		System.out.println("index="+index);
	}
}