Math包含执行基本数字运算的方法
没有构造方法，如何使用类中的成员呢？——通过查看帮助文档
看类的成员是否都是静态的，如果是，通过类名就可以直接调用
package com.itheima;
import jdk.swing.interop.SwingInterOpUtils;
/*
Math类的常用方法
*/
public class MathDemo {
public static void main(String[] args) {
//public static int abs(int a),返回参数的绝对值
System.out.println(Math.abs(88));
System.out.println(Math.abs(-88));
System.out.println("--------------");
//public static double ceil (double a),返回大于或等于参数的最小double值，等于一个整数
System.out.println(Math.ceil(12.34));
System.out.println(Math.ceil(12.56));
System.out.println("--------------");
//public static double floor (double a),返回小于或等于参数的最大double值，等于一个整数
System.out.println(Math.floor(12.34));
System.out.println(Math.floor(12.56));
System.out.println("---------------");
//public static int round(float a),按四舍五入返回最接近参数的int
System.out.println(Math.round(12.34F));
System.out.println(Math.round(12.56F));
System.out.println("----------------");
//public static int max(int a,int b),返回两个int值中的较大值
System.out.println(Math.max(66, 88));
System.out.println("----------------");
//public static int min(int a,int b),返回两个int值中的较小值（自学）
System.out.println(Math.min(66, 88));
System.out.println("----------------");
//public static double pow(double a,double b),返回a的b次幂的值
System.out.println(Math.pow(2.0, 8.0));
System.out.println("----------------");
//public static double random(),返回值为double的正值，[0.0,1.0)
System.out.println(Math.random());
System.out.println(Math.random());
System.out.println(Math.random() * 100);
System.out.println(Math.random() * 100);
System.out.println((int)(Math.random() * 100));
System.out.println((int)(Math.random() * 100));
System.out.println((int)(Math.random() * 100)+1);
System.out.println((int)(Math.random() * 100)+1);
System.out.println("******************");
}
}
System包含几个有用的类字段和方法，它不能被实例化
package com.itheima;
public class SystemDemo {
public static void main(String[] args) {
/*System.out.println("开始");
//public static void exit(int status);终止当前运行的Java虚拟机，非零表示异常终止
System.exit(0);
System.out.println("结束");//不打印结束，因为虚拟机已经终止
*/
//public static long currentTimeMillis();返回当前时间（以毫秒为单位）
System.out.println(System.currentTimeMillis() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");
System.out.println("++++++++++++++");
long start = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
System.out.println(i);
}
long end = System.currentTimeMillis();
System.out.println("共耗时：" + (end - start) + "毫秒");
}
}
Object是类层次结构的根，每个类都可以将Object作为超类。所有类都直接或者间接的继承自该类
构造方法：public Object()
回想面向对象中，为什么说子类的构造方法默认访问的是父类的无参构造方法？
因为他们的顶级父类只有无参构造方法
package com.itheima_01;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = 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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package com.itheima_01;
/*
测试类
Object是类层次结构的根，每个类都可以将Object作为超类。所有类都直接或者间接的继承自该类
看方法的源码，选中方法，按下Ctrl+B
建议所有子类重写此方法（toString）
如何重写呢？自动生成即可 Alt+Insert 选中toString然后全选确认
*/
public class ObjectDemo {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("拾叶");
s1.setAge(22);
System.out.println(s1);//com.itheima_01.Student@3ac3fd8b
System.out.println(s1.toString());//com.itheima_01.Student@3ac3fd8b
/*
public void println(Object x) {//x=s
String s = String.valueOf(x);
synchronized (this) {
print(s);
newLine();
}
}
public static String valueOf(Object obj) {obj=x
return (obj == null) ? "null" : obj.toString();
}
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
*/
}
}
package com.itheima_02;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = 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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
/*
this --- s1
o --- s2
*/
//比较地址是否相同，如果相同，直接返回true
if (this == o) return true;
//判断参数是否为null（如果是null，直接返回false）
//判断两个对象是否来自于同一个类
if (o == null || getClass() != o.getClass()) return false;
//向下转型
Student student = (Student) o;//student = s2;
//比较年龄是否相同
if (age != student.age) return false;
//比较姓名内容是否相同
return name != null ? name.equals(student.name) : student.name == null;
}
}
package com.itheima_02;
/*
测试类
public boolean equals (Object obj);提示一些其他对象是否等于此
*/
public class ObjectDemo {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("拾叶");
s1.setAge(22);
System.out.println(s1);//com.itheima_01.Student@3ac3fd8b
System.out.println("------------");
Student s2 = new Student();
s2.setName("拾叶");
s2.setAge(22);
//需求：比较两个对象的内容是否相同
System.out.println(s1 == s2);//false
System.out.println(s1.equals(s2));//false，重写equals之后为true
//此equals方法比较仍然是地址值，需要重写
/*
public boolean equals(Object obj) {
//this --- s1
//obj --- s2
return (this == obj);
}
*/
}
}
排序：将一组数据按照固定的规则进行排列
冒泡排序：一种排序的方式，对要进行排序的数据中心相邻的数据进行两两比较，将较大的数据放在后面，依次对所有数据进行操作，直至所有数据按要求完成排序
其他的同理进行，结果为
package com.itheima_01;
import jdk.swing.interop.SwingInterOpUtils;
/*
冒泡排序：一种排序的方式，对要进行排序的数据中心相邻的数据进行两两比较，将较大的数据放在后面，依次对所有数据进行操作，直至所有数据按要求完成排序
*/
public class ArrayDemo {
public static void main(String[] args) {
//定义一个数组
int[] arr = {24, 69, 80, 57, 13};
System.out.println("排序前：" + arrayToString(arr));
/*
//第一次比较
for (int i = 0; i < arr.length - 1; i++) {
if (arr[i] > arr[i + 1]) {
int temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
System.out.println("第一次比较后：" + arrayToString(arr));
//第二次比较
for (int i = 0; i < arr.length - 1 - 1; i++) {
if (arr[i] > arr[i + 1]) {
int temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
System.out.println("第二次比较后：" + arrayToString(arr));
//第三次比较
for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
if (arr[i] > arr[i + 1]) {
int temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
System.out.println("第三次比较后：" + arrayToString(arr));
//第四次比较
for (int i = 0; i < arr.length - 1 - 1 - 1 - 1; i++) {
if (arr[i] > arr[i + 1]) {
int temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
System.out.println("第四次比较后：" + arrayToString(arr));*/
for (int x = 0; x < arr.length - 1; x++) {
//第x次比较
for (int i = 0; i < arr.length - 1 - x; i++) {
if (arr[i] > arr[i + 1]) {
int temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
System.out.println("第" + (x + 1) + "次比较后：" + arrayToString(arr));
}
System.out.println("排序后：" + arrayToString(arr));
}
//把数组中的元素按照指定的规则组成一个字符串：[元素1， 元素2， ...元素n]
public static String arrayToString(int[] arr) {
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("[");
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
stringBuilder.append(arr[i]);
} else {
stringBuilder.append(arr[i]).append(", ");
}
}
stringBuilder.append("]");
String s = stringBuilder.toString();
return s;
}
}
Arrays类包含用于数组操作的各种方法
package com.itheima_02;
import java.util.Arrays;
public class ArraysDemo {
public static void main(String[] args) {
//定义一个数组
int[] arr = {24,69,80,57,13};
System.out.println("排序前："+ Arrays.toString(arr));
Arrays.sort(arr);
System.out.println("排序后："+Arrays.toString(arr));
}
}
工具类的设计思想：
将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据
常用的操作之一：用于基本数据类型与字符串之间的转换
Integer：包装一个对象中的原始类型int的值
（请注意，这里是.valueOf，不是.getInteger，后者功能不同，自己可以搜到）
package com.itheima_02;
/*
构造方法：
public Integer(int value);根据int值创建Integer对象（过时）
public Integer(String s);根据String值创建Integer对象（过时）
静态方法获取对象：
public static Integer valueOf (int i);返回表示指定的int值的Integer实例
public static Integer valueOf (String s);返回一个保存指定值的Integer对象String
*/
public class IntegerDemo {
public static void main(String[] args) {
//public Integer(int value);根据int值创建Integer对象（过时）
Integer i1 = new Integer(100);
System.out.println(i1);
//public Integer(String s);根据String值创建Integer对象（过时）
Integer i2 = new Integer("100");//这里的字符串要由数字组成的！
//Integer i3 = new Integer("拾叶");//报错NumberFormatException
System.out.println(i2);
System.out.println("===============");
//public static Integer valueOf (int i);返回表示指定的int值的Integer实例
Integer i3 = Integer.valueOf(100);
System.out.println(i3);
//public static Integer valueOf (String s);返回一个保存指定值的Integer对象String
Integer i4 = Integer.valueOf("100");//也只能用数字组成的字符串
//Integer i5 = Integer.valueOf("拾叶");//NumberFormatException
System.out.println(i4);
}
}
基本类型包装类的最常见的操作就是：用于基本类型和字符串之间的相互转换
public static String valueOf(int i);：返回int参数的字符串表示形式。该方法是String类中的方法
public static int parselnt(String s);：将字符串解析为int类型。该方法是Integer类中的方法
需求：有一个字符串：“91 27 46 38 50”，请写程序实现最终输出结果是：“27 38 46 50 91”
思路：
定义一个字符串
把字符串中的数字数据存储到一个int类型的数组中
得到字符串中每一个数字数据
public String[] split(String regex)
定义一个int数组，把String[]数组中的每一个元素存储到int数组中
public static int parselnt(String s)对int数组进行排序
把排序后的int数组中的元素进行拼接得到一个字符串，这里拼接采用StringBuilder来实现
输出结果
package com.itheima_03;
import java.util.Arrays;
/*
1. 定义一个字符串
2. 把字符串中的数字数据存储到一个int类型的数组中
- 得到字符串中每一个数字数据
- `public String[] split(String regex)`
- 定义一个int数组，把String[]数组中的每一个元素存储到int数组中
- `public static int parselnt(String s)`
3. 对int数组进行排序
4. 把排序后的int数组中的元素进行拼接得到一个字符串，这里拼接采用StringBuilder来实现
5. 输出结果
*/
public class IntegerTest {
public static void main(String[] args) {
//定义一个字符串
String s = "91 27 46 38 50";
//把字符串中的数字数据存储到一个int类型的数组中
String[] strArray = s.split(" ");
for (int i = 0; i < strArray.length; i++) {
System.out.println(strArray[i]);
}
System.out.println("===========");
//定义一个int数组，把String[]数组中的每一个元素存储到int数组中
int[] arr = new int[strArray.length];
for (int i = 0; i < arr.length; i++) {
arr[i] = Integer.parseInt(strArray[i]);
}
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
System.out.println("===========");
//对int数组进行排序
Arrays.sort(arr);
//把排序后的int数组中的元素进行拼接得到一个字符串，这里拼接采用StringBuilder来实现
StringBuilder sb = new StringBuilder();
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
sb.append(arr[i]);
} else {
sb.append(arr[i]).append(" ");
}
}
String result = sb.toString();
//输出结果
System.out.println("result:" + result);
}
}
Integer i = 100;//自动装箱
i += 200;//i = i + 200;i+200自动拆箱；i = i + 200;是自动装箱
注意：在使用包装类类型的时候，如果做操作，最好先判断是否为null
我们推荐的是，只要是对象，在使用前就必须进行不为null的判断
package com.itheima_04;
/*
- 装箱：把基本数据类型转换为对应的包装类类型
- 拆箱：把包装类类型转换为对应的基本数据类型
*/
public class IntegerDemo {
public static void main(String[] args) {
//装箱：把基本数据类型转换为对应的包装类类型
Integer i = Integer.valueOf(100);
Integer ii = 100;//自动装箱
//拆箱：把包装类类型转换为对应的基本数据类型
ii += 200;//隐含了自动拆箱和自动装箱
ii = ii.intValue()+200;
System.out.println(ii);
Integer iii = null;
if (iii != null) {
iii += 300;//NullPointerException
System.out.println(iii);
}
}
}
Date代表了一个特定的时间，精确到毫秒
package com.itheima;
import java.util.Date;
/*
public Date();分配一个Date对象，并初始化，以便代表它被分配的时间，精确到哦毫秒
public Date(long date);分配一个Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数
*/
public class DateDemo01 {
public static void main(String[] args) {
//public Date();分配一个Date对象，并初始化，以便代表它被分配的时间，精确到哦毫秒
Date d1 = new Date();
System.out.println(d1);//Sun Apr 17 09:24:48 CST 2022(CST中国标准时间)
//public Date(long date);分配一个Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数
long date = 1000*60*60;
Date d2 = new Date(date);
System.out.println(d2);
}
}
package com.itheima;
import java.util.Date;
/*
public long getTime();获取的是日期对象从1970年1月1日00:00:00到现在的毫秒值
public void setTime(long time);设置时间，给的是毫秒值
*/
public class DateDemo02 {
public static void main(String[] args) {
//创建日期对象
Date date = new Date();
//public long getTime();获取的是日期对象从1970年1月1日00:00:00到现在的毫秒值
System.out.println(date.getTime());//1650159338273
System.out.println("============");
System.out.println(date.getTime()*1.0/1000/60/60/24/365+"年");//52.326209356703444年
System.out.println("++++++++++++");
//public void setTime(long time);设置时间，给的是毫秒值
//long time = 1000*60*60;//Thu Jan 01 09:00:00 CST 1970
long time = System.currentTimeMillis();//Sun Apr 17 09:35:38 CST 2022
date.setTime(time);
System.out.println(date);
}
}
SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。我们重点学习日期格式化和解析
日期和时间格式由日期和时间模式字符串指定，在日期和时间模式字符串中，从’A’到’Z’以及从’a’到’z’引号的字母被解释为表示日期或时间字符串的组件的模式字母
常用的模式字母及对应关系如下
public final String format(Date date);：将日期格式化成日期/时间字符串
public Date parse(String source);：从给定字符串的开始解析文本以生成日期
package com.itheima_01;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
构造方法：
public SimpleDateFormat();构造一个SimpleDateFormat，使用默认模式和日期格式
public SimpleDateFormat(String pattern);构造一个SimpleDateFormat使用给定的模式和默认的日期格式
1. 格式化（从Date到String）
`public final String format(Date date);`：将日期格式化成日期/时间字符串
2. 解析（从String到Date）
`public Date parse(String source);`：从给定字符串的开始解析文本以生成日期
*/
public class SimpleDateFormatDemo {
public SimpleDateFormatDemo() {
}
public static void main(String[] args) throws ParseException {
//格式化（从Date到String）
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat();
String s = sdf.format(d);
System.out.println(s);//2022/4/17 下午2:15
System.out.println("==========");
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日，HH:mm:ss");
String s1 = sdf1.format(d);
System.out.println(s1);
System.out.println("++++++++++++");
// 解析（从String到Date）
String ss = "2048-08-09 11:11:11";
//ParseException解析异常，上下两个字符串格式不一样
//SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日，HH:mm:ss");
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date dd = sdf2.parse(ss);//Alt+Enter 增加抛出异常
System.out.println(dd);//Sun Aug 09 11:11:11 CST 2048
}
}
需求：定义一个日期工具类（DateUtils），包含两个方法：把日期转换为指定格式的字符串；把字符串解析为指定格式的日期，然后定义一个测试类（DateDemo），测试日期工具类的方法
思路：
package com.itheima_02;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
工具类
构造方法私有
成员方法静态
*/
public class DateUtils {
private DateUtils(){}
/*
把日期转为指定格式的字符串
返回值类型：String
参数：Date date，String format
*/
public static String dateToString(Date date,String format){
SimpleDateFormat sdf = new SimpleDateFormat(format);
String s = sdf.format(date);
return s;
}
/*
把字符串解析为指定格式的日期
返回值类型：Date
参数：String s,String format
*/
public static Date stringToDate(String s,String format) throws ParseException {
SimpleDateFormat sdf = new SimpleDateFormat(format);
Date d = sdf.parse(s);
return d;
}
}
package com.itheima_02;
import java.text.ParseException;
import java.util.Date;
public class DateDemo {
public static void main(String[] args) throws ParseException {
//创建日期对象
Date date = new Date();
String s1 = DateUtils.dateToString(date, "yyyy年MM月dd日,HH:mm:ss");
System.out.println(s1);
String s2 = DateUtils.dateToString(date, "yyyy年MM月dd日");
System.out.println(s2);
String s3 = DateUtils.dateToString(date, "HH:mm:ss");
System.out.println(s3);
System.out.println("+++++++++++++");
String s = "2048-08-08 12:12:12";
Date dd = DateUtils.stringToDate(s,"yyyy-MM-dd HH:mm:ss");
System.out.println(dd);
}
}
Calendar为某一时刻和一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法
Calendar提供了一个类方法getInstance用于获取Calendar对象，其日历字段已使用当前日期和时间初始化：
Calendar rightNow = Calendar.getInstance();
package com.itheima_01;
import java.util.Calendar;
/*
Calendar为某一时刻和一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法
Calendar提供了一个类方法getInstance用于获取Calendar对象，其日历字段已使用当前日期和时间初始化：
`Calendar rightNow = Calendar.getInstance();`
*/
public class CalendarDemo {
public static void main(String[] args) {
//获取对象
Calendar c = Calendar.getInstance();//多态的形式
//System.out.println(c);//java.util.GregorianCalendar[time=1650179528875,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=31,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2022,MONTH=3,WEEK_OF_YEAR=17,WEEK_OF_MONTH=4,DAY_OF_MONTH=17,DAY_OF_YEAR=107,DAY_OF_WEEK=1,DAY_OF_WEEK_IN_MONTH=3,AM_PM=1,HOUR=3,HOUR_OF_DAY=15,MINUTE=12,SECOND=8,MILLISECOND=875,ZONE_OFFSET=28800000,DST_OFFSET=0]
//public int get (int field)
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH) + 1;
int date = c.get(Calendar.DATE);
System.out.println(year + "年" + month + "月" + date + "日");
}
}
package com.itheima_01;
import java.util.Calendar;
/*
Calendar为某一时刻和一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法
Calendar提供了一个类方法getInstance用于获取Calendar对象，其日历字段已使用当前日期和时间初始化：
`Calendar rightNow = Calendar.getInstance();`
public abstract void add(int field,int amount);根据日历的规则，将指定的时间量添加或者减去给定的日历字段
public final void set(int year,int month,int date);设置当前日历的年月日
*/
public class CalendarDemo {
public static void main(String[] args) {
//获取对象
Calendar c = Calendar.getInstance();//多态的形式
//public int get (int field)
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH) + 1;
int date = c.get(Calendar.DATE);
System.out.println(year + "年" + month + "月" + date + "日");
System.out.println("================");
//public abstract void add(int field,int amount);根据日历的规则，将指定的时间量添加或者减去给定的日历字段
//需求1:3年前的今天
c.add(Calendar.YEAR, -3);
int year1 = c.get(Calendar.YEAR);
int month1 = c.get(Calendar.MONTH) + 1;
int date1 = c.get(Calendar.DATE);
System.out.println(year1 + "年" + month1 + "月" + date1 + "日");
System.out.println("=+=+=+=+=+=");
//需求2：十年后的五天前
c.add(Calendar.YEAR, 10);
c.add(Calendar.DATE, -5);
int year2 = c.get(Calendar.YEAR);
int month2 = c.get(Calendar.MONTH) + 1;
int date2 = c.get(Calendar.DATE);
System.out.println(year2 + "年" + month2 + "月" + date2 + "日");
System.out.println("--------------");
//public final void set(int year,int month,int date);设置当前日历的年月日
c.set(2048, 11, 11);
int year3 = c.get(Calendar.YEAR);
int month3 = c.get(Calendar.MONTH) + 1;
int date3 = c.get(Calendar.DATE);
System.out.println(year3 + "年" + month3 + "月" + date3 + "日");
System.out.println("================");
}
}
需求：获取任意一年的二月有多少天
思路：
package com.itheima_03;
import java.util.Calendar;
import java.util.Scanner;
/*
需求：获取任意一年的二月有多少天
思路：
1. 键盘录入任意的年份
2. 设置日历对象的年、月、日
- 年：来自于键盘录入
- 月：设置为3月，月份是从0开始的，所以设置的值是2
- 日：设置为1日
3. 3月1日往前推一天，就是2月的最后一天
4. 获取这一天输出即可
*/
public class CalendarTest {
public static void main(String[] args) {
//键盘录入任意的年份
Scanner scanner = new Scanner(System.in);
System.out.println("请输入年份：");
int year = scanner.nextInt();
//设置日历对象的年、月、日
Calendar calendar = Calendar.getInstance();
calendar.set(year, 2, 1);
//3月1日往前推一天，就是2月的最后一天
calendar.add(Calendar.DATE, -1);
//获取这一天输出即可
int date = calendar.get(Calendar.DATE);
System.out.println(year + "年的2月份有" + date + "天");
}
}