java API概述：就是java替我们写好的一些类，封装了一些功能，我们仅仅只需知道如何使用即可；
Object
Object类概述
Object类是Java语言中的根类，即所有类的父类。它里面描述的所有方法子类都可以使用，所有类在创建对象的时候，最终找的父类就是Object；
equals方法
equals方法（Object类的equals方法，有很多类都会重写该方法），用于比较两个对象是否相同，它其实就是使用两个对象的内存地址比较；
//源码
public boolean equals(Object obj) {
return (this == obj);
}
toString方法
toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值(在开发中也会经常重写它);
return getClass().getName() + "@" + Integer.toHexString(hashCode());
String
字符串是常量，它们的值在创建之后不能更改；即一旦这个字符串确定了，那么就会在内存区域中生成这个字符串，字符串本身不能改变，但str变量中记录的地址值是可以改变的；
String常见构造方法
public String();//空构造
public String(byte[] bytes);//把字节数组转成字符串（机器操作系统的默认字符集）
public String(byte[] bytes, int index, int length);//把字节数组的一部分转成字符串（机器操作系统默认的字符集）
public String(String original);//把字符串常量转成字符串
public String(char[] value);//把字符数组转成字符串
public String(char[] value, int index, int length);//把字符数组的一部分转成字符串
String常用方法
int length();//返回字符串的长度
String substring(int beginIndex, int endIndex);//获取字符串的一部分
String substring(int beginInde);//获取字符串的一部分
boolean startsWith(String prefix);//判断一个字符串是不是以指定的前缀开始
boolean endswith(String suffix);//判断一个字符串是不是以指定的后缀结尾
boolean contains(String s);//判断一个字符串中是否包含另一个字符串
int indexOf(String str);//返回指定字符串在此字符串中第一次出现的索引
byte[] getBytes();//将字符串转成字节数组
char[] toCharArray();//将字符串转成字符数组
boolean equals(Object anObject);// 方法传递字符串，判断字符串中的字符是否完全相同，如果完全相同返回true，否则false
boolean equalsIgnoreCase(String anotherString);//传递字符串，判断字符串中的字符是否相同，忽略大小写
boolean isEmpty();//判断该字符串的内容是否为空的字符串""
char charAt(int index);//判断该字符串中指定位置上的字符
String subString(int start);//从指定位置开始到末尾结束，截取该字符串，返回新字符串
String subString(int start, int end);//从指定位置开始，到指定位置结束，截取该字符串，返回新字符串
int indexOf(int ch);//获取给定的字符，在该字符串中第一次出现的位置
int indexOf(int ch, int fromIndex);//从指定位置开始，获取给定的字符在该字符串中第一次出现的位置
int indexOf(String str);//获取给定的字符串，在该字符串中第一次出现的位置
int indexOf(String str, int fromIndex);//从指定位置开始，获取给定的字符串，在该字符串中第一次出现的位置
String replace(char old, char new);//在该字符串中，将给定的旧字符，用新字符替换
String replace(String old, String new);//在该字符串中，将给定的旧字符串，用新字符串替换
String trim();//去除字符串两端空格，中间的不会去除，返回一个新字符串
String toLowerCase();//把该字符串转换成小写字符串
String toUpperCase();//把该字符串转换成大写字符串
StringBuffer类
A thread-safe, mutable sequence of characters. A string buffer is like a String, but can be modified.
StringBuffer和String的区别：String是一个不可变的字符序列，StringBuffer是一个可变的字符序列；
StringBuffer的方法使用
StringBuffer sb = new StringBuffer();
sb.append("haha");//在原有字符串缓冲区内容基础上,添加新数据
sb.insert("2, "it");//在原有字符串缓冲区内容基础上，在指定位置插入新数据
sb.deleteCharAt(2);////在原有字符串缓冲区内容基础上，删除指定位置上的字符
sb.delete("1, 4");//在原有字符串缓冲区内容基础上，删除指定范围内的多个字符
sb.replace(1, 4, "cast");//在原有字符串缓冲区内容基础上，将指定范围内的多个字符 用给定的字符串替换
sb.reverse();//将字符串缓冲区的内容 反转 "abc"----"cba"
//以上返回值都是当前对象自己，所以说StringBuffer它可以改变字符序列的长度和内容
subString(1);//从指定位置开始到末尾结束，截取该字符串缓冲区，返回新字符串（String）
subString(1, 4);//从指定位置开始，到指定位置结束，截取该字符串缓冲区，返回新字符串（String）
sb.toString();//返回此序列中数据的字符串表示形式
对象的方法链式调用
开发中就遇到调用一个方法后，返回一个对象的情况，然后使用返回的对象继续吊用方法，这种时候，我们就可以把代码写在一起，如：
StringBuffer sb = new StringBuffer();
String str = sb.append(true).append("hehe").toString();
StringBuilder
A mutable sequence of characters. This class provides an API compatible with StringBuffer, but with no guarantee of synchronization.
StringBuilder也是一个可变字符串，此类提供一个与StringBuffer兼容的API，但不保证同步；它被设计为StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）；如果可能优先使用该类，因为在大多数实现中，它比StringBuffer快；
正则表达式
正则表达式概念
正则表达式（Regular Expression，regex），是一个字符串，使用单个字符串来描述，用来定义匹配规则，匹配一系列符合某个句法规则的字符串；开发中正则表达式通常被用来检索、替换那些符合某个规则的文本。
正则表达式的匹配规则
正则表达式明确区分大小写；
| 字符 | 含义 | 例如 |
|---|---|---|
| x | 代表的是字符x | 匹配规则为"a"，需要匹配的字符串内容就是"a" |
| \\ | 代表的是反斜线 | 匹配规则为"\\"，需要匹配的字符串就是"\"; |
| \t | 制表符 | 匹配规则为"\t"，对应的效果就是产生一个制表符的空间 |
| \n | 换行符 | 匹配规则为"\n"，对应的效果就是换行，光标在原有位置的下一行 |
| \r | 回车符 | 匹配规则为"\r"，对应的效果就是回车后的效果，光标到下一行行首 |
| 字符类 | 含义 | 例如 |
|---|---|---|
| [abc] | 代表的是字符a、b或c | 匹配规则为"[abc]"，需要匹配的内容就是字符a、或者b、或者c中的一个 |
| [^abc] | 代表的是除了a、b或c以外的任何字符 | 匹配规则为"[^abc]"，需要匹配的内容为不是字符a、b、c中的任何一个字符 |
| [a-zA-Z] | 代表的是a到z或A到Z（含） | 匹配规则为"[a-zA-Z]"，需要匹配是一个大写或小写字母 |
| [0-9] | 代表的是数字0到9（含） | 匹配规则为"[0-9]"，需要匹配的是一个数字 |
| [a-zA-Z_0-9] | 代表字母或数字或下划线 | 匹配的是一个字母或数字或下划线 |
| 预定义字符类 | 含义 | 例如 |
|---|---|---|
| . | 代表的是任何字符 | 匹配规则为"."，匹配的是一个任意字符 |
| \d | 代表的是数字0到9（含） | 匹配规则为"\d"，需要匹配的是一个数字 |
| \w | 代表字母或下划线或数字 | 匹配规则为"\w"，需要匹配的是一个字母或下划线或数字 |
| 边界匹配器 | 含义 | 例如 |
|---|---|---|
| ^ | 代表的是行的开头 | 匹配规则为"^[abc][0-9]$"，匹配的内容从[abc]这个位置开始，相当于左双引号 |
| $ | 代表的是行尾 | 匹配规则为"^[abc][0-9]$"，匹配的内容以[0-9]这个结束，相当于右双引号 |
| \b | 代表的是单词边界 | 匹配规则为"\b[abc]\b"，代表字母a或b或c两边需要的是非单词字符 |
| 数量词 | 含义 | 例如 |
|---|---|---|
| x? | 代表的是x出现0次或1次 | 匹配规则为"a?"，匹配的内容是一个字符a，或者一个a都没有 |
| x* | 代表的是x出现0次或多次 | 匹配规则为"a*"，匹配的内容是多个a，或者一个a也没有 |
| x+ | 代表的是x出现一次或多次 | 匹配规则为"a+"，匹配的内容是多个a，或者一个a |
| x{n} | 代表的是x恰好出现n次 | 匹配规则为"a{5}"，匹配的内容是5个字符a |
| x{n,} | 代表的是x出现至少n次 | 匹配规则为"a{5,}"，匹配的内容是最少有5个字符a |
| x{n,m} | 代表的是x出现至少n次，但是不超过m次 | 匹配规则为"x{5, 8}"，匹配的内容是有5个a到8个a之间 |
字符串中涉及正则表达式的常用方法
-
public boolean **matches**(String regex)Tells Whether or not this string matches the given regular expression;
/** *校验qq号，1.必须是5-15位；2.0不能开头 */ String qq = "496930052"; String regex = "[1-9][0-9]{4,14}"; boolean flag = qq.matches(regex); /** *校验手机号 *1.要求位11位；2.第1位为1，第2位位3、4、5、7、8中的一个，后面9位为0到9之间的任意数 */ String phoneNum = "18815286559"; String regex = "1[34578][0-9]{9}"; boolean flag = phoneNum.matches(regex); -
public String[] split(String regex)Splits this string around matches of the given regular expression;
String s = "18-22-40-65"; String regex = "-"; String[] arr = s.split("-"); -
public String replaceAll(String regex, String replacement)Replace each substring of this string that matches the given regular expression with the given replacement;
String str = "Hello12345World6789012"; String regex = "[]0-9]"; String result = str.replaceAll(regex, "*");
正则表达式易错练习
-
在其他语言中"\\"表示：在正则表达式中插入一个普通的（字面上的）反斜杠，不要给它任何特殊的意义；
-
在java中，"\\"表示：插入一个正则表达式的反斜杠，所以其后的字符具有特殊意义；
-
所以在其他语言中，一个反斜杠\就足以具有转义的作用，而在java正则表达式中需要有两个反斜杠才能被解析为其他语言中的转义作用；
-
可以简单的理解，在java正则表达式中，两个\\代表其他语言中的一个\，也就是表示一个数字用\\d，表示一个普通的反斜杠用\\\\；
//匹配正整数
\\d+
//匹配正小数
\\d+\\.\\d+
//匹配负整数
-\\d+
//匹配负小数
\\-d+\\.\\d+
//匹配保留两位小数的正数
\\d+\\.\\d{2}
//匹配保留1-3位小数的正数
\\d+\\.\\d{1,3}
/**
*检查邮箱地址是否合法
*@前 数字字母_个数不少于1个
*@后 数字字母 个数不少于1个
*.后 字母
*/
String email = "abc123@sina.com";
String regex = "[a-zA-Z_0-9]+@[a-zA-Z0-9]+(\\.[a-z]+)+";
boolean flag = email.matches(regex);
//获取ip地址192.168.0.0中的每段数字
\\.
Date
Date类概述
Date类表示特定的瞬间，精确到毫秒；
//1000毫秒=1秒
//时间远点 1970年1月1日，0:00:00 英国格林威治
//获取当前日期的毫秒值，返回值long类型
System.currentTimeMillis();//1588866116649(当前)
Date类的构造方法
-
public Date()Allocates a Date object and initializes it so that it represents the time at which it was allocated, measured to the nearest millisecond;Date date1 = new Date(); System.out.println(date1);//Thu May 07 20:22:45 CST 2020 -
public Date(long date)Allocates a Date object and initializes it to represent the specified number of millisecondes since the standard base time known as "the epoch", namely January 1, 1970, 00:00:00 GMT;Date date2 = new Date(1323245425222L); System.out.println(date2);//Wed Dec 07 16:10:25 CST 2011
Date的get和set方法
-
public long getTime()Returns the number of milliseconds since January 1, 1970, 00:00:00 GMT;Date date3 = new Date(); long milliSec = date3.getTime(); System.out.println(milliSec);//1588866116681（当前） -
public void setTime(long time)Set this Date object to represent a point in time that is time milliseconds after January 1, 1970 00:00:Date date4 = new Date(); date4.setTime(5588866608132L); System.out.println(date4);//Wed Feb 08 06:56:48 CST 2147
DateFormat
DateFormat类概述
DateFormat是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间，日期/时间格式化子类（如SimpleDateFormat类）允许进行格式化（即日期-->文本）、解析（文本-->日期）和标准化；
通过这个类可以完成日期和文本之间的转换；
DateFormat类的作用
可以将一个Date对象转换为一个符合指定格式的字符串，也可以将一个符合指定格式的字符串转换为一个Date对象；
指定格式的具体规则参照SimpleDateFormat类的说明，规则是在一个字符串中，会将以下字母替换成对应的时间组成部分，剩余内容原样输出：
| 字母（以常用的为例） | 替换（将字母替换，其余原样输出） | 模式 |
|---|---|---|
| y | 替换为年 | 年份：yyyy |
| M | 替换为月 | 月份：MM |
| d | 替换为日 | 月中的天数：dd |
| H | 替换为时 | 0-23小时：HH |
| m | 替换为分 | 小时中的分钟：mm |
| s | 替换为妙 | 秒：ss |
SimpleDateFormat构造方法
DateFormat是抽象类，实际使用通过其子类SimpleDateFormat来创建对象；
-
public SimpleDateFormat(String pattern)Constructs a SimpleDateFormat using the given pattern and the default date format symbols for the default;
DateFormat类常用方法
-
format方法，将Date对象转成String；
-
日期对象转字符串，使用步骤：
- 创建SimpleDateFormat对象(构造方法中，指定日期模式)；
- SimpleDateFormat调用format方法对日期进行格式化
DateFormat df1 = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss"); Date date5 = new Date(); String strTime = df1.format(date5); System.out.println(strTime);//2020年05月08日 11:20:37
-
-
parse方法，用来将String转换成Date对象，转换时该String要符合指定格式；
-
字符串转成日期对象，使用步骤：
- 创建SimpleDateFormat的对象(构造方法中，指定日期模式)；
- 子类对象调用parse方法，传
String str = "2020年5月8日 18时27分00秒"; DateFormat df2 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒"); Date date6 = df2.parse(str); System.out.println(date6);//Fri May 08 18:27:00 CST 2020
-
Calendar
Calendar类概念
Calendar是日历类，在Date后出现，替换掉了许多Date的方法，该类将所有可能用到的时间信息封装为静态成员变量，方便获取；
Calendar为抽象类，由于语言敏感性，Calendar类在创建对象时并非直接创建，而是通过静态方法创建，将语言敏感内容处理好，再返回子类对象；如下：
Calendar calendar = Calendar.getInstance();（使用默认时区和语言环境获得一个日历对象）
Calendar类常用方法
-
int get(int field)返回给定日历字段的值；field 日历 YEAR 年 MONTH 月（从0开始算起） DATE 天 HOUR 时 MINUTE 分 SECOND 秒 Calendar calendar1 = Calendar.getInstance();//获取日历对象 int year = calendar1.get(Calendar.YEAR); System.out.println(year);//2020 -
abstract void add(int field, int amount)根据日历的规则，为给定的日历字段添加或减去指定的时间量；Calendar calendar2 = Calendar.getInstance(); calendar2.add(Calendar.YEAR, 3); System.out.println(calendar2.get(Calendar.YEAR));//2023 -
void set(int field, int value)将给定的日历字段设置为给定值；Calendar calendar3 = Calendar.getInstance(); calendar3.set(Calendar.YEAR, 2080); calendar3.set(Calendar.MONTH, 2); calendar3.set(Calendar.DATE, 28); System.out.println(calendar3.get(Calendar.YEAR) + "年" + calendar3.get(Calendar.MONTH) + "月" + calendar3.get(Calendar.DATE) + "日");//2080年2月28日 -
Date getTime()返回一个此日历对象的时间值转成的日期对象；Calendar calendar4 = Calendar.getInstance(); Date date7 = calendar4.getTime(); System.out.println(date7);//Fri May 08 20:37:41 CST 2020
日期相关类练习
/**
* 求出自己已经出生多少天
* 1. 获取当前时间对应的天数
* 2. 获取自己出生日期对应的天数
* 3. 两个时间相减
*/
System.out.println("请输入出生日期，格式要求：yyyy-MM-dd");
//获取出生日期，键盘输入
String birthDayString = new Scanner(System.in).next();
//创建SimpleDateFormat对象，写日期模式
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
//调用parse方法，字符串转成日期对象
Date birthDayDate = simpleDateFormat.parse(birthDayString);
//获取今天的日期对象
Date todayDate = new Date();
//将两个日期转成毫秒值，Date类的getTime()
long birthDayMilliSecond = birthDayDate.getTime();
long todayDateMilliSecond = todayDate.getTime();
long milliSecond = todayDateMilliSecond - birthDayMilliSecond;
System.out.println(milliSecond/1000/3600/24);
/**
* 判断是否闰年
* 日历设置到指定年份的3月1日，add向前偏移1天，获取天数，29为闰年
*/
System.out.println("请输入年份");
int year = new Scanner(System.in).nextInt();
Calendar calendar = Calendar.getInstance();
//将日历设到指定年的3月1日
calendar.set(year, Calendar.MARCH, 1);
//日历add方法，向前偏移1天
calendar.add(Calendar.DAY_OF_MONTH, -1);
//get方法获取day of month
int day = calendar.get(Calendar.DAY_OF_MONTH);
if (day == 29) {
System.out.println("该年是闰年");
} else {
System.out.println("该年不是闰年");
}
基本数据类型包装类
基本数据类型对象包装类概述
实际程序开发中，用户在界面输入的数据往往都是字符串类型的，我们需要把字符串数据根据需求转换成指定的基本数据类型；Java中提供了相应的对象来解决该问题，基本数据类型对象包装类。
java将基本数据类型值封装成了对象，以提供更多的操作基本数值的功能；
8种基本数据类型对应的包装类
| 字节型 | 短整型 | 整型 | 长整型 | 字符型 | 布尔型 | 浮点型 | 浮点型 |
|---|---|---|---|---|---|---|---|
| byte | short | int | long | char | boolean | float | double |
| Byte | Shotr | Integer | Long | Character | Boolean | Float | Double |
基本数据类型对象包装类特点：用于在基本数据和字符串之间进行转换；
-
将字符串转成基本类型：
方法 解释 public static byte parseByte(String s)将字符串参数解析为有符号的十进制byte public static short parseShort(String s)将字符串参数解析为有符号的十进制short public static int parseInt(String s)将字符串参数解析为有符号十进制int public static long parseLong(String s)将字符串参数解析为有符号十进制long public static float parseFloat(String s)返回一个新的float值，该值被初始化为用指定字符串表示的值 public static double parseDouble(String s)返回一个新的double值，该值被初始化为用指定字符串表示的值 public static boolean parseBoolean(String s)将字符串参数解析为boolean值 parseXXX(String s);其中XXX表示基本类型，参数为可以转成基本类型的字符串，如果字符串无法转成基本类型，将会发生数字转换的问题NumberFormatException；
-
将基本数值类型转成字符串，有3种方式：
- 基本类型直接与""相加，例如：
34 + "";; - 调用String的valueOf方法，例如：
String.valueOf(34);； - 调用包装类中的XXX.toString()方法，例如：
Integer.toStrng(34);；
- 基本类型直接与""相加，例如：
基本类型和对象转换
以int类型与Integer对象转换为例子，其他基本类型转换方式相同；
-
基本数值转包装对象：
基本数值转包装对象（以Integer()为例，其他一样） Integer(int value)构造一个新分配的Integer对象，它表示指定的int值；Integer(String s)构造一个新分配的Integer对象，它表示String参数所指示的值；Integer i = new Integer(4); Integer ii = new Integer("4");基本数值转包装对象（以Integer.valueOf()为例，其他一样） public static Integer valueOf(int i)返回一个表示指定int值的Integer对象public staitc Integer valueOf(String s)返回一个指定String值的Integer对象Integer iii = Integer.valueOf(4); Integer iiii = Integer.valueOf("4"); -
包装对象转基本数值：
包装对象转基本数值（以Integer转int为例，其他一样） public static int intValue()以int类型返回该Integer的值Integer i = 5; int iNum = i.intValue();
Integer类其他方法
/**
*十进制转二进制
*十进制转八进制
*十进制转十六进制
*/
System.out.println(Integer.toBinaryString(5));//101
System.out.println(Integer.toOctalString(9));//11
System.out.println(Integer.toHexString(17));//11
/**
* 获取int的最大值和最小值
*/
System.out.println(Integer.MAX_VALUE);//2147483647
System.out.println(Integer.MIN_VALUE);//-2147483648
自动装箱拆箱
在需要的情况下，基本类型与包装类型可以通用；有些时候必须使用引用数据类型时，可以传入基本数据类型。比如：基本类型可以使用运算符直接进行计算，但是引用类型不可以，而基本类型包装类作为引用类型的一种却可以计算，原因在于，Java“偷偷地”自动进行了对象向基本数据类型的转换。
相应的，引用数据类型变量的值必须是new出来的内存空间地址值，而我们可以将一个基本类型的值赋值给一个基本类型包装类的引用。原因同样在于java又“偷偷地”自动进行了基本数据类型向对象的转换。
-
自动拆箱：对象转成基本数值；
-
自动装箱：基本数值转成对象；
Integer i = 4;//自动装箱，相当于Integer i = Integer.valueOf(4); i = i + 5;//等号右边，将i对象转成数值（自动拆箱），相当于i.intValue() + 5;加法运算完成后再拆箱，把基本数值转成对象；
自动装箱和自动拆箱练习
Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i == j);//false
System.out.println(i.equals(j));//true
//数据在byte(-128~127)范围内，jvm不会重新new对象
Integer ii = 127;
Integer jj = 127;
System.out.println(ii == jj);//true
System.out.println(jj.equals(jj));//true
//自动装箱
Integer a = 500;
Integer b = 500;
System.out.println(a == b);//false
System.out.println(a.equals(b));//true
System类
概念
System中代表程序所在系统，提供了对应的一些系统属性信息，和系统操作；
System类不能手动创建对象，因为构造方法被private修饰，阻止外界创建对象，System类中都是static方法，类名访问即可；
-
currentTimeMillis()获取当前系统时间于1970年01月01日 00:00:00之间的毫秒值/** * 验证for循环打印数字0～9999所需要的时间 */ long start = System.currentTimeMillis();//当前时间x-1970年1月1日零时零分零秒 for (int i = 0; i < 10000; i++) { System.out.println(i); } long end = System.currentTimeMillis(); System.out.println("共耗时： " + (end - start)); -
exit(int status)终止当前正在运行的Java虚拟机，参数传入一个数字，通常传入0记为正常状态，其他为异常状态；/** * 推出虚拟机，所有程序全停止 */ while (true) { System.out.println("hello"); System.exit(0); } -
gc()用来运行JVM中的垃圾回收器，完成内存中垃圾的清除；public class Person { @Override public void finalize() { System.out.println("垃圾收取了"); } } public class Test { public static void main(String[] args) { new Person(); new Person(); new Person(); new Person(); /** * JVM在内存中，收取对象的垃圾 * 当没有更多引用指向该对象时，会自动调用垃圾回收机制回收堆中的对象 * 同时调用回收对象所属类的finalize()方法 */ System.gc(); } } -
getProperty(String key)获取指定键中所记录的系统属性System.out.println(System.getProperties()); -
arraycopy从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束；/** * System类方法，复制数组 * arraycopy(Object src, int srcPos, Object dest, int destPos, int length) * Object src, 要复制的源数组 * int srcPos, 数组源的起始索引 * Objet dest, 复制后的目标数组 * int destPos, 目标数组起始索引 * int length, 复制几位 */ int[] src = {11, 22, 33, 44, 55, 66}; int[] desc = {77, 88, 99}; System.arraycopy(src, 0, desc, 0, 3); for(int i = 0; i < desc.length; i++) { System.out.println(desc[i]); }
Math类
概念
Math类是包含用于执行基本数学运算方法的数据工具类，如初等函数、对数、平方根、三角函数等。类似这样的工具类，其所有方法均为静态方法，并且一般不会创建对象，如System类。
常用方法
-
static double abs(double d)返回参数值的绝对值int d1 = Math.abs(-5); double d2 = Math.abs(5); System.out.println(d1);//5 System.out.println(d2);//5.0 -
static double ceil(double d)返回大于或者等于参数d的最大整数double d1 = Math.ceil(3.3); double d2 = Math.ceil(-3.3); double d3 = Math.ceil(5.1); System.out.println(d1);//4.0 System.out.println(d2);//-3.0 System.out.println(d3);//6.0 -
static double floor(double d)返回小于或者等于参数d的最小整数double d1 = Math.floor(3.3); double d2 = Math.floor(-3.3); double d3 = Math.floor(5.1); System.out.println(d1);//3.0 System.out.println(d2);//-4.0 System.out.println(d3);//5.0 -
satatic double sqrt(double d)返回参数的平方根double d1 = Math.sqrt(4); double d2 = Math.sqrt(-4); double d3 = Math.sqrt(3); double d4 = Math.sqrt(-3); System.out.println(d1);//2.0 System.out.println(d2);//NaN System.out.println(d3);//1.7320508075688772 System.out.println(d4);//NaN -
static double pow(double a, double b)返回第一个参数的第二个参数次幂的值double d1 = Math.pow(2.0, 3.0); double d2 = Math.pow(-2.0, 3); System.out.println(d1);//8.0 System.out.println(d2);//-8.0 -
static double random()返回第正号的double值，该值大于等于0.0且小于1.0double d = Math.random(); System.out.println(d); -
static long round(double d)返回最接近参数的long值（四舍五入）double d1 = Math.round(5.5); double d2 = Math.round(5.6); double d3 = Math.round(5.3); System.out.println(d1);//6.0 System.out.println(d2);//6.0 System.out.println(d3);//5.0 -
static double max(double a, double b)返回两个double值中大的一个double d1 = Math.max(3.3, 5.5); int d2 = Math.max(3, 5); System.out.println(d1);//5.5 System.out.println(d2);//5 -
static double min(double a, double b)返回两个double值中小的一个double d1 = Math.min(3.3, 5.5); int d2 = Math.min(3, 5); System.out.println(d1);//3.3 System.out.println(d2);//3
Arrays类
概念
此类包含用来操作数组（比如排序和搜索）的各种方法；
常用方法
-
static String toString(数组)返回数组内容的字符串表现形式int[] arr = {5, 1, 4, 6, 10, 8, 9}; String str = Arrays.toString(arr); System.out.println(arr);//[I@1f89ab83 System.out.println(str);//[5, 1, 4, 6, 10, 8, 9] -
static int binarySearch(数组, 被查找的元素)数组的二分搜索法，返回元素在数组中出现的索引，如果元素不存在，返回的是-插入点索引-1int[] arr = {1, 4, 7, 9, 11, 15, 18}; int index1 = Arrays.binarySearch(arr, 11); int index2 = Arrays.binarySearch(arr, 5); System.out.println(index1);//4 System.out.println(index2);//-3; -2-1; {1, 4, 5, 7, 9, 11, 15, 18} -
static void sor(数组)对数组内的内容进行生序排列int[] arr = {5, 1, 4, 6, 8, 9, 0}; Arrays.sort(arr); for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); }
大数运算
BigInteger
Java中最long型为最大整数类型，对于超过long型的整数已经不能称为整数了，它们被封装成BigInteger对象，在BigInteger类中，实现四则运算符都是用方法来实现，并不是用运算符；
BigInteger构造方法
-
BigInteger(String s)将BigInteger的十进制字符串表现现实转换为BigIntegerBigInteger bigInteger1 = new BigInteger("23235424325"); System.out.println(bigInteger1);//23235424325 -
BigInteger(String s, int radix)BigInteger bigInteger2 = new BigInteger("11", 2); BigInteger bigInteger3 = new BigInteger("11", 8); BigInteger bigInteger4 = new BigInteger("11", 16); System.out.println(bigInteger2);//3 System.out.println(bigInteger3);//9 System.out.println(bigInteger4);//17
BigInteger四则运算
BigInteger big1 = new BigInteger("12345678909876543210");
BigInteger big2 = new BigInteger("98765432101234567890");
/**
* add 实现加法运算
*/
BigInteger bigAdd = big1.add(big2);
System.out.println(bigAdd);//111111111011111111100
/**
* subtract 实现减法运算
*/
BigInteger bigSub = big1.subtract(big2);
System.out.println(bigSub);//86419753191358024680
/**
* multiply 实现乘法运算
*/
BigInteger bigMul = big1.multiply(big2);
System.out.println(bigMul);//1219326312117055326552354825111263526900
/**
* divide 实现除法运算
*/
BigInteger bigDiv = big1.divide(big2);
System.out.println(bigDiv);//0
BigDecimal
如果使用double、float等类型进行运算很容易丢失精度，造成数据的不准确性；
System.out.println(0.09 + 0.01);//0.09999999999999999
System.out.println(1.0 - 0.32);//0.6799999999999999
System.out.println(1.015 * 100);//101.49999999999999
System.out.println(1.301 / 100);//0.013009999999999999
因此在涉及金额等商业计算中应该使用BigDecimal类的方式实现浮点数据的高精度计算；
BigDecimal的加、减、乘三则运算
BigDecimal big1 = new BigDecimal("0.09");
BigDecimal big2 = new BigDecimal("0.01");
/**
* add 实现加法运算
*/
BigDecimal bigAdd = big1.add(big2);
System.out.println(bigAdd);//0.10
/**
* subtract 实现减法运算
*/
BigDecimal bigSub = big1.subtract(big2);
System.out.println(bigSub);//0.08
/**
* multiply 实现乘法运算
*/
BigDecimal bigMul = big1.multiply(big2);
System.out.println(bigMul);//0.0009
BigDecimal的除法运算
对于浮点数据的除法运算和整数不同，可能会出现无限不循环小数，因此需要对所需要的位数进行保留和选择舍入模式；
-
public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)BigDecimal divisor int scale int roundingMode 除数 保留几位小数 保留模式：
static int ROUND_UP 向上加1
static int ROUND_DOWN 直接舍去
static int ROUND_HALF_UP 可理解为四舍五入
static int ROUND_HALF_DOWN >0.5向上加1，否则舍去BigDecimal big1 = new BigDecimal("1.7"); BigDecimal big2 = new BigDecimal("2"); //计算big/big2的商，调用方法divide BigDecimal bigDiv1 = big1.divide(big2); System.out.println(bigDiv1);//0.85 BigDecimal big3 = new BigDecimal("1.565"); BigDecimal big4 = new BigDecimal("1"); //计算big/big2的商，调用方法divide BigDecimal bigDiv2 = big3.divide(big4, 2, BigDecimal.ROUND_HALF_UP); System.out.println(bigDiv2);//1.57
网友评论