【原】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);        // 2147483647
        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);            // 2
        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));        // 11
        System.out.println(Integer.toHexString(10));        // a
        System.out.println(Integer.toOctalString(9));        // 11
    }
}

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));            // 10
        System.out.println(Integer.toString(10, 16));        // a
        System.out.println(Integer.toString(8, 8));            // 10
        
        System.out.println(Integer.toString(10, -2));        // 10
        System.out.println(Integer.toString(17, 17));        // 10
        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));        // 2
        System.out.println(Integer.parseInt("7", 8));        // 7
        System.out.println(Integer.parseInt("F", 16));        // 15
        System.out.println(Integer.parseInt("10", 16));        // 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);
//        }
    }
}