Java常用工具类

网上理论上的概念都大同小异，使用自己的方式来理解，把他"吃透"，这样才能变成你自己财富。

包装类

  在Java中基本数据类型都存放在栈内存中，那我们如果想把基本数据类型存放在堆中，那该如何来进行处理呢？这时我们就可以使用包装类来实现。

基本数据类型	对应的包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character

基本数据类型转换为引用数据类型称为装箱
包装好的数据类型转换为基本数据类型称为拆箱

Integer num1 = 12;   // 自动装箱
int num2  = num1;    // 自动拆箱

常用工具类

System

  将指定源数组中的数组从指定位置复制到目标数组的指定位置。

System.in：输入

System.out：输出

System.err：输出错误

System.arraycopy：数据拷贝

// System.arraycopy(源数组, 从源数组指定索引开始截取, 目标数组, 从目的数组指定的位置开始存放, 要复制的数组元素的数量);
System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
// 例：
int[] arr = {5,8,4,3,9,7};
int[] newArr = new int[10];
System.arraycopy(arr, 0, newArr, 2, arr.length);
System.out.println(Arrays.toString(newArr));

获取JVM环境在运行时的数据

/**
 * 获取Java程序运行时操作系相关的数据
 */
public class TestSystem {
	public static void main(String[] args) {
		// 获取当前Java程序运行时，操作系统的名称
		String osName= System.getProperty("os.name");
		System.out.println(osName);		// Windows 10
		// 获取操作系统位数(os.arch 获取操作系统的架构)
		String arch = System.getProperty("os.arch");
		System.out.println(arch);
		// 获取操作系统当前正在使用的目录类路径
		String dir = System.getProperty("user.dir");
		System.out.println(dir);
	}
}

Random

  该类的实例用于生成伪随机数的流。Random返回随机数的范围为[0, 1)；

public static void main(String[] args) {
	Random random = new Random();
	int num = random.nextInt(10);	// 随机输出一个[0, 10)之间的数字
	System.out.println(num);
}

Math

  Math类包含执行基本数字运算的方法，如基本指数，对数，平方根和三角函数。

常用方法：

public static void main(String[] args) {
		System.out.println("圆周率" + Math.PI);
		System.out.println("绝对值：" + Math.abs(-8));
		System.out.println("向上取整：" + Math.ceil(3.14));
		System.out.println("向下取整：" + Math.floor(3.14));
		System.out.println("返回两个数的较大值：" + Math.max(2, 8));
		System.out.println("返回两个数的较小值:" + Math.min(2, 8));
		System.out.println("平方根：" + Math.sqrt(8));
		System.out.println("计算2的8次方" + Math.pow(2, 8));
		System.out.println("正弦值" + Math.sin(30));
		System.out.println("余弦值" + Math.cos(30));
		System.out.println("正切值" + Math.tan(30));
		System.out.println("四舍五入：" + Math.round(10.5));
		System.out.println("四舍五入：" + Math.round(-10.5));
	}

UUID

  通用唯一识别码（ Universally Unique Identifier ）。一个表示不可变的通用唯一标识符（UUID）的类。SinceJDK1.5

import java.util.UUID;

/**
 * 面试题：如何产生一个唯一识别码(标识符)
 */
public static void main(String[] args) {
    // 随机产生一个UUID对象(通用唯一识别码)
	UUID randomUUID = UUID.randomUUID();
	System.out.println(randomUUID.toString());
}

Runtime

  能够获取程序在运行时的数据(总的堆内存空间，自由(剩余)堆内存空间)，还可以启动进程

内存使用率

import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;

public static void main(String[] args) {
	// 获取总空间
	Runtime runtime = Runtime.getRuntime();
	// 获取JVM总空间
	long total = runtime.totalMemory();
	// 获取JVM空闲空间
	long free = runtime.freeMemory();
	// 当前使用空间
	long usedMemory = total - free;
	// 获取当前使用率
	double useRate = 1.0*100*usedMemory/total;
	/* BigDecimal：有效位的数进行精确的运算
	 * MathContext(指定的精度, 舍入模式)：根据上下文设置进行舍入
	 * RoundingMode：指定丢弃精度的数值运算的舍入行为
	 */
	BigDecimal bDecimal = new BigDecimal(useRate, new MathContext(3, RoundingMode.HALF_UP));
	System.out.println("使用率：" + bDecimal + "%");
}

Runtime总常见的陷阱：https://www.jianshu.com/p/af4b3264bc5d

日期工具类

Date

  日期类：一般用来获取展示时间的类。

public static void main(String[] args) {
	// currentTimeMillis：获取从1970.01.01 00:00:00到现在的毫秒数
	long time = System.currentTimeMillis();
	System.out.println(time);
	
	Date date = new Date();
	System.out.println(date);	// Sat Sep 07 20:54:07 CST 2019
}

SimpleDateFormat

  格式化时间：常用的标准写法“ yyyy-MM-dd HH:mm:ss ”。

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

public class SimpleDateFormatTool {
    public static void main(String[] args) {
        Date date = new Date();
        /*
         * G ：年代标志符
         * y ：年
         * M ：月
         * d ：日
         * h ：小时（12小时制）
         * H ：小时（24小时制）（0-23）
         * m ：分
         * s ：秒
         * S ：毫秒
         * E ：星期
         * D ：一年中的第几天
         * F ：一个月中的第几个星期
         * w ：一年中的第几周
         * W ：一个月中的第几周
         * k ：一天中的小时数（1-24）
         * K ：上午(am)/下午(pm)中的小时数（0-11）
         * z/Z ：时区
         */
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        // 将日期时间转换为指定的格式
        String format = sdf.format(date);
        System.out.println(format);
    }
}

Calendar

  Calendar类是一个抽象类，不可以使用new关键字直接创建实例。

  Calendar可以为在某一特定时刻和一组之间的转换的方法 calendar fields（日历域） 如YEAR ， MONTH ， DAY_OF_MONTH ， HOUR 等等，以及用于操纵该日历字段，如获取的日期下个星期。

import java.util.Calendar;

/**
 * 使用默认时区和区域设置获取日历
 */
public class TestCalendar {
	public static void main(String[] args) {
		Calendar ca = Calendar.getInstance();
// get：返回给定日历字段的值。
		// YEAR：年份
		int year = ca.get(Calendar.YEAR);
		System.out.println(year);
		// MONTH：月份
		System.out.println(ca.get(Calendar.MONTH));
		// DATE：本月的日期
		System.out.println(ca.get(Calendar.DATE));
		// DAY_OF_MONTH：一周中的日期
		System.out.println(ca.get(Calendar.DAY_OF_MONTH));
		// 一个月的第几周
		System.out.println(ca.get(Calendar.DAY_OF_WEEK_IN_MONTH));
		// 一个月的第几天
		System.out.println(ca.get(Calendar.DAY_OF_MONTH));
		// HOUR_OF_DAY：当天的小时数
		System.out.println(ca.get(Calendar.HOUR_OF_DAY));
		// MINUTE：分
		System.out.println(ca.get(Calendar.MINUTE));
		// SECOND：秒
		System.out.println(ca.get(Calendar.SECOND));

		// 注意：静态成员和静态方法不要使用名称来调用，必须使用名称来调用。
		System.out.println(ca.get(ca.SECOND));
			
// set：设置日历字段的值
		// set(int field, nt value);
			// field -> 给定的日历字段
			// value -> 要为给定日历字段设置的值
		ca.set(Calendar.YEAR, 2020);
		Date time = ca.getTime();
		System.out.println(time);
		
		// set(int year, int month, int date, int hourOfDay, int minute, int second);
			// year -> 用于设置 YEAR日历字段的值。 
			// month -> 用于设置MONTH日历字段的值。 月值为0。 例如，1月份为0。 
			// date -> 用于设置 DAY_OF_MONTH日历字段的值。 
			// hourOfDay -> 用于设置 HOUR_OF_DAY日历字段的值。 
			// minute -> 用于设置 MINUTE日历字段的值。 
			// second -> 用于设置 SECOND日历字段的值。
	}
}

JDK1.8以后新增的几种日期工具类

LocalDate

  LocalDate是不可变的和线程安全的。

  LocalDate是一个不可变的日期时间对象，表示日期，通常被视为年月日。 也可以访问其他日期字段，例如日期，星期几和星期。

import java.time.LocalDate;

public class TestLocalDate {
	public static void main(String[] args) {
		// 获取当前日期（年-月-日）
		LocalDate time = LocalDate.now();
		// 将日期转换成字符串类型
		String str = time.toString();
		System.out.println(str);
		// 设置日期 of(年份, 月份, 月中的天数)
		LocalDate of = LocalDate.of(2020, 10, 1);
		System.out.println(of);

		// 获取年
		System.out.println(time.getYear());
		// 获取月
		System.out.println(time.getMonth());
		// 获取当前月的天数
		System.out.println(time.getDayOfMonth());
		// 获取一年中的天数
		System.out.println(time.getDayOfYear());
		// 获取当天星期几
		System.out.println(time.getDayOfWeek());
	}
}

LocalTime

  LocalTime是不可变的和线程安全的。

  LocalTime是一个不可变的日期时间对象，代表一个时间，通常被看作是小时 - 秒。 时间表示为纳秒精度。

import java.time.LocalTime;

public class TestLocalDate {
	public static void main(String[] args) {
		// now()：获取当前时间（时-分-秒-纳秒）
		// withNano(0)：去除纳秒
		LocalTime time = LocalTime.now().withNano(0);
		// 将时间转换成字符串类型
		String str = time.toString();
		System.out.println(str);
		// 获取小时
		System.out.println(time.getHour());
		// 获取分钟
		System.out.println(time.getMinute());
		// 获取秒
		System.out.println(time.getSecond());
	}
}

LocalDateTime

  LocalDateTime是不可变的和线程安全的。

  LocalDateTime是一个不可变的日期时间对象，代表日期时间，通常被视为年 - 月 - 日 - 时 - 分 - 秒。 也可以访问其他日期和时间字段，例如日期，星期几和星期。 时间表示为纳秒精度。

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

/**
 * LocalDateTime可以认为是LocalDate和LocalTime的结合体。
 */
public class TestLocalDateTime {
	public static void main(String[] args) {
		// now()：获取当前时间
		LocalDateTime time = LocalDateTime.now();
		System.out.println(time); 	// 2019-09-08T14:10:06.662
		// withNano(0)：去除纳秒
		LocalDateTime withNano = time.withNano(0);
		System.out.println(withNano);	 // 2019-09-08T14:10:06
		// JDK1.8以后的日期转换类 (通过定义格式可以把“T”去掉)
		DateTimeFormatter ofPattern = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
		String formatTime = ofPattern.format(time);
		System.out.println(formatTime);	 // 2019-09-08 14:10:06
	}
}

Flie类

  File：文件和目录路径名的抽象表示代表表磁盘中实际存在的文件和目录。

import java.io.File;

public class TestFile {
	public static void main(String[] args) {
		// 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
		// 注意：多层路径下用“\”来连接
		new File("text\Test.java");
		// 从父抽象路径名和子路径名字符串创建新的 File实例
		File file = new File("text", "Test.java");
		System.out.println(file);
	}
}

exists()

  测试此路径下的文件或目录是否存在，true(存在)、false(不存在)。

boolean exists = file.exists();
System.out.println(exists);

isDirectory()

  测试此路径名表示的文件是否为目录，true(是目录)、false(不是目录)。

boolean directory = file.isDirectory();
System.out.println(directory);

isFile()

  测试此路径名表示的文件是否为文件，true(是文件)、false(不是文件)。

boolean file2 = file.isFile();
System.out.println(file2);

创建目录、文件及删除

mkdir()

  创建由此路径名命名的目录，true(创建成功)、false(创建失败)；只能创建一个目录。

File file= new File("textDemo");
if (!file.exists()) {
	boolean mkdir = file.mkdir();
	System.out.println(mkdir);
}else {
	System.out.println(false);
}

mkdirs()

  创建由此路径名命名的目录，包括所有必需但不存在的父目录，true(创建成功)、false(创建失败)；可创建一个目录，也可创建多及目录（推荐）

File file= new File("textDemo\aaa\bbb");
if (!file.exists()) {
	boolean mkdir = file.mkdirs();
	System.out.println(mkdir);
}else {
	System.out.println(false);
}

createNewFile()

  当该名称的文件尚不存在时，创建一个由该路径名命名的新的空文件，true(创建成功)、false(创建失败)。

import java.io.File;

public class TestFile {
	public static void main(String[] args) {
		// 从父抽象路径名和子路径名字符串创建新的 File实例
		File file = new File("text", "TestDemo.java");
		System.out.println(file);
        // 这里需要抛出异常
		try {
			boolean createNewFile = file.createNewFile();
			System.out.println(createNewFile);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

delete()

  删除由此抽象路径名表示的文件或目录。 如果此路径名表示目录，则目录必须为空才能删除。true(删除成功)、false(删除失败)。

boolean delete = file.delete();
System.out.println(delete);

注意：此方法删除，直接删除，不进回收站，谨慎使用。

获取路径

import java.io.File;

public class GetPath {
	public static void main(String[] args) {
		File file = new File("text", "Test.java");
		// 返回此抽象路径名的绝对形式
		File absoluteFile = file.getAbsoluteFile();
		System.out.println(absoluteFile);
		// 返回此抽象路径名的绝对路径名字符串
		String absolutePath = file.getAbsolutePath();
		System.out.println(absolutePath);
		// 返回父目录的路径名
		File parentFile = file.getParentFile();
		System.out.println(parentFile);
		// 将此抽象路径名转换为路径名字符串
		String fileName = file.getName();
		System.out.println(fileName);
	}
}

length()

  返回路径名表示的文件的长度（字节数）

long length = file.length();
System.out.println(length);

list()

  返回一个字符串数组，由此路径名表示的目录中的所有文件和目录。

File file = new File("D:\学习\笔记\Java\Java SE");
String[] list = file.list();
for (String str : list) {
	System.out.println(str);
}

listFiles()

  获取指定路径下的所有文件的路径。

File file = new File("D:\学习\笔记\Java\Java SE");
File[] listFiles = file.listFiles();
for (File file2 : listFiles) {
	System.out.println(file2);
}

  获取指定路径下以某后缀结尾的所有文件的路径

import java.io.File;
import java.io.FilenameFilter;

public class TestFileFilter {
	public static void main(String[] args) {
		File file = new File("D:\学习\笔记\Java\Java SE");
		File[] listFiles = file.listFiles(new TestFileFilterImpl());
		for (File file2 : listFiles) {
			System.out.println(file2);
		}
	}

	// FilenameFilter -->文件过滤器
	// 实现FilenameFilter接口需重写accept()方法
	static class TestFileFilterImpl implements FilenameFilter {
		// 滤波器的方法
		@Override
		public boolean accept(File dir, String name) {
			// 由指定的字符串的后缀进行过滤
			return name.endsWith(".md");
		}
	}
}

  获取指定路径下以某后缀结尾的所有文件的路径（lambda写法）

import java.io.File;

public static void main(String[] args) {
	File file = new File("D:\学习\笔记\Java\Java SE");
	File[] listFiles = file.listFiles((dir,name)->name.endsWith(".md"));
	for (File file2 : listFiles) {
		System.out.println(file2);
	}
}

listRoots()

  获取系统所有的盘符。

File[] listRoots = File.listRoots();
for (File file2 : listRoots) {
	System.out.println(file2);
}

磁盘使用率

import java.io.File;
import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;

/**
 * 计算磁盘使用率
 */
public class TestFileDiskRage {
	public static void main(String[] args) {
		File file = new File("..");
		System.out.println(file.getAbsolutePath());	
		// 当前磁盘总空间
		long totalSpace = file.getTotalSpace();
		// 空闲空间
		long freeSpace = file.getFreeSpace();
		// 已使用的空间
		double usageRate = 1.0*100*(totalSpace - freeSpace)/totalSpace;
		// BigDecimal：有效位的数进行精确的运算
		// MathContext(指定的精度, 舍入模式)：根据上下文设置进行舍入
		// RoundingMode：指定丢弃精度的数值运算的舍入行为
		BigDecimal bDecimal = new BigDecimal(usageRate, new MathContext(3, RoundingMode.HALF_UP));
		System.out.println("当前磁盘使用率：" + bDecimal + "%");
	}
}

删除目录

  删除某个文件夹下面所有的子文件夹和文件

import java.io.File;

public class TestDeleteFile {
	public static void main(String[] args) {
		File file = new File("textDemo");
		deleteFolderOrFile(file);
	}
	
	public static boolean deleteFolderOrFile(File file){
		// 判断该路径是否存在并且该路径是否是文件夹
		if (file.exists() && file.isDirectory()) {
			// //获取路径下面所有的文件和目录列表
			File[] listFiles = file.listFiles();
			// 遍历当前文件夹的所有文件及目录
			for (File allFilePath : listFiles) {
				// File(parent, child)：
				// parent：父路径
				// child：子路径的文件名或者目录名
				File allFile = new File(file, allFilePath.getName());
				// 递归进行查找删除(每次自己调用自己都有一个压栈的过程)
				deleteFolderOrFile(allFile);
			}
		}
        //当路径是文件直接删除
		return file.delete();
	}
}

枚举（enum）

 枚举（enum）类型是JDK1.5新增的特性，存放在 java.lang 包中，创建枚举需要使用 enum 关键字来创建。

 定义枚举格式：

修饰符 enum 枚举名 {
    枚举体（常量列表）
}

例1：

public enum EWeek {
	MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY,SATURDAY,SUNDAY;
}

例2：

public enum EColour {
	RED((byte) 1) {
		@Override
		public void color() {
			System.out.println("红色");
		}
	},
	YELLOW((byte) 2) {
		@Override
		public void color() {
			System.out.println("黄色");
		}
	},
	TEAL((byte) 3) {
		@Override
		public void color() {
			System.out.println("青色");
		}
	},
	BLUE((byte) 4) {
		@Override
		public void color() {
			System.out.println("蓝色");
		}
	};

	private byte id;

	public byte getId() {
		return id;
	}

	private EColour(byte id) {
		this.id = id;
	}

	/**
	 * 内部定义颜色抽象方法,枚举中的所有类型都要重写该方法
	 */
	public abstract void color();
}