Java基础-常用API之String类
Scanner键盘录入时的一个小问题
描述：当第一次录入的是一个int类型的数据，第二次录入的是一个String类型的数据时，那么JVM会在扫描int类型 数据的时候，误将回车当做一个字符串，扫描成是第二次录入的String类型的数据，导致结果不一致。
解决方案：
A：在接收完int类型数据的时候，重新创建一个Scanner对象，调用新对象的nextLine（）方法
B：将所有类型，都使用String类型的数据录入，接收完后，将本该属于int类型数据的那个String类型数据转 换成int类型数据，然后继续运算
错误代码如下：
package cn.itcast12;
/*
* 测试Scanner录入数据异常
*/
import java.util.Scanner;
public class ScannerTest {
public static void main(String[] args) {
//创建Scanner对象
Scanner sc = new Scanner(System.in);
//获取一个int类型的数据
//System.out.println("请输入一个int类型的整数:");
int i = sc.nextInt();
//获取一个String类型的数据
//System.out.println("请输入一个String类型的值:");
String s= sc.nextLine();
System.out.println(i+s);
}
}
改进代码1：
package cn.itcast12;
/*
* 测试Scanner录入数据异常
*/
import java.util.Scanner;
public class ScannerTest {
public static void main(String[] args) {
//创建Scanner对象
Scanner sc = new Scanner(System.in);
//获取一个int类型的数据
System.out.println("请输入一个int类型的整数:");
int i = sc.nextInt();
//获取一个String类型的数据
System.out.println("请输入一个String类型的值:");
/*
* 改进代码
* 重新创建一个Scanner对象
*/
sc = new Scanner(System.in);
String s= sc.nextLine();
System.out.println(i+s);
}
}
结果：
改进代码2：
package cn.itcast12;
/*
* 测试Scanner录入数据异常
*/
import java.util.Scanner;
public class ScannerTest {
public static void main(String[] args) {
//创建Scanner对象
Scanner sc = new Scanner(System.in);
//获取一个int类型的数据
System.out.println("请输入一个int类型的整数:");
/*
* 所有数据类型的都使用String类型来接收
* 然后转换成相对应的类型
*
*/
String s1 = sc.nextLine();
//转换成int类型
int i = Integer.parseInt(s1);
//int i = sc.nextInt();
//获取一个String类型的数据
System.out.println("请输入一个String类型的值:");
String s= sc.nextLine();
System.out.println(i+s);
}
}
结果：
空串和null的区别
空串：空串是一个实实在在的对象，占用内存空间
null：是一个常量，当一个引用指向null时，使用该引用去调用方法，会报空指针异常 NullPointerException
创建String类对象的方式
A：通过new的方式：String s = newString（） 包括所有构造方法
B：通过直接赋值的方式：String s = “hello”
数组和字符串分别通过什么方式来获取长度
A：数组：通过的是数组的 length 属性： arr.length
B：字符串：通过字符串类中的 length（）方法： s.length()
String类的面试题
A：如何理解字符串一旦初始化就不可以改变。
字符串一旦被初始化后就不可以改变，指的是字符串的值，即字符串本身不可以改变，并不是指字符串对象的引用不可以改变，字符串的引用还可以指向其他内存空间的
B：String s = new String（“abc”）和String s = “abc”的区别
String s = new String（“abc”），在内存中存在两个“abc”，一个在常量池中，一个在对内存中
String s = “abc”，在内存中只有一个“abc”，存在常量池中。
String类的判断功能
A：boolean equals(Object obj)-->判断两个字符串的内容是否相等, 区分大小写
(比较的是内容,明显是重写了父类Object中的equals方法
B:boolean equalsIgnoreCase(String str)-->判断两个字符串的内容是否相等,不区分大小写
C:boolean contains(String str)-->判断这个字符串是否包含给定的字符串
D:boolean startsWith(String str)-->判断该字符串是否以给定的字符串开始
E:boolean endsWith(String str)-->判断字符串是否以给定的字符串结束
F:boolean isEmpty()-->判断字符串是否为空
代码:
package cn.itcast_03;
/*
* 判断功能：
* boolean equals(Object obj)：判断字符串的内容是否相同,区分大小写。
* boolean equalsIgnoreCase(String str):判断字符串的内容是否相同,不区分大小写。
* boolean contains(String str):判断字符串对象是否包含给定的字符串。
* boolean startsWith(String str):判断字符串对象是否以给定的字符串开始。
* boolean endsWith(String str):判断字符串对象是否以给定的字符串结束。
* boolean isEmpty():判断字符串对象是否为空。数据是否为空。
*/
public class StringDemo {
public static void main(String[] args) {
// 创建字符串对象
String s = "HelloWorld";
// boolean equals(Object obj)：判断字符串的内容是否相同,区分大小写。
System.out.println(s.equals("HelloWorld"));
System.out.println(s.equals("helloworld"));
System.out.println("--------------------");
// boolean equalsIgnoreCase(String str):判断字符串的内容是否相同,不区分大小写。
System.out.println(s.equalsIgnoreCase("HelloWorld"));
System.out.println(s.equalsIgnoreCase("helloworld"));
System.out.println("--------------------");
// boolean contains(String str):判断字符串对象是否包含给定的字符串。
System.out.println(s.contains("or"));
System.out.println(s.contains("ak"));
System.out.println("--------------------");
// boolean startsWith(String str):判断字符串对象是否以给定的字符串开始。
System.out.println(s.startsWith("Hel"));
System.out.println(s.startsWith("hello"));
System.out.println("--------------------");
// boolean endsWith(String str):判断字符串对象是否以给定的字符串结束。省略不讲。
// boolean isEmpty():判断字符串对象是否为空。数据是否为空。
System.out.println(s.isEmpty());
String s2 = "";
System.out.println(s2.isEmpty());
// String s3 = null;
// NullPointerException 空指针异常
// System.out.println(s3.isEmpty());
//boolean equals(Object obj)：判断字符串的内容是否相同,区分大小写。
}
}
String类的获取功能
A:int length()-->获取字符串的长度,注意这里是length()方法,与获取数组长度的length属性不同
B:char charAt(int index)-->获取指定index索引位置的字符,返回的是一个字符
C:int indexOf(int chr)-->获取指定字符,在字符串中第一次出现的索引
D:int indexOf(String str)-->获取指定字符串,在该字符串中第一个出现的索引
E:int indexOf(String str, int fromIndex)-->获取指定字符串在该字符串中,从fromIndex位置开始,第一次出现的位置
F:String subString(int start)-->截取子字符串,从指定start索引处开始,到结尾
G:String subString(int start, int end)-->截取子字符串,从指定的start索引处开始,到指定的end索引处结束
代码:
package cn.itcast_04;
/*
* 字符串的获取功能：
* 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)截取字符串。返回从指定位置开始到指定位置结束截取后的字符串。
*/
public class StringDemo {
public static void main(String[] args) {
// 创建字符串对象
String s = "helloworld";
// int length():获取字符串的长度
System.out.println(s.length());
System.out.println("--------");
// char charAt(int index):返回字符串中给定索引处的字符
System.out.println(s.charAt(2));
System.out.println("--------");
// 遍历字符串。
for (int x = 0; x < s.length(); x++) {
char ch = s.charAt(x);
System.out.println(ch);
}
System.out.println("--------");
// int indexOf(int ch):返回指定字符在此字符串中第一次出现的索引
System.out.println(s.indexOf('l'));
// int indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符的索引，从指定的索引开始搜索。
System.out.println(s.indexOf('l', 4));
System.out.println("--------");
// 常见的方法：包左不包右。
// String substring(int start):截取字符串。返回从指定位置开始截取后的字符串。
String s1 = "helloworld";
System.out.println(s1.substring(4));
// String substring(int start,int end)截取字符串。返回从指定位置开始到指定位置结束截取后的字符串。
System.out.println(s1.substring(3, 5));
//截取的串要和以前一样。
System.out.println(s1.substring(0));
System.out.println(s1.substring(0,s.length()));
System.out.println(s1);
}
}
String类的转换功能
A:byte[] getBytes()-->将字符串转换成字节数组
B:char[] toCharArray()-->将字符串转换成字符数组
C:static String valueOf(char[] chs)-->将字符数组转换成字符串
D:static String valueOf(int i)-->将一个int类型转换成字符串(适用于所有基本数据类型)
E:String toUpperCase()-->将字符串全部转换成大写
F:String toLowerCase()-->将字符串全部转换成小写
G:String concat(String str)-->将两个字符串拼接
代码:
package cn.itcast_05;
/*
* byte[] getBytes():把字符串转换成字节数组。
* char[] toCharArray()：把字符串转换成字符数组。
* static String copyValueOf(char[] chs):把字符数组转换成字符串。
* static String valueOf(char[] chs):把字符数组转换成字符串。
* static String valueOf(int i)基本类型：把int（基本类型）转换成字符串。
* String toLowerCase()：把字符串变成小写
* String toUpperCase():把字符串变成大写
* String concat(String str):拼接字符串。
*/
public class StringDemo {
public static void main(String[] args) {
// 创建字符串对象
String s = "HelloWorld";
// byte[] getBytes():把字符串转换成字节数组。
byte[] bys = s.getBytes();
for (int x = 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 copyValueOf(char[] chs):把字符数组转换成字符串。
char[] chs2 = { 'a', 'b', 'c', '中', '国' };
String s2 = String.copyValueOf(chs2);
System.out.println(s2);
System.out.println("-----------------");
// static String valueOf(char[] chs):把字符数组转换成字符串。
String s3 = String.valueOf(chs2);
System.out.println(s3);
System.out.println("-----------------");
// static String valueOf(int i)
int i = 100;
String s4 = String.valueOf(i);
System.out.println(s4);
System.out.println("-----------------");
// String toLowerCase()：把字符串变成小写
System.out.println(s.toLowerCase());
// String toUpperCase():把字符串变成大写
System.out.println(s.toUpperCase());
System.out.println("-----------------");
// String concat(String str):拼接字符串。
String s5 = "hello";
String s6 = s5 + "world";
String s7 = s5.concat("world");
System.out.println(s6);
System.out.println(s7);
}
}
关于String类的一些面试题:
统计一个字符串的大小写字符和数字的个数. 如:Hello1234World
代码:
package cn.itcast_04;
/*
* 统计大写小写字符的个数
*
* 举例：
* Hello12345World
*
* 大写：2
* 小写：8
* 数字：5
*
* 思路：
* A:定义三个统计变量
* B:获取到每一个字符。遍历字符串。
* C:判断是属于哪种范围的
* 大写：65-90
* 小写：97-122
* 数字：48-57
* C:是哪种哪种++
*/
public class StringTest {
public static void main(String[] args) {
String s = "Hello12345World";
// 定义三个统计变量
int bigCount = 0;
int smallCount = 0;
int numberCount = 0;
// 遍历字符串。
for (int x = 0; x < s.length(); x++) {
char ch = s.charAt(x);
// 判断是属于哪种范围的
// if (ch >= 65 && ch <= 90) {
// bigCount++;
// } else if (ch >= 97 && ch <= 122) {
// smallCount++;
// } else if (ch >= 48 && ch <= 57) {
// numberCount++;
// }
if (ch >= 'A' && ch <= 'Z') {
bigCount++;
} else if (ch >= 'a' && ch <= 'z') {
smallCount++;
} else if (ch >= '0' && ch <= '9') {
numberCount++;
}
}
System.out.println("大写：" + bigCount);
System.out.println("小写：" + smallCount);
System.out.println("数字：" + numberCount);
}
}
结果:
把字符串首字符转成大写,其余为小写. 如:helloWorld
代码:
package cn.itcast_05;
/*
* 需求:把字符串的首字母转成大写，其余为小写
*
* 举例：
* helloWorld
*
* 结果：
* Helloworld
*
* 思路：
* A:截取首字母。
* B:截取其他字母。
* C:把A转大写+B转小写
*/
public class StringTest {
public static void main(String[] args) {
String s = "helloWorld";
String s1 = s.substring(0, 1);
String s2 = s.substring(1);
String s3 = s1.toUpperCase().concat(s2.toLowerCase());
System.out.println(s3);
// 链式编程
String result = s.substring(0, 1).toUpperCase().concat(s.substring(1).toLowerCase());
// System.out.println(result);
}
}
结果:
大串找小串
代码
package cn.itcast_07;
/*
* 获取一个字符串中指定子串出的次数。比如说“hanbasdnbafllgnbahjnbakqqqqlnbaxi” 在这个字符串中，多有个nba？
*
* 思路:
* A:定义两个字符串,一个大串,一个小串.定义一个统一变量,初始化值为0
* B:在大串中查找小串第一次出现的索引 大串.indexOf(小串),并记录著index的值
* 如果存在,会返回index的值,这个时候,count++
* 如果不存在,该方法会返回-1,那么就代表在大串中不存在小串,直接返回count的值,此时为0
* C:如果存在,把步骤B中记录的index的值,加上小串的长度,作为起始位置,从该位置开始,截取大串,然后再次赋值给大串
* D:重复步骤B
*
*/
public class StringTest2 {
public static void main(String[] args) {
String str = "hanbasdnbafllgnbahjnbakqqqqlnbaxnbai";
String regex = "nba";
// 功能
int count = getCount(str, regex);
int count2 = getCount2(str, regex);
System.out.println(count);
}
/*
* 返回值：统计变量的值 int 参数列表：大串和小串
*/
public static int getCount(String maxString, String minString) {
// 定义统计变量
int count = 0;
// 在大串中查找小串一次
int index = maxString.indexOf(minString);
// 如果返回值不是-1，说明小串在大串中是存在的。
while (index != -1) {
// 统计变量++
count++;
// 把查找过的数据给截取掉,重新赋值给大串
maxString = maxString.substring(index + minString.length());
// 在新的大串中查找一次小串
index = maxString.indexOf(minString);
}
return count;
}
// 优化代码
//
public static int getCount2(String maxString, String minString) {
// 定义统计变量
int count = 0;
// 在大串中查找小串一次
int index = 0;
// 如果返回值不是-1，说明小串在大串中是存在的。
// 判断
while ((index = maxString.indexOf(minString)) != -1) {
// 统计变量++
count++;
// 把查找过的数据给截取掉,重新赋值给大串
maxString = maxString.substring(index + minString.length());
}
return count;
}
}结果:
