包装类

包装类

前言:

以前学集合的时候，在泛型的时候提到过基本数据类型需要使用他们的包装类，那到底包装类到底是什么呢，今天就详细聊聊什么是包装类，并且做几道关于包装类的题目。

包装类:基本数据类型对应的引用类型(对象)

各种数据类型对应的包装类

byte Byte short Short char Character int Integer

long Long float Float double Double boolean Boolean

这里只学习Integer对象，因为其他七种都大差不差

获取Integer对象的方式(了解)

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对象

public class Demo1 {
    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对象
        poblic 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);
        System.out.println(i2);

        //2.利用静态方法获取Integer对象(JDK5以前的方式)\
        Integer i3 =Integer.valueOf(1);
        Integer i4 =Integer.valueOf("1");
        Integer i5 =Integer.valueOf("123",8);
        System.out.println(i3);
        System.out.println(i4);
        System.out.println(i5);
    }
}

这两种获取方式区别（掌握）

//3.这两种获取方式区别
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

Integer i10=new Integer(127);
Integer i11=new Integer(127);
System.out.println(i10==i11);//false

Integer i12=new Integer(127);
Integer i13=new Integer(127);
System.out.println(i12==i13);//false

那为什么结果是什么这种呢，其实最后两种我们还是很好理解，new关键字就是堆空间开辟了空间，地址肯定不一样，那么前两种为什么一个是true，一个是false，主要是因为Java认为-128-127之间的数字会经常用，所以在底层把这些数放在了数组中，所以取的时候会先去数组中找，如果有直接把地址拿过来，如果没有就直接new一个空间出来

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer[] cache;
    static Integer[] archivedCache;

    static {
        // high value may be configured by property
        int h = 127;
        String integerCacheHighPropValue =
            VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            try {
                h = Math.max(parseInt(integerCacheHighPropValue), 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(h, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
                // If the property cannot be parsed into an int, ignore it.
            }
        }
        high = h;

        // Load IntegerCache.archivedCache from archive, if possible
        CDS.initializeFromArchive(IntegerCache.class);
        int size = (high - low) + 1;

        // Use the archived cache if it exists and is large enough
        if (archivedCache == null || size > archivedCache.length) {
            Integer[] c = new Integer[size];
            int j = low;
            for(int i = 0; i < c.length; i++) {
                c[i] = new Integer(j++);
            }
            archivedCache = c;
        }
        cache = archivedCache;
        // range [-128, 127] must be interned (JLS7 5.1.7)
        assert IntegerCache.high >= 127;
    }

可以看到low的值是-128，high=h=127

在以前包装类如何进行计算

public class Demo2 {
    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();
        System.out.println(result);

        //JDK5后提出了一个机制：自动装箱和拆箱
        //自动装箱：把基本数据类型自动转为对应的包装类
        //自动拆箱：把包装类自动转为为对应的基本数据类型

        Integer i3=10;
        Integer i4=20;
        System.out.println(i3+i4);
    }
}

Integer的成员方法

public static String toBinaryString(int i) 得到二进制

public static String toOctalString(int i) 得到八进制

public static String toHexString(int i) 得到十六进制

public static String parseIntString s) 将字符串类型的整数转为int类型的整数

注意：

返回值是String类型，这里不演示了

8中包装类中除了Character都有对应的parseXxx方法，进行类型转换

在类型转换的时候，括号中的参数如果不是该类型就会报错

改进键盘录入

import java.util.Scanner;

public class Demo3 {
    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);
    }
}

练习（共五题）

一：键盘录入

import java.util.ArrayList;
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //键盘录入一些1~100的数据，并且添加到集合中
        //直到集合所有数据和超过200为止

        //创建集合
        ArrayList<Integer> list=new ArrayList<>();
        //键盘录入
        Scanner sc=new Scanner(System.in);
        while (true){
            System.out.println("请输入一个整数");
            String numStr=sc.nextLine();
            int num=Integer.parseInt(numStr);
            if (num<1||num>100){
                System.out.println("不在范围中");
                continue;
            }
            else{
                list.add(num);
                //求和
                int sum= getSum(list);
                if (sum>200){
                    System.out.println("集合中所有数据的和已经满足需求");
                    break;
                }
            }
        }
    }

    private static int getSum(ArrayList<Integer> list) {
        int sum=0;
        for (int i = 0; i < list.size(); i++) {
            int num=list.get(i);
            sum=sum+num;
        }
        return sum;
    }
}

二：算法水题

public class Test2 {
    public static void main(String[] args) {
        //自己实现parseInt方法的效果，将字符串形式的数据转成整数
        //要求：
        //        字符串只能是数字不能有其他数字
        //        最少一位，最多十位
        //        0不能开头

        //定义一个字符串
        String str="123";
        //校验字符串
        //先将异常数据过滤掉，剩下来的就是正常的数据.
        if (!str.matches("[1-9]\\d{0,9}")){
            //错误的数据
            System.out.println("错误的数据");
        }else{
            //正确的数据
            int number=0;
            for (int i = 0; i <str.length() ; i++) {
                int c=str.charAt(i)-'0';
                number=number*10+c;
            }

            System.out.println(number);
            //证明是不是基本数据类型
            System.out.println(number+1);
        }


    }
}

三：算法水题

public class Test3 {
    public static void main(String[] args) {
        //定义一个方法自己实现toBinaryString方法的效果,将一个十进制整数转变为字符串表示的二进制
        //除基取余法

        System.out.println(toBinaryString(123));
    }
    public static String toBinaryString(int number){
        //核心：不断除2，得到余数，一直到商为0结束\

        //定义一个StringBuilder对象用于拼接余数
        StringBuilder sb=new StringBuilder();

        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="2002年8月24日";
        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(2002,8,24);
        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天是闰年，28平年

        //JDK7
        //可以把你要判断的年份都设置为3月1日，往前减一天来判断
        //现在先拿2000年举例
        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(2000,3,1);
        //减一天
        LocalDate ld2=ld.minusDays(1);
        //获取这一天是这个月的第几号
        int day2=ld2.getDayOfMonth();
        System.out.println(day2);
    }
}