《Java基础入门极速版》

ch05 Java流程控制

5.1 Object

Object类是所有Java类的祖先。每个类都使用 Object 作为超类。所有对象(包括数组)都实现这个类的方法。

在不明确给出超类的情况下，Java会自动把Object作为要定义类的超类。
可以使用类型为Object的变量指向任意类型的对象。
Object类是Java中唯一没有父类的类
Object类有一个默认构造方法pubilc Object()，在构造子类实例时，都会先调用这个默认构造方法。

Object API

方法名	描述
Object()	默认构造方法
toString()	返回该对象的字符串表示。
getClass()	返回一个对象的运行时类。
equals(Object obj)	指示某个其他对象是否与此对象“相等”。
hashCode()	返回该对象的哈希码值。
clone()	创建并返回此对象的一个副本。
notify()	唤醒在此对象监视器上等待的单个线程。
notifyAll()	唤醒在此对象监视器上等待的所有线程。
wait()	导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。
wait(long timeout)	导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量。
wait(long timeout, int nanos)	导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量。
finalize()	当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

equals() (判断两个对象是否相等)

基本数据类型，也称原始数据类型(byte,short,char,int,long,float,double,boolean)，他们之间的比较，用双等号(==)比较的是他们的值是否相等。
复合数据类型(类)
- 当他们用(==)进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。
- equals()这个方法的初始行为是比较对象的内存地址，但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。

【例题1】 Object举例

package cn.du.ch05;

public class Java01_Object {
    public static void main(String[] args) {

        // TODO 常见类和对象
        System.out.println("常见类和对象 - Object对象【杜老师改编】");
        // java.lang.Object : 对象
        Object obj = new Person();
        // Object obj = new User();

        // 讲对象转换成字符串。
        // toString默认打印的就是对象的内存地址，所以，为了能够更直观理解对象的内容，所以可以重写这个方法
        System.out.println("obj.toString(): "+ obj.toString());

        // TODO 获取对象的内存地址
        System.out.println("obj.hashCode(): " + obj.hashCode());

        // TODO 判断两个对象是否相等, 如果相等，那么返回true，否则返回false
        // equals方法比较对象时，默认比较就是内存地址
        Person other = new Person();
        System.out.println("other.hashCode(): "+other.hashCode());
        System.out.println("obj.equals(other)= "+obj.equals(other));

        // getClass获取对象的类型信息
        Class<?> aClass = obj.getClass();
        System.out.println("简洁类名：" + aClass.getSimpleName());
        System.out.println("包名："+aClass.getPackageName());
        System.out.println("obj的父类名称：" + aClass.getSuperclass().getSimpleName());
    }
}
class Person {    // Object是超类----所有未指明父类的父类
    public String name = "杜老师";

    @Override
    public String toString() {
        return "Person["+name+"]";
    }

//    @Override
//    public boolean equals(Object obj) {
//        return true;
//    }
}

class User extends Person {

}

5.2 数组

【例题2】数组举例之一

package cn.du.ch05;

public class Java02_Object {
    public static void main(String[] args) {

        // TODO 常见类和对象 - 数组
//        User1 user1 = new User1();
//        User1 user2 = new User1();
//        User1 user3 = new User1();
//        User1 user4 = new User1();
//
//        user1.test();
//        user2.test();
//        user3.test();
//        user4.test();

        System.out.println("常见类和对象 - 数组【杜老师整理】");
        // 0, 1, 2, 3
        User1[] users = new User1[5];
        for ( int i = 0; i < users.length; i++ ) {
            users[i] = new User1();
            users[i].test();
        }

        // TODO 数组的声明方式：类型[] 变量；
        // TODO 数组的创建：new 类型[容量]；
        String[] names = new String[3];
        // 给数组的小格子添加数据，添加的方式为 ：数组变量[索引] = 数据
        // 添加数据和访问数据时，索引是不能超过指定的范围的（0 ~ length-1）
        // 如果重复给相同的索引添加数据，那么等同于修改数据
        names[0] = "张三";
        names[0] = "张山";  // 覆盖
        names[1] = "李四";
        names[2] = "王五";
        // names[3] = "赵六";  // 索引超过指定的范围的（0 ~ length-1）

        // 查询(访问)数据，访问的方式为 ：数组变量[索引]
//        System.out.println(names[0]);
//        System.out.println(names[1]);
//        System.out.println(names[2]);
        System.out.println("****************************");
        for ( int i = 0; i < names.length; i++ ) {
            System.out.println(names[i]);
        }
    }
}
class User1 {
    public void test() {
        System.out.println("  test()方法运行...");
    }
}

【例题3】数组举例之二

package cn.du.ch05;

public class Java03_Object {
    public static void main(String[] args) {

        // TODO 常见类和对象 - 数组
        System.out.println("常见类和对象 - 数组【杜老师改编】");
        int[] nums = new int[3];
        nums[0] = 1;
        for (Object num : nums) {
            System.out.print(num+"    ");
        }
        System.out.println("\nnums.length = "+ nums.length+"\n");

        String[] 直辖市 = {"北京", "天津", "上海", "重庆"};
        System.out.println(直辖市);
        System.out.println(直辖市.toString());
        for (String name : 直辖市) {
            System.out.print(name+"    ");
        }
        System.out.println("\n直辖市.length = "+直辖市.length+"\n");

        // 二维数组
        String[][] 省区市 = {{"特别行政区", "香港", "澳门"}, {"自治区", "新疆", "西藏", "广西", "内蒙", "宁夏"}, {"直辖市", "北京", "天津", "上海", "重庆"},{"省", "河北", "山西", "黑龙江", "吉林", "辽宁", "江苏", "浙江", "安徽", "福建", "江西", "山东", "河南", "湖北", "湖南", "广东", "海南", "四川", "贵州", "云南", "陕西", "甘肃", "青海", "台湾"}};
        for ( String[] row: 省区市 ) {
            for ( String x: row ) {
                System.out.print(x + "  ");
            }
            System.out.println();
        }
        System.out.println("省区市.length = "+省区市.length);
        System.out.println("省区市[2].length = "+省区市[2].length);
        System.out.println("省区市[3].length = "+省区市[3].length);
        System.out.println();

        // 标准的二维数组
        String[][] namess = new String[3][3];
        namess[0][1] = "杜老师";
        System.out.println("namess[1][1] = "+namess[1][1]);
        for ( int row = 0; row < 3; row++ ) {
            for ( int col = 0; col < 3; col++ ) {
                System.out.print(namess[row][col] + "      ");
            }
            System.out.println();
        }
    }
}

【例题4】二维数组-九层妖塔

package cn.du.ch05;

public class Java03_Object_Test {
    public static void main(String[] args) {

        // TODO 常见类和对象
        // 二维数组-九层妖塔
        /*
            *
           ***
          *****
         *******
         */
        // 1 => 1
        // 2 => 3
        // 3 => 5
        // 4 => 7

        // 1 => 0
        // 2 => 1
        // 3 => 2
        // 4 => 3

        // 0 =>   8
        // 1 =>  789
        // 2 => 678910

        int row = 9;
        int col = 2 * (row - 1) + 1;
        System.out.println("二维数组-九层妖塔[【杜老师改编】");

        String[][] nineTower = new String[row][col];

        for ( int i = 0; i < row; i++ ) {
            for ( int j = 0; j < col; j++ ) {
                if ( j >= ( row - 1 ) - i && j <= ( row - 1 ) + i  ) {
                    nineTower[i][j] = "*";
                } else {
                    nineTower[i][j] = " ";
                }
            }
        }

        for ( int i = 0; i < row; i++ ) {
            for ( int j = 0; j < col; j++ ) {
                System.out.print(nineTower[i][j]);
            }
            System.out.println();
        }
    }
}

【例题5】数组-排序举例

package cn.du.ch05;

public class Java03_Object_Test_1 {
    public static void main(String[] args) {

        // TODO 常见类和对象-数组-排序
        System.out.println("数组-排序【杜老师改编】");
        int[] nums = {1,4,3,5,2};
        for (int num : nums) {
            System.out.print(num+"    ");
        }
        System.out.println();

        // TODO 希望获取到的数据，1，2，3，4，5
        // 简化需求：将数组中的最大值放置数组的最后
        for ( int j = 0; j < nums.length; j++ ) {
            for ( int i = 0; i < nums.length - j - 1; i++ ) {
                int num1 = nums[i];
                int num2 = nums[i+1];
                if ( num1 > num2 ) {
                    // 左边的数据大于右边的数据，应该交互位置
                    nums[i] = num2;
                    nums[i+1] = num1;
                }
            }
        }

        for (int num : nums) {
            System.out.print(num+"    ");
        }
    }
}

【例题6】数组-选择排序举例

package cn.du.ch05;

public class Java03_Object_Test_2 {
    public static void main(String[] args) {
        // TODO 常见类和对象
        // 数组 - 选择排序
        System.out.print("数组-选择排序【杜老师整理】\n排序前：");
        int[] nums = {1,4,3,5,2};
        for (int num : nums) {
            System.out.print(num+"   ");
        }
        System.out.print("\n排序后：");
        for ( int j = 0; j < nums.length; j++ ) {
            int maxIndex = 0;
            for ( int i = 1; i < nums.length - j; i++ ) {
                if ( nums[i] > nums[maxIndex] ) {
                    maxIndex = i;
                }
            }

            int num1 = nums[nums.length-j-1];
            int num2 = nums[maxIndex];

            nums[maxIndex] = num1;
            nums[nums.length-j-1] = num2;
        }

        for (int num : nums) {
            System.out.print(num+"   ");
        }
    }
}

【例题7】举例

package cn.du.ch05;

public class Java03_Object_Test_3 {
    public static void main(String[] args) {

        // TODO 常见类和对象
        // 数组 - 数据查询 - 二分查找法
        System.out.println("数组-数据查询-二分查找法--对分检索【杜老师整理】");
        int[] nums = {0,1,2,3,4,5,6,7,9,12,18};
        for (int num : nums) {
            System.out.print(num+"   ");
        }
        System.out.println();

        // 查询目标
//        int targetNum = 6;
//        int start = 0;
//        int end =  nums.length - 1;
//        int middle = 0;
//        while ( start <= end ) {
//            middle = (start + end) / 2;
//            if ( nums[middle] > targetNum ) {
//                end = middle - 1;
//            } else if ( nums[middle] < targetNum ) {
//                start = middle + 1;
//            } else {
//                break;
//            }
//        }
        System.out.println(" 6 数据在数组的位置：" + find(nums,6));
        System.out.println(" 0 数据在数组的位置：" + find(nums,0));
        System.out.println("10 数据在数组的位置：" + find(nums,10));
        System.out.println("12 数据在数组的位置：" + find(nums,12));
        System.out.println("15 数据在数组的位置：" + find(nums,15));
        System.out.println("18 数据在数组的位置：" + find(nums,18));
    }

    static int find(int[] nums, int targetNum){
        // 查询目标
        int start = 0;
        int end =  nums.length - 1;
        int middle = 0;
        while ( start <= end ) {
            middle = (start + end) / 2;
            if ( nums[middle] > targetNum ) {
                end = middle - 1;
            } else if ( nums[middle] < targetNum ) {
                start = middle + 1;
            } else {
                break;
            }
        }
        return middle;
    }
}

5.3 字符串

【例题8】字符串举例

package cn.du.ch05;

import java.util.Scanner;

public class Java04_Object_String {
    public static void main(String[] args) throws Exception {

        // TODO 常见类和对象
        // TODO 字符串连续字符组成形成的数据整体
        // java.lang.String
        // 字符串，字符，字节的关系
        System.out.println("字符串，字符，字节的关系【杜老师整理】");

        String name = "杜老师";
        String name2 = "杜老师";
        String name3 = "杜老师";
        String name4 = "杜老师";
        String name1 = new String("杜老师");  //new String是冗余的
        char[] cs = {'a', '中', '国'};
        byte[] bs = {-28,-72,-83,-27,-101,-67};

        String s = new String(cs);
        String s1 = new String(bs, "UTF-8");

        System.out.println(s);
        System.out.println(s1);
        String s2 = "\"";
        // 转义字符：\" => 文字内容的双引号
        // \', \t, \n, \\
        System.out.println("双引号："+s2);
        System.out.println("单引号：\'");
        System.out.println("ab之间tab键：a\tb");
        System.out.println("cd之间换行键：c\nd");
        System.out.println("ef之间转义字符----反斜杠：e\\f");
    }
}

【例题9】字符串操作

package cn.du.ch05;

public class Java04_Object_String_1 {
    public static void main(String[] args) throws Exception {

        // TODO 字符串操作
        System.out.println("字符串操作【杜老师整理】");
        // TODO 拼接：将多个字符串连接在一起
        {
            System.out.println("1. 拼接：将多个字符串连接在一起");
            String s = "a" + "b"; // "ab"
            String s1 = "ab";
            String s2 = "abc" + 1 + 2; // abc12
            String s3 = 1 + "abc" + 2; // 1abc2
            String s4 = (1 + 2) + "abc"; // 3abc

            System.out.println("s.hashCode() = "+s.hashCode());
            System.out.println("s1.hashCode() = "+ s1.hashCode());
            System.out.println(s2);
            System.out.println(s3);
            System.out.println(s4);
            System.out.println(s1.concat("abc")+"\n");
        }

        // TODO 字符串的比较
        {
            System.out.println("2. 字符串的比较");
            String a = "a";
            String b = "A";

            // 相等
            System.out.println("a.equals(b) = "+a.equals(b));
            // 忽略大小写的相等
            System.out.println("a.equalsIgnoreCase(b) = " + a.equalsIgnoreCase(b));

            // i = 正数，a > b
            // i = 负数，a < b
            // i = 0, a = b

            byte b1 = (byte) 'A';
            byte b2 = (byte) 'a';
            System.out.println("A = " + b1);
            System.out.println("a = " + b2);

            int i = a.compareTo(b);
            System.out.println(i);
            // 忽略大小写的比较
            System.out.println(a.compareToIgnoreCase(b)+"\n");
        }

        // TODO 字符串的截断操作 : 截取字符串的操作
        {
            System.out.println("3. 字符串的截断操作");
            String s = "  Hello World   ";
            // 子字符串
            // substring方法用于截取字符串，需要传递两个参数，
            //     第一个参数表示截取字符串的起始位置（索引，包含）
            //     第二个参数表示截取字符串的结束位置（索引，不包含）
            System.out.println(s.substring(0, 3));
            System.out.println(s.substring(0, "Hello".length()));
            System.out.println(s.substring(6, s.length()));
            // substring方法如果只传递一个参数，那么就表示从指定位置开始截取字符串，然后截取到最后
            System.out.println(s.substring(6));
            // 分解字符串 ：根据指定的规则对字符串进行分解。可以将一个完整的字符串，分解成几个部分。
            String[] s1 = s.split(",");
            System.out.println(s1.length);
            for (String s2 : s1) {
                System.out.println(s2);
            }
            // TODO trim : 去掉字符串的首尾空格的意思
            System.out.println("去掉字符串的首尾空格 !" + s.trim() + "!\n");
        }

        // TODO 字符串的替换。
        {
            System.out.println("4. 字符串的替换");
            String s = "Hello World 杜老师"; // Hello Java Java
            // 替换
            System.out.println(s.replace("World 杜老师", "Java"));
            // replaceAll按照指定的规则进行替换
            System.out.println(s.replaceAll("World|杜老师", "Java")+"\n");
        }

        // TODO 字符串的大小写转换
        {
            System.out.println("5. 字符串的大小写转换");
            String s = "Hello World";

            System.out.println(s.toLowerCase());
            System.out.println(s.toUpperCase());
            String className = "user"; // u + ser

            String s1 = className.substring(0, 1); // u
            String s2 = className.substring(1); // ser

            System.out.println(s1.toUpperCase() + s2+"\n");
        }

        // TODO 字符串的查找
        {
            String s = "Hello 杜老师 World World";
            System.out.println("6. 字符串的查找："+s);
            char[] chars = s.toCharArray();
            byte[] bytes = s.getBytes("UTF-8");
            // charAt可以传递索引定位字符串中指定位置的字符
            System.out.println("位置为1的字符："+s.charAt(1));
            // indexof方法用于获取数据在字符串中第一次出现的位置。
            System.out.println("第一次出现World的位置: "+s.indexOf("World"));
            // lastIndexOf方法用于获取数据在字符串中最后一次出现的位置。
            System.out.println("最后一次出现World的位置: "+s.lastIndexOf("World"));
            // 是否包含指定的字符串，返回布尔类型
            System.out.println("是否包含Hello123: "+s.contains("Hello123"));
            // 判断字符串是否以指定的数据开头，返回布尔类型
            System.out.println("是否以Hello开头: "+s.startsWith("Hello"));
            // 判断字符串是否以指定的数据结尾，返回布尔类型
            System.out.println("是否以World结尾: "+s.endsWith("World"));
            // 判断字符串是否为空，空格其实是一个特殊的字符，所以看不到，但是不为空。
            System.out.println("字符串是否为空: "+s.isEmpty());
        }
    }
}

StringBuilder和String区别

相同点：StringBuilder和String都是用来接收和处理字符串类型的数据
不同点：
- String拼接字符串的时候，是先将每个字符串在内存中创建出来，然后再将字符串拼接成一个新的字符串返回，这样做对于几个字符串来说不会有什么效率和感知上的差别。
- StringBuilder它是一种动态对象，它所代表的字符串是可变的，它的字符串拼接原理是在该对象的地址后面加上要拼接的对象，不用反复的去开辟创建新的地址，节省了内存资源也提高了拼接性能，当有大量的拼接需求或者不可知的拼接次数时，推荐使用StringBuilder来进行字符串的拼接。
注意：
- 当修改字符串信息时，此时不许创建对象，可以使用stringBuilder对象
- 使用stringBuilder对象拼接完后，对象的类型是StringBuilder类型，需要toString转换成String类型。
- 一般认为拼接次数超过5次就可以考虑使用StringBuilder进行拼接操作。

【例题10】stringBuilder字符串

package cn.du.ch05;

public class Java04_Object_String_2 {
    public static void main(String[] args) throws Exception {

        // TODO 常见类和对象
        // StringBuilder : 构建字符串

        System.out.println("StringBuilder【杜老师整理】");
        String s = "";
        for ( int i = 0; i < 50; i++ ) {
            s = s + i; // 01234....
        }
        System.out.println(s);

        // "a" + "b" => "ab"
        StringBuilder sb = new StringBuilder();
        for ( int i = 0; i < 30; i++ ) {
            sb.append(i);
        }
        System.out.println(sb.toString());

        StringBuilder s1 = new StringBuilder();
        s1.append("abcdef");
        System.out.println("\ns1.toString()="+s1.toString());
        System.out.println("s1.length()="+s1.length());
        System.out.println("s1.reverse()="+s1.reverse()); // 反转字符串
        System.out.println("s1 1位置 插入d ="+s1.insert(1, "d"));

    }
}

【例题11】String及其unicode

package cn.du.ch05;

public class Java04_Object_String_4 {

    /**
     * 字符串转unicode
     *
     * @param str
     * @return
     */
    public static String str2Unicode(String str) {
        str = (str == null ? "" : str);
        String tmp;
        StringBuffer sb = new StringBuffer(1000);
        char c;
        int i, j;
        sb.setLength(0);
        for (i = 0; i < str.length(); i++) {
            c = str.charAt(i);
            sb.append("\\u");
            j = (c >>> 8); // 取出高8位
            tmp = Integer.toHexString(j);
            if (tmp.length() == 1)
                sb.append("0");
            sb.append(tmp);
            j = (c & 0xFF); // 取出低8位
            tmp = Integer.toHexString(j);
            if (tmp.length() == 1)
                sb.append("0");
            sb.append(tmp);
        }
        return sb.toString();
    }

    /**
     * 字符串转unicode
     *
     * @param str
     * @return
     */
    public static String strToUnicode(String str) {
        StringBuilder sb = new StringBuilder();
        char[] c = str.toCharArray();
        for (int i = 0; i < c.length; i++) {
            sb.append("\\u" + Integer.toHexString(c[i]));
        }
        return sb.toString();
    }

    /**
     * unicode转字符串
     *
     * @param unicode
     * @return
     */
    public static String unicodeToStr(String unicode) {
        StringBuilder sb = new StringBuilder();
        String[] hex = unicode.split("\\\\u");
        for (int i = 1; i < hex.length; i++) {
            int index = Integer.parseInt(hex[i], 16);
            sb.append((char) index);
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        System.out.println("String及其Unicode【杜老师整理】");
        String ucode = str2Unicode("Hollow 世界");
        System.out.println(ucode);
        System.out.println(unicodeToStr(ucode) + "\n");

        ucode = strToUnicode("Hollow 新世界");
        System.out.println(ucode);
        System.out.println(unicodeToStr(ucode) + "\n");

        ucode = strToUnicode("杜兆将");
        System.out.println(ucode);
        System.out.println(unicodeToStr(ucode));

        System.out.print(Character.toString(0x675c));
        System.out.print(Character.toString(0x5146));
        System.out.print(Character.toString(0x5c06));
    }
}

5.4 包装

【例题12】基本数据类型的包装类

package cn.du.ch05;

public class Java05_Object_Datatype {
    public static void main(String[] args) throws Exception {

        // TODO 常见类和对象
        System.out.println("基本数据类型的包装类【杜老师整理】");
        // byte short int long
        // float double
        // char
        // boolean
        // TODO 包装类
        {
            Byte b = null;
            Short s = null;
            Integer i = null;
            Long lon = null;
            Float f = null;
            Double d = null;
            Character c = null;
            Boolean bln = null;
        }

        // TODO 将基本数据类型转换为包装类型
        {
            // 自动装箱
            int i = 10;
            // Integer i1 = new Integer(i);  //已弃用
            // Integer i2 = Integer.valueOf(i);  //不必要的装箱 'Integer.valueOf(i)'
            Integer i3 = i;
            System.out.println("i3的类型："+i3.getClass());
            System.out.println("比较i3.equals(11)："+i3.equals(11));
            System.out.println("比较i3.equals(10)："+i3.equals(10));
            System.out.println("比较 i3 == 10)："+(i3 == 10));
            System.out.println("比较 i3 == 11)："+(i3 == 11));

            // 自动拆箱
            //int i4 = i3.intValue();
            int i5 = i3;
            System.out.println("比较 i == i5)："+(i == i5));
        }
    }
}

5.5 日期、日历类

【例题13】日期

package cn.du.ch05;

import java.text.SimpleDateFormat;
import java.util.Date;

public class Java06_Object_Date {
    public static void main(String[] args) throws Exception {

        // TODO 常见类和对象
        // Date : 日期类
        // 时间戳 ： 毫秒
        SimpleDateFormat sdf0 = new SimpleDateFormat("yyyy-MM-dd HH:mm.ss");
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日");

        long l = System.currentTimeMillis();
        System.out.println("时刻1：long l = System.currentTimeMillis()\n  当下从1970.1.1 0:0:0:000 开始过去的毫秒数 ="+l);
        System.out.println("  当下从1970.1.1 0:0:0:000 开始过去的秒数 ="+(l/1000));
        System.out.println("  当下从1970.1.1 0:0:0:000 开始过去的天数 ="+(l/1000/60/60/24));
        System.out.println("  当下从1970.1.1 0:0:0:000 开始过去的天数 ="+(l/1000/60/60/24/365));
        // 根据时间戳构建指定的日期对象。
        Date d1 =  new Date(l);
        System.out.println("  毫秒数："+d1.getTime());
        System.out.println("  中国标准日期格式 "+sdf0.format(d1));
        System.out.println("  中国标准日期格式 "+sdf1.format(d1));
        System.out.println("  中国标准日期格式 "+sdf2.format(d1));
        Thread.sleep(2000);

        // Date : 日期类
        // Calendar : 日历类
        Date d2 = new Date();
        System.out.println("\n时刻2：Date d2 = new Date();\n  一般Date格式 "+d2);

        // Java格式化日期格式：
        // y (Y) -> 年 -> yyyy
        // m (M) -> MM : 月份，mm:分钟
        // d (D) -> dd : 一个月中的日期，D：一年中的日期
        // h (H) -> h : 12进制， HH：24进制
        // s (S) -> s : 秒，S :毫秒

        // Date -> String
        System.out.println("  中国标准时间格式 "+sdf0.format(d2));
        System.out.println("  中国标准日期格式 "+sdf1.format(d2));
        System.out.println("  中国标准日期格式 "+sdf2.format(d2));

        // String -> Date
        String dateString = "2022-06-01";
        System.out.println("\n时刻3：2022-06-01");
        Date parseDate = sdf1.parse(dateString);
        System.out.println("  默认格式："+parseDate);
        System.out.println("  中国标准时间格式："+sdf0.format(parseDate));
        System.out.println("  中国标准时间格式："+sdf1.format(parseDate));
        System.out.println("  中国标准日期格式："+sdf2.format(parseDate));
        System.out.println("  在当前时刻d1之前："+parseDate.before(d1));
        System.out.println("  在当前时刻d1之后："+parseDate.after(d1));
    }
}

【例题14】日历

package cn.du.ch05;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class Java07_Object_Date {
    public static void main(String[] args) throws Exception {

        // TODO 常见类和对象

        // 日历类
        System.out.println("日历类【杜老师改编】");
        Calendar instance = Calendar.getInstance(); ///当前时间的calendar对象
        System.out.println("instance = "+instance);
        System.out.println("年 = " + instance.get(Calendar.YEAR));
        System.out.println("月 = " + instance.get(Calendar.MONTH));  // 这里二月 为 1
        System.out.println("日 = " + instance.get(Calendar.DATE));
        //System.out.println(instance.get(Calendar.DAY));

        // instance.setTime(new Date());
        instance.add(Calendar.YEAR, -1);
        System.out.println("instance.add(Calendar.YEAR, -1)  年 = " + instance.get(Calendar.YEAR));

    }
}

【例题15】打印日历

package cn.du.ch05;

import java.util.Calendar;
import java.util.Date;

public class Java07_Object_Date_Test {
    public static void main(String[] args) throws Exception {

        // TODO 常见类和对象
        // 打印当前日历
        System.out.println("周一\t周二\t周三\t周四\t周五\t周六\t周日");
        // 获取当前日期的日历对象
        Calendar firstDate = Calendar.getInstance();
        // 把日历对象设定位当前月的第一天 : 10-01
        firstDate.set(Calendar.DAY_OF_MONTH, 1);
        // 获取当前月最大的日期 : 31
        int maxDay = firstDate.getMaximum(Calendar.DAY_OF_MONTH);
        for ( int i = 0; i < maxDay; i++ ) {
            // 当前日期是周几
            int weekX = firstDate.get(Calendar.DAY_OF_WEEK);
            // 当前日期是几号
            int monthY = firstDate.get(Calendar.DAY_OF_MONTH);
            if ( i == 0 ) {
                if (weekX == Calendar.SUNDAY) {
                    for ( int j = 0; j < 6; j++ ) {
                        System.out.print("\t\t");
                    }
                    System.out.println(monthY);
                } else {
                    // 周日是1，周一是2...周六是7
                    for ( int j = 0; j < weekX - 2; j++ ) {
                        System.out.print("\t\t");
                    }
                    System.out.print(monthY);
                    System.out.print("\t\t");
                }
            } else {
                // 不是一号的场合
                if ( weekX == Calendar.SUNDAY ) {
                    System.out.println(monthY);
                } else {
                    System.out.print(monthY);
                    System.out.print("\t\t");
                }
            }
            // 打印日历后，应该增加一天
            firstDate.add(Calendar.DATE, 1);
        }

    }
}

5.6 工具类

【例题16】StringUtil工具类

package cn.du.ch05;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Random;
import java.util.UUID;

public class Java08_Object_Util {
    public static void main(String[] args) throws Exception {
        System.out.println("StringUtil【杜老师】");
        System.out.println("null   是否为空："+StringUtil.isEmpty(null));
        System.out.println("\"\"     是否为空："+StringUtil.isEmpty(""));
        System.out.println("\"   \" 是否为空："+StringUtil.isEmpty("   "));
        System.out.println("\"abc\" 是否为空："+StringUtil.isEmpty("abc"));

        System.out.println("UUID1 = "+StringUtil.makeString());
        System.out.println("UUID2 = "+StringUtil.makeString("abcdedf123456", 6));
        System.out.println("UUID3 = "+StringUtil.makeString("abcdedf123456", 32));
        System.out.println("UUID4 = "+StringUtil.makeString("abcdedf123456", 36));

        System.out.println("今天的日期格式化："+StringUtil.formatDate(new Date(), "yyyy-MM-dd"));
        System.out.println("解析字符串2020-06-14为日期："+StringUtil.parseDate("2020-06-14", "yyyy-MM-dd"));
    }
}
// 字符串工具类
// 1. 工具类不应该创建对象才能使用，也就意味着，可以直接使用类中的属性和方法，一般都声明为静态的。
// 2. 工具类对外提供的属性或方法都应该是公共的。
// 3. 为了使用者开发方便，应该尽量提供丰富的方法和属性
class StringUtil {
    // 非空判断
    public static boolean isEmpty(String str) {
        // 如果字符串为null，为空
        if ( str == null ) {
            return true;
        }
        // 如果字符串为空字符串，为空
        if ( "".equals(str) ) {
            return true;
        }
        // 如果字符串全都是空格，也为空
        if ( "".equals(str.trim()) ) {
            return true;
        }
        if ( str == null || "".equals(str.trim()) ) {
            return true;
        }
        return false;
    }

    public static boolean isNotEmpty(String str) {
        return !isEmpty(str);
    }

    // 生成随机字符串
    public static String makeString() {
        return UUID.randomUUID().toString();
    }

    public static String makeString(String from, int len) {
        if ( len < 1 ) {
            return "";
        } else {
            char[] chars = from.toCharArray();
            StringBuilder str = new StringBuilder();
            for ( int i = 0; i < len; i++ ) {
                Random random = new Random();
                int j = random.nextInt(chars.length);
                char c = chars[j];
                str.append(c);
            }
            return str.toString();
        }
    }

    // 转换字符串 : ISO8859-1 => str => UTF-8
    public static String transform( String source, String encodeFrom, String encodeTo  ) throws Exception {
        byte[] bytes = source.getBytes(encodeFrom);
        return new String(bytes, encodeTo);
    }

    public static Date parseDate( String dateString, String format ) throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.parse(dateString);
    }

    public static String formatDate( Date date, String format ) throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.format(date);
    }
}

5.7 对象比较

【例题17】对象比较

package cn.du.ch05;

import java.util.Calendar;

public class Java09_Object {
    public static void main(String[] args) throws Exception {

        // TODO 常见类和对象
        // 等于
        // 基本数据类型，双等号比较数值
        System.out.println("基本数据类型，双等号比较数值. \nint i = 10; int j = 10; double d = 10.0");
        int i = 10;
        int j = 10;
        System.out.println("  i == j : " + (i == j));
        double d = 10.0;
        System.out.println("  i == d : "+ (i == d));
        // 引用数据类型，双等号比较变量的内存地址
        String s = "abc"; // 字符串常量池
        String s1 = "abc";
        String s2 = new String("abc");   // 新建 1 个 String 实例
        System.out.println("引用数据类型，双等号比较变量的内存地址，比较值用o.equals()");
        System.out.println("String s = \"abc\"; String s1 = \"abc\"; String s2 = new String(\"abc\");");
        System.out.println("  比较变量的内存地址 s == s1 : "+(s == s1));
        System.out.println("  比较变量的内存地址 s == s2 : "+(s == s2));
        System.out.println("  比较字符串数值 s.equals(s2)) : "+s.equals(s2));  //比较字符串数值

        User9 user1 = new User9();
        User9 user2 = new User9();

        System.out.println("\n  user1 == user2 "+ (user1 == user2));
        System.out.println("  比较值 user1.equals(user2) : "+user1.equals(user2));

        // 包装类型 比较值 要用 equals
        // int => Integer => JVM为了操作方便，简化了很多操作
        // Integer缓存：-128 ~ 127
        {
            Integer i1 = 100;
            Integer i2 = 100;
            System.out.println("\n  100 i1 == i2  "+(i1 == i2));
            System.out.println("  100 i1.equals(i2) "+i1.equals(i2));
        }
        {
            Integer i1 = 1000;
            Integer i2 = 1000;
            System.out.println("  1000 i1 == i2  "+(i1 == i2));
            System.out.println("  1000 i1.equals(i2) "+i1.equals(i2));
        }
        {
            Integer i1 = Integer.valueOf(-129);;
            Integer i2 = Integer.valueOf(-129);;
            System.out.println("  -129 i1 == i2  "+(i1 == i2));
            System.out.println("  -129 i1.equals(i2 "+i1.equals(i2));
        }
    }
}
class User9 {

}

《Java基础入门 极速版》

ch05 Java流程控制

5.1 Object

Object API

equals() (判断两个对象是否相等)

【例题1】 Object举例

5.2 数组

【例题2】 数组举例之一

【例题3】 数组举例之二

【例题4】 二维数组-九层妖塔

【例题5】数组-排序举例

【例题6】数组-选择排序举例

【例题7】举例

5.3 字符串

【例题8】字符串举例

【例题9】字符串操作

StringBuilder和String区别

【例题10】stringBuilder字符串

【例题11】String及其unicode

5.4 包装

【例题12】基本数据类型的包装类

5.5 日期、日历类

【例题13】日期

【例题14】日历

【例题15】打印日历

5.6 工具类

【例题16】StringUtil工具类

5.7 对象比较

【例题17】对象比较

《Java基础入门极速版》

【例题2】数组举例之一

【例题3】数组举例之二

【例题4】二维数组-九层妖塔