Java教程

近7000字长文详细讲解Java包装类,面试稳了

本文主要是介绍近7000字长文详细讲解Java包装类,面试稳了,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

零基础学习之Java包装类

    • 概述
    • 基本介绍
    • 包装类的使用
      • 装箱
        • 介绍
        • 代码示例
      • 拆箱
        • 介绍
        • 代码示例
    • 包装类常见的API
      • 基本数据类型和字符串之间的转换
      • 数据类型的最大值和最小值
      • 转大小写
      • 转进制
    • 包装类对象的缓存问题
      • 介绍
      • 面试常考
        • 常见笔试或面试问题举例

概述

说起Java包装类就不得不说Java的特性 - 面向对象。Java是Sun公司的程序James Gosling,Bill Joe本来打算试图修改和扩展C 的功能,新开发一个语言Oak的发展。C语言是一个面向过程的语言,改进后的Java是面向对象,这是一个非常大的改进,这也是Java发展至今依旧非常流行的原因。

但是,Java又不是完全的面向对象,它沿用了C语言的基本数据类型(这是为了便于开发者的使用,使得在进行基本的数据计算时,开发者可以直接使用基础类),但当需要和Java其他对象结合使用,如存入集合中,就需要将基础数据类型实例封装为Java对象,这样操作起来又比较麻烦了,为了满足面向对象的这一特性,Java的java.lang包中设置了包装类,使得每一个基本类型都有对应的包装类,这样直接就方便了开发者的使用。

简单理解来说:包装类就是为了使得Java中的基本数据类型具有面向对象的特性。

基本介绍

基本数据类型对应的包装类有8个(,根据其继承关系可以分成三类:Character、Number、Boolean。继承关系图如下:

在这里插入图片描述

这8个包装类和基本数据类型的对应关系如下表:

基本数据类型包装类(java.lang包)
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
charCharacter
booleanBoolean

包装类的使用

装箱

介绍

把基本类型变成包装类对象的过程称为装箱。

转为包装类的对象,是为了使用专门为对象设计的API和特性(比如泛型)

在JDK1.5之前,这个转化过程需要手动实现,即使用包装类的构造器来创建对象。(称为手动装箱);
在JDK1.15之后,这个转化过程可以自动实现,即直接赋值。(称为自动装箱)

代码示例

import org.junit.Test;//导入junit包,用来进行单元测试(比main方法好用,一个类可以创建多个程序入口)

public class Demo7 {

    /**
     *  Integer(Byte,Double,Float,Long,Short类似)
     */
    @Test
    public void test1(){
        int i1 = 10; //定义基本数据类型(整型)

		//基本数据类型转化成包装类
        //手动装箱(使用构造器)
        Integer i2 = new Integer(i1);
        Integer i3 = new Integer("11"); //也可以是字符类型,但是必须是数字,否则报错
        //自动装箱(直接赋值)
        Integer i4 = i1;

		//输出结果,测试验证
        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println(i4);


    }

    /**
     * Character
     */
    @Test
    public void test2(){
        char c1 = 'a'; //定义基本数据类型(字符型)

		//基本数据类型转化成包装类
        //手动装箱(构造器)
        Character c2 = new Character(c1);
		//Character c3 = new Character("a"); 不能是字符,如果是字符就会分不清,本身就是了

        //自动装箱(直接赋值)
        Character c4 = c1;

		//输出结果,测试验证
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c4);
    }

    /**
     * Boolean
     */
    @Test
    public void test3(){
        boolean b1=true; //定义基本数据类型(布尔型)
        
		//基本数据类型转化成包装类
        //手动装箱
        Boolean b2=new Boolean(b1);
        Boolean b3=new Boolean("true");//只要参数不是true这个字符串,都返回false
        if(b3)
            System.out.println("b3=true");
        else
            System.out.println("b3=false");

        //自动装箱(直接赋值)
        Boolean b4=b1;
		
		//输出结果,测试验证
		System.out.println(b1);
		System.out.println(b2);
		System.out.println(b4);

    }
}

拆箱

介绍

与装箱相反,拆箱就是把包装类对象转化为基本类型的过程。

转为基本数据类型,一般是因为需要运算,Java中的大多数运算符是为基本数据类型设计的。比较、算术等,这样的效率更高

在JDK1.5之前,这个转化过程需要手动实现,即通过对应的包装类调用xxxValue()方法。(称为手动拆箱);
在JDK1.15之后,这个转化过程可以自动实现,即直接赋值。(称为自动拆箱)

代码示例

import org.junit.Test;

public class Demo7 {

    /**
     *  Integer(Byte,Double,Float,Long,Short类似)
     */
    @Test
    public void test1(){
        int i1 = 10;//定义基本数据类型(整型)

        //自动装箱,用于后面拆箱
        Integer i4 = i1;

		//包装类转化为基本数据类型
		
        //手动拆箱(调用xxxValue())
        int i5 = i4.intValue();
        //自动拆箱(直接赋值)
        int i6 = i4;
		
		//输出结果,测试验证
        System.out.println(i1);
        System.out.println(i4);
        System.out.println(i5);
        System.out.println(i6);

    }

    /**
     * Character
     */
    @Test
    public void test2(){
        char c1 = 'a';//定义基本数据类型(字符型)

        //自动装箱,用于后面拆箱
        Character c4 = c1;
        
        //包装类转化为基本数据类型
        //手动拆箱
        char c5 = c4.charValue();
        //自动拆箱
        char c6 =c4;

		//输出结果,测试验证
        System.out.println(c1);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);

    }

    /**
     * Boolean
     */
    @Test
    public void test3(){
        boolean b1=true; //定义基本数据类型(布尔型)

       //自动装箱,用于后面拆箱
        Boolean b4=b1;

 		//包装类转化为基本数据类型
        //手动拆箱
        boolean b5=b2.booleanValue();
        //自动拆箱
        boolean b6=b2;
        
		//输出结果,测试验证
        System.out.println(b1);
        System.out.println(b4);
        System.out.println(b5);
        System.out.println(b6);

    }
}

包装类常见的API

基本数据类型和字符串之间的转换

(1)把基本数据类型转为字符串(调用valueOf()方法)

import org.junit.Test;

public class Demo8 {
    /**
     * 基本数据类型转化为字符型
     */
    
    @Test
    public void test(){

    int a = 10; //定义基本数据类型

    //String str = a;//不能直接转换
    
    //方式一:
    String str = a + "";
    //方式二:
    String str1 = String.valueOf(a);
    
    }
}

(2)把字符串转为基本数据类型

String转换成对应的基本类型 ,除了Character类之外,其他所有包装类都具有parseXxx()静态方法可以将字符串参数转换为对应的基本类型:

  • public static byte parseByte(String s):将字符串参数转换为对应的byte基本类型。
  • public static short parseShort(String s):将字符串参数转换为对应的short基本类型。
  • public static int parseInt(String s):将字符串参数转换为对应的int基本类型。
  • public static long parseLong(String s):将字符串参数转换为对应的long基本类型。
  • public static float parseFloat(String s):将字符串参数转换为对应的float基本类型。
  • public static double parseDouble(String s):将字符串参数转换为对应的double基本类型。
  • public static boolean parseBoolean(String s):将字符串参数转换为对应的boolean基本类型。
int a = Integer.parseInt("整数的字符串");
double a = Double.parseDouble("小数的字符串");
boolean b = Boolean.parseBoolean("true或false");

注意: 如果字符串参数的内容无法正确转换为对应的基本类型,
则会抛出java.lang.NumberFormatException异常。

数据类型的最大值和最小值

求某个数据类型的最大值和最小值,直接调用MAX_VALUE和MIN_VALUE方法

import org.junit.Test;

public class Demo8 {
   /**
     * Integer类型的最大值和最小值(其他类似)
     */
    @Test
    public void test1(){
        
        //最大值
        int maxValue = Integer.MAX_VALUE;
        //最小值  
        int minValue = Integer.MIN_VALUE;

		//输出结果,验证测试
        System.out.println(maxValue);
        System.out.println(minValue);
    }

}

转大小写

如果转包装类型的大小写,则需要调用toUpperCase()方法和toLowerCase()方法

import org.junit.Test;

public class Demo8 {
    /**
     * Character转大小写
     */
 
    @Test
    public void test2(){

        char x1 = Character.toUpperCase('x');
        char x2 = Character.toLowerCase('X');

        System.out.println(x1);
        System.out.println(x2);
    }

}

转进制

如果转包装类型的进制,则需要调用对应方法(二进制toBinaryString(),十六进制toHexString(),八进制toOctalString())

package com.atguigu.demo;

import org.junit.Test;

public class Demo8 {

    /**
     * 转进制
     */

    @Test
    public void test3(){

        int i = 6; //十进制的6

        String s1 = Integer.toBinaryString(i); //二进制
        String s2 = Integer.toHexString(i); //十六进制
        String s3 = Integer.toOctalString(i); //八进制

        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
    }
}

包装类对象的缓存问题

介绍

有一部分包装类提供了对象的缓存。对于频繁使用的包装类对象,其类在初始化时就会提前创建好对象,当需要使用该包装类的对象时,如果该对象包装的值在缓存的范围内(这个范围是在Java源码中设置的),就返回缓存的对象;当该对象的值大于缓存的范围,就会创建新的对象并返回。

下面以Integer的源码进行说明

	Integer i = 10; //自动装箱,默认会调用valueOf方法
	
              /**
		     * Integer的自动装箱源码
		     */
                 public static Integer valueOf(int i) {
                     //判断i的值,是否在一个范围  -128 ~ 127  从数组中取值(地址)
                    if (i >= IntegerCache.low && i <= IntegerCache.high)
                        //如果值在这个范围,返回一个数组中的值
                        return IntegerCache.cache[i + (-IntegerCache.low)];
                        //如果不在这个范围,new一个(和自己new的对象没区别)
                    return new Integer(i);
                 }

各个包装类对应的缓存对象大小如下表:

包装类缓存对象
Byte-128~127
Short-128~127
Integer-128~127
Long-128~127
Float没有
Double没有
Character0~127
Booleantrue和false

面试常考

包装类中“== ”与equals的用法比较,可以算是非常重要的考点了。

包装类中的equals方法和String类一样,都是重写了Object类中的equals方法,因此比较的是内容而不是地址,而“= =”比较的依然是引用变量的地址,只是当包装类型和与之相对应的基本类型进行“==”比较时会先做自动拆箱处理。具体可以分类如下:

  • ①如果在默认范围内的自动装箱,则相等(比较地址)
  • ②如果比较的对象有自己new的,则不相等(比较地址)
  • ③如果比较的对象值不在范围内部也是不想等的(比较地址)
  • ④如果有基本数据类型参与对比,包装类型就会自动拆箱,就会变成了基本数据类型的对比,
    这个时候比的就是值了。

常见笔试或面试问题举例

import org.junit.Test;

public class Demo9 {

    @Test
    public void test(){
        Integer i1 = 10; //1. Integer这个类会加载  2. 在创建i2这个局部变量
        Integer i2 = 10; 
        System.out.println(i1 == i2); //true 对比地址

        Integer i3 = new Integer(10);
        System.out.println(i1 == i3); //false 对比地址

        Integer i4 =300;
        Integer i5 =300;
        System.out.println(i4 == i5);//false 对比地址

        Integer i6 = 300;
        int i7 = 300;
        System.out.println(i6 == i7); //true 对比值(因为有基本数据类型(i6会转为int在对比) )

    }
}

这篇关于近7000字长文详细讲解Java包装类,面试稳了的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!