java day13第十三课 集合的工具类和其他类

集合中的工具类Collections和Arrays

集合框架的工具类：

Collections：

方法sort()
代码示例

package com.rf.collections;

import java.util.*;

public class CollectionsDemo {

public static void main(String[] args) {
// TODO Auto-generated method stub

sortDemo();

}

public static void sortDemo(){

List list = new ArrayList();
list.add("abb");
list.add("abc");
list.add("a");
list.add("aaaaaaaaa");
list.add("baa");
list.add("cba");
list.add("aaa");
System.out.println(list);
// 自然排序
Collections.sort(list);
System.out.println(list);
// 按照字符串长度排序，再自然排序
Collections.sort(list,new Compare());
System.out.println(list);

}

}
package com.rf.collections;

import java.util.Comparator;

public class Compare implements Comparator{

@Override
public int compare(String o1, String o2) {
// TODO Auto-generated method stub

if(o1.length() > o2.length()){
return 1;
}
if(o1.length() < o2.length()){
return -1;
}

return o1.compareTo(o2);
}

}
 

max()方法
package com.rf.collections;

import java.util.*;

public class CollectionsDemo {

public static void main(String[] args) {
// TODO Auto-generated method stub

maxDemo();

}

public static void maxDemo(){
List list = new ArrayList();
list.add("abb");
list.add("abc");
list.add("a");
list.add("aaaaaaaaa");
list.add("baa");
list.add("cba");
list.add("aaa");
Collections.sort(list);
System.out.println(list);
String max = Collections.max(list);
System.out.println(max);
}
｝
 

binarySearch 方法，前提是此集合必须是有序的

package com.rf.collections;

import java.util.*;

public class CollectionsDemo {

public static void main(String[] args) {
// TODO Auto-generated method stub

binarySearchDemo();

}

public static void binarySearchDemo(){
List list = new ArrayList();
list.add("abb");
list.add("abc");
list.add("a");
list.add("aaaaaaaaa");
list.add("baa");
list.add("cba");
list.add("aaa");
Collections.sort(list);
System.out.println(list);
int index = Collections.binarySearch(list,"aaa");
//相当于我们调用half方法，折半查找。
//half(list,"aaa");
System.out.println(index);
}

public static int half(List list,String value){
int max,min,mid;
max = list.size()-1;
min = 0;
while(min <= max){
mid = (max+min)>>1;
String str = list.get(mid);
int num = str.compareTo(value);
if(num > 0){
max = mid - 1;
}else if(num < 0){
min = max + 1;
}else{
return mid;
}
}
return min;

}
fill方法可以将list集合中的所有元素替换成指定元素。

public class CollectionsDemo {

public static void main(String[] args) {
// TODO Auto-generated method stub

fillDemo();

}

public static void fillDemo(){
List list = new ArrayList();
list.add("abb");
list.add("abc");
list.add("a");
list.add("aaaaaaaaa");
list.add("baa");
System.out.println(list);
Collections.fill(list, "qq");
System.out.println(list);
}

}
replaceAll方法和reverse方法

public class CollectionsDemo {

public static void main(String[] args) {
// TODO Auto-generated method stub

replaceAll();

}

public static void replaceAll(){
List list = new ArrayList();
list.add("abb");
list.add("abc");
list.add("a");
list.add("aaaaaaaaa");
list.add("baa");
System.out.println(list);
// 替换
Collections.replaceAll(list, "baa", "cba");
System.out.println(list);
// 反转
Collections.reverse(list);
System.out.println(list);

}

Arrays

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

将数组转换为list集合：

String[] arr = {"abc","aa","cc","bb"};
List list = Arrays.asList(arr);
System.out.println(list);
//判断数组里面是否存在某元素，如果用数组的方法写？
list.contains("cc");
//list.add("ssss");
//java.lang.UnsupportedOperationException 不支持操作异常
//注意：将数组转换为集合，不可以使用集合的增删方法，因为数组的长度是固定的

//如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转换成集合中的元素。
//如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素进行存储
int[] arr = {1,2,3,4};
List<int[]> list = Arrays.asList(arr);
System.out.println(list);

Integer[] arr1 = {1,2,3,4};
List list1 = Arrays.asList(arr1);
System.out.println(list1);
集合转数组：

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

高级for循环：

foreach格式：
for(数据类型 变量名：被遍历的集合(Collection)或者数组){

}
foreach的底层实现原理就是迭代器：
ArrayList list = new ArrayList();
list.add("a1");
list.add("a2");
list.add("a3");

for(String str : list){
str = "123";
System.out.println(str);
}
//foreach对集合进行遍历，只能获取集合的元素，不能对集合进行操作。
System.out.println(list);

//迭代器除了遍历，还可以进行remove集合中的元素动作。如果使用ListIterator还可以再遍历过程中进行增删改查的动作。
Iterator it = list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
传统for循环和高级for循环的区别？

高级for有局限性，必须有被遍历的目标。比如打印helloworld一百次。
所以我们在遍历数组的时候希望使用传统for循环。因为传统for循环可以定义角标

遍历map集合：
HashMap<Integer, String> ha = new HashMap<Integer, String>();
ha.put(1, "zhang");
ha.put(2, "wang");
ha.put(3, "wang");
ha.put(4, "wang");
// 实现1:
Set keySet = ha.keySet();
for(Integer key : keySet){
System.out.println("key = "+key+" value = "+ha.get(key));
}
// 实现2:
for(Map.Entry<Integer, String> mm : ha.entrySet()){
System.out.println("key = "+mm.getKey()+" value = "+mm.getValue());
}
可变参数
JDK1.5版本出现的新特性

package com.rf.arraysDemo;

public class Demo {

public static void main(String[] args) {
// show(1,2);
// show(1,2,3);
// 虽然少定义了参数的方法，但是我们每次都要定义一个数组，作为实际参数
// int[] arr = {3,4};
// show(arr);
// int[] arr1 = {3,4,5};
// show(arr1);
// 可变参数，其实就是上一种数组参数的简写形式，不用每次都手动建立数组对象。只要将
// 要操作的元素作为参数传递即可。隐式将这些参数封装成了数组。
show(1);
show(11,1,1,1,1,1,1,1,1,1,1,1);

}

public static void show(int... arr){
System.out.println(arr);
}

// public static void show(int[] arr){
//
// }
// public static void show(int a,int b){
//
//
// }
// public static void show(int a,int b,int c){
//
//
//
// }

}
静态导入

import java.util.;
import static java.util.Arrays.;// 导入的是Arrays这个类中的所有成员

public class Demo {

public static void main(String[] args) {

int[] arr ={1,2,2,5,7,8,4,3};
sort(arr);
int index = binarySearch(arr, 5);
// 当方法重名时，需要指定具体的包名
// 当方法重名时，指定所属的对象或者类
System.out.println(Arrays.toString(arr));
System.out.println(index);
}
}

其他对象

System

/*描述系统的一些信息，不能被实例化.他的方法和属性都是静态的
out代表：标准输出，默认是控制台
in代表：标准输入，默认键盘
获取系统属性信息：getProperties()
*/ 
	public static void main(String[] args) {
		Properties p = System.getProperties();
//	 	因为Properties是Hashtable的子类，也就是Map集合的一个子类对象
//		我们可以通过Map的方法取出该集合中的元素
//		该集合中存储的都是字符串，没有泛型定义
//		获取所有属性信息
		for (Object obj : p.keySet()){
			String value = (String)p.get(obj);
			System.out.println(obj+"::"+value);
		}

		//		如何在系统中自定义一些特有的属性信息
		System.setProperty("mykey", "mymac");
//		获取指定属性信息
		System.getProperty("mykey");
		
	}

Runtime

	/*
	该类中没有提供构造函数，说明我们不能new对象。我们如何使用其中的方法，该类中存在非静态方法，
	该类肯定会提供一个方法获取本类对象，而且该方法是静态的，并返回值类型是本类类型的。由这里能看出该类使用了单例设计模式
	该方法为getRuntime（）
	*/
		

Date

	public class DateDemo {

	public static void main(String[] args) throws IOException{
		// TODO Auto-generated method stub

		Date d = new Date();
		System.out.println(d);//打印时间看着不爽，希望格式能一目了然
		//将模式封装到SimpleDateFormat对象中
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 E HH:mm:ss");
		//调用format方法让模式格式化date对象
		String time = sdf.format(d);
		System.out.println(time);
		
	}

}
	

Calendar

	public class CalendarDemo {
	public static void main(String[] args) {
		Calendar c = Calendar.getInstance();
//		设置日期
//		c.set(2017, 4, 26);
//		add方法对时间量的偏移
		c.add(Calendar.YEAR, -1);
		print(c);
	}
	
	
	public static void print(Calendar c){
		System.out.println(c.get(Calendar.YEAR)+"年");
//		System.out.println((c.get(Calendar.MONTH)+1)+"月");
		System.out.println(c.get(Calendar.DAY_OF_MONTH)+"日");
//		System.out.println("星期"+c.get(Calendar.DAY_OF_WEEK));
		
		
		String[] months = {"一月","二月","三月","四月","五月","六月","七月","八月","九月","十月","十一月","十二月"};
		String[] weeks = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
		
		int index = c.get(Calendar.MONTH);
		int index1 = c.get(Calendar.DAY_OF_WEEK);
		
		System.out.println(months[index]);
		System.out.println(weeks[index1]);
		
		
		
	}
	//练习：1、获取任意年的二月有多少天？
			2、获取昨天的这个时刻？