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) {
}
}
思维导图: