Java 基本数据类型 引用数据类型

执行结果截图：

代码：

public class DataType {
    public static void main(String[] args) {
        String name = "汤姆·克鲁斯";
        int kill = 99;
        String title = "‘一竿走天涯’";

        // 以下使用格式化输出

        // 定义格式化字符串sentenceFormat，其中%s表示字符串，%d表示数字，%n表示换行
        String sentenceFormat = "%s 在进行了连续 %d 次野钓以后,获得了 %s 的称号%n%n";

        // 打印格式化字符串变量sentenceFormat，name、kill、title，依次对应该字符串内容里的%s、%d、%s
        // 注意：输出字符串变量的值的话，不需要双引号
        System.out.printf(sentenceFormat, name, kill, title);
        // 注意：println带自动换行，但printf不会自动换行

        float b1 = 1.1F;
        double c1 = 3.14159_2653589793_238462643383279_5028841971693993751058209749445923078164062862089986280348253421170679;

        String show_b1_output = "b1=" + b1;
        // 打印字符串变量show_b1_output的内容
        System.out.println(show_b1_output);

        String show_c1_output = "c1=" + c1;
        // 打印字符串变量show_c1_output的内容，能发现圆周率小数点后100位的值被截为了double数据类型的最大长度范围
        System.out.println(show_c1_output);

        // 打印字符串abc
        System.out.println("abc");

        // 定义字符串变量cde，并赋值“cde”
        String cde = "cde";

        // 打印字符串abc，紧跟着打印字符串变量cde的值
        System.out.println("abc" + cde);

        // 定义字符串变量d，并赋值为字符串abc的内容的子集。子集起始位置为字符串变量d的第1+1）个字符，结束为第3个字符
        String d = "abc".substring(1, 3);

        // 定义字符串变量e，并赋值为字符串变量cde的内容的子集。子集起始位置为字符串变量e的第（2+1）个字符，结束为第3个字符
        String e = cde.substring(2, 3);

        // 打印字符串变量d
        System.out.println(d);

        // 打印字符串变量e
        System.out.println(e);

        //打印一条分隔线
        System.out.println("========================================================");

        //数据类型转换
        int i1 = 1;

        // 八进制————逢八进一
        int i2 = 010;

        // 十六进制，0xF代表15
        int i3 = 0xF;

        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);

        // float类型的0.1
        float f1 = 0.1f;
        // double类型的0.1
        double d1 = 1 / 10;
        // (f1==d1)的判断结果应该是false，因此最好避免完全使用浮点数进行比较
        System.out.println(f1 == d1);

        float f2 = 123456789f;
        float f3 = f2 + 1;
        // （f2==f3）的判断结果应该是true，因此最好避免完全使用浮点数进行比较
        System.out.println(f2 == f3);

        // 以下为数据类型强制转换
        // char类型的值要用单引号
        char ca = 'a';
        char cb = '中';

        // '\u0061' 是Unicode编码，其所对应的是字母a
        char cc = '\u0061';

        System.out.println(ca);

        // 把char类型的变量ca的值强制转换为int类型,发现打印的不是字母a了，而是输出了对应字母a的Unicode编码
        System.out.println((int) ca);

        // 打印出来的应该是中文'中'
        System.out.println(cb);

        // 把char类型的变量ca的值强制转换为int类型,发现打印的不是中文‘中’了，而是输出了对应中文'中'的Unicode编码
        System.out.println((int) cb);

        // 打印出来的应该是字母a
        System.out.println(cc);

        //打印一条分隔线
        System.out.println("========================================================");

        // 定义布尔变量flag，用于后续进行字符串间的比较判断
        boolean flag = true;

        // 以下对字符串sa和sb进行比较：

        // 注意：这里的字符串的值是存在字符串常量池
        String sa = "Hello world";

        // 打印Hello world
        System.out.println(sa);

        // 注意：这里的字符串的值是存在字符串常量池
        String sb = "Hello world";

        // 打印Hello world
        System.out.println(sb);

        // 比较sa和sb，把比较结果赋值给flag
        flag = (sa == sb);

        /* 比较sa和sb 两个字符串，判断结果(flag的值）应该是true。因为它们同属于一个字符串常量池，而它们的字符串内容是相同的，
           它们实际上是指向了同一个对象，它们的值和存储地址都是一样的
        */
        if (flag) {
            // 如果比较的结果是true，打印sa和sb是完全相等的。\n是换行。
            System.out.println("sa is == sb\n");
        } else {
            // 如果比较的结果是false，打印sa和sb是不完全相等的。
            System.out.println("sa is not == sb\n");
        }

        // 以下对字符串sc和sd进行比较

        // 注意：这里的字符串的值是在字符串常量池
        String sc = "Hello\tworld";

        // 打印Hello跟着一个长度为制表符距离的空格，跟着是world
        System.out.println(sc);

        // 注意：这里的字符串的值是在字符串常量池
        String sd = "Hello\nworld";

        // 打印Hello换行，然后world
        System.out.println(sd);

        // 比较字符串sc和sd，把比较结果赋值给flag
        // 判断结果(flag的值）应该是false。因为它们的字符串内容是不同的（一个含有制表符，一个含有换行符）
        flag = (sc == sd);
        if (flag) {
            // 如果比较的结果是true，打印sc和sd是完全相等的。\n是换行。
            System.out.println("sc is == sd\n");
        } else {
            //如果比较的结果是false，打印sc和sd是不完全相等的。
            System.out.println("sc is not == sd\n");
        }

        // 以下对字符串se和sf进行比较

        // new一个字符串hello world，赋值给字符串变量se。注意：这个new出来的值是在堆内存，会分配新的内存地址
        String se = new String("Hello world");

        // 打印字符串变量se的值
        System.out.println(se);

        // new一个字符串hello world，赋值给字符串变量sf。注意：这个new出来的值是在堆内存，会分配新的内存地址
        String sf = new String("Hello world");

        // 打印字符串变量sf的值
        System.out.println(sf);

        // 比较字符串se和sf，把比较结果赋值给flag
        // 比较se和sf两个字符串，判断结果(flag的值）应该是false。因为它们被分配到了不同的存储地址，指向的是两个不同的对象，所以尽管它们有相同的值，却不完全相同。
        flag = (se == sf);
        if (flag) {
            // 如果比较的结果是true，打印se和sf是完全相等的。\n是换行。
            System.out.println("se is == sf\n");
        } else {
            // 如果比较的结果是false，打印se和sf是不完全相等的。
            System.out.println("se is not == sf\n");
        }

        /* 注意：阿里巴巴Java开发手册约定，所有整型包装类对象之间的比较，全部使用equals方法去比较，避免直接用==踩坑，
         * 因为在-127~128之间的值不会new新的对象，用==比较结果会不符合预期逻辑。
        */
    }
}