1、常用类的介绍
jdk中的内置类型即常用类,由jdk内部预定义好的一些Java类,直接可以拿来使用,例如对字符串的处理使用java.lang.String
;需要处理数值类型转换可以使用java.lang.Integer
,日期处理,文件处理,网络操作等,这些常见操作Java中都提供相关的类以便轻松实现所需功能。
2、封装类
2.1. Java中基本类型和封装类型的对应表
基本类型 | 封装类型 |
---|---|
byte | java.lang.Byte |
short | java.lang.Short |
int | java.lang.Integer |
long | java.lang.Long |
float | java.lang.Float |
double | java.lang.Double |
char | java.lang.Character |
boolean | java.lang.Boolean |
以上所有基本类型提供的引用类型中都封装一些实用的方法,用于进行类型转换,数值处理,进制转换等操作
2.2. Integer
Integer
类是针对int
的封装,一般常见使用Integer进行类型转换,进制转换等操作,java.lang.Integer
类继承自java.lang.Number
(java中所有的数值类型封装类都是从该类继承:Byte,Short,Integer,Long,Float,Double)
Integer提供的构造器:
Integer(int i)
:将一个基本int类型包装为一个Integer对象Integer(String s)
:将一个字符串类型的数值包装为Integer
Integer的常见方法
byteValue()
:将一个Integer对象转换为byte
类型shortValue()
:将一个Integer对象转换为short
类型intValue()
:将一个Integer对象转换为int
类型longValue()
:将一个Integer对象转换为long
类型floatValue()
:将一个Integer对象转换为float
类型valueOf(int i)
:返回一个 Integer实例表示指定的 int值valueOf(String s)
:返回一个 Integer对象持有指定的 String值。doubleValue()
:将一个Integer对象转换为double
类型static int parseInt(String s)
:将字符串类型的数值转换为int
类型static String toBinearyString(int i)
:将十进制整数转换为二进制字符串static String toOctalString(int i)
:将十进制整数转换为八进制字符串static String toHexString(int i)
:将十进制整数转换为十六进制字符串
String s1 = "123";
String s2 = "456";
// int i = 123;
// String s3 = i+"";
System.out.println(s1+s2);
Integer i1 = new Integer(10);
Integer i2 = new Integer("10");
// 0110 6
// 0111 7
// 1000 8
//获取将数值转换为二进制后,数值为1的个数
System.out.println(Integer.bitCount(6));
//将Integer对象转换为byte类型
byte b = i1.byteValue();
int i4 = Integer.parseInt("123");
System.out.println(i4);
//将十进制整数转换为二进制字符串
String bin = Integer.toBinaryString(8);
System.out.println(bin);
//十进制整数转换为八进制
String oct = Integer.toOctalString(8);
System.out.println(oct);
//十进制整数转换为16进制
String hexString = Integer.toHexString(1257);
System.out.println(hexString);
System.out.println(Integer.sum(10,20));
// 0000 0000 0000 0000 0000 0000 0000 1000
System.out.println(Integer.reverse(8));
2.3. 装箱和拆箱机制
在Jdk1.5版本引入自动装箱和拆箱机制,用于实现基本类型数据和封装类型之间无缝转换:
- 自动装箱:将基本类型数据自动封装为包装类
- 自动拆箱:将封装类型中包含基本类型数据拆分成基本类型数值
//自动装箱,内部是通过Integer.valueOf(int i)
Integer i1 = 10;
//自动拆箱,内部通过调用Integer的intValue()方法实现
int i2 = new Integer(10);
注意事项:
- 装箱,拆箱机制应用于所有的封装类
2.4. 经典面试题
观察以下代码,查看运行结果:
Integer x = 120; //cache[index]
Integer y = 120; //cache[index]
System.out.println(x == y); // true
Integer x1 = 150; // new Integer(150);
Integer y1 = 150; // new Integer(150);
System.out.println(x1 == y1); // false
以上的运行结果存在较大差异,造成以上以上结果的原因:Integer内部提供了一个缓存区(默认缓存了从-128~127
之间的Integer对象):
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];
static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;
//声明一个指定范围大小的Integer数组(长度256)
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
//缓存从-128到127之间的整数
cache[k] = new Integer(j++);
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
private IntegerCache() {}
}
在进行两个对象比较的时候默认调用一下方法:
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
如果获取的封装类型在缓存区,则直接取出缓存区中的对象(从数组中获取),如果获取的值不在缓存区,此时会重新
new
一个出来,地址将会发生改变缓存(cache):将一些经常使用到的数据进行缓存,避免每次需要使用时都重新创建获取等(减少时间的开销,提高程序的访问效率)
2.5. 封装类总结
封装类型中常见的方法主要是parseXXX(String s)
:将字符串类型的数据转化为其他基本类型数据。