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;
	}
}

结果: