算法刷题笔记:
算法刷题笔记:
题目
输入一个英文句子，单词之间用一个空格隔开，且句首和句尾没有多余空格。
翻转句子中单词的顺序，但单词内字符的顺序不变。
为简单起见，标点符号和普通字母一样处理。
例如输入字符串"I am a student."，则输出"student. a am I"。
样例
输入："I am a student."
输出："student. a am I"
package 翻转单词顺序;
public class reverseWords剑指offer58a {
/**
* 实现了翻转字符串指定2个位置间的字符
* @param strArg
* @param start
* @param end
* @return
*/
public static String strReverse(String strArg,int start,int end){
//
String strStart=strArg.substring(0,start);
String strEnd=strArg.substring(end);
String strSub=strArg.substring(start, end);
StringBuffer sb=new StringBuffer(strSub);
strSub=sb.reverse().toString();
//System.out.println(strSub);
/**
* concat用于链接字符串
*/
return strStart.concat(strSub).concat(strEnd);
}
public static String reverseWords(String s) {
StringBuilder stringBuffer = new StringBuilder(s);
String res=stringBuffer.reverse().toString();
String sb = res;
for (int i = 0; i < res.length(); i++) {
int j = i + 1;
while (j < res.length() && res.charAt(j) !=' ') {
j++;
}
sb= strReverse(sb,i,j);
i=j;
}
return sb;
}
public static void main(String[] args) {
String s ="In life's earnest battle they only prevail, who daily march onward and never say fail.";
System.out.println(reverseWords(s));
}
}class Solution {
public:
string reverseWords(string s) {
string res=reverse(s.begin(),s.end);
for(int i = 0; i < s.size(); i++) {
while(s[j]!=' '&&j<s.size)j++;
res=reverse(s.begin()+i,s.begin+j);
i=j;
}
return res;
}
};输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。为简单起见，标点符号和普通字母一样处理。例如输入字符串"I am a student. "，则输出"student. a am I"。
示例 1：
输入: "the sky is blue"
输出: "blue is sky the"示例 2：
输入: " hello world! "
输出: "world! hello"
解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。示例 3：
输入: "a good example"
输出: "example good a"
解释: 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。class Solution {
public String reverseWords(String s) {
String[] strs = s.trim().split(" "); // 删除首尾空格，分割字符串
StringBuilder res = new StringBuilder();
for(int i = strs.length - 1; i >= 0; i--) { // 倒序遍历单词列表
if(strs[i].equals("")) continue; // 遇到空单词则跳过
res.append(strs[i] + " "); // 将单词拼接至 StringBuilder
}
return res.toString().trim(); // 转化为字符串，删除尾部空格，并返回
}
}class Solution:
def reverseWords(self, s: str) -> str:
s = s.strip() # 删除首尾空格
strs = s.split() # 分割字符串
strs.reverse() # 翻转单词列表
return ' '.join(strs) # 拼接为字符串并返回语法知识
trim() 方法用于删除字符串的头尾空白符。
语法
public String trim()参数
- 无
返回值
删除头尾空白符的字符串。
实例
public class Test {
public static void main(String args[]) {
String Str = new String(" www.runoob.com ");
System.out.print("原始值 :" );
System.out.println( Str );
System.out.print("删除头尾空白 :" );
System.out.println( Str.trim() );
}
}以上程序执行结果为：
原始值 : www.runoob.com
删除头尾空白 :www.runoob.com改字符串中的某个位置字符
String item = "1111111111";
char[] status = item.toCharArray();
status[6] = '6';
status[7] = '6';
status[8] = '6';
String ss = Arrays.toString(status).replaceAll("[\\[\\]\\s,]", "");
System.out.println(ss);replace方法
该方法的作用是替换字符串中所有指定的字符，然后生成一个新的字符串。经过该方法调用以后，原来的字符串不发生改变。例如：
String s = “abcat”；
String s1 = s.replace（‘a’，‘1’）；
该代码的作用是将字符串s中所有的字符a替换成字符1，生成的新字符串s1的值是“1bc1t”，而字符串s的内容不发生改变。
replaceAll方法
如果需要将字符串中某个指定的字符串替换为其它字符串，则可以使用replaceAll方法，例如：
String s = “abatbac”；
String s1 = s.replaceAll（“ba”，“12”）；
该代码的作用是将字符串s中所有的字符串“ab”替换为“12”，生成新的字符串“a12t12c”，而字符串s的内容也不发生改变。
replaceFirst方法
如果只需要替换第一个出现的指定字符串时，可以使用replaceFirst方法，例如：
String s = “abatbac”；
String s1 = s. replaceFirst （“ba”，“12”）；
该代码的作用是只将字符串s中第一次出现的字符串“ab”替换为字符串“12”，则字符串s1的值是“a12tbac”，字符串s的内容也不发生改变。
public static void main(String[] args) {
String str = "****";
if(StringUtils.isNotBlank(str)){
StringBuilder sb = new StringBuilder("18698587234");
sb.replace(3, 7, str);
System.err.println("========"+sb.toString());
}
}连接字符
concat() 方法用于将指定的字符串参数连接到字符串上。
语法
public String concat(String s)参数
- s -- 要连接的字符串。
返回值
返回连接后的新字符串。
实例
public class Test {
public static void main(String args[]) {
String s = "菜鸟教程：";
s = s.concat("www.runoob.com");
System.out.println(s);
}
}以上程序执行结果为：
菜鸟教程：www.runoob.comJava StringBuffer 和 StringBuilder 类
当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。
和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
在使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。
StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。
实例
public class RunoobTest{
public static void main(String args[]){
StringBuilder sb = new StringBuilder(10);
sb.append("Runoob..");
System.out.println(sb);
sb.append("!");
System.out.println(sb);
sb.insert(8, "Java");
System.out.println(sb);
sb.delete(5,8);
System.out.println(sb);
}
}
以上实例编译运行结果如下：
Runoob..
Runoob..!
Runoob..Java!
RunooJava!然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。
Test.java 文件代码：
public class Test{ public static void main(String args[]){ StringBuffer sBuffer = new StringBuffer("菜鸟教程官网："); sBuffer.append("www"); sBuffer.append(".runoob"); sBuffer.append(".com"); System.out.println(sBuffer); } }
以上实例编译运行结果如下：
菜鸟教程官网：www.runoob.comStringBuffer 方法
以下是 StringBuffer 类支持的主要方法：
| 序号 | 方法描述 |
|---|---|
| 1 | public StringBuffer append(String s) 将指定的字符串追加到此字符序列。 |
| 2 | public StringBuffer reverse() 将此字符序列用其反转形式取代。 |
| 3 | public delete(int start, int end) 移除此序列的子字符串中的字符。 |
| 4 | public insert(int offset, int i) 将 int 参数的字符串表示形式插入此序列中。 |
| 5 | replace(int start, int end, String str) 使用给定 String 中的字符替换此序列的子字符串中的字符。 |
下面的列表里的方法和 String 类的方法类似：
| 序号 | 方法描述 |
|---|---|
| 1 | int capacity() 返回当前容量。 |
| 2 | char charAt(int index) 返回此序列中指定索引处的 char 值。 |
| 3 | void ensureCapacity(int minimumCapacity) 确保容量至少等于指定的最小值。 |
| 4 | void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此序列复制到目标字符数组 dst。 |
| 5 | int indexOf(String str) 返回第一次出现的指定子字符串在该字符串中的索引。 |
| 6 | int indexOf(String str, int fromIndex) 从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。 |
| 7 | int lastIndexOf(String str) 返回最右边出现的指定子字符串在此字符串中的索引。 |
| 8 | int lastIndexOf(String str, int fromIndex) 返回 String 对象中子字符串最后出现的位置。 |
| 9 | int length() 返回长度（字符数）。 |
| 10 | void setCharAt(int index, char ch) 将给定索引处的字符设置为 ch。 |
| 11 | void setLength(int newLength) 设置字符序列的长度。 |
| 12 | CharSequence subSequence(int start, int end) 返回一个新的字符序列，该字符序列是此序列的子序列。 |
| 13 | String substring(int start) 返回一个新的 String，它包含此字符序列当前所包含的字符子序列。 |
| 14 | String substring(int start, int end) 返回一个新的 String，它包含此序列当前所包含的字符子序列。 |
| 15 | String toString() 返回此序列中数据的字符串表示形式。 |
Java String 类
字符串广泛应用 在 Java 编程中，在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。
创建字符串
创建字符串最简单的方式如下:
String str = "Runoob";
在代码中遇到字符串常量时，这里的值是 "Runoob""，编译器会使用该值创建一个 String 对象。
和其它对象一样，可以使用关键字和构造方法来创建 String 对象。
用构造函数创建字符串：
String str2=new String("Runoob");
String 创建的字符串存储在公共池中，而 new 创建的字符串对象在堆上：
String s1 = "Runoob"; // String 直接创建 String s2 = "Runoob"; // String 直接创建 String s3 = s1; // 相同引用 String s4 = new String("Runoob"); // String 对象创建 String s5 = new String("Runoob"); // String 对象创建
String 类有 11 种构造方法，这些方法提供不同的参数来初始化字符串，比如提供一个字符数组参数:
StringDemo.java 文件代码：
public class StringDemo{ public static void main(String args[]){ char[] helloArray = { 'r', 'u', 'n', 'o', 'o', 'b'}; String helloString = new String(helloArray); System.out.println( helloString ); } }
以上实例编译运行结果如下：
runoob**注意:**String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了（详看笔记部分解析）。
如果需要对字符串做很多修改，那么应该选择使用 StringBuffer & StringBuilder 类。
字符串长度
用于获取有关对象的信息的方法称为访问器方法。
String 类的一个访问器方法是 length() 方法，它返回字符串对象包含的字符数。
下面的代码执行后，len 变量等于 14:
StringDemo.java 文件代码：
public class StringDemo { public static void main(String args[]) { String site = "www.runoob.com"; int len = site.length(); System.out.println( "菜鸟教程网址长度 : " + len ); } }
以上实例编译运行结果如下：
菜鸟教程网址长度 : 14连接字符串
String 类提供了连接两个字符串的方法：
string1.concat(string2);
返回 string2 连接 string1 的新字符串。也可以对字符串常量使用 concat() 方法，如：
"我的名字是 ".concat("Runoob");更常用的是使用'+'操作符来连接字符串，如：
"Hello," + " runoob" + "!"结果如下:
"Hello, runoob!"下面是一个例子:
StringDemo.java 文件代码：
public class StringDemo {
public static void main(String args[]) {
String string1 = "菜鸟教程网址：";
System.out.println("1、" + string1 + "www.runoob.com");
}
}以上实例编译运行结果如下：
1、菜鸟教程网址：www.runoob.com创建格式化字符串
我们知道输出格式化数字可以使用 printf() 和 format() 方法。
String 类使用静态方法 format() 返回一个String 对象而不是 PrintStream 对象。
String 类的静态方法 format() 能用来创建可复用的格式化字符串，而不仅仅是用于一次打印输出。