【原】Java学习笔记024 - 包装类

 package cn.temptation;

 public class Sample01 {
     public static void main(String[] args) {
         // 之前对于基本数据类型都是直接进行声明操作，缺少现成的成员方法可以使用
         // Java针对基本数据类型缺少成员方法的问题，提供了解决方案 ----- 包装类（WrapClass），对基本数据类型进行包装的类

         /*
          *         基本数据类型            对应的包装类
          *         byte                Byte
          *         short                Short
          *         int                    Integer
          *         long                Long
          *
          *         float                Float
          *         double                Double
          *
          *         char                Character
          *
          *         boolean                Boolean
          */

         // 包装类Integer：Integer 类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。 

         // Integer类的常用字段：
         // 1、static int MAX_VALUE ：值为 2^31－1 的常量，它表示 int 类型能够表示的最大值。
         // 2、static int MIN_VALUE ：值为 －2^31 的常量，它表示 int 类型能够表示的最小值。
         System.out.println("Integer.MAX_VALUE:" + Integer.MAX_VALUE);        //
         System.out.println("Integer.MIN_VALUE:" + Integer.MIN_VALUE);        // -2147483648

         // Integer类的构造函数
         // 1、Integer(int value) ：构造一个新分配的 Integer 对象，它表示指定的 int 值。
         // 2、Integer(String s) ：构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
         int i = 2;
         Integer integer1 = new Integer(i);
         System.out.println("integer1:" + integer1);            //
         System.out.println(integer1 instanceof Integer);    // true
         // 语法错误：Syntax error, insert "Dimensions" to complete ArrayType
 //        System.out.println(integer1 instanceof int);
         System.out.println("-----------------------------------------");

         String str = "123";
         Integer integer2 = new Integer(str);
         System.out.println("integer2:" + integer2);
         System.out.println(integer2 instanceof Integer);    // true

         String strEx = "java";
         // 执行异常：java.lang.NumberFormatException: For input string: "java"
         Integer integer3 = new Integer(strEx);
         System.out.println("integer3:" + integer3);
         System.out.println(integer3 instanceof Integer);
     }
 }

 package cn.temptation;

 public class Sample02 {
     public static void main(String[] args) {
         /*
          * Integer包装类的常用成员方法：
          * 1、static String toBinaryString(int i) ：以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。
          * 2、static String toHexString(int i) ：以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。
          * 3、static String toOctalString(int i) ：以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。
          */
         System.out.println(Integer.toBinaryString(3));        //
         System.out.println(Integer.toHexString(10));        // a
         System.out.println(Integer.toOctalString(9));        //
     }
 }

 package cn.temptation;

 public class Sample03 {
     public static void main(String[] args) {
         /*
          * int类型   和   string类型之间的转换
          *
          * int类型----->string类型
          * string类型----->int类型
          */

         // int类型----->string类型
         int i = 2;

         // 方法1、使用String类的valueOf()方法
         String str1 = String.valueOf(i);
         System.out.println(str1);

         // 方法2、使用int类型和空字符串做加法
         String str2 = i + "";
         System.out.println(str2);

         // 方法3、使用Integer包装类作为中间桥梁，使用Integer的构造函数和toString方法
         Integer integer1 = new Integer(i);
         System.out.println(integer1.toString());

         // 方法4、使用Integer包装类的toString(int i)方法
         System.out.println(Integer.toString(i));

         System.out.println("------------------------------------------------");

         // string类型----->int类型
         String str = "123";

         // 方法1、使用Integer包装类作为中间桥梁，使用Integer的构造函数 和 intValue方法
         Integer integer2= new Integer(str);
         System.out.println(integer2.intValue());

         // 方法2、使用Integer包装类的parseInt方法
         int j = Integer.parseInt(str);
         System.out.println(j);

         // 执行异常：java.lang.NumberFormatException: For input string: "java"
         System.out.println(Integer.parseInt("java"));
     }
 }

 package cn.temptation;

 public class Sample04 {
     public static void main(String[] args) {
         /*
          * Integer包装类的常用成员方法：
          * 1、static String toString(int i, int radix) ：返回用第二个参数指定基数表示的第一个参数的字符串表示形式。
          * 2、static int parseInt(String s, int radix) ：使用第二个参数指定的基数，将字符串参数解析为有符号的整数。
          */
         System.out.println(Integer.toString(2, 2));            //
         System.out.println(Integer.toString(10, 16));        // a
         System.out.println(Integer.toString(8, 8));            //

         System.out.println(Integer.toString(10, -2));        //
         System.out.println(Integer.toString(17, 17));        //
         System.out.println(Integer.toString(10, 17));        // a
         System.out.println(Integer.toString(16, 17));        // g

         // 查看Integer包装类的toString方法
         //if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
         //    radix = 10;
         // 查看Character包装类的字段
         //public static final int MIN_RADIX = 2;
         //public static final int MAX_RADIX = 36;

         System.out.println("------------------------------------");

         System.out.println(Integer.parseInt("2", 10));        //
         System.out.println(Integer.parseInt("7", 8));        //
         System.out.println(Integer.parseInt("F", 16));        //
         System.out.println(Integer.parseInt("10", 16));        //

     }
 }

 package cn.temptation;

 public class Sample05 {
     public static void main(String[] args) {
         /*
          * 自动装箱（boxing）   和  自动拆箱（unboxing）
          *
          * 自动装箱：把基本数据类型装换为包装类类型（值类型----->引用数据类型）
          * 自动拆箱：把包装类类型装换为基本数据类型（引用数据类型----->值类型）
          */

         // 自动装箱
         Integer integer1 = new Integer(2);
         System.out.println(integer1);

         // 简化写法:把int类型的数字字面量直接赋值给Integer包装类的变量
         Integer integer2 = 3;
         // 通过反编译class文件，看到
 //        Integer integer2 = Integer.valueOf(3);
         System.out.println(integer2);

         System.out.println("---------------------------------------");

         Integer integer3 = 4;
         integer3 += 5;
         // 通过反编译class文件，看到
 //        Integer integer3 = Integer.valueOf(4);            // 自动装箱
 //        integer3 = Integer.valueOf(integer3.intValue() + 5);        // 先做自动拆箱，拿着基本数据类型int和另一个基本数据类型int做加法，再做自动装箱
         System.out.println(integer3);

         System.out.println("---------------------------------------");

         Integer integer4 = null;
         System.out.println(integer4);
         // 注意：37行语句上已经有警告：Null pointer access: The variable integer4 can only be null at this location
         // 执行异常：java.lang.NullPointerException
 //        System.out.println(integer4.toString());

         // 注意：41行语句上已经有警告：Null pointer access: This expression of type Integer is null but requires auto-unboxing
         // 执行异常：java.lang.NullPointerException
 //        integer4 += 6;
 //        System.out.println(integer4);

         // 对于包装类类型的对象进行非空验证
         // 注意：47行语句上已经有警告：Dead code，因为eclipse判断了integer4就是null
         if (integer4 != null) {
             integer4 += 6;
             System.out.println(integer4);
         }
     }
 }

 package cn.temptation;

 public class Sample06 {
     public static void main(String[] args) {
         // == 比较的是包装类对象的地址，自然不同；equals比较的是内容，自然相同
         Integer integer1 = new Integer(127);
         Integer integer2 = new Integer(127);
         System.out.println(integer1 == integer2);        // false
         System.out.println(integer1.equals(integer2));    // true

         System.out.println("----------------------------------------");

         // == 比较的是包装类对象的地址，自然不同；equals比较的是内容，自然相同
         Integer integer3 = new Integer(128);
         Integer integer4 = new Integer(128);
         System.out.println(integer3 == integer4);        // false
         System.out.println(integer3.equals(integer4));    // true

         System.out.println("----------------------------------------");

         Integer integer5 = 127;
         Integer integer6 = 127;
         System.out.println(integer5 == integer6);        // true
         System.out.println(integer5.equals(integer6));    // true

         System.out.println("----------------------------------------");

         Integer integer7 = 128;
         Integer integer8 = 128;
         System.out.println(integer7 == integer8);        // false
         System.out.println(integer7.equals(integer8));    // true

         // 查看反编译后的class文件
 //        Integer integer5 = Integer.valueOf(127);
 //        Integer integer6 = Integer.valueOf(127);

 //        Integer integer7 = Integer.valueOf(128);
 //        Integer integer8 = Integer.valueOf(128);

         // Integer.valueOf(127)，传入127，使用byte缓冲区，所以使用==，比较的地址是同一个地址
         // Integer.valueOf(128)，传入128，使用new创建新的空间，所以使用==，比较的地址是不同的地址

         // 推测可能是valueOf方法中的写法的差别
         // 查看Integer类的valueOf方法源码
 //        public static Integer valueOf(int i) {
 //            if (i >= IntegerCache.low && i <= IntegerCache.high)
 //                return IntegerCache.cache[i + (-IntegerCache.low)];
 //            return new Integer(i);
 //        }

         // 查看IntegerCache内部类的源码
 //        static final int low = -128;
 //        static final int high;
 //        static final Integer cache[];
 //        static {
 //            int h = 127;
 //            ...
 //        }
 //        high = h;

         // IntegerCache内部类的cache范围：-128~127，也称为byte缓冲区/byte缓存区
     }
 }

 package cn.temptation;

 public class Sample07 {
     public static void main(String[] args) {
         // 类 Character：在对象中包装一个基本类型 char 的值。Character 类型的对象包含类型为 char 的单个字段。

         /*
          * Character类的构造函数：
          * Character(char value) ：构造一个新分配的 Character 对象，用以表示指定的 char 值。
          *
          * Character类的常用成员方法：
          * 1、static boolean isUpperCase(char ch) ：确定指定字符是否为大写字母。
          * 2、static boolean isLowerCase(char ch) ：确定指定字符是否为小写字母。
          * 3、static boolean isDigit(char ch) ：确定指定字符是否为数字。
          * 4、static char toUpperCase(char ch) ：使用取自 UnicodeData 文件的大小写映射信息将字符参数转换为大写。
          * 5、static char toLowerCase(char ch) ：使用取自 UnicodeData 文件的大小写映射信息将字符参数转换为小写。
          */
         Character character = new Character('a');
         System.out.println(character);                // a
         System.out.println("------------------------------------");

         System.out.println(Character.isUpperCase('A'));        // true
         System.out.println(Character.isUpperCase('a'));        // false
         System.out.println(Character.isLowerCase('A'));        // false
         System.out.println(Character.isLowerCase('a'));        // true

         System.out.println(Character.isDigit('1'));        // true
         System.out.println(Character.isDigit('a'));        // false
         System.out.println("------------------------------------");

         System.out.println(Character.toUpperCase('a'));        // A
         System.out.println(Character.toLowerCase('A'));        // a
     }
 }

 package cn.temptation;

 import java.util.Scanner;

 public class Sample08 {
     public static void main(String[] args) {
         // 需求：根据键盘录入的字符串（仅限大写字符、小写字符、数字字符），统计有多少个大写字符、多少个小写字符、多少个数字字符？（使用包装类）

         String str = "";
         // 大写字符个数
         int upperCount = 0;
         // 小写字符个数
         int lowerCount = 0;
         // 数字字符个数
         int digitCount = 0;

         System.out.println("输入一个字符串（仅限大写字符、小写字符、数字字符）：");
         Scanner input = new Scanner(System.in);
         if (input.hasNextLine()) {
             str = input.nextLine();
         } else {
             System.out.println("输入不正确！");
         }
         input.close();

         char[] arrChar = str.toCharArray();

         for (char item : arrChar) {
             if (Character.isUpperCase(item)) {
                 upperCount++;
             } else if(Character.isLowerCase(item)) {
                 lowerCount++;
             } else if (Character.isDigit(item)) {
                 digitCount++;
             }
         }

         System.out.println("字符串" + str + "中，大写字符有：" + upperCount + "个，小写字符有：" + lowerCount + "个，数字字符有：" + digitCount + "个");
     }
 }

 package cn.temptation;

 public class Sample09 {
     public static void main(String[] args) {
         int[] arr1 = null;
         System.out.println(arr1);        // null
         System.out.println("--------------------------------");

         float[] arr2 = null;
         System.out.println(arr2);        // null
         System.out.println("--------------------------------");

         boolean[] arr3 = null;
         System.out.println(arr3);        // null
         System.out.println("--------------------------------");

         char[] arr4 = null;
         // 执行异常：java.lang.NullPointerException
         System.out.println(arr4);

         // 查看反编译class文件，发现没有区别
 //        int arr1[] = null;
 //        System.out.println(arr1);
 //        System.out.println("--------------------------------");
 //        float arr2[] = null;
 //        System.out.println(arr2);
 //        System.out.println("--------------------------------");
 //        boolean arr3[] = null;
 //        System.out.println(arr3);
 //        System.out.println("--------------------------------");
 //        char arr4[] = null;
 //        System.out.println(arr4);

         // 所以，推测打印方法println()是否有不同的处理
         // 通过查看println()方法，可以看出，打印int[]、float[]、boolean[]数组，都是调用String的valueOf方法，打印出"null"
         // 而打印char[]数组，调用write()方法，因为null没有相应的属性，所以使用时产生空指针异常

 //        public void println(Object x) {
 //            String s = String.valueOf(x);
 //            synchronized (this) {
 //                print(s);
 //                newLine();
 //            }
 //        }
 //
 //        调用String类的valueOf方法
 //        public static String valueOf(Object obj) {
 //            return (obj == null) ? "null" : obj.toString();
 //        }
 //
 //        public void println(char x[]) {
 //            synchronized (this) {
 //                print(x);
 //                newLine();
 //            }
 //        }

 //        public void print(char s[]) {
 //            write(s);
 //        }
     }
 }