String字符串的的案例01

1: 案例: 演示String创建字符串后的 特点.
需求:
1.定义字符数组chs, 初始化值为: 'a, ‘b’, ‘c’, 这三个字符 .
2.将其分别封装成s1, s2这两个字符串对象.
3.通过判断s1和s2这两个字符串对象是否相同.
4.直接通过""的方式创建两个字符串对象s3和s4.
5.通过判断s3和s4这两个字符串对象是否相同.

结论记忆:
	1:通过new出来的方式创建的字符串对象,每次都会在堆内存中开辟新的空间.
	2:字符串值是一个常量, 如果是通过免 new 的方式之间创建对象, 则会储存在方法区 的 常量池中
public class TestDemo01 {
    public static void main(String[] args) {
        //1.定义一个字符数组, 初始值为: 'a' , 'b', 'c', 这个三个字符
        char[] ch = { 'a' , 'b', 'c'};
        //2.将其分别封装成s1, s2这两个字符换对象
        String s1 = new String(ch);
        String s2 = new String(ch);
        //3. 通过 == 来比较
        System.out.println(s1 == s2);   //false  比较的是地址值

        //4. 之间创建 " "的方发生来计较

        String s3= "abc";
        String s4 = "abc";
        System.out.println(s3==s4); // true 比较的地址值

    }
}

2: Java中的常量优化机制

  Java中有常量优化机制:
        针对于byte类型:
            如果是变量相加: 会自动提升类型, 然后在计算结果, 提升顺序为:  byte, short, char -> int -> long -> float -> double
            如果是常量相加: 会直接运算, 然后看结果在不在左边的数据类型范围内, 在不报错,不在, 就报错.
			
        **针对于String类型:
             如果是变量拼接:  会在堆区开辟新空间.
             如果是常量拼接:  不会在堆区开辟新空间, 而是在 常量池中做操作的.
        上述的相同点是, 如果既有变量参与, 又有常量参与, 则按照 变量 的规则走.**
public class Demo03 {
    public static void main(String[] args) {
        byte b1 = 3;
        byte b2 = 4;
        byte b3 = 3 + 124;
        //byte b4 = b1 + b2;      //报错, 因为类型提升了.
        //byte b5 = b1 + 4;         //如果既有变量参与, 又有常量参与, 则按照 变量 的规则走.
        System.out.println("---------------------------");

        String s1 = "abc";
        String s2 = "ab";
        String s3 = "c";
        //System.out.println(s1 == new StringBuilder().append(s2).append(s3).toString());
        System.out.println(s1 == s2 + s3);      //false
        System.out.println(s1 == s2 + "c");     //false
        System.out.println(s1 == "ab" + "c");   //true
    }
}

3: 案例: 演示字符串的比较.

    涉及到的String类中的成员方法:
        public boolean equals(Object obj)           比较两个字符串值是否相同, 比较的是: 内容, 区分大小写.
        public boolean equalsIgnoreCase(String s);  比较两个字符串值是否相同, 比较的是: 内容, 不区分大小写.

public class Demo01 {
    public static void main(String[] args) {
        //1.定义字符数组chs, 初始化值为: 'a, 'b', 'c', 这三个字符 .
        char[] chs = {'a', 'b', 'c'};
        //2.将其分别封装成s1, s2这两个字符串对象.
        String s1 = new String(chs);
        String s2 = new String(chs);
        //3.直接通过""的方式创建两个字符串对象s3和s4.
        String s3 = "abc";
        String s4 = "abc";

        //4.通过==分别判断s1和s2, s1和s3, s3和s4是否相同.
        System.out.println(s1 == s2);   //false
        System.out.println(s1 == s3);   //false
        System.out.println(s3 == s4);   //true
        System.out.println("--------------------");

        //5.通过equals()分别判断s1和s2, s1和s3, s3和s4是否相同.
        System.out.println(s1.equals(s2));  //true
        System.out.println(s1.equals(s3));  //true
        System.out.println(s3.equals(s4));  //true
        System.out.println("--------------------");

        //6.通过equalsIgnoreCase()判断字符串abc和ABC是否相同.
        System.out.println("abc".equals("ABC"));            //false, 区分大小写
        System.out.println("abc".equalsIgnoreCase("ABC"));  //true
        System.out.println("abc".equalsIgnoreCase("bcd"));  //false
    }
}

4:案例: 遍历字符串.

  需求:
*         键盘录入一个字符串, 使用程序实现在控制台遍历打印该字符串.
*
*    涉及到的String类中的成员方法:
*         public char charAt(int index);      根据索引, 去字符串中找该索引对应的字符, 索引是从0开始的.
*         public int length();                获取集合中元素的长度, 即: 字符串中字符的总个数.
*         public char[] toCharArray();        把字符串元素转成其对应的 字符数组.

public class TestDemo03 {
 public static void main(String[] args) {
     //1. 创建一个键盘录入对象 提示用户键盘录入
     Scanner sc = new Scanner(System.in);
     //2.接收用户键盘录入字符串
     System.out.println("请录入一个字符串:");
     String s = sc.nextLine();

     //方法1: 合并版
     //3.  for循环  遍历字符串  itar  遍历字符数组
/*     for (int i = 0; i < s.length(); i++) {
         char ch = s.charAt(i);
         System.out.println("每个字符是:" + ch);
     }
*/
     //方法2: 把字符串转成一个新的字符数组
     char[] chars = s.toCharArray();
     //然后遍历数组   itar  快速遍历数组
     for (int i = 0; i < chars.length; i++) {
         char aChar = chars[i];
         System.out.println("每一个字符是:" + aChar);
     }

 }
}

案例: 统计字符串中每类字符的个数, 并打印.

/*
 *     需求:
 *         键盘录入一个字符串, 统计该字符串中大写字母字符, 小写字母字符, 数字字符出现的次数.
 *         注意: 不考虑其他字符, 例如@, !, \, /等           
 *
 *     思路:
 *         1. 定义三个计数器, 分别用来记录: 小写字母字符, 大写字母字符, 以及数字字符出现的次数.
 *         2. 提示用户录入要用来统计的字符串, 并接收.
 *         3. 遍历字符串, 获取到每一个字符.
 *             方式1:  length() + charAt()方法结合.
 *             方式2:  toCharArray(), 直接把字符串 -> char[]
 *         4. 判断当前字符属于哪种字符, 是哪种, 对应的计数器就+1
 *         5. 循环结束后, 计数器记录的就是我们想要的结果, 直接打印即可.
 */
public class TestDemo04 {
    public static void main(String[] args) {
        //1.定义计数器 来统计出现的次数
        int lowerCaseLetters = 0;
        int uppercaseLetter = 0;
        int digital = 0;
        //2.Scanner  实现键盘录入且接收
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入字符内容:");
        String s = sc.nextLine();

        // 3. 遍历字符串, 获取到每一个字符.
        //方式1:  length() + charAt()方法结合.
        /*for (int i = 0; i < str.length(); i++) {
            //ch 就是字符串中的每一个字符.
            char ch = str.charAt(i);
        }*/


        // 方式2:  toCharArray(), 直接把字符串 -> char[]
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            char aChar = chars[i];
            //判断属于哪一种
            if (aChar >= 'a' && aChar <= 'z'){
                lowerCaseLetters++;;
            }else if (aChar >= '0' && aChar <= '9'){
                digital++;
            } else if (aChar >= 'A' && aChar <= 'Z') {
                uppercaseLetter++;
            }
        }

        //循环结束后  输出统计的次数
        System.out.println("小写字母出现的次数:" + lowerCaseLetters);
        System.out.println("大写字母出现的次数:" + uppercaseLetter);
        System.out.println("数字出现的次数:" + digital);

    }
}