1:Scanner的概述(理解)
1)Scanner是JDK5以后出现的方便我们从键盘接受数据的类。
2)Scanner的构造格式：
Scanner sc = new Scanner(System.in);
System.in 是System类下面有一个静态的成员变量in。它的类型是InputStream。
代表的是标准键盘输入流。也就是键盘录入数据。
Scanner是对其进行了封装，提供了各种转换功能。方便我们获取到想要的数据类型的数据。
3)要掌握的两个功能：
A:返回int类型
public int nextInt()
B:返回String类型
a、 public String nextLine() //返回下一个完整标记前的内容，完整标记包含：回车
例子：
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String s=sc.next();
System.out.println(s); //输入：123 456 输出：123
System.out.println("----------------");
Scanner sc2=new Scanner(System.in); //输入：123 456 输出：123 456
String s2=sc2.nextLine();
System.out.println(s2);
}
}
b、 public String next() //返回下一个完整标记前的内容，完整标记包含：回车，空格
例子：
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String s=sc.next();
System.out.println(s);
}
}
输入：adfgrw131 输入：123 456 789 //有空格
输出：adfgrw131 输出：123 //空格为完整的标记，注意输出的不同
注意事项：
先next,再nextLine会有问题。
解决方案：
重新建立Scanner对象。//一般不会这样做。因为消耗资源
根据需求，选择合适的方法。
统一一种方法。
2:String类的概述和使用(掌握)
1)字符串数据类型。属于引用数据类型。
2)String本质：值就是一个char[]
3)String类的特殊性：
字符串为常量，字符串值一旦初始化便不可以修改。
常量池：在java用于保存在编译期已确定的，已编译的class文件中的一份数据。
字符串特殊性内存解释。
图String是常量
4)String类的构造方法：
A:String s = new String();
B:String s = new String(byte[] bys);
C:String s = new String(byte[] bys,int startIndex,int count);
D:String s = new String(char[] chs);
E:String s = new String(char[] chs,int startIndex,int count);
F:String s = new String(String s2);
G:String s = "hello";
常使用：
BCDEG
例子：
package cn.itcast.myString;
/*
* String本质：值就是一个char[]
* String类型的构造方法：
* 1：字面值
* 2：String()
* 3：public String(byte[] bytes) 通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String
* 4:public String(byte[] bytes,
int offset,//offset:偏移量 距起始点差多少 即从哪开始
int length)//length：长度 即取多少个元素 通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String
5:public String(char[] value)分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
6:public String(char[] value,
int offset,
int count) 分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
7:public String(String original) 使用字符串创建字符串
*/
public class Demo3 { public static void main(String[] args) { //1：字面值
String s = "abc"; //2：String()
//没有值&null&有字符串对象但内容为空 比较
//String s2; 没有值
String s3 = new String();
s3 = null; //有值，没有对象，值为null(空)
String s4 = new String(); //有值，有对象，这个对象的值为空的。 //3，4：通过字节数组创建字符串
byte[] bArr = {97,98,99,-1,-2,-3};
String s5 = new String(bArr);
System.out.println(s5); //abc?? ,java中2个字节确定一个char类型的字符，字节-1 ，-2对应一个字符？
byte[] bArr2 = {97,98,99,100,101};
String s6 = new String(bArr2,1,2);
System.out.println(s6); //bc
s6 = new String(bArr2,1,bArr2.length-1);
System.out.println(s6); //bcde //5,6:通过字符数组创建字符串
char[] cArr = {'a','b','c','c'};
String s7 = new String(cArr,2,2);
System.out.println(s7); //cc char[] cArr2 = {97,98,99,100,101};
String s8 = new String(cArr2,2,2);
System.out.println(s8); //de //7:通过字符串创建字符串
String s9 = new String("abc");
System.out.println(s9); //abc
} }
5)String类的常用方法
(1)、判断方法
（1.1）:public boolean equals(Object anObject) 类 Object 中的 equals,比较的为字符串的数值。
（1.2）:public boolean equalsIgnoreCase(String?anotherString) Ignore：忽略 Case:大小写
（1.3）:public boolean isEmpty() is：是 empty：空的
例子
package cn.itcast.myString;
/*
* String的判断方法：
* 1:public boolean equals(Object anObject) 类 Object 中的 equals,比较的为字符串的数值。
* 2:public boolean equalsIgnoreCase(String anotherString) Ignore：忽略 Case:大小写
* 3:public boolean isEmpty() is：是 empty：空的
*/
public class Demo4 { public static void main(String[] args) { //1：euqals方法被重写，比较值
String s = "abc";
String s2 = new String("abc");
String s3 = "abc"; System.out.println(s.equals(s2)); //比较内容 System.out.println(s==s2); //flase 不同地址
System.out.println(s==s3); //true 同一个地址 //2：忽略大小写比较值
System.out.println("=======================");
String s4 = "Abc";
String s5 = "abc"; System.out.println(s4.equals(s5));
System.out.println(s4.equalsIgnoreCase(s5)); //3：判断字符串是否为空
System.out.println("=======================");
String s6 = new String();
String s7 = null;
String s8 = ""; System.out.println(s6.isEmpty());
//System.out.println(s7.isEmpty()); 空指针异常
System.out.println(s8.isEmpty());
System.out.println(s6==s8);
} }
练习： 1：将一个int数组的值拼写成字符串形式。
{1,2,3,4,5}
[1,2,3,4,5]
package cn.itcast.myString; /*
* 1：将一个int数组的值拼写成字符串形式。
* {1,2,3,4,5}
*
* [1,2,3,4,5]
*/ public class Test { public static void main(String[] args) { int[] arr = {1,2,3,4,6};
method(arr);
} public static void method(int[] arr) {
String s = "["; for (int i = 0; i < arr.length; i++) {
/*
int element = arr[i]; if(i==arr.length-1) {
s += element;
}else {
s += element+",";
// s = s + element + ",";
}
*/ s += arr[i];
if(i!=arr.length-1);
s += ",";
} s += "]";
System.out.println(s);
} }
（1.4）public boolean contains(CharSequence s) 当且仅当此字符串包含指定的 char 值序列时，返回 true。即A串里是否有子串
（1.5）public boolean startsWith(String prefix) 以某个字符串开头
（1.6）public boolean startsWith(String prefix, int toffset) 指定开始判断的偏移，是否以某个字符串开头
（1.7）public boolean endsWith(String suffix) 以某个字符串结束
例子
package cn.itcast.myString;
/*
* String的判断方法2：
* 1：public boolean contains(CharSequence s) 当且仅当此字符串包含指定的 char 值序列时，返回 true。即A串里是否有子串
* 2：public boolean startsWith(String prefix) 以某个字符串开头
* 3：public boolean startsWith(String prefix, int toffset) 指定开始判断的偏移，是否以某个字符串开头
* 4：public boolean endsWith(String suffix) 以某个字符串结束
*/
public class Demo5 { public static void main(String[] args) {
//1：注意多态
String s = "我爱java";
String s2 = "java"; boolean contains = s.contains(s2); //String类实现了CharSequence的接口
System.out.println(contains); //2，3：从指定索引开始判断
System.out.println("===================");
String s3 = "i love java,more and more！~";
String s4 = "more";
String s5 = "i";
String s6 = "i love";
String s7 = "ilove"; System.out.println(s3.startsWith(s4)); //false
System.out.println(s3.startsWith(s5)); //ture
System.out.println(s3.startsWith(s6)); //true
System.out.println(s3.startsWith(s7)); //false
System.out.println("===================");
System.out.println(s3.startsWith(s4,12)); //true ,字符串‘i love java,’的长度为12
System.out.println(s3.startsWith(s5,12)); //flase
System.out.println(s3.startsWith(s6,12)); //false
System.out.println(s3.startsWith(s7,12)); //flase //4：
System.out.println("===================");
String s8 = "i love java,more and more";
String s9 = "more";
String s10 = "i love"; System.out.println(s8.endsWith(s9)); //true
System.out.println(s8.endsWith(s10)); //false }
}
（2）、字符串的获取功能
(2.1):public int length() 获取字符串长度的 《方法()》！ 数组是获取数组长度属性！
(2.2):public char charAt(int index) 通过索引获取字符
(2.3):public int indexOf(int ch) 根据字符获取索引
(2.4):public int indexOf(int ch,int fromIndex)
(2.5):public int indexOf(String str) 根据字符串获取索引
(2.6):public int indexOf(String str, int fromIndex)
(2.7):lastIndexOf对应indexOf
(2.8):public String substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。
(2.9):public String substring(int beginIndex, int endIndex) 返回一个新的字符串，它是此字符串的一个子字符串。注意：包含头，不包含尾！
例子：
package cn.itcast.myString;
/*
* 字符串的获取功能：
* 1:public int length() 获取字符串长度的 《方法()》！ 数组是获取数组长度属性！
* 2:public char charAt(int index) 通过索引获取字符
* 3:public int indexOf(int ch) 根据字符获取索引
* 4:public int indexOf(int ch,int fromIndex)
* 5:public int indexOf(String str) 根据字符串获取索引
* 6:public int indexOf(String str, int fromIndex)
* 7:lastIndexOf对应indexOf
* 8:public String substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。
* 9:public String substring(int beginIndex, int endIndex) 返回一个新的字符串，它是此字符串的一个子字符串。
*/
public class Demo6 { public static void main(String[] args) {
//1:获取字符串与获取数组长度代码对比
String s = "i love java";
String[] sArr = {"i","love","java"}; System.out.println(s.length());
System.out.println(sArr.length); //2：
String s2 = "i love java";
int index = 1;
System.out.println(s2.charAt(index));
String s3 = "中国";
System.out.println(s3.charAt(index)); //3,4,5,6,7：indexOf(XXX) 根据字符（串）获取索引 返回第一次找到的索引 返回的永远是在整个字符串的索引，与从哪里开始检索无关
System.out.println("============================");
String s4 = "中国信息化建设程度赶超美国！"; int indexOf = s4.indexOf('国');
System.out.println(indexOf); int indexOf2 = s4.indexOf("国！");
System.out.println(indexOf2); int indexOf3 = s4.indexOf('国',4);
System.out.println(indexOf3); int indexOf4 = s4.indexOf("国！",4);
System.out.println(indexOf4);
System.out.println("============================"); System.out.println(s4.lastIndexOf('国'));
System.out.println(s4.lastIndexOf("国！"));
System.out.println(s4.lastIndexOf('国',4));
System.out.println(s4.lastIndexOf("国！",4)); //8:public String substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。
//9:public String substring(int beginIndex, int endIndex) 返回一个新的字符串，它是此字符串的一个子字符串。包含头不包含尾！ String s5 = "abcde i love java!"; String substring = s5.substring(5);
System.out.println(substring);
String substring2 = s5.substring(0);
System.out.println(substring2); //原来的字符串 String substring3 = s5.substring(0, 7);
System.out.println(substring3);
String substring4 = s5.substring(0,s5.length());
System.out.println(substring4); System.out.println(s5);
} }
（3）、字符串的转换功能
（3.1）：重写了Object的toString方法，返回这个字符串本身的数值
（3.2）：public static String copyValueOf(char[] data, int offset, int count) //返回指定数组中表示该字符序列的 String。
（3.3）:public static String valueOf(boolean b或其他基本类型) 基本类型直接转成引用类型
(3.4)：public static String valueOf(char[] data,int offset,int count)
（3.5）：public static String valueOf(Object obj) //注意：字符数组特殊性：打印时，结果不是地址，而是值
例子:
package cn.itcast.myString; import cn.itcast.Person; /*
* String转换：
* 1：重写了Object的toString方法，返回这个字符串本身的数值
* 2：public static String copyValueOf(char[] data, 返回指定数组中表示该字符序列的 String。
int offset, //从哪开始
int count) //取多少个 3:public static String valueOf(boolean b或其他基本类型) 基本类型直接转成引用类型
4：public static String valueOf(char[] data,int offset,int count)
5：public static String valueOf(Object obj) 注意：
字符数组特殊性：打印时，结果不是地址，而是值
*/
public class Demo7 { public static void main(String[] args) { //2:
char[] cArr = {97,98,99}; String copyValueOf = String.copyValueOf(cArr,1,2);
System.out.println(copyValueOf);//bc //3：public static String valueOf(boolean b或其他基本类型)
String valueOf = String.valueOf(true);
System.out.println(valueOf); //true //4：public static String valueOf(char[] data,int offset,int count)
char[] cArr2 = {'a','b','c'};
String valueOf2 = String.valueOf(cArr2, 0, cArr2.length);
System.out.println(valueOf2); //abc //5:public static String valueOf(Object obj)
Person p = new Person();
String valueOf3 = String.valueOf(p);
System.out.println(valueOf3); //调用p对象的toString方法 int[] iArr = {1,2,3,4};
char[] cArr3 = {'a','b','g','s'}; String valueOf4 = String.valueOf(iArr);
String valueOf5 = String.valueOf(cArr3); System.out.println(valueOf4); //打印出来地址
System.out.println(valueOf5);//abgs
} }
（3.6）：public String toLowerCase() 大变小
(3.7)：public String toUpperCase() 小变大
(3.8):public String concat(String str) 将指定字符串连接到此字符串的结尾，可以直接用+代替
例子：
package cn.itcast.myString;
/*
* String转换2：
* 1：public String toLowerCase() 大变小
* 2：public String toUpperCase() 小变大
* 3:public String concat(String str) 将指定字符串连接到此字符串的结尾，可以直接用+代替
*/
public class Demo8 { public static void main(String[] args) {
//1,2：
String s = "I love java"; String lowerCase = s.toLowerCase();
System.out.println(lowerCase); String upperCase = s.toUpperCase();
System.out.println(upperCase); System.out.println(s); //3：
String s2 = ", very much!";
System.out.println(s.concat(s2));
System.out.println(s+s2); //+代替concat() } }
（3.9）public char[] toCharArray() 转成字符数组
（3.10）public byte[] getBytes() 转换成字节数组
例子：
package cn.itcast.myString;
/*
* String的转换方法3：
* 1：public char[] toCharArray() 转成字符数组
* 2:public byte[] getBytes() 转换成字节数组
*/
public class Demo11 { public static void main(String[] args) { //1：
String s = "i love java";
char[] charArray = s.toCharArray();
//{'i',' ','l','o','v','e'....}
System.out.println(charArray); //2:
String s2 = "ab";
byte[] bytes = s2.getBytes(); for (int i = 0; i < bytes.length; i++) {
System.out.print(bytes[i] + " "); //输出对应的ASCII码 97 98
}
System.out.println();
String s3 = "我爱a";
byte[] bytes2 = s3.getBytes();
for (int i = 0; i < bytes2.length; i++) {
System.out.print(bytes2[i] + " "); //-50 -46 -80 -82 97 注意：一个中文字符对应两个字节
}
} }
（4）、其他功能
（4.1）：public String replace(char oldChar, char newChar) 用新字符替换旧字符
（4.2）：public String[] split(String regex) 用指定规则分隔字符串
例子：
package cn.itcast.myString;
/*
* String的其他方法：
* 1：public String replace(char oldChar, char newChar) 用新字符替换旧字符
* 2：public String[] split(String regex) 用指定规则分隔字符串
*/
public class Demo9 { public static void main(String[] args) { //1：
String s = "i love java?";
String replace = s.replace('?', '!');
String replace2 = s.replace('a', 'b');
System.out.println(replace);// i love java！
System.out.println(replace2);// i love jbvb？ //2：使用给定的regex规则，将调用split方法的对象分隔成字符串数组
String s2 = "i wanna u";
String[] split = s2.split(" "); //用空格分割
//{"i","wanna","u"} for (int i = 0; i < split.length; i++) {
System.out.print(split[i]+"----");
} } }
(4.3):public String trim() 返回字符串的副本，忽略前导空白和尾部空白。
* (4.4):public int compareTo(String anotherString) 按字典顺序比较两个字符串。先比较字母，如果一个字符串是另一个字符串的子字符串，
则比较长度
例子:
package cn.itcast.myString;
/*
* String的其他方法：
* 1:public String trim() 返回字符串的副本，忽略前导空白和尾部空白。
* 2:public int compareTo(String anotherString) 按字典顺序比较两个字符串。先比较字母，如果一个字符串是另一个字符串的子字符串，则比较长度
*/
public class Demo10 { public static void main(String[] args) { //1:
String s = "i love java";
String s2 = " i love java";
String s3 = "i love java ";
String s4 = " i love java "; System.out.println(s.trim());
System.out.println(s2.trim());
System.out.println(s3.trim());
System.out.println(s4.trim()); //2按字典顺序比较,public int compareTo(String anotherString) 按字典顺序比较两个字符串。
String s5 = "abc";
String s6 = "bbc";
String s7 = "cbc"; System.out.println(s5.compareTo(s5));
System.out.println(s5.compareTo(s6));
System.out.println(s6.compareTo(s5)); System.out.println(s5.compareTo(s7));
System.out.println(s7.compareTo(s5)); String s8 = "abc";
String s9 = "abcd";
String s10 = "abcdefg"; System.out.println(s8.compareTo(s8)); //
System.out.println(s8.compareTo(s9)); //-1
System.out.println(s9.compareTo(s8)); // System.out.println(s8.compareTo(s10));//-4
System.out.println(s10.compareTo(s8));// String s11 = "abcc";
String s12 = "zbc"; System.out.println(s11.compareTo(s12)); //-25
System.out.println(s12.compareTo(s11)); // String s13 = "aac";
String s14 = "abc"; System.out.println(s13.compareTo(s14)); //-1
} }
3、面试题：
A:字符串一旦被赋值就不能被改动。
注意：这里的改动指的是字符串的内容，而不是字符串对象的引用。
B:String s = new String("hello");和String s = "hello";有区别吗?是什么呢?
有。
前者创建了两个对象。
后者创建了一个对象。
C:看程序，写结果
String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1==s2); //比较地址，false
System.out.println(s1.equals(s2)); // 比较内容，true
String s3 = new String("hello");
String s4 = "hello";
System.out.println(s3==s4); // 比较地址，false
System.out.println(s3.equals(s4)); // 比较内容，true
String s5 = "hello";
String s6 = "hello";
System.out.println(s5==s6); //常量池里面，比较地址 true
System.out.println(s5.equals(s6)); //常量池里面，比较内容 true
D:看程序，写结果
String s7 = "hello";
String s8 = "world";
String s9 = "helloworld";
System.out.println(s9==s7+s8); //false
System.out.println(s9=="hello"+"world"); //true
变量就直接造，常量先找，如果有就使用，否则就造。
(4)字符串的常见功能：(补齐中文)
A:判断功能
boolean equals(Object obj)
boolean equalsIgnoreCase(String str)
boolean contains(String str)
boolean startsWith(String str)
boolean endsWith(String str)
boolean isEmpty()
B:获取功能
int length()
char charAt(int index)
int indexOf(int ch)
int indexOf(String str);
int indexOf(int ch,int fromIndex)
int indexOf(String str,int fromIndex)
String substring(int start)
String substring(int start,int end)
C:转换功能
byte[] getBytes() //获取字符串的字节数组
char[] toCharArray() //获取字符串的字符数组
static String copyValueOf(char[] chs)
static String valueOf(char[] chs)
static String valueOf(int i)
String toLowerCase()
String toUpperCase()
String concat(String str)
D:其他功能
String replace(char old,char new)
String replace(String old,String new)
String[] split(String regex)
String trim()
int compareTo(String str)
int compareToIgnoreCase(String str)
(5)案例：(理解)
A:遍历字符串
package cn.itcast;
/*
* 遍历字符串中每一个字符
*/
public class Test { public static void main(String[] args) { String s = "i love java"; for (int i = 0; i < s.length(); i++) { //遍历字符串
char charAt = s.charAt(i); //通过索引获取到每一个字符
System.out.print(charAt+" ");
} System.out.println(); char[] charArray = s.toCharArray();//将字符串转成字符数组
for (int i = 0; i < charArray.length; i++) { //遍历数组
char c = charArray[i];
System.out.print(c);
}
} }
B:统计字符串中大写字母，小写字母以及数字字符出现的次数
package cn.itcast;
public class Main {
public static void main(String[] args) {
String s = "hello123ABC";
//统计字符串中大写字母，小写字母以及数字字符出现的次数
char[] c= s.toCharArray();
int uCount=0;
int lCount=0;
int numCount=0; for(int i=0;i<c.length;i++){
if(c[i]>='A'&& c[i]<='Z'){
uCount++;
}else if (c[i]>='a'&& c[i]<='z'){
lCount++;
}else if(c[i]>='0'&& c[i]<='9'){
numCount++;
}
}
System.out.println(uCount);
System.out.println(lCount);
System.out.println(numCount);
}
}
C:把一个字符串的首字母变成大写，其他的全部小写
package cn.itcast;
public class Main {
public static void main(String[] args) {
String s = "I lovE Java";
//截取头
tset(s);
} private static void tset(String s) {
String headString=s.substring(0,1); //头变大写
String uHeadString= headString.toUpperCase(); //截取身体
String bodyString= s.substring(1);
//身体大写
String uBodyString=bodyString.toLowerCase();
//输出
System.out.println(uHeadString+uBodyString);
}
}
D:统计大串中小串出现的次数
package cn.it;
/*
* 给定一个字符串找到子串在字符串中出现的次数。String s = “abcitcastabcxxxabc”中的“abc”
*/
public class Test4 { public static void main(String[] args) { //定义变量，记录大字符串
String s = "abcitcastabcxxxabc";
// "itcastabcxxxabc"
//定义变量，记录小字符串
String subS = "abc"; method(s, subS);
}
public static int method(String s, String subS) {
//定义变量，为初始字符串保持副本
String copyS = s;
//定义变量，记录出现次数
int count = 0; //定义变量，记录小字符串在大字符串中出现的索引
int index = s.indexOf(subS); //
while (index!=-1) {
count++;//找到一次小字符串就将个数+1
// index+subS.length() 这是去掉了一次小字符串后的剩余字符串开始索引
// 截取剩余字符串
s = s.substring(index+subS.length());
// 使用剩余字符串继续判断是否有"abc"字符串
index = s.indexOf(subS);
} System.out.println(subS+"在"+copyS+"中出现的次数为："+count); } }