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<String> list = new ArrayList<String>();
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<String>{
@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<String> list = new ArrayList<String>();
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<String> list = new ArrayList<String>();
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<String> 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<String> list = new ArrayList<String>();
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<String> list = new ArrayList<String>();
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
用于操作数组的工具类，里面都是静态方法，
将数组转换为list集合：
String[] arr = {"abc","aa","cc","bb"};
List<String> 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<Integer> list1 = Arrays.asList(arr1);
System.out.println(list1);
集合转数组：
ArrayList<String> list = new ArrayList<String>();
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<String> list = new ArrayList<String>();
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<String> 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<Integer> 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、获取昨天的这个时刻？
