集合(下)
五、工具类
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);
}
}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);
}
}
8323
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
