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 static double pow(double a, double b) | 返回a的b次幂的值 |
public static double random() | 返回值为double的正值,[0.0,1.0) |
/*
Math
*/
public class MathDemo {
public static void main(String[] args) {
//返回参数的绝对值
System.out.println(Math.abs(-23));
System.out.println(Math.abs(23));
System.out.println("------");
//返回大于或等于参数的最小double值,等于一个整数
System.out.println(Math.ceil(12.34));
System.out.println(Math.ceil(12.56));
System.out.println("--------");
//返回小于或等于参数的最大double值,等于一个整数
System.out.println(Math.floor(12.34));
System.out.println(Math.floor(12.56));
System.out.println("--------");
//按照四舍五入返回最接近参数的int
System.out.println(Math.round(12.34F));
System.out.println(Math.round(12.56F));
System.out.println("--------");
//返回两个int值中的较大值
System.out.println(Math.max(66,88));
System.out.println("--------");
//返回两个int值中的较小值
System.out.println(Math.min(66,88));
System.out.println("--------");
//返回a的b次幂的值
System.out.println(Math.pow(2.0,3.0));
System.out.println("--------");
//返回值为double的正值,[0.0,1.0)
System.out.println(Math.random());
}
}
System
System包含几个有用的类字段和方法,不能被实例化
方法名 | 说明 |
---|---|
public static void exit(int status) | 终止当前运行的Java虚拟机,非零遍式异常终止 |
public static long currentTimeMillis() | 返回当前时间(以毫秒为单位) |
publicstaticvoidmain(String[]args){
//获取开始的时间节点
longstart=System.currentTimeMillis();
for(inti=1;i<=10000;i++){
System.out.println(i);
}
//获取代码运行结束后的时间节点
longend=System.currentTimeMillis();
System.out.println("共耗时:"+(endstart)+"毫秒");
}
Object
Object是类层次结构的根,每个类都可以将Object作为超类。所有类都直接或者间接的继承自该类。换句话说,该类所具备的方法,所有类都会有一份。
查看方法源码的方式:选中方法,按下Ctrl+B
方法名 | 说明 |
---|---|
public String toString() | 返回对象的字符串表示形式。建议所有子类重写该方法,自动生成 |
public boolean equals(Object o) | 比较对象是否相等。默认比较地址,重写可以比较内容,自动生成 |
1. Object类的 toString()方法
-
重写toString方法的方式:
①Alt+Insert选择toString
②在类的空白区域,右键->Generate->选择toString -
toString方法的作用:以良好的格式,更方便的展示对象中的属性值
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 + '}';
}
}
public class toStringDemo {
public static void main(String[] args) {
Student s = new Student();
s.setName("zhangsan");
s.setAge(30);
System.out.println(s);
System.out.println(s.toString());
}
}
2. Object类的 equals()方法
-
equals方法的作用:用于对象之间的比较,返回true和false的结果
例:s1.equals(s2);s1和s2是两个对象 -
重写equals方法的场景:
不希望比较对象的地址值,想要结合对象属性进行比较的时候。 -
重写equals方法的方式:
①alt+insert选择equals()andhashCode(),IntelliJDefault,一路next,finish即可
②在类的空白区域,右键->Generate->选择equals()andhashCode(),后面同上。
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) {
//thiss1
//os2
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;//students2
if (age != student.age) return false;
return name != null ? name.equals(student.name) : student.name == null;
}
}
public class equalsDemo {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("zhangsan");
s1.setAge(20);
Student s2 = new Student();
s2.setName("zhangsan");
s2.setAge(20);
//比较两个对象的内容是否相同
System.out.println(s1.equals(s2));
}
}
Arrays
- 冒泡排序
- 一种排序方式,对要进行排序的数据中相邻的数据进行两两比较,将较大的数据放在后面,依次对所有的数据进行操作,直至所有数据按要求完成排序
- 如果有n个数据进行排序,总共需要比较n-1次
- 每一次比较完毕,下一次的比较就会少一个数据参与
/*
冒泡排序
*/
public class ArrayDemo {
public static void main(String[] args) {
//定义数组
int[] arr = {12,23,2,45,56};
System.out.println("排序前:" + arrayToString(arr));
//减1,是控制每轮比较的次数
for (int x = 0; x < arr.length - 1; x++) {
//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 i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
sb.append(arr[i]);
} else {
sb.append(arr[i]).append(",");
}
}
sb.append("]");
String s = sb.toString();
return s;
}
}
- Arrays类
Arrays类包含用于操作数的各种方法
构造方法用private
修饰
成员用public static
修饰
方法名 | 说明 |
---|---|
public static String toString(int[] a) | 返回指定数组的内容的字符串表示形式 |
public static void sort(int[]a) | 按照数字顺序排列指定的数组 |
import java.util.Arrays;
public class ArrayDemo_02 {
public static void main(String[] args) {
//定义数组
int[] arr = {12,23,2,45,56};
System.out.println("排序前:"+ Arrays.toString((arr)));
Arrays.sort(arr);
System.out.println("排序后:"+ Arrays.toString(arr));
}
}
基本类型包装类
基本数据类型 | 包装类 |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
char | Character |
boolean | Boolean |
- Integer类
包装一个对象中的原始类型int值
方法名 | 说明 |
---|---|
public Integer(int value) | 根据int值创建Integer对象(已过时) |
public Integer(String s) | 根据String值创建Integer对象(已过时) |
public static IntegerOf(int i) | 返回表示指定的int值的Integer实例 |
public static IntegerOf(String s) | 返回一个保存指定值的Integer对象String |
public class IntegerDemo {
public static void main(String[] args) {
//构造方法
//根据int值创建Integer对象(已过时)
Integer i1 = new Integer(12);
System.out.println(i1);
//根据String值创建Integer对象(已过时)
Integer i2 = new Integer("12");
//Integer i2 = new Integer("qwe");//NumberFormatException
System.out.println(i2);
System.out.println("------");
//静态方法获取对象
//返回表示指定的int值的Integer实例
Integer i3 = Integer.valueOf(10);
System.out.println(i3);
//返回一个保存指定值的Integer对象String
Integer i4 = Integer.valueOf("10");
//Integer i4 = new Integer("qwe");//NumberFormatException
System.out.println(i4);
}
}
- 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 int_StringDemo {
public static void main(String[] args) {
//int to String
int n = 12;
//方式一
String s1 = ""+ n;
System.out.println(s1);
//方式二,public static String valueOf(int i)
String s2 = String.valueOf(n);
System.out.println(s2);
System.out.println("------");
//String to int
String s = "12";
//方式一,String——Integer——int
//public int intValue()
Integer i = Integer.valueOf(s);
int x = i.intValue();
System.out.println(x);
//方式二,public static int parseInt(String s)
int y = Integer.parseInt(s);
System.out.println(y);
}
}
- 自动装箱和拆箱
装箱:把基本数据类型转换为对应的包装类类型
拆箱:把包装类类型转换为对应的基本数据类型
Integer i = 12;//自动装箱
i += 23;//i=i+23;i+23是自动拆箱;i=i+23是自动装箱
使用包装类类型时,需要进行不为null的判断。
public class Integer_zidong {
public static void main(String[] args) {
//装箱
Integer i = Integer.valueOf(12);
Integer i1 = 12;
//拆箱
//i1 = i1.intValue() + 23;
i1 += 23;
System.out.println(i1);
Integer i2 = null;
if (i2 != null) {
i2 += 23;//NullPointerException
}
System.out.println(i2);
}
}
日期类
- Date类
Date代表了一个特定的时间,精确到毫秒。
(1)构造方法
方法名 | 说明 |
---|---|
public Date() | 分配一个Date对象,并初始化,以便它代表它被分配的时间,精确到毫秒 |
public Date(long date) | 分配一个Date对象,并将其初始化为表示从标准基准时间其指定的毫秒数 |
import java.util.Date;
public class Date01 {
public static void main(String[] args) {
//分配一个Date对象,并初始化,以便它代表它被分配的时间,精确到毫秒
Date d1 = new Date();
System.out.println(d1);
//分配一个Date对象,并将其初始化为表示从标准基准时间其指定的毫秒数
long date = 1000 * 60 * 60;
Date d2 = new Date(date);
System.out.println(d2);
}
}
(2)常用方法
方法名 | 说明 |
---|---|
public long getTime() | 获取的时日期对象从1970年1月1日00:00:00到现在的毫秒 |
public void setTime(long time) | 设置时间,给的是毫秒值 |
import java.util.Date;
public class Date02 {
public static void main(String[] args) {
Date d = new Date();
//获取的时日期对象从1970年1月1日00:00:00到现在的毫秒
System.out.println(d.getTime());
System.out.println(d.getTime()*1.0/1000/60/60/24/365+"年");
}
}
import java.util.Date;
public class Date02 {
public static void main(String[] args) {
Date d = new Date();
//设置时间,给的是毫秒值
long time = 1000*60*60;
d.setTime(time);
System.out.println(d);
}
}
- SimpleDateFormat类
一个具体的类,用于以区域设置敏感的方式格式化和解析日期。
常用的模式字母即对应关系
字母 | 含义 |
---|---|
y | 年 |
M | 月 |
d | 日 |
H | 时 |
m | 分 |
s | 秒 |
(1)构造方法
方法名 | 说明 |
---|---|
public SimpleDateFormat() | 构造一个SimpleDateFormat,使用默认模式和日期格式 |
public SimpleDateFormat(String patterm) | 构造一个SimpleDateFormat,使用给定的模式和默认的日期格式 |
(2)格式化和解析使用的方法
方法 | 说明 |
---|---|
格式化(Date——String) | public final String(Date date) :将日期格式化成日期/时间字符串 |
解析(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("yyy年MM月dd日 HH:mm:ss");
String s = sdf.format(d);
System.out.println(s);
System.out.println("------");
//解析(String——Date)
String s1 = "2021年3月1日 10:27:00";//日期格式与给定的模式一致
SimpleDateFormat sdf2 = new SimpleDateFormat("yyy年MM月dd日 HH:mm:ss");
Date d1 = sdf2.parse(s1);
System.out.println(d1);
}
}
- Calendar类
Calendar类为某一时刻和一组日历字段之间的转换提供了一些方法,并为操作日历字段提供了一些方法。
Calendar提供了一个类方法getInstance用于获取Calendar对象,其日历字段已使用当前日期和时间初始化:Calendar rightNow = Calendar.getInstance();
import java.util.Calendar;
public class CalendarDemo {
public static void main(String[] args) {
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) | 设置当前日历的年月日 |
import java.util.Calendar;
public class CalendarDemo {
public static void main(String[] args) {
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 + "日");
*/
/*
//public abstract void add(int field,int amount):根据日历的规则,将指定的时间量添加或减去给定的日历字段
//两年前的7个月后
c.add(Calendar.YEAR, -2);
c.add(Calendar.MONTH, +4);
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 + "日");
*
*/
//public final void set(int year,int month,int date):设置当前日历的年月日
c.set(2019, 10, 24);
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 + "日");
}
}