Java基础<十>_集合(下)

集合(下)
五、工具类

5.1、Collections

Collections是一个操作集合的工具类，它没有向外提供构造方法，不可以用new创建对象，并且向外提供的方法都是静态的，所以可以直接用类名.方法()的方式使用。下面介绍几个常用方法：

public static <T extends Comparable<? super T>> void sort(List<T> list)：

该方法用于给list集合进行排序；要进行排序，首先要元素具备比较性，那么用泛型来限定。

public static <T> void sort(List<T> list, Comparator<? super
T> c)：

传入比较器的方式进行排序，元素不一定要具备比较性。

public static <T extends Object &Comparable<? super T>> T max(Collection<?
extends T> coll)：

取最大值；首先要元素具备比较性，用泛型来限定。

public static <T> int binarySearch(List<? extendsComparable<?
super T>> list, T key)：

对有序集合List集合的二分查找，元素必须具备比较性，用泛型限定。

public static <T> int binarySearch(List<?extends T> list, T key, Comparator<?super
T> c)：

二分查找，传入比较器，不一定要元素自身具备比较性。

static <T> void fill(List<? super T> list,T obj)：

使用指定元素替换指定列表中的所有元素。

static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)：

使用另一个值替换列表中出现的所有某一指定值。

static void reverse(List<?> list)：

反转指定列表中元素的顺序。

static <T> Comparator<T> reverseOrder(Comparator<T> cmp)：

返回一个比较器，它强行逆转指定比较器的顺序

static <T> List<T> synchronizedList(List<T> list)：

返回指定列表支持的同步（线程安全的）列表。映射，Set同理！

下面代码演示：

1：

package itheima.day17;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class CollectionsDemo {

public static void main(String[] args) {

List<String> list = new ArrayList<String>();
//		添加元素
list.add("abcv");
list.add("cbcv");
list.add("abdgfd");
list.add("bav");
list.add("ab");
list.add("jhghk");
sop(list);

//		排序，按照字符串的默认形式
//		Collections.sort(list);
//		排序，传进比较器
Collections.sort(list,new StrLenComparator());
sop(list);

//		取最大值，按照字符串的默认形式
//		String max = Collections.max(list);
//		取最大值，传进比较器
String max = Collections.max(list,new StrLenComparator());
sop(max);

//		二分查找，默认方式
//		int index = Collections.binarySearch(list,"jhghk");
//		二分查找，传入比较器
int index = Collections.binarySearch(list,"jhghk",new StrLenComparator());
sop(index);

//		int index1 = halfSearch(list,"jhghk");
int index1 = halfSearch2(list,"jhghk",new StrLenComparator());
sop(index);
}

//	自定义的二分查找，没比较器
public static  int halfSearch(List<String> list,String key){

int max,min,mid;
max = list.size()-1;
min =0;

while(min<=max){
mid = (min+max)>>1;
String str = list.get(mid);
int num = str.compareTo(key);

if(num>0)
max = mid-1;
else if(num<0)
min = mid+1;
else
return mid;
}
//		min就是元素的插入点
return -min-1;
}

//	自定义的二分查找，比较器
public static  int halfSearch2(List<String> list,String key,Comparator<String> cmp){

int max,min,mid;
max = list.size()-1;
min =0;

while(min<=max){
mid = (min+max)>>1;
String str = list.get(mid);
//			用比较器比较
int num = cmp.compare(str, key);

if(num>0)
max = mid-1;
else if(num<0)
min = mid+1;
else
return mid;
}
return -min-1;
}
public static void sop(Object obj){
System.out.println(obj);
}
}

//自定义的比较器，创建一个类实现Comparator，覆盖compare(o1,o2)方法
class StrLenComparator implements Comparator<String>{
@Override
public int compare(String o1, String o2) {
//		按照字符串长度排序
int num = o1.length()-o2.length();
if(num == 0)
return o1.compareTo(o2);
return num;
}
}

2：

package itheima.day17;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.TreeSet;

import itheima.day17.StrLenComparator;//导入比较器

public class CollectionsDemo2 {
public static void main(String[] args) {

//		fillDemo();
ReplaceAll();
//		orderDemo();
}

//	练习：将list集合中部分元素替换成指定元素
public static void fillDemo(){

List<String> list = new ArrayList<String>();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
sop(list);

//		把list集合中所有的元素替代为"abc"
Collections.fill(list, "abc");
sop(list);
}

public static void ReplaceAll(){

List<String> list = new ArrayList<String>();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
sop(list);

//		替代"abc2"为"123"
Collections.replaceAll(list, "abc2", "123");
sop(list);

//		反序
Collections.reverse(list);
sop(list);

//		交换两个位置的数
Collections.swap(list, 1, 2);
sop(list);

//		使用默认随机源对指定列表进行置换，随机数！
Collections.shuffle(list);
sop(list);
}

public static void orderDemo(){

//		Collections.reverseOrder(new StrLenComparator())：  将原来的比较器反序
TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));
ts.add("asdv1111");
ts.add("bsdv111");
ts.add("csdv1");
ts.add("dsdv11");
ts.add("esdv");

//		迭代器方式取出
Iterator it = ts.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}

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

5.2、Arrays

Arrays是一个操作数组的工具类，同Collections一样，不可创建对象，方法都是静态的，所以用类名.方法的形式调用。

数组变集合：static <T> List<T> asList(T… a): 返回一个受指定数组支持的固定大小的列表。

数组变list集合的好处：数组功能比较少，集合功能多，可以用集合的思想和方法来操作数组中的元素。

注意：将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的；如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素；如果数组中的元素是基本数据类型，那么会将该数组作为集合中的元素存在。

集合变数组：Collection接口中的toArray()方法。

1、

Object[] toArray():返回包含此 collection 中所有元素的数组;

2、<T> T[] toArray(T[] a)：返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

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

集合变数组的好处：为了限定对元素的操作，不需要增删，就变成数组。

Arrays工具类封装了很多操作数组的静态方法，比如：二分查找、排序、数组变成字符串等等，详情请查阅API。

代码演示：

package itheima.day17;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

//演示Arrays工具类
public class ArraysDemo {
public static void main(String[] args) {

int[] intArr = {2,3,4};
//		将各种数组变成字符串
sop(Arrays.toString(intArr));

String[] arr ={"abc","cc","dg"};
//		将数组转成List集合
List<String> list = Arrays.asList(arr);
sop(list);

//		数组变集合后，不可用集合的增删方法，因为数组的长度是固定的
sop("contains:::"+list.contains("cc"));
//		java.lang.UnsupportedOperationException
//		list.add("aa");

//		如果数组中元素是对象，那么变成集合时，数组中元素就直接转为集合元素；
//		如果数组中元素是基本数据类型，那么会将该数组作为集合中的元素。
//		int[] num = {2,5,6};
//		List<int[]> li = Arrays.asList(num);
Integer[] num = {2,5,6};
List<Integer> li = Arrays.asList(num);
sop(li);

ListToArray();
}
public static void ListToArray(){

ArrayList<String> al = new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
al.add("abc4");
//		集合变数组
String[] arr = al.toArray(new String[al.size()]);
//		数组变成字符串
System.out.println(Arrays.toString(arr));
}

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

六、特性

6.1、高级for循环

Collection在JDK1.5后出现的父接口public interface Iterable<T>,实现这个接口的对象可以允许成为foreach语句的遍历目标。

高级for循环格式：for(数据类型 变量名:被遍历的集合(Collection)或者数组){执行语句;}；其实底层原理还是迭代器，这个升级，简化书写。

注意：对集合进行遍历，只能获取，但不能对集合进行过多的操作；迭代器除了遍历，还可以进行remove()集合中元素的动作；如果用ListIterator，还可以在遍历的过程中进行增删改查的操作。

与传统for循环区别：高级for有一个局限性，必须要有被遍历的目标；遍历数组时，还是希望是用传统for，因为传统for可以定义角标。

6.2、可变参数

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

注意：可变参数一定要定义在参数列表的最后面。

6.3、静态导入

静态导入：import static；当类名重名时，需要指定具体的包名；当方法重名时，需指定具备所属的对象或者类。

下面代码演示：

package itheima.day17;

//静态导入：这是一种很变态的做法！
import static java.lang.System.*;

public class ParamMethodDemo {

public static void main(String[] args) {

//		int[] arr = {3,4};
show(3,4);
//		int[] arr1 = {1,2,3,4,5};
show(1,2,3,4,5);
}
//	可变参数
public static void show(int... arr){

out.println("length:::::"+arr.length);
//		高级for循环
for(int i:arr){
out.print(i+"  ");
}
System.out.println();
}
}

七、其他几个类

在介绍这些类之前说明，记住这些类不是重点，重点是通过这些类的介绍熟悉该怎么去查看API文档。

7.1、System类

System是用来描述系统信息的一个工具类，该类包含一些有用的类字段和方法。它不能被实例化，说明没有向外暴露构造函数，那么方法一定是静态的，用类名调用。

Out：标准输出，默认是控制台；in： 标准输入，默认是键盘。该集合中存储的都是字符串，没有定义泛型。

下面代码演示：

package itheima.day18;

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

//演示System工具类
public class SystemDemo {
public static void main(String[] args) {

Properties pro = System.getProperties();

//		Set keySet = pro.keySet();
//		Iterator it = keySet.iterator();
//		while(it.hasNext()){
//			Object key = it.next();
//			Object value = pro.get(key);
//			System.out.println(key+":::"+value);
//		}

//		设置属性
System.setProperty("myKey","myvalue");
//		获取属性
String value = System.getProperty("myKey");
System.out.println("value = "+value);
//		获取属性
String osName = System.getProperty("os.name");
System.out.println("Operation System::::"+osName);

//		该集合中存储的都是字符串，没有定义泛型
//		for(Object obj:pro.keySet()){
//			String value = (String)pro.get(obj);
//			System.out.println(obj+":::"+value);
//		}

}
}

7.2、Runtime

Runtime：每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。该类中的方法都是静态的，采用的是单例设计模式。通过getRuntime()方法获取运行时的对象。

下面代码演示：

package itheima.day18;

import java.io.IOException;

//演示Runtime类
public class RuntimeDemo {
public static void main(String[] args) throws IOException, InterruptedException {

//		获取Runtime对象
Runtime r = Runtime.getRuntime();
Process p =	r.exec("C:\\Program Files\\Ludashi\\ComputerZ_CN.exe");
Thread.sleep(5000);
p.destroy();
}
}

7.3、Date、Calendar

Date是一个日期类，但很多方法都过时了，参见DateFormat，但该类抽象，用SimpleDateFormat子类实现。

Calendar也是一个时间日期的类。

下面代码演示：

1：日期类的格式化：

package itheima.day05;

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

public class DateDemo {

public static void main(String[] args) {

Date d = new Date();
//		打印的时间看不懂，希望有些格式
System.out.println(d);

//		将模式封装到SimpleDateformat对象中
//		其实封装日期格式的类是DateFormat，但该类为抽象类，SimpleDateFormat为它的实现类
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日E  hh:mm:ss");

//		调用format方法让模式格式化指定的Date对象
String time = sdf.format(d);
System.out.println("time = "+time);
}
}

2：前面只是简单的格式化日期，但获取日期中的某个字段还是有Calendar比较优

package itheima.day05;

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

public class CalendarDemo {

public static void main(String[] args) {

Date d = new Date();
//		打印，可以获取到的是日期的全部，可是现在的需求是仅仅获取年
System.out.println(d);

//		那就仅仅格式化年的字段，即可
SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
String year= sdf.format(d);
System.out.println(year);

//		Calender类是一个抽象类，但有获取对象的方法
Calendar  c = Calendar.getInstance();

System.out.println(c.get(Calendar.YEAR)+"年"+(c.get(Calendar.MONTH)+1)+"月"+c.get(Calendar.DAY_OF_MONTH)+"日");
System.out.println("星期"+c.get(Calendar.DAY_OF_WEEK));

//		上面的方式太麻烦，可以使用查表法
String[] mons ={"一月","二月","三月","四月",
"五月","六月","七月","八月",
"九月","十月","十一月","十二月"};
String[] weeks ={"","星期日","星期一","星期二","星期三",
"星期四","星期五","星期六"};

int index = c.get(Calendar.MONTH);
int index1 = c.get(Calendar.DAY_OF_WEEK);
sop(mons[index]);
sop(weeks[index1]);
}

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

3：

package itheima.day18;

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

//练习1：获取任意年的二月有多少天。
// 思路：根据指定年设定一个时间就是c.set(year,2,1)//某一年的3月1日
//      c.add(Calendar.DAY_OF_MONTH,-1)//往前推一天，获取天数
//  2练习：获取昨天的现在这个时刻？
// 		c.add(Calendar.DAY_OF_MONTH,-1)
public class CalendarTest {

public static void main(String[] args) {
test1();
test2();
}

public static void test1(){

Date d = new Date();
Calendar c = Calendar.getInstance();
//		时间设为2012年
c.set(2012,2,1);
c.add(Calendar.DAY_OF_MONTH, -1);
int day =c.get(Calendar.DAY_OF_MONTH);
System.out.println(day);
}

public static void test2(){

Calendar c = Calendar.getInstance();
c.add(Calendar.DAY_OF_MONTH,-1);

Date d = new Date();
d = c.getTime();

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

7.4、Math

Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数；其实用得最多的还是生成随机数。

下面代码演示：

1：基本演示：

package itheima.day18;

import java.util.Random;

public class MathDemo {

public static void main(String[] args) {

//		通过Random类产生随机数
Random r = new Random();
for(int x =0;x<10;x++){
//			int d =(int)(Math.random()*6+1);
int d =r.nextInt(6);
sop(d);
}
//		show();
//		Test();
}
public static void show(){
//		进1
double d = Math.ceil(15.2);
//		取整
double d1 = Math.floor(12.35);
//		四舍五入
long l = Math.round(14.23);
sop("d="+d);
sop("d1="+d1);
sop("l="+l);
//		2的3次幂
double d2 = Math.pow(2,3);
sop("d2 = "+d2);
}
//	给定一个小数，保留小数后的两位
public static void Test(){

//		获取一个0--100之间的浮点数
Random r = new Random();
double d = r.nextDouble()*100;
sop("d = "+d);
//		舍弃后面的小数
int temp = (int)(d*100);
//		获取
d = temp/100.0;
sop("d = "+d);
}

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

2、练习一枚：

package itheima.day18;

//练习：给定一个小数，保留小数的后两位
import java.util.Random;

public class MathTest {
public static void main(String[] args){

//		产生一个随机数
Random r = new Random();
//		产生一个0--1.0之间的随机数
double d = r.nextDouble()*100;
System.out.println("d = " + d);

//		前移两位，转成整数，去除后面的小数
int temp = (int)(d * 100);
//		再转成小数
d = (double)temp / 100;
System.out.println("d = " + d);
}
}