Java SE基础学习笔记3·工具类

API

jdk 帮助文档

API 是应用程序编程接口

Java APl：指的就是 JDK 中提供的各种功能的Java类
这些类将底层的实现封装了起来，可以通过帮助文档来学习这些API如何使用

遇到新的方法多看看帮助文档，可以搞清楚返回值之类的

注意： 软件包 在 java.lang 的不需要 导包

jdk 1.8 帮助文档下载

jdk 在线帮助文档

按照帮助文档的使用步骤学习Scanner类的使用，并实现键盘录入一个字符串，最后输出在控制台
操作过程

Ctrl + Alt + V

调用方法的时候，如果方法有明确的返回值要用变量接收可以使用快捷键的方式完成 Ctrl + Alt + V

Math

Math 类中的常用方法

范例：

System.out.println(Math.ceil(12.34));	// 13.0

生成 [0,1) 的随机数

System.out.println(Math.random());

生成一个大于等于5，小于100 随机整数

// 先实现这个 >=0  < 95, 乘 95 就行
System.out.println((int) (Math.random() * 95));

生成 [0,int) 的随机数

random.nextInt(int)

random.nextInt(100)		// [0,100)

随机数种子
随机种子是固定的，那生成的随机数的序列也是一定的

Random random = new Random(1); // 每次都是同一个序列
Random random = new Random();	// 这就去掉种子了
int num = random. nextInt(1000);

System

System 类中的常用方法

exit

System.out.printLn("开始");
System.exit(0);
System.out.println("结束");
// 开始

currentTimeMillis

1970年1月1日到现在的毫秒

System.out.println(System.currentTimeMillis());		// 输出毫秒差
System.out.println(System.currentTimeMillis() * 1.0 / 1000 / 60 / 60 / 24 / 365 +"年");		// 输出和1970年差多少年

查看程序运行时间

long start = System.currentTimeMillis();
for( int i = 0; i < 100; i++) {
}
long end = System.currentTimeMillis();
System.out.println("共耗时:" + (end - start)+“毫秒");

Object

常用方法：

克隆 clone

分类 面试经常遇见

比如，深度克隆我的钱100次，也会出现100个我

概述


可以下转型成 Person 类型对象

获取哈希值 hashCode

定义：JDK 根据对象的地址或者字符串或者数字算出来的 int 类型的数值

返回对象的哈希码值
Object 类中的 hashCode 方法

Student s1 = new Student("小李", 20);
Student s2 = new Student("小李", 20);
system.out.println(s1.hashCode());	// 1060830840
System.out.println(s2.hashCode());	// 2137211482
// 两者哈希值不同，因为对象不同

对象的哈希值特点

1. 同一个对象多次调用hashCode()方法返回的哈希值是相同的

2. 默认情况下，不同对象的哈希值是不同的

3. 重写 hashCode()方法，可以实现让不同对象的哈希值相同
   例如：字符串

   System.out.println("重地".hashCode());	// 1179395
   System.out.println("通话".hashCode());	// 1179395
   

equals

引用类型（对象）直接调用 equals方法 比较的是他们的地址

public class objectDemo {
	public static void main(string[]args) {
		Student s1 =.new student( );
		s1.setName("小李");
		s1.setAge( 30) ;
		student s2 = new student( );
		s2.setName("小李");
		s2.setAge(30) ;
		System.out.println(s1.equals(s2));	// false
	}
}

需要在类中重写 equals方法，自动生成 ↓

toString

System.out.println(s1);
// com.situ.demo0210.Student@7852e922

// 在 Students 重写
@Override
public String toString() {
	return "Student [name=" + name + ", age=" + age + "]";
}
// Student [name=小李, age=20]

其它方法

即当不用的时候就都清除掉，防止占用资源

Arrays

toString

工具类的设计思想
构造方法用 private 修饰
成员用 public static 修饰

Arrays类 属于工具类，包含用于操作数组的各种方法

// 定义一个数组
int[] arr = {24, 57， 13};
System.out.println("排序前：" + Arrays.toString(arr));
排序前：[24, 57， 13]
Arrays.sort(arr);
System.out.print1n("排序后："+ Arrays.toString(arr));
排序后：[13, 24， 57]

判断 数组 值是否相等

int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};

System.out.println(Arrays.equals(arr1,arr2));	// true

基本类型包装类

除了基本数据，Java 是完全面向对象的，所以有了包装类

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

什么情况下用哪个：链接

常用的操作：用于基本数据类型与字符串之间的转换

lnteger

包装一个对象中的原始类型int的值

// Integer ii = new Integer(100);	// 过时了
Integer i1 = Integer.valueOf(100);
System.out.println(i1);		// 100

必须是数字字符串，否则的话会报错

Integer i2 = Integer.valueof("abc");	// abc
Integer i2 = Integer.valueof("123");
System.out.println(i2);		// 123

自动装箱

操作	将	转化为
装箱	基本数据类型	包装类类型
拆箱	包装类类型	基本数据类型

案例：

// 装箱：明确调方法来实现的
Integer i  = Integer.valueof(3);
Integer ii = 3;	// 自动装箱
//           integer.valueof(123) ;
// 在底层其实也做了这个动作

构造方法

byte b3 = 100; 
Byte b4 = b3;	// 基本类型的变量
Byte b5 = b3;	// 基本类型的变量
System.out.println(b4 == b5);	// true

包装类型运算

算术运算
包装类型的对象进行算术运算时，将自动拆箱为基本数据类型，再进行运算

Byte b1 = 100;
System.out.println( b1 + s1 + i1 + l1 + f1);		// 500.0
System.out.println( 100 + s1 + f1);	// 300.0

比较运算符

System.out.println(b1 < s1);
System.out.println(b1 <= s1);
System.out.printLn(b1 == s1),	// 报错
System.out.println(b1 != 1);	// 报错

自动拆箱

案例：

Integer i = 3; 			// 自动装箱
i = i.intValue( ) + 2;	// 装箱
i += 200;				// 自动装箱
// 步骤分解 
i = i + 200;
i + 200			// 1. 自动拆箱
i = i + 200;	// 2. 自动装箱

null

Integer i = nu11;
i += 300; // 空指针异常：NuLLPointerException

int 和 String 的相互转换

1. int 转换为 String

public static String valueOf(int i);

该方法是 String类 中的方法

int number = 123;

// 方式1
String s1 = "" + number;
System.out.println(s1);		// 123

// 方式2
String s2 = string.valueOf( number);
System.out.println(s2);		// 123

2. String 转换为 int

public static int parseInt(String s):

该方法是 Integer类 中的方法

String s = "123";

// 方式1
// String --- Integer --- int
Integer i = Integer.valueof(s);
int x = i.intValue();
System.out.print1n(×);		// 123

//方式2
int y = Integer.parseInt(s);
System.out.println(y);		// 123

字符串中数据排序

有一个字符串： “91 27 46 38 50”
排序后输出：“27 38 46 50 91"

得到字符串中每一个数字数据：
.split(“?”) ：作为分割的符号

public String[] split(String regex)

String[]strArray = s.split(" ");

//定义一个字符串
String s = "91 27 46 38 50" ;

//把字符串中的数字数据存储到一个int类型的数组中
String[]strArray = s.split(regex: " ");

//定义一个int数组，把string[]数组中的每一个元素存储到int 数组中
int[] arr = new int[strArray.length];
for(int i = 0; i < arr.length; i++) {
	arr[i] = Integer.parseInt(strArray[i]);
}

// 对int数组进行排序
Arrays.sort(arr);

// 把排序后的int数组中的元素进行拼接得到一个字符串
// 这里拼接采用StringBuiLder来实现StringBuilder sb = new StringBuilder();
for(int i=o; i < arr.1ength; 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);

日期类 Date

有的类只在一个包里有，有的多个包里都有，比如：Date，使用 util包 下的

描述：

Date代表了一个特定的时间，精确到毫秒

构造方法

Date
CST 是中国所在的时间

Date d1 = new Date();
System.out.println(d1);
// Fri Feb 11 20:52:04 CST 2022

Date(long date)
因为时区不同，所以不是00时

long date = 1000 * 60 * 60 * 24L;
Date d2 = new Date(date);
System.out.println(d2);
// Fri Jan 02 08:00:00 CST 1970

常用方法

System.out.println(d.getTime());
system.out.println(d.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365 + “年");

System.out.println(d);
// Fri Feb 11 20:52:04 CST 2022

long time = 1000 * 60 * 60 * 24;
d.setTime(time);
System.out.println(d);
// Fri Jan 02 08:00:00 CST 1970

long time = System.currentTimeMillis();
d.setTime(time);
System.out.println(d);
// Fri Feb 11 20:52:04 CST 2022

SimpleDateFormat 类

SimpleDateFormat是一个具体的类，抽象类 DateFormat 的子类，用于以区域设置敏感的方式格式化和解析日期

日期和时间格式由日期和时间模式字符串的组件的模式字母指定，从’A’到‘Z’以及从 ‘a’到‘z’的字母

模式字母	格式
y	年
M	月
d	日
H	时
m	分
s	秒

SimpleDateFormat构造方法

SimpLeDateFormat sdf = new SimpleDateFormat();

SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");

格式化 从 Date 到 String

将日期格式化成日期/时间字符串

public final String format(Date date)

// 别忘了创建日期对象
Date d = new Date();
String s = sdf.format(d);
System.out.println(s);
// 22-2-12 上午9:22
// 2022年02月12日09:22:21

解析 从 String 到 Date

出现异常选第一个

public static void main(String[] args) throws ParseException {

	String s = "2022-02-12 09:37:20";
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date d = sdf.parse(s);
		System.out.println(d);
		// Sat Feb 12 09:37:20 CST 2022
}

日期格式要匹配

String s = "2022-02-12 09:37:20";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
// 报错：Unparseable date

日期工具类

工具类：

1. 构造方法私有

   public class DateUtils {
   	private DateUtils() {}
   }
   

2. 成员方法静态

   public static String dateToString(Date date，String format) {
   }
   

日期工具类 DateUtils

import java.util.Date;

public class DateUtils {
	private DateUtils() {}
	
	// 格式化
	public static String dateToString(Date date，String format) {
		simpleDateFormat sdf = new simpleDateFormat(format);
		String s = sdf.format(date);
		return s;
	}
	
	// 解析
	public static Date stringToDate(String s,String format) throws ParseException {
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		Date d = sdf.parse(s);
		return d;
	}
}

测试类 DateDemo

import java.util.Date;

public class DateDemo {
	public static void main(String[] args) {
		//创建日期对象
		Date d = new Date();
		String s1 = DateUtils.dateToString(d,format: "yyyy年MM月dd日HH:mm:ss");
		System.out.print1n(s1);
		// 2022年02月12日09:22:21

		String s2 = "2022-02-12 09:37:20";
		Date d2 = DateUtils.stringToDate(s2,format: "yyyy-MM-dd HH:mm:ss");
		System.out.println(d2);
		// Sat Feb 12 09:37:20 CST 2022
	}
}

日历 Calendar

Calendar 抽象类 为某一时刻和一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法，只有年月日

getInstance

Calendar的类方法（构造方法），用于获取Calendar对象
其日历字段已使用当前日期和时间初始化
获取的月份是从0开始的，一般都 +1

格式： Calendar 是抽象类，所以用多态的方式来获取对象

Calendar rightNow = Calendar.getInstance();

常用方法

get

返回日历的值
获取年月日等信息 ↓，后面的要全部大写

Calendar.？
Calendar.YEAR

案例：

import java.util.Calendar;

// 多态的形式获取对象
Calendar c = Calendar.getInstance();

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 + “日");
// 2022年2月12日

add

将指定时间增加或减少

c.add( calendar.YEAR,-2);	// 两年前
c.add(caLendar.DATE,8);		// 八天后
// 2020年2月20日

set

所给日历字段的值
别忘了月份是从0开始的

c.set( 2022, 1, 12);
// 2022年2月12日

2月有多少天

不需要再判断平年闰年什么的，主要思路 ↓
二月最后一天：c.add(3月第一天, -1);

// 键盘录入任意的年份
Scanner sc = new Scanner(System.in) ;System.out.println(“请输入年份:");
int year = sc.nextInt();

// 设置日历对象的年、月、日
Calendar c = Calendar.getInstance();
c.set(year, 2, 1);

// 3月1日往前推一天，就是2月的最后一天
c.add(Calendar.DATE, -1);

//获取这一天输出即可
int date = c.get(Calendar.DATE);
System.out.println(year +"年的2月份有" + date + "天");

后续
后续内容在《Java SE基础学习笔记4·异常》