包装类

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

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

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

  1. Integer num1 = 12;// 自动装箱
  2. intnum2 = num1;// 自动拆箱

System

将指定源数组中的数组从指定位置复制到目标数组的指定位置。
System.in：输入
System.out：输出
System.err：输出错误
System.arraycopy：数据拷贝

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

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

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

Random

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

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

Math

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

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

UUID

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

  1. import java.util.UUID;
  3. /**
  4. * 面试题：如何产生一个唯一识别码(标识符)
  5. */
  6. public static void main(String[] args) {
  7.     // 随机产生一个UUID对象(通用唯一识别码)
  8.     UUID randomUUID = UUID.randomUUID();
  9.     System.out.println(randomUUID.toString());
  10. }

Runtime

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

内存使用率

  1. import java.math.BigDecimal;
  2. import java.math.MathContext;
  3. import java.math.RoundingMode;
  5. public static void main(String[] args) {
  6.     // 获取总空间
  7.     Runtime runtime = Runtime.getRuntime();
  8.     // 获取JVM总空间
  9.     long total = runtime.totalMemory();
  10.     // 获取JVM空闲空间
  11.     long free = runtime.freeMemory();
  12.     // 当前使用空间
  13.     long usedMemory = total - free;
  14.     // 获取当前使用率
  15.     double useRate = 1.0*100*usedMemory/total;
  16.     /* BigDecimal：有效位的数进行精确的运算
  17.     * MathContext(指定的精度, 舍入模式)：根据上下文设置进行舍入
  18.     * RoundingMode：指定丢弃精度的数值运算的舍入行为
  19.     */
  20.     BigDecimal bDecimal = new BigDecimal(useRate, new MathContext(3, RoundingMode.HALF_UP));
  21.     System.out.println("使用率：" + bDecimal + "%");
  22. }

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

日期工具类

Date

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

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

SimpleDateFormat

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

  1. import java.util.Date;
  2. import java.text.SimpleDateFormat;
  4. public class SimpleDateFormatTool {
  5.     public static void main(String[] args) {
  6.         Date date = new Date();
  7.         /*
  8.         * G ：年代标志符
  9.         * y ：年
  10.         * M ：月
  11.         * d ：日
  12.         * h ：小时（12小时制）
  13.         * H ：小时（24小时制）（0-23）
  14.         * m ：分
  15.         * s ：秒
  16.         * S ：毫秒
  17.         * E ：星期
  18.         * D ：一年中的第几天
  19.         * F ：一个月中的第几个星期
  20.         * w ：一年中的第几周
  21.         * W ：一个月中的第几周
  22.         * k ：一天中的小时数（1-24）
  23.         * K ：上午(am)/下午(pm)中的小时数（0-11）
  24.         * z/Z ：时区
  25.         */
  26.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  27.         // 将日期时间转换为指定的格式
  28.         String format = sdf.format(date);
  29.         System.out.println(format);
  30.     }
  31. }

Calendar

Calendar类是一个抽象类，不可以使用new关键字直接创建实例。
Calendar可以为在某一特定时刻和一组之间的转换的方法 calendar fields（日历域） 如YEAR ， MONTH ， DAY_OF_MONTH ， HOUR 等等，以及用于操纵该日历字段，如获取的日期下个星期。

  1. import java.util.Calendar;
  3. /**
  4. * 使用默认时区和区域设置获取日历
  5. */
  6. public class TestCalendar {
  7.     public static void main(String[] args) {
  8.         Calendar ca = Calendar.getInstance();
  9.         // get：返回给定日历字段的值。
  10.         // YEAR：年份
  11.         int year = ca.get(Calendar.YEAR);
  12.         System.out.println(year);
  13.         // MONTH：月份
  14.         System.out.println(ca.get(Calendar.MONTH)+1);
  15.         // DATE：本月的日期
  16.         System.out.println(ca.get(Calendar.DATE));
  17.         // DAY_OF_MONTH：一周中的日期
  18.         System.out.println(ca.get(Calendar.DAY_OF_MONTH));
  19.         // 一个月的第几周
  20.         System.out.println(ca.get(Calendar.DAY_OF_WEEK_IN_MONTH));
  21.         // 一个月的第几天
  22.         System.out.println(ca.get(Calendar.DAY_OF_MONTH));
  23.         // HOUR_OF_DAY：当天的小时数
  24.         System.out.println(ca.get(Calendar.HOUR_OF_DAY));
  25.         // MINUTE：分
  26.         System.out.println(ca.get(Calendar.MINUTE));
  27.         // SECOND：秒
  28.         System.out.println(ca.get(Calendar.SECOND));
  30.         // 注意：静态成员和静态方法不要使用名称来调用，必须使用名称来调用。
  31.         System.out.println(ca.get(ca.SECOND));
  32.         // set：设置日历字段的值
  33.         // set(int field, nt value);
  34.         // field -> 给定的日历字段
  35.         // value -> 要为给定日历字段设置的值
  36.         ca.set(Calendar.YEAR, 2020);
  37.         Date time = ca.getTime();
  38.         System.out.println(time);
  39.         // set(int year, int month, int date, int hourOfDay, int minute, int second);
  40.         // year -> 用于设置 YEAR日历字段的值。
  41.         // month -> 用于设置MONTH日历字段的值。 月值为0。 例如，1月份为0。
  42.         // date -> 用于设置 DAY_OF_MONTH日历字段的值。
  43.         // hourOfDay -> 用于设置 HOUR_OF_DAY日历字段的值。
  44.         // minute -> 用于设置 MINUTE日历字段的值。
  45.         // second -> 用于设置 SECOND日历字段的值。
  46.     }
  47. }

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

LocalDate

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

  1. import java.time.LocalDate;
  3. public class TestLocalDate {
  4.     public static void main(String[] args) {
  5.         // 获取当前日期（年-月-日）
  6.         LocalDate time = LocalDate.now();
  7.         // 将日期转换成字符串类型
  8.         String str = time.toString();
  9.         System.out.println(str);
  10.         // 设置日期 of(年份, 月份, 月中的天数)
  11.         LocalDate of = LocalDate.of(2020, 10, 1);
  12.         System.out.println(of);
  14.         // 获取年
  15.         System.out.println(time.getYear());
  16.         // 获取月
  17.         System.out.println(time.getMonth());
  18.         // 获取当前月的天数
  19.         System.out.println(time.getDayOfMonth());
  20.         // 获取一年中的天数
  21.         System.out.println(time.getDayOfYear());
  22.         // 获取当天星期几
  23.         System.out.println(time.getDayOfWeek());
  24.     }
  25. }

LocalTime

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

  1. import java.time.LocalTime;
  3. public class TestLocalDate {
  4.     public static void main(String[] args) {
  5.         // now()：获取当前时间（时-分-秒-纳秒）
  6.         // withNano(0)：去除纳秒
  7.         LocalTime time = LocalTime.now().withNano(0);
  8.         // 将时间转换成字符串类型
  9.         String str = time.toString();
  10.         System.out.println(str);
  11.         // 获取小时
  12.         System.out.println(time.getHour());
  13.         // 获取分钟
  14.         System.out.println(time.getMinute());
  15.         // 获取秒
  16.         System.out.println(time.getSecond());
  17.     }
  18. }

LocalDateTime

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

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

Flie类

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

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

exists()

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

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

isDirectory()

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

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

isFile()

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

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

创建目录、文件及删除

mkdir()

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

  1. File file= new File("textDemo");
  2. if (!file.exists()) {
  3.     boolean mkdir = file.mkdir();
  4.     System.out.println(mkdir);
  5. }else {
  6.     System.out.println(false);
  7. }

mkdirs()

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

  1. File file= new File("textDemo\\aaa\\bbb");
  2. if (!file.exists()) {
  3.     boolean mkdir = file.mkdirs();
  4.     System.out.println(mkdir);
  5. }else {
  6.     System.out.println(false);
  7. }

createNewFile()

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

  1. import java.io.File;
  3. public class TestFile {
  4.     public static void main(String[] args) {
  5.         // 从父抽象路径名和子路径名字符串创建新的 File实例
  6.         File file = new File("text", "TestDemo.java");
  7.         System.out.println(file);
  8.         // 这里需要抛出异常
  9.         try {
  10.             boolean createNewFile = file.createNewFile();
  11.             System.out.println(createNewFile);
  12.         } catch (IOException e) {
  13.             e.printStackTrace();
  14.         }
  15.     }
  16. }

delete()

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

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

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

获取路径

  1. import java.io.File;
  3. public class GetPath {
  4.     public static void main(String[] args) {
  5.         File file = new File("text", "Test.java");
  6.         // 返回此抽象路径名的绝对形式
  7.         File absoluteFile = file.getAbsoluteFile();
  8.         System.out.println(absoluteFile);
  9.         // 返回此抽象路径名的绝对路径名字符串
  10.         String absolutePath = file.getAbsolutePath();
  11.         System.out.println(absolutePath);
  12.         // 返回父目录的路径名
  13.         File parentFile = file.getParentFile();
  14.         System.out.println(parentFile);
  15.         // 将此抽象路径名转换为路径名字符串
  16.         String fileName = file.getName();
  17.         System.out.println(fileName);
  18.     }
  19. }

length()

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

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

list()

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

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

listFiles()

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

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

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

  1. import java.io.File;
  2. import java.io.FilenameFilter;
  4. public class TestFileFilter {
  5.     public static void main(String[] args) {
  6.         File file = new File("D:\\学习\\笔记\\Java\\Java SE");
  7.         File[] listFiles = file.listFiles(new TestFileFilterImpl());
  8.         for (File file2 : listFiles) {
  9.             System.out.println(file2);
  10.         }
  11.     }
  13.     // FilenameFilter -->文件过滤器
  14.     // 实现FilenameFilter接口需重写accept()方法
  15.     static class TestFileFilterImpl implements FilenameFilter {
  16.         // 滤波器的方法
  17.         @Override
  18.         public boolean accept(File dir, String name) {
  19.             // 由指定的字符串的后缀进行过滤
  20.             return name.endsWith(".md");
  21.         }
  22.     }
  23. }

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

  1. import java.io.File;
  3. public static void main(String[] args) {
  4.     File file = new File("D:\\学习\\笔记\\Java\\Java SE");
  5.     File[] listFiles = file.listFiles((dir,name)->name.endsWith(".md"));
  6.     for (File file2 : listFiles) {
  7.         System.out.println(file2);
  8.     }
  9. }

listRoots()

获取系统所有的盘符。

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

磁盘使用率

  1. import java.io.File;
  2. import java.math.BigDecimal;
  3. import java.math.MathContext;
  4. import java.math.RoundingMode;
  6. /**
  7. * 计算磁盘使用率
  8. */
  9. public class TestFileDiskRage {
  10.     public static void main(String[] args) {
  11.         File file = new File("..");
  12.         System.out.println(file.getAbsolutePath());
  13.         // 当前磁盘总空间
  14.         long totalSpace = file.getTotalSpace();
  15.         // 空闲空间
  16.         long freeSpace = file.getFreeSpace();
  17.         // 已使用的空间
  18.         double usageRate = 1.0*100*(totalSpace - freeSpace)/totalSpace;
  19.         // BigDecimal：有效位的数进行精确的运算
  20.         // MathContext(指定的精度, 舍入模式)：根据上下文设置进行舍入
  21.         // RoundingMode：指定丢弃精度的数值运算的舍入行为
  22.         BigDecimal bDecimal = new BigDecimal(usageRate, new MathContext(3, RoundingMode.HALF_UP));
  23.         System.out.println("当前磁盘使用率：" + bDecimal + "%");
  24.     }
  25. }

删除目录

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

  1. import java.io.File;
  3. public class TestDeleteFile {
  4.     public static void main(String[] args) {
  5.         File file = new File("textDemo");
  6.         deleteFolderOrFile(file);
  7.     }
  8.     public static boolean deleteFolderOrFile(File file){
  9.         // 判断该路径是否存在并且该路径是否是文件夹
  10.         if (file.exists() && file.isDirectory()) {
  11.             // //获取路径下面所有的文件和目录列表
  12.             File[] listFiles = file.listFiles();
  13.             // 遍历当前文件夹的所有文件及目录
  14.             for (File allFilePath : listFiles) {
  15.                 // File(parent, child)：
  16.                 // parent：父路径
  17.                 // child：子路径的文件名或者目录名
  18.                 File allFile = new File(file, allFilePath.getName());
  19.                 // 递归进行查找删除(每次自己调用自己都有一个压栈的过程)
  20.                 deleteFolderOrFile(allFile);
  21.             }
  22.         }
  23.         //当路径是文件直接删除
  24.         return file.delete();
  25.     }
  26. }

枚举（enum）

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

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

例1：

  1. public enum EWeek {
  2.     MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY,SATURDAY,SUNDAY;
  3. }

例2：

  1. public enum EColour {
  2.     RED((byte) 1) {
  3.         @Override
  4.         public void color() {
  5.             System.out.println("红色");
  6.         }
  7.     },
  8.     YELLOW((byte) 2) {
  9.         @Override
  10.         public void color() {
  11.             System.out.println("黄色");
  12.         }
  13.     },
  14.     TEAL((byte) 3) {
  15.         @Override
  16.         public void color() {
  17.             System.out.println("青色");
  18.         }
  19.     },
  20.     BLUE((byte) 4) {
  21.         @Override
  22.         public void color() {
  23.             System.out.println("蓝色");
  24.         }
  25.     };
  27.     private byte id;
  29.     public byte getId() {
  30.         return id;
  31.     }
  33.     private EColour(byte id) {
  34.         this.id = id;
  35.     }
  37.     /**
  38.     * 内部定义颜色抽象方法,枚举中的所有类型都要重写该方法
  39.     */
  40.     public abstract void color();
  41. }