Java第四天基础学习
1. Math
2. System
3. Object
4. Objects
5. BigDecimal
6. 包装类
7. Date
8. SimpleDateFormat
9. Calendar
Math
实现数学运算的工具类
常用方法：
1.int abs(int a ):绝对返回值
2.double ceil(doublr a):向上取整（天花板）
3.double floor(double a):向下取整（地板）
4.int round(float a):四舍五入
5.double pow(double a,double b);计算a的b次方法
package _01Math类;
/*
目标：掌握Math类的基本使用
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 double pow(double a,double b) : 计算a的b次方法
*/
public class Demo1 {
public static void main(String[] args) {
//返回绝对值
//public static int abs(int a)
int num = Math.abs(-2);
System.out.println("num = " + num);
System.out.println( Math.abs(-3.14) );
//向上取整（天花板）
System.out.println( Math.ceil(3.004) ); //4.0
System.out.println( Math.ceil(3.499) ); //4.0
System.out.println( Math.ceil(3.999) ); //4.0
//向下取整（地板）
System.out.println( Math.floor(3.14) );
System.out.println( Math.floor(3.5001) );
System.out.println( Math.floor(3.9999) );
//四舍五入
System.out.println( Math.round(3.14) );
System.out.println( Math.round(3.499) );
System.out.println( Math.round(3.501) );
System.out.println( Math.round(3.999) );
//public static double pow(double a,double b) : 计算a的b次方 幂
System.out.println( Math.pow(2,3) ); //8.0 2*2*2
System.out.println( Math.pow(2,10) ); //2的10次方 1024.0
int max = Math.max(2, 5);
System.out.println("max = " + max);
}
}
System
代表当前系统的类
常用方法：
1.static void exit(int status)强制退出虚拟机
2.static long currentTimeMillis();获取系统时间（毫秒值）
3.arraycopy(原数组，拷贝的开始索引，新数组，放到新数组的开始索引，拷贝个数)；拷贝数组
package _02System类;
/*
目标：学习System类的常用方法
System类介绍：
System系统类，代表当前Java程序的运行平台。
? 常用方法：
static void exit(int status) 强制退出虚拟机
static long currentTimeMillis() :获取系统时间（毫秒值）
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 拷贝数组
*/
public class Demo1 {
public static void main(String[] args) {
//static void exit(int status) 强制退出虚拟机
/* System.out.println(1);
System.exit(0); //退出JVM
System.out.println(1);
System.out.println(1);*/
//static long currentTimeMillis() :获取系统时间（毫秒值）
//long time = System.currentTimeMillis();
//System.out.println("time = " + time); //从1970年1月1日
//计算某段代码的执行时间（帮助进行代码的优化）
/*long start = System.currentTimeMillis();
String s = "";
for (int i = 0; i < 100000; i++) {
s+=i;
}
long end = System.currentTimeMillis();
System.out.println( end - start ); //2857 */
long start = System.currentTimeMillis();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100000; i++) {
sb.append(i);
}
String s = sb.toString();
long end = System.currentTimeMillis();
System.out.println( end - start ); //8
}
}
package _02System类;
import java.util.Arrays;
public class Demo2 {
public static void main(String[] args) {
/*
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 拷贝数组
arraycopy(原数组, 拷贝的开始索引, 新数组, 放到新数组的开始索引, 拷贝个数)
*/
int[] arr = {1, 2, 3, 4, 5};
int[] newArr = new int[arr.length];
System.arraycopy(arr, 0, newArr, 0, arr.length);
System.out.println(Arrays.toString(newArr));
int[] arr2 = new int[10];
//把arr的部分元素拷贝到arr2中，效果如下：[0, 0, 0, 2, 3, 4, 0, 0, 0, 0]
System.arraycopy(arr,1,arr2,3,3);
System.out.println(Arrays.toString(arr2));
}
}
Object
所有java类的根类。任何类都默认或者直接继承Object
常用方法：
1.toString
得到的是对象的地址值，格式为"类全名@16进制地址值"。
一般会重写toString方法，以便打印对象中的具体数据
2.equals
默认使用==比较两个对象的地址值
如果想要比较对象的内容，需要重写该方法
package _03Object类;
/*
目标：学习Object类的使用
1.Object类特点
2.Object类方法：
public String toString()
打印对象的地址值，输出对象名时，默认就是调用了toString方法
如果想打印对象的成员变量的值，需要重写toString方法
public boolean equals(Object obj)
比较两个对象是否相等，默认比较使用==比较两个对象地址值。
如果想比较对象的内容，需要重写该方法
*/
public class Demo1 {
public static void main(String[] args) {
Student s = new Student("张三",20);
System.out.println(s); //默认打印地址 _03Object类.Student@3f3afe78
System.out.println(s.toString()); //默认打印地址 _03Object类.Student@3f3afe78
//ArrayList<Integer> list = new ArrayList<>();
//list.add(1);
//list.add(2);
//System.out.println(list); //打印集合对象，是打印元素，所以说明ArrayList中重写了toString方法
}
}
package _03Object类;
public class Demo2 {
public static void main(String[] args) {
Student s1 = new Student("柳岩" ,25);
Student s2 = new Student("柳岩" ,25);
System.out.println( s1.equals(s2) ); //默认比较地址，false
//比较对象的属性值（重写类的equals方法）
}
}
package _03Object类;
import java.util.Objects;
public class Student{
String name;
int age;
public Student(){}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//如果想打印对象的成员变量的值，需要重写toString方法
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
//重写的equals方法，作用比较对象的姓名和年龄
@Override
public boolean equals(Object o) {
//如果两个对象相同，返回true
if (this == o) {
return true;
}
//this.getClass() 获取对象的类型
//如果参数为null 或者 比较的两个对象不是同一个类型，返回false
if (o == null || this.getClass() != o.getClass()) {
return false;
}
//强转
Student student = (Student) o;
//比较两个对象的年龄和姓名，如果都相同，返回true
return this.age == student.age &&
//this.name.equals(student.name); //如果this.name为null，会有空指针异常
Objects.equals(this.name, student.name); //避免空指针异常
}
}
Objects
equals(对象1，对象2)：
调用对象自身的equals方法，比较两个对象是否相同
好处：避免空指针异常
package _04Objects类;
import java.util.Objects;
/*
目标：了解Objects类的基本使用
1.Objects类介绍:
Objects类是JDK7新增的工具类，方便对对象进行操作。
2.常用方法：
static boolean equals(Object a, Object b) ：避免空指针异常
static boolean isNull(Object obj)：判断对象是否为空
*/
public class Demo1 {
public static void main(String[] args) {
String s1 = null;
String s2 = null;
System.out.println(Objects.equals(s1, s2));
//底层还是调用参数自身的equals方法比较，但是比较前会进行非空的判断，
//可以避免空指针异常
if(s1!=null) {
System.out.println(s1.equals(s2));
}
}
}
BigDecimal
创建对象：
构造方法创建对象：BigDecimal(String val)
静态方法创建对象：BigDecimal.valueOf（数据值）
常用方法：
相加：BigDecimal add(BigDecimal b)
相减：BigDecimal subtract(BigDecimal b)
相乘：BigDecimal multiply(BigDecimal b)
相除（能整除）:BigDecimal divide(BigDecimal b)
相除（不能整除）:public BigDecimal divide(另一个BigDecimal对象，保留位数，舍入模式)
舍入模式通常使用RoundingMode.HALF_UP，表示四舍五入
package _05BigDecimal类;
import java.math.BigDecimal;
/*
目标：掌握BigDecimal类的加减乘除方法
1.创建对象的方式：
BigDecimal(String val) （推荐）
BigDecimal(double val) 有精度问题，不要使用
valueOf()的静态方法创建对象（推荐）
*/
public class Demo1 {
public static void main(String[] args) {
//计算机中，浮点数的存储无法保证所有数字都能精确存储
//System.out.println(0.1 + 0.2); //0.30000000000000004
//构造方法参数是字符串（推荐方式）
BigDecimal b1 = new BigDecimal("0.1"); //相当于double b1 = 0.1;
System.out.println( b1 ); //0.1
/*double d = 0.1;
BigDecimal b2 = new BigDecimal(d); //0.1000000000000000055511151231257827021181583404541015625
System.out.println(b2);*/
double d = 0.1;
BigDecimal b2 = new BigDecimal(d+"");
System.out.println( b2 ); //0.1
//valueOf()的静态方法
BigDecimal b3 = BigDecimal.valueOf(d);
System.out.println(b3);
}
}
package _05BigDecimal类;
import java.math.BigDecimal;
import java.math.RoundingMode;
/*
2.常用方法：
相加：BigDecimal add(BigDecimal b)
相减：BigDecimal subtract(BigDecimal b)
相乘：BigDecimal multiply(BigDecimal b)
相除：BigDecimal divide(BigDecimal b)
*/
public class Demo2 {
public static void main(String[] args) {
BigDecimal b1 = new BigDecimal("10");
BigDecimal b2 = new BigDecimal("6");
//相加
BigDecimal result = b1.add(b2);// b1+b2
System.out.println(result);
//相减
System.out.println(b1.subtract(b2)); //b1-b2
System.out.println(b2.subtract(b1)); //b2-b1
//相乘
System.out.println(b1.multiply(b2)); //b1*b2
//相除，必须是能整除，否则这个方法会报错
//System.out.println(b1.divide(b2)); //b1/b2
//如果不能整除，需要使用重载的方法
//divide(除数，保留的小数位，进行舍入的模式);
//RoundingMode.HALF_UP是四舍五入
System.out.println(b1.divide(b2, 3, RoundingMode.HALF_UP));//四舍五入保留3位小数
}
}
包装类
基本类型的包装类：
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
基本类型转字符串：
利用包装类提供的toString方法
字符串转基本类型：
除了Character之外，其他包装类都有parseXxx(String s)的静态方法可以将字符串转为基本类型
Integer.parseInt(“5”);
Double.parseDouble(“3.14”);
package _06包装类的应用_重点;
/*
目标：学习包装类的应用
八种基本类型对应的包装类：
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
包装类的作用：
Java的基本类型只能用于运算，而包装类能以面向对象的方式操作数据。
*/
public class Demo1 {
public static void main(String[] args) {
}
}
package _06包装类的应用_重点;
/*
包装类的应用
1.包装类作为泛型。
2.基本类型转字符串。
3.字符串转基本类型。（重点）
*/
public class Demo2 {
public static void main(String[] args) {
//2.基本类型转字符串。
int a = 10;
String s = Integer.toString(a);
double d = 3.14;
String s1 = Double.toString(d);
//将基本类型和字符串拼接
String s2 = a + "";
//3.字符串转基本类型。（重点）
String number = "10";
//int num = number;
int num = Integer.parseInt(number);
System.out.println(num-5);
double v = Double.parseDouble("5.5");
System.out.println(v);
boolean b = Boolean.parseBoolean("true");
//字符串转字符
String str = "A";
char ch = str.charAt(0);
//使用包装类可以访问一些封装好的数据，比如获取类型的最大和最小值
System.out.println( Byte.MAX_VALUE );
System.out.println( Byte.MIN_VALUE );
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
//定义变量
int i = 10;
Integer obj = new Integer(10);
}
}
自动
自动装箱，自动拆箱
package _07自动装箱和拆箱_了解;
/*
目标：了解自动装箱和拆箱
1.装箱和拆箱
装箱：基本数据类型转换为包装类的过程。
拆箱：包装类转换为基本数据类型的过程。
2.自动装箱和拆箱
自动完成基本类型和包装类的转换
*/
public class Demo1 {
public static void main(String[] args) {
int i = 10;
Integer obj = i; //自动装箱，自动完成将基本类型转为引用类型 Integer.valueOf(i);
int ii = obj; //自动拆箱，完成将引用类型转为基本类型 obj.intValue();
/*
int i = 10;
Integer obj = Integer.valueOf(i); //手动装箱
int ii = obj.intValue();
*/
//Double obj2 = Double.valueOf(3.4); //数字转为对象 装箱
//double d = obj2.doubleValue(); //对象变为基本类型 拆箱
//底层自动完成转换
Double obj2 = 3.4;
double d = obj2;
}
}
package _07自动装箱和拆箱_了解;
public class Student {
//考试成绩，默认值（null比较合理）
double score1; //0.0
Double score2; //null
}
class Test{
public static void main(String[] args) {
Student s = new Student();
System.out.println(s.score1);
System.out.println(s.score2);
}
}
Date
获取当前系统时间：
Date d = new Date();
返回当前时间的毫秒值：
getTime();
package _08Date类;
import java.util.Date;
/*
目标：掌握Date类的基本使用
1.Date类的作用：
java.util.Date 代表一个精确的时间，精确到毫秒。
2.构造方法
Date()
Date(long date) : 使用毫秒数创建Date对象（在1970年1月1日 00:00:00 基础上加上指定毫秒数）
3.常用方法
long getTime() ：获取当前时间的毫秒值
void setTime(long time) ：设置时间（在1970年1月1日 00:00:00基础上增加设置的毫秒值）
*/
public class Demo1 {
public static void main(String[] args) {
//创建Date对象
Date d = new Date();
System.out.println(d); //Tue Aug 03 15:06:52 CST 2021
//使用毫秒数创建Date对象（在1970年1月1日 00:00:00 基础上加上指定毫秒数）
//Date d2 = new Date(1000L*60);
//System.out.println(d2); //Thu Jan 01 08:00:01 CST 1970 中国在东8区，在原来基础上加上8小时
//long getTime() ：获取当前时间的毫秒值
long time = d.getTime(); //System.currentTimeMillis(); 效果是一样的
System.out.println(time);
//void setTime(long time) ：设置时间（在1970年1月1日 00:00:00基础上增加设置的毫秒值）
//d.setTime(1000L);
//System.out.println(d);
}
}
SimpleDateFormat
日期格式化（Date转String）
formar(日期对象)
解析日期（String转Date）:
parse(字符串日期)
package _09日期格式化处理;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
目标：能够使用SimpleDateFormat类处理日期格式。
1.构造方法
SimpleDateFormat() 使用默认日期模板创建对象。
SimpleDateFormat(String pattern) 使用指定日期模板创建对象。
2.日期格式化
public final String format(Date date)
3.文本解析
public Date parse(String source)
*/
public class Demo1 {
public static void main(String[] args) {
//SimpleDateFormat() 使用默认日期模板创建对象。
SimpleDateFormat sf = new SimpleDateFormat();
//日期格式化
//public final String format(Date date)
Date d = new Date();
System.out.println(d); //Tue Aug 03 15:39:46 CST 2021
String s = sf.format(d);
System.out.println(s); //2021/8/3 下午3:39
}
}
package _09日期格式化处理;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
目标：能够使用SimpleDateFormat类处理日期格式。
1.构造方法
SimpleDateFormat() 使用默认日期模板创建对象。
SimpleDateFormat(String pattern) 使用指定日期模板创建对象。
2.日期格式化
public final String format(Date date)
3.文本解析
public Date parse(String source)
*/
public class Demo2 {
public static void main(String[] args) throws ParseException {
//使用指定日期模板创建对象。
SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd");
//SimpleDateFormat sf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
//SimpleDateFormat sf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
//SimpleDateFormat sf = new SimpleDateFormat("yyyy年MM月dd日 E a HH时mm分ss秒");
//SimpleDateFormat sf = new SimpleDateFormat("HH:mm E yyyy/MM/dd");
//format() :时间格式化
Date d = new Date();
String s = sf.format(d);
System.out.println(s); //2021-08-03 15:46:04
//parse() :解析时间
String sdate = "1949年10月1日";
SimpleDateFormat sf2 = new SimpleDateFormat("yyyy年MM月dd日"); //指定和要转换的字符串一样的模板
Date dd = sf2.parse(sdate);
System.out.println(dd);
}
}
package _10日期转换练习_秒杀活动;
import java.text.ParseException;
import java.text.SimpleDateFormat;
/*
目标：使用日期转换完成需求。
需求：
秒杀开始时间: 2020年11月11日 00:00:00
秒杀结束时间: 2020年11月11日 00:10:00
小贾下单并付款的时间为：
2020年11月11日 0:03:47
小皮单并付款的时间为：
2020年11月11日 0:10:11
用代码说明这两位同学有没有参加上秒杀活动?
思路：
将字符串时间转为 Date 类型：使用SimpleDateFormat的 parse方法
通过Date对象的getTime方法获取毫秒值
判断付款时间是否在秒杀时间内
*/
public class Demo1 {
public static void main(String[] args) throws ParseException {
//创建转换模板
SimpleDateFormat sf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
//转换字符串为Date对象
//秒杀开始时间的毫秒
long start = sf.parse("2020年11月11日 00:00:00").getTime();
//秒杀结束时间的毫秒
long end = sf.parse("2020年11月11日 00:10:00").getTime();
//小贾的下单时间的毫秒
long xiaoJia = sf.parse("2020年11月11日 0:03:47").getTime();
//小皮的下单时间的毫秒
long xiaoPi = sf.parse("2020年11月11日 0:10:11").getTime();
//判断付款时间是否在秒杀时间内
if(xiaoJia>=start && xiaoJia<=end){
System.out.println("小贾秒杀成功");
}else {
System.out.println("小贾秒杀失败");
}
if(xiaoPi>=start && xiaoPi<=end){
System.out.println("小皮秒杀成功");
}else {
System.out.println("小皮秒杀失败");
}
}
}
Calendar
创建对象：
Calendar.getInstance()
获取指定字段：
get(字段名)
设置指定字段的值：
set(字段名，字段值)
增加或减去字段的值:
add(字段名，字段值)（增加）
add(字段名，-字段值)（减去）
常见字段含义：
年：YEAR
月：MONTH（0-11表示1-12月）
日：DATE或者DAY_OF_MONTH
时：HOUR_OF_DAY(24小时)
分：MINUTE
秒：SECOND
周几：DAY_OF_WEEK(1-7表示周日-周六)
package _11Calendar类;
import java.util.Calendar;
import java.util.Date;
/*
目标：学习Calendar类的常用功能
1.创建对象:
Calendar.getInstance();
2.常用方法：
get(int field) 获取指定日历字段的值
getTime() 将Calendar转为Date对象
getTimeInMillies() 返回该日历时间的毫秒值。
set(int field, int value) 设置某个日历字段的值
set?(int year, int month, int date) 设置年,月,日
add(int field, int amount) 添加或减去某个日历字段的值。
3.常用日历字段含义
年：YEAR
月：MONTH （0~11表示1~12月）
日：DATE 或者 DAY_OF_MONTH
时：HOUR_OF_DAY（24小时）
分：MINUTE
秒：SECOND
周几：DAY_OF_WEEK（1~7表示周日~周六）
*/
public class Demo1 {
public static void main(String[] args) {
//Calendar.getInstance();
Calendar c = Calendar.getInstance(); //获取当前系统的日历对象
//get(int field) 获取指定日历字段的值
int year = c.get(Calendar.YEAR);
System.out.println("year = " + year); //年
int month = c.get(Calendar.MONTH) + 1; //月（0~11表示1~12月）
System.out.println("month = " + month);
int date = c.get(Calendar.DATE); //日
System.out.println("date = " + date);
//c.get(Calendar.HOUR);//12小时制的时间
int hour = c.get(Calendar.HOUR_OF_DAY);//24小时制的时间
System.out.println("hour = " + hour);
int minute = c.get(Calendar.MINUTE);
System.out.println("minute = " + minute);
int second = c.get(Calendar.SECOND);
System.out.println("second = " + second);
//周几：DAY_OF_WEEK（1~7表示周日~周六）
int week = c.get(Calendar.DAY_OF_WEEK)-1;
String[] weeks = {"星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
System.out.println(weeks[week]);
//getTime() 将Calendar转为Date对象
Date d = c.getTime();
System.out.println(d);
//getTimeInMillies() 返回该日历时间的毫秒值。
long mills = c.getTimeInMillis();
System.out.println(mills);
//获取当前系统毫秒值（3个方法）
//System.currentTimeMillis();
//new Date().getTime();
//Calendar.getInstance().getTimeInMillis();
}
}
package _11Calendar类;
import java.util.Calendar;
/*
set(int field, int value) 设置某个日历字段的值
set?(int year, int month, int date) 设置年,月,日
add(int field, int amount) 添加或减去某个日历字段的值。
*/
public class Demo2 {
public static void main(String[] args) {
//set(字段名, 字段值) 设置某个日历字段的值
//北京奥运会2008年8月8日 当天是星期几
Calendar c = Calendar.getInstance();
c.set(2008, 7,8);
int week = c.get(Calendar.DAY_OF_WEEK)-1;
String[] weeks = {"星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
System.out.println(weeks[week]); //星期五
//add(字段名, 字段值) 添加或减去某个日历字段的值。
//字段值正数，往后加，负数，往前减
//100天前是几月几号
Calendar cal = Calendar.getInstance();
cal.add(Calendar.DATE,-100);
int month = cal.get(Calendar.MONTH) + 1;
int date = cal.get(Calendar.DATE);
System.out.println(month+"月"+date+"日");
}
}
综合练习
package _12日期综合练习_年龄天数计算;
import java.util.Calendar;
/*
计算从出生到现在，总共过了多少天？
将日期设置到出生当天，转为毫秒值 a
获取当前时间的毫秒值 b
b -a 总共到目前活了多少毫秒，转为天数
*/
public class Demo {
public static void main(String[] args) {
//将日期设置到出生当天
Calendar c = Calendar.getInstance();
//假设出生日期是1995/9/9
c.set(1995, 8, 9);
long birthday = c.getTimeInMillis();
//获取当前时间的毫秒值
long now = Calendar.getInstance().getTimeInMillis();
//计算总共到目前活了多少毫秒，转为天数
long days = (now - birthday) / 1000 / 60 / 60 / 24;
System.out.println(days); //9460
}
}
总结！！！！！
package _13总结;
/*
能够说出Object类的特点
Object是java的根类，是所有类的父类
能够重写Object类的toString方法
toString：默认打印对象的地址值，可以重写方法，打印对象的属性值。
能够重写Object类的equals方法
equals：默认比较两个对象的地址值，可以重写方法，比较两个对象的属性值。
String类的equals方法，就是重写过的方法，比较字符串的内容。
能够使用System类获取当前系统毫秒值
System.currentTimeMillis();
能够说出BigDecimal可以解决的问题
解决浮点数运算的精度问题
创建对象 new BigDecimal(字符串数字) 或者 BigDecimal.valueOf(基本类型数字)
能够说出自动装箱、自动拆箱的概念
自动装箱：基本类型转为引用类型
自动拆箱：引用类型转为基本类型
能够将基本类型转换为对应的字符串
int a = 10;
String s = a+""; //方式1
String s = Integer.toString(a); //方式2
能够将字符串转换为对应的基本类型
String s = "10";
int i = Integer.parseInt(s);
能够使用日期类输出当前日期
Date d = new Date();
能够使用将日期格式化为字符串的方法
SimpleDateFormat sf = new SimpleDateFormat("日期模板");
Date d = new Date();
String s = sf.format(d);
能够使用将字符串转换成日期的方法
SimpleDateFormat sf = new SimpleDateFormat("日期模板");
Date d = sf.parse("字符串日期");
*/
public class Demo {
public static void main(String[] args) {
}
}
思维导图：
