Java基础系列文章
Java基础(十)：关键字static、代码块、关键字final
目录
一、为什么需要包装类
- Java提供了两个类型系统，
基本数据类型与引用数据类型 - 使用基本数据类型在于效率，然而当要使用只针对对象设计的API或新特性（例如泛型），怎么办呢？
//情况1：方法形参
Object类的equals(Object obj)
//情况2：方法形参
ArrayList类的add(Object obj)
//没有如下的方法：
add(int number)
add(double d)
add(boolean b)
//情况3：泛型
Set<T>
List<T>
Cllection<T>
Map<K,V>
二、有哪些包装类
- Java针对八种基本数据类型定义了相应的引用类型：包装类（封装类）
封装以后的，内存结构对比：
public static void main(String[] args){
int num = 520;
Integer obj = new Integer(520);
}
自定义包装类
public class MyInteger {
int value;
public MyInteger() {
}
public MyInteger(int value) {
this.value = value;
}
@Override
public String toString() {
return String.valueOf(value);
}
}
三、包装类与基本数据类型间的转换
1、装箱
- 装箱：把基本数据类型转为包装类对象
- 转为包装类的对象，是为了使用专门为对象设计的API和特性
- 基本数值---->包装对象：（
包装类中的valueOf()方法）
Integer obj1 = new Integer(4);//使用构造函数函数
Float f = new Float(“4.56”);
Long l = new Long(“asdf”); //NumberFormatException
Integer obj2 = Integer.valueOf(4);//使用包装类中的valueOf方法
2、拆箱
- 拆箱：把包装类对象拆为基本数据类型
- 转为基本数据类型，一般是因为需要运算，Java中的大多数运算符是为基本数据类型设计的。比较、算术等
- 包装对象---->基本数值：（
包装类对象的xxxValue()方法）
Integer obj = new Integer(4);
int num1 = obj.intValue();
3、自动装箱与拆箱
- 由于我们经常要做基本类型与包装类之间的转换
- 从
JDK5.0开始，基本类型与包装类的装箱、拆箱动作可以自动完成
例如：
Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后，再次装箱，把基本数值转成对象
- 注意：只能与自己对应的类型之间才能实现自动装箱与拆箱
Integer i = 1;
Double d = 1;//错误的，1是int类型
四、基本数据类型、包装类与字符串间的转换
1、基本数据类型转为字符串
- 方式1：调用字符串重载的
valueOf()方法
int a = 10;
//String str = a;//错误的
String str = String.valueOf(a);
- 方式2：更直接的方式
int a = 10;
String str = a + "";
2、字符串转为基本数据类型
- 包装类的parseXxx静态方法
public static int parseInt(String s)：将字符串参数转换为对应的int基本类型public static long parseLong(String s)：将字符串参数转换为对应的long基本类型public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型
int a = Integer.parseInt("整数的字符串");
double d = Double.parseDouble("小数的字符串");
boolean b = Boolean.parseBoolean("true或false");
- Character特殊，没有parse方法
- str.charAt(0)：获取字符串对应角标位置的字符
- str.toCharArray()：获取字符串所有字符分别组合成的数组
String str ="CSDN";
//方法一
char c1 = str.charAt(0);
System.out.println(c1);
//方法二
char[] value = str.toCharArray();
char c2=value[1];
System.out.println(c2);
3、字符串转为包装类
- 包装类的valueOf静态方法
public static Integer valueOf(String s)：将字符串参数转换为对应的Integer包装类public static Long valueOf(String s)：将字符串参数转换为对应的Long包装类public static Double valueOf(String s)：将字符串参数转换为对应的Double包装类
int a = Integer.valueOf("整数的字符串");
double d = Double.valueOf("小数的字符串");
boolean b = Boolean.valueOf("true或false");
4、通过包装类的构造器实现
int i = new Integer(“12”);
其他方式小结：
五、包装类的其它API
1、 数据类型的最大最小值
Integer.MAX_VALUE和Integer.MIN_VALUE
Long.MAX_VALUE和Long.MIN_VALUE
Double.MAX_VALUE和Double.MIN_VALUE
2、字符转大小写
Character.toUpperCase('x');
Character.toLowerCase('X');
3、整数转进制
Integer.toBinaryString(int i)
Integer.toHexString(int i)
Integer.toOctalString(int i)
4、比较的方法
Double.compare(double d1, double d2)
Integer.compare(int x, int y)
六、包装类对象的特点
1、包装类缓存对象
| 包装类 | 缓存对象 |
|---|---|
| Byte | -128~127 |
| Short | -128~127 |
| Integer | -128~127 |
| Long | -128~127 |
| Float | 没有 |
| Double | 没有 |
| Character | 0~127 |
| Boolean | true和false |
示例：
Integer a = 1;
Integer b = 1;
System.out.println(a == b);//true
Integer i = 128;
Integer j = 128;
System.out.println(i == j);//false
Integer m = new Integer(1);//新new的在堆中
Integer n = 1;//这个用的是缓冲的常量对象，在方法区
System.out.println(m == n);//false
Integer x = new Integer(1);//新new的在堆中
Integer y = new Integer(1);//另一个新new的在堆中
System.out.println(x == y);//false
Double d1 = 1.0;
Double d2 = 1.0;
System.out.println(d1==d2);//false 比较地址，没有缓存对象，每一个都是新new的
2、类型转换问题
Integer i = 1000;
double j = 1000;
System.out.println(i==j);//true 会先将i自动拆箱为int，然后根据基本数据类型“自动类型转换”规则，转为double比较
Integer i = 1000;
int j = 1000;
System.out.println(i==j);//true 会自动拆箱，按照基本数据类型进行比较
Integer i = 1;
Double d = 1.0
System.out.println(i==d);//编译报错
3、包装对象不可变
public class TestExam {
public static void main(String[] args) {
int i = 1;
Integer j = new Integer(2);
Circle c = new Circle();
change(i,j,c);
System.out.println("i = " + i);//1
System.out.println("j = " + j);//2
System.out.println("c.radius = " + c.radius);//10.0
}
/*
* 方法的参数传递机制：
* （1）基本数据类型：形参的修改完全不影响实参
* （2）引用数据类型：通过形参修改对象的属性值，会影响实参的属性值
* 这类Integer等包装类对象是“不可变”对象，即一旦修改，就是新对象，和实参就无关了
*/
public static void change(int a ,Integer b,Circle c ){
a += 10;
// b += 10;//等价于 b = new Integer(b+10);
c.radius += 10;
/*c = new Circle();
c.radius+=10;*/
}
}
class Circle{
double radius;
}