JAVA自学教程之（常用对象API）- 基本数据类型对象包装类



JAVA自学教程之（常用对象API）- 基本数据类型对象包装类。

将基本数据类型（8种：int..）封装成对象的好处就是可以在对象中封装更多的功能和方法来操控该数据

常见的操作就是：用于基本数据类型与字符串之间的转换

基本数据类型对象包装类一般用于基本类型和字符串之间的转换

基本类型—–>字符串

1.基本类型数值+”"

2.用string类中的valueOf（基本类型数值）

3.用Integer.ValueOf();

字符串–>基本类型数值

1.使用包装类中的静态方法XXX  parseXXX(“XXXX”)比如：int parseInt(“123″)/boolean parseBoolean(“true”),但是Character没有parse，多余

2.如果字符串被Integer进行对象的封装

可使用非静态的方法intValue（）

将一个Integer对象转成基本类型数值


（先将字符串封装成对象，然后再用XXXValue转换）

 

  3. public class Main {
  4.     public static void main(String[] args)
  5.     {   /*
  6.          * 基本数据类型包装类
  7.          * 为了方便基本数据类型值，将其封装成了对象，在对象中定义了属性和行为丰富了该数据的操作
  8.          * 用于描述该对象的类就是基本数据类型包装类
  9.          *
  10.          * byte Byte
  11.          * short Shrot
  12.          * int Integer
  13.          * long Long
  14.          * double Double
  15.          * char Character
  16.          * boolean Boolean
  17.          *
  18.          */
  20.         int num;
  21.         System.out.println(Integer.MAX_VALUE);//int的最大值 2147483647
  23.         System.out.println( Integer.toBinaryString(6));//转换成二进制
  24.         Integer x = new Integer(“4″);
  25.         //System.out.println(x);
  26.         int xx = Integer.parseInt(“1234″);//将字符串转化为int，且parseInt方法是静态的
  27.         System.out.println(xx);
  28.         if(Boolean.parseBoolean(“true”))
  29.         {
  30.             Integer xInteger = new Integer(“123″);
  31. <span style=”white-space:pre”>        </span>System.out.println(xInteger.intValue());//将”123″转化为int
  33.     }
  35. }

进制转换

 

 

  3. public class Main {
  4.     public static void main(String[] args)
  5.     {
  6.         /*十进制 -> 其他进制*/
  7.         System.out.println(Integer.toBinaryString(6));//二进制
  8.         System.out.println(Integer.toOctalString(10));//八进制
  9.         System.out.println(Integer.toHexString(20));//十六进制
  10.         System.out.println(Integer.toString(50, 4));//把50以 四进制 的表现
  12.         /*其他进制  ->  十进制*/
  14.         System.out.println(Integer.parseInt(“110″,2));//将110视为二进制的表现形式，并将其转换为十进制
  15.         System.out.println(Integer.parseInt(“3C”,16));
  16.     }
  18. }

自动装箱拆箱

 

 

  1. public class Main {
  2.     public static void main(String[] args)
  3.     {
  4.         Integer a = new Integer(“3″);
  5.         Integer b = new Integer(3);
  6.         System.out.println(a == b);//两个new地址肯定不一样
  7.         System.out.println(a.equals(b));//equals比较的是内容
  9.         System.out.println(a.compareTo(b));
  11.         int num = 5;
  12.         num++;
  13.         Integer xInteger = 5;//xInteger = new Integer(5)->自动装箱
  14.         xInteger++;//XInteger = XInteger + 1   实际操作   xInteger = new Integer(xInteger.intValue()+1)
  15.         //注意异常
  17.         //JDK1.5以后，自动装箱，如果装箱是一个字节，那么该数据会被共享，不会重新开辟空间
  18.         Integer x = 128;
  19.         Integer y = 128;
  20.         System.out.println(x == y);//也就是128以前true，128及128以后是false
  21.         System.out.println(x.equals(y));//true
  22.     }
  23. }

 

关于自动装箱与拆箱：基本数据类型值赋值给了引用数据类型值才装箱，和基本数据类型做运算时才拆箱。

练习：

 

 

  1. import java.util.Arrays;
  3. /*
  4.  * 对一个字符串中的数值进行从小到大的排序
  5.  * ”123 2 5 652 7 -3 4 456 456 12 489″
  6.  */
  7. public class Main {
  8.     private static final String SPS_SIGAL = ” ”;//ctrl+shift+X小写变大写，大写变小写+Y
  10.     public static void main(String[] args) {
  11.         String str = ”123 2 5 652 7 -3 4 456 456 12 489″;
  13.         String[] arr = StringToArray(str);
  15.         int aa[] = StringToInt(arr);
  17.         sort(aa);
  19.         StringBuilder string = IntToString(aa);
  21.         show(string);
  23.     }
  25.     public static StringBuilder IntToString(int[] arr) {
  26.         StringBuilder SB = new StringBuilder();
  27.         for (int i = 0; i < arr.length; i++) {
  28.             if (i == arr.length - 1)
  29.                 SB.append(arr[i]);
  30.             else
  31.                 SB.append(arr[i] + ”,”);
  32.         }
  33.         return SB;
  34.     }
  36.     public static int[] StringToInt(String[] arr) {
  37.         int aa[] = new int[arr.length];
  38.         for (int i = 0; i < arr.length; i++) {
  39.             aa[i] = Integer.parseInt(arr[i]);
  40.         }
  41.         return aa;
  42.     }
  44.     public static String[] StringToArray(String str) {
  45.         String[] arr = str.split(SPS_SIGAL);
  46.         return arr;
  47.     }
  49.     public static void sort(int[] arr) {
  50.         Arrays.sort(arr);// Arrays类中提供了排序方法
  51.         /*
  52.          * for(int i = 0;i<arr.length-1;i++) { for(int j =
  53.          * 0;j<arr.length-1-i;j++) { if(arr[j] > arr[j+1]) swap(arr,j,j+1); } }
  54.          */
  55.     }
  57.     public static void swap(int[] arr, int i, int j) {
  58.         int t = arr[i];
  59.         arr[i] = arr[j];
  60.         arr[j] = t;
  61.     }
  63.     public static void show(StringBuilder string) {
  64.         System.out.println(string);
  65.     }
  66. }