包装类
包装类就是基本数据类型所对应的引用数据类型. 就是把基本数据类型变成了一个对象.
包装类可以理解为: 用一个对象, 将基本数据类型包起来.
图 1
Java 中万物皆对象, 所有的东西都可以看作是一个对象, 而且由于多态特性, 所有的对象都可以用 Object 来表示.
图 2
图 3
此时, 如果没有包装类, 传递过来了一个整数, 方法就无法接受, 程序就有局限性. 另一方面, 集合不能存储基本数据类型, 只能存储对象.
JDK5 对获取对象的方式进行了优化.
JDK5 之前, 如果要获取包装类的对象, 需要根据构造方法自己 new. 或者根据静态方法 valueOf() 来获取, 这是一个被重载的方法.
图 4
valueOf() 源码:
图 5
传进来的参数, 如果在 [-128, 127] 范围内, 就直接从一个数组中去获取, 否则 new 一个出来.
进入 1080 行的 cache 的源码:
图 6
可以看见, cache 是一个 Integer 类型的数组.
low 和 high 的值:
图 7
程序示例:
public class IntegerDemo1 {
public static void main(String[] args) {
/*
* public Integer(int value) 根据传递的整数创建一个 Integer 对象
* public Integer(String s) 根据传递的字符串创建一个 Integer 对象
* public static Integer valueOf(int i) 根据传递的整数创建一个 Integer 对象
* public static Integer valueof(String s) 根据传递的字符串创建一个 Integer 对象
* public static Integer valueof(String s, int radix) 根据传递的字符串和进制创建一个 Integer 对象
*/
// 1. 利用构造方法获取 Integer 的对象 (JDK5 以前的方式)
Integer i1 = new Integer(1);
Integer i2 = new Integer("1");
System.out.println(i1); // 1
System.out.println(i2); // 1
// 2. 利用静态方法获取 Integer 的对象 (JDK5 以前的方式)
Integer i3 = Integer.valueOf(123); // 123
Integer i4 = Integer.valueOf("123"); // 123
Integer i5 = Integer.valueOf("123", 8); // 83
System.out.println(i3); // 123
System.out.println(i4); // 123
System.out.println(i5); // 83
// 3. 这两种方式获取对象的区别 (掌握)
// 底层原理:
// 因为在实际开发中, -128~127 之间的数据, 用的比较多.
// 如果每次使用都是 new 对象, 那么太浪费内存了
// 所以, 提前把这个范围之内的每一个数据都创建好对象
// 如果要用到了不会创建新的, 而是返回已经创建好的对象.
Integer i6 = Integer.valueOf(127);
Integer i7 = Integer.valueOf(127);
System.out.println(i6 == i7); // true
Integer i8 = Integer.valueOf(128);
Integer i9 = Integer.valueOf(128);
System.out.println(i8 == i9); // false
// 下面的代码中, 因为看到了 new 关键字, 在 Java 中, 每一次 new 都是创建了一个新的对象
// 所以下面的两个对象都是 new 出来, 地址值不一样.
Integer i10 = new Integer(127);
Integer i11 = new Integer(127);
System.out.println(i10 == i11); // false
Integer i12 = new Integer(128);
Integer i13 = new Integer(128);
System.out.println(i12 == i13); // false
}
}
程序示例:
public class IntegerDemo2 {
public static void main(String[] args) {
// 在以前包装类如何进行计算
Integer i1 = new Integer(1);
Integer i2 = new Integer(2);
// 需求: 要把两个数据进行相加得到结果 3
// 对象之间是不能直接进行计算的.
// 步骤:
// 1. 把对象进行拆箱, 变成基本数据类型
// 2. 相加
// 3. 把得到的结果再次进行装箱 (再变回包装类)
int result = i1.intValue() + i2.intValue();
Integer i3 = new Integer(result);
System.out.println(i3);
}
}
程序示例:
public class Demo3 {
public static void main(String[] args) {
// 在 JDK5 的时候提出了一个机制: 自动装箱和自动拆箱
// 自动装箱: 把基本数据类型会自动的变成其对应的包装类
// 自动拆箱: 把包装类自动的变成其对应的基本数据类型
// 自动装箱的动作, 在底层, 此时还会去自动调用静态方法 valueOf 得到一个 Integer 对象, 只不过这个动作不需要我们自己去操作了
Integer i1 = 10;
Integer i2 = new Integer(10);
// 自动拆箱的动作
int i = i2;
// 结论: 在 JDK5 以后, int 和 Integer 可以看做是同一个东西, 因为在内部可以自动转化.
}
}
图 8
包装类 Integer 的成员方法:
图 9
程序示例:
public class demo4 {
public static void main(String[] args) {
/*
* public static string toBinaryString(int i) 得到二进制
* public static string toOctalString(int i) 得到八进制
* public static string toHexString(int i) 得到十六进制
* public static int parseInt(String s) 将字符串类型的整数转成 int 类型的整数
*/
// 1. 把整数转成二进制, 十六进制
String str1 = Integer.toBinaryString(100);
System.out.println(str1); // 1100100
// 2. 把整数转成八进制
String str2 = Integer.toOctalString(100);
System.out.println(str2); // 144
// 3. 把整数转成十六进制
String str3 = Integer.toHexString(100);
System.out.println(str3); // 64
// 4. 将字符串类型的整数转成 int 类型的整数
// 强类型语言:每种数据在 Java 中都有各自的数据类型
// 在计算的时候, 如果不是同一种数据类型, 是无法直接计算的.
int i = Integer.parseInt("123");
System.out.println(i);
System.out.println(i + 1); // 124
// 细节 1:
// 在类型转换的时候, 括号中的参数只能是数字不能是其他, 否则代码会报错
// 细节 2:
// 8 种包装类当中, 除了 Character 都有对应的 parseXxx 的方法, 进行类型转换
String str = "true";
boolean b = Boolean.parseBoolean(str);
System.out.println(b);
}
}
程序示例:
import java.util.Scanner;
public class Demo {
public static void main(String[] args) {
// 键盘录入
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");
// String str = sc.next();
// System.out.println(str);
// 弊端:
// 当我们在使用 next, nextInt, nextDouble 在接收数据的时候, 遇到空格, 回车, 制表符的时候就停止了
// 键盘录入的是 123 123 那么此时只能接收到空格前面的数据
// 我想要的是接收一整行数据
// 约定:
// 以后我们如果想要键盘录入, 不管什么类型, 统一使用 nextLine
// 特点: 遇到回车才停止
String line = sc.nextLine();
System.out.println(line);
System.out.println(line + 1);
double v = Double.parseDouble(line);
System.out.println(v);
System.out.println(v + 1);
}
}
执行结果:
请输入一个字符串
2.3
2.3
2.31
2.3
3.3
练习题:
第一题:
import java.util.Scanner;
public class A05_IntegerDemo5 {
public static void main(String[] args) {
// 键盘录入
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");
/*
* String str = sc.next();
* System.out.println(str);
*/
// 弊端:
// 当我们在使用 next, nextInt, nextDouble 在接收数据的时候, 遇到空格, 回车, 制表符的时候就停止了
// 键盘录入的是 123 123 那么此时只能接收到空格前面的数据
// 我想要的是接收一整行数据
// 约定:
// 以后我们如果想要键盘录入, 不管什么类型, 统一使用 nextLine
// 特点: 遇到回车才停止
String line = sc.nextLine();
System.out.println(line);
double v = Double.parseDouble(line);
System.out.println(v);
}
}
第二题:
public class Test2 {
public static void main(String[] args) {
/*
* 自己实现 parseInt 方法的效果, 将字符串形式的数据转成整数. 要求: 字符串中只能是数字不能有其他字符最少一位, 最多 10 位, 0 不能开头
*/
// 1. 定义一个字符串
String str = "123";
// 2. 校验字符串
// 习惯: 会先把异常数据进行过滤, 剩下来就是正常的数据.
if (!str.matches("[1-9]\\d{0,9}")) {
// 错误的数据
System.out.println("数据格式有误");
} else {
// 正确的数据
System.out.println("数据格式正确");
// 3. 定义一个变量表示最终的结果
int number = 0;
// 4. 遍历字符串得到里面的每一个字符
for (int i = 0; i < str.length(); i++) {
int c = str.charAt(i) - '0'; // 把每一位数字放到 number 当中
number = number * 10 + c;
}
System.out.println(number);
System.out.println(number + 1);
}
}
}
第三题:
public class Test3 {
public static void main(String[] args) {
/*
* 定义一个方法自己实现 toBinaryString 方法的效果, 将一个十进制整数转成字符串表示的二进制
*/
}
public static String tobinarystring(int number) {// 6
// 核心逻辑:
// 不断的去除以 2, 得到余数, 一直到商为日就结束.
// 还需要把余数倒着拼接起来
// 定义一个 StringBuilde r用来拼接余数
StringBuilder sb = new StringBuilder();
// 利用循环不断的除以 2 获取余数
while (true) {
if (number == 0) {
break;
}
// 获取余数 %
int remaindar = number % 2; // 倒着拼接
sb.insert(0, remaindar);
// 除以 2
number = number / 2;
}
return sb.toString();
}
}
第四题:
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.util.Date;
public class Test4 {
public static void main(String[] args) throws ParseException {
// 请使用代码实现计算你活了多少天, 用 JDK7 和 JDK8 两种方式完成
// JDK7
// 规则: 只要对时间进行计算或者判断, 都需要先获取当前时间的毫秒值
// 1. 计算出生年月日的毫秒值
String birthday = "2000年1月1日";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
Date date = sdf.parse(birthday);
long birthdayTime = date.getTime();
// 2. 获取当前时间的毫秒值
long todayTime = System.currentTimeMillis();
// 3. 计算间隔多少天
long time = todayTime - birthdayTime;
System.out.println(time / 1000 / 60 / 60 / 24);
// JDK8
LocalDate ld1 = LocalDate.of(2000, 1, 1);
LocalDate ld2 = LocalDate.now();
long days = ChronoUnit.DAYS.between(ld1, ld2);
System.out.println(days);
}
}
第五题:
import java.time.LocalDate;
import java.util.Calendar;
public class Test5 {
public static void main(String[] args) {
/*
* 判断任意的一个年份是闰年还是平年要求: 用 JDK7 和 JDK8 两种方式判断提示:
* 二月有 29 天是闰年一年有 366 天是闰年
*/
// JDK7
// 我们可以把时间设置为 2000 年 3 月 1 日
Calendar c = Calendar.getInstance();
c.set(2000, 2, 1);
// 月份的范围: 0~11
// 再把日历往前减一天
c.add(Calendar.DAY_OF_MONTH, -1);
// 看当前的时间是 28 号还是 29 号?
int day = c.get(Calendar.DAY_OF_MONTH);
System.out.println(day);
// JDK8
// 月份的范围: 1~12
// 设定时间为 2000 年的 3 月 1 日
LocalDate ld = LocalDate.of(2001, 3, 1);
// 把时间往前减一天
LocalDate ld2 = ld.minusDays(1);
// 获取这一天是一个月中的几号
int day2 = ld2.getDayOfMonth();
System.out.println(day2);
// true: 闰年
// false: 平年
System.out.println(ld.isLeapYear());
}
}
浙公网安备 33010602011771号