JavaSE进阶6之常用API
API 应用程序编程接口
Object类
- 一个类要么默认继承了Object类，要么间接继承了Object类，Object类是Java中的祖宗类
- Object类的方法是一切子类都可以直接使用的
Object类常用方法
- public String toString()
默认是返回当前对象在堆内存中的地址信息：类的全限名@内存地址
开发中直接输出对象，默认输出对象的地址其实是毫无意义的
开发中输出对象变量，更多的时候是希望看到对象的内容数据而不是对象的地址信息toString存在的意义:
- 父类toString()方法存在的意义就是为了被子类重写，以便返回对象的内容信息，而不是地址信息
public class Student { //extends Object
private String name;
private int age;
private char sex;
public Student() {
}
public Student(String name, int age, char sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
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;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
}
public class StudentPro {
private String name;
private int age;
private char sex;
public StudentPro() {
}
public StudentPro(String name, int age, char sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
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;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
@Override
public String toString() {
return "StudentPro{" +
"name='" + name + '\'' +
", age=" + age +
", sex=" + sex +
'}';
}
}
public class demo {
public static void main(String[] args) {
Student student = new Student("张三", 20, '女');
System.out.println(student.toString());
System.out.println(student); //两个输出情况一致
StudentPro s1 = new StudentPro("李四", 21, '男');
System.out.println(s1.toString());
}
}
2. public Boolean equals(Object o)默认是比较当前对象与另一个对象的地址是否相同，相同返回true,不同返回false
直接比较两个对象的地址是否相同完全可以用”==“替代equals
equals存在的意义
- 父类equals方法存在的意义就是为了被子类重写，以便子类自己来定制比较规则
public class StudentPro {
private String name;
private int age;
private char sex;
public StudentPro() {
}
public StudentPro(String name, int age, char sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
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;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
@Override
public String toString() {
return "StudentPro{" +
"name='" + name + '\'' +
", age=" + age +
", sex=" + sex +
'}';
}
//自己重写的比较值的方法
@Override
public boolean equals(Object o){
if(o instanceof StudentPro){
StudentPro s=(StudentPro) o;
return name.equals(s.name)&&age==s.age&&sex==s.sex;
}
else{
return false;
}
}
}
public class StudentMaxPro {
private String name;
private int age;
private char sex;
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;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public StudentMaxPro() {
}
public StudentMaxPro(String name, int age, char sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
@Override
public String toString() {
return "StudentMaxPro{" +
"name='" + name + '\'' +
", age=" + age +
", sex=" + sex +
'}';
}
@Override //官方生成的equals
public boolean equals(Object o) {
//判断是否是同一个对象，是直接返回true
if (this == o) return true;
//如果o为空直接返回false, 或者 本类和参数类不一致 返回false
if (o == null || getClass() != o.getClass()) return false;
//强制类型转换
StudentMaxPro that = (StudentMaxPro) o;
//对比每个参数值是否相同
return age == that.age && sex == that.sex && Objects.equals(name, that.name);
}
}
public class demo1 {
public static void main(String[] args) {
Student s1 = new Student("张三", 20, '男');
Student s2 = new Student("张三", 20, '男');
//默认是直接比较两个对象的地址是否一样
System.out.println(s1.equals(s2));
System.out.println(s1==s2);
System.out.println("----------------------------------------");
StudentPro s3 = new StudentPro("李四", 21, '男');
StudentPro s4 = new StudentPro("李四", 21, '男');
System.out.println(s3.equals(s4));
System.out.println("----------------------------------------");
StudentMaxPro s5 = new StudentMaxPro("王五", 22, '女');
StudentMaxPro s6 = new StudentMaxPro("王五", 22, '女');
System.out.println(s5.equals(s6));
}
}
Objects类
Objects类与Object还是继承关系
Objects类的equals有非空校验，更安全，不会出现空指针异常
- public static boolean equals(Object a,Object b)
比较两个对象的，底层会先进行非空判断，从而可以避免空指针异常，再进行equals比较 - public static boolean isNull(Object obj)
判断变量是否为null,为null返回true,反之false
public class demo2 {
public static void main(String[] args) {
String s1="zhangsan";
String s2=new String("zhangsan");
String s3=null;
System.out.println(Objects.equals(s1,s2));
System.out.println(Objects.equals(s1,s3));
/*
public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}
*/
System.out.println(Objects.isNull(s1));
System.out.println(Objects.isNull(s3));
System.out.println(s3==null); //两种写法效果一致
}
}
StringBuilder
- StringBuilder是一个可变的字符串类，我们可以把它看成一个对象容器
- 作用：提高字符串的操作效率，如拼接、修改等
- public StringBuilder()
创建一个空白的可变的字符串对象，不包含任何内容 - public StringBuilder(String str)
创建一个指定字符串内容的可变字符串对象 - public StringBuilder append(任意类型）
添加数据并返回StringBuilder对象本身 - public StringBuilder reverse()
将对象的内容反转 - public int length()
返回对象内容长度 - public String toString()
通过toString()就可以实现把StringBuilder转换为String
案例：打印整型数组内容
需求
设计一个方法用于输出任意整型数组的内容，要求输出成如下格式：
“该数组内容为：[11,22,33,44,55]”
分析
- 定义一个方法，要求该方法能够拼接数组，并输出数组内容
- 定义一个静态初始化的数组，调用该方法，并传入该数组
public class Demo1 {
public static void main(String[] args) {
int[] a=null;
System.out.println("该数组内容为："+pin(a));
int[] b={11,22,33,44,55};
System.out.println("该数组内容为："+pin(b));
int[] c={};
System.out.println("该数组内容为："+pin(c));
}
public static String pin(int[] a){
if(a!=null){
StringBuilder abc=new StringBuilder();
abc.append("[");
for (int i = 0; i < a.length; i++) {
abc.append(a[i]).append(i==a.length-1?"":",");
}
abc.append("]");
return abc.toString();
}else
return null;
}
}
Math类
- 包含执行基本数字运算的方法，Math类没有提供公开的构造器
- Math中的方法都是静态方法，通过类名就可以调用
- public static int abs(int a)
获取参数的绝对值 - public static double ceil(double a)
向上取整 - public static double floor(double a)
向下取整 - public static int round(float a)
四舍五入 - public static int max(int a,int b)
获取两个int值中的较大值 - public static double pow(double a,double b)
返回a的b次幂的值 - public static double random()
返回值为double的随机值，范围[0.0,1.0)
public class demo2 {
public static void main(String[] args) {
System.out.println("Math.abs(10.5):"+Math.abs(10.5));
System.out.println("Math.abs(-10.5):"+Math.abs(-10.5));
System.out.println("-----------------------");
System.out.println("Math.ceil(4.1):"+Math.ceil(4.1));
System.out.println("Math.ceil(4.6):"+Math.ceil(4.6));
System.out.println("----------------------");
System.out.println("Math.floor(4.7):"+Math.floor(4.7));
System.out.println("Math.floor(5.1):"+Math.floor(5.1));
System.out.println("----------------------");
System.out.println("Math.round(4.4999):"+Math.round(4.4999));
System.out.println("Math.round(4.5111):"+Math.round(4.5111));
System.out.println("Math.max(4,8):"+Math.max(4,8));
System.out.println("Math.max(15,7):"+Math.max(15,7));
System.out.println("Math.pow(2,3):"+Math.pow(2,3));
System.out.println("Math.pow(2,10):"+Math.pow(2,10));
System.out.println("------------------------");
System.out.println("Math.random():"+Math.random());
System.out.println("Math.random():"+Math.random());
System.out.println("-----------------------");
System.out.println("输出 3-9 的随机数：");
//3-9的随机数—— （0-6的随机数）+3
System.out.println((int)(Math.random() * 7) + 3);
System.out.println((int)(Math.random() * 7) + 3);
//36-69的随机数：（0-33)的随机数+36
System.out.println("输出36-69的随机数：");
System.out.println((int) (Math.random() * 34) + 36);
System.out.println((int) (Math.random() * 34) + 36);
System.out.println((int) (Math.random() * 34) + 36);
}
}
System类
- System的功能是通用的，都是直接用类名调用即可，所以System不能被实例化
- public static void exit(int status)
终止当前运行的Java虚拟机，非零表示异常终止 - public static long currentTimeMillis()
返回当前系统的时间毫秒值形式 - public static void arraycopy(数据源数组，起始索引，目的地数组，起始索引，拷贝个数)
数组拷贝
时间毫秒值
- 计算机认为时间是有起点的，起始时间：1970年1月1日 00:00:00
- 时间毫秒值：指的是从1970年1月1日 00:00:00走到此刻的总毫秒数
1s=1000ms
public class demo1 {
public static void main(String[] args) {
System.out.println("程序开始.....");
System.exit(0);
System.out.println("程序终止.....");
}
}
public class demo2 {
public static void main(String[] args) {
System.out.println("程序开始。。。。。");
long startTime=System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
}
long endTime=System.currentTimeMillis();
double all=(endTime-startTime)/1000.0;
System.out.println("执行100000次循环需要花费："+all+"s");
int[] a={10,20,30,40,50,60,70};
int[] b=new int[10];
/*
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
*/
System.arraycopy(a,2,b,3,4);
System.out.println(Arrays.toString(b));
}
}
BigDecimal类
- 用于解决浮点型运算精度失真的问题
使用步骤 - 创建对象BigDecimal封装浮点型数据（最好的方式是调用方法）
- public static BigDecimal valueOf(double val);
- 包装浮点数成为BigDecimal对象
- public BigDecimal add(BigDecimal b)
加法 - public BigDecimal subtract(BigDecimal b)
减法 - public BigDecimal multiply(BigDecimal b)
乘法 - public BigDecimal divide(BigDecimal b)
除法 - public BigDecimal divide(另一个BigDecimal对象，精确几位，舍入模式）
除法
public class demo3 {
public static void main(String[] args) {
//计算机计算时候会出现失真现象
System.out.println("0.1+0.2："+(0.1+0.2));
System.out.println("0.3+0.55："+(0.3+0.55));
System.out.println("1.0-0.32："+(1.0-0.32));
System.out.println("----------------------");
double a=0.1;
double b=0.2;
double c=a+b;
System.out.println(c);
System.out.println("----------------------");
BigDecimal a1=BigDecimal.valueOf(0.1);
BigDecimal b1=BigDecimal.valueOf(0.2);
BigDecimal c1=a1.add(b1);
BigDecimal d1=b1.subtract(a1);
BigDecimal e1=a1.multiply(b1);
BigDecimal f1=a1.divide(b1);
System.out.println("a1.add(b1)："+c1);
System.out.println("b1.subtract(a1)："+d1);
System.out.println("a1.multiply(b1)："+e1);
System.out.println("a1.divide(b1)："+f1);
//转成浮点型
double first=a1.doubleValue();
double twice=b1.doubleValue();
System.out.println("0.1+0.2："+first+twice);
System.out.println("---------------------");
BigDecimal a11=BigDecimal.valueOf(10.0);
BigDecimal b11=BigDecimal.valueOf(3.0);
BigDecimal c11 = a11.divide(b11, 4, RoundingMode.UP);
System.out.println(c11);
}
}
Date类
- Date类的对象在Java中代表的是当前所在系统的此刻日期时间
- Date的构造器
public Date() 创建一个Date对象，代表的是系统当前此刻日期时间 - Date的常用方法
public long getTime() 获取时间对象的毫秒值 - 时间毫秒值->日期对象
public Date(long time) 把时间毫秒值转换成Date日期对象
public void setTime(long time) 设置日期对象的时间为当前时间毫秒值对应的时间
案例
- 请计算出当前时间往后走1小时121秒之后的时间是多少
public class demo1 {
public static void main(String[] args) {
Date d=new Date();
long time=(60*60+121)*1000;
Date f=new Date(System.currentTimeMillis()+time);
//时间毫秒值换成日期对象
System.out.println(d);
System.out.println(f);
System.out.println("----------------------------------");
Date e=new Date();
e.setTime(System.currentTimeMillis()+time);
System.out.println(d);
System.out.println(e);
}
}
SimpleDateFormat类
- 可以对Date对象或时间毫秒值格式化成我们喜欢的时间形式
- 也可以把字符串的时间形式解析成日期对象
SimpleDateFormat构造器
- public SimpleDateFormat()
构造一个SimpleDateFormat，使用默认格式 - public SimpleDateFormat(String pattern)
构造一个SimpleDateFormat，使用指定的格式
SimpleDateFormat的格式化方法
- public final String format(Date date)
将日期格式化成日期/时间字符串 - public final String format(Object time)
将时间毫秒值式化成日期/时间字符串
格式化的时间形式的常用的模式对应关系如下：
public class demo2 {
public static void main(String[] args) {
Date d=new Date();
System.out.println(d);
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
SimpleDateFormat sdf1=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE a");
String a=sdf.format(d);
String b=sdf1.format(d);
System.out.println("sdf.format(d)："+a);
System.out.println("sdf1.format(d)："+b);
//将121秒后时间毫秒值转换成日期对象
long time=System.currentTimeMillis()+121*1000;
System.out.println("sdf1.format(System.currentTimeMillis()+121*1000)："+sdf1.format(time));
}
}
SimpleDateFormat解析字符串时间成为日期对象
- public Date parse(String source)
从给定字符串的开始解析文本以生成日期
案例
- 请计算出2022年08月06日11点11分11秒，往后走2天14小时49分06秒后的时间是多少
public class demo4 {
public static void main(String[] args) throws ParseException {
//1.把字符串时间拿到程序中来
String date="2022年08月06日 11:11:11";
//2.把字符串时间解析成日期对象
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
Date f=sdf.parse(date);
//3.往后走2天 14小时 49分 06秒
long time=f.getTime()+(2L*24*60*60+14*60*60+49*60+6)*1000;
//4.格式化这个时间毫秒值就是结果
String dateTime = sdf.format(time);
System.out.println(dateTime);
}
}
练习：秒杀活动
需求：
- 小贾下单并付款的时间为：2020年11月11日 0:03:47
- 小皮下单并付款的时间为：2020年11月11日 0:10:11
- 用代码说明这两位同学有没有参加上秒杀活动
分析
- 判断下单时间是否在开始到结束的范围内
- 把字符串形式的时间变成毫秒值
public class demo5 {
public static void main(String[] args) throws ParseException {
String mStart="2020年11月11日 00:00:00";
String mEnd="2020年11月11日 00:10:00";
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
Date start = sdf.parse(mStart);
Date end= sdf.parse(mEnd);
long sTime=start.getTime();
long eTime=end.getTime();
String jia="2020年11月11日 00:03:47";
Date xj= sdf.parse(jia);
long jtime=xj.getTime();
if(jtime>sTime && jtime<eTime){
System.out.println("小贾参加上秒杀活动了~");
}else{
System.out.println("小贾没有参加上秒杀活动~");
}
String pi="2020年11月11日 00:10:11";
Date xp=sdf.parse(pi);
long ptime=xp.getTime();
if(ptime>sTime&&ptime<eTime){
System.out.println("小皮参加上秒杀活动了~");
}else{
System.out.println("小皮没有参加上秒杀活动~");
}
}
}
方法二
public class demo6 {
public static void main(String[] args) throws ParseException {
String start="2020-11-11 00:00:00";
String end="2020-11-11 00:10:00";
String jia="2020-11-11 00:03:47";
String pi="2020-11-11 00:10:11";
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date s=sdf.parse(start);
Date e=sdf.parse(end);
Date xj=sdf.parse(jia);
Date xp=sdf.parse(pi);
if(xj.after(s)&&xj.before(e)){
System.out.println("小贾秒杀成功，可以发货了~");
}else{
System.out.println("小贾秒杀失败~");
}
if(xp.after(s)&&xp.before(e)){
System.out.println("小皮秒杀成功，可以发货了~");
}else{
System.out.println("小皮秒杀失败~");
}
}
}
Calendar类
- Calendar代表了系统此刻日期对应的日历对象
- Calendar是一个抽象类，不能直接创建对象
Calendar日历创建日历对象的方法
- public static Calendar getInstance()
获取当前日历对象
Calendar常用方法
- public int get(int field)
取日期中的某个字段信息 - public void set(int field,int value)
修改日历的某个字段信息 - public void add(int field,int amount)
为某个字段增加/减少指定的值 - public final Date getTime()
拿到此刻日期对象 - public long getTimeInMillis()
拿到此刻时间毫秒值
注意：Calendar是可变日期对象，一旦修改后其对象本身表示的时间将产生变化
public class demo7 {
public static void main(String[] args) {
Calendar cal=Calendar.getInstance();
int year = cal.get(Calendar.YEAR);
int month=cal.get(Calendar.MONTH)+1; //月是从0开始计算的，所以要加1等于现在的月份
int day=cal.get(Calendar.DAY_OF_MONTH);
System.out.println("获取年："+year);
System.out.println("获取月："+month);
System.out.println("获取日："+day);
//为现在日历增加64天
cal.add(Calendar.DAY_OF_YEAR,64);
System.out.println(cal.get(Calendar.MONTH)+1);
System.out.println(cal.get(Calendar.DAY_OF_YEAR));
//获取日期
Calendar cal1=Calendar.getInstance();
System.out.println(cal1.getTime());
//获取毫秒值
System.out.println(cal1.getTimeInMillis());
}
}
扫一扫
607
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
