概念:API是应用程序编程接口,指的是java中原来就提供的类和接口中的接口
但一般所说的API指的是API文档,该文档对官方提供的类与接口会进行一个说明,供开发人员学习使用
使用API查阅类的时候可以使用关键字进行查阅,但是在系统化学习的时候尽量还是按照包名来查找
常用类 基本的包装类在java语言中,提供了八种基础的数据类型,分别是byte,short,int,long,float,double,boolean,char,在目前的阶段实际应用是都是通过声明该类型的变量进行使用,这八种使用方式并不是面向对象的,在使用起来会造成不便,为了解决这种不足,java提供八种不同的包装类来代表这八种数据类型,Short,Integer,Long,Float,Double,Char,Boolean八个类被称为包装类
包装类的主要用途:
● 作为和基本数据类型对应的类类型存在。 ● 包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法。
包装类中的常用方法:
八种包装类中的方法时类似的,故以Integer类为代表说明
1.intValue()方法(byteValue(),floatValue(),shortVlaue()……):以int(或者其他形式)返回对象中的属性值
2.compareTo()方法:比较两个对象中包含的基本类型值的大小
3.Integer 变量名称 =new Integer(int 变量名(String 变量名))用构造方法将int型或者String型的数据对属性初始化赋值
4.Integer.valueOf()方法也是用来创建Integer对象并赋予初始值的方法
int a =10; Integer b1=new Integer(10);//Integer类对应int型,其中包含一个int型的属性常量,还有很多对对int型数据的操作方法与常量 int c=b1.intValue();//从对象中返回一个int类型值的方法 float f=b1.floatValue();//返回一个float类型的值 Integer b2=new Integer(20); Integer b3=Integer.valueOf(20); System.out.println(b2.compareTo(b1));//使用两个不同对象中的属性进行比较,<返回-1,=返回0,>返回1 //Integer包装类中的静态方法与静态常量 System.out.println(Integer.MAX_VALUE);//表示int数据类型的最大值 System.out.println(Integer.MIN_VALUE);//表示int数据类型的最小值 System.out.println(Integer.max(10,20));//返回两个int型数据中较大一个 System.out.println(Integer.min(10,20));//返回两个int型数据中较小一个 System.out.println(Integer.toBinaryString(5));//将int型数据转换为二进制数 System.out.println(Integer.toOctalString(50));//将int型数据转换为八进制数 System.out.println(Integer.toHexString(300));//将int型数据转换为16进制数
数据的装箱与拆箱
与字面意思类似,装箱的意思就是将基本数据类型转换成对应的包装类,拆箱是指将包装类转换为基本数据类型下面以Integer类型为例进行示范
装箱的语法格式:
Integer 变量名=new Integer(int m);
Integer 变量名=new Integer(String s);
Integer 变量名=Integer.valueOf(int m);
拆箱的语法格式:
int m=对象名.intvalue;
int m=Integer.parseInt(String s);//将String类型转换为int类型//实际上在装箱的第二条语法中的底层调用的就是该方法
自动的装箱与拆箱:
自动装箱:int x=10;
Integer y=x;//自动转换为包装类的类型,实际上在底层调用的是valueOf()方法
自动拆箱:Integer x=new Integer(10);
int y=x;//自动转换为基本数据类型,实际上在底层调用的是intValue()方法
Integer x=new Integer(10); int y=x;//自动将包装类型转换为了基本数据类型,实际上底层调用的是intValue方法 System.out.println(y); int a=10; Integer b=a;//自动将基本数据类型转换为了包装类型,实际上底层调用的是valueOf方法 System.out.println(b);
除此之外需要注意一下valueOf方法使用时的差异:
Integer x=new Integer(10); Integer y=new Integer(10); System.out.println(x==y);//由于是创建了两个对象,而两个对象的地址并不相同,故返回值为flase //利用valueOf方法装箱过程中的差异 Integer a=Integer.valueOf(10); Integer b=Integer.valueOf(10); System.out.println(a==b);//返回值为true,是由于valueOf方法中已经缓存了-128至127的对象, // 故如果使用valueOf方法装箱,在上述区间内装箱同一值会返回同一个对象, //而超过这个区间就会新创建一个对象 Integer c=Integer.valueOf(128); Integer d=Integer.valueOf(128); System.out.println(c==d);//返回值为false System.out.println(c.equals(d));//利用equals方法可以比较包装类中的属性值
在valueOf()方法中已经定义好了区间在-128—127中对应的每一个包装类对象(为了缓存调用),此时如果使用valueOf方法装箱,在上述区间内装箱同一值会返回同一个对象,但是超过这个区间调用该方法就会创建新的对象
Object类● Object类是所有Java类的祖先（根基类）。每个类都使用 Object 作为超类（父类）。所有对象（包括数 组）都实现这个类的方法。 ● 如果在类的声明中未使用extends关键字指明其基类，则默认基类为
● Object类可以实现多态
Object类 public class Person { ... } 等价于： public class Person extends Object { ... }
Object中常用的方法: public String toString()
toString( )方法:将任意形式的数据转换为String类型的形式,该方法的底层实现是将对象内存中的地址(哈希值)转换为十六进制的数
在输出对象时,对象会默认调用类中的toString()方法
//Object类中的方法
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
//应用
public static void main(String[] args) {
Car car=new Car("奔驰",500000);
System.out.println(car);//com.yzl.javaapi.obj.Car@16d3586,自动调用父类中的toString方法将哈希值的地址直接转换为十六进制数
//若是想要直接输出对象中的内容则可以重写Object类中的toString()方法
int []a=new int[]{1,2,3,4,5};
System.out.println(a);
equals( )方法: public boolean equals(Object obj)
一般在调用此方法时是想要比较两个对象中的内容是否相等,在Object类中提供了该方法,但是该方法却是直接对对象名来比较的,故若想使用该方法来比较属性值需要重写该方法
//Object类中的原方法
public boolean equals(Object obj) {
return (this == obj);
}
Arrays类
Arrays类是属于java.util包下的类,主要的功能是对数组进行操作
equals( )方法: Arrays.equals()
在Arrays类中重写了该方法变为为静态方法,可以比较两个数组对象中的内容是否相等
toString( )方法:Arrays.toString()
在Arrays类中重写了toString()方法变为静态方法,使该方法可以将数组内容转换为String类型的形式
public static void main(String[] args) {
int []a1={1,2,3,4,5};
int []a2={1,2,3,4,5};
System.out.println(a1==a2);//判断两个数组的地址是否相同
System.out.println(Arrays.equals(a1,a2));//用Arrays类中的equals方法去判断两个数组中的内容是否相等
System.out.println(Arrays.toString(a1));//Arrays类中有一个静态方法可以直接调用输出数组中的内容
System.out.println(Arrays.toString(a2));
sort( )排序方法: Arrays.sort()
Arrays类中的静态方法,对数组内的元素进行排序,除此之外,该类中还重载了该方法,可以对其进行任意区间内进行排序使用方法为Arrays.sort(a,开始位置,结束位置)
int []a={4,2,5,3,1};
Arrays.sort(a,2,5);
System.out.println(Arrays.toString(a));
Arrays.sort(a);//使用sort方法对基本数据类型进行排序
System.out.println(Arrays.toString(a));
该方法除了对基本数据类型进行排序外,也能对引用类型进行排序,但是在实现对引用类型排序的时候需要在类中实现Comparable接口,并且重写compareTo()方法才能对该类型进行排序,这是由于在底层代码中对实现引用类型的排序时需要调用到compareTo()方法
//Car类中重写的方法
@Override
public int compareTo(Car o) {
return this.no-o.no;
}//该方法在sort排序的底层调用
Car car1=new Car(1234,"宝马1");
Car car2=new Car(1235,"宝马2");
Car car3=new Car(1236,"宝马3");
Car car4=new Car(1237,"宝马4");
Car car5=new Car(1238,"宝马5");
Car []cars=new Car[5];
cars[0]=car1;
cars[1]=car2;
cars[2]=car3;
cars[3]=car4;
cars[4]=car5;
Arrays.sort(cars);//直接调用的话会报错,需要重写compareTo方法才能排序应用类型
System.out.println(Arrays.toString(cars));
binarySearch( )二分查找(折半查找)方法: Arrays.binarySearch(int[] a, int key)
该方法的使用前提是数组是有序的,该方法可以查询数组中有无指定值,若有则返回该值在数组中的索引,若没有则返回负数 该方法也可以返回指定区间内有无指定值,使用二分查找能提高查找的效率
int [] a=new int[]{5,3,7,1,9,2,4};
Arrays.sort(a);//先对数组进行排序,1,2,3,4,5,7,9
int index= Arrays.binarySearch(a,7);//返回查找值的索引,若没有则返回负数
System.out.println(index);
int index2= Arrays.binarySearch(a,0,5,9);//查找指定区间中有无指定值
System.out.println(index2);
int index3= ArrayDemo3.efSearch(a,0,7,7);
System.out.println(index3);
copyOf( )数组复制方法: Arrays.copyOf(int [] a, int newlength)
数组的长度一旦定义就改变不了了,但是使用该方法可以创建一个新的数组,并且可以复制旧的数组,且指定新数组的长度
int []a={1,4,2,5,6};
int []b=Arrays.copyOf(a,7);
System.out.println(Arrays.toString(b));//新定义的数组中新添的值为默认值
String类
String类是属于java.lang包下的类,该类被final修饰不能被子类继承
特性1.字符串中的值创建之后就不能再被更改
这是由于String类底层存储的是char类型的数组(jdk9之后就存储的是byte类型的数组),通常可以看到用 字符串连接运算符可以将两个字符串拼接在一起,但是实际上在运算过后会创建一个新的对象,并将原来的对 象引用指向该对象
例如:String s="abc"; s=s+"ef";此时就新创建了一个对象在字符串常量池中
特性2:java中的所有字符串" "的形式都可以被视作String类的实例
创建String类的两种方式
1.隐式创建:String s1="abc";
隐式创建的过程为先在栈中创建一个对String类的对象引用变量s，然后去字符串常量池中查找有没 有"abc", 如果没有则在常量池中添加”abc”, s引用变量指向常量池中的”abc”，如果常量池中有,则直接指向 改地址即可,不用重新创建.
2.通过new关键字进行创建(也是通过构造方法进行创建):
String s2=new Sting(有参或无参);
通过new创建的字符串都是在堆空间中创建的新对象
String类中的构造方法
public String(),无参的构造方法,调用该方法可以为字符串为赋予空值""
public String(String str),有参的构造方法,直接赋予字符串的初值
public String(byte[] bytes),有参的构造方法,通过byte数组赋予字符串初值
public String(char[] value),有参的构造方法,通过char数组赋予字符串初值
String类中判断功能的方法
boolean equals(),比较两个字符串中的内容是否相同
boolean equals(),比较两个字符串的内容是否相同且忽视大小写
boolean contains(),判断字符串中是否包含某子串
boolean isEmpty(),判断字符串是否为空
boolean startsWith(),判断字符串是否以某个子串开头
boolean endsWith(),判断字符串是否以某子串结尾
String类中获取功能的方法
int length(),获取字符串的长度
char charAt(int index),返回指定索引处的字符
int indexOf(String str),返回指定索引处的字符
int indexOf(String str,int fromIndex),返回指定字符或者子串第一次出现的位置
String substring(int start),返回从指定位置开始到结束位置的子串
String substring(int start,int end),返回指定区间的子串
String类的转换方法
getBytes()方法,将字符串转换为一个byte数组
该方法在应用场景多见于转码,在对字符串进行传输时用的是字节数组进行的传输,此时就需要对字符串进行转换变为字节数组,该过程是转码的过程,在转码的过程中应用的字符集默认为utf-8,也可以在方法的参数中指定字符集
与该方法对应的有解码的方法,对应构造方法中的public String(byte[] bytes)方法,此方法可以通过对应的字符集将字节数组转换为字符串,默认的字符集为utf-8,也可以在参数中设置指定的字符集
String s="中文";
byte []a=s.getBytes();//返回一个byte数组,该方法也被称为转码
System.out.println(Arrays.toString(a));
//byte []a=s.getBytes("utf-8");//可以通过参数来指定转换的字符集,此处指定的是utf-8
//byte []a=s.getBytes("gbk");//指定gbk字符集转换
String s1=new String(a);//通过构造方法进行解码,默认使用utf-8
System.out.println(s1);
String s2=new String(a,0,3,"utf-8");
System.out.println(s2);
//new String(byte,offet(开始位置),length(转码长度),charsetName(设置字符集)),此方法可以对指定位置长度的数组还有字符集进行转码
toCharArray()方法,返回一个char型的数组
在对字符串进行操作的时候本质上是对字符数组在进行操作,故用该方法在对字符串进行操作的时候很便捷
与该方法对应的还有构造方法public String(char[] value),可以将字符数组转换为字符串
String s="dabc"; char []a=s.toCharArray();//转换为字符数组 Arrays.sort(a);//对字符数组进行排序 String s1=new String(a);//利用构造方法创建新的对象 System.out.println(s1);
valueOf()方法,也属于转换方法,将其他类型的值转换为字符串
valueOf()方法与toString()方法的区别,toSring()方法也是将其他类型的数据转换为字符串,但是如果转换的引用指向了null,toString()方法会报空指针错误,但是valueOf()方法却不会,这是由于在底层valueOf()方法实现了将null转换为"null"字符串,故在转换为字符串的时候,建议使用valueOf()数组
Integer i1=null; String s1=String.valueOf(i1);//注意此方法转换为字符串不会报错,是因为底层对指向null的引用会自动转换为"null" //Integer i2=null; //String s2=i2.toString();//此种方法虽然也是对数据类型的转换,但是对null值的引用不会转换,使用此方法会报错
String toLowerCase().将字符串中的大写字母全部转换为小写字母,并返回一个新的字符串
String toUpperCase(),将字符串中的小写字母全部转换为大写字母,并返回一个新的字符串
String concat(String str),拼接一个新的子串在字符串上,并且返回一个新的字符串
Stirng[] split(分割符);,用分隔符将字符串分割为一个字符串数组,注意该方法使用的是正则表达式进行的判断
String s3="abcdEFG";
String s4=s3.toLowerCase();
String s5=s3.toUpperCase();
System.out.println(s4);
System.out.println(s5);
System.out.println(s3.concat("hij"));
String s6="ab,cd,ef";
String []s=s6.split(",");
System.out.println(Arrays.toString(s));
String类中的替换方法
String replace(char old,char new),用新的字符替换旧的字符,返回一个新的字符串
String replace(String old,String new),用新的子串替换旧的子串,返回一个新的字符串
String replaceAll(String regex, String replacement),用正则表达式判断子串,再替换该子串
String replaceFirst(String regex, String replacement),用正则表达式判断子串,再替换第一次出现的该子串
String trim(),去掉字符串两边的空格,然后返回一个新的字符串
String s="abcfabcedab";
String s1=s.replace('c','C');
System.out.println(s1);
String s2=s.replace("ab","AB");
System.out.println(s2);
String s3=s.replaceAll("ab","AB");
System.out.println(s3);//该方法与第一个方法区别在于,判别需要替换的子串的时候使用的是正则表达式而不是子串,
// 两者都是替换的字符串中的全部子串
String s4=s.replaceFirst("ab","AB");
System.out.println(s4);//该方法也是使用正则表达式进行对需要替换的子串进行的判断
String s5=" abc d ";
System.out.println(s5.trim());//去掉字符串两边的空格
正则表达式
正则表达式又称规则表达式,（Regular Expression，在代码中常简写为regex、regexp或RE）是一种模式匹配语言,通常被用来检索、替换那些符合某个模式（规则）的文本,由于在String类中的转换方法splite与替换方法replaceAll,replaceFirst中都使用了正则表达式,故必须要了解正则表达式的基本用法
d匹配0-9的数字
[a-z]匹配小写字母
[A-Z]匹配大写字母
w 匹配包括下划线的任何单词字符。类似但不等价于“[A-Z a-z 0-9_]”，这里的"单词"字符使用Unicode字符集。
{n}表示匹配任意个字符
{n,}表示从第n位开始匹配任意多个字符
{n1,n2}表示最少匹配n1个字符,最多匹配n2个字符
*号代表匹配0次或者多次 +号也代表匹配一次或者多次
System.out.println(s.matches("[1][3,5,6,7,8,9][1-9]{9}"));
String s1="a132683485@qq.com.cn";
boolean b=s1.matches("[A-z]\w{4,10}@\w{2,5}\.(com|com\.cn)");//由于.符号在正则表达式中有含义故需要用转义符来
// 让它代表原本的含义
System.out.println(b);
//在之前学到的String类的方法中也有用到正则表达式
String s2="abc2asd3fs";
System.out.println(Arrays.toString(s2.split("\d")));//使用正则表达式来作为分割符
System.out.println(s2.replaceAll("\d","a"));//split(),replaceAll()方法都是使用正则表达式来做判断
StringBuffer类
由于String类的底层是数组,String类的对象的值一旦确定就更改不了了,若是需要对String类进行操作,则会产生新的对象,例如字符串的拼接操作等,这些操作在底层对数组进行操作,既费时,而且创建新的对象也会造成空间的浪费而StringBuffer类是一个可变的带缓冲区的字符串,若是需要大量的对字符串进行拼接与删减操作则建议使用此类
构造方法 public StringBuffer() public StringBuffer(String str)
添加功能 public StringBuffer append(String str),增加一个子串在字符串的末尾 public StringBuffer insert(int offset,String str),增加一个子串在字符串的任意位置
删除功能 public StringBuffer deleteCharAt(int index),删除指定位置处的字符 public StringBuffer delete(int start,int end),删除指定区间的子串,从起始索引对应字符开始到结束索引前一个字符结束所对应的子串
替换功能 public StringBuffer replace(int start,int end,String str),替换指定区间的子串,对应区间与删除中的区间相同
反转功能 public StringBuffer reverse(),逆序输出
截取功能
上述四个功能都是返回的原来的StringBuffer对象,而截取功能返回的是一个新的字符串
public String substring(int start),截取从指定位置开始后面的所有字符,返回一个新字符串 public String substring(int start,int end)截取对应区间的子串,创建一个新字符串并赋值
//创建一个StringBuffer对象
StringBuffer s=new StringBuffer("abcd");//参数使用字符串可以直接创建一个(该字符串长度+16)的可变字符串
//也可以不使用字符串作为参数而直接使用容量作为参数创建该对象
s.append("efg");
s.append("efg");
s.append("efg");
s.append("efg");
s.append("efg1");//若是增加的字符串在超过了缓冲区的长度,则会在底层新创建一个字符数组赋予原来数组,达到增长字符串的目的
//使用增加的方法都是返回的同一个StringBuffer对象,不会创建新的StringBuffer对象
s.insert(3,"ef");//在指定位置插入子串,原来位置的字符向后移动
s.delete(0,2);//删除指定区间的子串,从起始索引对应字符开始到结束索引前一个字符结束所对应的子串
s.deleteCharAt(0);//删除指定位置的字符
//替换功能
s.replace(0,2,"EF");//替换指定区间的子串,对应的区间与删除功能相同
//反转功能
s.reverse();//逆序输出
//截取功能 截取功能与上述功能不同,该功能是返回一个新的字符串对象,但原StringBuffer对象不变
String s1=s.substring(17);//截取从指定位置开始后面的所有字符
System.out.println(s1);
String s2=s.substring(0,17);//截取对应区间的子串,创建一个新的子串并赋值
System.out.println(s2);
System.out.println(s);
StringBuilder类
底层实现原理与StringBuffer类完全一致
两者的区别:
StringBuffer类是多线程操作安全的,该类所有的方法都被synchranized关键字修饰
StringBuilder类是多线程操作不安全的,单线程的情况下使用该类
String类,StringBuffer类,StringBuilder类之间的联系
String类可以通过构造方法转换为StringBuffer类,StringBuilder类
StringBuffer类,StringBuilder类也可以通过构成方法转换为String类
String：是字符常量,适用于少量的字符串操作的情况
StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况
StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况
Math类位于java.lang.Math包下,并且提供了一系列静态方法用于科学计算；其方法的参数和返回值类型一般为double型。
int abs 绝对值
double sqrt 平方根
double pow(double a, double b) a的b次幂
[取决于传入参数类型] max(double a, double b)//重载了对应八个基本数据类型的方法
[取决于传入参数类型] min(double a, double b)//重载了对应八个基本数据类型的方法
double random() 返回 0.0 到 1.0 的随机数//
long round(double a) double型的数据a转换为long型（四舍五入）
Random类位于java.util包下,此类用于产生随机数
构造方法 public Random() 成员方法 public int nextInt(),重载了对应八个基本数据类型的方法
public int nextInt(int n),随机生成0到n的随机数
public byte[] nextBytes(byte[] byt),传入一个字节数组,并为字节数组中的每一个数组赋予随机的字节类型范围内的数
Random ra=new Random(); System.out.println(ra.nextBoolean());//返回一个随机的布尔值 System.out.println(ra.nextDouble());//返回一个随机的double类型的值 System.out.println(ra.nextFloat());//返回一个随机的float类型的值 System.out.println(ra.nextInt());//返回一个随机的int类型的值,范围在int型的数据之内 System.out.println(ra.nextLong());//返回一个随机的long型的值 System.out.println(ra.nextInt(35));//设置一个界限.返回0-bound之内的值 byte []a=new byte[5]; ra.nextBytes(a);//为byte数组的每个元素赋予随机的值 System.out.println(Arrays.toString(a));Date类
位于java.util包下,用来代表时间的类,该类的对象中包含了时间相关的信息与方法
构造方法:
Date d = new Date();//创造该类的对象时可以获取程序运行那一刻的时间
Date d = new Date(long d);//使用long类型的参数,可以创建一个与1970-1-1 00:00:00时刻对应时间差的对象
方法:
Date类中有很多方法已经过期了,已经有了更好的方法可以取代,但是依然可以使用
但是long getTime()方法还是经常使用的,该方法可以返回创建对象时与1970-1-1 00:00:00时刻的时间差
Date date =new Date(); System.out.println(date);//直接输出就可以输出对象所包含的时间信息 System.out.println(date.getYear());//该方法已过期,java中带有删除线的方法表示已经过期的方法,虽然可以使用但是有更好的方法 System.out.println(date.getDay());//今天的星期几,该方法已过期 System.out.println(date.getDate());//今天是这个月的第几号,该方法已过期 System.out.println(date.getMonth());//今天是几月,月份从0开始算到11月份,该方法已过期 System.out.println(date.getTime());//返回从1970-1-1 0:0:0时刻到至今的毫秒差返回的数据类型是long类型 //该方法的返回值可以用来创建一个Date对象 System.out.println(new Date(1658564581538L));//使用long类型的数据创建一个Date对象,该对象包含该数据的时间Calendar类
位于java.util包下
Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明的，只需要使用getInstance方法创建即可。
方法:
long getTimeInMillis( ),返回从1970-1-1 0:0:0时刻到至今的毫秒差返回的数据类型是long类型
ca.getTime( ),返回程序运行这一刻的时间
Calendar ca=new GregorianCalendar();//由于是抽象类不能直接创建该类的对象的,故可以用该类的引用指向子类的对象 //Calendar类中还有一个静态方法可以创建对象 Calendar ca1=Calendar.getInstance();//该方法在底层也是也是创建的GregorianCalendar类的对象 System.out.println(ca);//返回的是该对象中包含的所有元素 System.out.println(ca.get(Calendar.DATE));//返回今天是这个月的第几天 System.out.println(ca.get(Calendar.DAY_OF_MONTH));//返回今天是这个月的第几天 System.out.println(ca.get(Calendar.DAY_OF_WEEK));//返回今天是这个星期的第几天 System.out.println(ca.get(Calendar.DAY_OF_YEAR));//返回今天是今年的第几天 System.out.println(ca.get(Calendar.WEEK_OF_MONTH));//返回找一个周是这个月的第几周 System.out.println(ca.get(Calendar.WEEK_OF_YEAR));//返回这一周是今年的第几周 System.out.println(ca.getTimeInMillis());//返回从1970-1-1 0:0:0时刻到至今的毫秒差返回的数据类型是long类型 System.out.println(ca.getTime());//返回程序运行这一刻的时间SimpleDateFormat类
可以将日期对象转换为格式指定的字符串
应用场景为:想要将日期对象显示成为指定格式的字符串,或者将指定格式的字符串转换为日期对象
构造方法:
SimpleDateFormat 变量名称=new SimpleDateFormat(),参数为指定字符串的格式,该格式是类中自定义的格式,使用时需要参考api中的格式规定
方法:
String format(Date d),将日期对象转换为指定格式的字符串
Date parse(String s)将指定格式的字符串对象指定转换为日期对象
Date da1=new Date();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss E");//参数需要输入该类指定的格式
String s1=sdf.format(da1);
System.out.println(s1);
String s2="2022-07-23";
SimpleDateFormat sdf1=new SimpleDateFormat("yyyy-MM-dd");
try {
Date da2=sdf1.parse(s2);//将指定格式的字符串转换为日期对象
System.out.println(da2);//由于parse()方法可能转换不会成功,故需要使用try/catch捕捉异常
} catch (ParseException e) {
e.printStackTrace();
}
BigInteger类
BigInteger类位于java.math包中
在 Java 中，有许多数字处理的类，比如 Integer类，但是Integer类有一定的局限性。Integer 是 Int 的包装类，int 的最大值为 2^31-1。但是若希望描述更大的整数数据时，使用Integer 数据类型就无法实现了，所以Java中提供了BigInteger 类。 BigInteger类型的数字范围较Integer，Long类型的数字范围要大得多，它支持任意精度的整数，也就是说在运算中 BigInteger 类型可以准确地表示任何大小的整数值而不会丢失任何信息。
构造方法 BigInteger(String val) /BigInteger(byte[] val) ... 基本运算方法 add()，subtract()，multiply()，divide()/加减乘除
BigInteger bi1=new BigInteger("102938129043082758035");
BigInteger bi2=new BigInteger("1029381290430827580353812904308275803538129043082758035");
BigInteger bi3=bi1.add(bi2);//加法运算,该类中的数据都需要通过指定的方法进行运算,不能直接使用运算符
System.out.println(bi3);
BIgDecimal类
在计算机中不论是float 还是double都是浮点数，而计算机是二进制的，浮点数会失去一定的精确度。
根本原因是:十进制值通常没有完全相同的二进制表示形式;十进制数的二进制表示形式可能不精确。只能无限接近于那个值.
构造方法 BigDecimal(String val) 基本运算方法 add()，subtract()，multiply()，divide()//加减乘除
但是要注意的是在使用除法的时候如果出现无限循环小数,需要在方法参数中提供保留的小数位与取整的方法
double a = 1.0-0.9; double b = 0.8-0.7; System.out.println(a);//0.09999999999999998 System.out.println(b);//0.10000000000000009 System.out.println(a==b); // 结果为false,两个double类型的数运算之后可能会产生无限接近于某个数的小数 BigDecimal bd1=new BigDecimal(10); BigDecimal bd2=new BigDecimal(3); BigDecimal bd3=bd1.divide(bd2,3,BigDecimal.ROUND_FLOOR);//使用除法是如果出现无限循环小数则会报错,此时需要加上保留小数位,与取整的方式作为参数 System.out.println(bd3);
