1.字符串相关类

String类及常用方法

String声明为final的，不可被继承
String实现了
1. Serializable接口：表示字符串是支持序列化的
2. Comparable接口：表示String可以比较大小
String内部定义了final char[] value用于储存字符串数据
String代表不可变的字符序列->不可变性
String对象的创建

String str = "hello";
String s1 = new String();
String s2 = new String(String val);
String s3 = new String(char[] val);
String s4 = new String(char[] a, int startIndex, int count);
String s5 = new String(int[] data); // ASCII码转字符

String内存解析

String h1="Hello",  w1="World";    // 变量
final String h2="Hello",  w2="World"; // 常量
String s1 = "HelloWorld";    //会存储在常量池中，后续再调用也是同一个地址
String s2 = "Hello" + "World"; // 常量+常量，编译期会自动合并两个，常量池中
String s3 = h1 + w1; // 变量+变量，在堆中创建
String s4 = h2 + w2; // 常量+常量，在常量池中
String s5 = h2 + "World"; // 常量+常量，在常量池中
String s6 = h1 + w2; // 变量+常量，在堆中创建
String s7 = (h1 + w2).intern(); // intern中内容强行存入常量池中
String s8 = new String("HelloWorld"); // 在堆中创建

String常用类

int length();
// 返回字符串的长度：return value.length
char charAt(int index); 
// 返回某索引处的字符：return value[index]
boolean isEmpty();
// 判断是否是空字符串：return value.length == 0
String toLowerCase();
// 使用默认语言环境，将 String 中的所有字符转换为小写
String toUpperCase();
// 使用默认语言环境，将 String 中的所有字符转换为大写
String trim();
// 返回字符串的副本，忽略前导空白和尾部空白
boolean equals(Object obj);
// 比较字符串的内容是否相同
boolean equalsIgnoreCase(String anotherString);
// 与equals方法类似，忽略大小写
String concat(String str);
// 将指定字符串连接到此字符串的结尾。 等价于用“+”
int compareTo(String anotherString);
// 比较两个字符串的大小
String substring(int beginIndex);
// 返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
String substring(int beginIndex, int endIndex);
// 返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
boolean endsWith(String suffix);
// 测试此字符串是否以指定的后缀结束
boolean startsWith(String prefix);
// 测试此字符串是否以指定的前缀开始
boolean startsWith(String prefix, int toffset);
// 测试此字符串从指定索引开始的子字符串是否以指定前缀开始
boolean contains(CharSequence s);
// 当且仅当此字符串包含指定的 char 值序列时，返回 true
int indexOf(String str);
// 返回指定子字符串在此字符串中第一次出现处的索引
int indexOf(String str, int fromIndex);
// 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
int lastIndexOf(String str);
// 返回指定子字符串在此字符串中最右边出现处的索引
int lastIndexOf(String str, int fromIndex);
// 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索
String replace(char oldChar, char newChar);
// 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。 
String replace(CharSequence target, CharSequence replacement);
// 使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。 
String replaceAll(String regex, String replacement);
//  使用给定的replacement 替换此字符串所有匹配给定的正则表达式的子字符串。 
String replaceFirst(String regex, String replacement);
//  使用给定的replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
String[] split(String regex);
// 根据给定正则表达式的匹配拆分此字符串。 
String[] split(String regex, int limit);
// 根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。
boolean matches(String regex);
// 告知此字符串是否匹配给定的正则表达式。 
// 编码问题
byte[] getBytes();
// 使用默认编码集进行转换byte数组
byte[] getBytes(String charsetName); // GBK、utf8
// 使用指定编码集进行转换byte数组
String new String(byte[] data, String charsetName);
// byte数组解码
// char数组返回字符串
String String.copyValueOf(char[] data); 
String String.copyValueOf(char[] data, int offset, int count); // 开头+长度
String String.valueOf(char[] data);
String String.valueOf(char[] data, int offset, int count);

使用案例

String str.replaceAll("//d", "");// 正则去除数字
String str.replaceAll("^,|,$", "");// 去除开头或结尾的逗号(,)
boolean str.matches("\\d+"); // 判断字符是否全部有数字组成
boolean result = tel.matches("0571-\\d{7,8}"); // 判断是否是杭州的固定电话
String[] str.split(" "); //以空格进行切分字符串
String[] str.split("\\."); //以点进行切分字符串

正则匹配

匹配格式	匹配说明
字符类
[abc]	a、b、c
[^abc]	除a、b、c外的字符
[a-zA-Z]	[a-z]或[A-Z]的字符
预定类字符类
.	匹配所有(行结束符肯能匹配不到)
\d	数字：[0-9]
\D	非数字： [^0-9]
\s	空白字符：[ \t\n\x0B\f\r]
\S	非空白字符：[^\s]
\w	单词字符：[a-zA-Z_0-9]
\W	非单词字符：[^\w]
POSIX字符类（仅US-ASCII）
\p{Lower}	小写字母字符：[a-z]
\p{Upper}	大写字母字符：[A-Z]
\p{ASCII}	所有 ASCII：[\x00-\x7F]
\p{Alpha}	字母字符：[\p{Lower}\p{Upper}]
\p{Digit}	十进制数字：[0-9]
\p{Alnum}	字母数字字符：[\p{Alpha}\p{Digit}]
\p{Punct}	!”#$%&’()*+,-./:;<=>?@[]^_`{\|}~
\p{Blank}	空格或制表符：[ \t]
边界匹配器
^	行开头
$	行结尾
Greedy 数量词
x?	X，一次或一次也没有
x*	X，零次或多次
x+	X，一次或多次
x{n}	X，恰好 n 次
x{n,}	X，至少 n 次
x{n,m}	X，至少 n 次，但是不超过 m 次
Logical 运算符
XY	X 后跟 Y
X \| Y	X 或 Y
(x)	X，作为捕获组
特殊构造（非捕获）
(?:X)	X，作为非捕获组
(?=X)	X，通过零宽度的正 lookahead
(?!X)	X，通过零宽度的负 lookahead
(?<=X)	X，通过零宽度的正 lookbehind
(?<!X)	X，通过零宽度的负 lookbehind
(?>X)	X，作为独立的非捕获组

常见正则

验证用户名和密码，要求第一个字必须为字母，一共6~16位字母数字下划线组成：
(^[a-zA-Z]\w{5,15}$)
验证电话号码：xxx/xxxx-xxxxxxx/xxxxxxxx：
(^(\d{3,4}-)\d{7,8}$)
验证手机号码：
( ^(13[0-9]|14[5|7]15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$ )
验证身份证号：
(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$) 
验证Email地址：
(^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$)
只能输入由数字和26个英文字母组成的字符串：
(^[A-Za-z0-9]+$)
整数或者小数：
(^[0-9]+(\.\[0-9\]+){0,1}$)
中文字符的正则表达式：
([\u4e00-\u9fa5])
金额校验(非零开头的最多带两位小数的数字)：
(^(\[1-9\][0-9]*)+(.[0-9]{1,2})?$)
IPV4地址：
(((\\d{1,2})|(1\\d{1,2})|(2[0-4]\\d)|(25[0-5]))\\.){3}((\\d{1,2})|(1\\d{1,2})|(2[0-4]\\d)|(25[0-5]))

AbstractStringBuilder

StringBuilder、StringBuffer的继承对象，它们的接口完全一致

sb -> StringBuilder
StringBuilder append(xx);    
// 链式编程、拼接(改变原数组并返回数组)
StringBuilder insert(int index, xx);
// 在index位置插入元素(改变原数组并返回数组)
StringBuilder deleteCharAt(int index);
// 删除index位置的元素(改变原数组并返回数组)
StringBuilder delete(int start, int end);
// 删除[start, end)的值(改变原数组并返回数组)
void serCharAt(int index, xx);
// 替换index位置的字符
StringBuffer reverse();
// 字符串反转
void setLength(int newLength);
// 设置当前字符序列长度为newLength
StringBuffer replace(int start, int end, String str);
// 替换[start, end)的字符序列为str
int indexOf(String str);
// 查询str第一次出现的下标
int indexOf(String str, int fromIndex);
// 查询从[fromIndex,最后]出现的下标
int lastIndexOf(String str);
// 查询最后一次出现的下标
int lastIndexOf(String str, int fromIndex);
// 查询从[fromIndex,最后]最后一次出现的下标
String substring(int start);
// 截取当前字符序列[start,最后]并返回
String substring(int start, int end);
// 截取当前字符序列[start,en)并返回
String toString();
// 当前序列以字符串返回
int length();
// 返回长度(字符串数)
int capacity();
// 返回当前容量
int codePointAt(int index)；
// 返回索引位置的ascii码值
// StringBuffer和String的互换
String str = builderStr.toString();
StringBuilder str = new StringBuilder(str);

StringBuffer

面试题1：String、StringBuffer、StringBuilder的区别

String：

不可变的字符序列；
底层使用final的char型数组

StringBuffer：

底层使用char型数组，可变
可变的字符序列；线程安全的(它方法有synchronized)，效率低

StringBuilder：

底层使用char型数组，可变
jdk5新增，线程不安全，效率高

面试题2：为什么字符串的length()和数组的length不同

字符串的length()是方法、数组的length是属性/常量

为什么字符串使用的是方法？

因为字符串底层就是使用char型数组实现的，
而数组里就有length属性，通过内部数组调用length属性即可，无需再创建一个属性

2. 数组类

Array

Object Arrary.get(Object arr, int index);    // 返回位置的值
Array.copy(E[] e,newLength);    // 扩容

Arrays


//java.util.Arrays
Object Arrays.copyOf();
boolean equals(int[] a, int[] b);// judge tow arrays is euals
String toString(int[] a); //print array  info
void fill(int[] a, int val); //将指定值填充到数组中
void sort(int[] a); //sort the array
int binarySearch(int[] a, int key); // binary find
int[] copyOf(int[] original, int newLength); //copy array
List<T> asList(T...a); // 生成不可变的Listmap

3.JDK8之前的时期时间API

Date类

import java.util.Date;
Date date = new Date();
// 当前系统时间
new Date(long);
// 毫秒值转时间对象
long getTime();
// 距离1970-1-1的毫秒值
// 不推荐使用
int getYear();    //年 今年-1990
int getMonth();    //月 [0,11]
int getDay();    //星期 [0,6] 0是星期日、1是星期一...
int getHours();    //时 [0,23]
int getMinutes();//分 [0,59]
int getSeconds();//秒 [0,59]

Calendar类 -> 日期类

import java.util.Calendar;
Calendar c = Calendar.getInstance();
// 获取Calendar的对象
get(常量);
Calendar.YEAR
// 获取年
Calendar.MONDAY
// 获取月[0-11]
Calendar.DATE
// 获取日[1-31]
Calendar.HOUR
// 获取时[1-12]
Calendar.MINUTE
// 获取分[1-60]
Calendar.SECOND
// 获取秒
Calendar.ZONE_OFFSET
// 获取毫秒

SimpleDateFormat类

格式化：日期 -> 文本解析：文本 -> 日期

import java.text.SimpleDateFormat;
import java.util.Date;
// 格式化日期对象 转 文本日期
Date date = new Date();
// 创建当前对象
SimpleDateFormat format0 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
// 创建格式化字符规则
String time = format0.format(date.getTime());
// 生成指定时间字符串
// 解析文本日期 转 日期对象
SimpleDateFormat format1 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
// 创建格式化字符规则
Date date1 = format1.parse("2022年03月06日 11时47分48秒");
// 解析文本生成日期对象

yyyy：年 MM：月 dd：日 hh：1~12小时制(1-12) HH：24小时制(0-23) mm：分 ss：秒 S：毫秒 E：星期几 D：一年中的第几天 F：一月中的第几个星期(会把这个月总共过的天数除以7) w：一年中的第几个星期 W：一月中的第几星期(会根据实际情况来算) a：上下午标识 k：和HH差不多，表示一天24小时制(1-24)。 K：和hh差不多，表示一天12小时制(0-11)。 z：表示时区

4.JDK8中新时期时间API

Date类被弃用，Date面临的问题

Date中年份以1900年开始、月从0开始、日从1开始

容易导致开发人员混淆

Date和SimpleDateFormat它们是线程不安全的

时间处理开发中并发会有潜在安全问题

没有时区的组件、在DateFormat中更好的处理日期格式、无法使用非公历日期

TemporalAdjusters类->时间调整器

LocalDate的时间调整器

import java.time.temporal.TemporalAdjusters;
import java.time.DayOfWeek;
TemporalAdjusters.dayOfWeekInMonth();
// 一周中的某一天，例如，三月中第二个星期二
TemporalAdjusters.firstDayOfMonth();
// 当前月的第一天
TemporalAdjusters.firstDayOfNextMonth();
// 下一个月的第一天
TemporalAdjusters.firstDayOfNextYear();
// 下一年的第一天
TemporalAdjusters.firstDayOfYear();
// 当年的第一天
TemporalAdjusters.lastDayOfMonth();
// 当月的最后一天
TemporalAdjusters.nextOrSame();
// 下一次或当天发生的一周中的某天

LocalDate->对年月日做出处理

LocalTime->对时分秒纳秒做出处理

LoaclDateTime->同时可以处理年月日时分秒

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
// LocalDate、LocalTime、LocalDateTime他们的共同接口为Temporal
// 这使用Temporal来代替
Temporal now(); Temporal now(Zooeld zooe);
// 获取系统时间对象
Temporal of(Y,M,D,H,M,S,N);
// 自定义时间对象
// datetime(年、月、日、时、分、秒、毫秒) 
// date    (年、月、日)
// time (时、分、秒、毫秒)
String toString();
// datetime (年-月-日T时:分:秒.毫秒)
// date (年-月-日)
// time(时:分:秒.毫秒)
long toInstant(ZoneOffset.of("+8")).toEpochMilli();
// 获取时间戳
int getYear();
// 获取年[2022]
Month getMonth();
// 获取月对象
int getMonthValue(); int getMonth().getValue();
// 获取月值[1-12]
String getMonth().toString();
// 获取月英语
int getDayOfWeek().getValue();
// 今天是星期几、[星期一,星期日],[1,7]
String getDayOfWeek().toString();
// 今天星期的英语单词
int getDayOfMonth();
// 今天是几号 [1-31]
int getDayOfYear();
// 今天是今年的第几天
int getHour();
// 获取小时
int getMinute();
// 获取分钟
int getSecond();
// 获取秒
Temporal withYear(); Temporal withMonth(); Temporal withDayOfYear(); Temporal withDayOfMonth();
// 修改年；修改月；修改年份天数；修改月份天数(修改并返回对象)
Temporal with(TemporalAdjusters t);
// 使用时间调整器进行修改时间(修改并返回对象)
Temporal plusDays(); Temporal plusWeeks(); Temporal plusMonths(); Temporal plusYears(); Temporal plusHours();
// 当前对象添加几天、几周、几月、几年、几小时(修改并返回对象)
Temporal minusDays(); Temporal minusWeeks(); Temporal minusMonths(); Temporal minusYears(); Temporal minusHours();
// 当前对象减少几天、几周、几月、几年、几小时
Temporal plus(TemporalAdjusters t); Temporal minus(TemporalAdjusters t);
// 使用时间调整器进行添加和修改时间
boolean isBefore(Temporal b); boolean isAfter(Temporal b);
// 两个时间对象进行对比(a<b?true:false);(a>b?true:false)
boolean isLeapYear();
// 判断是否是闰年
Temporal parse("2022-03-04");
// 根据字符串获取，严格按照yyyy-MM-dd来验证(04不能写成4)
Temporal with(TemporalAdjusters.firstDayOfMonth());
// 获取本月第一天的日期(2022-03-01)
Temporal with(TemporalAdjusters.lastDayOfMonth());
// 获取本月最后一天的日期(2022-03-31)
Temporal with(TemporalAdjusters.firstDayOfNextMoth());
// 获取下一个月的第一天
Temporal Temporal.parse("2022-01-01").with(TemporalAdjusters.firstInMonth(DayOfWeek.MONDAY));
Temporal Temporal.now().with(TemporalAdjusters.firstDayOfYear()).
    with(TemporalAdjusters.firstInMonth(DayOfWeek.MONDAY));
// 获取今年的第一个星期一

LocalDate、LocalTime、LocalDateTime的区别？相同点：三者的创建、方法都有共同之处不同点： LocalDate只对日期进行处理 LocalTime只对时间进行处理 LocalDateTime可以处理日期和时间

ZonedDateTime->时区信息类、Zone的时区类

ZonedDateTime同样拥有LocalDateTime的方法

import java.time.ZoneId;
import java.time.ZonedDateTime;
ZoedDateTime ZoedDateTime.now();
// 获取带有时区的时间对象
ZoedDateTime ZoedDateTime.now(ZoneId.of("America/New_York"));
now(ZoneId.of("UTC")); // 标准时区
new(ZoneId.of("GMT")); // 格林威治时区；GMT(+0)、GMT+8(+8)
// 获取并修改时区的时间对象
ZoedDateTime ZoedDateTime.now(ZoneId.of());
ZoneId getZone();
// 获取时区

时区                协调时区    位置、国家、城市
Asia/Harbin            UTC+8    亚洲 / 中国 / 哈尔滨
Asia/Shanghai        UTC+8    亚洲 / 中国 / 上海    // 默认时区
Asia/Chungking        UTC+8    亚洲 / 中国 / 重庆
Asia/Urumqi            UTC+6    亚洲 / 中国 / 乌鲁木齐
Asia/Kashgar        UTC+6    亚洲 / 中国 / 喀什地区
Asia/Macao            CST        亚洲 / 中国 / 澳门
Asia/Hong_Kong         HKT        亚洲 / 中国 / 香港
Asia/Taipei         CST        亚洲 / 中国 / 台湾台北
Asia/Seoul             KST        亚洲 / 韩国 / 首尔
Asia/Tokyo            JST        亚洲 / 日本 / 东京
Asia/Singapore         +08        亚洲 / 新加坡 / 新加坡
Asia/Saigon         +07     亚洲 / 越南 / 西贡
Asia/Bangkok         +07        亚洲 / 泰国 / 曼谷
Asia/Phnom_Penh     +07        亚洲 / 柬埔寨 / Phnom_Penh
Asia/Dubai             +04        亚洲 / 阿拉伯联合酋长国 / 迪拜
America/New_York    EDT        美洲 / 美国 / 纽约
America/Cayman         EST        美洲 / 开曼群岛 / 开曼
Europe/Zurich        CEST    欧洲 / 瑞士 / 苏黎世
Europe/Berlin        CEST    欧洲 / 德国 / 柏林
Europe/Paris        CEST    欧洲 / 法国 / 巴黎
Europe/London        BST        欧洲 / 英国 / 伦敦
Europe/Athens        EEST    欧洲 / 希腊 / 雅典
Europe/Rome            CEST    欧洲 / 意大利 / 罗马
Australia/Sydney    AEST    澳大利亚 / 悉尼
Africa/Cairo        EET        非洲    / 埃及 / 开罗
Africa/Johannesburg    SAST    非洲 / 南非 / 约翰内斯堡

Period->日期间隔类

import java.time.Period;
// 用于计算两个日期的间隔
LocalDate t1 = LocalDate.now();
LocalDate t2 = LocalDate.of(2020, 5, 5);
Period b = Period.between(t2, t1);
int b.getYears();
// 间隔年
int b.getMonths();
// 间隔月
int b.getDays();
// 间隔日
long b.toTotalMonths();
// 总共间隔月份(隔年*12 + 隔月)

Duration->时间间隔类

import java.time.Duration;
// 计算两个时间的间隔
LocalDateTime t1 = LocalDateTime.now();
LocalDateTime t2 = LocalDateTime.of(2018, 12, 31, 0, 0, 0);
Duration d = Duration.between(t2, t1);
long d.toDays();
// 总天数
long d.toHours();
// 总小时
long d.toMinutes();
// 总分钟

DateTimeFormatter

import java.time.format.DateTimeFormatter;
// 预定义的标准格式，toString()就是标准格式
// 2022-03-06T21:59:39.419
DateTimeFormatter ISO_DATE_TIME;
// 本地化相关的格式1
// 2022年3月6日 下午09时59分39秒
DateTimeFormatter ofLocalizedDateTime(FormatStyle.LONG);
// 本地化相关的格式2
// 22-3-6 下午9:59
DateTimeFormatter ofLocalizedDateTime(FormatStyle.SHORT);
// 自定义的格式
// 2022年03月06日 21时59分39秒419毫秒星期日是这年的65天
DateTimeFormatter ofPattern("yyyy年MM月dd日 HH时mm分ss秒SSS毫秒E是这年的D天");
// 格式化时间对象转文本，标准写法
LocalDateTime now = LocalDateTime.now();
DateTimeFormatter df = DateTimeFormatter.ISO_DATE_TIME;
System.out.println(df.format(now));
// 解析文本转时间对象，标准写法
String str = "2022-03-06T21:59:39.419";
DateTimeFormatter dtf = DateTimeFormatter.ISO_DATE_TIME;
LocalDateTime dt = LocalDateTime.parse(str, dtf);

Instant

5.Java比较器

Comparable接口

Comparator接口

6.数学相关类

Math类，包含基本数学运算方法

double PI; 
//返回圆周率
double ceil(double a);    
// 向上取整    
double floor(double a);    
// 向下取整
int round(float a);     
// 四舍五入
int abs(int a);    
// 绝对值
double pow(double a, double b);
//a的b次方
double sqrt(double a);     
// 平方根
int max(int a, int b);    
// 最大值
int min(int a, int b); 
//最小值
double log(double a);    
// 自然对数
double random();    
// 产生 0-1的随机数
    random()*90+10;    // 10-99的随机数
    random()*6+1;// 1-7的随机数
    random()*10; //0-9的随机数

Random随机类

import java.util.Random;
00                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          new Random();
// 创建随机数生成器
new Random(long seed);
// 使用long种子创建一个新的随机数生成器
// 种子相同生成的随机数相同(这是生成器，重复调用，随机数相同)
boolean nextBoolean();
// 返回随机布尔值
vode nextBytes(byte[] bytes);
// 生成随机字节，并覆盖bytes的数组(含正数、负数、0)[-128,127]
double nextDouble();
// 生成[0,1)之间的16-17位小数
float nextFloat();
// 生成[0,1)之间的6-8位小数
double nextGaussian();
// 呈高斯(正态)分布的double值,平均值是0,标准误差是1
int nextInt();
// 返回均匀分布的int值
int nextInt(int n);
// 返回均匀分布[0,n)的int值
long nextLong();
// 返回均匀分布的Long值

BigInteger：用于表示任意超大的整数

底层使用字符串存储，用特殊的运算规则来模拟整数类型

BigInteger b1 = new BigInteger("12345648674896486");
BigInteger b2 = new BigInteger("12345648674896486");
b1.add(b2);    //相加
b1.subtract(b2); // 相减
BigInteger abs()  返回大整数的绝对值
BigInteger add(BigInteger val) 返回两个大整数的和
BigInteger and(BigInteger val)  返回两个大整数的按位与的结果
BigInteger andNot(BigInteger val) 返回两个大整数与非的结果
BigInteger divide(BigInteger val)  返回两个大整数的商
double doubleValue()   返回大整数的double类型的值
float floatValue()   返回大整数的float类型的值
BigInteger gcd(BigInteger val)  返回大整数的最大公约数
int intValue() 返回大整数的整型值
long longValue() 返回大整数的long型值
BigInteger max(BigInteger val) 返回两个大整数的最大者
BigInteger min(BigInteger val) 返回两个大整数的最小者
BigInteger mod(BigInteger val) 用当前大整数对val求模
BigInteger multiply(BigInteger val) 返回两个大整数的积
BigInteger negate() 返回当前大整数的相反数
BigInteger not() 返回当前大整数的非
BigInteger or(BigInteger val) 返回两个大整数的按位或
BigInteger pow(int exponent) 返回当前大整数的exponent次方
BigInteger remainder(BigInteger val) 返回当前大整数除以val的余数
BigInteger leftShift(int n) 将当前大整数左移n位后返回
BigInteger rightShift(int n) 将当前大整数右移n位后返回
BigInteger subtract(BigInteger val)返回两个大整数相减的结果
byte[] toByteArray(BigInteger val)将大整数转换成二进制反码保存在byte数组中
String toString() 将当前大整数转换成十进制的字符串形式
BigInteger xor(BigInteger val) 返回两个大整数的异或

BigDecimal：用来对超过16位有效位的数进行精确的运算

2、构造器描述 
BigDecimal(int)       创建一个具有参数所指定整数值的对象。 
BigDecimal(double) 创建一个具有参数所指定双精度值的对象。 //不推荐使用
BigDecimal(long)    创建一个具有参数所指定长整数值的对象。 
BigDecimal(String) 创建一个具有参数所指定以字符串表示的数值的对象。//推荐使用
3、方法描述 
BigInteger add(BigDecimal)        BigDecimal对象中的值相加，然后返回这个对象。 
BigInteger subtract(BigDecimal) BigDecimal对象中的值相减，然后返回这个对象。 
BigInteger multiply(BigDecimal)  BigDecimal对象中的值相乘，然后返回这个对象。 
BigInteger divide(BigDecimal)     BigDecimal对象中的值相除，然后返回这个对象。 
String toString()                将BigDecimal对象的数值转换成字符串。 
double doubleValue()          将BigDecimal对象中的值以双精度数返回。 
float floatValue()             将BigDecimal对象中的值以单精度数返回。 
long longValue()             将BigDecimal对象中的值以长整数返回。 
int intValue()               将BigDecimal对象中的值以整数返回。

6.系统类

System

void System.arraycopy(obj[] arr1，int index1, arr2, int index2, int length);
// array拷贝(原数组， 原数组开始位置， 目标数组， 目标数组位置， 拷贝数量)
long System.currentTimeMillis();
// 获取时间戳
void System.exit(0);
// 终止程序
void System.gc();   
// 通知垃圾回收器回收垃圾，回收释放对象占用的内存
String System.getProperty("user.name");
// 获取系统环境变量值
Properties p = System.getProperties();
for(Object o:p.keySet()){
    Object v = p.get(o);
    System.out.println(o + "---->" + v);}
// 获取所有的系统变量信息

Runtime

Runtion运行时类，每个java程序，在运行期间都会有一个Runtime类实例，用于连接运行环境 Runtion类它是单例模式设计的(饿汉式)

Runtime rt = Runtime.getRuntime();
// 获取Runtime类实例
void System.exit(0);
// 终止程序
void System.gc();   
// 通知垃圾回收器回收垃圾，回收释放对象占用的内存
Process exec("notepad");
// 使用系统cmd命令
// notepad记事本、calc计算器、mspaint画图板
long totalMemory();
// Java虚拟机中的内存总量
long freeMemory();
// Java虚拟机中的空闲内存量，gc可能释放内存
long maxMemory();
// java虚拟机试图使用的最大内存量

Java 基础笔记

7.java常用类

1.字符串相关类

String类及常用方法

String对象的创建

String内存解析

String常用类

AbstractStringBuilder

StringBuffer

2. 数组类

Array

Arrays

3.JDK8之前的时期时间API

Date类

Calendar类 -> 日期类

SimpleDateFormat类

4.JDK8中新时期时间API

TemporalAdjusters类->时间调整器

LocalDate->对年月日做出处理

LocalTime->对时分秒纳秒做出处理

LoaclDateTime->同时可以处理年月日时分秒

ZonedDateTime->时区信息类、Zone的时区类

Period->日期间隔类

Duration->时间间隔类

DateTimeFormatter

Instant

5.Java比较器

Comparable接口

Comparator接口

6.数学相关类

Math类，包含基本数学运算方法

Random随机类

BigInteger：用于表示任意超大的整数

BigDecimal：用来对超过16位有效位的数进行精确的运算

6.系统类

System

Runtime