Day12 --Scanner键盘录入对象 和 String字符串对象

 a.        
    Scanner
        概述
            * 一个可以使用正则表达式来解析基本类型和字符串的简单文本扫描器。
    
        构造方法原理
            1） 学习一个对象，首先观察他的构造方法。一般我们使用的是：Scanner(InputStream source)这个对象，即：Scanner(System.in); 即：System.in 对应 Scanner(InputStream source)这个构造函数，表示为：标准的键盘录入对象。
            2） System类下有一个静态的字段：
                    * public static fianl InputStream in； 标准的输入流，对应着键盘录入。 
                    
        一般方法
            * hasNextXxx() 判断是否右下一个输入项，其中xxx 可以是Int, Double, String等，如果需要判断是否包含下一个字符串,即String，就可以省略Xxx。
                    * 如：hasNextInt()； 表示判断键盘录入的是否是一个int数值，如果是就返回true, 如果不是就返回false(不执行)，hasNextXxx可以作为if的判断语句，即：if(sc.hasNextInt()){...}else{...}。
            * nextXxx() 获取下一个输入项， Xxx的含义和hasNextXxx()相同，默认情况下，Scanner使用空格，回车键来表示分隔符。
    
        常见的异常
            InputMismatchException：由 Scanner 抛出，表明获取的标记(自己录入的对象)与期望类型的模式不匹配，或者该标记超出期望类型的范围。


        获取数据时出现的问题及解决方法
            * 两个常见方法：
                * public int nextInt(); 表示获取一个int类型的值。
                * public int nextLine(); 表示获取一个String类型的值。
            演示：
                混合录入：先 nextInt() 后 nextLine()
                分析：                    
                    nextInt()是键盘录入整数的方法，当我们录入5的时候，其实是录入了5和\r\n，
                    nextInt()方法只是获取到了5就结束了，那么nextLine()是录入字符串的方法，可以接收任意类型，但是他凭什么能获取一行呢？ 通过\r\n， 只要nextLine()遇到\r\n就证明一行结束了。
                        
            两者解决的方案：
                    第一种： 先获取一个数值后，再创建一个新的键盘录入对象来获取字符串。（浪费内存，不建议使用）
                    第二种：    把所有的数据都先按照 nextLine()字符串获取，然后要什么，你就对应的转换为什么。(后面讲)    


b.
    String
        概述        
            * String存在java.lang下，所以使用时不用导包。
            * String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。
            * 字符串是常量；它们的值在创建之后不能更改。字符串缓冲区StringBuffer支持可变的字符串。因为 String 对象是不可变的，所以可以共享。
            * String类重写了toString方法，所以返回的就是该对象本身，该对象就是一个字符串对象了，如 “abc”就是一个字符串对象，可以直接“abc”.String中的方法。
            * 简单记： String表示字符串，值在声明后不可改变，因为存在于常量池中，所以可被共享。
        例子：
            String str = "abc";
            str="nfc";
            sop(str);结果为nfc，“abc”字符串对象并没有被改变，只是引用变量str指向了一个常量池中新创建的字符串对象 “nfc” 而已。


c.
        String中的常见构造方法：【构造方法都是将byte数组 或 char数组 转换为String字符串的一部分或全部】
            public String(); 空参构造，结果空，无意义。
    
            public String(byte[] bytes); 将字节数组转化为字符串，这是一个解码的过程，将计算机读的懂的转换成我们读的懂的东西。
            public String(byte[] bytes,int index,int length); 将字节数组的一部分转换为字符串，index表示从字节数组中的哪个索引开始， length表示转换（截取）几个字节为字符串。
    
            public String(char[] values); 将字符数组转换为字符串。 在某种意义上 字符串和字符数组可以任意转换，因为字符串拆开就是一个个独立的字符。 所以可以用字符数组来表示壤括一个个独立的字符。
            public String(char[] values,int index,int length);  将字符数组的一部分转换为字符串，index表示从字符数组的哪个索引开始，length表示转换（截取）为几个字符为字符串。
            
            public String(String original):将字符串常量值转成字符串 ，将字符串转换为字符串，也没有什么意义。


​        
String的常见面试题：
都是通过 == 和equals方法 的规则来说明的：
    即 == 既可以比较基本数据类型，也可比较引用数据类型，当比较基本数据类型 比较的是值，当比较引用数据类型 的时候比较的是地址值。
    即 equals 只能比较引用数据类型，且重写了Object中的equals方法,所以比较的是对象的属性值。
    
    * 1.判断定义为String类型的s1和s2是否相等
     String s1 = "abc";
     String s2 = "abc";
     System.out.println(s1 == s2);     //true，因为String的值是存在于常量池中的，当常量池中没有abc,就创建一个abc并且有一个地址值，给了s1,  s2="abc"; 因为abc存在于常量池中有，所以也就给了s2,即同样的地址分别给了s1和s1,指向的都是常量池中的abc.所以返回true        
     System.out.println(s1.equals(s2)); //true，将此字符串与指定的对象比较。当且仅当该参数不为 null，并且是与此对象表示相同字符序列的 String 对象时，结果才为 true。 

* 2.下面这句话在内存中创建了几个对象?
  String s1 = new String("abc"); //创建了两个对象，一个在常量池中，即“abc”， 另一个在堆内存中，即new String("abc");  此时的new String("abc");中的abc是常量池中的副本而已， 但严谨的说只创建了一个在堆内存中，即 new String("abc");  且两个对象的地址值不同，因为一个的堆内存的地址值，另一个是常量池中的地址值。

* 3.判断定义为String类型的s1和s2是否相等
  String s1 = new String("abc");  // s1记录的是堆内存的地址值
  String s2 = "abc"; //s2记录的是常量池中的地址值
  System.out.println(s1 == s2);  //false 因为当 == 比较的是引用数据类型时，比较的是地址值，一个地址值在堆内存，另一个地址值在常量池中，所以为false
  System.out.println(s1.equals(s2)); //true, 因为 equals比较的是对象的属性值，即 new String("abc")和 对象“abc”的属性值相同，所以返回true

* 4.判断定义为String类型的s1和s2是否相等
  //    byte b = 3+4;  java 具有常量优化机制，在编译时就变成了7，且在byte的取值范围，所以就给了b。
       String s1 = "a" + "b" + "c"; //java中有常量优化机制，在编译时就将单个的字符串变成了一个整串的字符串， 且任何与“”字符串相邻的都会变成字符串， 所以最终就是字符串 “abc” 常量池中没有 所以就在常量池中创建了 “abc”
      String s2 = "abc"; // 因为常量池中存在，所以 直接拿来使用
      System.out.println(s1 == s2); //true  因为s1和s2都是字符串对象，且对象中的数值一样，所以返回true
      System.out.println(s1.equals(s2)); //true 因为String重写了Object中的equals方法，所以比较的是对象的内容，因为s1和s2都是对象，且equals比较的是对象中的属性值，而且属性值相同，所以也返回true
      
      String s3 = "a"+"1"+"4";
      String s4 = "a14";
      System.out.println(s3 == s4); // true 印证 上面s1 == s2 的说法
      System.out.println(s3.equals(s4)); // true  同样同于印证 上面s1.equals(s2) 的说法

* 5.判断定义为String类型的s1和s2是否相等
  String s1 = "ab";         //常量池中不存在，就创建了一个“ab” 常量池数值
  String s2 = "abc";     //常量池中不存在，就创建了一个“abc” 常量池数值
  String s3 = s1 + "c"; //s1变量+“c” 是StringBuffer通过append方法加入的“c”,即生成一个最终存在于堆内存的“abc”的StingBuffer的数值，再通过.toString()的方法，变成了一个新的字符串，且将数值“abc” 堆内存的地址值给了s3 
  System.out.println(s3 == s2); // false 因为s3的地址值所代表的值在堆内存中， 即 s2所代表的地址值在常量池中，即地址值所属不同，所以返回false
  System.out.println(s3.equals(s2)); // true 因为equals比较的是对象的属性值，所以s3是对象“abc” 和s2也是对象“abc” 所以返回的是true 




c.
    String中的常见判断功能：（6种）
        * 共同点： 都是返回Boolean数据的类型。
        * Boolean equals（Object obj）; 比较字符串的内容是否相等，区分大小写。
        * Boolean equalsIngoreCase(String str); 比较字符串的内容是否相等，忽略大小写。
        
        * Boolean contains(String str); 判断大字符串是否包含小字符串。
        
        * Boolean startsWith(String str); 判断字符串是否已某个指定字符串开头。
        * Boolean endsWith(String str); 判断字符串是否以某个指定字符串结尾。
        
        * Boolean isEmpty(); 判断字符串是否为空
            * 当且仅当length()的长度为0，的时候返回true，否则false。
            特殊：
                System.out.println(" ".length()); //返回字符串的长度是1，因为长度不是0，所以isEmpty()返回的是false
                System.out.println("".length()); //返回字符串的长度是0，而且 isEmpty()返回的是true


     ""  和 null的区别？
         * "" 是字符串常量，同时也是一个String字符串对象，既然是对象就可以调用String类中的所有方法。
         * null 是空常量，不能使用任何方法，否则会 出现空指针异常 NullPointerException，null常量可以给任意的引用数据类型赋值。



d.
    小案例：模拟用户登录。
     A:案例演示
        * 需求：模拟登录,给三次机会,并提示还有几次。
        * 用户名和密码都是admin




e.
    String中的获取功能 (10个)
        1）* int length(); 获取字符串的长度。
            * 注意？
                * 每个字母，标点符号，中文都是一个字符。
                * 如：System.out.println("你是，哈哈？mmd".length()); //9 



        2）* int charAt(int index); 获取指定索引位置上的字符。
            * 解释
                * 返回指定索引处的 char 值。索引范围为从 0 到 length() - 1。序列的第一个 char 值位于索引 0 处，第二个位于索引 1 处，依此类推，这类似于数组索引。 
            * 注意？
                * 传入的参数，是索引值。
            * 可能出现的问题？
                * 如果不存在指定索引，就会出现异常：StringIndexOfBoundsException  字符串索引越界异常。





        3）* int indexOf(int ch) 返回指定字符在字符串中第一次出现的索引。
            * 解释
                * 返回指定字符在此字符串中第一次出现处的索引。如果在此 String 对象表示的字符序列中出现值为 ch 的字符，则返回第一次出现该字符的索引
            * 注意？
                * 参数类型是int, 传入char类型即 'c'，会自动类型提升为int。
                * 如：System.out.println("bcde".indexOf('e')); //3 3就是该字符第一次在字符串中出现的索引位置
            * 可能出现的问题？
                * 如果参数传入的是不存在的char值，就会返回-1 




        4）* int indexOf(String str) 返回指定字符串在字符串中第一次出现的索引。
            * 解释
                * 获取字符串中第一个字符出现的位置。 
            * 注意？
                * 只能是挨着的字符串，不能是间隔的，否则返回-1，即传入不存在的字符串就返回-1 
            * 返回：
                如果字符串参数作为一个子字符串在此对象中出现，则返回第一个这种子字符串的第一个字符的索引；如果它不作为一个子字符串出现，则返回 -1。
            * 可能出现的问题？
                * 传入不存在的字符串就返回-1 



        5）* int indexOf(int ch, int fromIndex) 返回指定字符在此字符串指定位置后第一次出现的索引。
            * 解释
                * 在此 String 对象表示的字符序列中，如果带有值 ch 的字符的索引不小于 fromIndex，则返回第一次出现该值的索引。
            * 如：
                * System.out.println("woaiheima".indexOf('a',4)); //8 查找指定字符在此字符串的指定索引4后第一次出现的索引




        6）* int indexOf(String str, int fromIndex) 返回指定字符串在此字符串指定位置后第一次出现的索引。
            参数：
                str - 要搜索的子字符串。
                fromIndex - 开始搜索的索引位置。 
                返回：
                指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
            * 如：
                * System.out.println("woaiheima".indexOf("im",4)+" ``````"); //6


        7）* lastIndexOf(int ch); 返回指定字符在此字符串中最后一次出现处的索引。
            * 如: 
                * System.out.println("woaiheima".lastIndexOf('a')+"................"); //8 从后往前早，第一次字符出现的位置， 但是索引还是从0开始往后找
        
        8) * lastIndexOf(int ch, int fromIndex)    返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始往前找。                
            * 如：    
                * System.out.println("woaiheima".lastIndexOf('a', 7)); //2 从索引7的位置往前找。（从索引7开始往前 找 ←的形式开始找，最后出现的位置）
            * 可能出现的问题？
                * 如果传入没有的字符，就返回-1

​        

        9）* String subString(int start); 从指定位置开始截取字符串，默认到末尾。 切记：包含索引位置
            * 如:
                * //截取 无敌
                * System.out.println("heimawudi".substring(5)); //wudi 从5的索引位置开始截取，是包含索引的。


​            
​        
        10）* String subString(int beginIndex, int endIndex); 从指定位置开始到指定位置结束截取的字符串。 切记：包含索引位置
            * 如：
                * System.out.println("heimawudi".substring(0, 5)); //heima 根据：左闭右开原则 这样记：endIndex - beginIndex  如：5-0 =5 也就是说从beginIndex开始往后数5个。
                * System.out.println("fasdfeadvgftu".subSequence(2, 6)); //sdfe 采用的是：左闭右开的原则，这样记：endIndex - beginIndex  如：6-2 =4 也就是说从beginIndex开始往后数4个。
                * System.out.println("fasfsfm]/.'[=-01".subSequence(3, 8)); //fsfm]  也就是说从开始索引往后数5个字符。



f.
    例子：
    字符串的遍历
        * 使用普通for循环，如下：
            String s = "wowowowwosfs";
            for(int i=0;i
                sop（s.charAt(i)）;
            }
    统计不同类型字符个数
        * String s = "ABCDEabcd123456!@#$%^";
            * int big = 0;
            * int small = 0;
            * int num = 0;
            * int other = 0;
            for(int i =0;i
                char c = s.charAt(i);
                
                if(c >='A' && c<='Z'){
                    big++;
                }else if(c>='a' && c<='z'){
                    small++;
                }else if(c>='0' && c<='9'){
                    num++;
                }else{
                    other++;
                }
            }
            sop(big+" "+small+" "+num+" "+other+" ");



g.
    String中常见的转换功能
            1）* byte[] getBytes() 将字符串转换成字节数组
                    * 是一个编码的过程： 将我们看的懂得的，翻译成计算机能看得懂的。对应着 String(byte bty) 将字节数组转换成字符串，这是解码的过程，将计算机能看懂的翻译成我们能看懂的内容。
            2）* char[] toCharArray() 将字符串转换成字符数组
                    * 遍历字符串的两种方式：
                        * 方式一：  charAt(i) 传入的是遍历索引    i
                        * 方式二： toCharArray() 
                    
            3）* static String valueOf(char[] chars) 将字符数组转换成字符串。
                        * 底层是通过String(char[] values);的方式做的。 
            4）* static String valueOf(int i) 将int类型的数据转换成字符串。    
                    * 注意：String类中的valueOf方法可以将任意类型的数据转换成字符串。
    
            5)   * static String valueOf(Object o);  传入的是一个对象。注意：一般调用的是该对象的toString方法。 
                    * 如：
                             Student s = new Student("haha", 4);
                            String ObjectValueOf = String.valueOf(s);
                            System.out.println(ObjectValueOf); //调用的是对象Student的toString方法。
    
            6）* String toLowerCase() 将字符串转换成小写。
            7）* String toUpperCase() 将字符串转换成大写。
            8）* String concat(String str) 将字符串拼。
                    * + 号是任意字符可拼接。
                    * concat只能是字符串的可拼接。


        例子1：
            * A:案例演示
            * 需求：把一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)
            代码：    
                String str1 ="fasaASDFASfsdfFASDFfasdfaS";
                String concat = str1.substring(0,1).toUpperCase().concat(str1.substring(1).toLowerCase());
                System.out.println(concat);


        例子2：
            A:案例演示
            * 需求：把数组中的数据按照指定个格式拼接成一个字符串
                * 举例：
                    * int[] arr = {1,2,3};    
                * 输出结果：
                    * "[1, 2, 3]"
            代码：
                 int[] arr = {1,2,3};
                 String str="[";    
                 for(int i=0;i
                    if(i == arr.length-1){
                        str = str + arr[i] + "]"    
                    }else{
                        str = str + arr[i] + ", "
                    }
                }
                sop(str);



h.
    String中的其他功能
        * String replace(char old, char new); 将旧的字符用新的字符代替。
            可能存在的问题？
                * 字符替换, 也就是将所有的旧的都换成新的。
                * 如果没有旧的，什么都不替换成功，还是原来的。    
        * String replace(String old, String new); 将旧的字符串用新的字符串来代替。
            可能存在的问题？
                * 
        * String trim();    去空格，只能去两边的空格，不能去中间的。
        
         String的按照字典顺序比较爱两个字符串
        * int compareTo(String str) 比较
        * int compareToIgnoreCase(String str)(了解) 忽略大小写的比较



    例子1：
        字符串反转
            * A:案例演示
                * 需求：把字符串反转
                    * 举例：键盘录入"abc"        
                    * 输出结果："cba"
            
        路径：G:\CSDN_Android_\Code\Day12_Scanner对象和String对象\src\com\day12\one\test\string\Test6_字符串的反转.java


    例子2：
        在大串中查找小串出现的次数代码实现
            * A:案例演示    
                * 统计大串中小串出现的次数
    
        路径：G:\CSDN_Android_\Code\Day12_Scanner对象和String对象/src/com/day12/c/test/string/Test7_统计大串中小串出现的次数.java