Math
Math类的概述
Math包含执行基本数字运算的方法(通过查找帮助文档)
没有构造方法,如何使用类中的成员呢?
看类的成员是否都是静态的,如果是,通过类名就可以直接调用
Math类的常用方法
方法名 | 说明 |
public static int abs(int a) | 返回参数的绝对值 |
public static double ceil (double a) | 返回大于或等于参数的最小double值,等于一个整数 |
public static double floor (double a) | 返回小于或等于参数的最大double值,等于一个整数 |
public static int round (float a) | 按照四舍五入返回最接近参数的int |
public static int max(int a,int b) | 返回两个int值中的较大值 |
public static int min (int a,int b) | 返回两个int值中的较小值 |
public stiatic double pow (double a,double b) | 返回a的b次幂的值 |
public static double random () | 返回值为double的正值,[0.0,1.0) |
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(12,13));
System.out.println(Math.max(-1,0));
System.out.println("-----------");
//public static int min (int a,int b) 返回两个int值中的较小值
System.out.println(Math.min(2,3));
System.out.println(Math.min(-1,0));
System.out.println("-----------");
//public static double pow (double a,double b) 返回a的b次幂的值
System.out.println(Math.pow(2.0,3.0));
System.out.println(Math.pow(1.0,2.0));
System.out.println("------------");
//public static double random () 返回值为double的正值,[0.0,1.0)
System.out.println((int)(Math.random()*100) + 1);
}
}
System
System类的概述
System包含几个有用的类字段和方法,它不能被实例化
System类的常用方法
方法名 | 说明 |
public static void exit (int status) | 终止当前运行的Java虚拟机,非零表示异常终止 |
public static long currentTimeMillis () | 返回当前时间(以毫秒为单位) |
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());
//System.out.println(System.currentTimeMillis() * 1.0 / 1000 / 60 /60/ 24 / 365 + "年");
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类的概述
Object是类层次结构的根,每个类都可以将Object作为超类。所有类都直接或者间接的继承自该类
构造方法: public Object ( )
回想面向对象中,为什么说子类的构造方法默认访问的是父类的无参构造方法?
因为他们的顶级父类只有无参构造方法
Object类的常用方法
方法名 | 说明 |
public String toString ( ) | 返回对象的字符串表示形式。建议所有子类重写该方法,自动生成 |
public boolean equals (Object obj) | 比较对象是否相等。默认比较地址,重写可以比较内容,自动生成 |
public class Student {
private String name;
public 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 +
'}';
}
}
public class ObjectDemo {
public static void main(String[] args) {
Student s = new Student();
s.setName("小明");
s.setAge(18);
System.out.println(s);//com.itheima_01.Student@16b98e56
System.out.println(s.toString());//com.itheima_01.Student@16b98e56
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 boolean equals(Object o) {
//this ---- s1
// o ---- s2
//比较地址是否相同,如果相同,直接返回true
if (this == o) return true;
//判断参数是否为null,或者判断两个对象是否来自同一个类
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;
}
}
/*
测试类
public boolean equals (Object obj): 指示一些其他对象是否等于此
*/
public class ObjectDemo {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("小明");
s1.setAge(18);
Student s2 = new Student();
s2.setName("小明");
s2.setAge(18);
//需求:比较两个对象的内容是否相同
//System.out.println(s1 == s2);
System.out.println(s1.equals(s2));
/*
public boolean equals(Object obj) {
//this ---- s1
//obj ---- s2
return (this == obj);
}
*/
}
}
Arrays
冒泡排序
排序:将一组数据按照固定的规则进行排序
冒泡排序:一种排序的方式,对要进行排序的数据中相邻的数据进行两两比较,将较大的数据放在后面,依次对所有的数据进行操作,直至所有数据按要求完成排序
· 如果有n个数据进行排序,总共需要比较n-1次
· 每一次比较完毕,下一次的比较就会少一个数据参与
Arrays类的概述和常用方法
Arrays类包含用于操作数组的各种方法
方法名 | 说明 |
public static String toString (int [ ] a) | 返回指定数组的内容和字符串表示形式 |
public static void sort (int [ ] a) | 按照数字顺序排序指定的数组 |
工具类的设计思想:
· 构造方法用private修饰
· 成员用 public static 修饰
public class ArraysDemo {
public static void main(String[] args) {
//定义一个数组
int[] arr = {24, 69, 80, 57, 13};
System.out.println("排序前:" + arrayToString(arr));
for (int x = 0; x < arr.length-1; 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("排序后:" + arrayToString(arr));
}
//把数组中的元素按照指定的规则组成一个字符串:【元素1,元素2,..】
public static String arrayToString(int [] arr){
StringBuilder sb = new StringBuilder();
sb.append("[");
for (int x=0;x< arr.length;x++){
if (x == arr.length-1){
sb.append(arr[x]);
}else {
sb.append(arr[x]).append(",");
}
}
sb.append("]");
String s = sb.toString();
return s;
}
}
基本类型包装类
基本类型包装类概述
将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据
常用的操作之一: 用于剧本数据类型与字符串之间的转换
基本数据类型 | 包装类 |
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
char | Character |
boolean | Boolean |
Integer类的概述和使用
Integer: 包装一个对象中的原始类型 int 的值
方法名 | 说明 |
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 |
int 和 String 的相互转换
基本类型包装类的最常见操作就是: 用于基本类型和字符串之间的相互转换
1.int 转换为 String
public static String valueOf(int i): 返回 int 参数的字符串表示形式。该方法是 String 类中的方法
2.String 转换为 int
public static int parseInt(String s): 将字符串解析为 int 类型。该方法是 Integer 类中的方法
public class IntegerDemo {
public static void main(String[] args) {
//int --- String
int number = 100;
//方式1
String s1 = "" + number;
System.out.println(s1);
//方式2
//public static String valueOf (int i)
String s2 = String.valueOf(number);
System.out.println(s2);
System.out.println("---------");
//String --- int
String s = "100";
//方式1
//String --- Integer --- int
Integer i = Integer.valueOf(s);
//public int intValue()
int x= i.intValue();
System.out.println(x);
//方式2
//String --- int
//public static int parseInt (String s)
int y = Integer.parseInt(s);
System.out.println(y);
}
}
自动装箱和拆箱
· 装箱: 把基本数据类型转换为对应的包装类类型
· 拆箱: 把包装类类型转换为对应的基本数据类型
Integer i 100; //自动装箱
i += 200; //i = i + 200 自动拆箱; i = i + 200; 是自动装箱
注意:在使用包装类类型的时候,如果做操作,最好先判断是否为null
我们推荐的是,只要是对象,在使用前就必须进行不为null的判断
public class IntegerDemo {
public static void main(String[] args) {
//装箱: 把基本数据类型转换为对应的包装类类型
Integer i = Integer.valueOf(100); //自动装箱
Integer ii = 100; //自动装箱 Integer.valueOf(100);
//拆箱: 把包装类类型转换为对应的基本数据类型
//ii += 200;
ii = ii.intValue() + 200; //手动拆箱
ii += 200; //自动拆箱
System.out.println(ii);
Integer iii = null;
if (iii != null) {
iii += 300; //NullPointerException
}
}
}
日期类
Date类概述和构造方法
方法名 | 说明 |
public Date ( ) | 分配一个Date对象,并初始化,以便它代表它被分配的时间,精确到毫秒 |
public Date (long date) | 分配一个Date对象,并将其初始化为表示从标准基准时间起指定毫秒数 |
Date类的常用方法
方法名 | 说明 |
public long getTime ( ) | 获取的是日期对象从1970年1月1日00:00:00到现在的毫秒值 |
public void setTime (long time) | 设置时间,给的是毫秒值 |
import java.util.Date;
public class DateDemo01 {
public static void main(String[] args) {
//public Date ( ) 分配一个Date对象,并初始化,以便它代表它被分配的时间,精确到毫秒
Date d1 = new Date();
System.out.println(d1);
//public Date (long date) 分配一个Date对象,并将其初始化为表示从标准基准时间起指定毫秒数
long date = 1000*60*60;
Date d2 = new Date(date);
System.out.println(d2);
}
}
SimpleDateFormat类概述
SimpleDateFormat是一个具体的类,用于以区域设置敏感的方式格式化和解析日期。我们重点学习日期格式化和解析
日期和时间格式由日期和时间模式字符串指定,在日期和时间模式字符串中,从'A'到'Z'以及从'a'到'z'引号的字母被解释为表示日期或时间字符串的组件的模式字母
常用的模式字母及对应关系如下:
y | 年 |
M | 月 |
d | 日 |
H | 时 |
m | 分 |
s | 秒 |
SimpleDateFormat的构造方法
方法名 | 说明 |
public SimpleDateFormat ( ) | 构造一个SimpleDateFormat,使用默认模式和日期格式 |
public SimpleDateFormat (Spring pattern) | 构造一个SimpleDateFormat使用给定的模式和默认的日期格式 |
SimpleDateFormat格式化和解析日期
1.格式化(从Date到String)
public final String format(Date date): 将日期格式化成日期/时间字符串
2.解析(从String到Date)
public Date parse(String source): 从给定字符串的开始解析文本以生成日期
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDateFormatDemo {
public static void main(String[] args) throws ParseException {
//格式化:从 Date 到 String
Date d = new Date();
// SimpleDateFormat sdf = new SimpleDateFormat();
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String s = sdf1.format(d);
System.out.println(s);
System.out.println("----------");
//解析: 从 String 到 Date
String ss = "2022年11月06日 22:27:30";
//ParseException
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
Date dd = sdf2.parse(ss);
System.out.println(dd);
}
}
import java.text.ParseException;
import java.util.Date;
/*
测试类
*/
public class DateDemo {
public static void main(String[] args) throws ParseException {
//创建日期对象
Date d = new Date();
String s1 = DateUtils.dateToString(d, "yyyy年MM月dd日 HH:mm:ss");
System.out.println(s1);
String s2 = DateUtils.dateToString(d, "yyyy年MM月dd日");
System.out.println(s2);
String s3 = DateUtils.dateToString(d, "HH:mm:ss");
System.out.println(s3);
System.out.println("--------------");
String s = "2022-11-07 19:46:50";
Date dd = DateUtils.stringToDate(s, "yyyy-MM-dd HH:mm:ss");
System.out.println(dd);
}
}
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;
}
}
Calendar类概述
Calendar为某一时刻和一组日历字段之间的转换提供了一些方法,并为操作日历字段提供了一些方法
Calendar提供了一个类方法getInstance用于获取Canlendar对象,其日历字段已使用当前日期和时间初始化: Calendar rightNow = Calendar.getInstance();
import java.util.Calendar;
public class CalendarDemo {
public static void main(String[] args) {
//获取Calendar对象
Calendar c = Calendar.getInstance(); //多态的形式
// System.out.println(c);
//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 + "日");
}
}
Calendar的常用方法
方法名 | 说明 |
---|---|
public int get (int field) | 返回给定日历字段的值 |
public abstract void add (int field,int amount) | 根据日历的规则,将指定的时间量添加或减去给定的日历字段 |
public final void set (int year,int month,int date) | 设置当前日历的年月日 |