目录
1.API
1.1定义:
API(applicant programming interface)应用程序编程接口
一般在开发中,api表示java语言中为我们提供的各种类和接口(基础功能)
java官方为开发人员提供了一个文档 ,对语言中提供的接口和类进行说明,我们称为API文档
2.Object类
2.1 toString() 方法
2.1.1定义:
在开发中，经常用到输出一个对象，但是对象在内存中储存，是不能直接输出到控制台的,一旦要输出某个对象，那么会默认自动调用类中toString()方法,把对象中的信息，以字符的形式输出
举例:
如果类中没有定义toString()方法,那么就会在父类里面调用
Object类中的toString()默认输出的是对象在内存中的地址(Object类是所有类的父类)
package Objectdemo.toStringdemo;
public class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//Object中的toString()方法输出的是对象的地址,与我们想要的结果不一样,那么我们就重写toString方法
@Override
public String toString() {
return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
}
}
Object中的toString() 输出的是对象的地址,与我们想要的结果不一样,那么我们就重写toString()
package Objectdemo.toStringdemo;
public class ToStringDemo {
public static void main(String[] args) {
Person person = new Person();
person.setAge(20);
person.setName("Tom");
System.out.println(person);
}
}
2.2 equals() 方法
2.2.1 定义:
Object类中 默认的equals(Object obj) 比较两个对象的地址是否相等 , 与 == 效果相等
为了区分,开发人员把equals进行重写, 从而比较 内容 是否相同
如果两个相等，则返回值为true，否则返回值为false (Boolean类型)
2.2.2 举例:
package Objectdemo.Equalsdemo;
public class Person {
String name;
int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//重写equals方法,用来比较内容是否相等
@Override
public boolean equals(Object obj) {
//Person是自己定义的类,需要重写equals方法
if (obj instanceof Person){
Person p = (Person)obj;//判断,如果类型相同,就向下转型
return this.age == p.age && this.name.equals(p.name);
//(name)String类型中的equals已经被重写了,比较的是内容是否相同
}
return false;
}
}
自己定义的类,需要重写equals方法,系统中定义的类,一般情况下已经重写过equals()方法了
package Objectdemo.Equalsdemo;
public class Demo1 {
public static void main(String[] args) {
Person p1 = new Person();
p1.setName("jim");
p1.setAge(20);
Person p2 = new Person();
p2.setAge(20);
p2.setName("jim");
//比较p1和p2是否相等
//1.比较地址是否相同
System.out.println(p1==p2);//==左右，当两边是引用数据类型时，比较的是 地址 是否相等
//2.比较内容是否相同
System.out.println(p1.equals(p2));//默认调用equals(),也是比较对象地址是否相等;重写后,比较的是内容是否相同
}
}
3. Arrays 类
3.1 equals() 方法
3.1.1 定义:
比较两个数组对象中元素是否相等.
举例:
package Arraysdemo.equalsdemo;
import java.util.Arrays;
public class Demo1 {
public static void main(String[] args) {
int[] a={1,2,3,4,5};
int[] b={1,2,3,4,5,6};
System.out.println(a==b);//比较地址
System.out.println(Arrays.equals(a,b));//比较内容(Arrays类中的equals()已被重写)
}
}
3.2 sort() 方法
3.2.1排序
举例:
package Arraysdemo.Sortdemo;
import java.util.Arrays;
public class SortDemo1 {
public static void main(String[] args) {
int a[]={3,2,1,5,4};
Arrays.sort(a);////对数组内容进行排序
Arrays.sort(a,0,3);//对数组指定的 区间 进行排序（数组，包含开始的位置，不包含结束的位置）
System.out.println(Arrays.toString(a));
}
}
3.2.2 自定义对象排序
需要为自定义的对象提供一个排序规则，即指定用哪个属性(学号,字母...)进行排序
compareTo()会在Arrays类中的sort()排序时会自动调用,根据返回的结果判断两个值谁大谁小；
举例:
package Arraysdemo.Sortdemo;
public class Student implements Comparable<Student> {
private int no;
private String name;
public Student(String name, int no) {
this.name = name;
this.no = no;
}
@Override
public String toString() {
return "Student{" +
"no=" + no +
", name='" + name + '\'' +
'}';
}
@Override //实现接口 要重写抽象方法
public int compareTo(Student o) {
//用学号排序
return this.no-o.no;//返回结果 小于0 等于0 大于0
//用name排序
//return this.name.compareTo(o.name);
}
}
package Arraysdemo.Sortdemo;
import java.util.Arrays;
//自定义对象排序
public class SortDemo2 {
public static void main(String[] args) {
//构造方法赋值
Student student1 = new Student("b", 101);
Student student2 = new Student("a", 102);
Student student3 = new Student("c", 103);
Student student4 = new Student("d", 104);
Student student5 = new Student("e", 105);
//开辟有5个空间的学生数组
Student[] students = new Student[5];
//将学生随机装入数组中
students[0] = student3;
students[1] = student2;
students[2] = student5;
students[3] = student1;
students[4] = student4;
//对学生数组进行排序
Arrays.sort(students);
System.out.println(Arrays.toString(students));
}
}
3.3 binarySearch() 方法
3.3.1 定义:
二分查找算法（折半查找算法）
(1)前提：数组要是有序的
(2)方法：每次找到数组的中间值，用我们将要找的值与中间值进行比较。
如果我们要找的值大于中间值，就继续向右边查找 .然后再与右边的中间值进行比较,以此类推,如果小于中间值就向左查找
(3)举例:
int[] a = {1,2,3,4,5,6,7,8,9......,10000};
判断数组中是否包含 5535 这个元素
常用做法是从第一个开始查找,效率低,时间长;但是如果使用
二分查找(适合有序的大基数查找)直接从5000开始比较,加快了查找速率
package Arraysdemo.BinarySearchdemo;
import java.util.Arrays;
public class BinarySearchDemo1 {
public static void main(String[] args) {
int [] a= {9,5,8,7,2,6,4,3,1};
Arrays.sort(a);//1.先排序成{1,2,3,4,5,6,7,8,9}
//2.（要查找的数组,要寻找的元素） 如果返回负数,说明要寻找的值不存在
System.out.println(Arrays.binarySearch(a, 9));
//3.查找区间中的元素(要查找的数组,开始位置,结束位置,查找的元素)
System.out.println(Arrays.binarySearch(a,0,5,3));
}
}
3.4 copyOf() 方法
3.4.1定义:
数组复制,将原数组中的内容,复制到一个新创建的指定长度的数组
举例:
package Arraysdemo.Copyofdemo;
import java.util.Arrays;
public class CopyOfDemo {
public static void main(String[] args) {
int[] a = {1,2,3,4,5};
//int[] b = new int[8];//[1,2,3,4,5,0,0,0]
int[] b = Arrays.copyOf(a,8);//(原数组,新数组的长度)
System.out.println(Arrays.toString(b));
}
}
3.5 fill() 方法
3.5.1定义: 数组填充
举例:
package Arraysdemo.Filldemo;
import java.util.Arrays;
public class FillDemo {
public static void main(String[] args) {
int[] a = {1,2,3,4,5};
//(要填充的数组,要填充的元素)
Arrays.fill(a,1);//将a数组中的元素全填充为1
System.out.println(Arrays.toString(a));
}
}
3.6 toString() 方法
3.6.1定义:
返回指定数组内容的字符串的表示形式
4.基本数据类型包装类
4.1定义:
由于java是面向对象的,但是8中基本类型的数据类型不是面向对象的,使用起来不方便,所以 java语言中,为8种基本数据类型,各提供一个包装类进行表示, 包装类中可以包含一个基本 类型值以及一些常用的操作方法(例如: 寻找整数的最大值, 将整数转为二进制)
4.2 包装类的两种主要用途
● 包含每种基本数据类型的相关属性(最大/小值)以及相关的操作方法
● 作为 与基本数据类型 对应的 类型存在
4.3方法
(1)基本方法和常用静态方法
package basetypedemo;
public class IntegerDemo1 {
public static void main(String[] args) {
//int类型的包装类:Integer
//基本方法
System.out.println(Integer.MAX_VALUE);//最大值
System.out.println(Integer.MIN_VALUE);//最小值
System.out.println(Integer.BYTES);//4 含有的字节数
System.out.println(Integer.SIZE);//32 含有的比特位
//常用静态方法
System.out.println(Integer.max(10,5));//返回较大的值
System.out.println(Integer.min(10,5));//返回较小的值
System.out.println(Integer.toBinaryString(8));//2进制
System.out.println(Integer.toHexString(28));//16进制
System.out.println(Integer.toOctalString(9));//8进制
System.out.println(Integer.compare(11, 10));//两个数比大小--->返回 -1 0 1
String a ="10";
String b = "20";
//例如 ： String a ="10c"; 无法转换为整数,会报错
int ai = Integer.parseInt(a);
int bi = Integer.parseInt(b);
System.out.println(ai+bi);//把字符串类型的数值,转为基本类型数值,转换时不能出现非数字的字符
//同理可以调用其他基本类型的包装类,就省略了
}
}
(2)构造方法和实例方法
package basetypedemo;
public class IntegerDemo2 {
public static void main(String[] args) {
//构造方法
Integer i1 = new Integer(20);
Integer i2 = new Integer("20");//会调用parseInt(),将Stirng转为int类型的
//实例方法
System.out.println(i1.equals(i2));//equals(),比较Integer对象中的内容是否相等
System.out.println(i1.compareTo(i2));//compareTo(),比较Integer对象中的数据大小
String s = i1.toString();//toString(),将整数类型转为String类型
int a = i1.intValue();//intValue(),把包装类型转为基本类型
}
}
5. String类
5.1定义
java.lang.String 被final修饰,不能被继承
String是java中的字符串(用" "表示),String类中有一个char数组,用来存储字符串内容,
字符串对象一旦创建后,值就不能改变,改变值就是重新创建一个新的字符串对象
举例:
package Stringdemo.Demo;
public class Demo1 {
public static void main(String[] args) {
String s1 = new String("abc");
s1 += "def";
s1 += "ghi";
s1 += "jkl";
System.out.println(s1);
}
}
5.2 字符串类型创建对象的方式:
1.赋值方式
String s = "abc"; 类似于装箱,隐式的创建了一个字符串对象
2.new方式
String s = new String("abc");
package Stringdemo.Demo;
public class Demo2 {
public static void main(String[] args) {
String s1 = "abc";
String s2 = "abc";
String s3 = new String("abc");
String s4 = new String("abc");
System.out.println(s1 == s2);//true
/* s1和s2指向的是同一个地址,系统认为s1已经创建过一个"abc"对象,
放在字符串常量池当中,当s2的值为"abc"时,常量池里如果有,就把s1的地址赋给s2*/
System.out.println(s3 == s4);//false
System.out.println(s1.equals(s2));
System.out.println(s3.equals(s4));
}
}
注意:字符串常量池
5.3 判断功能
1. equals()方法 : 判断内容是否一致
equalsIgnoreCase() 方法: 判断内容是否一致，且忽略大小写
2.contains()方法 : 判断是否包含某个内容
3. isEmpty()方法 : 判断是否为空, 空返回true 否则返回false
4.startWith()方法 : 判断是否为指定的子串作为开头
5.endWith()方法 : 判断是否为指定的子串作为结尾
package Stringdemo.Demo;
public class Demo3 {
public static void main(String[] args) {
String s1 = "abcd";
String s2 = "abCd";
System.out.println(s1.equals(s2));//看内容是否一致
System.out.println(s1.equalsIgnoreCase(s2));//看内容是否一致，且忽略大小写
System.out.println(s1.contains("bd"));//false 判断是否包含一个整体 “bd”
System.out.println(s1.contains("b"));//true 判断是否包含“b”
System.out.println(s1.isEmpty());//判断是否为空 空返回true 否则返回false
System.out.println(s1.startsWith("ab"));//判断是否为指定的子串作为开头
System.out.println(s1.endsWith("d"));//判断是否为指定的子串作为结尾
}
}
5.4 获取功能
1. length() 方法 : 获取字符串的长度
2. charAt() 方法 : 获取指定位置上的字符
3. indexOf() 方法: 获取指定字符出现的位置，从前往后找
lastindexOf()方法 : 获取指定字符出现的位置，从后往前找
4. substring() 方法 : 截取字符,从...开始
substring( , )方法 : 截取字符,从...开始,到...结束
package Stringdemo.Demo;
public class Demo4 {
public static void main(String[] args) {
String s1 = "abcdefg";//['a','b','c','d','e','f','g']
System.out.println(s1.length());//获取字符串的长度
System.out.println(s1.charAt(2));//获取指定位置上的字符
System.out.println(s1.indexOf("c"));//获取指定字符出现的位置，从前往后找
System.out.println(s1.indexOf("c",3));
System.out.println(s1.lastIndexOf("c"));//从后向前找
System.out.println(s1.lastIndexOf("c",2));
String s2 = s1.substring(2);//截取字符,从第2个位置开始
System.out.println(s2);
String s3 =s1.substring(3,4);//截取字符,从第3个位置开始,到第4个位置结束
System.out.println(s3);
}
}
5.5转换功能
1.将char数组转换为字符串对象的方法:
(1).构造方法
(2).valueOf()方法
2.把字符串转换为char数组的方法:
toCharArray()方法
3.转码解码
getBytes()方法
package Stringdemo.Demo;
import java.util.Arrays;
public class Demo6 {
public static void main(String[] args) {
//构造方法
String s1 = new String();//创建一个字符串对象 this.value = "".value;
String s2 = new String("abcd");//创建String类型的
char[] chars ={'a','b','c','d'};
//将char数组转为字符串对象的方法:
String s3 = String.valueOf(chars);//String类的valueOf()方法
String s4 = new String(chars);//构造方法
String s5 = "abcd";
//把字符串转为char数组的方法:
char[] chars1 = s5.toCharArray();//toCharArray()方法
Arrays.sort(chars);//对数组进行排序
String s6 = new String(chars1);//把排好序的char数组转为字符串 （因为字符串没法排序，只有转为数组才可以排序）
System.out.println(s6);
//转换功能(转码解码)
String s7 = "abcd";//数据在传输时，都是以数字进行传递的
byte[] bytes= s7.getBytes();//将看的懂的字符转为看不懂的编码
System.out.println(Arrays.toString(bytes));//97 98 99 100
String s8 = new String(bytes);//再 将看不懂的字节数组转为看的懂的字符串
System.out.println(s8);
}
}
5.5 其他功能
一.将不同类型的数据转换为字符串类型的两种方法
1.toString()
用的比较少，如果a的值是整数，就不报错。但是a的值是null，会报错
2.valueOf() ----装箱
用的比较多 即使值为null,转换时也不会报错
二.大小写转换
1.toLowerCase()
转小写
2.toUpperCase()
转大写
三.字符串连接
concat() : 必须传String类型
四.去除字符串空格
1.trim()
去掉字符串前后的空格 不能去掉中间空格
2.replace()
使用replace(),将中间空格替换
五.字符串拆分
split() 用指定的分隔符，将一个字符串拆分成数组,不会去除中间的空格
六.字符串替换
replace(原来的字符,替换后的字符)
package Stringdemo.Demo;
import java.util.Arrays;
public class Demo5 {
public static void main(String[] args) {
//一.将不同类型的数据转换为字符串类型的两种方法
Integer a = null;
/*1.toString()方法
用的比较少，如果a的值是整数，就不报错。但是a的值是null，会报错。*/
//String s1 = a.toString();//会报错
/*2.valueOf()方法----装箱
用的比较多 即使值为null,转换时也不会报错*/
String s = String.valueOf(a);
System.out.println(s);
//二.大小写转换
String s3 = "abCD";
System.out.println(s3.toLowerCase());// abcd 转小写
System.out.println(s3.toUpperCase());// ABCD 转大写
//三.字符串连接
String s4 = s3.concat("efg");//concat()中必须传String类型
System.out.println(s4);//abCDefg 连接字符串
//四.去除字符串空格
//(1)去除前后空格
String s5 = s3.trim();//去掉字符串前后的空格 不能去掉中间空格
System.out.println(s5.length());
//(2)去除中间空格----使用replace(),将中间空格替换
//五.字符串拆分
String s6= "ab;cd :efg;hjk";
String[] strings = s6.split(";");
//用指定的分隔符，将一个字符串拆分成数组,不会去除中间的空格
System.out.println(Arrays.toString(strings));
//六.字符串替换
String s7= "abcecc";
String s8 = s7.replace("ce", "CD");//替换字符 (原来的字符,替换后的字符)
System.out.println(s8);
}
}
6.StringBuffer StringBuilder类
6.1 定义
由于String声明的字符串是不可以改变的,每次拼接(+=)都会创建一个对象,效率低
所以java中提供了两个值可变的字符串对象: StringBuffer 和 StringBuilder
6.2 注意
1.StringBuffer的创建不能通过赋值 即StringBuffer stringBuffer =" ";
只能通过new 即StringBuffer stringBuffer = new StringBuffer();
2.StringBuffer内部存在一个没有被final修饰的数组(默认长度16),可以向数组中存放字符
装满后,会自动扩容 同时不会创建新的StringBuffer对象 效率高
2. StringBuffer : 在多线程场景下是安全的，因为它的方法都加了 锁，一次只允许进一个
StringBuilder : 它的方法上，没有加锁，所以适合单线程场景
6.3 功能及源码
添加---删除---替换---逆序
package Stringdemo.StringBuffer;
public class StringBufferDemo {
public static void main(String[] args) {
StringBuffer stringBuffer1 = new StringBuffer();//无参的构造方法,默认容量是16
StringBuffer stringBuffer2 = new StringBuffer("abcd");
StringBuffer stringbuffer = new StringBuffer(10);//指定新的容量
//String s = new StringBuffer(stringBuffer);//可以将StirngBuffer类型转为String类,故此类中提供的方法较少
//常用方法:
stringbuffer.append("ss");//不能用 += 方法添加字符
stringbuffer.append("bb");//向末尾添加元素
stringbuffer.insert(3, "cnm");//向指定位置添加元素
stringbuffer.deleteCharAt(1);//删除指定位置上的值
stringbuffer.delete(0,5);//删除某个区间
stringbuffer.replace(0,2,"cccccc");//把某个区间替换成其他
stringbuffer.reverse();//逆序字符串 bmncbss
System.out.println(stringbuffer);
}
}
package Stringdemo.StringBuffer;
public class StringBuilderDemo {
public static void main(String[] args) {
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("abcd");
}
}
7. 正则表达式
7.1定义
正则表达式(RegEx)是一种文本格式匹配工具,是计算机语言的一种技术,主流编程语言都支持
使用正则表达式中的元素，制定一个规则，用这个规则与字符串进行匹配 matches()， 匹配成功返回true，否则返回false
7.2使用规范及代码
package Stringdemo.RegEx;
public class RedExDemo {
public static void main(String[] args) {
//使用正则表达式，就可以很轻松的进行字符串的格式匹配 举例:验证手机号是否正确
//正常方法 :遍历字符串,验证是否存在非数字字符 && 第一位必须为1 && 第二位为3579 && 其他位是数字
String s1 = "154sdhsh_54@xxx.com";
System.out.println(s1.matches("[0-9]"));//只能匹配一个数字
//注意： "-"表示范围 且要用[]表示
System.out.println(s1.matches("[0-9]*"));// * 表示不限数字个数
System.out.println(s1.matches("[0-9]{3}"));//只能是三个数字
System.out.println(s1.matches("[0-9]{3,}"));//数字的个数可在三个以上
System.out.println(s1.matches("[0-9]{3,6}"));//至少三个数字，最多6个
System.out.println(s1.matches("\\d{3,6}"));// \\d 相当于[0-9],和上一行表示相同
//正则表达式方法:验证11位手机号是否规范
System.out.println(s1.matches("[1][3,5,7,8,9][0-9]{9}"));
String s = "bc";
System.out.println(s.matches("[a-z]"));//只能是 一个 小写字母,不能出现两个字母
System.out.println(s.matches("[a-zA-z]"));//表示为任意一个大小写字母
System.out.println(s.matches("[A-z]"));//因为a的值是大于A的值，所以不能表达为[a-Z]
System.out.println(s.matches("\\w*"));// \\w 表示为[A-z0-9_]
String s2 = "ahidc_ajd@qq.com.cn";
//邮箱格式 154sdhsh_54 @ xxx . com
System.out.println(s2.matches("\\w{6,20}@\\w{2,6}\\.(com|com\\.cn)"));
/*注意：
1."."可以代表任意字母数字或者符号,所以把 . 替换为 \\. ---->让其只是单纯的 . 而不是任意的字符
2.使用正则表达式的时候不要轻易添加空格,可能会格式不正确*/
}
}
8.Random类
8.1定义
Random类用于产生随机数
8.2使用规范及代码
package randomdemo;
import java.util.Arrays;
import java.util.Random;
public class RandomDemo {
public static void main(String[] args) {
Random random = new Random();
System.out.println(random.nextInt());//在int类型的取值范围内随机返回一个整数
System.out.println(random.nextBoolean());
System.out.println(random.nextFloat());
System.out.println(random.nextDouble());//在double类型的取值范围内随机返回一个数
System.out.println(random.nextLong());
//在0到指定区间内,随机返回一个数 取值范围:[0,指定数)
System.out.println(random.nextInt(10));//在0到10之间随机返回一个数
//在数组空间中生成随机数
byte[] bytes= new byte[10];//创建一个有10个空间的数组
random.nextBytes(bytes);
System.out.println(Arrays.toString(bytes));//输出
}
}
9.Date类
9.1 定义
java.sql.Date 连接数据库时使用
java.util.Date 一个Date类的对象,表示当前系统运行那一刻的时间
9.2使用方法及源码
package Datedemo;
import java.util.Date;
public class DateDemo {
public static void main(String[] args) {
Date date = new Date();
System.out.println(date);
System.out.println(date.getYear()+1900);//从1900年开始计算
System.out.println(date.getMonth()+1);//在英文中1月记忆为0
System.out.println(date.getDate());//日
System.out.println(date.getDay());//把星期天记为第一周的开始
System.out.println(date.getHours());//时
System.out.println(date.getMinutes());//分
System.out.println(date.getSeconds());//秒
//getTime 获得的是从 1970.1.1 0.0.0.秒 到 date对象创建时 所有的毫秒值
System.out.println(date.getTime());
Date date1 = new Date();
System.out.println(date1.getTime()-date.getTime());//获得两次时间的 毫秒差
Date date2 = new Date(1739430660659l);//将毫秒差还原成某一时间
System.out.println(date2);
}
}
10.Calendar 类
10.1定义:
相比起Date类中方法,更加全面
使用时调用 getInstance() 方法
10.2使用方法及源码
举例:
package Calendardemo;
import java.util.Calendar;
public class CalendarDemo {
public static void main(String[] args) {
//创建一个日历对象
Calendar calendar= Calendar.getInstance();//获得Calender的一个子类对象GregorianCalendar
//时间表示
System.out.println(calendar.get(Calendar.YEAR));//年
System.out.println(calendar.get(Calendar.MONTH)+1);//月
System.out.println(calendar.get(Calendar.DAY_OF_MONTH));//日
System.out.println(calendar.get(Calendar.HOUR));//时 12小时制
System.out.println(calendar.get(Calendar.HOUR_OF_DAY));//时 24小时制
System.out.println(calendar.get(Calendar.MINUTE));//分
System.out.println(calendar.get(Calendar.SECOND));//秒
//第... 中第...
System.out.println(calendar.get(Calendar.WEEK_OF_MONTH));//月中的第几周
System.out.println(calendar.get(Calendar.DAY_OF_WEEK));//周中的第多少天
System.out.println(calendar.get(Calendar.DAY_OF_YEAR));//今年的第多少天
//其他表达省略.....
//相当于Date类中的getTime()方法 获得的是从 1970.1.1 0.0.0.秒 到 date对象创建时 所有的毫秒值
System.out.println(calendar.getTimeInMillis());
}
}
11.SimpleDateFormat 类
11.1定义
日期格式化 (java.text)
1.将日期类型转为指定格式的字符串 format()
2.将指定格式的字符串转为日期类型 parse()
11.2方法及源码
举例:
package SimpleDateFormatdemo;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDateFormatDemo {
public static void main(String[] args) throws ParseException {
Date date = new Date();
//将日期类型 转为字符串类型 年 月 日 时 分 秒 毫秒 星期
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss S E");
String s1= simpleDateFormat.format(date);
System.out.println(s1);
//将字符串类型转为日期类型
String dateStr = "2002-02-02";
SimpleDateFormat simpleDateFormat1= new SimpleDateFormat("yyyy-MM-dd");
Date date1 = simpleDateFormat1.parse(dateStr);
System.out.println(date1);
}
}
11.3格式化表达:
12. BigInteger 类
12.1 定义
BigInteger类型是一个数字范围比Integer , Long类型的数字范围大得多的类型，它支持任意精度的整数，即 在运算中 BigInteger 类型可以准确地表示任何大小的整数值而不会丢失任何息。
12.2使用方法及源码
package BigIntegerdemo;
import java.math.BigInteger;
public class BigIntegerDemo {
public static void main(String[] args) {
System.out.println(Long.MAX_VALUE);
BigInteger bigInteger1 = new BigInteger("9999999999999999999999");
BigInteger bigInteger2 = new BigInteger("1111111111111111111111");
//加法
BigInteger bigInteger3 = bigInteger1.add(bigInteger2);
System.out.println(bigInteger3);
//乘法
BigInteger bigInteger4 = bigInteger1.multiply(bigInteger2);
System.out.println(bigInteger4);
//其他方法省略......
}
}
13.BigDecimal 类
13.1定义
问题: 在计算机中,float 和 double 都是浮点数 , 而计算机是二进制的，浮点数会失去一定的精确度 (根本原因是 十进制浮点值没有完全与之相同的二进制形式 , 十进制浮点值的二进制表示形式不精确,只能无限接近于那个值.)
举例 : 在金融项目这种情况很危险，例如涉及金额的计算 , 都必须十分精确，如果你的支付宝账户余额显示 193.99999999999998，那是一种怎么样的体验？
解决方法 : 使用BigDecimal类中的方法进行运算
13.2使用方法及源码
package BigDecimaldemo;
import java.math.BigDecimal;
public class BigDecimalDemo {
public static void main(String[] args) {
//System.out.println(0.1+0.2);//0.30000000000000004
//浮点数运算
BigDecimal bigDecimal1 = new BigDecimal("0.1");
BigDecimal bigDecimal2 = new BigDecimal("0.2");
BigDecimal bigDecimal3 = bigDecimal1.add(bigDecimal2);
System.out.println(bigDecimal3);
BigDecimal bigDecimal4 = new BigDecimal("10");
BigDecimal bigDecimal5 = new BigDecimal("3");
BigDecimal bigDecimal6 = bigDecimal4.divide(bigDecimal5,3,3);
//方法.(要操作的变量,保留小数的位数,进位的模式 )
System.out.println(bigDecimal6);
}
}