黑马程序员--java基础--集合（三）

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

第八部分：Collections工具类

Collections是集合框架的工具类，里面存在能对List集合容器操作的方法，并且这些方法都是静态的。下面将对方法一一介绍：
1、static void sort(List<T> list)：根据元素的自然顺序对指定列表进行升序排序。
static void sort(List<T> list：根据指定比较器产生的顺序对指定列表进行排序。

a、根据元素的自然顺序排序代码示例：

class HelloDemo {
	public static void main(String[] args) 
	{
		List<String> list = new ArrayList<String>();
		list.add("avced");
		list.add("av");
		list.add("aved");
		list.add("ed");
		list.add("zz");
		Collections.sort(list);//给list按照字母顺序排序，从第一个开始
		System.out.println(list);
	}
}

输出结果：

[av, avced, aved, ed, zz]//根据字符的ASCII值进行比较

b、根据比较器进行比较。这里需求是先按照字符串的长度进行比较，长度相同再根绝字符比较。

代码示例：

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

//主函数
Collections.sort(list,new StrLenComparator());
System.out.println(list);

输出结果：

[av, ed, zz, aved, avced]

2、static max(Collection<? extends T> coll)：返回自然顺序排序后的List容器内的最大元素。

如果需要自定义的顺序，往里传入比较器参数即可。




3、static binarySearch(List<? extends Comparable<? super T>> list, T key)：使用二分搜索法搜索指定列表，以获得指定对象。

同样可以传入比较器。

P.S 如果要查找的key不存在与容器内，则返回的是-（插入点）-1

代码示例：

List<String> list = new ArrayList<String>();
list.add("avced");
list.add("av");
list.add("aved");
list.add("ed");
list.add("zz");
Collections.sort(list,new StrLenComparator());
int index1 = Collections.binarySearch(list,"zzz");//如果zzz不存在，返回插入点的负数再减一。这里是-6
System.out.println(index1);

输出结果：

[avced, av, aved, ed, zz]
-6

因为按照自然顺序排序后"zzz"应该插入的位置角标是5，按照公式则返回-5-1=-6

4、static <T> void fill(List list, T obj)：使用指定元素obj替换列表的所有元素

5、static <T> boolean replaceAll(List list,T oldVal, T newVal)：使用另一个值newVal替换列表中出现的所有某一指定值oldVal。

6、static oid reverse(List list)：反转指定列表中元素的位置。

7、（重点）

static<T> Comparator<T> reverseOrder()：返回一个比较器，它强行逆转实现了Comparable 接口的对象 collection 的自然顺序。

代码示例：

	public static void main(String[] args) 
	{
		TreeSet<String> ts  = new TreeSet<String>(Collections.reverseOrder());//将自然元素顺序强行逆转
		ts.add("abcde");
		ts.add("aaa");
		ts.add("kkk");
		ts.add("ccc");
		
		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			System.out.print(it.next()+" ");
		}
	}

输出结果：

kkk ccc abcde aaa 

同时也可以已经实现好的比较器进行强制转换顺序。

代码示例：

TreeSet<String> ts  = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));

StrLenComparetor()即为新的比较器。

8、static void swap(List list, int i, int j)：将List容器中指定位置i和j的元素进行调换。

static void shuffle(List list)：对指定列表的所有元素以随机方式进行重新排序。

第九部分：Arrays工具类

Arrays工具类是用于操作数组的工作类，里面都是静态方法。下面将介绍里面的方法。

1、重点：List asList(数组)将数组转成集合。
这个方法的好处是：可以使用集合的思想和方法来操作数组中的元素
注意：将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的
可以使用的是：contains()、get()、indexOf(Object obj)：返回obj第一次出现的位置、subList()方法。
但是如果发生增删操作了，那么会发生UnsupportedOperationException。

代码示例：

String[] arr = {"aaa","cc","dsd"};
List<String> ls = Arrays.asList(arr);
System.out.println("contains:"+ls.contains("cc"));
System.out.println(ls);

这里需要注意的是：

如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中元素；
如果数组中的元素都是基本数据类型，那么会将该数组整体作为集合中的单个元素存在。因此如果存入int[]数组时候，应该这么存：

int[] arr = {2,3,4};
List<int[]> list = Arrays.asList(arr);

或者另一种方法：

Integer[] arr = {2,4,5};
List<Integer> list = Arrays.asList(arr);

2、上面提到的数组转成集合，那么下面将介绍怎么将集合转成数组。

这里使用的方法是接口Collection的toArray()方法。

代码示例：

class  
{
	public static void main(String[] args) 
	{
		ArrayList<String> al = new ArrayList<String>();
		al.add("abc");
		al.add("c");
		al.add("s");

		/*
		1、指定类型的数组到底要定义多长？
		当指定类型的数组小于了集合的size，那么该方法内部会创建一个新的数组，长度为集合的size
		当指定类型的数组长度大于了集合的size，就不会新创建数组。而是使用传递进来的数组
		所以创建一个刚刚好的数组最最优
		2、为什么要将集合变成数组
		为了限定对元素的操作。
		不需要进行增删了。
		*/
		String[] arr = al.toArray(new String[al.size()]);
		System.out.println(Arrays.toString(arr));//打印数组的元素
	}
}

第十部分：其他对象类

1、System

System:类中的方法和属性都是静态的
out：标准输出，默认是控制台
in：标准输入，默认是键盘
获取系统属性信息：Properties getProperties()

方法示例：

import java.util.Properties;
import java.util.Set;

public class HelloDemo {
	public static void main(String[] args) {
		// 获取系统的属性信息，并存储到了Properties集合中
		Properties prop = System.getProperties();

		Set<String> nameSet = prop.stringPropertyNames();

		for (String name : nameSet) {
			String value = prop.getProperty(name);
			System.out.println(name + " = " + value);
		}
	}
}

2、Runtime

该类中并没有提供构造函数。说明不可以new对象，会直接想到该类中的方法都是静态的。
发现该类中还有非静态方法，说明该类肯定会提供一个方法，获取本类对象。而且该方法是静态的，并且返回值类型是本类类型。
由这个特点可以看出，该类使用了单例设计模式完成。

代码示例：

class  
{
	public static void main(String[] args) throws Exception
	{
		Runtime r = Runtime.getRuntime();
		
		//启动程序和杀掉子进程
		Process p = r.exec("D:\\Program Files (x86)\\360\\360zip\\360zip.exe");
		Thread.sleep(4000);
		p.destroy();
	}
}

3、Date和SimpleDateFormat的联合使用

代码示例

import java.text.SimpleDateFormat;
import java.util.Date;

public class HelloDemo {
	public static void main(String[] args) {
		Date d = new Date();
		System.out.println(d);
		// 打印的事件看不懂，希望有些格式

		// 将模式封装到SimpleDateFormat对象中
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
		SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日E hh:mm:ss");
		// 调用format方法让模式格式化指定Date对象
		String time = sdf.format(d);
		String time1 = sdf1.format(d);

		System.out.println(time);
		System.out.println(time1);
	}
}

输出结果：

Wed Aug 12 19:56:59 GMT+08:00 2015
2015年08月12日
2015年08月12日星期三 07:56:59

4、Calendar 类

Calendar是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。

这个方法使用查表法比较好：

String[] mons = {"一月","二月","三月","四月","五月","六月","七月","八月","九月","十月","十一月","十二月"};
String[] weeks = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};

获取年：

Calendar c = Calendar.getInstance();
System.out.println(c.get(Calendar.YEAR)+"年");

获取月份：

int num = c.get(Calendar.MONTH);
System.out.println(mons[num]);

获取星期：

int index = c.get(Calendar.DAY_OF_WEEK);
System.out.println(weeks[index]);

获取一个月中的天数

System.out.println(c.get(Calendar.DAY_OF_MONTH)+"日");

5、Math类

Math.ceil(double d):返回大于指定数据的最小整数
Math.floor(double d):返回小于指定数据的最大整数
Math.round(double d):四舍五入，返回long型
Math.pow(int a,int b):返回a的b次幂

小知识点，获取随机数

<span style="font-size:14px;">Random r = new Random();
int x = r.nextInt(10)+1;</span>

第十一部分：小知识点

1、增强for循环

格式：
for(数据类型 变量名： 遍历的集合(Collection)或者数组)
{}
对集合进行遍历：只能获取集合中的元素，但是不能对集合进行操作。
迭代器除了遍历，还可以进行remove集合中元素的操作
如果是用ListIterator，还可以在遍历过程中对集合元素进行增删查改

传统for循环和高级for循环有什么区别？
高级for有一个局限性，必须有被遍历的目标。

注：建议在遍历数组时候，还是使用传统for。因为传统for可以定义角标

代码示例：

class  
{
	public static void main(String[] args) 
	{
		ArrayList<String> al = new ArrayList<String>();
		al.add("abc");
		al.add("c");
		al.add("s");
		
		for(String s : al)
		{
			System.out.println(s);
		}	

		int[] arr = {3,5,1};
		for(int i:arr)
		{
			。。。
		}

		//map不支持迭代器
		HashMap<Integer,String> hm = new HashMap<Integer,String>();
		hm.put(1,"a");
		hm.put(2,"b");
		hm.put(3,"c");
		Set<Integer> keySet = hm.keySet();
		for(Integer i : keySet)
		{
			sop(i+":"+hm.get(i));
		}

		HashMap<Integer,String> hm = new HashMap<Integer,String>();
		hm.put(1,"a");
		hm.put(2,"b");
		hm.put(3,"c");
		Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();
		for(Map.Entry<Integer,String> me : entrySet)//for(Map.Entry<Integer,String> me : hm.entrySet())
		{
			sop(me.getKey()+":"+me.getValue());
		}
		//诀窍，set什么类型，冒号:左边就是什么类型
	}
}

2、可变参数

JDK1.5以后出现的新特性
可变参数，其实就是上一种数组参数的简写形式。不用每一次都手动的建立数组对象，只要将操作的元素作为参数传递即可。
隐式将这些参数封装成了数组。
(int... arr)

方法的可变参数
使用时注意：可变参数一定要定义在参数列表的最后面
如(String str , int... arr)
代码示例：

class  
{
	public static void main(String[] args) 
	{
		show(2,3);
		show(2,3,4,3,7,23);
		show();
	}
	public static void show(int... arr)
	{
		sop(arr.length);
	}
}

3、静态导入

导入类中的所有静态成员。

使用示例：

import java.util.*;
import static java.util.Arrays.*;//导入的是Array这个类中的所有静态成员
class Demo//extends Object
{
	public static void main(String[] args) 
	{
		//导入前	
		int[] arr = {1,3,4};
		Arrays.sort(arr);
		int index = Arrays.binarySearch(arr,1);
		System.out.println(Arrays.toString(arr));
		System.out.println(index);

		//导入以后
		int[] arr = {1,3,4};
		sort(arr);
		int index = binarySearch(arr,1);
		System.out.println(Arrays.toString(arr));//这里Arrays必须写，因为Object里也有这个方法
		System.out.println(index);
	}
}