String类__ 上

String类是对字符串事物的描述。该类定义了专门用于操作字符串的方法。

String类的特点：一旦初始化就不会被改变。

一个字符串就是一个对象

经典案例解析：

class  Demo
{
	public static void main(String[] args) 
	{
		String s1 = "abc";
		String s2 = new String("abc");
		/*
		==判断s1和s2是否指向同一个对象，或者说，s1和s2所存储的内存地址值是否相等
		s1在内存中有一个对象
		s2在内存中有两个对象，一个在堆内存中，一个在常量池中，s2中存储的是"abc"在堆内存中的地址值
		*/
		System.out.println(s1==s2);
		//复写了Object类中的equals方法，这里的equals方法比较对象中的字符串是否相等
		System.out.println(s1.equals(s2));
	}
}

总结：

上面案例中s1和s2的区别说明

String s1 = "abc";

该语句中创建了一个"abc"对象，该对象存储在常量池中，s1获取的是"abc"在常量池中的地址值；

String s2 = new String("abc");

执行该语句时，将会在堆内存中创建一个"abc"对象（第一个对象）的同时检查常量池中是否存在该字符串，如果没有，将会在常量池中创建一个"abc"对象（第二个对象）。

值得注意的是，类类型变量s2中存储的是堆内存中"abc"对象的内存地址值。

String类中定义了大量的用于操作字符串的方法

这写方法可以分为这几类： 获取，判断，转换，替换，切割，取子串，其他；

对字符串常见的操作
1，获取
1.1 字符串中的包含的字符数，也就是字符串的长度。
int length() :获取长度。

注意：length()方法获取的是字符串中字符的个数，并不是角标
1.2 根据位置获取位置上某个字符。
char charAt(int index):
1.3 根据字符获取该字符在字符串中位置。
int indexOf(int ch):返回的是ch在字符串中第一次出现的位置。
int indexOf(int ch, int fromIndex) :从fromIndex指定位置开始，获取ch在字符串中出现的位置。

传入值为什么是int型？

其实传入的参数还是字符，只不过JVM会将其转换为ASCII，字符对应的ASCII都是int型数据

int indexOf(String str):返回的是str在字符串中第一次出现的位置。
int indexOf(String str, int fromIndex):从fromIndex指定位置开始，获取str在字符串中出现的位置。

int lastIndexOf(int ch) ：返回指定字符在此字符串中最后一次出现处的索引。

代码示例：

/**
获取
1.获取字符串的长度
2.获取某个位置上的字符
3.根据字符串获取该字符串的位置
*/
class GetDemo
{
	public static void main(String[] args) 
	{
		String s = "abcdeabcfghigk";
		sop(get_1(s));
		sop(get_2(s,5));
		sop(get_3(s,'f'));
		sop(get_4(s,'a',4));
		sop(get_5(s,"abc"));
		sop(get_6(s,"abc",4));
		sop(get_7(s,'a'));
	}
	public static int get_1(String s)
	{
		int a = s.length();//获取该字符传中字符的个数
		return a ;
	}
	public static char get_2(String s, int index)
	{
		char ch = s.charAt(index);//获取对应索引的字符
		return ch;<span style="white-space:pre">		//当访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException。</span>
	}
	public static int get_3(String s,char ch)
	{
		int b = s.indexOf(ch);//获取要查找的字符的索引，如果没找到将返回-1
		return b;
	}
	public static int get_4(String s,char ch,int x)
	{
		int c = s.indexOf(ch,x);//获取从指定索引开始查找的字符的索引
		return c;
	}
	public static int get_5(String s,String str)
	{
		int d = s.indexOf(str);//获取该字符串对应的索引
		return d;
	}
	public static int get_6(String s, String str,int y)
	{
		int e = s.indexOf(str,y);//从y指定位置开始，获取str在字符串中出现的位置。
		return e;
	}
	public static int get_7(String s,char ch)
	{
		int f = s.lastIndexOf(ch);//返回指定字符在此字符串中最后一次出现处的索引。
		return f;
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

2，判断
2.1 字符串中是否包含某一个子串。
boolean contains(str):
特殊之处：indexOf(str):可以索引str第一次出现位置，如果返回-1.表示该str不在字符串中存在。
所以，也可以用于对指定判断是否包含。
if(str.indexOf("aa")!=-1)
而且该方法即可以判断，也可以获取字符串出现的位置。
2.2 字符中是否有内容。
boolean isEmpty():原理就是判断长度是否为0. 
2.3 字符串是否是以指定内容开头。
boolean startsWith(str);
2.4 字符串是否是以指定内容结尾。
boolean endsWith(str);
2.5 判断字符串内容是否相同。复写了Object类中的equals方法。
boolean equals(str);
2.6 判断内容是否相同，并忽略大小写。
boolean equalsIgnoreCase();

代码示例：

/**
判断（返回值类型都是boolean型）
1.字符串中是否包含某一个子串。
2.字符中是否有内容。
3.字符串是否是以指定内容开头。
4.字符串是否是以指定内容结尾。
5.判断字符串内容是否相同。复写了Object类中的equals方法。
6.判断内容是否相同，并忽略大小写。（应用：邮箱账号的输入）
*/
class IsDemo 
{
	public static void main(String[] args) 
	{
		String s = "HelloWorld.java";
		String s1 = "helloworld.java";
		sop(s.contains("Hello"));//判断s中是否包含字符串“Hello”
		sop(s.isEmpty());//判断字符串s是否为空
		sop(s.startsWith("Hello"));//判断字符串s是否以“Hello”开头
		sop(s.endsWith(".java"));//判断字符串s是否以“.java”开头
		sop(s.equals(s1));//判断字符串s和s1中的字符是否相同
		sop(s.equalsIgnoreCase(s1));//忽略大小写判断字符串是否相同
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

3，转换。
3.1 将字符数组转成字符串。
构造函数：String(char[])
String(char[],offset,count):将字符数组中的一部分转成字符串。
静态方法：
static String copyValueOf(char[])：
static String copyValueOf(char[] data, int offset, int count) 
static String valueOf(char[])：
3.2 将字符串转成字符数组。
char[] toCharArray():
3.3 将字节数组转成字符串。
String(byte[])
String(byte[],offset,count):将字节数组中的一部分转成字符串。
3.4 将字符串转成字节数组。
byte[]  getBytes():
3.5 将基本数据类型转成字符串。
static String valueOf(int)
static String valueOf(double)
这样也可以：3+"";//String.valueOf(3);
特殊：字符串和字节数组在转换过程中，是可以指定编码表的。

代码示例：

/**
转换
	1. 将字符数组转成字符串。
		
	2. 将字符串转成字符数组。
		
	3. 将字节数组转成字符串。
			
	4. 将字符串转成字节数组。
			
	5. 将基本数据类型转成字符串。
		
		注意：字符串和字节数组在转换过程中，是可以指定编码表的。
*/
class TransDemo 
{
	public static void main(String[] args) 
	{
		char[] arr = {'a','b','c','d','e','f','g'};
		//构造方法将字符数组转成字符串
		String s = new String(arr,2,3);
		String s1 = new String(arr);
		sop(s);
		sop(s1);

		//静态方法将字符数组抓换成字符串
		sop(String.copyValueOf(arr));

		//将指定位置后的几个字符数组的元素转换成字符串
		sop(String.copyValueOf(arr,2,3));

		String s2 = "asdfjkl";
		//将字符串转换成字符数组
		char[] ch = s2.toCharArray();
		for (int a = 0;a<ch.length ;a++ )//打印字符数组中的元素
		{
			sop(ch[a]);
		}
		//将字符串转换成字节数组，输出的结果将是字符对应的ASCII码
		byte[] by = s2.getBytes();
		for (int a = 0;a<ch.length ;a++ )
		{
			sop(by[a]);
		}
		//将基本数据类型的数转换成字符串
		sop(String.valueOf(99));//此结果和99+“”的结果是一致的
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

4，替换
String replace(oldchar,newchar);

代码示例：

/**
替换
将字符串中的某个字符替换成另外的字符
*/
class ReplaceDemo 
{
	public static void main(String[] args) 
	{
		String s = "asdfasjkl";
		System.out.println(s.replace('a','e'));
	}
}

5，切割 ：根据要求将字符串进行切割
String[] split(regex);

代码示例：

/**
切割
根据要求将字符串进行切割
*/
class SplitDemo 
{
	public static void main(String[] args) 
	{
		String s = "abcabcasd";
		String[] str = s.split("a");//如果从首字符开始切割，将会输出一个空的值
		for (int a = 0;a<str.length ;a++ )
		{
			System.out.println(str[a]+",");
		}
	}
}

输出结果：

6，子串。获取字符串中的一部分。
String substring(begin);
String substring(begin,end);//输出的结果，包含begin不包含end

代码示例：

/**
获取子串

*/
class  SubstringDemo
{
	public static void main(String[] args) 
	{
		String s = "asdfghjkl";
		//获取3~5之间的子串，输出fg。注意：输出结果，包含头不包含尾
		System.out.println(s.substring(3,5));
	}
}

7，其他方法，大小写转换，去除空格，比较。
7.1 将字符串转成大写或则小写。
String toUpperCase();
String toLowerCase();

7.2 将字符串两端的多个空格去除。
String trim();//邮箱输入应用

7.3 对两个字符串进行自然顺序的比较。
int compareTo(string);//输出的结果是两个字符串首字符对应ASCII码表的值的差

/**
1.转换大小写
2.去除字符串两端的空格
3.对两个字符串进行自然顺序的比较
*/
class ToDemo 
{
	public static void main(String[] args) 
	{
		String s = "   asdfGHjkl   ";
		String s1 = "abcdef";
		//转换大小写
		sop(s.toUpperCase());
		sop(s.toLowerCase());
		//去除字符串两端的空格，应用：邮箱账号的输入
		sop(s.trim());
		//两个字符串自然顺序的比较，输出的结果是两个字符串首字符对应ASCII码表的值的差
		sop(s.compareTo(s1));
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

练习汇总

练习一

模拟一个trim方法，去除字符串两端的空格。

/**
需求：
模拟一个trim方法，去除字符串两端的空格。
思路：
1，判断字符串第一个位置是否是空格，如果是继续向下判断，直到不是空格为止。
	结尾处判断空格也是如此。
2，当开始和结尾都判断到不是空格时，就是要获取的字符串。
步骤：
使用String类中的获取方法charAt();
从字符串开头来判断是否是空格，是就继续向下一位判断，否则输出不是空格的角标
从最后一位开始判断字符是否是空格，是就继续向前面一位判断，否则输出不是空格的角标
使用获取字符串的方法substring(start,end)来获取这个字符串
*/
class MyTrim 
{
	public static void main(String[] args) 
	{
		String s = "   a   ";
		int start = start(s);
		int end = end(s);
		String str = s.substring(start,end);
		System.out.println(str);
	}
	//从头开始查找空格字符
	public static int start(String s)
	{
		int a = 0;
		for (;a < s.length()-1 ;a++ )
		{
			if (s.charAt(a) != ' ')//比较字符是否等于空格
			{
				break;
			}
		}
		return a;
	}
	//从尾向前查找空格字符
	public static int end(String s)
	{
		int b = s.length()-1;
		for ( ;b >0  ;b-- )
		{
			if (s.charAt(b) != ' ')
			{
				break;
			}
		}
		return b+1;//因为substring（）方法输出的字符串包含头不包含尾的特性，所以在尾部+1，b+1
	}
}

练习二

将一个字符串进行反转。将字符串中指定部分进行反转。

/**
将一个字符串进行反转。将字符串中指定部分进行反转，
思路：
	1，曾经学习过对数组的元素进行反转。
	2，将字符串变成数组，对数组反转。
	3，将反转后的数组变成字符串。
	4，只要将需反转的部分的开始和结束位置作为参数传递即可。
步骤：
1.使用toCharArray()方法将字符串转变成数组
2.使用第三方变量将数组进行翻转，定义翻转的开始位置和结束位置
3.将翻转后的数组变成字符串 copyValueOf()
*/
class ReverseDemo 
{
	public static void main(String[] args) 
	{
		String s = "asdfghjkl";
		System.out.println(reverse(s,2,8));
	}
	public static String reverse(String s,int a ,int b)
	{
		//将字符串转变为字符数组
		char[] ch = s.toCharArray();
		//翻转数组
		swap( ch, a , b);
		//将翻转后的数组转换成字符串并返回
		return new String(ch);//使用String类的构造方法来转换数组
	}
	public static void swap(char[] ch,int a,int b)
	{
		while (a < b)//在满足a<b的情况下才能进行换位
		{
			char temp = ch[a];
			ch[a] = ch[b];
			ch[b] = temp;
			a++;
			b--;
		}
	}
}

练习三

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

方式一

使用indexOf(char key)方法

/**
获取一个字符串在另一个字符串中出现的次数。
	"abkkcdkkefkkskk"
思路：
	1，定义一个计数器。
	2，获取kk第一次出现的位置。
	3，从第一次出现位置后剩余的字符串中继续获取kk出现的位置。
		每获取一次就计数一次。
	4，当获取不到时，计数完成。

*/
class GetCountDemo 
{
	public static void main(String[] args) 
	{
		String s = "abkkcdkkefkkskk";
		System.out.println(getCount(s,"kk"));
	}
	public static int getCount(String s,String key)
	{
		int count = 0;//定义一个计数器
		int index = 0;//该变量用于存储找到的key的角标

		while ((index = s.indexOf(key)) != -1)//如果在字符串中找不到key就结束寻找
		{
			s = s.substring(index + key.length());//每次查找都是在上一次找到key之后的字符转中开始找
			count++;
		}
			return count;
	}
}

方式二
使用方式一的重载方法indexOf(char key,int start)方法

/**
获取一个字符串在另一个字符串中出现的次数。
	"abkkcdkkefkkskk"

思路：
1.从0角标位开始查找key字符串
2.从key角标位之后的字符串中找
3.找到一次，计数器+1

*/
class GetCountDemo 
{
	public static void main(String[] args) 
	{
		String s = "abkkcdkkefkkskk";
		System.out.println(getCount_2(s,"kk"));
	}

	public static int getCount_2(String s,String key)
	{
		int count = 0;
		int index = 0;
		while ((index = s.indexOf(key,index)) != -1)//将找到key字符串的角标赋值给index，然后判断结果是否为-1
		{
			index = index + key.length();//控制每次起始查找的角标
			count++;
		}
		return count;
	}
}

练习四

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

/**
获取两个字符串中最大相同子串。第一个动作：将短的那个串进行长度一次递减的子串打印。
	"abcwerthelloyuiodef"
	"cvhellobnm"
思路：
	1，将短的那个子串按照长度递减的方式获取到。
	2，将每获取到的子串去长串中判断是否包含，
		如果包含，已经找到。
*/
class  GetMaxStringDemo
{
	public static void main(String[] args) 
	{
		String s1 = "abcwerthelloyuiodef";
		String s2 = "cvhellobnm";
		sop(getMaxSubString(s1,s2));
	}
	public static String getMaxSubString(String s1,String s2)
	{

		String max = "",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))//用获取到的子串和最大字符串进行比较
					return temp;
			}
		}
		return "";
	}

	public static void sop(String str)
	{
		System.out.println(str);
	}
}

练习五

对字符串中字符进行自然顺序排序

/**
对字符串中字符进行自然顺序排序。

思路：
1，字符串变成字符数组。
2，对数组排序，选择，冒泡，Arrays.sort();
3，将排序后的数组变成字符串。
*/
class SortDemo 
{
	public static void main(String[] args) 
	{
		String s = "asdfghjkl";
		System.out.println(sort(s));
	}
	public static String sort(String s)
	{
		//将字符串变成字符数组
		char[] ch = s.toCharArray();
		//对数组进行排序
		selectionSort(ch);
		//将排序后的数组转换为字符串
		return String.copyValueOf(ch);
	}
	//选择排序
	public static void selectionSort(char[] ch)
	{
		for (int a = 0;a<ch.length-1 ;a++ )
		{
			for (int b = a +1;b<ch.length ;b++ )
			{
				swap(a,b,ch);
			}
		}
	}
	//翻转位置
	public static void swap(int a,int b,char[] ch )
	{
		if (ch[a]<ch[b])
		{
			char temp =ch[a];
			ch[a] = ch[b];
			ch[b] = temp;
		}
	}
}