Java学习笔记(六)——基本数据类型及其对应的包装类

包装类

包装类：基本数据类型对应的引用数据类型。

集合无法存储基本数据类型，需要用到包装类。

基本数据类型及其对应的包装类

获取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;
        }

    }
}