Java基础类库

命令行启动程序

Java程序入口，public static void main(String[] args) {}为什么这么定义呢？

• public：java程序通过java虚拟机JVM调用，属于外部调用，所以需要使用public修饰，否则虚拟机无法调用
• static：在java中，没有static的变量或方法，如果想被调用的话，是要先新建一个对象才可以。而main方法作为程序的入口，需要在其它方法实例化之前就启动，这也就是为什么要加一个static。main方法好比一个门，要探索其它方法要先从门进入程序。static提供了这样一个特性，无需建立对象，就可以启动。
• void：当main方法出现返回值时JVM无法进行上抛，如果有返回值难道抛给操作系统么。
• String args[]：运行Java程序时在类名后紧跟一个或多个字符串，JVM会将字符串一次赋值给字符串数组的。（这个数组名可以随便改动）

常用类

String、StringBuffer、StringBuilder

1. String是一个不可变类，所以会产生很多临时变量。
2. StringBuffer是一个线程安全的可变类。
3. StringBuilder是一个线程不安全的可变类，因此性能比较高。
4. Java9以前字符串采用char[]数组来保存，所以字符串的每个字符占两个字节；Java9以后采用byte[]数组保存和encoding-flag字段来保存，所以字符串的每个字符占一个字节。
5. StringBuffer和StringBuilder有两个属性：length（字符串序列的长度）、capacity（容量），可以通过length()、capacity()获得，一般capacity都比length大。

ThreadLocalRandom与Random

ThreadLocalRandom是Random的增强版，可以代替Random减少多线程资源的竞争，最终保证系统具有更好的线程安全性。

Random rand = new Random();
ThreadLocalRandom rand = ThreadLocalRandom.current();

BigDecimal

使用BigDecimal时不推荐使用浮点数作为参数的构造器，因为浮点数的值并非表面所见到的那样。

一般使用String作为参数的构造器。

也可以使用BigDecimal.valueOf(double value)来创建BigDecimal对象。

public class BigDecimalTest
{
	public static void main(String[] args)
	{
		var f1 = new BigDecimal("0.05");
		var f2 = BigDecimal.valueOf(0.01);
		var f3 = new BigDecimal(0.05);
		System.out.println("使用String作为BigDecimal构造器参数：");
		System.out.println("0.05 + 0.01 = " + f1.add(f2));
		System.out.println("0.05 - 0.01 = " + f1.subtract(f2));
		System.out.println("0.05 * 0.01 = " + f1.multiply(f2));
		System.out.println("0.05 / 0.01 = " + f1.divide(f2));
		System.out.println("使用double作为BigDecimal构造器参数：");
		System.out.println("0.05 + 0.01 = " + f3.add(f2));
		System.out.println("0.05 - 0.01 = " + f3.subtract(f2));
		System.out.println("0.05 * 0.01 = " + f3.multiply(f2));
		System.out.println("0.05 / 0.01 = " + f3.divide(f2));
	}
}

使用String作为BigDecimal构造器参数：
0.05 + 0.01 = 0.06
0.05 - 0.01 = 0.04
0.05 * 0.01 = 0.0005
0.05 / 0.01 = 5
使用double作为BigDecimal构造器参数：
0.05 + 0.01 = 0.06000000000000000277555756156289135105907917022705078125
0.05 - 0.01 = 0.04000000000000000277555756156289135105907917022705078125
0.05 * 0.01 = 0.0005000000000000000277555756156289135105907917022705078125
0.05 / 0.01 = 5.000000000000000277555756156289135105907917022705078125

做加减乘除精确运算时，可以为BigDecimal写一个工具类方便使用。

public class Arith
{
	// 默认除法运算精度
	private static final int DEF_DIV_SCALE = 10;
	// 构造器私有，让这个类不能实例化
	private Arith()	{}
	// 提供精确的加法运算。
	public static double add(double v1, double v2)
	{
		var b1 = BigDecimal.valueOf(v1);
		var b2 = BigDecimal.valueOf(v2);
		return b1.add(b2).doubleValue();
	}
	// 提供精确的减法运算。
	public static double sub(double v1, double v2)
	{
		var b1 = BigDecimal.valueOf(v1);
		var b2 = BigDecimal.valueOf(v2);
		return b1.subtract(b2).doubleValue();
	}
	// 提供精确的乘法运算。
	public static double mul(double v1, double v2)
	{
		var b1 = BigDecimal.valueOf(v1);
		var b2 = BigDecimal.valueOf(v2);
		return b1.multiply(b2).doubleValue();
	}
	// 提供（相对）精确的除法运算，当发生除不尽的情况时.
	// 精确到小数点以后10位的数字四舍五入。
	public static double div(double v1, double v2)
	{
		var b1 = BigDecimal.valueOf(v1);
		var b2 = BigDecimal.valueOf(v2);
		return b1.divide(b2, DEF_DIV_SCALE,
			RoundingMode.HALF_UP).doubleValue();
	}
	public static void main(String[] args)
	{
		System.out.println("0.05 + 0.01 = "
			+ Arith.add(0.05, 0.01));
		System.out.println("1.0 - 0.42 = "
			+ Arith.sub(1.0, 0.42));
		System.out.println("4.015 * 100 = "
			+ Arith.mul(4.015, 100));
		System.out.println("123.3 / 100 = "
			+ Arith.div(123.3, 100));
	}
}

java.time包中的日期时间类(Clock)

public class NewDatePackageTest
{
   public static void main(String[] args)
   {
      // -----下面是关于Clock的用法-----
      // 获取当前Clock
      var clock = Clock.systemUTC();
      // 通过Clock获取当前时刻
      System.out.println("当前时刻为：" + clock.instant());
      // 获取clock对应的毫秒数，与System.currentTimeMillis()输出相同
      System.out.println(clock.millis());
      System.out.println(System.currentTimeMillis());
      // -----下面是关于Duration的用法-----
      var d = Duration.ofSeconds(6000);
      System.out.println("6000秒相当于" + d.toMinutes() + "分");
      System.out.println("6000秒相当于" + d.toHours() + "小时");
      System.out.println("6000秒相当于" + d.toDays() + "天");
      // 在clock基础上增加6000秒，返回新的Clock
      var clock2 = Clock.offset(clock, d);
      // 可以看到clock2与clock1相差1小时40分
      System.out.println("当前时刻加6000秒为：" +clock2.instant());
      // -----下面是关于Instant的用法-----
      // 获取当前时间
      var instant = Instant.now();
      System.out.println(instant);
      // instant添加6000秒（即100分钟），返回新的Instant
      var instant2 = instant.plusSeconds(6000);
      System.out.println(instant2);
      // 根据字符串解析Instant对象
      var instant3 = Instant.parse("2014-02-23T10:12:35.342Z");
      System.out.println(instant3);
      // 在instant3的基础上添加5小时4分钟
      var instant4 = instant3.plus(Duration
         .ofHours(5).plusMinutes(4));
      System.out.println(instant4);
      // 获取instant4的5天以前的时刻
      var instant5 = instant4.minus(Duration.ofDays(5));
      System.out.println(instant5);
      // -----下面是关于LocalDate的用法-----
      var localDate = LocalDate.now();
      System.out.println(localDate);
      // 获得2014年的第146天
      localDate = LocalDate.ofYearDay(2014, 146);
      System.out.println(localDate); // 2014-05-26
      // 设置为2014年5月21日
      localDate = LocalDate.of(2014, Month.MAY, 21);
      System.out.println(localDate); // 2014-05-21
      // -----下面是关于LocalTime的用法-----
      // 获取当前时间
      var localTime = LocalTime.now();
      // 设置为22点33分
      localTime = LocalTime.of(22, 33);
      System.out.println(localTime); // 22:33
      // 返回一天中的第5503秒
      localTime = LocalTime.ofSecondOfDay(5503);
      System.out.println(localTime); // 01:31:43
      // -----下面是关于localDateTime的用法-----
      // 获取当前日期、时间
      var localDateTime = LocalDateTime.now();
      // 当前日期、时间加上25小时３分钟
      var future = localDateTime.plusHours(25).plusMinutes(3);
      System.out.println("当前日期、时间的25小时3分之后：" + future);
      // -----下面是关于Year、YearMonth、MonthDay的用法示例-----
      var year = Year.now(); // 获取当前的年份
      System.out.println("当前年份：" + year); // 输出当前年份
      year = year.plusYears(5); // 当前年份再加5年
      System.out.println("当前年份再过5年：" + year);
      // 根据指定月份获取YearMonth
      var ym = year.atMonth(10);
      System.out.println("year年10月：" + ym); // 输出XXXX-10，XXXX代表当前年份
      // 当前年月再加5年、减3个月
      ym = ym.plusYears(5).minusMonths(3);
      System.out.println("year年10月再加5年、减3个月：" + ym);
      var md = MonthDay.now();
      System.out.println("当前月日：" + md); // 输出--XX-XX，代表几月几日
      // 设置为5月23日
      var md2 = md.with(Month.MAY).withDayOfMonth(23);
      System.out.println("5月23日为：" + md2); // 输出--05-23
   }
}

java.time包中的日期时间格式器

public class NewFormatterTest
{
	public static void main(String[] args)
	{
		var formatters = new DateTimeFormatter[] {
			// 直接使用常量创建DateTimeFormatter格式器
			DateTimeFormatter.ISO_LOCAL_DATE,
			DateTimeFormatter.ISO_LOCAL_TIME,
			DateTimeFormatter.ISO_LOCAL_DATE_TIME,
			// 使用本地化的不同风格来创建DateTimeFormatter格式器
			DateTimeFormatter.ofLocalizedDateTime(FormatStyle.FULL, FormatStyle.MEDIUM),
			DateTimeFormatter.ofLocalizedDate(FormatStyle.LONG),
			// 根据模式字符串来创建DateTimeFormatter格式器
			DateTimeFormatter.ofPattern("Gyyyy%%MMM%%dd HH:mm:ss")
		};
		var date = LocalDateTime.now();
		// 依次使用不同的格式器对LocalDateTime进行格式化
		for (var i = 0; i < formatters.length; i++)
		{
			// 下面两行代码的作用相同
			System.out.println(date.format(formatters[i]));
			System.out.println(formatters[i].format(date));
		}
	}
}

public class NewFormatterParse
{
   public static void main(String[] args)
   {
      // 定义一个任意格式的日期时间字符串
      var str1 = "2014==04==12 01时06分09秒";
      // 根据需要解析的日期、时间字符串定义解析所用的格式器
      var fomatter1 = DateTimeFormatter
         .ofPattern("yyyy==MM==dd HH时mm分ss秒");
      // 执行解析
      var dt1 = LocalDateTime.parse(str1, fomatter1);
      System.out.println(dt1); // 输出 2014-04-12T01:06:09
      // ---下面代码再次解析另一个字符串---
      var str2 = "2014$$$4月$$$13 20小时";
      var fomatter2 = DateTimeFormatter
         .ofPattern("yyy$$$MMM$$$dd HH小时");
      var dt2 = LocalDateTime.parse(str2, fomatter2);
      System.out.println(dt2); // 输出 2014-04-13T20:00

   }
}

JavaSE合集五

原文：https://www.cnblogs.com/jtStudy/p/14607682.html