【原】Java学习笔记022

package cn.temptation;

public class Sample01 {
    public static void main(String[] args) {
        // 字符串
        // 定义：String 类代表字符串。由多个字符组成的一串数据（类比：羊肉串）。字符数组可以由多个字符组成（类比，整型数组由多个整型数字组成）。
        
        // 字符串的声明及赋值
        // 1、String类代表字符串
        // 2、Java 程序中的所有字符串字面值（如 "abc" ）都作为String类的实例实现。（对比，之前的实例实现通过new关键字进行类的实例化获得类的对象）
        // 3、字符串（字符串字面值）是常量，它们的值在创建后不能更改
        // 4、因为String对象是不可变得，所以可以共享（"abc"这个字符串字面值可以被不同的String类型的对象拿来引用使用）
//        String str = "abc";
        
        // 字符串String类的常用构造函数：
        // 1、String() ：初始化一个新创建的 String 对象，使其表示一个空字符序列。
        // 2、String(byte[] bytes) ：通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
        // 3、String(byte[] bytes, int offset, int length) ：通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。
        // 4、String(char[] value) ：分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
        // 5、String(char[] value, int offset, int count) ：分配一个新的 String，它包含取自字符数组参数一个子数组的字符。
        // 6、String(String original) ：初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。
        
        // 字符串String类的常用成员方法：
        // 1、int length() ：返回此字符串的长度。 
        String string1 = new String();
        System.out.println("string1:" + string1);        // 显示为：string1:   看到显示的结果为无内容，显然String类是没有使用Object类继承而来的toString方法
        System.out.println("string1的长度为：" + string1.length());        // 0
        System.out.println("-------------------------------------------------------");
        
//        byte[] bytes = { 65, 66, 67, 68 };
        byte[] bytes = { 97, 98, 99, 100 };
        String string2 = new String(bytes);
        System.out.println("string2:" + string2);
        System.out.println("string2的长度为：" + string2.length());        // 4
        System.out.println("-------------------------------------------------------");
        
        String string3 = new String(bytes, 1, 2);
        System.out.println("string3:" + string3);                        // bc
        System.out.println("string3的长度为：" + string3.length());        // 2
        
        // offset参数 或 length参数索引超出bytes数组的范围
        // 执行异常：java.lang.StringIndexOutOfBoundsException: String index out of range: 5
//        String string4 = new String(bytes, 3, 2);
//        System.out.println("string4:" + string4);
//        System.out.println("string4的长度为：" + string4.length());
        System.out.println("-------------------------------------------------------");
        
        char[] chars = { 'J', 'a', 'v', 'a', '真', '简', '单' };
        String string5 = new String(chars);
        System.out.println("string5:" + string5);                        // Java真简单
        System.out.println("string5的长度为：" + string5.length());        // 7
        System.out.println("-------------------------------------------------------");
        
        String string6 = new String(chars, 1, 3);
        System.out.println("string6:" + string6);                        // ava
        System.out.println("string6的长度为：" + string6.length());        // 3
        
        // offset参数 或 length参数索引超出chars数组的范围
        // 执行异常：java.lang.StringIndexOutOfBoundsException: String index out of range: 9
//        String string7 = new String(chars, 5, 4);
//        System.out.println("string7:" + string7);                        // ava
//        System.out.println("string7的长度为：" + string7.length());
        System.out.println("-------------------------------------------------------");
        
        String string8 = new String("中华人民共和国");
        System.out.println("string8:" + string8);                        // 中华人民共和国
        System.out.println("string8的长度为：" + string8.length());        // 7
        System.out.println("-------------------------------------------------------");
        
        String string9 = "中华人民共和国";
        System.out.println("string9:" + string9);                        // 中华人民共和国
        System.out.println("string9的长度为：" + string9.length());        // 7
    }
}

package cn.temptation;

public class Sample02 {
    public static void main(String[] args) {
        // 如何理解：字符串是常量，它们的值在创建以后不能更改？
        // 1、使用字符串字面值时，首先到堆内存中的方法区的字符串常量池中查找该字符串字面值是否存在，如果存在则直接拿来使用；如果不存在则创建之
        // 2、字符串字面量的值是常量，这个值在方法区中的字符串常量池中创建后的确没有发生过改变
        
        String str = "Java";        // 首先到堆内存中的方法区的字符串常量池中查找该字符串字面值是否存在，如果存在则直接拿来使用；如果不存在则创建"Java"字面量
        str += "真简单";                // 等价于：str = str + "真简单";
        // 分解：str + "真简单" -----> "Java" + "真简单"，因为到字符串常量池中查找"真简单"这个字符串字面值是否存在，不存在则创建"真简单"字面量
        //        这里的加号作为字符串的连接   -----> "Java真简单"，因为到字符串常量池中查找"Java真简单"这个字符串字面值是否存在，不存在则创建"Java真简单"字面量
        System.out.println(str);    // Java真简单
        
        // 上述三行语句，实际上在字符串常量池中创建了3个字符串字面量
    }
}

package cn.temptation;

public class Sample03 {
    public static void main(String[] args) {
        /*
         * 1、== 做比较
         * A：用在基本数据类型上，比较值是否相等
         * B：用在引用数据类型上，比较地址值是否相同
         * 
         * 2、equals 做比较
         * A：用在引用数据类型上：如果继承自Object类型的equals，还是比较的是地制值是否相同；有内容比较的要求可以通过重写equals方法来实现比较
         */
        
        // 下句是将字符串字面量赋值给String类型的变量，首先去字符串常量池中查找有没有"Java真简单"字符串实例实现，没有就创建之
        String string1 = "Java真简单";
        // 下句是通过new关键字在堆内存中开辟一块空间存放String类型的对象，而该构造函数会使用"Java真简单"这个字符串字面量
        // 使用这个字符串字面量还是去字符串常量池中查找有没有"Java真简单"字符串实例，这时已经存在该字面量了，就不再创建了，直接拿着用
        String string2 = new String("Java真简单");
        
        // 因为string1 和 string2 都是在栈上的声明，string1引用的是字符串字面量"Java真简单"的地址，string2引用的是在堆内存中开辟的空间地址
        // 自然不会相同，也就判断为false
//        System.out.println(string1 == string2);            // false
//        System.out.println("string1`s hashCode:" + string1.hashCode());        // string1`s hashCode:-125004366
//        System.out.println("string2`s hashCode:" + string2.hashCode());        // string2`s hashCode:-125004366
//        
        // String类的常用成员方法：
        // 1、boolean equals(Object anObject) ：将此字符串与指定的对象比较。
        //        将此字符串与指定的对象比较。当且仅当该参数不为 null，并且是与此对象表示相同字符序列的 String 对象时，结果才为 true。 
        // String类的equals方法重写了继承自Object类的equals方法，比较两个字符串对象的内容
        System.out.println(string1.equals(string2));    // true
        
        // instanceof的使用：判断是否为某一类型的实现
        System.out.println(string1 instanceof String);        // true
        System.out.println(string2 instanceof String);        // true
    }
}
// 查看String类的equals方法的源码
//public boolean equals(Object anObject) {
//    if (this == anObject) {
//        return true;
//    }
//    if (anObject instanceof String) {
//        String anotherString = (String)anObject;
//        int n = value.length;
//        if (n == anotherString.value.length) {
//            char v1[] = value;
//            char v2[] = anotherString.value;
//            int i = 0;
//            while (n-- != 0) {
//                if (v1[i] != v2[i])
//                    return false;
//                i++;
//            }
//            return true;
//        }
//    }
//    return false;
//}

package cn.temptation;

public class Sample04 {
    public static void main(String[] args) {
//        String string1 = new String("Java真简单");
//        String string2 = new String("Java真简单");
//        System.out.println(string1 == string2);            // false
//        System.out.println(string1.equals(string2));    // true
//        System.out.println("string1`s hashCode:" + string1.hashCode());            // string1`s hashCode:-125004366
//        System.out.println("string2`s hashCode:" + string2.hashCode());            // string2`s hashCode:-125004366
//        System.out.println("-----------------------------------------");
//        
//        String string3 = new String("Java真简单");
//        String string4 = "Java真简单";
//        System.out.println(string3 == string4);            // false
//        System.out.println(string3.equals(string4));    // true
//        System.out.println("-----------------------------------------");
        
        // string5引用的字符串字面量是字符串常量池中的字面量"Java真简单"（首先也是在常量池中查找是否存在）
        String string5 = "Java真简单";
        // string6引用的字符串字面量就是字符串常量池中的字面量"Java真简单"
        String string6 = "Java真简单";
        System.out.println(string5 == string6);            // true
        System.out.println(string5.equals(string6));    // true
    }
}

package cn.temptation;

public class Sample05 {
    public static void main(String[] args) {
        String string1 = "Java";
        String string2 = "真简单";
        String string3 = "Java真简单";
        
        System.out.println(string3 == string1 + string2);        // false
        // 通过反编译.class文件，发现上句其实是：
        // System.out.println(string3 == (new StringBuilder(String.valueOf(string1))).append(string2).toString());        显然地址不一致
        
        System.out.println(string3.equals(string1 + string2));    // true
        // 通过反编译.class文件，发现上句其实是：
        // System.out.println(string3.equals((new StringBuilder(String.valueOf(string1))).append(string2).toString()));        比较的是内容，显然一致
        System.out.println("----------------------------------------");
        
        System.out.println(string3 == "Java" + "真简单");        // true
        // 通过反编译.class文件，发现上句其实是：
        // System.out.println(string3 == "Java真简单");        显然地址一致
        
        System.out.println(string3.equals("Java" + "真简单"));    // true
        // 通过反编译.class文件，发现上句其实是：
        // System.out.println(string3.equals("Java真简单"));        比较的是内容，显然一致
        System.out.println("----------------------------------------");
        
        System.out.println(string3 == string1 + "真简单");        // false
        // 通过反编译.class文件，发现上句其实是：
        // System.out.println(string3 == (new StringBuilder(String.valueOf(string1))).append("真简单").toString());        显然地址不一致
        
        System.out.println(string3 == "Java" + string2);        // false
        // 通过反编译.class文件，发现上句其实是：
        // System.out.println(string3 == (new StringBuilder("Java")).append(string2).toString());        显然地址不一致
        
        System.out.println(string3.equals(string1 + "真简单"));    // true
        // 通过反编译.class文件，发现上句其实是：
        // System.out.println(string3.equals((new StringBuilder(String.valueOf(string1))).append("真简单").toString()));        比较的是内容，显然一致
        
        System.out.println(string3.equals("Java" + string2));    // true
        // 通过反编译.class文件，发现上句其实是：
        // System.out.println(string3.equals((new StringBuilder("Java")).append(string2).toString()));        比较的是内容，显然一致
        
        /*
         * 结论：
         * 1、字符串变量做加法（连接）时，先去做开辟空间的事情，再去做字符串的连接
         * 2、字符串字面量（常量）做加法（连接）时，先做字符串的连接，再去常量池中查找是否存在，存在就直接使用，不存在就创建之
         * 3、字符串变量 和 字符串字面量做加法（连接）时，先去做开辟空间的事情，再去做字符串的连接
         */
    }
}

package cn.temptation;

public class Sample06 {
    public static void main(String[] args) {
        /*
         * String类的常用成员方法：（具有判断功能）
         * 1、boolean equals(Object anObject) ：将此字符串与指定的对象比较。
         * 2、boolean equalsIgnoreCase(String anotherString) ：将此 String 与另一个 String 比较，不考虑大小写。
         * 3、boolean contains(CharSequence s) ：当且仅当此字符串包含指定的 char 值序列时，返回 true。
         * 4、boolean startsWith(String prefix) ：测试此字符串是否以指定的前缀开始。 
         * 5、boolean startsWith(String prefix, int toffset) ：测试此字符串从指定索引开始的子字符串是否以指定前缀开始。 
         * 6、boolean endsWith(String suffix) ：测试此字符串是否以指定的后缀结束。  
         * 7、boolean isEmpty() ：当且仅当 length() 为 0 时返回 true。 
         */
        String string1 = "Java";
        String string2 = "java";
        String string3 = "Java";
        
        System.out.println(string1.equals(string2));        // false
        System.out.println(string1.equals(string3));        // true
        System.out.println("-----------------------------------------");
        
        System.out.println(string1.equalsIgnoreCase(string2));        // true
        System.out.println(string1.equalsIgnoreCase(string3));        // true
        System.out.println("-----------------------------------------");
        
        // CharSequence不是char字符，而是字符序列。
        // String类实现了CharSequence接口
        // 语法错误：The method contains(CharSequence) in the type String is not applicable for the arguments (char)
//        System.out.println(string1.contains('a'));
        System.out.println(string1.contains("a"));        // true
        System.out.println(string1.contains("b"));        // false
        System.out.println(string1.contains("va"));        // true
        System.out.println(string1.contains("sb"));        // false
        System.out.println("-----------------------------------------");
        
        System.out.println(string1.startsWith("J"));        // true
        System.out.println(string1.startsWith("J", 0));        // true
        System.out.println(string1.startsWith("J", 1));        // false
        System.out.println(string1.startsWith("ava", 1));    // true
        System.out.println("-----------------------------------------");
        
        System.out.println(string1.endsWith("a"));            // true
        System.out.println(string1.endsWith("va"));            // true
        System.out.println(string1.endsWith("Java"));        // true
        System.out.println(string1.endsWith("av"));            // false
        System.out.println("-----------------------------------------");
        
        String string4 = null;        // null值
        String string5 = "";        // 空字符串
        String string6 = "0";        // 字符串内容为0
        String string7 = "null";    // 字符串内容为null
        String string8 = " ";        // 字符串内容为一个空格
        
        // 执行异常：java.lang.NullPointerException
//        System.out.println("string4 isEmpty:" + string4.isEmpty());
        System.out.println("string5 isEmpty:" + string5.isEmpty());        // true
        System.out.println("string6 isEmpty:" + string6.isEmpty());        // false
        System.out.println("string7 isEmpty:" + string7.isEmpty());        // false
        System.out.println("string8 isEmpty:" + string8.isEmpty());        // false
    }
}

package cn.temptation;

public class Sample07 {
    public static void main(String[] args) {
        // String类的常用成员方法：
        // String intern() ：返回字符串对象的规范化表示形式。
        // 一个初始为空的字符串池，它由类 String 私有地维护。 
        // 当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（用 equals(Object) 方法确定），则返回池中的字符串。
        // 否则，将此 String 对象添加到池中，并返回此 String 对象的引用。 
        // 它遵循以下规则：对于任意两个字符串 s 和 t，当且仅当 s.equals(t) 为 true 时，s.intern() == t.intern() 才为 true。 
        // 所有字面值字符串和字符串赋值常量表达式都使用 intern 方法进行操作。
        
        String string1 = "Java真简单";
        String string2 = new String("Java真简单");
        
        System.out.println(string1 == string2);                        // false
        System.out.println(string1 == string2.intern());            // true
        System.out.println(string1.intern() == string2.intern());    // true
        
        System.out.println(string1.equals(string2.intern()));        // true
    }
}

package cn.temptation;

public class Sample08 {
    public static void main(String[] args) {
        // String类的使用：涉及开发习惯
        
//        String str = "java";
        // 变量str被赋值为null时，如下写法会产生执行异常：java.lang.NullPointerException，因为null值没有equals方法
        String str = null;
        
        // 初始写法：
//        if (str.equals("javatemptation")) {
//            System.out.println("内容一致");
//        } else {
//            System.out.println("内容不一致");
//        }
        
        // 改进写法：因为字符串字面量一定有equals方法，所以把其放在前面，而可能有null的变量作为equals方法的参数，这样就避免了空指针异常
        if ("javatemptation".equals(str)) {
            System.out.println("内容一致");
        } else {
            System.out.println("内容不一致");
        }
    }
}

package cn.temptation;

import java.util.Scanner;

public class Sample09 {
    public static void main(String[] args) {
        // 需求：模拟用户登录，最多可以登录三次，且每次登录失败的话提示还有几次机会
        
        // 思路：
        // 1、有设定好的帐号和密码用来进行对比是否输入正确
        // 2、通过Scanner类的方法接收控制台的键盘录入
        // 3、将输入的帐号和密码与设置好的帐号和密码进行对比：一致时，登录成功；不一致时（有一个不一致和两个都不一致），登录失败，提示登录失败
        // 4、登录次数的限制为3次，且在每次失败时提示还剩的次数
        
        // 设置帐号和密码
        String username_default = "admin";
        String password_default = "123";
        // 设置最多登录次数
        int maxCount = 3;
        
        Scanner input = new Scanner(System.in);
        
        for (int i = 0; i < maxCount; i++) {
            // 接收键盘录入
            System.out.println("输入帐号：");
            String username = input.nextLine();
            System.out.println("输入密码：");
            String password = input.nextLine();
            
            // 判断登录是否成功
            if (username_default.equals(username) && password_default.equals(password)) {
                System.out.println("登录成功！");
                // 登录成功时，就跳出循环
                break;
            } else {
                // 登录失败时
                int temp = maxCount - 1 - i;
                if (temp == 0) {
                    System.out.println("登录失败，帐号已锁定！");
                } else {
                    System.out.println("登录失败，还有" + temp + "次机会！");
                }
            }
        }
        
        input.close();
    }
}

package cn.temptation;

import java.util.Scanner;

public class Sample10 {
    public static void main(String[] args) {
        // Sample09的写法还是面向过程的写法，我们应该具备面向对象的思想
        // 思考在登录这个事情中，有哪些对象？对象的行为是什么？对象的特征是什么？
        // 分析出：有一个用户（对象），他/她有登录这个行为，会操作帐号和密码这两个特征
        
        // 因为是由系统给予用户几次登录的机会，所以登录次数不应该属于用户，而是系统的特征
        // 设置最多登录次数
        int maxCount = 3;
        
        // 静态方法的调用，注意方法中是否有成员变量，有的话，就必须设置成员变量为静态的
//        test(maxCount);
        
        // 非静态方法的调用
        // 写法1：常规写法
//        Sample10 sample10 = new Sample10();
//        sample10.test(maxCount);
        
        // 写法2：匿名对象
        (new Sample10()).test(maxCount); 
    }
    
    /**
     * 系统给予用户登录的操作
     * @param maxCount
     */
//    public static void test(int maxCount) {        // 静态写法
    public void test(int maxCount) {            // 非静态写法
        User user = new User();
        
        // 接收键盘录入
        Scanner input = new Scanner(System.in);
        
        for (int i = 0; i < maxCount; i++) {
            // 接收键盘录入
            System.out.println("输入帐号：");
            user.setUsername(input.nextLine());
            System.out.println("输入密码：");
            user.setPassword(input.nextLine());
            
            // 判断登录是否成功
            if (user.checkLogin(user)) {
                System.out.println("登录成功！");
                // 登录成功时，就跳出循环
                break;
            } else {
                // 登录失败时
                int temp = maxCount - 1 - i;
                if (temp == 0) {
                    System.out.println("登录失败，帐号已锁定！");
                } else {
                    System.out.println("登录失败，还有" + temp + "次机会！");
                }
            }
        }
        
        input.close();
    }
}

// 抽象出一个用户类
class User {
    // 成员变量
    // 帐号
    private String username;
    // 密码
    private String password;
    // 正确的用户帐号
    private String username_default = "admin";
    // 正确的用户密码
    private String password_default = "123";
    
    // 构造函数
    public User() {
        super();
    }
    
    public User(String username, String password) {
        super();
        this.username = username;
        this.password = password;
    }

    // 成员方法
    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
    
    // 自定义的成员方法
    // 判断是否登录成功（这个成员方法功能OK，但是不够好，不够好的原因在于不够面向对象，因为这样写可能会有很长的参数列表）
//    public boolean checkLogin(String username, String password) {
//        // 判断
//        if (username_default.equals(username) && password_default.equals(password)) {
//            return true;
//        } else {
//            return false;
//        }
//    }
    
    // 改进写法
    // 判断是否登录成功（传入一般类的对象，这样就可以无视参数个数了，反正都是对象的特征）
    public boolean checkLogin(User user) {
        if (username_default.equals(user.getUsername()) && password_default.equals(user.getPassword())) {
            return true;
        } else {
            return false;
        }
    }
}

package cn.temptation;

public class Sample11 {
    public static void main(String[] args) {
        /*
         * String类的常用成员方法：（具有获取功能）
         * 1、int length() ：返回此字符串的长度。
         * 2、char charAt(int index) ：返回指定索引处的 char 值。
         * 3、int indexOf(int ch) ：返回指定字符在此字符串中第一次出现处的索引。
         * 4、int indexOf(int ch, int fromIndex) ：返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
         * 5、int indexOf(String str) ：返回指定子字符串在此字符串中第一次出现处的索引。
         * 6、int indexOf(String str, int fromIndex) ：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
         * 7、String substring(int beginIndex) ：返回一个新的字符串，它是此字符串的一个子字符串。
         * 8、String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串的一个子字符串。        
         */
        String string1 = "javatemptation";
        System.out.println("string1`s length:" + string1.length());        // 14
        String string2 = "";
        System.out.println("string2`s length:" + string2.length());        // 0
        String string3 = null;
        // 执行产生异常：java.lang.NullPointerException        空指针异常
//        System.out.println("string3`s length:" + string3.length());
        String string4 = " ";
        System.out.println("string4`s length:" + string4.length());        // 1
        System.out.println("-----------------------------------------------------------");
        
        System.out.println("string1.charAt(7):" + string1.charAt(7));    // p
        // 执行产生异常：java.lang.StringIndexOutOfBoundsException: String index out of range: 20        索引越界异常
//        System.out.println("string1.charAt(20):" + string1.charAt(20));
        System.out.println("string1.charAt(13):" + string1.charAt(13));        // n
        System.out.println("-----------------------------------------------------------");
        
        System.out.println("string1.indexOf(106):" + string1.indexOf(106));        // 106表示的是j        0
        System.out.println("string1.indexOf(97):" + string1.indexOf(97));        // 97表示的是a        1
        // 返回：在此对象表示的字符序列中第一次出现该字符的索引；如果未出现该字符，则返回 -1。
        System.out.println("string1.indexOf(98):" + string1.indexOf(98));        // 98表示的是b        -1
        System.out.println("-----------------------------------------------------------");
        
        System.out.println("string1.indexOf(106, 0):" + string1.indexOf(106, 0));    // 106表示的是j        0
        // 返回：在此对象表示的字符序列中第一次出现的大于或等于 fromIndex 的字符的索引；如果未出现该字符，则返回 -1。
        System.out.println("string1.indexOf(106, 1):" + string1.indexOf(106, 1));    // j    -1
        System.out.println("-----------------------------------------------------------");
        
        System.out.println("string1.indexOf("av"):" + string1.indexOf("av"));        // av     1
        // 返回：如果字符串参数作为一个子字符串在此对象中出现，则返回第一个这种子字符串的第一个字符的索引；如果它不作为一个子字符串出现，则返回 -1。
        System.out.println("string1.indexOf("vb"):" + string1.indexOf("vb"));        // vb    -1
        System.out.println("-----------------------------------------------------------");
        
        // 返回：指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
        System.out.println("string1.indexOf("av", 0):" + string1.indexOf("av", 0));    // av        1
        System.out.println("string1.indexOf("av", 1):" + string1.indexOf("av", 1));    // av        1
        System.out.println("string1.indexOf("av", 2):" + string1.indexOf("av", 2));    // av        -1
        System.out.println("string1.indexOf("vb", 0):" + string1.indexOf("vb", 0));    // vb    -1
        System.out.println("-----------------------------------------------------------");
        
        // 参数：beginIndex - 起始索引（包括）。 
        System.out.println("string1.substring(0):" + string1.substring(0));        // javatemptation
        System.out.println("string1.substring(5):" + string1.substring(5));        // emptation
        // 执行异常：java.lang.StringIndexOutOfBoundsException: String index out of range: -2        字符串索引越界异常
//        System.out.println("string1.substring(-2):" + string1.substring(-2));
        // 执行异常：java.lang.StringIndexOutOfBoundsException: String index out of range: -6        字符串索引越界异常
//        System.out.println("string1.substring(20):" + string1.substring(20));
        System.out.println("-----------------------------------------------------------");
        
        // 参数：beginIndex - 起始索引（包括）。        endIndex - 结束索引（不包括）。 
        System.out.println("string1.substring(0, 1):" + string1.substring(0, 1));    // j
        System.out.println("string1.substring(0, 13):" + string1.substring(0, 13));    // javatemptatio
        System.out.println("string1.substring(0, 14):" + string1.substring(0, 14));    // javatemptation
        // 执行异常：java.lang.StringIndexOutOfBoundsException: String index out of range: 20        字符串索引越界异常
//        System.out.println("string1.substring(0, 20):" + string1.substring(0, 20));
        // 执行异常：java.lang.StringIndexOutOfBoundsException: String index out of range: -2        字符串索引越界异常
//        System.out.println("string1.substring(-2, 14):" + string1.substring(-2, 14));
        // 执行异常：java.lang.StringIndexOutOfBoundsException: String index out of range: -2        字符串索引越界异常
//        System.out.println("string1.substring(10, 8):" + string1.substring(10, 8));
        System.out.println("string1.substring(0, string1.length()):" + string1.substring(0, string1.length()));                // javatemptation
        System.out.println("string1.substring(0, string1.length() - 1):" + string1.substring(0, string1.length() - 1));        // javatemptatio
    }
}

package cn.temptation;

import java.util.Scanner;

public class Sample12 {
    public static void main(String[] args) {
        // 需求：通过键盘录入，循环获取输入的一个字符串中的每一个字符并显示出来
        // 例如：输入：abc，显示出        a    b    c
        
        String str = "";
        
        System.out.println("输入一个字符串：");
        Scanner input = new Scanner(System.in);
        if (input.hasNextLine()) {
            str = input.nextLine();
        } else {
            System.out.println("输入的不正确！");
        }
        input.close();
        
        for (int i = 0; i < str.length(); i++) {
            System.out.print(str.charAt(i) + "	");
        }
    }
}

package cn.temptation;

import java.util.Scanner;

public class Sample13 {
    public static void main(String[] args) {
        // 需求：根据键盘录入的一个字符串（仅限于有大写英文、小写英文和数字），统计一下该字符串中大写英文字符有多少个？小写英文字符有多少个？数字字符有多少个？
        // 例如："Java123456"：大写1个、小写3个、数字6个
        
        // 思路：（人为控制输入格式的版本）
        // 1、接收键盘录入的字符串，循环取得该字符串的每一个字符
        // 2、判断每一个字符是大写，还是小写，还是数字
        // 3、分类做累加
        
        String str = "";
        // 大写英文字符的个数
        int upperCount = 0;
        // 小写英文字符的个数
        int lowerCount = 0;
        // 数字字符的个数
        int numberCount = 0;
        
        System.out.println("输入一个字符串（仅限于有大写英文、小写英文和数字）：");
        Scanner input = new Scanner(System.in);
        if (input.hasNextLine()) {
            str = input.nextLine();
        } else {
            System.out.println("输入不正确！");
        }
        input.close();
        
        for (int i = 0; i < str.length(); i++) {
            // 获取单个字符
            char temp = str.charAt(i);
            
            // 判断写法1
//            if (temp >= 65 && temp <= 90) {        // 大写英文字符
//                upperCount++;
//            } else if (temp >= 97 && temp <= 122) {        // 小写英文字符
//                lowerCount++;
//            } else if(temp >= 48 && temp <= 57) {        // 数字字符
//                numberCount++;
//            }
            
            // 判断写法2
            if (temp >= 'A' && temp <= 'Z') {        // 大写英文字符
                upperCount++;
            } else if (temp >= 'a' && temp <= 'z') {        // 小写英文字符
                lowerCount++;
            } else if(temp >= '0' && temp <= '9') {            // 数字字符
                numberCount++;
            }
        }
        
        System.out.println("字符串：" + str + "中，大写英文字符有：" + upperCount + "个，小写英文字符有：" 
                + lowerCount + "个，数字字符有：" + numberCount + "个");
    }
}

package cn.temptation;

import java.util.Scanner;

public class Sample14 {
    public static void main(String[] args) {
        // 需求：根据键盘录入的一个字符串（仅限于有大写英文、小写英文和数字），统计一下该字符串中大写英文字符有多少个？小写英文字符有多少个？数字字符有多少个？
        // 例如："Java123456"：大写1个、小写3个、数字6个
        
        // 思路：（程序控制输入格式的版本）
        // 1、接收键盘录入的字符串，循环取得该字符串的每一个字符
        // 2、判断每一个字符是大写英文、还是小写英文、还是数字，如果都不是，那么就是不正确的输入，应该提示让其重新输入；否则进行统计
        // 3、对于输入正确格式的字符串，循环获取每一个字符并进行判断统计
        
        Scanner input = new Scanner(System.in);
        
        String str = "";
        // 大写英文字符的个数
        int upperCount = 0;
        // 小写英文字符的个数
        int lowerCount = 0;
        // 数字字符的个数
        int numberCount = 0;
                
        for(;;) {
            // 声明统计执行判断标识
            boolean flag = true;
            
            // 1、判断操作，看看输入格式是否正确
            System.out.println("输入一个字符串（仅限于有大写英文、小写英文和数字）：");
            if (input.hasNextLine()) {
                str = input.nextLine();
            } else {
                System.out.println("输入的内容不是字符串！");
                break;
            }
            
            // 对输入的字符串的格式进行判断
            for (int i = 0; i < str.length(); i++) {
                char temp = str.charAt(i);
                
                if (!((temp >= 'A' && temp <= 'Z') || (temp >= 'a' && temp <= 'z') || (temp >= '0' && temp <= '9'))) {
                    // 大写英文字符、小写英文字符、数字字符之外的都是不正确的格式
                    System.out.println("输入的字符串格式不正确，仅限有大写英文、小写英文和数字！");
                    flag = false;
                    // 考虑：这里使用break？ 还是使用continue？
                    // 因为只要有一个字符是不合规则的字符，就不用再判断其他字符是否符合规则了，所以使用break跳出内层for循环
                    break;
                }
            }
            
            // 2、统计操作
            if (flag) {
                for (int i = 0; i < str.length(); i++) {
                    // 获取单个字符
                    char temp = str.charAt(i);
                    
                    // 判断写法1
//                    if (temp >= 65 && temp <= 90) {        // 大写英文字符
//                        upperCount++;
//                    } else if (temp >= 97 && temp <= 122) {        // 小写英文字符
//                        lowerCount++;
//                    } else if(temp >= 48 && temp <= 57) {        // 数字字符
//                        numberCount++;
//                    }
                    
                    // 判断写法2
                    if (temp >= 'A' && temp <= 'Z') {        // 大写英文字符
                        upperCount++;
                    } else if (temp >= 'a' && temp <= 'z') {        // 小写英文字符
                        lowerCount++;
                    } else if(temp >= '0' && temp <= '9') {            // 数字字符
                        numberCount++;
                    }
                }
                
                System.out.println("字符串：" + str + "中，大写英文字符有：" + upperCount + "个，小写英文字符有：" 
                        + lowerCount + "个，数字字符有：" + numberCount + "个");
                
                // 正确的格式输入后，进行统计操作，操作结束后跳出当前的外层循环（死循环）
                break;
            }
        }
        
        input.close();
    }
}

package cn.temptation;

public class Sample15 {
    public static void main(String[] args) {
        /*
         * String类的常用成员方法：（具有转换功能）
         * 1、byte[] getBytes() ：使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
         * 2、char[] toCharArray() ：将此字符串转换为一个新的字符数组。
         * 3、static String valueOf(char[] data) ：返回 char 数组参数的字符串表示形式。
         * 4、static String valueOf(int i) ：返回 int 参数的字符串表示形式。
         * 5、String toLowerCase() ：使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
         * 6、String toUpperCase() ：使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
         * 7、String concat(String str) ：将指定字符串连接到此字符串的结尾。       
         */
        
        String string1 = "javatemptation";
        
        // 将字符串转换为byte数组
        byte[] arrByte = string1.getBytes();
        for (byte item : arrByte) {
            System.out.println(item);
        }
        System.out.println("------------------------------------------------------");
        
        // 将字符串转换为char数组
        char[] arrChar = string1.toCharArray();
        for (char item : arrChar) {
            System.out.println(item);
        }
        System.out.println("------------------------------------------------------");
        
        // 将字符数组转换为字符串（与上述方法是可逆操作）
        String string2 = String.valueOf(arrChar);
        System.out.println(string2);
        System.out.println("------------------------------------------------------");
        
        int i = 97;
        // int类型转换成字符串类型的方法1
//        String string3 = String.valueOf(i);
//        System.out.println(string3);            // 97
//        
//        String string4 = String.valueOf((char)i);
//        System.out.println(string4);            // a
//        
//        String string5 = String.valueOf((int)'a');
//        System.out.println(string5);            // 97
        
        //  int类型转换成字符串类型的方法2
        System.out.println(i + "");                // 97
        System.out.println("" + i);                // 97
        System.out.println(" " + i);            // 空格97
        System.out.println((String)(i + ""));    // 97
        // 语法错误：Invalid character constant
//        System.out.println(i + '');
        // 语法错误：Char cannot be resolved to a type
//        System.out.println((char)(i + ""));
        System.out.println("------------------------------------------------------");
        
        String string6 = "JAVATEMPTATION";
        System.out.println(string6.toLowerCase());        // javatemptation
        System.out.println("------------------------------------------------------");
        
        String string7 = "javatemptation";
        System.out.println(string7.toUpperCase());        // JAVATEMPTATION
        System.out.println("------------------------------------------------------");
        
        String string8 = "offerfirstblood";
        System.out.println(string1.concat(string8));    // javatemptationofferfirstblood
    }
}

package cn.temptation;

import java.util.Scanner;

public class Sample16 {
    public static void main(String[] args) {
        // 需求：根据键盘录入一个字符串（仅限大写英文字符和小写英文字符），显示该字符串，且转换该字符串为首字符大写，其他字符均小写，并显示转换后的字符串
        // 例如："javaTEMPTATION" ------> "Javatemptation"
        String str = "";
        
        System.out.println("录入一个字符串（仅限大写英文字符和小写英文字符）：");
        Scanner input = new Scanner(System.in);
        if (input.hasNextLine()) {
            str = input.nextLine();
        } else {
            System.out.println("输入的格式不正确！");
        }
        input.close();
        
        // 思路1：
        // 1、获取输入的字符串，循环遍历得到每一个字符
        // 2、判断第一个字符是否为大写字符，如果不是，转为大写
        // 3、判断从第二个字符到最后一个字符是否为小写字符，如果不是，转为小写
        // 4、将转换后的字符组成字符串输出
//        char[] arrChar = new char[str.length()];
//        
//        for (int i = 0; i < arrChar.length; i++) {
//            char temp = str.charAt(i);
//            
//            if (i == 0) {        // 第一个字符
//                if (temp >= 'a' && temp <= 'z') {
//                    // 小写字符转换为大写字符
//                    temp -= 32;
//                }
//            } else {            // 从第二个字符到最后一个字符
//                if (temp >= 'A' && temp <= 'Z') {
//                    // 大写字符转换为小写字符
//                    temp += 32;
//                }
//            }
//            
//            arrChar[i] = temp;
//        }
//        
//        System.out.println("转换后的字符串为：" + String.valueOf(arrChar));
        
        // 思路2：
        // 1、获取输入的字符串，直接转为char数组
        // 2、判断第一个字符是否为大写字符，如果不是，转为大写
        // 3、判断从第二个字符到最后一个字符是否为小写字符，如果不是，转为小写
        // 4、将转换后的字符组成字符串输出
        
        // 写法2-1
//        char[] arrChar = str.toCharArray();
//        if (arrChar[0] >= 'a' && arrChar[0] <= 'z') {        // 第一个字符
//            // 小写字符转换为大写字符
//            arrChar[0] -= 32;
//        }
//        // 从第二个字符到最后一个字符判断
//        for (int i = 1; i < arrChar.length; i++) {
//            if (arrChar[i] >= 'A' && arrChar[i] <= 'Z') {
//                // 大写字符转换为小写字符
//                arrChar[i] += 32;
//            }
//        }
//        
//        System.out.println("转换后的字符串为：" + String.valueOf(arrChar));
        
        // 写法2-2
//        char[] arrChar = str.toCharArray();
//        // 重新定义一个char类型的数组来接收
//        char[] arrCharEx = new char[arrChar.length];
//        
//        // 从第1个字符到最后一个字符（先都拿出来判断），如果是大写字符，转换为小写字符，
//        // 因为拿出来的是一个一个的char类型的元素，判断后发生变化的元素自身，然后放入新的数组中
//        int i = 0;
//        for (char item : arrChar) {
//            if (item >= 'A' && item <= 'Z') {
//                // 大写字符转换为小写字符
//                item += 32;
//            }
//            
//            arrCharEx[i] = item;
//            i++;
//        }
//        
//        // 首字符判断，如果是小写字符转换为大写字符
//        if (arrCharEx[0] >= 'a' && arrCharEx[0] <= 'z') {        // 首字符
//            // 小写字符转换为大写字符
//            arrCharEx[0] -= 32;
//        }
//        
//        System.out.println("转换后的字符串为：" + String.valueOf(arrCharEx));
        
        // 写法2-3
//        char[] arrChar = str.toCharArray();
//        
//        // 从第1个字符到最后一个字符（先都拿出来判断），如果是大写字符，转换为小写字符，
//        // 因为拿出来的是一个一个的char类型的元素，判断后发生变化的元素自身，再放入原数组中
//        int i = 0;
//        for (char item : arrChar) {
//            if (item >= 'A' && item <= 'Z') {
//                // 大写字符转换为小写字符
//                item += 32;
//            }
//            
//            arrChar[i] = item;
//            i++;
//        }
//        
//        // 首字符判断，如果是小写字符转换为大写字符
//        if (arrChar[0] >= 'a' && arrChar[0] <= 'z') {        // 首字符
//            // 小写字符转换为大写字符
//            arrChar[0] -= 32;
//        }
//        
//        System.out.println("转换后的字符串为：" + String.valueOf(arrChar));
        
        // 思路3：
        // 1、得到字符串
        // 2、首字符----->子字符串变为大写
        // 3、其他字符----->子字符串变为小写
        // 4、拼接两个子字符串
        
//        String string1 = str.substring(0, 1).toUpperCase();
//        String string2 = str.substring(1).toLowerCase();
//        System.out.println("转换后的字符串为：" + string1.concat(string2));
        
        // 思路4：（链式编程）
        // 1、得到字符串
        // 2、字符串全部变为小写
        // 3、字符串首字符变成大写
        // 下面两种写法等价
//        System.out.println("转换后的字符串为：" + str.substring(0, 1).toUpperCase().concat(str.substring(1).toLowerCase()));
        System.out.println("转换后的字符串为：" + str.toLowerCase().substring(0, 1).toUpperCase().concat(str.substring(1).toLowerCase()));
    }
}

package cn.temptation;

public class Sample17 {
    public static void main(String[] args) {
        /*
         * String类的常用成员方法：（具有替换功能）
         * 1、String replace(char oldChar, char newChar) ：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
         * 2、String replace(CharSequence target, CharSequence replacement) ：使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。  
         */
        String string1 = "luck";
        System.out.println(string1.replace('l', 'f'));        // fuck
        System.out.println(string1);                        // luck
        
        String string2 = "feel";
        System.out.println(string2.replace('e', 'o'));        // fool
        
        String string3 = "food";
        System.out.println(string3.replace('e', 'a'));        // food
        // 拿着第一个参数字符去查找，找到了就替换，找不到就不替换
        System.out.println("--------------------------------------------------");
        
        System.out.println(string1.replace("lu", "clo"));    // clock
        System.out.println(string1);                        // luck
        
        // 注意：replace(...)方法替换后得到的是一个新的字符串，原字符串不变
    }
}

package cn.temptation;

public class Sample18 {
    public static void main(String[] args) {
        /*
         * String类的常用成员方法：（其他功能）
         * 1、String trim() ：返回字符串的副本，忽略前导空白和尾部空白。 
         * 2、int compareTo(String anotherString) ：按字典顺序比较两个字符串。
         * 3、int compareToIgnoreCase(String str) ：按字典顺序比较两个字符串，不考虑大小写。  
         */
        String string1 = " java temptation ";
        System.out.println("string1:" + string1 + "，length：" + string1.length());                            // string1: java temptation ，length：17
        System.out.println("string1.trim():" + string1.trim() + "，length：" + string1.trim().length());        // string1.trim():java temptation，length：15
        System.out.println(string1.trim() + " is good");        // java temptation is good
        System.out.println("-----------------------------------------------");
        
        String string2 = "java";
        String string3 = "java";
        String string4 = "php";
        String string5 = "japan";
        
        System.out.println(string2.compareTo(string3));            // 0
        System.out.println(string2.compareTo(string4));            // -6    j - p
        System.out.println(string2.compareTo(string5));            // 6    v - p
        
        String string6 = "java";
        String string7 = "ja";
        String string8 = "jav";
        String string9 = "j";
        
        System.out.println(string6.compareTo(string7));            // 2
        System.out.println(string6.compareTo(string8));            // 1
        System.out.println(string6.compareTo(string9));            // 3
        System.out.println("-----------------------------------------------");
        
        String string10 = "java";
        String string11 = "javA";
        
        System.out.println(string10.compareTo(string11));                // 32        97 - 65
        System.out.println(string10.compareToIgnoreCase(string11));        // 0
    }
}

package cn.temptation;

public class Sample19 {
    public static void main(String[] args) {
        // 需求：把数组的内容按照一定的格式组成一个字符串
        // 例如：int[] arr = { 3, 5, 7, 9 };    ----->  字符串"[3, 5, 7, 9]"
        
        // 数组的内容（元素）的数据类型未知，考虑转换为Object类型
//        int[] arr = { 3, 5, 7, 9 };
//        double[] arr = { 3.14, 5.26, 7.38 };
        boolean[] arr = { true, false, false, true };
        
        // 转换为Object数组
        Object[] arrObj = new Object[arr.length];
        
        for (int i = 0; i < arr.length; i++) {
            arrObj[i] = arr[i];
        }
        
        System.out.println(arrayToString(arrObj));
    }
    
    /**
     * 数组转字符串
     * @param arr
     * @return
     */
    public static String arrayToString(Object[] arr) {
        String result = "[";
        
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                result += arr[i] + "]";
            } else {
                result += arr[i] + ",";
            }
        }
        
        return result;
    }
}

package cn.temptation;

import java.util.Scanner;

public class Sample20 {
    public static void main(String[] args) {
        // 需求：通过键盘录入一个字符串，实现其反转
        // 例如："abcd" -----> "dcba"
        String str = "";
        
        System.out.println("输入一个字符串：");
        Scanner input = new Scanner(System.in);
        if (input.hasNextLine()) {
            str = input.nextLine();
        } else {
            System.out.println("输入的格式不正确！");
        }
        input.close();
        
        // 思路1：
        // 1、获取录入的字符串
        // 2、将其转换为字符数组
        // 3、循环从字符数组的最后一个开始取出字符，再拼接为一个字符串输出
        
        // 写法1：
//        char[] arrChar = str.toCharArray();
//        String strTemp = "";
//        for (int i = arrChar.length - 1; i >= 0; i--) {
//            strTemp += arrChar[i];
//        }
//        System.out.println("反转后，字符串为：" + strTemp);
        
        // 思路2：
        // 1、获取录入的字符串
        // 2、通过charAt(...)取得每一个字符
        // 3、通过反序拼接为一个字符串输出
        
        // 写法2：
//        String strTemp = "";
//        for (int i = str.length() - 1; i >= 0; i--) {
//            char temp = str.charAt(i);
//            strTemp = strTemp.concat(str.valueOf(temp));
//        }
//        System.out.println("反转后，字符串为：" + strTemp);
        
        // 思路3：
        // 1、获取录入的字符串
        // 2、将其转换为字符数组
        // 3、首尾对调，第2个位置和倒数第2个位置对调,....直到中间
        // 4、对调后的结果再转换为字符串输出
        
        // 写法3：
        char[] arrChar = str.toCharArray();
        for (int i = 0; i < str.length() / 2; i++) {
            // 对调
            char temp = arrChar[i];
            arrChar[i] = arrChar[str.length() - 1 - i];
            arrChar[str.length() - 1 - i] = temp;
        }
        System.out.println("反转后，字符串为：" + String.valueOf(arrChar));
    }
}

package cn.temptation;

public class Sample21 {
    public static void main(String[] args) {
        // 需求：从字符串"javagoodjavabetterjavabestjavaamazing"中统计"java"出现的次数
        
//        String str = "javagoodjavabetterjavabestjavaamazing";
//        String str = "javajavajava";
//        String strTemp = "java";
        
        String str = "lolol";
        String strTemp = "lol";
        
        // 声明出现次数变量
        int apperCount = 0;
        
        // 思路1：（反复使用indexOf方法和substring方法）
        // 1、对原字符串使用indexOf(子字符串)：如果没有的话，返回-1
        // 2、第1次出现："|java|goodjavabetterjavabestjavaamazing"，根据出现的位置做截取，形成新的字符串"goodjavabetterjavabestjavaamazing"
        // 3、第2次出现："good|java|betterjavabestjavaamazing"，根据出现的位置做截取，形成新的字符串"betterjavabestjavaamazing"...
        // 4、重复上述操作，直到返回-1
        
        // 写法1：
//        while (str.indexOf(strTemp) != -1) {
//            // 找到一次子字符串，就自增一下
//            apperCount++;
//            
//            // 以查找的字符串出现的索引位置 + 查找的字符串的长度 作为substring方法的beginIndex参数的值，用来做字符串的截取
//            int beginIndex = str.indexOf(strTemp) + strTemp.length();
//            str = str.substring(beginIndex);
//        }
//        
//        System.out.println("原字符串中查找字符串：" + strTemp + "出现的次数为：" + apperCount);
        
        // 思路2：（反复使用charAt）
        // 1、反复使用charAt组合出j、a、v、a进行比较
        // 2、有满足条件的做累加
        
        // 写法2：
        for (int i = 0; i < str.length() - strTemp.length() + 1; i++) {
//            if (str.charAt(i) == 'j' && str.charAt(i + 1) == 'a' && str.charAt(i + 2) == 'v' && str.charAt(i + 3) == 'a') {
//                apperCount++;
//            }
            
//            if (str.charAt(i) == 'l' && str.charAt(i + 1) == 'o' && str.charAt(i + 2) == 'l') {
//                apperCount++;
//            }
            
            // 功能实现后，重新审视，觉得写的不太好，因为硬编码
            // 另外还要思考一个问题：1、"javajavajava"；2、从"lolol"查找"lol"
            
            // 变形1
//            if (str.charAt(i + 0) == 'j') {
//                if (str.charAt(i + 1) == 'a') {
//                    if (str.charAt(i + 2) == 'v') {
//                        if (str.charAt(i + 3) == 'a') {
//                            apperCount++;
//                        }
//                    }
//                }
//            }
            
            // 变形2
//            if (str.charAt(i + 0) == strTemp.charAt(0)) {
//                if (str.charAt(i + 1) == strTemp.charAt(1)) {
//                    if (str.charAt(i + 2) == strTemp.charAt(2)) {
//                        if (str.charAt(i + 3) == strTemp.charAt(3)) {
//                            apperCount++;
//                        }
//                    }
//                }
//            }
            
            // 变形3
            // 声明判断标识
//            boolean flag = true;
//            if (str.charAt(i + 0) != strTemp.charAt(0)) {
//                flag = false;
//            }
//            if (str.charAt(i + 1) != strTemp.charAt(1)) {
//                flag = false;
//            }
//            if (str.charAt(i + 2) != strTemp.charAt(2)) {
//                flag = false;
//            }
//            if (str.charAt(i + 3) != strTemp.charAt(3)) {
//                flag = false;
//            }
//            if (flag) {
//                apperCount++;
//            }
            
            // 变形4
            boolean flag = true;
            for (int j = 0; j < strTemp.length(); j++) {
                if (str.charAt(i + j) != strTemp.charAt(j)) {
                    flag = false;
                }
            }
            if (flag) {
                apperCount++;
            }
        }
        
        System.out.println("原字符串中查找字符串：" + strTemp + "出现的次数为：" + apperCount);
    }
}