正文开始@Assassin目录
- Java基本数据类型及其包装类
- 1. 基本类型包装类概述：
- 1.1 基本数据类型和包装类型的区别：
- 1.2 各包装类的一些基本的属性：
- 2. 基本数据类型包装类应用:
- 2.1 基本类型 → 字符串:
- 2.2 字符串 → 基本类型:
- 3. Integer类:
- 3.1 Integer类概述:
- 3.2 构造方法:
- 3.3 int类型和String类型的相互转换:
- 3.4 常用的基本进制转换:
- 3.5 十进制转换成其他进制:
- 3.6 其他进制到十进制:
- 3.7 自动拆装箱:
- 4. BigInteger:
- 5. BigDecimal:
- 6. Character类:
- 6.1 Character类概述:
- 6.2 构造方法:
- 6.3 常用方法:
- 6.4 来做个题：
为了方便操作基本数据类型值，将其一系列可能用到的方法封装成了对象，在对象中定义了属性和行为丰富了该数据的操作。用于描述该对象的类就称为基本数据类型对象包装类。
- 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
- 常用的操作之一：用于基本数据类型与字符串之间的转换。
- 基本类型和包装类的对应：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时会使用。
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(基本类型数值)；
使用包装类中的静态方法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 对象 |
代码示例：
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);
}
}
运行结果：
| 返回值 | 方法 | 说明 |
|---|---|---|
| String | toBinaryString(int i) | 以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式 |
| String | toOctalString(int i) | 以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式 |
| String | toHexString(int i) | 以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式 |
| 返回值 | 方法声明 | 功能描述 |
|---|---|---|
| String | toBinaryString(int i) | 十进制转换成二进制 |
| String | toOctalString(int i) | 十进制转换成八进制 |
| String | toHexString(int i) | 十进制转换成十六进制 |
| String | toString(int i,int radix) | 十进制转换成任何进制 |
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));
}
}
运行结果：
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) | 构造方法 |
不可变的、任意精度的有符号十进制数。由于在运算的时候，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) | 商、几位小数、如何取舍 |
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 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'));
}
}
运行结果：
统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
package com.test;
import java.util.Scanner;
public class CsdnTest {
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 + "个");
}
}
结果展示：
