[学习笔记]Java常用工具类

1.概述

工具类的出现是为了在不用创建对象的前提下更方便地使用一些固定的方法。

2.特点

工具类的方法一般全是静态方法。
工具类的使用一般直接用类名调用方法。
Java5以及更新版本中，可以使用静态导入，这样可以免除类名的输入。

Collections类

1.概述

Collections类是集合框架中的一个工具类，用于操作集合对象，它的方法全都是静态的，不需要创建对象，并未封装特有数据。

2.方法

二分查找

static<T>intbinarySearch(List<?extendsComparable<?superT>>list,Tkey)

static<T>intbinarySearch(List<?extendsT>list,Tkey,Comparator<?superT>c)

获取最大值和最小值

static<TextendsObject&Comparable<?superT>>Tmax(Collection<?extendsT>coll)

static<T>Tmax(Collection<?extendsT>coll,Comparator<?superT>comp)

static<TextendsObject&Comparable<?superT>>Tmin(Collection<?extendsT>coll)

static<T>Tmin(Collection<?extendsT>coll,Comparator<?superT>comp)
全部替换，单独替换和交换

static<T>voidfill(List<?superT>list,Tobj)

static<T>booleanreplaceAll(List<T>list,ToldVal,TnewVal)

staticvoidswap(List<?>list,inti,intj)
逆序排列（直接逆序或获取逆序比较器）

staticvoidreverse(List<?>list)

static<T>Comparator<T>reverseOrder()

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

随机排列

staticvoidshuffle(List<?>list)

staticvoidshuffle(List<?>list,Randomrnd)

排序

static<TextendsComparable<?superT>>voidsort(List<T>list)

static<T>voidsort(List<T>list,Comparator<?superT>c)

获取线程安全的集合

static<T>Collection<T>synchronizedCollection(Collection<T>c)

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

static<K,V>Map<K,V>synchronizedMap(Map<K,V>m)

static<T>Set<T>synchronizedSet(Set<T>s)

3.Collection类和Collections类的区别

Collection是集合框架中的一个顶层接口，提供了单列集合的最基本操作，并且其实现能够提供元素的存储等，所以使用时必须new出集合对象。
Collections是集合框架的一个工具类，由静态方法构成，主要提供了对集合进行操作的一系列方法，所以使用时必须传入集合对象参数。

4.示例

packagetools;

importjava.util.ArrayList;

importjava.util.Collection;

importjava.util.Collections;

importjava.util.List;

importcomparator.ComparatorByLength;

publicclassCollectionsDemo{

publicstaticvoidmain(String[]args){

/*

*1.将非同步的集合转成同步的集合

*2.获取List集合最值。

*3.对List集合排序。

*4.对List集合进行元素插入，并保持有序。

*5.对List集合进行按字符串由长到短排序。

*6.保留List集合前2个以及后2个元素，将其他元素替换为"null"。

*/

List<String>l=newArrayList<String>();

init(l);

//1.将非同步集合转换成同步集合。

List<String>list=Collections.synchronizedList(l);

//2.获取List集合最值。

Stringmax=Collections.max(list);//"zzz"

Stringmin=Collections.min(list);//"abcde"

//3.对List集合排序。

Collections.sort(list);//[abcde,it&java,java,me,nba,zoom,zzz]

//4.对List集合进行元素插入，并保持有序。

Stringstr="niubility";

intindex=Collections.binarySearch(list,str);

//如果集合中无此元素，则返回-(insertionpoint)-1

if(index<0){

index=-(index+1);

}

list.add(index,str);//[abcde,it&java,java,me,nba,niubility,zoom,zzz]

//5.对List集合进行按字符串由长到短排序。

Collections.sort(list,Collections.reverseOrder(newComparatorByLength()));

//[niubility,it&java,abcde,zoom,java,zzz,nba,me]

//6.保留List集合前2个以及后2个元素，将其他元素替换为"null"。

replaceFunc(list);//[niubility,it&java,null,null,null,null,nba,me]

}

privatestaticvoidreplaceFunc(List<String>list){

List<String>l=newArrayList<String>();

//1.先将中间需要替换的元素存入新集合，并在老集合中删除这些元素。

for(inti=2;i<list.size()-2;i++){

l.add(list.get(i));

/*

*由于remove会使得后面的元素替代到这个位置上

*所以要让i--抵消掉下一轮的i++，也就是说重新判断该位置上的元素。

*并且每趟循环必须重新计算list.size();

*/

list.remove(i--);

}

//2.将新集合中的元素全部替换。

Collections.fill(l,"null");

//3.将新集合中的元素全部添加回老集合。

list.addAll(2,l);

}

publicstaticvoidinit(Collection<String>c){

c.clear();

c.add("java");

c.add("abcde");

c.add("zzz");

c.add("it&java");

c.add("me");

c.add("nba");

c.add("zoom");

}

}

Arrays类

1.概述

Arrays类是一个操作数组的工具类，全部由静态方法构成，不需要创建对象，并没有封装特定的数据。

2.方法

将数组转换为集合

static<T>List<T>asList(T...a)
二分查找（以byte为例）

staticintbinarySearch(byte[]a,bytekey)

staticintbinarySearch(byte[]a,intfromIndex,inttoIndex,bytekey)

static<T>intbinarySearch(T[]a,intfromIndex,inttoIndex,Tkey,Comparator<?superT>c)

static<T>intbinarySearch(T[]a,Tkey,Comparator<?superT>c)
填充数据（以byte为例）

staticvoidfill(byte[]a,byteval)

staticvoidfill(byte[]a,intfromIndex,inttoIndex,byteval)
数组复制（以byte为例）

staticbyte[]copyOf(byte[]original,intnewLength)

staticbyte[]copyOfRange(byte[]original,intfrom,intto)
排序（以byte为例）

staticvoidsort(byte[]a)

staticvoidsort(byte[]a,intfromIndex,inttoIndex)

static<T>voidsort(T[]a,Comparator<?superT>c)

static<T>voidsort(T[]a,intfromIndex,inttoIndex,Comparator<?superT>c)
生成字符串（以byte为例）

staticStringtoString(byte[]a)

3.示例

packagetools;

importjava.util.Arrays;

publicclassArraysDemo{

publicstaticvoidmain(String[]args){

/*

*Arrays:用于操作数组的工具类，由一系列静态方法构成。

*1.对数组排序。

*2.二分查找。

*3.数组复制。

*4.对两个数组进行元素的比较，判断两个数组是否相同。

*5.将数组转成字符串。

*/

int[]arr={34,21,67,99,18};

//1.对数组排序。

Arrays.sort(arr);//[18,21,34,67,99]

//2.二分查找。

intindex1=Arrays.binarySearch(arr,55);//-4(-(insertionpoint)-1)

intindex2=Arrays.binarySearch(arr,67);//3

//3.数组复制

int[]arrCopy=Arrays.copyOfRange(arr,1,3);//[21,34]，含头不含尾

//4.对两个数组进行元素的比较，判断两个数组是否相同。

booleanb=Arrays.equals(arr,arrCopy);//false

//5.将数组转换成字符串

Stringstr=Arrays.toString(arr);//[18,21,34,67,99]

System.out.println(str);

}

}

集合和数组的相互转换

1.数组转集合

目的：使得可以使用集合中的方法对元素进行操作。

方法：List<T>Arrays.asList()(T...a)

特点

集合不可修改，因为数组转出的集合为常量集合，否则报UnsupportedOperationException异常。
如果数组中存储的是基本数据类型，那么转成集合，数组对象会作为集合中唯一的元素存在，所以需要注意。

如果数组中存储的是引用数据类型，那么转成集合，数组元素会作为集合元素存在。

2.集合转数组

目的：限制对元素的增删操作。

方法：Collection对象：<T>T[]toArray(T[]a)

特点

如果参数的数组的长度小于集合的长度，会创建一个同类型的数组，长度为集合的长度。

如果参数的数组的长度大于集合的长度，就会使用这个数组，没有存储元素的位置为null。
参数数组的长度最好直接定义为和集合长度一致。

3.示例

packagecollection.list;

importjava.util.ArrayList;

importjava.util.Arrays;

importjava.util.Collection;

importjava.util.List;

publicclassList2Array{

publicstaticvoidmain(String[]args){

/*

*数组转集合

*目的：使得可以使用集合中的方法对元素进行操作。

*但是不可修改集合，因为得到的集合是常量集合，否则UnsupportedOperationException

*如果数组中存储的是基本数据类型，那么转成集合，数组对象会作为集合中唯一的元素存在。

*如果数组中存储的是引用数据类型，那么转成集合，数组元素会作为集合元素存在。

*/

int[]arr={22,85,45,65,19,4,96};

String[]strs={"a","b","c"};

//数组转集合

List<int[]>listArr=Arrays.asList(arr);//[[I@15db9742]

List<String>listStr=Arrays.asList(strs);//[a,b,c]

/*

*集合转数组

*目的：限制对元素的增删操作。

*如果传递的数组的长度小于集合的长度，会创建一个同类型的数组，长度为集合的长度。

*如果传递的数组的长度大于集合的长度，就会使用这个数组，没有存储元素的位置为null。

*长度最好直接定义为和集合长度一致。

*/

Collection<String>c=newArrayList<String>();

init(c);

//集合转数组

String[]arrStrs=c.toArray(newString[c.size()]);

//[java,abcde,zzz,itheima,me]

//也可以用无参数的toArray方法，但是该方法返回Object类型数组，需要向下转型才可以使用。

}

publicstaticvoidinit(Collection<String>c){

c.clear();

c.add("java");

c.add("abcde");

c.add("zzz");

c.add("itheima");

c.add("me");

}

}

Math类

1.概述

Math数学运算。方法都是静态的，并且包括自然对数和圆周率常量。

2.常用方法

staticdoubleabs(doublea)//绝对值

staticdoubleceil(doublea)//向上取整

staticdoublefloor(doublea)//向下取整

staticintround(floata)//四舍五入

staticlonground(doublea)

staticdoublecbrt(doublea)//开立方

staticdoublesqrt(doublea)//开方

staticdoubleexp(doublea)//自然对数的次方

staticdoublepow(doublea,doubleb)//次方

staticdoublelog(doublea)//自然对数

staticdoublelog10(doublea)//10为底的对数

staticdoublemax(doublea,doubleb)//最大值

staticdoublemin(doublea,doubleb)//最小值

staticdoublerandom()//0~1的随机数（不包括1）

3.示例

packagetools;

publicclassMathDemo{

publicstaticvoidmain(String[]args){

/*

*Math数学运算。方法都是静态的。

*/

inti=Math.abs(-4);//4

doubled0=Math.sqrt(16);//4

doubled1=Math.cbrt(8);//2

doubled2=Math.ceil(12.54);//13.0

doubled3=Math.floor(12.54);//12.0

longd4=Math.round(12.54);//13

doubled5=Math.pow(10.1,3.1);//1298.3633826837624

doubledr=Math.random();//0~1的随机数

}

}

系统相关类

1.System类

概述

该类全部由静态成员构成，无构造方法，不可以创建实例。

静态域

标准输入流

staticInputStreamin
标准输出流

staticPrintStreamout

常用方法

数组复制

staticvoidarraycopy(Objectsrc,intsrcPos,Objectdest,intdestPos,intlength)
获取系统时间（毫秒）

staticlongcurrentTimeMillis()
获取当前时间（纳秒，常用作计算程序消耗时间）

staticlongnanoTime()
结束虚拟机

staticvoidexit(intstatus)
垃圾回收

staticvoidgc()
获取系统属性集或者属性集中的数据

staticPropertiesgetProperties()

staticStringgetProperty(Stringkey)

staticStringgetProperty(Stringkey,Stringdef)
设置系统属性集

staticvoidsetProperties(Propertiesprops)

staticStringsetProperty(Stringkey,Stringvalue)
获取当前系统下的换行符

staticStringlineSeparator()
设置默认的输入输出流

staticvoidsetIn(InputStreamin)

staticvoidsetOut(PrintStreamout)

示例

packagetools;

importjava.util.Properties;

publicclassSystemDemo{

publicstaticvoidmain(String[]args){

//1.数组复制

byte[]src={5,3,7,1,9};

byte[]dest=newbyte[5];

System.arraycopy(src,2,dest,0,3);//[7,1,9,0,0]

//2.获取系统时间（毫秒）

longtimeMillis=System.currentTimeMillis();//1418684143024

//3.获取当前时间（纳秒，常用作计算程序消耗时间）

longtimeNano=System.nanoTime();//53653295860546

//4.结束虚拟机

//System.exit(0);

//5.垃圾回收

System.gc();

//6.获取系统属性集或者属性集中的数据

Propertiesprop=System.getProperties();

StringosName=System.getProperty("os.name");//Windows7

//7.设置系统属性集

StringosOldName=System.setProperty("os.name","Windows18");

StringosNewName=System.getProperty("os.name");//Windows18

//8.获取当前系统下的换行符

Stringls=System.lineSeparator();

Stringstr="java"+ls+"happy";

//java

//happy

}

}

2.Runtime类

概述

该类无构造方法，不可以通过new方法创建实例。
每个JVM运行都会在底层生成一个Runtime实例。
由于该类有非静态方法，那么只能通过静态方法获取该类实例。

常用方法

获取当前JVM的Runtime实例。

staticRuntimegetRuntime()
按命令执行程序。

Processexec(Stringcommand)

Processexec(Stringcommand,String[]envp)

Processexec(Stringcommand,String[]envp,Filedir)

Processexec(String[]cmdarray)

Processexec(String[]cmdarray,String[]envp)

Processexec(String[]cmdarray,String[]envp,Filedir)
结束JVM。

voidexit(intstatus)
执行垃圾回收

voidgc()
获取JVM已获取的未使用内存

longfreeMemory()
获取JVM最大可获取的内存

longmaxMemory()
获取当前JVM已获取的总内存

longtotalMemory()