1. /*
   
2.         *基本数据类型对象包装类,
   
3.         *常见作用：用于基本数据类型和字符串类型之间转换
   
4.         *主要是Integer类的Demo
   
5.         *其他基本类型与其大同小异
   
6. */
   
7. class  MyInteger
   
8. {
   
9.         public static void main(String[] args)
   
10.         {
    
11.         //基本类型转换成字符串
    
12.                 sop(Integer.toString(123));
    
13.                 sop(Float.toString(123));
    
14.                 sop(Double.toString(123));
    
15.                 sop(Character.toString('a'));
    
16. 
    
17.         //字符串转换成基本数据类型
    
18.                 String s="35";
    
19.                 sop(Byte.parseByte(s));
    
20.                 sop(Short.parseShort(s));
    
21.                 sop(Integer.parseInt(s));//把字符串转换成int类型
    
22.                 sop(Long.parseLong(s));
    
23.                 sop(Float.parseFloat(s));
    
24.                 sop(Double.parseDouble(s));
    
25.                 //sop(Character.parseCharacter('a'));无此方法
    
26.                 sop(Boolean.parseBoolean("true"));
    
27. 
    
28.                 Integer i=new Integer(s);//非静态，创建对象再调用数值
    
29.                 sop(i.intValue());
    
30. 
    
31.         //十进制转换成其他进制
    
32.                 int shi=60;
    
33.                 sop(Integer.toBinaryString(shi));//十进制转换成二进制
    
34.                 sop(Integer.toOctalString(shi));//十进制转换成8进制
    
35.                 sop(Integer.toHexString(shi));//十进制转换成16进制
    
36.         //其他进制转换成十进制
    
37.                 sop(Integer.parseInt("111100",2));//二进制转换成十进制
    
38.                 sop(Integer.parseInt("3c",16));//16进制转换成十进制
    
39.                 sop(Integer.parseInt("74",8));//8进制转换成十进制
    
40. 
    
41.         //基本数据类型对象包装类（Integer）新特性1.5后，开发不常用
    
42.                 Integer old=new Integer(123);
    
43.                 Double newer=123.0;//自动装箱
    
44. 
    
45.                 old=old+2;
    
46.                 newer=newer+2.0;//自动拆箱变成int型与2进行运算，在自动装箱给newer。
    
47.                               //自动拆箱方法  newer=newer.intValue()+2;
    
48. 
    
49.                 sop(old);
    
50.                 sop(newer);
    
51. 
    
52. 
    
53.                 Integer m=128;
    
54.                 Integer n=128;
    
55.                 sop(m==n);//结果为false，m和n指向了不同的对象
    
56.                 sop(m.equals(n));//结果为true，因为equals对比的是两个数值
    
57.                 Integer a=127;
    
58.                 Integer b=127;
    
59.                 sop(a==b);//结果为true，因为a和b指向了同一个对象
    
60.                 //因为当数值在byte范围内127~-128时，如果该数值已经存在，则不会另开辟空间。
    
61. 
    
62.                 String str1="abcdefgddddddddddddddddddd";
    
63.                 String str2="abcdefgddddddddddddddddddd";
    
64.                 sop("String="+(str1==str2));//String类没有范围限制，只要数值相同则就表示可以指向同一对象
    
65. 
    
66.                 Double dou1=1.0;
    
67.                 Double dou2=1.0;
    
68.                 sop("Double="+(dou1==dou2));//无论大小都是false
    
69. 
    
70.                 Float f1=1.0f;
    
71.                 Float f2=1.0f;
    
72.                 sop(f1==f2);//无论大小都是false
    
73. 
    
74.                 Byte b1=-127;
    
75.                 Byte b2=-127;
    
76.                 sop(b1==b2);//在不越界的情况下即（127~-128），结果为true
    
77. 
    
78.                 Short s1=127;
    
79.                 Short s2=127;
    
80.                 sop(s1==s2);//与Integer相同。在Byte范围内为true
    
81. 
    
82. 
    
83.         }
    
84. 
    
85.         public static void sop(Object obj)
    
86.         {
    
87.                 System.out.println(obj);
    
88.         }
    
89. }
    

复制代码

如有不足或错误敬请指出。

感谢分享，总结的很不错