包装类
- 基本类型-->包装类
- byte-->Byte
- short-->Short
- int-->Integer
- long-->Long
- char-->Character
- float-->Float
- double-->Double
- boolean-->Boolean
- 基本类型转为包装类型：
- 自动装箱Autoboxing：将基本类型直接赋值给包装类变量或者Object类变量
- 包装类型转为包装类型：
- 自动拆箱AutoUnboxing：把包装类对象直接赋值给基本类型变量
- 示例：自动装箱与自动拆箱
public class T1{
public static void main(String[] args) {
Integer inObj=13; //自动装箱
Object boolObj=true; //自动装箱，基本类型赋值给Object类型变量
int i=inObj; //自动拆箱
float f=inObj; //自动拆箱，注意类型匹配
System.out.println(i);
System.out.println(f);
if (boolObj instanceof Boolean) {
boolean b=(Boolean)boolObj; //强制类型转换+自动拆箱
System.out.println(b);
}
}
}
- 字符串型的值转为基本类型：
- 用包装类的静态的parse...()方法。注意没有Character类，String的toCharArray()方法转为字符数组
- 用包装类的构造器
- 基本类型转为字符串
- 静态方法String.valueOf()；
- 基本变量+""；
- 示例：字符串转基本类型
public class Test{
public static void main(String[] args) {
String strByte="127";
String strShort="32767";
String strInt="2147483647";
String strLong="21474836478"; //加了L，用parse和new转，都会失败
String strFloat="3.1415F"; //加了F，用parse和new转，都能成功
String strDouble="3.5665956565";
String strBoolean="true";
byte b1=Byte.parseByte(strByte);
byte b2=new Byte(strByte);
System.out.println(b1+" "+b2);
short s1=Short.parseShort(strShort);
short s2=Short.parseShort(strShort);
System.out.println(s1+" "+s2);
int i1=Integer.parseInt(strInt);
int i2=new Integer(strInt);
System.out.println(i1+" "+i2);
long l1=Long.parseLong(strLong);
long l2=new Long(strLong);
System.out.println(l1+" "+l2);
float f1=Float.parseFloat(strFloat);
float f2=new Float(strFloat);
System.out.println(f1+" "+f2);
double d1=Double.parseDouble(strDouble);
double d2=new Double(strDouble);
System.out.println(d1+" "+d2);
boolean boo1=Boolean.parseBoolean(strBoolean);
boolean boo2=new Boolean(strBoolean);
System.out.println(boo1+" "+boo2);
}
}
输出
127 127
32767 32767
2147483647 2147483647
21474836478 21474836478
3.1415 3.1415
3.5665956565 3.5665956565
true true
- 示例：基本类型转字符串
public class Test{
public static void main(String[] args) {
System.out.println(String.valueOf(127));
System.out.println(String.valueOf(32767));
System.out.println(String.valueOf(2147483647));
System.out.println(String.valueOf(21474836478L)); //注意L
System.out.println(String.valueOf(3.1415F)); //注意F
System.out.println(String.valueOf(3.5665956565));
System.out.println(String.valueOf(true));
}
}
输出如下：
127
32767
2147483647
21474836478 //注意没有L
3.1415 //注意没有F
3.5665956565
true
- 包装类型与基本类型的比较
- 包装类是引用类型，但可以直接用"=="跟基本类型比较
- 包装类与包装类的比较
- 如果包装类对象都是通过构造方法创建的：遵循对象的比较规则，即用"=="比较的是地址，用equals()比较对象的内容
- 如果包装类对象都是通过自动装箱创建，且属于[-128,127]，可以用"=="比较他们的值是否相等；如果在[-128,127]之外，那么遵循对象的比较规则
- 通过自动装箱和构造方法创建的对象，不论是不是属于[-128,127]，都遵循对象的比较规则
- 关于[-128,127]：
- Integer类在初始化时，一个内部类的静态代码块将[-128,127]的每个整数都创建了Integer对象，并保存在一个数组中，今后在将[-128,127]中的一个整数自动装箱成Integer对象时，则直接指向这个数组中对应的对象，因此可以用"=="比较它们的值是否相等
- 示例：包装类与包装类的比较
public class Test{
public static void main(String[] args) {
System.out.println(new Integer(2)==new Integer(2));
System.out.println(new Integer(2).equals(new Integer(2)));
Integer i1=127;
Integer i2=127;
System.out.println("127: i1==i2？ "+(i1==i2));
Integer i3=128;
Integer i4=128;
System.out.println("128: i3==i4？ "+(i3==i4));
Integer i5=new Integer(127);
System.out.println("127: i1==i5？ "+(i1==i5));
Integer i6=new Integer(128);
System.out.println("128: i3==i6？ "+(i3==i6));
}
}
输出如下：
false
true
127: i1i2？ true
128: i3i4？ false
127: i1i5？ false
128: i3i6？ false
- 包装类的compare()方法：compare(a,b)
- a>b：返回1
- a==b：返回0
- a<b：返回-1
- 示例代码：
public class Test{
public static void main(String[] args) {
System.out.println(Boolean.compare(true,false));
System.out.println(Boolean.compare(new Boolean(false),true));
System.out.println(Integer.compare(5,13));
System.out.println(Integer.compare(new Integer(19),new Integer(10)));
}
}
toString()方法
- Object类的toString()方法返回的是类名@十六进制hashCode()值
- 自己定义一个类的时候，一般都得重写toString()方法，用以下格式：类名[主要变量1=值1，主要变量2=值2，...]
对象与对象的相等比较equals()与"=="
-
"==":
- 对引用变量而言，只有两个变量指向同一个对象时，才返回true
- 两个对象如果没有继承关系，那么不能用"=="比较，会出现编译错误
-
equals():
- Object的equals()方法跟"=="一样，指向同一个对象才返回true
- equals()一般都要重写，重写应满足的条件：
- 自反性：对任意x，x.equals(x)一定返回true
- 对称性：对任意x、y，如果x.equals(y)返回true，那么y.equals(x)也要返回true
- 传递性：对任意x、y、z，x.equals(y)返回true，y.equals(z)也返回true，那么x.equals(z)一定也返回true
- 一致性：只要两个对象用于比较的信息没有发生改变，那么不论调用equals()多少次，返回的结构都应该相同
- 对任意不是null的x，x.equals(null)一定返回false
-
equals()重写示例，固定写法
class Person{
private String name;
private String id;
Person(){}
Person(String name,String id){
this.name=name;
this.id=id;
}
public boolean equals(Object obj){
if (this==obj){ //如果二者指向同一个对象，返回true
return true;
}
if (obj!=null && obj.getClass()==Person.class){ //obj不为null，且指向的对象是Person类
Person perObj=(Person)obj; //类型转换
if(this.id.equals(perObj.id)){ //根据id是否相等判断两个Person对象是否相等
return true;
}
}
return false; //如果obj为null或者obj指向的对象不是Person，返回false
}
}
字符串与"=="
- 字符串有两种情况，一种是字符串直接量，存储在常量池中，常量池也在堆内存中；一种是堆内存中的字符串对象，存储在堆内存中
- String的这个问题很复杂，慢慢来看，下面参考：http://www.cnblogs.com/kkgreen/archive/2011/08/24/2151450.html
代码1：
String s1="AB";
String s2="A"+"B";
System.out.println(s1==s2); //true。编译阶段即可确定s2="AB"，运行时，s1和s2都指向常量池的"AB"
代码2：
String s1="AB";
String s2="B";
String s3="A"+s2；
System.out.println(s1==s3); //false。s2是变量，编译阶段不能确定s3的值
代码3：
String s1="AB";
final String s2="B"; //注意多了个final
String s3="A"+s2；
System.out.println(s1==s3); //true。s2的值不可变，编译阶段就确定了s3的值是"AB"
代码4：
public static void main(String[] args) {
String s1="AB";
final String s2=getString(); //注意有final
String s3="A"+s2;
System.out.println(s1==s3); //false。虽然s2值不可变，但是是通过方法返回的，编译阶段也不能确定其值
}
static String getString(){
return "B";
}
代码5：
String s1="AB";
String s2="A";
String s3="B";
String s4=s2+s3;
System.out.println(s1==s4); //false.
代码：6
String s1="AB";
final String s2="A";
final String s3="B";
String s4=s2+s3;
System.out.println(s1==s4); //true.s4的值在编译期即可确定
代码7：开始引入intern()方法
String s1="A";
String s2="B";
String s3=s1+s2; //s3实际指向堆内存中的"AB"
System.out.println(s3==s3.intern()); //true。s3.intern()将堆内存中"AB"对象的地址添加到常量池表中，而不是在常量池中再创建个对象，二者实际都指向堆内存中的对象，因此二者相等
System.out.println(s3=="AB"); //true。s3指向堆内存中"AB"的地址；"AB"按理说应当位于常量池，但常量池中只保存了"AB"在堆内存中的地址，所有二者还是相当
//intern()方法用于将该字符串追加到常量池中，如果已经有了，就返回其引用；如果没有就将地址添加到常量池表中，再返回其引用，实际指向的是堆内存中的对象
代码8：将代码7最后两行代码换个顺序
String s1="A";
String s2="B";
String s3=s1+s2;
System.out.println(s3=="AB"); //false.s3指向堆内存中的对象，"AB"则在常量池中
System.out.println(s3==s3.intern()); //false.s3还是指向堆内存中的对象，s3.intern()返回常量池中的"AB"的地址
- 总结：
- 代码7和8的结果十分诡异，以上所做的解释也只是一种猜测，关键在于intern()方法，在常量池中没有字符串的情况下，是新建个字符串对象，还是将字符串的地址添加在常量池表中
- 凡是编译阶段能确定的字符串，在运行期就在常量池中创建一个运算后的对象，而不会再计算一遍，
这点存疑，从Java1.7开始，常量池位于堆内存 - 用""创建的字符串位于常量池
- 用new String()构造方法创建的字符串位于堆内存中，运行期创建
- 用"+"连接的字符串直接量，在编译器就可以确定连接后的值，因此属于常量池
- 用"+"连接的是字符串和变量或者方法返回值，则要到运行期才能确定，属于堆内存对象
- 其他：
- String s1=new String("ABC");String s2=new String("ABC");这两个语句创建了3个String对象