Java基本数据类型及其包装类

Java基本数据类型及其包装类

正文开始@Assassin

1. 基本类型包装类概述：

为了方便操作基本数据类型值，将其一系列可能用到的方法封装成了对象，在对象中定义了属性和行为丰富了该数据的操作。用于描述该对象的类就称为基本数据类型对象包装类。

• 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
• 常用的操作之一：用于基本数据类型与字符串之间的转换。
• 基本类型和包装类的对应：Byte，Short，Integer，Long，Float，Double，Character，Boolean；

基本数据类型	对应的包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

实际上，JAVA中还存在另外一种基本类型void，它也有对应的包装类Void，不过无法直接对它们进行操作。

1.1 基本数据类型和包装类型的区别：

• 包装类是类，可以实例化出对象，拥有方法和字段，对象的调用都是通过引用对象的地址；

• 包装类型是引用的传递，基本类型是值的传递，本质上来说引用的传递就是通过地址来对对象本体进行操作，值的传递就是简单的拷贝；

• 声明方式不同，基本数据类型不需要new关键字，而包装类型需要在堆内存中进行new来分配内存空间；

• 存储位置不同，基本数据类型直接将数据保存在栈中，而包装类型是把对象放在堆中，然后通过对象的引用 (这里的对象的引用也是存放在栈中，引用存的是对象的地址) 来调用他们，因此，包装类的效率会比基本数据类型的效率要低。

• 初始值不同，比如：int的初始值为0，double类型是0.0，boolean的初始值为false，而包装类型的初始值为null；

• 使用方式不同，基本数据类型直接赋值使用即可，而包装类型是在集合，比如Collection、Map时会使用。

1.2 各包装类的一些基本的属性：

public class PrimitiveTypeTest{
    public static void main(String[] args) {
        System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);
        System.out.println("包装类：java.lang.Byte");
        System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);
        System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE + "\n");

        System.out.println("基本类型：short 二进制位数：" + Short.SIZE);
        System.out.println("包装类：java.lang.Short");
        System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);
        System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE + "\n");
 
        System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);
        System.out.println("包装类：java.lang.Integer");
        System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);
        System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE + "\n");
    
        System.out.println("基本类型：long 二进制位数：" + Long.SIZE);
        System.out.println("包装类：java.lang.Long");
        System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);
        System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE + "\n");

        System.out.println("基本类型：float 二进制位数：" + Float.SIZE);
        System.out.println("包装类：java.lang.Float");
        System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);
        System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE + "\n");

        System.out.println("基本类型：double 二进制位数：" + Double.SIZE);
        System.out.println("包装类：java.lang.Double");
        System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);
        System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE + "\n");

        System.out.println("基本类型：char 二进制位数：" + Character.SIZE);
        System.out.println("包装类：java.lang.Character");
        // 以数值形式而不是字符形式将Character.MIN_VALUE和Character.MAX_VALUE输出到控制台
        System.out.println("最小值：Character.MIN_VALUE=" + (int) Character.MIN_VALUE);
        System.out.println("最大值：Character.MAX_VALUE=" + (int) Character.MAX_VALUE);
}

结果如下：

---

2. 基本数据类型包装类应用:

该包装对象主要用于基本类型和字符串之间的转换；

2.1 基本类型 → 字符串:

• 基本类型数值 + " "
• 使用String类中的静态方法valueOf(基本类型数值)；

2.2 字符串 → 基本类型:

使用包装类中的静态方法xxx parseXxx("xxx")；

• int parseInt(String str);
• long parseLong(String str);
• boolean parseBoolean(String str);
• 只有Character没有parse方法，一般是通过str.CharAt(0)来获取字符串的首元素作为字符;

如果字符串被Integer进行对象的封装，可使用另一个非静态的方法，intValue。

将一个Integer对象转成基本数据类型值。

用Integer的静态方法valueOf(String s);

---

3. Integer类:

3.1 Integer类概述:

Integer 类在对象中包装了一个基本类型 int 的值 该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法

3.2 构造方法:

public Integer(int value) , public Integer(String s)

PS：这个字符串必须是由数字字符组成，这样才能进行相互转换。

3.3 int类型和String类型的相互转换:

返回值	方法	说明
int	intValue()	以 int 类型返回该 Integer 的值
int	parseInt(String s)	将字符串参数作为有符号的十进制整数进行解析
String	toString(int i)	返回一个表示指定整数的 String 对象
Integer	valueOf(int i)	返回一个表示指定的 int 值的 Integer 实例
Integer	valueOf(String s)	返回保存指定的 String 的值的 Integer 对象

代码示例：

/*
 * int类型和String类型的相互转换
 *  
 * int -- String
 *      String.valueOf(number)
 *  
 * String -- int
 *      Integer.parseInt(s)
 */  
public class IntegerDemo {  
    public static void main(String[] args) {  
        // int -- String  
        int number = 100;  
        // 方式1  
        String s1 = "" + number;  
        System.out.println("s1:" + s1);  
        // 方式2  
        String s2 = String.valueOf(number);  
        System.out.println("s2:" + s2);  
        // 方式3  
        // int -- Integer -- String  
        Integer i = new Integer(number);  
        String s3 = i.toString();  
        System.out.println("s3:" + s3);  
        // 方式4  
        // public static String toString(int i)  
        String s4 = Integer.toString(number);  
        System.out.println("s4:" + s4);  
        System.out.println("-----------------");  

        // String -- int  
        String s = "100";  
        // 方式1  
        // String -- Integer -- int  
        Integer ii = new Integer(s);  
        // public int intValue()  
        int x = ii.intValue();  
        System.out.println("x:" + x);  
        //方式2  
        //public static int parseInt(String s)  
        int y = Integer.parseInt(s);  
        System.out.println("y:" + y);  
    }  
}  

运行结果：

3.4 常用的基本进制转换:

返回值	方法	说明
String	toBinaryString(int i)	以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式
String	toOctalString(int i)	以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式
String	toHexString(int i)	以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式

3.5 十进制转换成其他进制:

返回值	方法声明	功能描述
String	toBinaryString(int i)	十进制转换成二进制
String	toOctalString(int i)	十进制转换成八进制
String	toHexString(int i)	十进制转换成十六进制
String	toString(int i,int radix)	十进制转换成任何进制

3.6 其他进制到十进制:

public static int parseInt(String s，int radix)

代码示例：

/*
 * 常用的基本进制转换
 * public static String toBinaryString(int i)
 * public static String toOctalString(int i)
 * public static String toHexString(int i)
 *  
 * 十进制到其他进制
 * public static String toString(int i,int radix)
 * 由这个我们也看到了进制的范围：2-36
 * 为什么呢?0,...9,a...z
 *  
 * 其他进制到十进制
 * public static int parseInt(String s,int radix)
 */  
public class IntegerDemo {  
    public static void main(String[] args) {  
        // 十进制到二进制，八进制，十六进制  
        System.out.println(Integer.toBinaryString(100));  
        System.out.println(Integer.toOctalString(100));  
        System.out.println(Integer.toHexString(100));  
        System.out.println("我是分割线-------------------------");  

        // 十进制到其他进制  
        System.out.println(Integer.toString(100, 10));  
        System.out.println(Integer.toString(100, 2));  
        System.out.println(Integer.toString(100, 8));  
        System.out.println(Integer.toString(100, 16));  
        System.out.println(Integer.toString(100, 5));  
        System.out.println(Integer.toString(100, 7));  
        System.out.println(Integer.toString(100, -7));  
        System.out.println(Integer.toString(100, 70));  
        System.out.println(Integer.toString(100, 1));  
        System.out.println(Integer.toString(100, 17));  
        System.out.println(Integer.toString(100, 32));  
        System.out.println(Integer.toString(100, 37));  
        System.out.println(Integer.toString(100, 36));  
        System.out.println("-------------------------");  

        //其他进制到十进制  
        System.out.println(Integer.parseInt("100", 10));  
        System.out.println(Integer.parseInt("100", 2));  
        System.out.println(Integer.parseInt("100", 8));  
        System.out.println(Integer.parseInt("100", 16));  
        System.out.println(Integer.parseInt("100", 23));  
        //NumberFormatException  
        //System.out.println(Integer.parseInt("123", 2));  
    }  
}  

运行结果：

3.7 自动拆装箱:

/*
 * 自动装箱：把基本类型转换为包装类类型
 * 自动拆箱：把包装类类型转换为基本类型
 *  
 * 注意一个小问题：
 *      在使用时，Integer  x = null;代码就会出现NullPointerException。
 *      建议先判断是否为null，然后再使用。
 */  
public class IntegerDemo {  
    public static void main(String[] args) {  
        // 定义了一个int类型的包装类类型变量i  
        // Integer i = new Integer(100);  
        Integer ii = 100;  
        ii += 200;  
        System.out.println("ii:" + ii);  

        // 通过反编译后的代码  
        // Integer ii = Integer.valueOf(100); //自动装箱  
        // ii = Integer.valueOf(ii.intValue() + 200); //自动拆箱，再自动装箱  
        // System.out.println((new StringBuilder("ii:")).append(ii).toString());  

        Integer iii = null;  
        // NullPointerException  
        if (iii != null) {  
            iii += 1000;  
            System.out.println(iii);  
        }  
    }  
}  

---

4. BigInteger:

BigInteger：可以让超过Integer范围内的数据进行运算。超大整数相加的问题

方法声明	功能描述
add(BigInteger val)	加
subtract(BigInteger val)	减
multiply(BigInteger val)	乘
divide(BigInteger val)	除
divideAndRemainder(BigInteger val)	返回商和余数的数组
BigInteger(String val)	构造方法

5. BigDecimal:

不可变的、任意精度的有符号十进制数。由于在运算的时候，float类型和double很容易丢失精度，演示案例。所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal

方法声明	功能描述
BigDecimal(String val)	构造方法
add(BigDecimal augend)	加
subtract(BigDecimal subtrahend)	减
multiply(BigDecimal multiplicand)	乘
divide(BigDecimal divisor)	除
divide(BigDecimal divisor,int scale,int roundingMode)	商、几位小数、如何取舍

6. Character类:

6.1 Character类概述:

Character类在对象中包装一个基本类型 char 的值，此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然；

6.2 构造方法:

public Character(char value)

6.3 常用方法:

方法	说明
isUpperCase(char ch)	判断是否是大写
isLowerCase(char ch)	判断是否是小写
isDigit(char ch)	判断是否是数字
char toUpperCase(char ch)	转换成大写
char toLowerCase(char ch)	转换成小写

代码示例：

/*
 * public static boolean isUpperCase(char ch):判断给定的字符是否是大写字符
 * public static boolean isLowerCase(char ch):判断给定的字符是否是小写字符
 * public static boolean isDigit(char ch):判断给定的字符是否是数字字符
 * public static char toUpperCase(char ch):把给定的字符转换为大写字符
 * public static char toLowerCase(char ch):把给定的字符转换为小写字符
 */  
public class CharacterDemo {  
    public static void main(String[] args) {  
        // public static boolean isUpperCase(char ch):判断给定的字符是否是大写字符  
        System.out.println("isUpperCase:" + Character.isUpperCase('A'));  
        System.out.println("isUpperCase:" + Character.isUpperCase('a'));  
        System.out.println("isUpperCase:" + Character.isUpperCase('0'));  
        System.out.println("-----------------------------------------");  
        // public static boolean isLowerCase(char ch):判断给定的字符是否是小写字符  
        System.out.println("isLowerCase:" + Character.isLowerCase('A'));  
        System.out.println("isLowerCase:" + Character.isLowerCase('a'));  
        System.out.println("isLowerCase:" + Character.isLowerCase('0'));  
        System.out.println("-----------------------------------------");  
        // public static boolean isDigit(char ch):判断给定的字符是否是数字字符  
        System.out.println("isDigit:" + Character.isDigit('A'));  
        System.out.println("isDigit:" + Character.isDigit('a'));  
        System.out.println("isDigit:" + Character.isDigit('0'));  
        System.out.println("-----------------------------------------");  
        // public static char toUpperCase(char ch):把给定的字符转换为大写字符  
        System.out.println("toUpperCase:" + Character.toUpperCase('A'));  
        System.out.println("toUpperCase:" + Character.toUpperCase('a'));  
        System.out.println("-----------------------------------------");  
        // public static char toLowerCase(char ch):把给定的字符转换为小写字符  
        System.out.println("toLowerCase:" + Character.toLowerCase('A'));  
        System.out.println("toLowerCase:" + Character.toLowerCase('a'));  
    }  
}

运行结果：

6.4 来做个题：

统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)

package com.test;

import java.util.Scanner;

public class CsdnTest {
    /*
     * 统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)
     *
     * 分析：
     *      A:定义三个统计变量
     *          int bigCont=0;
     *          int smallCount=0;
     *          int numberCount=0;
     *      B:键盘录入一个字符串
     *      C:把字符串转换为字符数组
     *      D:遍历字符数组获取到每一个字符
     *      E:判断该字符是
     *          大写  bigCount++;
     *          小写  smallCount++;
     *          数字  numberCount++;
     *      F:输出结果即可
     */

    public static void main(String[] args) {
        // 定义三个统计变量
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;

        // 键盘输入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("Please enter a string：");
        String line = sc.nextLine();

        // 把字符串转换为字符数组
        char[] chs = line.toCharArray();

        // 遍历字符数组获取到每一个字符
        for (int x = 0; x < chs.length; x++) {
            char ch = chs[x];
            // 判断该字符
            if (Character.isUpperCase(ch)) {
                bigCount++;
            } else if (Character.isLowerCase(ch)) {
                smallCount++;
            } else if (Character.isDigit(ch)) {
                numberCount++;
            }
        }

        // 输出结果即可
        System.out.println("大写字母：" + bigCount + "个");
        System.out.println("小写字母：" + smallCount + "个");
        System.out.println("数字字符：" + numberCount + "个");
    }

}

结果展示：