Javase.String 类

String 类

  • 【本节目标】
  • 1. String类的重要性
  • 2. 常用方法
    • 2.1 字符串构造
    • 2.2 String对象的比较
    • 2.3 字符串查找
    • 2.4 转化
    • 2.5 字符串替换
    • 2.7 字符串截取
    • 2.8 其他操作方法
    • 2.9 字符串的不可变性
    • 2.10 字符串修改
  • 3. StringBuilder和StringBuffer
    • 3.2 面试题：
  • 4. String类oj
    • 4.1第一个只出现一次的字符
    • 4.2最后一个单词的长度
    • 4.3检测字符串是否为回文

【本节目标】

  1. 认识String类
  2. 了解String类的基本用法
  3. 熟练掌握String类的常见操作
  4. 认识StringBuffer和StringBuilder

1. String类的重要性

在C语言中已经涉及到字符串了，但是在C语言中要表示字符串只能使用字符数组或者字符指针，可以使用标准库提供的字符串系列函数完成大部分操作，但是这种将数据和操作数据方法分离开的方式不符合面相对象的思想，而字符串应用又非常广泛，因此Java语言专门提供了String类。

2. 常用方法

2.1 字符串构造

String类提供的构造方式非常多，常用的就以下三种：

public static void main(String[] args) {//使用常量串构造String s1 = "hello world";System.out.println(s1);//直接new String 对象String s2 = new String("hello world");System.out.println(s2);//使用字符数组进行构造char[] array = {'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'};String s3 = new String(array);System.out.println(s3);
}

其他方法需要用到时，大家参考Java在线文档：String文档

【注意】

  1. String是引用类型，内部并不存储字符串本身，在String类的实现源码中，String类实例变量如下：
    在这里插入图片描述
public static void main(String[] args) {//s1和s2引用的不是同一对象String s1 = new String("hello");String s2 = new String("world");//s1和s3引用的是同一对象String s3 = s1;System.out.println(s1.length());//获取字符串长度 -> 输出5System.out.println(s1.isEmpty());//如果字符串长度为0，返回true，否则返回false
}

在这里插入图片描述

  1. 在Java中“”引起来的也是String类型对象。
public static void main(String[] args) {//打印"hello"字符串(String对象)的长度System.out.println("hello".length());
}

2.2 String对象的比较

字符串的比较是常见操作之一，比如：字符串排序。Java中总共提供了4中方式：

  1. ==比较是否引用同一个对象
    注意：对于内置类型，比较的是变量中的值；对于引用类型比较的是引用中的地址。
public class Test {public static void main(String[] args) {int a = 10;int b = 20;int c = 10;//对于基本数据类型，==比较的是两个变量中存储的值是否相同System.out.println(a == b);//falseSystem.out.println(a == c);//true//对于引用类型变量，==比较两个引用变量引用的时候为同一对象String s1 = new String("hello");String s2 = new String("hello");String s3 = new String("world");String s4 = s1;System.out.println(s1 == s2);//falseSystem.out.println(s2 == s3);//falseSystem.out.println(s1 == s4);//true}
}
  1. boolean equals(Object anObject) 方法：按照字典序比较

字典序：字符大小的顺序

String类重写了父类Object中equals方法，Object中equals默认按照==比较，String重写equals方法后，按照如下规则进行比较，比如： s1.equals(s2)

//库方法
public boolean equals(Object anObject) {if (this == anObject) {return true;}if (anObject instanceof String) {String anotherString = (String)anObject;int n = value.length;if (n == anotherString.value.length) {char v1[] = value;char v2[] = anotherString.value;int i = 0;while (n-- != 0) {if (v1[i] != v2[i])return false;i++;}return true;}}return false;
}

//Test.java
public static void main(String[] args) {String s1 = new String("hello");String s2 = new String("hello");String s3 = new String("Hello");//s1、s2、s3引用的是三个不同的对象，因此==比较的结果全部是falseSystem.out.println(s1 == s2);//falseSystem.out.println(s1 == s3);//false/*** equals比较：String对象中逐个字符* 虽然s1和s2引用的不是同一个对象，但是两个对象中放置的内容相同，因此输出的是true* s1和s3引用的不是同一个对象，而且两个对象中的内容也不同，因此输出false*/System.out.println(s1.equals(s2));//trueSystem.out.println(s1.equals(s3));//false
}
  1. int compareTo(String s) 方法: 按照字典序进行比较

与equals不同的是，equals返回的是boolean类型，而compareTo返回的是int类型，具体比较方式：

  • 先按照字典序大小比较，如果出现不等的字符，直接返回两个字符大小的差值
  • 如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值
public class Test {public static void main(String[] args) {String s1 = new String("abc");String s2 = new String("ac");String s3 = new String("abc");String s4 = new String("abcs");System.out.println(s1.compareTo(s2));//不同输出字符值为-1System.out.println(s1.compareTo(s3));//相同输出0System.out.println(s1.compareTo(s4));//前k个字符完全相同，输出长度差值-1}
}
  1. int compareToIgnoreCase(String str) 方法：与compareTo方式相同，但是忽略大小写比较
public class Test {public static void main(String[] args) {String s1 = new String("abc");String s2 = new String("ac");String s3 = new String("ABc");//忽略大小写 -> abcString s4 = new String("abcs");System.out.println(s1.compareToIgnoreCase(s2));//不同输出字符差值为-1System.out.println(s1.compareToIgnoreCase(s3));//相同输出0System.out.println(s1.compareToIgnoreCase(s4));//前k个字符完全相同，输出长度差值-1}
}

2.3 字符串查找

字符串查找也是字符串中非常常见的操作，String类提供的常用查找的方法：

方法功能
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, intfromIndex)从fromIndex位置开始找，从后往前找str第一次出现的位置，没有返回-1
public class Test {public static void main(String[] args) {String s = "ababcabcd";//char charAt(int index):System.out.println(s.charAt(3));//b//int indexOf(int ch):System.out.println(s.indexOf('c'));//4//int indexOf(int ch, int fromIndex):System.out.println(s.indexOf('c', 3));//4//int indexOf(String str):System.out.println(s.indexOf("abc"));//2//int indexOf(String str, int fromIndex):System.out.println(s.indexOf("abc", 3));//5//int lastIndexOf(int ch):System.out.println(s.lastIndexOf('c'));//7//int lastIndexOf(int ch, int fromIndex):System.out.println(s.lastIndexOf('c', 3));//-1//int lastIndexOf(String str):System.out.println(s.lastIndexOf("abc"));//5//int lastIndexOf(String str, int fromIndex):System.out.println(s.lastIndexOf("abc", 3));//2}
}

注意：上述方法都是实例方法。

2.4 转化

  1. 数值和字符串转化
//Test.java
class Student {public String name;public int age;public Student(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}
}

//Test.java
public class Test {public static void main(String[] args) {//1.数字转字符串String s1 = String.valueOf(1234);String s2 = String.valueOf(12.34);String s3 = String.valueOf(true);String s4 = String.valueOf(new Student("张三", 19));System.out.println(s1);System.out.println(s2);System.out.println(s3);System.out.println(s4);System.out.println("===========================");//2. 字符串转数字//注意：Integer、Double等是Java中的包装类，后面会详细介绍int data1 = Integer.parseInt("1234");double data2 = Double.parseDouble("12.34");System.out.println(data1);System.out.println(data2);System.out.println(data1 + data2);}
}
  1. 大小写转换
public class Test {public static void main(String[] args) {String s1 = "hello";String s2 = "HELLO";//1. 小写转大写System.out.println(s1.toUpperCase());//2. 大写转小写System.out.println(s2.toLowerCase());}
}/*
执行结果：
HELLO
hello*/
  1. 字符串转数组
public class Test {public static void main(String[] args) {String s = "hello";//1. 字符串转数组char[] ch = s.toCharArray();//{'h', 'e', 'l', 'l', 'o'};for (int i = 0; i < ch.length; i++) {System.out.print(ch[i] + " ");}System.out.println();//2. 数组转字符串String s2 = new String(ch);System.out.println(s2);}
}/*
执行结果：
h e l l o
hello*/
  1. 格式化
public class Test {public static void main(String[] args) {String s = String.format("%d-%d-%d", 2024, 6, 20);System.out.println(s);}
}/*
执行结果：
2024-6-20*/

2.5 字符串替换

使用一个指定的新的字符串替换掉已有的字符串数据，可用的方法如下：

方法功能
String replaceAll(String regex, String replacement)替换所有的指定内容
String replaceFirst(String regex, String replacement)替换收个内容
  • 代码示例: 字符串的替换处理
//Test.java
public static void main(String[] args) {String str = "hello world hello mom";String[] ret = str.split(" ");//按照空格拆分for(String s : ret) {System.out.println(s);}
}/*
1.执行结果：
hello
world
hello
mom
*/
  • 代码示例: 字符串的部分拆分
public static void main(String[] args) {String str = "hello world hello mom";String[] ret = str.split(" ", 2);for(String s : ret) {System.out.println(s);}
}/*2.执行结果：
hello
world hello mom
*/

拆分是特别常用的操作. 一定要重点掌握. 另外有些特殊字符作为分割符可能无法正确切分, 需要加上转义

  • 代码示例: 拆分IP地址
public static void main(String[] args) {String str = "192.168.1.1" ;String[] ret = str.split("\\.") ;for(String s : ret) {System.out.println(s);}
}/*
3.执行结果：
192
168
1
1
*/

注意事项：
1. 字符"|"、"*"、"+"、"."都得加上转义字符，前面加上"\\"。
2. 而如果是"\"，那么就得写成"\\\\"。
3. 如果一个字符串中有多个分隔符，可以用"|"作为连字符。
  • 代码示例: 多次拆分
public static void main(String[] args) {String str = "name=zhangsan&age=18" ;String[] ret = str.split("&") ;for (int i = 0; i < ret.length; i++) {String[] temp = ret[i].split("=") ;System.out.println(temp[0]+" = "+temp[1]);}
}/*
4.执行结果：
name = zhangsan
age = 18
*/

这种代码在以后的开发之中会经常出现

2.7 字符串截取

从一个完整的字符串之中截取出部分内容。可用方法如下：

方法功能
String substring(int beginIndex)从指定索引截取到结尾
String substring(int beginIndex, int endIndex)截取部分内容

代码示例: 观察字符串截取

public class Test {public static void main(String[] args) {String str = "helloworld";System.out.println(str);//String substring(int beginIndex):System.out.println(str.substring(3));//String substring(int beginIndex, int endIndex):System.out.println(str.substring(0, 5));//[0,5)}
}/*
执行结果：
helloworld
loworld
hello*/

注意事项：

  1. 索引从0开始
  2. 注意前闭 后开区间的写法，substring(0, 5) 表示包含 0 号下标的字符, 不包含 5 号下标

2.8 其他操作方法

方法功能
String trim()去掉字符串中的左右空格,保留中间空格
String toUpperCase()字符串转大写
String toLowerCase()字符串转小写
  • 代码示例: 观察trim()方法的使用
public static void main(String[] args) {String str = " hello world  ";System.out.println("[" + str + "]");System.out.println("[" + str.trim() + "]");
}/*
1.执行结果：
[ hello world  ]
[hello world]*/

trim 会去掉字符串开头和结尾的空白字符(空格, 换行, 制表符等)。

  • 代码示例: 大小写转换
public static void main(String[] args) {String str = " hello%$$%@#$%WORLD 哈哈哈 " ;System.out.println(str.toUpperCase());System.out.println(str.toLowerCase());
}/*
2.执行结果：HELLO%$$%@#$%WORLD 哈哈哈hello%$$%@#$%world 哈哈哈*/

这两个函数只转换字母。

2.9 字符串的不可变性

String是一种不可变对象. 字符串中的内容是不可改变。字符串不可被修改，是因为：

  1. String类在设计时就是不可改变的，String类实现描述中已经说明了
    以下来自JDK1.8中String类的部分实现：
    在这里插入图片描述
    在这里插入图片描述
    String类中的字符实际保存在内部维护的value字符数组中，该图还可以看出：

    • String类被final修饰，表明该类不能被继承
    • value被修饰被final修饰，表明value自身的值不能改变，即不能引用其它字符数组，但是其引用空间中的内容可以修改。

  2. 所有涉及到可能修改字符串内容的操作都是创建一个新对象，改变的是新对象
    比如 replace 方法：

在这里插入图片描述
【纠正】 网上有些人说：字符串不可变是因为其内部保存字符的数组被final修饰了，因此不能改变。

这种说法是错误的，不是因为String类自身，或者其内部value被final修饰而不能被修改。

final修饰类表明该类不想被继承，final修饰引用类型表明该引用变量不能引用其他对象，但是其引用对象中的内容是可以修改的。

public class Test {public static void main1(String[] args) {String str = "abc";System.out.println(str.replace("a", "qq"));}public static void main(String[] args) {final int[] array = {1, 2, 3, 4, 5};array[0] = 100;System.out.println(Arrays.toString(array));//编译报错：java: 无法为最终变量array分配值//array = new int[]{6, 7, 8};}
}

为什么 String 要设计成不可变的?(不可变对象的好处是什么?)

  1. 方便实现字符串对象池. 如果 String 可变, 那么对象池就需要考虑写时拷贝的问题了
  2. 不可变对象是线程安全的
  3. 不可变对象更方便缓存 hash code, 作为 key 时可以更高效的保存到 HashMap 中

2.10 字符串修改

注意：尽量避免直接对String类型对象进行修改，因为String类是不能修改的，所有的修改都会创建新对象，效率非常低下。

public static void main1(String[] args) {String s = "hello";s += " world";System.out.println(s);//hello world
}

但是这种方式不推荐使用，因为其效率非常低，中间创建了好多临时对象。

在这里插入图片描述

public class Test {public static void main(String[] args) {long start = System.currentTimeMillis();//毫秒String s = "";for(int i = 0; i < 10000; ++i){s += i;}long end = System.currentTimeMillis();System.out.println(end - start);//248start = System.currentTimeMillis();StringBuffer sbf = new StringBuffer("");for(int i = 0; i < 10000; ++i){sbf.append(i);}end = System.currentTimeMillis();System.out.println(end - start);//1start = System.currentTimeMillis();StringBuilder sbd = new StringBuilder();for(int i = 0; i < 10000; ++i){sbd.append(i);}end = System.currentTimeMillis();System.out.println(end - start);//0}
}/*
执行结果：
248
1
0
*/

可以看待在对String类进行修改时，效率是非常慢的，因此：尽量避免对String的直接需要，如果要修改建议尽量使用StringBuffer或者StringBuilder。

借助StringBuffer 和 StringBuilder

3. StringBuilder和StringBuffer

由于String的不可更改特性，为了方便字符串的修改，Java中又提供StringBuilder和StringBuffer类。这两个类大部分功能是相同的，这里介绍 StringBuilder常用的一些方法，其它需要用到了大家可参阅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的方式返回
public static void main(String[] args) {StringBuilder sb1 = new StringBuilder("hello");StringBuilder sb2 = sb1;//追加：即尾插 ->字符、字符串、整型数字sb1.append(' ');//hellosb1.append("world");//hello worldsb1.append(123);//hello world123System.out.println(sb1);//hello world123System.out.println(sb1 == sb2);//trueSystem.out.println("===========================");System.out.println(sb1.charAt(0));//获取0号位上的字符 hSystem.out.println(sb1.length());//获取字符串的有效长度14System.out.println(sb1.capacity());//获取底层数组的总大小System.out.println("===========================");sb1.setCharAt(0, 'H');//设置任意位置的字符 Hello world123sb1.insert(0, "Hello world!!!");//Hello world!!!Hello world123System.out.println(sb1);System.out.println(sb1.indexOf("Hello"));//获取Hello第一次出现的位置System.out.println(sb1.lastIndexOf("hello"));//获取hello最后一次出现的位置System.out.println("===========================");sb1.deleteCharAt(0);//删除首字符sb1.delete(0,5);//删除[0, 5)范围内的字符String str = sb1.substring(0, 5);//截取[0, 5)区间中的字符以String的方式返回System.out.println(str);System.out.println("===========================");sb1.reverse();//字符串逆转str = sb1.toString();//将StringBuffer以String的方式返回System.out.println(str);
}

从上述例子可以看出：String和StringBuilder最大的区别在于String的内容无法修改，而StringBuilder的内容可以修改。频繁修改字符串的情况考虑使用StringBuilder

注意：String和StringBuilder不能直接转换。如果想要互相转换，可以采用如下原则：

  • String变成StringBuilder：利用StringBuilder的构造方法或者append()方法
public static void main(String[] args) {String str = "hello";StringBuilder sb = new StringBuilder(str);//使用构造方法//或者StringBuilder sb2 = new StringBuilder();System.out.println(sb2.append(str));//使用append方法
}
  • StringBuilder变成String：调用toString()方法。
public static void main(String[] args) {StringBuilder sb = new StringBuilder("hello");String str = sb.toString();System.out.println(str);
}

3.2 面试题：

  1. String、StringBuffer、StringBuilder的区别
  • String的内容不可修改，StringBuffer和StringBuilder的内容可以修改
  • StringBuffer和StringBuilder的大部分功能是相似的
  • StringBuffer采用同步处理，属于线程安全操作，而StringBuilder未采用同步处理，属于线程不安全操作
  1. 以下总共创建了多少个String对象 【前提不考虑常量池之前是否存在】
public class Test {public static void main(String[] args) {String str = new String("ab");//会创建多少个对象String str1 = new String("a") + new String("b");//会创建多少个对象}
}

在Java中，使用new关键字创建一个对象时，就会在堆内存中分配一个新的对象实例。现在，来分析一下代码，看看分别创建了多少个对象。

对于第一行代码：

String str = new String("ab");

这里会创建两个对象：

  • 一个是在字符串常量池中创建的字符串字面量"ab"（如果池中尚未存在该字面量）。但请注意，如果之前已经有相同的字符串字面量存在于常量池中，则不会创建新的字面量对象。

  • 另一个是通过 new String(“ab”) 在堆上创建的一个新的String对象，该对象的内容与字符串常量池中的"ab"相同，但是是堆上的一个独立副本。

所以，这行代码至少会创建一个堆上的String对象，可能还会在字符串常量池中创建一个对象（如果之前不存在的话）。

对于第二行代码：

String str1 = new String("a") + new String("b");

这里发生的事情稍微复杂一些：

  • 首先，字符串字面量"a"和"b"会被放入字符串常量池（如果它们之前不存在的话）。

  • 然后，通过 new String(“a”)和new String(“b”) 在堆上分别创建两个新的String对象。

当执行字符串连接操作时（使用+运算符），Java会创建一个新的StringBuilder对象（在某些情况下可能是StringBuffer，但在大多数情况下是StringBuilder），并使用其append方法来连接两个字符串。然后，通过调用StringBuilder的toString方法来创建一个表示连接结果的新String对象。

  • 因此，这行代码至少会创建以下对象：

两个在堆上的String对象（通过new String(“a”)和new String(“b”)创建）。

  1. 一个StringBuilder对象（或类似的可变字符序列对象）。
  2. 一个表示连接结果的String对象（通过StringBuilder的toString方法创建）。
  • 另外，如果字符串常量池中之前没有"a"和"b"这两个字面量，那么还会在池中创建这两个对象。

综上所述，str的初始化至少会创建一个对象（堆上的String），可能还会在字符串常量池中创建一个；而str1的初始化则会创建至少四个对象（两个堆上的String，一个StringBuilder，以及一个表示连接结果的String），同样，如果字符串常量池中之前没有相关字面量，还会在池中创建。不过，请注意，JVM的具体实现和版本可能会影响这些细节。

4. String类oj

4.1第一个只出现一次的字符

第一个只出现一次的字符

描述：

	给定一个字符串 s ，找到 它的第一个不重复的字符，并返回它的索引 。如果不存在，则返回 -1 示例 1：输入: s = "leetcode"输出: 0示例 2:输入: s = "loveleetcode"输出: 2示例 3:输入: s = "aabb"输出: -1

代码展示：

class Solution {public static int firstUniqChar(String s) {int[] count = new int[26];//这个数组拿来计数：字符出现的次数for(int i = 0; i < s.length(); i++) {//从字符串中拿出字符：char ch = s.charAt(i);//length//放在计数的数组中count[ch - 'a'] ++;}//计数完重新遍历一遍字符串，找到它的第一个不重复的字符for(int i = 0; i < s.length(); i++) {char ch = s.charAt(i);if(count[ch - 'a'] == 1) {return i;}}return -1;}
}public class Test {public static void main(String[] args) {int ret = Solution.firstUniqChar("loveleetcode");System.out.println(ret);}
}

解析：

  • 初始化计数数组：首先，代码创建了一个大小为26的整数数组count，用于记录字符串中每个小写字母出现的次数。因为英文字母有26个，所以数组大小是26。
  • 统计字符出现次数：接着，代码遍历输入字符串s，对每个字符进行计数。字符的计数位置是通过将字符转换为0-25之间的索引来确定的（通过ch - ‘a’）。例如，字符’a’对应索引0，字符’b’对应索引1，以此类推。
  • 寻找第一个只出现一次的字符：完成计数后，代码再次遍历字符串s。这次遍历的目的是找到第一个在count数组中计数为1的字符，即只出现一次的字符。一旦找到这样的字符，就返回它在字符串中的位置（索引）。
  • 没有只出现一次的字符：如果字符串中没有只出现一次的字符，函数将返回-1。

简而言之，这段代码通过两次遍历字符串：第一次统计字符出现次数，第二次找到第一个只出现一次的字符。

图文：
在这里插入图片描述

4.2最后一个单词的长度

最后一个单词的长度
描述：

计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。（注：字符串末尾不以空格为结尾）
输入描述：
输入一行，代表要计算的字符串，非空，长度小于5000。输出描述：
输出一个整数，表示输入字符串最后一个单词的长度。

示例：

输入：hello nowcoder
输出：8
说明：最后一个单词为nowcoder，长度为8

代码展示：

  • 方法1：
import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {//方法1：使用split方法 -> 切割字符串public static void main1(String[] args) {Scanner scanner = new Scanner(System.in);String s = scanner.nextLine();//使用split切割字符串，装在新的数组中String[] ss = s.split(" ");//取出最后一个索引的内容int len = ss[ss.length - 1].length();System.out.println(len);}
}

解析：

  • 创建Scanner对象：首先，代码创建了一个Scanner对象来读取用户的输入。
    读取一行文本：使用scanner.nextLine()方法读取用户输入的一行文本，并将其存储在字符串s中。
  • 分割字符串：使用s.split(" ")方法将字符串s按照空格分割成多个子字符串，并将这些子字符串存储在一个字符串数组ss中。
  • 获取最后一个单词的长度：通过ss[ss.length - 1]获取数组ss中的最后一个元素（即最后一个单词），然后使用.length()方法计算这个单词的长度，并将长度存储在变量len中。
  • 打印长度：最后，代码使用System.out.println(len)打印出最后一个单词的长度。

简而言之，这段代码就是读取一行文本，找出其中的最后一个单词，并输出这个单词的长度。

  • 方法2：
import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Test {//方法2：使用lastIndexOf() 和 substring()public static void main(String[] args) {//lastIndexOf() : 从字符串的后面开始找： " ",找到就返回索引，否则就返回-1//substring(int beginIndex) : 从beginIndex开始发生截断Scanner scanner = new Scanner(System.in);String s = scanner.nextLine();//找最后一个空格后面的字符串int index = s.lastIndexOf(" ");//从index索引开始发生截断 -> 得到index+1后面的字符串int len = s.substring(index + 1).length();System.out.println(len);}
}

解析：

  • 读取输入：首先，通过Scanner对象读取用户输入的一行文本。
  • 查找最后一个空格：使用lastIndexOf(" ")方法从输入的文本中查找最后一个空格的位置，并返回其索引。如果没有找到空格，该方法会返回-1，但在这个上下文中，我们假设输入中至少有一个空格。
  • 截取字符串：使用substring(index + 1)方法从最后一个空格之后开始截取字符串。index + 1确保了我们从空格之后的第一个字符开始截取。
  • 计算长度并输出：计算截取后的字符串的长度，并使用System.out.println输出这个长度。

简而言之，这段代码读取一行文本，找到最后一个空格后的字符串部分，并输出其长度。

4.3检测字符串是否为回文

检测字符串是否为回文
描述：

如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，短语正着读和反着读都一样。则可以认为该短语是一个 回文串 。字母和数字都属于字母数字字符。给你一个字符串 s，如果它是 回文串 ，返回 true ；否则，返回 false 。

示例：

示例 1：
输入: s = "A man, a plan, a canal: Panama"
输出：true
解释："amanaplanacanalpanama" 是回文串。示例 2：
输入：s = "race a car"
输出：false
解释："raceacar" 不是回文串。示例 3：
输入：s = " "
输出：true
解释：在移除非字母数字字符之后，s 是一个空字符串 "" 。
由于空字符串正着反着读都一样，所以是回文串。

代码展示：

class Solution {public boolean isPalindrome(String s) {//所有大写字符转换为小写字符:s = s.toLowerCase();//开始判断：定义两个索引：一个从左边开始， 一个从右边开始，进行对比int left = 0;int right = s.length() - 1;//开始对比：while(left < right) {//遇到非字母和非数字就跳过，不进行比较while(left < right && !isNumberAndCharacter(s.charAt(left))) {left++;}while(left < right && !isNumberAndCharacter(s.charAt(right))) {right--;}//走到这，证明字符都是字母，可以进行对比if(s.charAt(left) == s.charAt(right)) {left++;right--;//对比完，就往下走}else {//不相同，说明不是回文串return false;}}//走到这，证明是回文串return true;}//字母和数字都属于字母数字字符。 -> 假如是非字母和非数字就跳过，不进行比较private boolean isNumberAndCharacter(char ch) {//用isDigit() : 判断字符是否为数字//用isLetter() : 判断字符是否为字母if(Character.isDigit(ch) || Character.isLetter(ch)) {return true;}else {return false;}}
}
public class Test {public static void main(String[] args) {Solution solution = new Solution();System.out.println(solution.isPalindrome("A man, a plan, a canal: Panama"));}
}

解析：
代码定义了一个Solution类，其中包含两个方法：isPalindrome和isNumberAndCharacter。这个类的主要功能是检查一个字符串是否是一个“回文串”，即正读和反读都相同的字符串。

  1. isPalindrome方法：

    • 首先，该方法将输入字符串s转化为小写，以确保大小写不影响回文的判断。

    • 定义了两个指针，left从字符串的开始位置出发，right从字符串的末尾位置出发。

    • 使用一个while循环，当left小于right时执行循环体内的代码。
      在循环体内，代码会跳过left指针位置上的非字母和非数字字符，直到找到第一个字母或数字字符。

      • 同样，代码也会跳过right指针位置上的非字母和非数字字符，直到找到第一个字母或数字字符。
      • 接着，比较left和right指针位置上的字符是否相同。如果相同，则将两个指针向中间移动；如果不同，则直接返回false，表示该字符串不是回文串。

    • 如果left指针超过了right指针，说明已经检查完整个字符串，且字符串是回文的，所以返回true。

  2. isNumberAndCharacter方法：

    • 这个辅助方法用于检查一个字符是否是字母或数字。
    • 使用Character.isDigit(ch)检查字符ch是否为数字。
    • 使用Character.isLetter(ch)检查字符ch是否为字母。
    • 如果字符是数字或字母，则返回true；否则返回false。

简而言之，这段代码通过双指针的方法，从字符串的两端向中间遍历，同时跳过非字母和非数字的字符，来判断一个字符串是否是回文串。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/355223.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【MySQL】 -- 用户管理

【MySQL】 -- 用户管理

1. 权限 如果我们只能使用root用户&#xff0c;这样存在安全隐患。这时&#xff0c;就需要使用MySQL的用户管理。创建出非root用户&#xff0c;限制其权限。 权限这个概念拿出来就是用来限制非root用户的。这样从技术手段上保证了数据的安全性和完整性&#xff0c;防止有人删库…
阅读更多...
【SAP Abap】一条SQL语句实现支持报表项配置的财务报表

【SAP Abap】一条SQL语句实现支持报表项配置的财务报表

【SAP Abap】一条SQL语句实现支持报表项配置的财务报表 1、业务背景2、配置项特殊处理3、实现方式&#xff08;Hana Studio SQL语句&#xff09;4、实现方式&#xff08;Abap OpenSQL语句&#xff09;5、总结 1、业务背景 在财务三大报表之外&#xff0c;业务需要使用类似的科…
阅读更多...
数据库复习——模式分解

数据库复习——模式分解

模式分解这边主要包括无损分解和保持函数依赖的分解两种形式&#xff0c;简单整理一下。 无损分解 把一个 R R R 分成 ρ { R 1 , R 2 , ⋯ , R k } \rho \{R_1,R_2,\cdots,R_k\} ρ{R1​,R2​,⋯,Rk​}&#xff0c;然后通过自然连接 R 1 ⋈ R 2 ⋈ ⋯ ⋈ R k R_1\bowtie R…
阅读更多...
git的远程管理与标签管理

git的远程管理与标签管理

✨前言✨ &#x1f4d8; 博客主页&#xff1a;to Keep博客主页 &#x1f646;欢迎关注&#xff0c;&#x1f44d;点赞&#xff0c;&#x1f4dd;留言评论 ⏳首发时间&#xff1a;2024年6月20日 &#x1f4e8; 博主码云地址&#xff1a;博主码云地址 &#x1f4d5;参考书籍&…
阅读更多...
swift使用swift-protobuf协议通讯，使用指北

swift使用swift-protobuf协议通讯，使用指北

什么是Protobuf Protobuf&#xff08;Protocol Buffers&#xff09;协议&#x1f609; Protobuf 是一种由 Google 开发的二进制序列化格式和相关的技术&#xff0c;它用于高效地序列化和反序列化结构化数据&#xff0c;通常用于网络通信、数据存储等场景。 为什么要使用Proto…
阅读更多...
【python】Sklearn—Cluster

【python】Sklearn—Cluster

参考学习来自 10种聚类算法的完整python操作示例 文章目录 聚类数据集亲和力传播——AffinityPropagation聚合聚类——AgglomerationClusteringBIRCH——Birch&#xff08;✔&#xff09;DBSCAN——DBSCANK均值——KMeansMini-Batch K-均值——MiniBatchKMeans均值漂移聚类——…
阅读更多...
MySQL之复制(七)

MySQL之复制(七)

复制 定制的复制方案 分离功能 许多应用都混合了在线事务处理(OLTP)和在线数据分析(OLAP)的查询。OLTP查询比较短并且是事务型的。OLAP查询则通常很大&#xff0c;也很慢&#xff0c;并且不要求绝对最新的数据。这两种查询给服务器带来的负担完全不同&#xff0c;因此它们需…
阅读更多...
Linux系统部署Samba服务，共享文件夹给Windows

Linux系统部署Samba服务，共享文件夹给Windows

Samba服务是在Linux和UNIX系统上实现SMB协议的一个免费软件&#xff0c;由服务器及客户端程序构成。 Samba服务是连接Linux与Windows的桥梁&#xff0c;它通过实现SMB&#xff08;Server Message Block&#xff09;协议来允许跨平台的文件和打印机共享。该服务不仅支持Linux和…
阅读更多...
用React编写一个密码组件表单

用React编写一个密码组件表单

theme: condensed-night-purple highlight: atelier-cave-light 背景介绍 我们在使用网站或者应用程序的登录界面或创建帐户界面时&#xff0c;往往避免不了需要用户输入密码这一步骤&#xff0c;而用户是否可以选择看见他们输入的密码是十分重要的一项功能。尤其是在当输入的…
阅读更多...
20240620每日后端---------Spring Boot中的 5 大设计模式最佳实践和示例 这些是我经常使用的设计模式并且非常喜欢

20240620每日后端---------Spring Boot中的 5 大设计模式最佳实践和示例 这些是我经常使用的设计模式并且非常喜欢

在本文中&#xff0c;我们将深入探讨五种基本设计模式&#xff0c;并探讨在 Spring Boot 项目中有效应用它们的最佳实践。每个模式都将附有一个实际示例来演示其实现。 单例模式 Singleton 模式确保一个类只有一个实例&#xff0c;并提供对它的全局访问点。这对于管理资源&am…
阅读更多...
【车载开发系列】CAN通信总线再理解（中篇）

【车载开发系列】CAN通信总线再理解（中篇）

【车载开发系列】CAN通信总线再理解&#xff08;中篇&#xff09; 九. CAN总线标准十. CAN物理层十一. CAN数据链路层1&#xff09;CAN的通信帧类型2&#xff09;CAN的标准帧格式1. CAN ID2. 数据场 3&#xff09;CAN总线仲裁 十二. CAN应用层1&#xff09;CANopen2&#xff09…
阅读更多...
linux如何部署前端项目和安装nginx

linux如何部署前端项目和安装nginx

要在Linux上部署前端项目并安装Nginx&#xff0c;你可以按照以下步骤操作&#xff1a; 安装Nginx: sudo apt update sudo apt install nginx 启动Nginx服务: sudo systemctl start nginx 确保Nginx服务开机自启: sudo systemctl enable nginx 部署前端项目&#xff0c;假设前…
阅读更多...
Ruby on Rails Post项目设置网站初始界面

Ruby on Rails Post项目设置网站初始界面

在构建了Ruby的Web服务器后&#xff0c;第三步就可以去掉框架的官方页面&#xff0c;设置自己的网页初始页了。 Linux系统安装Ruby语言-CSDN博客 、在Ubuntu中创建Ruby on Rails项目并搭建数据库-CSDN博客、 Ruby语言建立Web服务器-CSDN博客 了解Ruby onRails项目中的主要文件…
阅读更多...
Srouce Insight 4出现乱码

Srouce Insight 4出现乱码

今天用SI4打开一个工程文件&#xff0c;一打开发现注释全是乱码。中文全部看不出来&#xff0c;英文和数字可以看得出来。 那是因为中文的编码格式不算特别兼容。所以需要调整编码格式。 于是我在这里调整了编码格式&#xff1a; 找到菜单的Options-Preferences里面的Files 调…
阅读更多...
《计算机英语》Unit1 计算机概述

《计算机英语》Unit1 计算机概述

期末试卷组成 1、选择20道 2、判断20道 3、词汇翻译&#xff08;单词词组&#xff0c;参照课后习题&#xff09; 4、翻译2道&#xff08;一道原题&#xff0c;参照作业&#xff09; Unit One Computer Overview 单元1 计算机概述 algorithm n. 算法 operate …
阅读更多...
k8s之kubelet证书时间过期升级

k8s之kubelet证书时间过期升级

1.查看当前证书时间 # kubeadm alpha certs renew kubelet Kubeadm experimental sub-commands kubeadm是一个用于引导Kubernetes集群的工具&#xff0c;它提供了许多命令和子命令来管理集群的一生周期。过去&#xff0c;某些功能被标记为实验性的&#xff0c;并通过kubeadm a…
阅读更多...
CVPR 2024揭幕，清华大学论文接收量霸榜，轻松碾压斯坦福、麻省理工

CVPR 2024揭幕，清华大学论文接收量霸榜，轻松碾压斯坦福、麻省理工

CVPR2024 会议之眼 快讯 会议介绍 2024 年 CVPR &#xff08;Computer Vision and Pattern Recogntion Conference) 即国际计算机视觉与模式识别会议&#xff0c;于6月17日至21日正在美国西雅图召开。CVPR是计算机视觉和模式识别领域的顶级会议之一。与ICCV和ECCV并称为计算…
阅读更多...
Java基础 - 练习（四）打印九九乘法表

Java基础 - 练习（四）打印九九乘法表

Java基础练习 打印九九乘法表&#xff0c;先上代码&#xff1a; public static void multiplicationTable() {for (int i 1; i < 9; i) {for (int j 1; j < i; j) {// \t 跳到下一个TAB位置System.out.print(j "" i "" i * j "\t"…
阅读更多...
【全网最全最详细】RabbitMQ面试题

【全网最全最详细】RabbitMQ面试题

一、说下RabbitMQ的架构大致是什么样的&#xff1f; RabbitMQ是一个开源的消息中间件&#xff0c;用于在应用程序之间传递消息。它实现了AMQP&#xff08;高级消息队列协议&#xff09;并支持其它消息传递协议&#xff0c;例如STOMP&#xff08;简单文本定向消息协议&#xff…
阅读更多...
【QT5】＜重点＞ QT多线程

【QT5】＜重点＞ QT多线程

文章目录 前言 一、QThread创建多线程 二、QMutex基于互斥量的同步 三、QReadWriteLock线程同步 四、QWaitCondition线程同步 五、QSemaphore基于信号量的同步 前言 本篇记录学习QT多线程的知识&#xff0c;参考视频13.1QThread创建多线程程序_哔哩哔哩。若涉及版权问题…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023