(8)Java String字符串_str = str.substring(index+key.length());-CSDN博客

本文链接：https://blog.csdn.net/u011818171/article/details/17911625

Java String字符串

概述

在实际开发中常见的数据之一--字符串，它适用于描述字符串事物。

因为常用所以java把它封装成了对象，以便操作这些字符串。

查询API，在lang包里的string类被final修饰，所以不能复写其功能，子类也不会有。

String类代表字符串。

字符串是一个特殊对象，一旦初始化就不可以被改变。

示例：

String s1 = “abc”;//s1是一个类类型变量，“abc”是一个对象；

String s2 = new String(“abc”);

面试考点：

S1与s2的区别？

S1在内存中有一个对象。

S2在内存中有两个对象。

S1==s2结果是false，因为是两个对象。

S1.equals(s2)结果是true，因为他们比较的是内存地址值。

String类复写了Object类中的equals方法，该方法用于判断字符串是否相同。

字符串常见操作：

获取：

1，字符串中包含的字符数，也就是字符串的长度

int length():获取长度。

2，根据位置获取该位置上的某字符。

char charAt(int intdex);

3，根据字符获取该字符在字符串中位置。

int indexOf(int ch);返回的是ch在字符串中第一次出现的位置。

int indexOf(int ch,int fromIndex);从fromIndex指定位置开始，获取ch在字符串中出现的位置

int indexOf(String str);返回的是str在字符串中第一次出现的位置。

int intdexOf(String str,int fromIndex);从fromIndex指定位置开始，获取str在字符串中出现的位置

4，int lastIndexOf(int ch);/返向索引一个字符串出现的位置。

示例：

class StringDemo {
	public static void sop(Object obj){
		System.out.println(obj);
	}
	public static void main(String[] args) {
		String str = "abcdefg";
		sop(str.length());//获取字符串长度
		sop(str.charAt(4));//根据索引获取该字符串，
		//当访问到字符串角标不存在时会发生Strinng IndexOutOfBoundsException.
		sop(str.indexOf('m',3));//根据字符获取索引，若没找到，返回-1；
		sop(str.lastIndexOf("a"));
	}
}

判断：

1，字符串中是否包含了某一字符串。

boolean contains(str);

特殊之处：

indexOf(str):可以索引str第一次出现的位置，若该str不在字符串返回-1，索引也可以适用于对指定判断是否包含。

if(str.indexOf(“aa”)!-1)

该方法既可以判断也可以获取出现位置。

2，字符串中是否有内容,原理就是判断长度为0

boolean isEmpty();

3，字符串是否是以指定内容开始。

boolean startsWith(str);

4，字符串是否是以指定内容结尾

boolean endsWith(str);。

5，判断字符串的内容是否相同。复写了object类中的equals方法。

boolean equals(str)

6，判断内容是否相同，并忽略大小写

boolean equalsIgnoreCase()

示例：
	public static void demo_1(){ 
		String str = "StringDemo.java";
		sop(str.startsWith("String"));//判断文件名称是否是String单词开头
		sop(str.endswith("Demo"));//判断文件名称是否是.java的文件
		sop(str.contains(".java"));//判断文件名中是否包含Demo
　　}

转换：

1，将字符数组转成字符串。

构造函数：

String(char[]);

String (char[],offset,count);：将字符数组中的一部分转换成字符串

静态方法：

static String copyValueOf(char[]);

static String copyValueOf(char[] data,int offset,int count);

static String ValueOf(char[]);

2，将字符串转换成字符数组

char[] toCharArray();

3，将字节数组转换成字符串

String(byte[])

String(byte[],offset,count)：将字节数组中的一部分转成字符串

4，将字符串转化成字节数组

byte[] getBytes();

5，将基本数据类型转换成字符串

static String valueOf(int );

static String valueOf(double );

特殊：字符串和字节数组在转换过程中，是可以指定编码表的。

示例：
	public static void demo_2(){
		char[] arr = {‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘h’};
		String s = new String(arr,1,3);//将字符数组中的标记起始位置1后面的3个字符转成字符串
		sop(s);
　<span style="white-space:pre">		</span>String s1 = “rtyutyu”;
		Char[] chs = s1.toCharArray();//将s1对象代表的字符串转换成字符数组。
		for(int x = 0;x<chs.length;x++){
			sop(chs[]);//打印字符数组。
	}

替换：

String replace(oldchar,newchar);//新字符替换老字符

示例：
	public static void demo_3(){
		String str = “hello java”;
		String str1 = str.replace(‘h’,’o’);//若要替换的字符不存在，返回的还是原串。
		String str2 = str.replace(“hello”,”java”);
		sop(str1);
　　sop(str2);
	}

切割：

String split(regex);

示例：
	public static void demo_4(){
		String s = “zhangsan,lisi,wangwu”;
		String[] arr = s.split(“,”);
		for(int x =0;x<arr.length;x++){
			sop(arr[x]);
		}
	}

子串：

获取字符串中的一部分。

String substring(begin);

String substring(begin,end);

示例：
	public static void demo_5(){
		String s = “qwertyui”;
		sop(s.substring(2));//从指定位置开始到结尾，若角标不存在，会出现字符串角标越界异常
　　<span style="white-space:pre">		</span>sop(s.substring(2,4))//;包含头不包含尾。获取整串：s.substring(0,s.length());

转换，去除空格，比较。

1，将字符串转换成大写或者小写。

String toUpperCase();

String toLowerCase();

2，将字符串两端的多个空格去除。

String trim();

3，对两个字符串进行自然顺序的比较。

int compareTo(string);

示例：
	public static void demo_4(){
		String s = “   werty   ”;
		sop(s.toUpperCase());
		sop(s.toLowerCase());
		sop(s.trim());
		String s1 = “wywy”;
		String s2 = “wyffy”;
		sop(s1.compareTo(s2));

练习一

去除字符串两端空格

class StringTest{
	public static void sop(Object obj){
		System.out.println(obj);
	}
	public static void main(String[] args) {
		String str = "   ertyu rtyu    ";
		sop("("+str+")");//打印原字符串
		str = myTrim(str);//调用方法
		sop("("+str+")");//去除空格后的字符串
	}
	public static String myTrim(String str){
		int start = 0,end = str.length()-1;//定义字符串开始和结尾角标
		while (start<end && str.charAt(start)==' ')//判断头角标是否是空格若是start就自增
			start++;//
		while (start<end && str.charAt(end)==' ')//判断尾角标是否是空格若是end就自减
			end--;//
		return str.substring(start,end+1);//返回字符串中的指定子串
	}
}

练习二

将字符串头尾互换

class StringReverse {
	public static void main(String[] args) {
		String s = "  jjjhhhkh  ";
		System.out.println(reverseString(s));//将字符串反转
	}
	public static String reverseString(String s){
		return reverseString(s,0,s.length());
	}
	private static String reverseString(String s,int start,int end){
		char[] chs = s.toCharArray();//将字符串转成字符数组
		reverse(chs,start,end);//反转字符数组
		return new String(chs);//将反转后的字符数组转为字符串并返回
	}
	private static void reverse(char[] chs,int x,int y){
		for (int start=x,end=chs.length-1;start<end ;start++,end-- )
		{
			swap(chs,start,end);//头尾互换
		}
	}
	private static void swap(char[]chs,int x ,int y){
		char temp = chs[x];
		chs[x] = chs[y];
		chs[y] = temp;
	}
}

练习三

获取一个字符串在另一个字符串中出现的次数

class  GetStrCount
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		String s1 = "dfgtyujavatyfjavat";
		String s2 = "java";
		sop(getSubCount_2(s1,s2));
	}
	public static int getSubCount_1(String str,String key)
	{
		int count = 0;//定义计数器
		int index = 0;//定义第一次出现相同字符串的位置
		while ((index = str.indexOf(key))!=-1)//当第一次出现的位置不是-1就往复循环
		{
			//在相同字符串出现的位置基础在加上其key字符串的长度，获取str字符串的子串
			str = str.substring(index+key.length());
			count++;//每获取一次就计数一次
		}
		return count;//返回出现次数
	}
	public static int getSubCount_2(String str,String key)
	{
		int count = 0;//定义计数器
		int index = 0;//定义第一次出现相同字符串的位置
		while ((index = str.indexOf(key,index))!=-1)//从指定位置开始查找，若没有返回-1
		{
			index = index+key.length();
			count++;//每获取一次就计数一次
		}
		return count;//返回出现次数
	}
}

练习四：

获取两个字符串中最大相同的子串

"ertyjavatyuretyj"

"dhgfjavad"

分析：用较短的字符串去比较较长的字符串，每比较一次，短的字符串自减一次长度再比较，直到包含到的最大长度子串。

lass GetZiString 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		String s1 = "ertyjavatyuretyj";
		String s2 = "dhgfjavad";
		String s = getMaxSubString(s1,s2);
		sop("最大相同子串是："+s);
		
	}	
	public static String getMaxSubString(String s1,String s2)
	{
		String max = "";String min = "";
		max = (s1.length()>s2.length())?s1:s2;//获取较长的字符串
		min = (max==s1)?s2:s1;// 获取较短的字符串
		//外循环，较短字符串每循环一次头角标自增一次，缩减比较范围
		for (int x=0;x<min.length() ;x++ )
		{
			//内循环，当短字符最后角标位置不超出字符串长度，
			//那就随着每比较一次就减一次长度，同时头尾角标自增一次再比较
			for (int y=0,z=min.length()-x; z!=min.length()+1;y++,z++ )
			{
				//获取每一次比较后的短字符串的子串
				String temp = min.substring(y,z);
				if (max.contains(temp))//判断子串在s1字符串中是否包含
					return temp;
			}
		}
		return "";
	}
}

打印结果如图：