Java学习笔记(六)——基本数据类型及其对应的包装类
文章目录
-
- 包装类
-
- 基本数据类型及其对应的包装类
- 获取Integer对象的方式(了解)
-
- 获取Integer对象两种方式的区别(掌握)
- 包装类的计算：自动装箱和自动拆箱
- Integer成员方法
- 综合练习
-
- 练习1
- 练习2
- 练习3
- 练习4
- 练习5
包装类
包装类：基本数据类型对应的引用数据类型。
集合无法存储基本数据类型，需要用到包装类。
基本数据类型及其对应的包装类
获取Integer对象的方式(了解)
public class test30 {
public static void main(String[] args) {
Integer i0 = new Integer(10);
Integer i1 = new Integer("123");
Integer i2 = Integer.valueOf(10);
Integer i3 = Integer.valueOf("145");
Integer i4 = Integer.valueOf("110", 2);
System.out.println(i0); //10
System.out.println(i1); //123
System.out.println(i2); //10
System.out.println(i3); //145
System.out.println(i4); //6
}
}
获取Integer对象两种方式的区别(掌握)
public class test31 {
public static void main(String[] args) {
Integer i1=new Integer(127);
Integer i2=new Integer(127);
System.out.println(i1==i2); //false
Integer i3=new Integer(128);
Integer i4=new Integer(128);
System.out.println(i3==i4); //false
Integer i5=Integer.valueOf(127);
Integer i6=Integer.valueOf(127);
System.out.println(i5==i6); //true
Integer i7=Integer.valueOf(128);
Integer i8=Integer.valueOf(128);
System.out.println(i7==i8); //false
}
}
注意：==比较的是地址。
查看源码：
IntegerCache.low=-128，IntegerCache.high=127
会先创建【-128-127】的Integer对象放进cache数组，因为实际开发中【-128~127】的数据用的比较多
包装类的计算：自动装箱和自动拆箱
在JDK5的时候提出了一个机制：自动装箱和自动拆箱。
自动装箱：把基本数据类型自动变成其对应的包装类。
自动拆箱：把包装类自动变成其对应的基本数据类型。
public class test32 {
public static void main(String[] args) {
//自动装箱
Integer i=10;
//自动拆箱
Integer i1=Integer.valueOf(20);
int i2=i1;
}
}
Integer成员方法
public class test32 {
public static void main(String[] args) {
Integer i=10;
String binaryString = Integer.toBinaryString(i);
String octalString = Integer.toOctalString(i);
String hexString = Integer.toHexString(i);
String str="123";
int i1 = Integer.parseInt(str);
}
}
注意：Java是强类型语言，不同数据类型的数据无法直接计算；8种包装类，只有Character没有parseXXX方法。
综合练习
练习1
键盘录入一些1~10日之间的整数，并添加到集合中。直到集合中所有数据和超过200为止。
import java.util.ArrayList;
import java.util.Scanner;
public class test33 {
public static void main(String[] args) {
//键盘录入一些1~100之间的整数，并添加到集合中。直到集合中所有数据和超过200为止。
Scanner sc = new Scanner(System.in);
ArrayList<Integer> arrayList = new ArrayList<>();
while (true) {
String str = sc.nextLine();
int in = Integer.parseInt(str);
if (in > 100 || in < 0) {
System.out.println("非法数据！请输入1~100之间的整数：");
continue;
}
arrayList.add(in);
if(sum(arrayList)>200){
break;
}
}
}
public static int sum(ArrayList<Integer> arrayList) {
int sum = 0;
for (int i = 0; i < arrayList.size(); i++) {
sum += arrayList.get(i);
}
return sum;
}
}
练习2
实现parseInt方法的效果，将字符串形式的数据转成整数。
要求：字符串中只能是数字不能有其他字符，最少一位，最多10位，0不能开头
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class test34 {
public static void main(String[] args) {
//实现parseInt方法的效果，将字符串形式的数据转成整数。要求:字符串中只能是数字不能有其他字符最少一位，最多10位,0不能开头
Scanner sc = new Scanner(System.in);
System.out.println("请输入：");
while (true) {
String str = sc.nextLine();
boolean flag = isCharacter(str);
if (!flag) {
System.out.println("非法输入！");
} else if (str.length() > 10) {
System.out.println("非法输入！");
} else {
int sum=0;
int k=1;
for(int i=0;i<str.length();i++){
sum=sum*10+(str.charAt(i)-'0');
}
System.out.println(sum);
}
}
}
public static boolean isCharacter(String str) {
String regex = "[1-9]\\d{0,9}";
return str.matches(regex);
}
}
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class test34 {
public static void main(String[] args) {
//实现parseInt方法的效果，将字符串形式的数据转成整数。要求:字符串中只能是数字不能有其他字符最少一位，最多10位,0不能开头
Scanner sc = new Scanner(System.in);
System.out.println("请输入：");
while (true) {
String str = sc.nextLine();
boolean flag = isCharacter(str);
if (!flag) {
System.out.println("非法输入！");
} else if (str.length() > 10) {
System.out.println("非法输入！");
} else {
int sum=0;
int k=1;
for (int i = str.length()-1; i>=0; i--) {
//System.out.println(str.charAt(i));
sum+=(str.charAt(i)-'0')*k;
k=k*10;
}
System.out.println(sum);
}
}
}
public static boolean isCharacter(String str) {
String regex = "[1-9]\\d{0,9}";
return str.matches(regex);
}
}
练习3
定义一个方法自己实现toBinaryString方法的效果，将一个十进制整数转成字符串表示的二进制
import java.util.ArrayList;
import java.util.Scanner;
public class test35 {
public static void main(String[] args) {
//定义一个方法自己实现toBinaryString方法的效果，将一个十进制整数转成字符串表示的二进制
Scanner sc=new Scanner(System.in);
while (true){
int i=sc.nextInt();
System.out.println(toBinaryString(i));
}
}
public static String toBinaryString(int i){
String str="";
ArrayList<Integer> arrayList=new ArrayList<>();
int k; //余数
while(i!=0){
k=i%2;
arrayList.add(k);
i=i/2;
}
for(int j=arrayList.size()-1;j>=0;j--){
str=str+arrayList.get(j);
}
return str;
}
}
练习4
请使用代码实现计算活了多少天，用JDK7和JDK8两种方式完成
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.Date;
import java.util.Scanner;
import java.util.regex.Pattern;
public class test36 {
public static void main(String[] args) throws ParseException {
//请使用代码实现计算活了多少天，用JDK7和JDK8两种方式完成
Scanner sc = new Scanner(System.in);
System.out.println("请输入生日：(格式 yyyy-MM-dd)");
while (true) {
String str = sc.nextLine();
if(str.matches("\\d{1,4}(-)(1[0-2]|0?[1-9])\\1(0?[1-9]|[1-2]\\d|30|31)")){
System.out.println("JDK7：" + JDK7(str) + "天");
System.out.println("JDK8：" + JDK8(str) + "天");
}else {
System.out.println("非法输入！");
}
}
}
public static long JDK7(String str) throws ParseException {
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
Date date = sdf.parse(str);
Date now=new Date();
long time=now.getTime()-date.getTime();
return time/(1000*24*60*60);
}
public static long JDK8(String str) {
LocalDateTime now=LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
String[] split = str.split("-");
LocalDate localDate=LocalDate.of(Integer.parseInt(split[0]),Integer.parseInt(split[1]),Integer.parseInt(split[2]));
return ChronoUnit.DAYS.between(localDate,now);
}
}
练习5
判断任意的一个年份是闰年还是平年要求:用JDK7和JDK8两种方式
闰年判断：
二月有29天是闰年/一年有366天是闰年
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.Month;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;
public class test38 {
public static void main(String[] args) throws ParseException {
//判断任意的一个年份是闰年还是平年要求:用JDK7和JDK8两种方式判断提示:二月有29天是闰年一年有366天是闰年
Scanner sc = new Scanner(System.in);
System.out.println("请输入日期：(格式 yyyy-MM-dd)");
while (true) {
String str = sc.nextLine();
if (str.matches("\\d{1,4}(-)(1[0-2]|0?[1-9])\\1(0?[1-9]|[1-2]\\d|30|31)")) {
if (JDK7(str)) {
System.out.println("JDK7:");
System.out.println("输入的年份是闰年！");
} else {
System.out.println("输入的年份是平年！");
}
if (JDK8(str)) {
System.out.println("JDK8:");
System.out.println("输入的年份是闰年！");
} else {
System.out.println("输入的年份是平年！");
}
} else {
System.out.println("非法输入！");
}
}
}
public static boolean JDK7(String str) throws ParseException {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date date = sdf.parse(str);
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.set(Calendar.MONTH, 2); //把日期设置成3月1日
calendar.set(Calendar.DAY_OF_MONTH,1);
calendar.add(Calendar.DAY_OF_MONTH,-1); //把日期减1天，看看是几号
int day = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(day);
if (day == 29) {
return true;
} else {
return false;
}
}
public static boolean JDK8(String str) {
String[] split = str.split("-");
LocalDate localDate = LocalDate.of(Integer.parseInt(split[0]),3,1); //把日期设置成3月1日
LocalDate localDate1 = localDate.minusDays(1); //把日期减1天，看看是几号
int day = localDate1.getDayOfMonth();
System.out.println(day);
if (day == 29) {
return true;
} else {
return false;
}
}
}
闰年判断：
（1）四年一闰百年不闰：即如果year能够被4整除，但是不能被100整除，则year是闰年。
（2）每四百年再一闰：如果year能够被400整除，则year是闰年。
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;
public class test37 {
public static void main(String[] args) throws ParseException {
//判断任意的一个年份是闰年还是平年要求:用JDK7和JDK8两种方式判断提示:二月有29天是闰年一年有366天是闰年
Scanner sc = new Scanner(System.in);
System.out.println("请输入日期：(格式 yyyy-MM-dd)");
while (true) {
String str = sc.nextLine();
if (str.matches("\\d{1,4}(-)(1[0-2]|0?[1-9])\\1(0?[1-9]|[1-2]\\d|30|31)")) {
if(JDK7(str)){
System.out.println("JDK7:");
System.out.println("输入的年份是闰年！");
}else {
System.out.println("输入的年份是平年！");
}
if(JDK8(str)){
System.out.println("JDK8:");
System.out.println("输入的年份是闰年！");
}else {
System.out.println("输入的年份是平年！");
}
} else {
System.out.println("非法输入！");
}
}
}
public static boolean JDK7(String str) throws ParseException {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date date = sdf.parse(str);
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
int year = calendar.get(Calendar.YEAR);
//闰年：
//（1）四年一闰百年不闰：即如果year能够被4整除，但是不能被100整除，则year是闰年。
//（2）每四百年再一闰：如果year能够被400整除，则year是闰年。
if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
return true;
} else {
return false;
}
}
public static boolean JDK8(String str) {
String[] split = str.split("-");
LocalDate localDate=LocalDate.of(Integer.parseInt(split[0]),Integer.parseInt(split[1]),Integer.parseInt(split[2]));
int year = localDate.getYear();
if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
return true;
} else {
return false;
}
}
}