常用类-day01
今日学习内容:
- 工具类的设计
- 单例模式
- 八大基本类型的包装类
- 装箱和拆箱
- 包装类的缓存设计
- BigDecimal类
- Math类
- Random类
- UUID类
今日学习目标:
- 熟悉查看API,熟悉方法调用
- 了解工具的两种设计方案,公共静态方法和单例模式
- 掌握单例模式的编写
- 掌握八大基本数据类型的包装类
- 了解基本类型和包装类的区别
- 掌握什么是装箱和拆箱,什么是自动装箱和拆箱
- 掌握BigDecimal的加减乘除和保留精度操作
- 掌握随机数的生成和UUID的使用
14. 工具类的设计
一般的,把很多完成通用功能的方法分类存放到类中,这些类就叫工具类。
- 工具类起名:XxxUtil、XxxUtils、XxxTool、XxxTools等,其中Xxx表示一类事物,比如ArrayUtil、StringUtil、JdbcUtil。
- 工具类存放的包起名:util、utils、tool、tools等
工具类如何设计,在开发中有两种设计:
-
如果工具方法全部使用public static修饰
- 此时只需要使用工具类名调用工具方法
- 此时必须把工具类的构造器私有化,防止创建工具类的对象来调用静态方法
-
如果工具方法没有使用static修饰
- 此时必须使用工具类的对象去调用工具方法
- 此时把必须工具类设计为单例模式的
一般的出于简单考虑,首选第一种,如JDK中提供的工具java.util.Arrays类。
14.1. 公共静态方法(掌握)
比如使用公共静态方法的方式,设计一个数组的工具类。
public class ArrayUtil {
private ArrayUtil() {
}
public static void sort(int[] arr) {
System.out.println("排序操作");
}
public static void binarySearch(int[] arr, int key) {
System.out.println("二分查找操作");
}
}
调用者直接使用工具类名.工具方法名称完成调用:
int[] arr = new int[]{7,4,2,8,1,9};
ArrayUtil.sort(arr);
14.2. 单例模式(掌握)
设计模式(Design pattern):是一套被反复使用的代码设计经验总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。
比如使用单例模式的方式,设计一个数组的工具类。
单例设计模式(singleton):最常用、最简单的设计模式,单例的编写有N种写法。
目的:保证在整个应用中某一个类有且只有一个实例(一个类在堆内存只存在一个对象)。
写单例模式的步骤(单讲饿汉式):
- 必须在该类中,自己先创建出一个对象
- 私有化自身的构造器,防止外界通过构造器创建新的工具类对象
- 向外暴露一个公共的静态方法用于返回自身的对象
public class ArrayUtil {
private ArrayUtil() {
}
private static ArrayUtil instance = new ArrayUtil();
public static ArrayUtil getInstance() {
return instance;
}
public void sort(int[] arr) {
System.out.println("排序操作");
}
public void binarySearch(int[] arr, int key) {
System.out.println("二分查找操作");
}
}
调用代码:
int[] arr = new int[]{7,4,2,8,1,9};
ArrayUtil.getInstance().sort(arr);
使用枚举完成:
public enum ArrayUtil {
INSTANCE;
public void sort(int[] arr) {
System.out.println("排序操作");
}
public void binarySearch(int[] arr, int key) {
System.out.println("二分查找操作");
}
}
调用代码:
int[] arr = new int[]{7,4,2,8,1,9};
ArrayUtil.INSTANCE.sort(arr);
15. 包装类
自定义测试类名时千万不能和JDK中的类名同名。
学习常用类,多查阅文档,不熟悉,多写。
15.1. 基本类型包装类(掌握)
需求:使用double类型来表示学生的考试成绩,此时怎么区分考试成绩为0和没有成绩两种情况?使用double是不行的,只能表示0.0的情况,此时要解决该问题就得使用基本类型的包装类。
模拟定义一个类来封装int类型的值。
public class IntWrapper {
private int value; //值
public IntWrapper(int value) {
this.value = value;
}
}
使用该int的包装类。
IntWrapper wrapper = null; //没有对象,没有数据
IntWrapper wrapper = new IntWrapper(0); //有对象,表示数据0
此时能发现,模拟的int包装类IntWrapper既可以表示0,也可以表示null。
基本数据类型和包装类对应关系:
除了Integer和Character外,其他都是讲基本类型的首字母大写。讲课单以Integer举例。
15.1.1. 装箱和拆箱(了解)
装箱:把基本类型数据转成对应的包装类对象。
拆箱:把包装类对象转成对应的基本数据类型。
装箱操作:
方式一: Integer num1 = new Integer(17);
方式二: Integer num2 = Integer.valueOf(17); //建议
拆箱操作:
Integer num3 = Integer.valueOf(17); //装箱操作
int val = num3.intValue(); //拆箱操作
从Java5开始提供了的自动装箱(AutoBoxing)和自动拆箱(AutoUnBoxing)功能:
自动装箱:可把一个基本类型变量直接赋给对应的包装类变量。
自动拆箱:可以把包装类对象直接赋给对应的基本数据类型变量。
Integer num4 = 17; //装箱操作
int val2 = num4; //拆箱操作
自动装箱和拆箱,在底层依然是手动装箱和拆箱。
思考Object obj = 17;代码正确吗?为什么?
Integer i = 17; //自动装箱操作
Object obj = i; //把子类对象赋给父类变量
把字符串转换为int类型操作:
int num = Integer.parseInt("123");
如果传入的数据是非数字组成,如“SB250”,此时报错NumberFormatException。
15.1.2. 缓存设计(了解)
从性能上考虑,把常用数据存储到缓存区域,使用时不需要每次都创建新的对象,可以提高性能。
- Byte、Short、Integer、Long:缓存范围[-128,127];
- Character:缓存范围[0,127];
Integer i1 = new Integer(123);
Integer i2 = new Integer(123);
System.out.println(i1 == i2);// false
Integer i3 = Integer.valueOf(123);
Integer i4 = Integer.valueOf(123);
System.out.println(i3 == i4);// true
Integer i5 = 123; // 底层等价于
Integer i6 = 123;
System.out.println(i5 == i6);// true
Integer的部分源代码如下:
如果把上述代码中的123换成250,则结果都为false。
如果要比较两个对象的数据是否相等,必须使用equals方法来判断。
==比较的是两个数据的内存空间是否是同一块,equals比较的是存储数据是否相等。
int类型的默认值为0,Integer的默认值为null,在开发中建议使用Integer。
- Integer既可以表示0,也可以表示null。
15.2. BigDecimal(掌握)
float和double都不能表示精确的小数,使用BigDecimal类可以解决该问题,BigDecimal用于处理金钱或任意精度要求高的数据。
BigDecimal不能直接把赋值和运算操作,只能通过构造器传递数据,而且必须使用字符串类型的构造器,操作BigDecimal主要是加减乘除四个操作。
// 使用double类型:
System.out.println(0.09 + 0.01);// ?
// 使用BigDecimal类型double类型的构造器:
BigDecimal num1 = new BigDecimal(0.09);
BigDecimal num2 = new BigDecimal(0.01);
System.out.println(num1.add(num2));// ?
// 使用BigDecimal类型String类型的构造器:
BigDecimal num3 = new BigDecimal("0.09");
BigDecimal num4 = new BigDecimal("0.01");
System.out.println(num3.add(num4));// ?
结果为:
0.09999999999999999
0.09999999999999999687749774324174723005853593349456787109375
0.10
加减乘除操作:
BigDecimal num1 = new BigDecimal("10");
BigDecimal num2 = new BigDecimal("3.1415926");
BigDecimal ret1 = num1.add(num2);
BigDecimal ret2 = num1.subtract(num2);
BigDecimal ret3 = num1.multiply(num2).setScale(2, RoundingMode.HALF_UP);
BigDecimal ret4 = num1.divide(num2, 2 , RoundingMode.HALF_UP);
上述代码分别表示乘法和除法按照四舍五入方式保留两位小数。
17. 字符串
字符串(字符序列),表示把多个字符按照一定得顺序排列起来。
字符串的分类(根据同一个对象,内容能不能改变而区分):
- 不可变的字符串——String:当String对象创建完毕之后,该对象的内容是不能改变的,一旦内容改变就变成了一个新的对象。
- 可变的字符串——StringBuilder/StringBuffer:当StringBuilder对象创建完毕之后,对象的内容可以发生改变,当内容发生改变的时候,对象保持不变。
字符串的本质是char[],char表示一个字符,char[]表示同一种类型的多个字符。
String str = "ABCD"; 等价于 char[] cs = new char[]{'A','B','C','D'};
17.1.String(掌握)
17.1.1.String概述
String类,表示不可变的字符串,当String对象创建完毕之后,该对象的内容是不能改变的,一旦内容改变就变成了一个新的对象,看下面代码。
String str = "龙哥";
str = "龙哥17";
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PwFGgmeL-1693278549553)(F:\基础班资料\第三阶段-常用类\常用类day01\笔记\img\图片 140.png)]
String对象的创建的两种方式:
1、直接赋一个字面量: String str1 = "ABCD";
2、通过构造器创建: String str2 = new String("ABCD");
两种方式有什么区别,分别在内存中如何分布?
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nGGeGmL9-1693278549554)(F:\基础班资料\第三阶段-常用类\常用类day01\笔记\img\图片 141.png)]
String对象的空值:
- 表示引用为空(null) : String str 1 = null ; 没有初始化,没有分配内存空间.
- 内容为空字符串 : String str2 = “”; 已经初始化,分配内存空间,不过没有内容
判断字符串非空:字符串不为null并且字符内容不能为空字符串(“”)
判断一个字符串非空:
public static boolean hasLength(String str) {
return str != null && !"".equals(str.trim());
}
字符串的比较操作:
- 使用”==”号:比较两个字符串引用的内存地址是否相同
- 使用equals方法:比较两个字符串的内容是否相同
System.out.println("ABCD" == "ABCD"); //true
System.out.println("ABCD" == new String("ABCD")); //false
System.out.println("ABCD".equals("ABCD")); //true
System.out.println("ABCD".equals(new String("ABCD"))); //true
17.1.2. 常用方法(要记住)
- int length() 返回此字符串的字符个数
- char charAt(int index) 返回指定索引位置的字符
- int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引位置
- boolean equals(Object anObject) 比较内容是否相同
- boolean equalsIgnoreCase(String anotherString) 忽略虑大小写,比较内容是否相同
- String toUpperCase() 把当前字符串转换为大写
- String toLowerCase() 把当前字符串转换为小写
- String substring(int beginIndex):从指定位置开始截取字符串
- String substring(int beginIndex, int endIndex):截取指定区域的字符串
public class StringDemo{
public static void main(String[] args) {
String str = "HelloWorld";
System.out.println(str.length());// 10
char ch = str.charAt(3);
System.out.println(ch);// l
int index = str.indexOf("lo");
System.out.println(index);// 3
System.out.println("helloworld".equals(str));// false
System.out.println("helloworld".equalsIgnoreCase(str));// true
System.out.println(str.toLowerCase());// helloworld
System.out.println(str.toUpperCase());// HELLOWORLD
String str1 = str.substring(3);
System.out.println(str1);// loWorld
String str2 = str.substring(3, 6);
System.out.println(str2);// loW
}
}
17.2.StringBuilder(掌握)
Sting是不可变的,每次内容改变都会在内存中创建新的内存区域,如果现在要把N个字符串连接起来,此时需要在内存中创建N块内存空间,性能很低。此时要解决多个字符串做拼接性能低的问题,我们可以使用StringBuilder来搞定。
StringBuffer和StringBuilder都表示可变的字符串,功能方法相同的,区别是:
- StringBuffer:StringBuffer中的方法都使用了synchronized修饰,保证线程安全但性能较低
- StringBuilder:StringBuilder中的方法没有使用synchronized修饰,线程不安全但但是性能较高
开发中建议使用StringBuilder,具体用法如下:
- 如果事先知道需要拼接多少个字符,可以在创建StringBuilder对象时指定字符数组容量,缺省为16
StringBuilder sb = new StringBuilder(40);
使用append方法在原字符串后面继续拼接字符串
sb.append("ABC").append(123).append("will");
代码:
public class StringBuilderDemo {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer(40);
sb.append("abc").append("will").append(17);
String str = sb.toString();
System.out.println(str); //abcwill17
}
}
学习优势:
1.包含java前后端从 0 ->1 全过程教学, 内容全面, 知识点不遗漏, 学完即可参加实际工作.
2.课程为目前项目开发常用的技术知识,向用人单位对标,学以致用。那些脱离实际,废弃不用的,太前沿的框架技术前期不建议学。
3.一起学习,打卡,一起交流,希望能营造一个和线下一样的学习环境。