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)); //0 System.out.println(s8.compareTo(s9)); //-1 System.out.println(s9.compareTo(s8)); //1 System.out.println(s8.compareTo(s10));//-4 System.out.println(s10.compareTo(s8));//4 String s11 = "abcc"; String s12 = "zbc"; System.out.println(s11.compareTo(s12)); //-25 System.out.println(s12.compareTo(s11)); //25 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); } }