String类常用方法

一.String类特点

Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现;字符串一旦被赋值,其值不能再改变

二.String类常用的构造方法

1）String():表示一个空字符序列。

2）public String(byte[] bytes,Charset ch):默认字符集(编码格式):GBK,如果是GBK格式,可以不写第二个参数

3）public String(byte[] bytes,int index,int length):将部分字节数组构造成一个字符串

4）public String(char[] value,int index,int length):将部分字符数组构造成一个字符串

5）public String(char[] value):将字符数组构造成一个字符串

6）public String(String original):通过字符串常量构造一个字符串对象

获取字符串的长度功能:public int length()

面试题：

数组中有没有length(),字符串(字符串缓冲区:StringBuffer)中没有length(),集合中有没有length()(集合后面补充)?

数组没有length(),但有length属性、字符串中有length()、集合中没有length(),获取集合中元素数量:size()

三.编码和解码：

一定要保证编码格式一致

编码：把能看懂的东西转换成一个看不懂的东西:String----->byte[]:public byte[] getBytes(String charsetName)

解码：把当前的byte[]转成能看懂的东西(String):byte[]----->String :public String(byte[] bytes,CharsetName ch)

package day_11_10_29.string01;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class StringDemo01 {
	public static void main(String[] args) throws UnsupportedEncodingException{
		//创建一个String对象
		String s1 = new String();
		System.out.println("s1.length():"+s1.length());//0
		System.out.println("s1:"+s1);
		System.out.println("----------------------");
		
		/**
		 * public String(byte[] bytes,Charset ch):默认字符集(编码格式):GBK,如果是GBK格式,可以不写第二个参数
		 * */
		byte[] bys = {97,98,99,100,101};
		String s2 = new String(bys);  	//字节的值要找它对应的ASCII码表中的字符
		System.out.println("s2:"+s2);	//abcde
		System.out.println("s2.length():"+s2.length()); //5
		/**
		 * 编码和解码格式必须一致
		 */
		//编码
		String s = "你好啊";
		//[-28, -67, -96, -27, -91, -67, -27, -107, -118]:utf-8:一个中文:对应三个字节
		//[-60, -29, -70, -61, -80, -95]  :GBK格式编码，一个中文:对应两个字节 
		//byte[] bys2 = s.getBytes("utf-8");
		byte[] bys2 = s.getBytes();
		//System.out.println(bys2);
		System.out.println(Arrays.toString(bys2));
		System.out.println("-------");
		/**
		 * 5.public String(byte[] bytes,int index,int length):将部分字节数组构造成一个字符串
		 * */
		String s7 = new String(bys2,2,4);
		System.out.println("s7.length():"+s7.length());
		System.out.println("s7:"+s7);
		System.out.println("-------");
		//解码
		/**
		 *1.public String(byte[] bytes,CharsetName ch),GBK格式编码可以省略第二个参数
		 * */
		//String str = new String(bys2,"utf-8");
		String str = new String(bys2);
		System.out.println("str:"+str);
		System.out.println("-------");
		/**
		 *2.public String(char[] value):将字符数组构造成一个字符串
		 * */
		char[] chs = {'爱','学','习'};
		String s3 = new String(chs);
		System.out.println("s3.length():"+s3.length());
		System.out.println("s3:"+s3);
		System.out.println("-------");
		/**
		 *3.public String(char[] value,int index,int length):将部分的字符数组构造成一个字符串
		 * */
		String s4 = new String(chs,1,2);
		System.out.println("s4.length():"+s4.length());
		System.out.println("s4:"+s4);
		System.out.println("-------");
		/**
		 *4.public String(String original):通过字符串常量构造一个字符串对象
		 * */
		String s5 = new String("hello");
		System.out.println("s5.length():"+s5.length());
		System.out.println("s5:"+s5);
		System.out.println("-------");
		String s6 = "hello" ;
		System.out.println("s6:"+s6);
		System.out.println("s6.length():"+s6.length());
	}
}

面试题：

String s = "hello"和String s = new String("helllo")两个的区别？分别创建了几个对象

第一个创建了一个对象
第二个s创建两个对象(堆内存中有new String(),然后字符串常量池中也有这样一个字符串常量(开辟空间的地址))

练习题： 字符串常量相加和字符串变量相加的区别：

package day_11_10_29.string01;
/**
 * 字符串变量相加:先开辟空间,在相加,s3 == s1 + s2<=>s1+s2 ====>new String("helloworld")
 * 字符串常量相加:首先在字符串常量池找,有没有当前这个常量值,有,就直接返回,没有,需要创建!
 * 
 */
public class StringDemo {
	public static void main(String[] args) {
		String s1 = "hello";  
		String s2 = "world";
		String s3 = "helloworld";
		System.out.println(s3 == s1 + s2);// false
		//System.out.println(s3 == (new StringBuilder(String.valueOf(s1))).append(s2).toString());
//		s1+s2 ====>new String("helloworld")
		
		System.out.println(s3.equals((s1 + s2)));//true , 
		System.out.println(s3 == "hello" + "world");//true
		System.out.println(s3.equals("hello" + "world"));//true
		
		/**
		 * 通过反编译工具查看第三个输出语句:
		 * System.out.println(s3 == "helloworld");
			System.out.println(s3.equals("helloworld"));
		 * */

	}

}
package day_11_10_29.string01;

public class StringDemo3 {
	public static void main(String[] args) {
		//创建字符串对象
		String s1 = new String("hello");
		String s2 = new String("hello");
		System.out.println(s1==s2);//false,两个new对象的地址不一样
		
		
		String s3 = "hello" ;
		String s4 = "hello" ;
		System.out.println(s3==s4);//true,两个指向字符串常量池中的一个地址
		System.out.println(s3.equals(s4));//true，String类重写了equals方法，比较的是两个对象的值
		
		String s5 = new String("world") ;
		String s6 = "world" ;
		System.out.println(s5==s6);//false,s5指向两个地址(堆内存和常量池中都有一个地址)，s6只指向字符串常量池中的地址
		System.out.println(s5.equals(s6));//true,String类重写了equals方法，比较的是两个对象的值
	}

}



练习题：模拟用户登陆，给三次机会，成功登陆后，玩猜数字游戏

package day_11_10_29.guess_number;

import java.util.Scanner;
/**
 * 需求:模拟用户登陆,给3次机会,并给提示
 * 
 * 分析：1)定义一个用户名和密码
 * 			String name = "luola";
 * 			String password = "123";
 * 	 	2)创建键盘录入对象，录入用户名和密码
 * 		3)给3次机会，使用for循环进行判断for(int i=0;i<3;i++){}
 * 		录入：录入的用户名和密码和已经存在的用户名和密码进行比较，
 * 		判断：如果一致：登陆成功
 * 			 不一致：有一个不符合，就登陆不成功
 * 			if((2-x)==0){
 * 			}else{
 * 				//输出还有(2-x)次机会
 * 			}
 * */
public class StringTest {
	public static void main(String[] args) {
		// 定义用户名和密码
		String name = "luola";
		String password = "123";
		for(int x=0;x<3;x++){
			//创建键盘录入对象
			Scanner sc = new Scanner(System.in);
			//录入用户名和密码
			System.out.println("请输入用户名: ");
			String newUserName = sc.nextLine();
			System.out.println("请输入密码:");
			String newPassword = sc.nextLine();
			//判断
			if(name.equals(newUserName)&&password.equals(newPassword)){
				//一致
				System.out.println("登陆成功，开始玩游戏。。。");
				GuessNumber.start();
				break;
			}else{
				//登陆不成功
				//2,1,0
				//如果有0次机会了，换一种提示
				if((2-x)==0){
					System.out.println("机会已用完，速与管理员联系。。。");
				}else{
					System.out.println("你还有"+(2-x)+"次机会");
				}
			}
		}
	}

}

package day_11_10_29.guess_number;
import java.util.Scanner;
/**
 * 分析：1.生成一个随机数Math.random()
 * 	   2.创建键盘录入对象，并输入所猜数据
 * 	   3.判断录入数据和随机数的大小
 * */
public class GuessNumber {
	
//构造方法私有化，通过静态功能
	private GuessNumber() {
	}
	
	public static void start(){
		//生成一个随机数0-100：Math.random();
		int number = (int)(Math.random()*100+1);
		//定义一个统计变量
		int count = 0;
		//多次录入
		while(true){
			//创建键盘录入对象
			Scanner sc = new Scanner(System.in);
			System.out.println("请输入一个数字：");
			int guessNumber = sc.nextInt();
			//统计变量
			count ++;
			//判断
			if(guessNumber>number){
				System.out.println("您猜的数据"+guessNumber+"大了");
			}else if(guessNumber < number){
				System.out.println("您猜的数据"+guessNumber+"小了");
			}else{
				System.out.println("恭喜您"+count+"次猜中了...");
				break;
			}
		}
	}	
}

四.String类的中常用的判断功能:

1)booleanequals(Object obj):当前该对象是否obj这个对象是否相等;
2)boolean equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写
3)boolean contains(String str):判断str这个字符串是否包含在当前字符串中
4)boolean startsWith(String str):是否以str子字符串开头
5)boolean endsWith(String str):判断是否以str子字符串结尾
6)boolean isEmpty():判断字符串是否为空

注意：

String s = "";空字符       

String s = " " ;字符串"空格"

String s = null ;当前字符串对象为空

package day_11_10_29.decision;

public class StringDemo {

	public static void main(String[] args) {
		// 定义一个字符串
		String s1 = "helloworld";
		String s2 = "helloworld";
		String s3 = "";	  //空字符
		String s4 = " ";	//字符串"空格
		String s5 = null;  //当前字符串对象为空
		/**
		 * 1.equals(Object obj):当前该对象是否obj这个对象是否相等; 
		 * */
		System.out.println(s1.equals(s2));	//true
		/**
		 * 2.equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写
		 * */
		System.out.println(s1.equalsIgnoreCase(s2)); //true
		/**
		 * 3.contains(String str):判断str这个字符串是否包含在当前字符串中
		 * */
		System.out.println(s1.contains("hel")); //true
		System.out.println(s1.contains("hed")); //false
		/**
		 * 4.startsWith(String str):是否以str子字符串开头
		 * */
		System.out.println(s1.contains("hel")); //true
		/**
		 * 5.endsWith(String str):判断是否以str子字符串结尾
		 * */
		System.out.println(s1.contains("ld")); //true
		/**
		 * 6.isEmpty():判断字符串是否为空
		 * */
		System.out.println(s1.isEmpty());   //false
		System.out.println("s3="+s3.isEmpty());	//true
		System.out.println(s4.isEmpty());	//false
		//System.out.println(s5.isEmpty());	//java.lang.NullPointerException
		
	}

}

五. String类的获取功能:

1)int length():获取字符串长度功能

2)char charAt(int index):返回的是索引处对应的字符

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

注意：为什么这里的字符用int来定义:97 'a'

4)int indexOf(String str):返回指定子字符串在此字符串中第一次出现的索引

5)int indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。

6)int indexOf(String str,int fromIndex):返回在此字符串中第一次出现指定字符串处的索引，从指定的索引开始搜索

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

8)String substring(int start,int end):从指定位置开始截取到指定位置结束,包前(start索引)不包后(end索引)

package day_11_10_29.string01;
public class StringDemo5 {
	public static void main(String[] args) {
		// 定义一个字符串
		String str = "helloworld";
		/**
		 *1.int length()	:获取字符串长度功能
		 * */
		int length = str.length();
		System.out.println("length:"+length);  //length:10
		System.out.println("-----------");  //length:10
		
		/**
		 *2. char charAt(int index):返回的是索引处对应的字符
		 * */
		System.out.println("charAt:"+str.charAt(0));
		System.out.println("-----------");
		for(int i=0;i<str.length();i++){
			str.charAt(i);
			System.out.print("charAt["+i+"]:"+str.charAt(i)+" ");
		}
		System.out.println("");
		
		/**
		 *3. int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引
		 * */
		System.out.println(str.indexOf('l'));
		
		/**
		 *4. int indexOf(String str):返回指定子字符串在此字符串中第一次出现的索引
		 * */
		System.out.println(str.indexOf("lo"));
		
		/**
		 *5. int indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
		 * */
		System.out.println(str.indexOf('l',5));
		
		/**
		 *6. int indexOf(String str,int fromIndex):返回在此字符串中第一次出现指定字符串处的索引，从指定的索引开始搜索
		 * */
		System.out.println(str.indexOf("lo",6)); //不存在，返回-1
		
		/**
		 *7. String substring(int start):从指定位置开始截取字符串,默认截取到末尾
		 * */
		System.out.println(str.substring(1));
		
		/**
		 *8. String substring(int start,int end):从指定位置开始截取到指定位置结束,包前(start索引)不包后(end索引)
		 * */
		System.out.println(str.substring(0,5)); //hello
	}
}

练习：字符串的遍历输出（charAt(index)）

package day_11_10_29.string01;

public class StringTest {
	public static void main(String[] args) {
		// 定义字符串
		String s = "helloworld";
		for(int i=0;i<s.length();i++){
			System.out.print(s.charAt(i)+" ");
		}
	}
}

练习：把数组中的数据按照指定个格式拼接成一个字符串，举例：int[] arr = {1,2,3};输出结果：[1, 2, 3]

明确输出结果是String类型，输入的是一个整形数组

package day_11_10_29.string01;
/**
 *分析: 
 *	1)定义数组:int[] arr = {1, 2, 3}
 * 	2)定义空字符串:String s = "" ;
 * 	3)用空串拼接一个"["
 *  4)遍历int类型的数组,获取到每一个数组中的元素
 *  判断当前某一个索引是否是最大索引
 * 			如果是:用空串+= arr[x] ;
 * 				   用空串 +="]";
 * 			不是:
 * 				用空串+= arr[x]
 * 				用空串+= ", "
 * */
public class StringTest2 {
	public static void main(String [] args){
		//定义一个数组并初始化
		int [] arr = {1,2,3};
		String s = "";
		s+="[";
		for(int i=0;i<arr.length;i++){
			//判断
			if(i==arr.length-1){
				s+=arr[i];
				s+="]";
			}else{
				s+=arr[i];
				s+=",";
			}	
		}
		System.out.println(s);
	}
}

练习：使用键盘录入一个字符串：统计该字符串中大写字母字符，小写字母字符，数字字符,及其他字符出现的次数。

package day_11_10_29.string01;

import java.util.Scanner;

/**
 * 需求：使用键盘录入一个字符串：统计该字符串中大写字母字符，小写字母字符，数字字符,及其他字符出现的次数。
 * 分析：1）定义四个统计变量
 * 			int bigCount = 0 ;
 * 		    int smallCount = 0 ;
 * 			int numberCount = 0 ;
 * 			int otherCount = 0;
 * 		2)创建键盘录入对象,录入一个字符串
 * 		3)使用for循环遍历字符串
 * 		4)遍历的时候获取到字符
 * 			ch>='a' && ch<='z'
 * 				属于小写字母字符:smallCount++;
 * 			ch>='A' && ch<='Z'
 *				 属于大写字母字符:bigCount++;
 *			ch>='0' && ch<='9'
 * 				属于数字字符:numberCount++;
 * 			其他字符otherCount++;
 * 
 * */
public class StringTest3 {
	public static void main(String[] args) {
		// 定义四个统计变量
		int bigCount = 0 ;
	    int smallCount = 0 ;
		int numberCount = 0 ;
		int otherCount = 0;
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		
		//录入并接收
		System.out.println("请输入一个字符串：");
		String s1 = sc.nextLine();
		
		//for循环遍历字符串
		for(int i=0;i<s1.length();i++){
			//获取每一个字符串
			char ch = s1.charAt(i);
			//对当前的字符进行判断
			if(ch>='a' && ch<='z'){
				smallCount++;
			}else if(ch>='A' && ch<='Z'){
				bigCount++;
			}else if(ch>='0' && ch <='9'){
				numberCount++;
			}else{
				otherCount++;
			}	
		}
		System.out.println("当前字符串中大写字母字符共有:"+bigCount+"个");
		System.out.println("当前字符串中小写字母字符共有:"+smallCount+"个");
		System.out.println("当前字符串中数字字符共有:"+numberCount+"个");
		System.out.println("当前字符串中其他字符共有:"+otherCount+"个");
		

	}

}

六.String类的转换功能(重点)

1).byte[]getBytes():将字符串转换字节数组

2)char[]toCharArray():将字符串转换成 字符数组 (开发中经常使用)

3)static StringvalueOf(char[] chs):将字符数组转换成字符串

4)static StringvalueOf(int i):将一个int类型的数据转换成字符串

注意：String类中的valueOf()可以将任何数据类型转换成字符串

5)StringtoLowerCase():将字符串全部转成小写

6)StringtoUpperCase():将字符串全部转换成大写

7)String concat(String str):字符串拼接方法

package day_11_10_29.string01;

public class StringDemo6 {
	public static void main(String[] args) {
		// 定义一个字符串
		String s = "javaSE";
		/**
		 *1.byte[] getBytes():将字符串转换字节数组
		 * */
		byte[] bys = s.getBytes();
		//遍历字节数组
		for(int i=0;i<bys.length;i++){
			System.out.print(bys[i]+" ");
		}
		System.out.println("-----------");
		
		/**
		 *2.char[] toCharArray():将字符串转换成 字符数组 (开发中经常使用)
		 * */
		char[] ch = s.toCharArray();
		for(int i=0;i<bys.length;i++){
			System.out.print(ch[i]+" ");
		}
		System.out.println("");
		System.out.println("------------");
		
		/**
		 *3.static String valueOf(char[] chs):将字符数组转换成字符串
		 * */
		String s2 = String.valueOf(ch);
		System.out.print("s2:"+s2);
		System.out.println("");
		System.out.println("------------");
		
		/**
		 *4.static String valueOf(int i):将一个int类型的数据转换成字符串
		 * */
		String s3 = String.valueOf(97);
		System.out.println("s3:"+s3);//97
		System.out.println("------------");
		
		/**
		 *5.String toLowerCase():将字符串全部转成小写
		 * */
		String s4 = s.toLowerCase();
		System.out.println("s4:"+s4);
		System.out.println("------------");
		
		/**
		 *6.String toUpperCase():将字符串全部转成大写
		 * */
		String s5 = s.toUpperCase();
		System.out.println("s5:"+s5);
		System.out.println("------------");
		
		/**
		 *7.String concat(String str):字符串拼接方法
		 * */
		String s6 = "hello";
		String s7 = "world";
		System.out.println("concat:"+s6.concat(s7));	
	}
}