Math类
Math类中包含一些对数据进行数学运算的方法，而该类中的方法全都是静态的。像这样的类称之为工具类。
public static int abs(int a)
对一个数据求绝对值
public static double ceil(double n)
对一个小数向上取整 4.3 --> 5.0
public static double floor(double n)
对一个小数向下取整 4.3 --> 4.0
public static long round(double n)
对一个小数进行四舍五入 4.3 --> 4 ; 4.5 --> 5
public static int max(int a,int b)
求两个数的最大值
public static int min(int a,int b)
求两个数的最小值
public static double random()
生成[0,1)范围内的随机数System类
public static void exit(int n)
退出Java虚拟机 //System.exit(0);
public static long currentTimeMillis()
获取当前时间的毫秒值，距离1970年1月1日0时0分0秒之间的毫秒值
public static void arraycopy(Object src, int srcPos,Object dest,int destPos,int length)
把源数组中的元素复制到目标数组中。
参数：
src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量。
int[] arrayA={1,2,3,4,5};
int[] arrayB=new int[2];
//把arrayA中的3和4这两个元素，赋值到arrayB中
System.arraycopy(arrayA,2,arrayB,0,2);
Object类
Object是所有类的父类，任何一个子类都可以调用Object的方法。
public String toString()
把一个对象转换字符串。 字符串格式： 包名+类名@地址值。
每次打印对象，底层会自动去调用toString()方法。
注意：自己写的类，如果不想打印地址就可以复写toString()方法
快捷键：alt+inert-->toString()
public boolean equals(Object obj)
用来比较两个对象是否“相等“。
默认比较的是地址值，底层用的是"=="
注意：自己写的类，如果不想比较地址值可以重写equals()方法，比较自己的内容.
快捷键：alt+inert-->Equals and HashCodeObjects类
Objects类是一个工具类，经常用于对一个对象进行判空的处理。JDK7以后才有的
public static String toString(Object s,String defalutStr)
把一个对象转换为字符串, 如果对象为null,返回默认字符串
public static boolean isNull(Object s)
判断一个对象是否为null 等价于 s==null
public static boolean nonNull(Object s)
判断一个对象不为null 等价于 s!=nullBigDegimal类
BigDegimal可以做一些数据的精确运算，还可做一些较大数据的运算。
构造方法
public BigDecimal(double val)
使用double类型的小数，创建BigDecimal对象
public BigDecimal(String val)
使用String类型的数据(必须是纯数字)，创建BigDecimal对象四则运算的方法
public BigDecimal add(BigDecimal augend)
对两个数进行加法运算
public BigDecimal subtract(BigDecimal subtrahend)
对两个数进行减法运算
public BigDecimal multiply(BigDecimal multiplicand)
对两个数进行乘法运算
public BigDecimal divide(BigDecimal divisor)
对两个数进行除法运算
public BigDecimal divide(BigDecimal divisor,int num,int type)
对两个数进行除法运算，可以保留小数个数.
参数：
BigDecimal divisor： 除数
int num：保留小数个数
int type: 保留小数的方式
BigDecimal.ROUND_HALF_UP 最后一位小数四舍五入
BigDecimal.ROUND_UP 最后一位小数不管满不满5都进1
BigDecimal.ROUND_FLOOR 最后一位小数不管慢不满5都舍弃
注意：需要运算的两个数，必须先封装尾BigDecimal对象，然后通过上面的方法进行运算。基本数据类型包装类
每一个基本数据类型都有一个对应的包装类，并且提供了一些方法给开发人员使用。
基本数据类型 包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
boolean Boolean
char Character获取Integer对象
Integer num1 = Integer.valueOf(100);
Integer num2 = Integer.valueOf("100");
//如果数据在-128~127范围内，得到的对象是同一个； 否则就是重新创建的对象.自动装箱和自动拆箱
为了方便基本数据类型和包装类能够直接运算，所有Java提供了自动装箱和自动拆箱的机制。
//自动装箱： 基本类型(int) 自动转换为 包装类(Integer)
Integer num=100; //等价于 Integer num = Integer.valueOf(100);
//自动拆箱： 包装类(Integer) 自动转换为 基本类型(int)
int num2=num; //等价于 int num2 = num.intValue();
包装类的数据转换
如果一个字符串是纯数字的字符串(如: "12345")，不能做数值的数学运算，必须把字符串转换为数值，才能做数学运算。 这样的转换方法在包装类中已经提供了.
-
字符串转其他的基本数据类型
【口诀】：想要转为什么类型就找什么类型的包装类，调用parseXxx方法
//需求1："12345"转换为12345
int num1=Integer.parseInt("12345");
//需求2: “3.14”转换为3.14
double num2=Double.parseDouble("3.14");
//需求3： "6.88"转换为6.88
float num3=Float.parseFloat("6.88");
...
-
其他类型转换为字符串
1.直接和""做拼接，因为任何一个数据和字符串做拼接结果都是字符串
String s=100+"";
2.可以使用String类的valueOf方法
String s1=String.valueOf(100);
String s2=String.valueOf(3.14);
数组的高级操作
二分查找
二分查找对于数组中的元素必须要有从小到大的顺序，否则不能做二分查找。
二分查找的思路：
1.获取数组的开始和结束的索引
int start=0;
int end=array.length-1;
2.循环的获取start和end中间的元素
int mid=(start+end)/2;
3.让array[mid]和目标数据进行比较
大了：end=mid-1;
小了：start=mid+1;
中了: 直接返回mid
//对一个数组进行二分查找，查找元素对应的索引
public static int binarySerach(int[] array,int key){
//获取数组的开始和结束的索引
int start=0;
int end=array.length-1;
//循环的获取start和end中间的元素
while(start<end){
//获取中间的元素索引
int mid=(start+end)/2;
if(array[mid]>key){
end=mid-1;
}else if(array[mid]<key){
start=mid+1;
}else{
return mid;
}
}
return -1; //没有找到元素
}
冒泡排序
把相邻的两个元素进行比较，把大的往后放。
1.如果数组的长度为length，一共要比较length-1轮
2.每一轮比较的次数比上一轮少1次
//对数组进行排序
public static void sort(int[] array){
//1.数组的长度为array.length,比较的轮数是 array.length-1
for(int i=0;i<array.length-1;i++){
//2.每一轮比较的次数比上一轮少一次
for(int j=0;j<array.length-1-i;j++){
//相邻的元素进行比较，大的往后放
if(array[j]>array[j+1]){
int temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}
}
Arrays类
Arrays是一个工具类。Arrays类中提供了一些对数组进行操作的方法（比如：查找和排序）
public static int binarySearch(int[] array,int key)
对数组的元素进行二分查找。前提：元素必须是由顺序的
public static void sort(int[] array)
对数组进行排序。
public static String toString(int[] array)
把数组转换为字符串 格式："[元素1,元素2,元素3]"
递归
方法自己调用自己，这种方式叫做递归。
public static void main(String[] args) {
int sum = getSum(5);
System.out.println(sum);
}
//方法：求1~n的和
public static int getSum(int n){
if(n==1){
return 1;
}else {
return getSum(n-1)+n; //n-1以内的和加上n，如：(1+2+3+4)+5
}
}
JDK7的日期时间类。
Date类
Date类表示时间，时间可以精确到毫秒。创建一个Date对象，其实就表示时间的对象。
Date date1=new Date(); //当前系统时间
Date date2=new Date(0L); //1970年1月1日8点0时0分 (中国)
Date date3=new Date(1000L*60*60*24); //1970年1月2日8点0时0分 (中国)获取和设置时间
Date date=new Date(); //当前系统时间
//设置时间为
date.setTime(1000L*60*60*24); //1970年1月2日8点0时0分 (中国)
//获取时间
long time=date.getTime(); //1000L*60*60*24
System.out.println(time); //毫秒值 SimpleDateFormat类
SimpleDateFormat类可以对日期进行格式化和解析的操作。
SimpleDateFormat在进行日期格式化或者解释时，需要识别一些特定符号
yyyy: 年 1999年
MM: 年中的月 8月
dd: 月中的天 28日
HH: 天中的小时 16时
mm: 时中的分 20分
ss: 分中的秒 18秒
SS: 毫秒
格式化：Date对象转换为字符串
解析： 字符串转换为Date对象
//在进行日期格式化和解析之前，必须使用以上的符号创建SimpleDateFormat对象，来指定日期或者时间的格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");-
下面是格式化和解析的代码
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
//1.日期格式化：Date对象-->String
String str=sdf.format(new Date()); //把当前时间格式化为字符串
//2.日期解析：String --> Date对象
Date date=sdf.prase("1992年08月09日 16时24分18秒"); -
练习：键盘录入一个生日（格式：yyyy-MM-dd），计算当前的年龄是多少？
//键盘录入字符串生日
Scanner sc=new Scanner(System.in);
System.out.println("请输入你的生日(格式：yyyy-MM-dd)：");
String birthday=sc.next();
//把生日的字符串，转换为Date
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
Date date1=sdf.prase(birthday); //生日那天的Date对象
long time1=date1.getTime(); //生日那天的毫秒值
//获取当前时间的毫秒值
long time2=System.currentTimeMills(); //当前时间的毫秒值
//计算时间差
long age=(time2-time1)/1000/60/60/24/365;
System.out.println("年龄为："+age);JDK8新增的日期类
LocalDateTime获取对象
LocalDateTime类 可以表示时间的(年、月、日、时、分、秒)
public static LocalDateTime now()
获取当前的系统时间LocalDateTime对象
public static LocalDateTime of(int y,int m,int d,int h,int m,int s)
获取指定时间的LocalDateTime对象代码演示
//获取当前时间对象
LocalDateTime ldt1 = LocalDateTime.now();
//获取指定时间对象，2011年11月11日10点10分10秒
LocalDateTime ldt2 = LocalDateTime.of(2011,11,11,10,10,10);LocalDateTime的获取方法
public int getYear()
获取年
public int getMonthValue()
获取月
public int getDayOfMonth()
获取月中的天
public int getDayOfYear()
获取年中的天
public DayOfWeek getDayOfWeek()
获取星期中的第几天
public int getHour()
获取小时
public int getMinute()
获取分钟
public int getSecond()
获取秒LocalDateTime的转换方法
三者的区别
LocalDateTime： 包含年、月、日、时、分、秒
LocalDate： 包含年、月、日
LocalTime: 包含时、分、秒
可以通过LocalDateTime转换为LocalDate和LocalTime
public LocalDate toLocalDate()
把LocalDateTime转换为LocalDate
public LocalTime toLocalTime()
把LocalDateTime转换为LocalTimeLocalDateTime的格式化和解析
public String format(DateTimeFormatter formatter)
格式化：把LocalDateTime转换为String
static LocalDateTime parse(CharSequence text, DateTimeFormatter formatter)
解析：把字符串转换为LocalDateTime对象-
日期格式化代码演示
//获取当前时间的LocalDateTime对象
LocalDateTime localDateTime = LocalDateTime.now();
//创建日期格式化器
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
//格式化
String str=localDateTime.format(formatter);
System.out.println(str); -
日期解析的代码演示
//创建日期格式化器
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
//日期解析
LocalDateTime localDateTime= LocalDateTime.parse("2020-08-23 15:19:39",formatter);
//...后面就可以使用LocalDateTime的方法，对时间进行操作LocalDateTime加减运算方法
public LocalDateTime plusYears(int n)
加、减年 (正数表示增加、负数表示减少)
public LocalDateTime plusMonths(int n)
加、减月
public LocalDateTime plusDays(int n)
加、减日
public LocalDateTime plusHours(int n)
加、减时
public LocalDateTime plusMinutes(int n)
加、减分
public LocalDateTime plusSeconds(int n)
加、减秒LocalDateTime设置时间的方法
public LocalDateTime withYear(int n)
设置年
public LocalDateTime withMonth(int n)
设置月
public LocalDateTime withDay(int n)
设置日
public LocalDateTime withHour(int n)
设置时
public LocalDateTime withMinute(int n)
设置分
public LocalDateTime withSecond(int n)
设置秒时间间隔类
Period类
计算两个时间间隔的年、月、日。
//生日的时间
LocalDate localDate1 = LocalDate.of(1996, 6, 23);
//今天的时间
LocalDate localDate2 = LocalDate.now();
//获取时间间隔对象
Period period = Period.between(localDate1,localDate2);
//获取相隔的年
int years = period.getYears();
System.out.println(years);
//获取相隔月
long totalMonths = period.getMonths();
System.out.println(totalMonths);
//获取相隔的日
int days = period.getDays();
System.out.println(days);
Duration类
计算两个时间间隔的时、分、秒
//当时间
LocalDateTime localDate1 = LocalDateTime.now();
//国庆时间
LocalDateTime localDate2 = LocalDateTime.of(2021, 10, 1,0,0,0);
//获取时间间隔对象
Duration duration = Duration.between(localDate1,localDate2);
//获取相隔总共小时数
long hour = duration.toHours();
//获取相隔的总共分钟数
long minutes = duration.toMinutes();
//获取相隔的总共秒数
long seconds = duration.toSeconds();
//相隔的总共毫秒秒数
long millis = duration.toMillis();
System.out.println("-------------------");
//获取相隔天的部分
long day = duration.toDaysPart();
//获取相隔小时的部分
int hoursPart = duration.toHoursPart();
//获取相隔分钟的部分
int minutesPart = duration.toMinutesPart();
//获取相隔秒的部分
int secondsPart = duration.toSecondsPart();
System.out.println("距离今年国庆放假还有："+day+"天"+hoursPart+"小时"+minutesPart+"分钟"+secondsPart+"秒");
异常
异常其实就是程序在编译和运行时期的一些不正常的异常。 Java的工程师们，把一些常见的问题都封装了异常类 ，在API中给你列举出来了。当我们使用Java语言写代码的时候，可能会出现这些问题，当出现这些问题的时候，就可以去API中找，哪里出现了问题。
异常类的继承体系
Throwable 是所有异常和错误的根类
Error: 错误，不能解决的问题。
Exception: 异常，可以解决的问题。
RuntimeException: 运行时异常，在运行时才出现问题
非RuntimeException：编译时异常，编译时有问题。
异常的处理
-
虚拟机默认处理
直接停止程序运行，然后把异常信息打印在控制台
-
try...catch手动处理
try{
//检查代码中是否有异常
}catch(异常类1 e){
//如果try中有异常，就会被catch捕获到
}catch(异常类2 e){
//如果try中有异常，就会被catch捕获到
}
【注意：如果有多个catch语句，异常类有继承关系，较大的类要写后面】
好处：处理之后的代码还可以继续执行
-
throws 声明异常
throws用在方法上，用来声明一个方法它可能会有异常
//如果一个方法后面有throws声明异常，那么调用方法的时候就需要处理异常。
public static void method(String str) throws ParseException {
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
Date date = sdf.parse(str);
System.out.println(date);
}
Throwable的方法
public String getMessage()
获取异常信息
public String toString()
返回异常类名+异常信息
public void printStackTrace()
打印详细的异常信息
throw 产生一个异常
如果你是写API的人，在写方法的时候，会考虑到方法的调用者传递非法的参数。你必须先对这些参数左一些合法性的校验，如果不通过，告诉调用者一个异常。
public static void main(String[] args) {
sale(7);
}
//卖东西
public static void sale(int money){
if(money==5||money==10){
System.out.println("钱是真的，可以正常买东西");
}else{
throw new RuntimeException("钱是假的，我报警了，等着！！！");
}
}
自定义异常
如果在写一个方法的时候，API中提供的异常类，还不足以说明程序的问题。你就可以自己定义一个异常类
自定义异常类的步骤：
1.写一个类继承Exception或者RuntimeException
2.自动生成两个构造方法
注意：自定义异常，名称一定要见名知意(最好是能够使用异常类的名称，来说明问题)
异常的小结
1. 什么是异常？
答：在程序编译和运行过程中，产生一些不正常的状况。这些不正常的状况叫做异常。
异常本质上是一个类，设计Java语言的这帮工程师们，早就想到可能会出现这些问题，他们把这些异常类以及产生异常的原因都整理放在了API中
(异常的API： 代码的故障说明书 )
2. 异常的继承体系，以及分类？
异常类有很多很多，有些异常是存在共性的，所以就形成了异常的继承体系.
Throwable类
-- Error以及其子类: 比较严重的错误(不深究)
-- Exception以及其子类： 异常可以解决
-- RuntimeException: 运行时异常
-- 非RuntimeException: 编译时异常(检查时异常、受检异常)
3. 什么情况下产生异常？
答：异常的产生一定伴随触发条件
比如数组索引越界时，触发ArrayIndexOutOfBoundsException异常
当一个对象为null时调用方法触NullPointerException.....
//在写一个方法时，如果这个方法中有一些数据无法保证是正确的
//方法的编写者就需要对数据进行安全性的校验.
public static void method(String str) throws 异常类{
//在方法内部，无法保证参数是正确的
if(如果校验不通过){
throw new 异常对象();
}
//如果前面没有异常，就继续执行后面的代码
//....
}
4. 发现异常如何处理？
答：别人写好的方法如果有异常的声明，作为调用者我们需要对异常进行处理. 调用者的处理方案有两种
1) 继续throws声明 (甩锅)
2) 使用try...catcch处理异常，即是有异常产生代码还会继续执行.
5. 如何自定异常？
答：异常类最重要的就是名字，如果API中给你提供的异常类不足以说明你的问题，那么可以自定义异常(见名知意)
1) 自定义一个类 继承 Exception或者RuntimeException
2) 写两个构造方法
一、异常总结：
1.如何理解异常
异常其实就是程序编译或者运行时的一些不正常的状况。 而且这些异常都是程序员在写代码时不合法的操作导致的，Java语言的设计者早就意料到可能会出现这些问题。
他们就把可能出现的异常状况，编写到API文档中；当程序员出现异常时，可以结合API文档去找异常的原因。
举例：
ArrayIndexOutOfBoundsException: API告诉我们，使用不合法的索引时，产生此异常
NullPoniterException: API告诉我们，使用null对象去调用方法/属性；使用null数组去访问元素时，会出现此异常.
...
2.异常的分类：
编译时异常： 继承自Exception的子类(非RuntimeException类)
运行时异常： 继承子RuntimeException的子类
3.异常的体系结构
由于异常很多很多，有些问题是有共性，所有就形成继承体系
Throwable -- 异常的根类
Error: 错误
Exception: 异常
Exception的子类： 编译时异常，IDEA编译时会有红色波浪线提示
RuntimeException的子类：运行时异常，运行报错(打印异常信息)
4. 异常是如何产生的？
实际上写方法和调用方法可能并不是同一个人，特别是做一些SDK开发(特定功能的组件)，你开发的组件是给其他程序员的，那么你需要给比人提供API文档。
//这个时候你是作为开发API方法的人，你写好的方法是给别人用的。
//你无法确定别人调用你这个方法是否正确调用，那么你就需要在方法内部做一些检验。
public static void method(String 参数) throws 异常类{
if(对参数进行校验，如果校验不合法){
throw new 异常对象();
}
//后面才是正常的代码执行
....
}
5. 调用一个有异常的方法如何处理？
调用一个有异常的方法，IDEA会给出红色波浪线的提示，告诉我们需要对异常进行处理。调用者有两种处理方式
第一种：不处理，继续使用throws声明，出现异常代码终止执行了。
第二种：使用try...catch进行处理，即是出现异常代码还能继续执行。
6. 自定义异常：
什么时候使用自定义异常?
异常就是为了描述问题而存在，如果API中提供的异常类不足以描述你的问题，他们你可以自定义异常类描述自己的问题。
如何自定义异常：
1)只需要自定义一个类，继承Exception或者RuntimeException就可以。
2)写两个构造方法就可以了
二、集合
1.集合和数组的区别
数组：长度固定，元素类型既可以是基本类型，也可以是引用类型
集合：长度可变，元素类型只能是引用类型
2.集合体系结构
Collection(接口)
-- List(接口)
-- ArrayList(实现类)
-- LinkedList(实现类)
-- Set(接口)
-- HashSet(实现类)
-- TreeSet(实现类)
3.Collection的方法
public boolean add(E e)
添加元素到集合的末尾
public boolean addAll(Collection<? extends E> c)
添加一个集合中所有的元素
public void clear()
清空集合
public boolean contains(Object o)
判断集合中是否包含某一个元素
public boolean isEmpty()
判断集合是否为空
public boolean remove(Object o)
移除集合中的元素
public int size()
获取集合的长度(元素的个数)
public boolean removeIf(Predicate<? super E> filter)
删除集合中满足条件的元素
扩展知识：
removeIf方法底层会自动遍历集合，得到每一个元素，然后在把元素传递给Predicted接口的test方法，然后由test方法对元素进行校验，校验通过就删除；否则就不删。
调用者提供test方法校验的实现过程，也就是Lamdba表达式
4.集合的遍历方式
1)普通for循环：有索引才可以使用
for(int i =0; i<= 集合.size(); i++){
元素类型 变量名 = 集合.get(i);
}
2)迭代器遍历：任何集合都可以遍历
//获取迭代器对象
Iterator<String> it = 集合.iterator();
//判断是否有下一个元素
while (it.hasNext()){
//获取元素
String e = it.next();
System.out.println(e);
}
3)增强for遍历：任何集合都可以遍历，它是迭代器的简化写法
for(元素类型 变量 : 集合/数组){
Sytem.out.println(变量);
}
823
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
