包装类就是基本数据类型所对应的引用数据类型. 就是把基本数据类型变成了一个对象.
包装类可以理解为: 用一个对象, 将基本数据类型包起来.
集合不能存储基本数据类型, 只能存储对象.
JDK5 对获取对象的方式进行了优化.
JDK5 之前, 如果要获取包装类的对象, 需要根据构造方法自己 new. 或者根据静态方法 valueOf() 来获取, 这是一个被重载的方法.
valueOf() 源码:
传进来的参数, 如果在 [-128, 127] 范围内, 就直接从一个数组中去获取, 否则 new 一个出来.
进入 1080 行的 cache 的源码:
可以看见, cache 是一个 Integer 类型的数组.
low 和 high 的值:
程序示例:
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可以看做是同一个东西, 因为在内部可以自动转化.
}
}
包装类 Integer 的成员方法:
程序示例:
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 demo5 {
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);
}
}
练习题:
第一题:
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位日不能开头
*/
// 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, 得到余数, 一直到商为日就结束.
// 还需要把余数倒着拼接起来
// 定义一个StringBuilder用来拼接余数
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());
}
}