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

工具类

1. 概述

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

2. 特点

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

Collections类

1. 概述

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

2. 方法

  1. 二分查找
    static <T> int  binarySearch(List<? extends Comparable<? super T>> list, T key)
    static <T> int  binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
  2. 获取最大值和最小值
    static <T extends Object & Comparable<? super T>> T  max(Collection<? extends T> coll)
    static <T> T  max(Collection<? extends T> coll, Comparator<? super T> comp)
    static <T extends Object & Comparable<? super T>> T  min(Collection<? extends T> coll)
    static <T> T  min(Collection<? extends T> coll, Comparator<? super T> comp)
  3. 全部替换,单独替换和交换
    static <T> void  fill(List<? super T> list, T obj)
    static <T> boolean  replaceAll(List<T> list, T oldVal, T newVal)
    static void  swap(List<?> list, int i, int j)
  4. 逆序排列(直接逆序或获取逆序比较器)
    static void  reverse(List<?> list)
    static <T> Comparator<T>  reverseOrder()
    static <T> Comparator<T>  reverseOrder(Comparator<T> cmp)
  5. 随机排列
    static void  shuffle(List<?> list)
    static void  shuffle(List<?> list, Random rnd)
  6. 排序
    static <T extends Comparable<? super T>> void  sort(List<T> list)
    static <T> void  sort(List<T> list, Comparator<? super T> c)
  7. 获取线程安全的集合
    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. 示例

   
   
package tools;
 
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
 
import comparator.ComparatorByLength;
 
public class CollectionsDemo {
 
public static void main(String[] args) {
/*
* 1. 将非同步的集合转成同步的集合
* 2. 获取List集合最值。
* 3. 对List集合排序。
* 4. 对List集合进行元素插入,并保持有序。
* 5. 对List集合进行按字符串由长到短排序。
* 6. 保留List集合前2个以及后2个元素,将其他元素替换为"null"。
*/
List<String> l = new ArrayList<String>();
init(l );
// 1. 将非同步集合转换成同步集合。
List<String> list = Collections.synchronizedList(l );
// 2. 获取List集合最值。
String max = Collections. max(list); // "zzz"
String min = Collections. min(list); // "abcde"
// 3. 对List集合排序。
Collections.sort(list ); // [ abcde, it&java, java, me, nba, zoom, zzz ]
// 4. 对List集合进行元素插入,并保持有序。
String str = "niubility";
int index = Collections.binarySearch(list , str );
// 如果集合中无此元素,则返回-(insertion point) - 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 (new ComparatorByLength()));
// [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]
}
 
private static void replaceFunc(List<String> list) {
List<String> l = new ArrayList<String>();
// 1. 先将中间需要替换的元素存入新集合,并在老集合中删除这些元素。
for (int i = 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);
}
 
public static void init(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. 方法

  1. 将数组转换为集合
    static <T> List<T>  asList(T... a)
  2. 二分查找(以byte为例)
    static int  binarySearch(byte[] a, byte key)
    static int  binarySearch(byte[] a, int fromIndex, int toIndex, byte key)
    static <T> int  binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)
    static <T> int  binarySearch(T[] a, T key, Comparator<? super T> c)
  3. 填充数据(以byte为例)
    static void  fill(byte[] a, byte val)
    static void  fill(byte[] a, int fromIndex, int toIndex, byte val)
  4. 数组复制(以byte为例)
    static byte[]  copyOf(byte[] original, int newLength)
    static byte[]  copyOfRange(byte[] original, int from, int to)
  5. 排序(以byte为例)
    static void  sort(byte[] a)
    static void  sort(byte[] a, int fromIndex, int toIndex)
    static <T> void  sort(T[] a, Comparator<? super T> c)
    static <T> void  sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)
  6. 生成字符串(以byte为例)
    static String  toString(byte[] a)

3. 示例

    
    
package tools;
 
import java.util.Arrays;
 
public class ArraysDemo {
 
public static void main(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. 二分查找。
int index1 = Arrays. binarySearch(arr, 55); // -4 (-(insertion point) - 1)
int index2 = Arrays. binarySearch(arr, 67); // 3
 
// 3. 数组复制
int[] arrCopy = Arrays.copyOfRange(arr , 1, 3); // [21, 34],含头不含尾
 
// 4. 对两个数组进行元素的比较,判断两个数组是否相同。
boolean b = Arrays. equals(arr, arrCopy); // false
// 5. 将数组转换成字符串
String str = 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. 示例

     
     
package collection.list;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
 
public class List2Array {
 
public static void main(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 = new ArrayList<String>();
init(c );
// 集合转数组
String[] arrStrs = c.toArray( new String[ c.size()]);
// [java, abcde, zzz, itheima , me]
// 也可以用无参数的toArray方法,但是该方法返回Object类型数组,需要向下转型才可以使用。
}
 
public static void init(Collection<String> c) {
c.clear();
c.add("java");
c.add("abcde");
c.add("zzz");
c.add("itheima");
c.add("me");
}
}

Math类

1. 概述

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

2. 常用方法

static double  abs(double a) // 绝对值
static double  ceil(double a) // 向上取整
static double  floor(double a) // 向下取整
static int  round(float a) // 四舍五入
static long  round(double a)

static double  cbrt(double a) // 开立方
static double  sqrt(double a) // 开方

static double  exp(double a) // 自然对数的次方
static double  pow(double a, double b) // 次方

static double  log(double a) // 自然对数
static double  log10(double a) // 10为底的对数

static double  max(double a, double b) // 最大值
static double  min(double a, double b) // 最小值

static double  random() // 0~1的随机数(不包括1)

3. 示例

    
    
package tools;
 
public class MathDemo {
 
public static void main(String[] args) {
/*
* Math数学运算。方法都是静态的。
*/
 
int i = Math.abs(-4); // 4
 
double d0 = Math. sqrt(16); // 4
double d1 = Math. cbrt(8); // 2
 
double d2 = Math. ceil(12.54); // 13.0
double d3 = Math. floor(12.54); // 12.0
long d4 = Math.round(12.54); // 13
 
double d5 = Math. pow(10.1, 3.1); // 1298.3633826837624
 
double dr = Math. random(); // 0~1的随机数
}
}

系统相关类

1. System类

概述

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

静态域

  1. 标准输入流
    static InputStream  in
  2. 标准输出流
    static PrintStream  out

常用方法

  1. 数组复制
    static void  arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
  2. 获取系统时间(毫秒)
    static long  currentTimeMillis()
  3. 获取当前时间(纳秒,常用作计算程序消耗时间)
    static long  nanoTime()
  4. 结束虚拟机
    static void  exit(int status)
  5. 垃圾回收
    static void  gc()
  6. 获取系统属性集或者属性集中的数据
    static Properties  getProperties()
    static String  getProperty(String key)
    static String  getProperty(String key, String def)
  7. 设置系统属性集
    static void  setProperties(Properties props)
    static String  setProperty(String key, String value)
  8. 获取当前系统下的换行符
    static String  lineSeparator()
  9. 设置默认的输入输出流
    static void  setIn(InputStream in)
    static void  setOut(PrintStream out)

示例

    
    
package tools;
 
import java.util.Properties;
 
public class SystemDemo {
 
public static void main(String[] args) {
 
// 1. 数组复制
byte[] src = {5, 3, 7, 1, 9};
byte[] dest = new byte[5];
System.arraycopy(src , 2, dest , 0, 3); // [7, 1, 9, 0, 0]
// 2. 获取系统时间(毫秒)
long timeMillis = System. currentTimeMillis(); // 1418684143024
// 3. 获取当前时间(纳秒,常用作计算程序消耗时间)
long timeNano = System. nanoTime(); // 53653295860546
// 4. 结束虚拟机
//System.exit(0);
// 5. 垃圾回收
System.gc();
// 6. 获取系统属性集或者属性集中的数据
Properties prop = System. getProperties();
String osName = System. getProperty("os.name"); // Windows 7
// 7. 设置系统属性集
String osOldName = System. setProperty("os.name", "Windows 18");
String osNewName = System. getProperty("os.name"); // Windows 18
// 8. 获取当前系统下的换行符
String ls = System.lineSeparator();
String str = "java" + ls + "happy";
// java
// happy
}
}

2. Runtime类

概述

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

常用方法

  1. 获取当前JVM的Runtime实例。
    static Runtime  getRuntime()
  2. 按命令执行程序。
    Process  exec(String command)
    Process  exec(String command, String[] envp)
    Process  exec(String command, String[] envp, File dir)
    Process  exec(String[] cmdarray)
    Process  exec(String[] cmdarray, String[] envp)
    Process  exec(String[] cmdarray, String[] envp, File dir)
  3. 结束JVM。
    void  exit(int status)
  4. 执行垃圾回收
    void  gc()
  5. 获取JVM已获取的未使用内存
    long  freeMemory()
  6. 获取JVM最大可获取的内存
    long  maxMemory()
  7. 获取当前JVM已获取的总内存
    long  totalMemory()

  • 4
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值