目录
1.4.1、通过(str1 == str2)来比较,这样比较的是两个引用当中的地址
1.4.2、 boolean equals(Object anObject)方法:比较两个引用所指向的对象里面的内容是否一致
1.4.3、 int compareTo(String s)方法:用来比较两个字符串的大小
1.4.4、int compareToIgnoreCase(String str)方法:与compareTo方式相同,但是忽略大小写,进行比较
1.5.1、char charAt(int index)方法:查找index下标上的字符
1.5.2、int indexOf(int ch)方法:找字符串中c第一次出现的位置,没有返回-1
1.5.3、int indexOf(int ch,int fromIndex)方法:从指定下标(fromIndex)开始查找字符c第一次出现的位置(下标)
1.5.4、 int indexOf(String str)方法:查找字符串中某一串字符串(abcd)出现的位置,返回这个字符串的第一个字母的下标,没有返回-1
1.5.5、int lastIndexOf(int ch):默认从后往前找,找到返回下标,没找到返回-1
1.5.6、int lastIndexOf(int ch, int fromIndex)方法:从指定位置(fromIndex)开始找,从后往前字母(a)第一次出现的位置。
1.6.2、字符串转数字 :Integer.paresInt(str1)
1.6.3、字符串小写转大写:xxx.toUpperCase();
1.6.4、字符串大写转小写:xxx.toLoweCase();
1.6.5、字符串转数组:xxx.toCharArray();
1.7.2、 替换所有指定的内容(xxx.replaceAll)
1.7.3、替换首个所指的内容(xxx.replaceFirst)
1.8.1、String[] split(String regex):将字符串全部拆分
1.8.2、 String[] split(String regex, int limit) :将字符串以指定的格式,拆分为limit组
1.8.3、拆分IP地址:有一些特殊字符作为分割符可能无法正常切分,需要加上转义。
1.9.1、String substring(int beginIndex) :从指定位置开始截取所有字符
1.9.2、String substring(int beginIndex, int endIndex) :截取某个区域内的内容
1.10、String trim():去掉字符串中的最外侧的空格,保留中间空格
2.2、String、StringBuilder、StringBuffer的区别
前言:
在c语言中,使用字符串,一般使用字符数组和字符串指针,它没有一个专门的类。而在Java中设计出专门的类,将数据和操作数据的方法放在一个类当中,这样符合Java的面向对象的思想。
🏆创建一个类对最终目的就是实例化对象,所以在学习一个类的时候一定是从它的构造方法开始学起。
1.1、了解字符串构造方法
String类提供的构造方法有很多,常用的就一下三种:
1️⃣、使用常量串构造
2️⃣、直接newString对象
3️⃣、使用字符数组经行构造
public class Test {
public static void main(String[] args) {
//使用常量串构造
String str1 = "hello";
System.out.println(str1);
//直接newString对象
String str2 = new String("hello");
System.out.println(str2);
}
}
String类是引用类型,所以这两种写法的本质是一样的,区别就是使用常量串简化了直接newString对象。
public class Test {
public static void main(String[] args) {
//字符数组
char[] values = {'a','v','c','d'};
//这里new String对象,是调用构造方法,将字符数组转化成为字符串。
String str3 = new String(values);
System.out.println(str3);
}
}
当然,想了解String类更多的构造方法,可以选中String按住Ctrl+点击鼠标左键,然后再点击左下角的Structure,来查看String类的构造方法。
❗❗❗【注意】
1、String是引用数据类型,内部并不存储字符串本身,String类有两个成员属性,在创建String类的时候,不论调用有参还是无参构造方法,都会给value属性赋值。
🌈两个成员属性:value hash
2、通过调试上述的代码,我们可以看见,字符串结束的时候,并不像C语言一样,使用\0来结束。
上述代码,可以画图理解:
String是一个类,那么就有很多方法,那么现在来了解一下他的方法
1.2、求字符串长度(xxx.length())
public class Test {
public static void main(String[] args) {
String str1 = "hello";
System.out.println(str1.length());
//通过调用String类当中的lenght()方法,就可以求出字符串的长度
}
相比于数组求长度(array.length)
public class Test {
public static void main(String[] args) {
int[] array = {1,2,3,4};
System.out.println(array.length);
}
💥字符串求长度调用的是length()方法,而数组求长度调用的类似于一个属性(array.length),所以在使用的时候要分清是否要加()
1.3、isEmpty()方法
表示判断引用所指向的对象里面的字符串长度是否为0,是,返回true,不是,返回false。
public class Test {
public static void main(String[] args) {
String str2 = "";
System.out.println(str2.length());//0
//下面两个isEmpty表示的空,是字符串长度为空
System.out.println(str2.isEmpty());//true
//null:表示str3指向的引用为空,表示str3不指向任何对象
String str3 = null;
}
❗❗❗注意:
在Java中“”引起来的也是String类型的对象
// 打印"hello"字符串(String对象)的长度 System.out.println("hello".length());
在调用上述两个方法时,一定是一个字符串类型,不一定是一个变量,它也可以是一个常量。
1.4、String对象的比较
字符串的比较有两种情况:
1️⃣相不相同
2️⃣大小
1.4.1、通过(str1 == str2)来比较,这样比较的是两个引用当中的地址
public class Test {
public static void main(String[] args) {
String str1 = "hello";
String str2 = "abcd";
System.out.println(str1 == str2);
//比较的是两个引用当中的地址,结果一定是错的
}
1.4.2、 boolean equals(Object anObject)方法:比较两个引用所指向的对象里面的内容是否一致
public class Test {
public static void main(String[] args) {
String str1 = new String("hello");
String str2 = new String("hello");
System.out.println(str1.equals(str2));
}
✨拓展:equals也可以忽略大小写进行比较内容是否一致
public class Test {
public static void main(String[] args) {
String str1 = new String("HEllo");
String str2 = new String("hello");
//忽略大小写进行比较内容是否一致,返回true或false
System.out.println(str1.equalsIgnoreCase(str2));
}
}
1.4.3、 int compareTo(String s)方法:用来比较两个字符串的大小
compareTo()方法,按字典序进行比较大小
字典序:字符大小的顺序
public class Test {
public static void main(String[] args) {
String str1 = new String("hello");
String str2 = new String("abcd");
//比较两个引用所指向的对象的内容的大小
System.out.println(str1.compareTo(str2));
}
当str1>str2时,返回一个正数
当str1<str2时,返回一个负数
当str1=str2时,返回0
str1:调用这个方法的引用,str2:作为参数传给这个方法的引用
这里可以了解一下这个方法的返回值
所以上述代码,比较结果为7,h比a大7,返回了差值。
✨字符串比较存在这样的情况
public class Test {
public static void main(String[] args) {
String str1 = new String("helloabc");
String str2 = new String("hello");
//比较两个引用所指向的对象的内容的大小
System.out.println(str1.compareTo(str2));
}
1.4.4、int compareToIgnoreCase(String str)方法:与compareTo方式相同,但是忽略大小写,进行比较
public class Test {
public static void main(String[] args) {
String str1 = new String("Hello");
String str2 = new String("hello");
//忽略大小写进行比较
System.out.println(str1.compareToIgnoreCase(str2));
}
1.5、字符串查找
方法 | 功能 |
char charAt(int index) | 返回index位置上字符,如果index为负数或者越界,抛出IndexOutOfBoundsException异常 |
int indexOf(int ch) | 返回ch第一次出现的位置,没有返回-1 |
int indexOf(int ch,int fromIndex) | 从fromIndex位置开始找ch第一次出现的位置,没有返回-1 |
int indexOf(String str) | 返回str第一次出现的位置,没有返回-1 |
int indexOf(String str,int fromIndex) | 从fromIndex位置开始找str第一次出现的位置,没有返回-1 |
int lastIndexOf(int ch) | 从后往前找,返回ch第一次出现的位置,没有返回-1 |
int lastIndexOf(int ch,int fromIndex) | 从fromIndex位置开始找,从后往前找ch第一次出现的位置,没有返回-1 |
int lastIndexOf(String str) | 从后往前找,返回str第一次出现的位置,没有返回-1 |
int lastIndexOf(String str,int fromIndex) | 从fromIndex位置开始找,从后往前找str第一次出现的位置,没有返回-1 |
1.5.1、char charAt(int index)方法:查找index下标上的字符
public class Test {
public static void main(String[] args) {
String str1 = "hello";
for (int i = 0; i < str1.length(); i++){
//将变量i作为charAt()方法的参数,被charAt()方法的index参数接收,每循环一次输出一个字母
System.out.println(str1.charAt(i));
}
}
1.5.2、int indexOf(int ch)方法:找字符串中c第一次出现的位置,没有返回-1
public class Test {
public static void main(String[] args) {
String str1 = "abcabcabcabcde";
//直接返回c字母在数组中的下标
System.out.println(str1.indexOf('c'));
}
1.5.3、int indexOf(int ch,int fromIndex)方法:从指定下标(fromIndex)开始查找字符c第一次出现的位置(下标)
public class Test {
public static void main(String[] args) {
String str1 = "abcabcabcabcde";
//从指定的下标为6的位置开始找c第一次出现的位置(下标)
System.out.println(str1.indexOf('c',6));
}
1.5.4、 int indexOf(String str)方法:查找字符串中某一串字符串(abcd)出现的位置,返回这个字符串的第一个字母的下标,没有返回-1
public class Test {
public static void main(String[] args) {
String str1 = "abcabcabcabcde";
System.out.println(str1.indexOf("abcd"));
}
}
1.5.5、int lastIndexOf(int ch):默认从后往前找,找到返回下标,没找到返回-1
public class Test {
public static void main(String[] args) {
String str1 = "abcabcabcabcde";
//查找的时候,是从后往前找,但是返回下标的时候,是从前往后数
System.out.println(str1.lastIndexOf('a'));
}
}
1.5.6、int lastIndexOf(int ch, int fromIndex)方法:从指定位置(fromIndex)开始找,从后往前字母(a)第一次出现的位置。
public class Test {
public static void main(String[] args) {
String str1 = "abcabcabcabcde";
//查找的时候,是从后往前找,但是返回下标的时候,是从前往后数
System.out.println(str1.lastIndexOf('a',7));
}
1.6、字符串的转换
1.6.1、数字转字符串:xxx.valueOf()
public class Test{
public static void main(String[] args) {
//数字转字符串
String str1 = String.valueOf(123);
System.out.println(str1);
}
}
1.6.2、字符串转数字 :Integer.paresInt(str1)
public class Test{
public static void main(String[] args) {
String str2 = "12345";
//字符串转数字
int data = Integer.parseInt(str2);
System.out.println(data);
}
以上这两种转换只限定于,数字样式的字符串,将字符串和数字之间相互转换,不能字母和数字之间转换,这样编译器会报错。
1.6.3、字符串小写转大写:xxx.toUpperCase();
public class Test{
public static void main(String[] args) {
String str1 = "abcd";
//字符串小写转大写
System.out.println(str1.toUpperCase());
}
1.6.4、字符串大写转小写:xxx.toLoweCase();
public class Test{
public static void main(String[] args) {
String str2 = "ABCD";
//字符串大写转小写
System.out.println(str2.toLowerCase());
}
1.6.5、字符串转数组:xxx.toCharArray();
public class Test{
public static void main(String[] args) {
String str1 = "abcdef";
//字符串转数组,因为toCharArray()方法的返回值是char[]类型,所以用char[]类型的数组接收
char[] array = str1.toCharArray();
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
1.6.6、格式化输出
public class Test{
public static void main(String[] args) {
String s = String.format("%d-%d-%d",2022,12,25);
System.out.println(s);
}
}
1.7、字符串的替换
1.7.1、替换指定的字母:xxx.replace();
public class Test{
public static void main(String[] args) {
String str1 = "aaaaabbbbbddddcccc";
//将字符串中的a字母全都替换成p
String ret1 = str1.replace('a','p');
System.out.println(ret1);
}
}
1.7.2、 替换所有指定的内容(xxx.replaceAll)
public class Test{
public static void main(String[] args) {
String str2 = "abaababababcd";
String ret2 = str2.replaceAll("ab","ooo");
System.out.println(ret2);
}
}
1.7.3、替换首个所指的内容(xxx.replaceFirst)
public class Test{
public static void main(String[] args) {
String str1 = "aaaaabbbbbddddcccc";
String ret3 = str1.replaceFirst("ab","999");
System.out.println(ret3);
}
}
✨ 拓展:上述的replaceAll和replaceFirst方法,也可以将字符串中的某个字符替换成空格,还是某些字符都是可以的。但是replace方法是不能实现的
public class Test{
public static void main(String[] args) {
String str1 = "aaaaabbbbbddddcccc";
String ret3 = str1.replaceFirst("ab"," # ");
System.out.println(ret3);
}
}
🎉🎉总结:由于字符串是不可变对象,所以上述的字符串的替换和字符串的转化,都没有修改当前的字符串,而是产生一个新的字符串,对其进行修改。
1.8、字符串的拆分
字符串的拆分有两种方法:
1.8.1、String[] split(String regex):将字符串全部拆分
public class Test{
public static void main(String[] args) {
String str = "how are you";
//按空格拆分,将拆分后的字符串用字符串数组进行接收
String[] strs = str.split(" ");
for (int i = 0; i < strs.length; i++) {
System.out.println(strs[i]);
}
}
}
1.8.2、 String[] split(String regex, int limit) :将字符串以指定的格式,拆分为limit组
public class Test{
public static void main(String[] args) {
String str = "how are you";
//按照空格拆分,拆分成两组
String[] strs = str.split(" ",2);
for (int i = 0; i < strs.length; i++) {
System.out.println(strs[i]);
}
}
1.8.3、拆分IP地址:有一些特殊字符作为分割符可能无法正常切分,需要加上转义。
【注意事项】
- 字符"|" ,"*","+"都得加上转义字符,前面加上"\\".
- 而如果"\",那么就得写成"\\\\".
- 如果一个字符串中有多个分隔符,可以用"|"作为连字符。
1、
public class Test{
public static void main(String[] args) {
String str = "192.168.1.1";
//按照.拆分,要添加转义字符\,但是这里添加了两个\,原因在于先将\转义,在转义.
String[] strs = str.split("\\.");
for (int i = 0; i < strs.length; i++) {
System.out.println(strs[i]);
}
}
2、
public class Test{
public static void main(String[] args) {
String str = "192\\168\\1\\1";
//在写字符串的时候,不能单独写一个\,因为这样和后面的数组形成了转义必须写\\
//按照\拆分,在写的时候,先要将\转义,再转义\\,所以这里就要写\\\\
String[] strs = str.split("\\\\",2);
for (int i = 0; i < strs.length; i++) {
System.out.println(strs[i]);
}
}
3、
public class Test{
public static void main(String[] args) {
String str = "192&168@1=1";
//字符串被多个分割符隔开,想要将字符串按照这些分割符拆分,那么可以使用连字符将这些分隔符写在一起
String[] strs = str.split("&|@|=");
for (int i = 0; i < strs.length; i++) {
System.out.println(strs[i]);
}
}
}
1.8.4、多次拆分
public class Test{
public static void main(String[] args) {
String str = "name=zhangsan&age=18";
//这个字符串中有两部分,名字和年龄,先将她两拆分
String[] strs = str.split("&");
for (int i = 0; i < strs.length; i++) {
//拆分成两个数组后,再用=拆分
String[] string = strs[i].split("=");
for (String s:string){
System.out.println(s);
}
}
}
}
1.9、字符串的截取
1.9.1、String substring(int beginIndex) :从指定位置开始截取所有字符
public class Test{
public static void main(String[] args) {
String str = "abcdefgh";
//从第二个字母开始截取后面所有字母
String s = str .substring(2);
System.out.println(s);
}
1.9.2、String substring(int beginIndex, int endIndex) :截取某个区域内的内容
public class Test{
public static void main(String[] args) {
String str = "abcdefgh";
//表示包含0下标的字符,不包含6下标的字符
String s = str .substring(0,6);//他是一个前闭后开区间的写法[)
System.out.println(s);
}
}
注意事项:
1、索引从0开始
2、注意前闭后开区间的写法。
3、 字符串的拆分和截取,都不是再原字符串上操作的,都是在新产生的字符串上操作的。
1.10、String trim():去掉字符串中的最外侧的空格,保留中间空格
public class Test{
public static void main(String[] args) {
String str = " hello abcd ";
System.out.println(str);
//去掉最外侧的空格,保留中间的空格
String ret = str.trim();
System.out.println(ret);
}
}
1.11、字符串的不可变性
public class Test{
public static void main(String[] args) {
String str1 = "abcd";
String str2 = new String("abcd");
String str3 = "abcd";
System.out.println(str1 == str2);
System.out.println(str1 == str3);
}
❗❗❗【纠正错误】
上述这副图在这里只是用作理解上述代码中为什么str1==str3,字符串常量池还没有讲解,所以这幅图是错误的,举例来说
1、String str1 = "abc";从下面这副图来看,他创建了一个String对象(value)和一个char数组对象(abc).
2、String str2 = new String(abc);从下面的图来看,它创建了两个String对象(value)和一个char数组对象(abc);
这里涉及到常量池的概念,小编还没学习常量池的内容,所以这里就不讲解了。
字符串为什么有不可变性?
- 给String类的引用赋值字符串后,在内存中字符串是以字符数组的形式保存的。
- String类当中的value[ ] 属性,是被private修饰的,也就是说value[ ] 是被封装的。
- 被封装了之后,因该要设置公开方法get和set方法,来得到value[ ] ,并且可以修改value[ ]所指向的数组中的值。
- 但是在String类当中,并没有给出公开的方法让我们得到value[ ]属性。得不到value[ ]引用,所以他指向的数组中的内容不能被修改,所以字符串具有不可变性 。
总结:
1、String类被final修饰,表明该类不能被继承
2、value被final修饰,表明value不能引用其他对象(指向不可变),即不能引用其他字符数组,但是其引用空间中的内容可以修改。
为什么String要设计成不可变的?(不可变对象的好处是什么?)
- 方便实现字符串池,如果String可变,那么对象池就需要考虑写时拷贝的问题了。
- 不可变对象是线程安全的。
- 不可变对象更方便缓存hash code,作为key时可以更高效的保存到HashMap中
1.12、字符串的修改
注意:尽量避免直接对String类型对象进行修改,因为String类是不能修改的,所有的修改都会创建新对象,效率非常低下。
public class Test {
public static void main(String[] args) {
String str = "hello";
str += "abc";
System.out.println(str);
}
}
通过反汇编来看一下,这种方式在中间创建了很多对象
模拟一下上述反汇编的代码:
public class Test {
public static void main(String[] args) {
String str = "hello";
// 这里4句代码相当于上面代码的str += "abc";
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(str);
stringBuilder.append("abc");
// 这里调用toString方法的作用是,在拼接完成之后,有一个新的String对象
str = stringBuilder.toString();
System.out.println(str);
}
}
那么设想一下,每拼接一次,调用上述的4句代码,那么在代码编写时,写一个循环,那么每循环一次,调用这4句代码,就造成了代码效率非常低下。
总结:
所以在循环当中不建议使用+对字符串进行拼接。因为这样的写法,会产生很多的临时对象,造成代码效率低下。如果要修改建议尽量使用StringBuffer或者StringBulider
2、StringBulider和StringBuffer
2.1、StringBulider的学习
由于String的不可更改特性,为了方便字符串的修改,Java中有提供了StringBulider和StringBuffer类,这两个类大部分功能时相同的
通过上述图片可以看见,StringBuilder类有即有参构造方法,也有无参构造方法。
2.1.1、StringBuilder类的append方法
❓❓那么StringBuilder类对字符串进行拼接,会是什么样的那?
🕖先来看一下append方法的源码:
🕕利用append方法对字符串进行拼接
public class Test {
public static void main(String[] args) {
StringBuilder stringBuilder = new StringBuilder("abc");
System.out.println(stringBuilder);
stringBuilder.append("123").append(10);
stringBuilder.append(19.0);
System.out.println(stringBuilder);//此时不会产生多余的临时对象,
//他永远返回的是当前对象,所有的修改都在当前对象
}
}
2.1.2、Stringbuilder类当中的方法介绍
方法 | 说明 |
StringBuff append(String str) | 在尾部追加,相当于String的+=,可以追加:boolean、char、char[]、 double、float、int、long、Object、String、StringBuff的变量 |
char charAt(int index) | 获取index位置的字符 |
int length() | 获取字符串的长度 |
int capacity() | 获取底层保存字符串空间总的大小 |
void ensureCapacity(int mininmumCapacity) | 扩容 |
void setCharAt(int index, char ch) | 将index位置的字符设置为ch |
int indexOf(String str) | 返回str第一次出现的位置 |
int indexOf(String str, int fromIndex) | 从fromIndex位置开始查找str第一次出现的位置 |
int lastIndexOf(String str) | 返回最后一次出现str的位置 |
int lastIndexOf(String str, int fromIndex) | 从fromIndex位置开始找str最后一次出现的位置 |
StringBuff insert(int offset, String str) | 在offset位置插入:八种基类类型 & String类型 & Object类型数据 |
StringBuffer deleteCharAt(int index) | 删除index位置字符 |
StringBuffer delete(int start, int end) | 删除[start, end)区间内的字符 |
StringBuffer replace(int start, int end, String str) | 将[start, end)位置的字符替换为str |
String substring(int start) | 从start开始一直到末尾的字符以String的方式返回 |
String substring(int start,int end) | 将[start, end)范围内的字符以String的方式返回 |
StringBuffer reverse() | 反转字符串 |
String toString() | 将所有字符按照String的方式返回 |
❗❗❗总结:从上述例子可以看出:String和StringBuilder最大的区别在于String的内容无法修改,而StringBuilder的内容可以修改。频繁修改字符串可以考虑使用StringBuilder。
❗❕❗注意:String和StringBuilder类不能直接转换。如果想要相互转换,可以采用如下原则:
- String变为StringBuilder:利用StringBuilder的构造方法或append()方法。
- StringBuilder变为String:调用toString()方法。
//通过stringBuilder来调用toString方法,达到将StringBuilder类型对象转换为String类型对象 public class Test { public static void main(String[] args) { StringBuilder stringBuilder = new StringBuilder("abc"); String ret = stringBuilder.toString(); } }
//通过stringBuilder调用构造方法或者append()方法,将String类型转换为StringBuilder类型 public class Test { public static void main3(String[] args) { StringBuilder stringBuilder = new StringBuilder("abc"); System.out.println(stringBuilder); stringBuilder.append("123"); System.out.println(stringBuilder); } }
2.2、String、StringBuilder、StringBuffer的区别
- String的内容不可修改,StringBuffer与StringBuilder的内容可以修改。
- StringBuffer与StringBuilder大部分功能是相似的
- StringBuffer采用同步处理,属于线程安全操作;而StringBuilder未采用同步处理,属于线程不安全操作
2.3、来看一道面试题
以下两串代码分别创建了几个String对象【前提:不考虑常量池之前是否存在】
String str = new String("ab"); // 会创建多少个对象
String str = new String("a") + new String("b"); // 会创建多少个对象
1️⃣第一句:创建了2个对象。
- 因为字符串是一个对象,
- 而又new了一个对象,所以有两个对象。
2️⃣第二句:创建了5个对象。
- 因为字符串是一个对象,
- 而又new了两个对象,
- 又因为在进行字符串的拼接,这样会创建一个StringBuilder类型的对象,
- 在拼接完成之后,又会通过StringBuilder类型的对象调用toString方法,这样又创建了一个String对象。
- 又因为问的是创建了几个String对象,所以StringBuilder对象在这里就不算了。
- 为什么StringBuilder调用的toString方法创建的对象在这里可以算一个String对象?toString方法创建的对象是String类型的,所以在这里算。
2.4、习题
1、字符串中的第一个唯一字符
给定一个字符串s,找到他的第一个不重复的字符,并返回他的索引。如果不存在,则返回-1。
要求:字符串s只包含小写字母。
public class Test {
public int firstUniqChar(String s) {
int[] count = new int[26];
//统计每个字符出现的次数
for(int i = 0; i < s.length(); ++i){
char ch = s.charAt(i);
count[ch - 'a']++;
}
//找第一个只出现一次的字符
for(int i = 0; i < s.length(); ++i){
char ch = s.charAt(i);
//通过for循环遍历,并且通过if判断每一个字母在上一轮的fou循环中计数的情况(是否只出现过一次,若第一个字母计数>1,那么就判断下一个字母,直到找到计数为一的字母,并返回该字母)
if(count[ch - 'a'] == 1){//用ch - 'a'用字母的ASCII的减去97,得到字母在数组中的下标。
return i;
}
}
return -1;
}
2、最后一个单词的长度
输出一个正数,表示输入字符串最后一个单词的长度。
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while(in.hasNextLine()){
String str = in.nextLine();
int index = str.lastIndexOf(" ");//最后一个空格开始
String ret = str.substring(index+1);//从最后一个空格+1的位置开始,向后计算字符串的长度
System.out.println(ret.length());
}
}
}
3、检测一个字符串是否为回文字符串
如果在将所有大写字符转换为小写字符,并移除所有非字母数字字符之后短语正着读和反着读都一样。则可认为该短语是一个回文串。
字母和数字都属于数字字符。
要求 :给你一个字符串s,如果他是回文串,返回true;否则,返回false.
public class Test {
public boolean isPalindrome(String s){
s = s.toLowerCase();//将大写字母转换为小写
int left = 0;//从左边开始的下标
int right = s.length()-1;//从右边开始的下标
while(left < right){
while(left < right && !isValidChar(s.charAt(left))){
left++;
}
while(left < right && !isValidChar(s.charAt(right))){//条件是左边下标小于右边下标,并且来两边要是有效字符。
right -- ;
}
//判断如果左边字母不等于右边字母,返回false,两边字母相等,左边向前挪一位,右边向前挪一位。
//每个字母判断完成之后,都相等,返回true。
if(s.charAt(left) !=s.charAt(right)){
return false;
}else{
left++;
right--;
}
}
return true;
}
//判断他是否为有效字符
private boolean isValidChar(char ch){
if(ch >= '0' && ch <= '9'|| ch <= 'a'&& ch <= 'z'){
//上边语句可以优化为
//if(Character.isDigit(ch)||Character.isLetter(ch))
//isDigit()判断是否为数字 isLetter()判断是否为字母
return true;
}
return false;
}
}