12. 常见类(Scanner和String)

publicclass ScannerDemo {
       public static void main(String[] args) {
              // 创建对象
              Scanner sc = newScanner(System.in);
              // 获取数据
              if (sc.hasNextInt()) {
                     int x = sc.nextInt();
                     System.out.println("x:"+ x);
              } else {
                     System.out.println("你输入的数据有误");
              }
       }
}

(4)要掌握的两个方法

public int nextInt(): 获取一个int类型的值

publicString nextLine(): 获取一个String类型的值

(5)需要注意的小问题

A:同一个Scanner对象，先获取数值，再获取字符串会出现一个小问题。

主要原因：就是那个换行符号的问题。

B:解决方案：

a:重新定义一个Scanner对象

b:把所有的数据都用字符串获取，然后再进行相应的转换

public class ScannerDemo {
   publicstatic void main(String[] args) {
          //创建对象
          Scannersc = new Scanner(System.in);
          //获取两个int类型的值
          //int a = sc.nextInt();
          //int b = sc.nextInt();
          //System.out.println("a:" + a + ",b:" + b);
          //System.out.println("-------------------");
          //获取两个String类型的值
          //String s1 = sc.nextLine();
          //String s2 = sc.nextLine();
          //System.out.println("s1:" + s1 + ",s2:" + s2);
          //System.out.println("-------------------");
          //先获取一个字符串，在获取一个int值
          //String s1 = sc.nextLine();
          //int b = sc.nextInt();
          //System.out.println("s1:" + s1 + ",b:" + b);
          //System.out.println("-------------------");
          //先获取一个int值，在获取一个字符串
          //int a = sc.nextInt();
          //String s2 = sc.nextLine();
          //System.out.println("a:" + a + ",s2:" + s2);
          //System.out.println("-------------------");
          inta = sc.nextInt();
          Scannersc2 = new Scanner(System.in);
          Strings = sc2.nextLine();
          System.out.println("a:"+ a + ",s:" + s);
   }
}

2:String类的概述和使用(掌握)

(1)多个字符组成的一串数据。

其实它可以和字符数组进行相互转换。

(2)构造方法：

public String(): 空构造

publicString(byte[] bytes): 把字节数组转成字符串

publicString(byte[] bytes,int index,int length): 把字节数组的一部分转成字符串

publicString(char[] value): 把字符数组转成字符串

publicString(char[] value,int index,int count): 把字符数组的一部分转成字符串

publicString(String original): 把字符串常量值转成字符串

字符串的方法：

publicint length()：返回此字符串的长度。

下面的这一个虽然不是构造方法，但是结果也是一个字符串对象

G:String s ="hello";

public class StringDemo {
       publicstatic void main(String[] args) {
// public String():空构造
              Strings1 = new String();
              System.out.println("s1:"+ s1);
              System.out.println("s1.length():"+ s1.length());
              System.out.println("--------------------------");
// public String(byte[] bytes):把字节数组转成字符串
              byte[]bys = { 97, 98, 99, 100, 101 };
              Strings2 = new String(bys);s
              System.out.println("s2:"+ s2);
              System.out.println("s2.length():"+ s2.length());
              System.out.println("--------------------------");
// public String(byte[] bytes,intindex,int length):把字节数组的一部分转成字符串
              //我想得到字符串"bcd"
              Strings3 = new String(bys, 1, 3);
              System.out.println("s3:"+ s3);
              System.out.println("s3.length():"+ s3.length());
              System.out.println("--------------------------");
// public String(char[] value):把字符数组转成字符串
              char[]chs = { 'a', 'b', 'c', 'd', 'e', '爱','林', '亲'};
              Strings4 = new String(chs);
              System.out.println("s4:"+ s4);
              System.out.println("s4.length():"+ s4.length());
              System.out.println("--------------------------");
// public String(char[] value,intindex,int count):把字符数组的一部分转成字符串
              Strings5 = new String(chs, 2, 4);
              System.out.println("s5:"+ s5);
              System.out.println("s5.length():"+ s5.length());
              System.out.println("--------------------------");
//public String(String original):把字符串常量值转成字符串
              Strings6 = new String("abcde");
              System.out.println("s6:"+ s6);
              System.out.println("s6.length():"+ s6.length());
              System.out.println("--------------------------");
//字符串字面值"abc"也可以看成是一个字符串对象。
              Strings7 = "abcde";
              System.out.println("s7:"+s7);
              System.out.println("s7.length():"+s7.length());
       }
}

(3)字符串的特点

A:字符串一旦被赋值，就不能改变。

注意：这里指的是字符串的内容不能改变，而不是引用不能改变。

B:字面值作为字符串对象和通过构造方法创建对象的不同

String s = newString("hello");和String s = "hello"的区别?

有。前者会创建2个对象，后者创建1个对象。

==:比较引用类型比较的是地址值是否相同

equals:比较引用类型默认也是比较地址值是否相同，而String类重写了equals()方法，比较的是内容是否相同。

public class StringDemo2 {
       publicstatic void main(String[] args) {
              Strings1 = new String("hello");
              Strings2 = "hello";
              System.out.println(s1== s2);// false
              System.out.println(s1.equals(s2));//true
       }
}

(4)字符串的面试题(看程序写结果)

A:==和equals()

                     Strings1 = new String("hello");
                     Strings2 = new String("hello");
                     System.out.println(s1== s2);// false
                     System.out.println(s1.equals(s2));//true
                     Strings3 = new String("hello");
                     Strings4 = "hello";
                     System.out.println(s3== s4);// false
                     System.out.println(s3.equals(s4));//true
                     Strings5 = "hello";
                     Strings6 = "hello";
                     System.out.println(s5== s6);// true
                     System.out.println(s5.equals(s6));//true

B:字符串的拼接

                     Strings1 = "hello";
                     Strings2 = "world";
                     Strings3 = "helloworld";
                     System.out.println(s3== s1 + s2);// false
                     System.out.println(s3.equals((s1+ s2)));// true
                     System.out.println(s3== "hello" + "world");// false 这个我们错了，应该是true
                     System.out.println(s3.equals("hello"+ "world"));// true

(5)字符串的功能

A:判断功能

boolean equals(Object obj): 比较字符串的内容是否相同,区分大小写

booleanequalsIgnoreCase(String str): 比较字符串的内容是否相同,忽略大小写

booleancontains(String str): 判断大字符串中是否包含小字符串

booleanstartsWith(String str): 判断字符串是否以某个指定的字符串开头

booleanendsWith(String str): 判断字符串是否以某个指定的字符串结尾

booleanisEmpty(): 判断字符串是否为空。

public class StringDemo {
   publicstatic void main(String[] args) {
          //创建字符串对象
          Strings1 = "helloworld";
          Strings2 = "helloworld";
          Strings3 = "HelloWorld";
          //boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
          System.out.println("equals:"+ s1.equals(s2));
          System.out.println("equals:"+ s1.equals(s3));
          System.out.println("-----------------------");
          //boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
          System.out.println("equals:"+ s1.equalsIgnoreCase(s2));
          System.out.println("equals:"+ s1.equalsIgnoreCase(s3));
          System.out.println("-----------------------");
          //boolean contains(String str):判断大字符串中是否包含小字符串
          System.out.println("contains:"+ s1.contains("hello"));
          System.out.println("contains:"+ s1.contains("hw"));
          System.out.println("-----------------------");
          //boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
          System.out.println("startsWith:"+ s1.startsWith("h"));
          System.out.println("startsWith:"+ s1.startsWith("hello"));
          System.out.println("startsWith:"+ s1.startsWith("world"));
          System.out.println("-----------------------");
 
// 练习：boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾这个自己玩
          //boolean isEmpty():判断字符串是否为空。
          System.out.println("isEmpty:"+ s1.isEmpty());
          Strings4 = "";
          Strings5 = null;
          System.out.println("isEmpty:"+ s4.isEmpty());
          //NullPointerException
          //s5对象都不存在，所以不能调用方法，空指针异常
          System.out.println("isEmpty:"+ s5.isEmpty());
   }
}

B:获取功能

int length(): 获取字符串的长度。

char charAt(intindex): 获取指定索引位置的字符

int indexOf(intch): 返回指定字符在此字符串中第一次出现处的索引。

为什么这里是int类型，而不是char类型?原因是：'a'和97其实都可以代表'a'

int indexOf(Stringstr):

返回指定字符串在此字符串中第一次出现处的索引。

int indexOf(intch,int fromIndex):

返回指定字符在此字符串中从指定位置后第一次出现处的索引。

int indexOf(String str,intfromIndex):

返回指定字符串在此字符串中从指定位置后第一次出现处的索引。

String substring(intstart): 从指定位置开始截取字符串,默认到末尾。

String substring(intstart,int end): 从指定位置开始到指定位置结束截取字符串。

public class StringDemo {
       publicstatic void main(String[] args) {
              //定义一个字符串对象
              Strings = "helloworld";
              //int length():获取字符串的长度。
              System.out.println("s.length:"+ s.length());
              System.out.println("----------------------");
              //char charAt(int index):获取指定索引位置的字符
              System.out.println("charAt:"+ s.charAt(7));
              System.out.println("----------------------");
              //int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
              System.out.println("indexOf:"+ s.indexOf('l'));
              System.out.println("----------------------");
       //int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
              System.out.println("indexOf:"+ s.indexOf("owo"));
              System.out.println("----------------------");
// intindexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
              System.out.println("indexOf:"+ s.indexOf('l', 4));
              System.out.println("indexOf:"+ s.indexOf('k', 4)); // -1
              System.out.println("indexOf:"+ s.indexOf('l', 40)); // -1
              System.out.println("----------------------");
              //自己练习：int indexOf(String str,int
       //fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
              // String substring(int start):从指定位置开始截取字符串,默认到末尾。包含start这个索引
              System.out.println("substring:"+ s.substring(5));
              System.out.println("substring:"+ s.substring(0));
              System.out.println("----------------------");
              //String substring(int start,int
              // end):从指定位置开始到指定位置结束截取字符串。包括start索引但是不包end索引
              System.out.println("substring:"+ s.substring(3, 8));
              System.out.println("substring:"+ s.substring(0, s.length()));
       }
}

C:转换功能

byte[] getBytes(): 把字符串转换为字节数组。

char[] toCharArray(): 把字符串转换为字符数组。

static String valueOf(char[] chs): 把字符数组转成字符串。

static String valueOf(int i): 把int类型的数据转成字符串。

注意：String类的valueOf方法可以把任意类型的数据转成字符串。

String toLowerCase(): 把字符串转成小写。

String toUpperCase(): 把字符串转成大写。

String concat(Stringstr): 把字符串拼接。

public class StringDemo {
       publicstatic void main(String[] args) {
              //定义一个字符串对象
              Strings = "JavaSE";
              //byte[] getBytes():把字符串转换为字节数组。
              byte[]bys = s.getBytes();
              for (intx = 0; x < bys.length; x++) {
                     System.out.println(bys[x]);
              }
              System.out.println("----------------");
              // char[] toCharArray():把字符串转换为字符数组。
              char[] chs = s.toCharArray();
              for (int x = 0; x < chs.length;x++) {
                     System.out.println(chs[x]);
              }
              System.out.println("----------------");
              //static String valueOf(char[] chs):把字符数组转成字符串。
              Stringss = String.valueOf(chs);
              System.out.println(ss);
              System.out.println("----------------");
              // static String valueOf(int i):把int类型的数据转成字符串。
              int i = 100;
              String sss = String.valueOf(i);
              System.out.println(sss);
              System.out.println("----------------");
              // String toLowerCase():把字符串转成小写。
              System.out.println("toLowerCase:"+ s.toLowerCase());
              System.out.println("s:"+ s);
              //System.out.println("----------------");
              // String toUpperCase():把字符串转成大写。
              System.out.println("toUpperCase:"+ s.toUpperCase());
              System.out.println("----------------");
              // String concat(String str):把字符串拼接。
              String s1 = "hello";
              Strings2 = "world";
              Strings3 = s1 + s2;
              Strings4 = s1.concat(s2);
              System.out.println("s3:"+s3);
              System.out.println("s4:"+s4);
       }
}

D:其他功能

a:替换功能

String replace(char old,char new)

String replace(String old,String new)

b:去除字符串两空格

String trim()

c:按字典顺序比较两个字符串

int compareTo(String str)

int compareToIgnoreCase(String str)

public class StringDemo {
   publicstatic void main(String[] args) {
          //替换功能
          Strings1 = "helloworld";
          Strings2 = s1.replace('l', 'k');
          Strings3 = s1.replace("owo", "ak47");
          System.out.println("s1:"+ s1);
          System.out.println("s2:"+ s2);
          System.out.println("s3:"+ s3);
          System.out.println("---------------");
          //去除字符串两空格
          Strings4 = " hello world  ";
          Strings5 = s4.trim();
          System.out.println("s4:"+ s4 + "---");
          System.out.println("s5:"+ s5 + "---");
          //按字典顺序比较两个字符串
          Strings6 = "hello";
          Strings7 = "hello";
          Strings8 = "abc";
          Strings9 = "xyz";
          System.out.println(s6.compareTo(s7));//0
          System.out.println(s6.compareTo(s8));//7
          System.out.println(s6.compareTo(s9));//-16
   }
}

(6)字符串的案例

A:模拟用户登录

* 分析：

* A:定义用户名和密码。已存在的。

* B:键盘录入用户名和密码。

* C:比较用户名和密码。

* 如果都相同，则登录成功

* 如果有一个不同，则登录失败

* D:给三次机会，用循环改进，最好用for循环。

public class StringTest {
       publicstatic void main(String[] args) {
              //定义用户名和密码。已存在的。
              Stringusername = "admin";
              Stringpassword = "admin";
              //给三次机会，用循环改进，最好用for循环。
              for(int x = 0; x < 3; x++) {
                     //x=0,1,2
                     //键盘录入用户名和密码。
                     Scannersc = new Scanner(System.in);
                     System.out.println("请输入用户名：");
                     Stringname = sc.nextLine();
                     System.out.println("请输入密码：");
                     Stringpwd = sc.nextLine();
                     //比较用户名和密码。
                     if(name.equals(username) && pwd.equals(password)) {
                            //如果都相同，则登录成功
                            System.out.println("登录成功");
                            break;
                     }else {
                            //如果有一个不同，则登录失败
                            //2,1,0
                            //如果是第0次，应该换一种提示
                            if((2 - x) == 0) {
                                   System.out.println("帐号被锁定，请与班长联系");
                            }else {
                                   System.out.println("登录失败，你还有" + (2 - x) + "次机会");
                            }
                     }
              }
       }
}

B:字符串遍历

* 分析：

* A:如何能够拿到每一个字符呢?

* charcharAt(int index)

* B:我怎么知道字符到底有多少个呢?

* intlength()

public class StringTest {
       publicstatic void main(String[] args) {
              //定义字符串
              Strings = "helloworld";
              //原始版本
              //System.out.println(s.charAt(0));
              //System.out.println(s.charAt(1));
              //System.out.println(s.charAt(2));
              //System.out.println(s.charAt(3));
              //System.out.println(s.charAt(4));
              //System.out.println(s.charAt(5));
              //System.out.println(s.charAt(6));
              //System.out.println(s.charAt(7));
              //System.out.println(s.charAt(8));
              //System.out.println(s.charAt(9));
              //只需要我们从0取到9
              // for (int x = 0; x < 10; x++) {
              //System.out.println(s.charAt(x));
              //}
              //如果长度特别长，我不可能去数，所以我们要用长度功能
              for(int x = 0; x < s.length(); x++) {
                     //char ch = s.charAt(x);
                     //System.out.println(ch);
                     //仅仅是输出，我就直接输出了
                     System.out.println(s.charAt(x));
              }
       }
}

C:统计字符串中大写，小写及数字字符的个数

* 举例：

* "Hello123World"

* 结果：

* 大写字符：2个

* 小写字符：8个

* 数字字符：3个

* 分析：

* 前提：字符串要存在

* A:定义三个统计变量

* bigCount=0

* smallCount=0

* numberCount=0

* B:遍历字符串，得到每一个字符。

* length()和charAt()结合

* C:判断该字符到底是属于那种类型的

* 大：bigCount++

* 小：smallCount++

* 数字：numberCount++

* 这道题目的难点就是如何判断某个字符是大的，还是小的，还是数字的。

* ASCII码表：

* 0 48

* A 65

* a 97

* 虽然，我们按照数字的这种比较是可以的，但是想多了，有比这还简单的

* charch = s.charAt(x);

* if(ch>='0'&& ch<='9') numberCount++

* if(ch>='a'&& ch<='z') smallCount++

* if(ch>='A'&& ch<='Z') bigCount++

* D:输出结果。

* 练习：把给定字符串的方式，改进为键盘录入字符串的方式。

public class StringTest2 {
       publicstatic void main(String[] args) {
              //定义一个字符串
              Strings = "Hello123World";
              //定义三个统计变量
              intbigCount = 0;
              intsmallCount = 0;
              intnumberCount = 0;
              //遍历字符串，得到每一个字符。
              for(intx=0; x<s.length(); x++){
                     charch = s.charAt(x);
                     //判断该字符到底是属于那种类型的
                     if(ch>='a'&& ch<='z'){
                            smallCount++;
                     }elseif(ch>='A' && ch<='Z'){
                            bigCount++;
                     }elseif(ch>='0' && ch<='9'){
                            numberCount++;
                     }
              }
              //输出结果。
              System.out.println("大写字母"+bigCount+"个");
              System.out.println("小写字母"+smallCount+"个");
              System.out.println("数字"+numberCount+"个");
       }
}

D:把字符串的首字母转成大写，其他小写

* 举例：

* helloWORLD

* 结果：

* Helloworld

* 分析：

* A:先获取第一个字符

* B:获取除了第一个字符以外的字符

* C:把A转成大写

* D:把B转成小写

* E:C拼接D

public class StringTest {
       publicstatic void main(String[] args) {
              //定义一个字符串
              Strings = "helloWORLD";
              //先获取第一个字符
              Strings1 = s.substring(0, 1);
              //获取除了第一个字符以外的字符
              Strings2 = s.substring(1);
              //把A转成大写
              Strings3 = s1.toUpperCase();
              //把B转成小写
              Strings4 = s2.toLowerCase();
              //C拼接D
              Strings5 = s3.concat(s4);
              System.out.println(s5);
              //优化后的代码
              //链式编程
              Stringresult = s.substring(0, 1).toUpperCase().concat(s.substring(1).toLowerCase());
              System.out.println(result);
       }
}

E:把int数组拼接成一个指定格式的字符串

* 举例：

* int[]arr = {1,2,3};

* 输出结果：

* "[1,2, 3]"

* 分析：

* A:定义一个字符串对象，只不过内容为空

* B:先把字符串拼接一个"["

* C:遍历int数组，得到每一个元素

* D:先判断该元素是否为最后一个

* 是：就直接拼接元素和"]"

* 不是：就拼接元素和逗号以及空格

* E:输出拼接后的字符串

public class StringTest {
   publicstatic void main(String[] args) {
          //前提是数组已经存在
          int[]arr = { 1, 2, 3 };
          //定义一个字符串对象，只不过内容为空
          Strings = "";
          //先把字符串拼接一个"["
          s+= "[";
          //遍历int数组，得到每一个元素
          for(int x = 0; x < arr.length; x++) {
                 //先判断该元素是否为最后一个
                 if(x == arr.length - 1) {
                        //就直接拼接元素和"]"
                        s+= arr[x];
                        s+= "]";
                 }else {
                        //就拼接元素和逗号以及空格
                        s+= arr[x];
                        s+= ", ";
                 }
          }
          //输出拼接后的字符串
          System.out.println("最终的字符串是：" + s);
   }
}

F:字符串反转

* 举例：键盘录入”abc”

* 输出结果：”cba”

* 分析：

* A:键盘录入一个字符串

* B:定义一个新字符串

* C:倒着遍历字符串，得到每一个字符

* a:length()和charAt()结合

* b:把字符串转成字符数组

* D:用新字符串把每一个字符拼接起来

* E:输出新串

public class StringTest3 {
       publicstatic void main(String[] args) {
              //键盘录入一个字符串
              Scannersc = new Scanner(System.in);
              System.out.println("请输入一个字符串：");
              Stringline = sc.nextLine();
              //定义一个新字符串
              Stringresult = "";
              //把字符串转成字符数组
              char[]chs = line.toCharArray();
              //倒着遍历字符串，得到每一个字符
              for(int x = chs.length - 1; x >= 0; x--) {
                     //用新字符串把每一个字符拼接起来
                     result+= chs[x];
              }
              //输出新串
              System.out.println("反转后的结果是：" + result);
              //改进为功能实现
              Strings = myReverse(line);
              System.out.println("实现功能后的结果是：" + s);
       }
        // 两个明确： 返回值类型：String 参数列表：String
       publicstatic String myReverse(String s) {
              //定义一个新字符串
              Stringresult = "";
              //把字符串转成字符数组
              char[]chs = s.toCharArray();
              //倒着遍历字符串，得到每一个字符
              for(int x = chs.length - 1; x >= 0; x--) {
                     //用新字符串把每一个字符拼接起来
                     result+= chs[x];
              }
              return  result;
       }
}

G:统计大串中小串出现的次数

* 举例：

* 在字符串"woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun"

* 结果：

* java出现了5次

* 分析：

* 前提：是已经知道了大串和小串。

* A:定义一个统计变量，初始化值是0

* B:先在大串中查找一次小串第一次出现的位置

* a:索引是-1，说明不存在了，就返回统计变量

* b:索引不是-1，说明存在，统计变量++

* C:把刚才的索引+小串的长度作为开始位置截取上一次的大串，返回一个新的字符串，并把该字符串的值重新赋值给大串

* D:回到B

publicclass StringTest5 {
       public static void main(String[] args) {
              // 定义大串
              String maxString ="woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
              // 定义小串
              String minString ="java";
              // 写功能实现
              int count = getCount(maxString,minString);
              System.out.println("Java在大串中出现了：" + count + "次");
       }
        // 两个明确： 返回值类型：int 参数列表：两个字符串
       public static int getCount(StringmaxString, String minString) {
              // 定义一个统计变量，初始化值是0
              int count = 0;
              // 先在大串中查找一次小串第一次出现的位置
              int index =maxString.indexOf(minString);
              // 索引不是-1，说明存在，统计变量++
              while (index != -1) {
                     count++;
// 把刚才的索引+小串的长度作为开始位置截取上一次的大串，返回一个新的字符串，并把该字符串的值重新赋值给大串
                     // int startIndex = index +minString.length();
                     // maxString =maxString.substring(startIndex);
                     maxString =maxString.substring(index + minString.length());
                     // 继续查
                     index =maxString.indexOf(minString);
              }
              //第二种方法：
              int index;
              //先查，赋值，判断
              while((index=maxString.indexOf(minString))!=-1){
                     count++;
                     maxString= maxString.substring(index + minString.length());
              }
              return count;
       }
}