字符串

总结 Java 字符串的语法和函数，通过 leetcode 题目进行灵活应用。

字符串长度

str.length()

返回指定位置的字符

charAt( index )

分割字符串

str.split() :对字符串进行分割

 String str = "a|b|c";
String[] strArr = str.split("\|");
System.out.println(strArr.length); // 输出:3
for (int i = 0; i < strArr.length; ++i){
System.out.println(strArr[i]);// 输出:a b c
}

截取子字符串

str.substring(start, end)
按字符进行截取

返回指定字符在字符串中第一次出现的位置

int indexOf(String str ) 如果没有就返回 -1

返回指定字符最后一次出现的位置

int lastIndexOf(char ch)

字符串替换

replace(“axv”,“fsd”)
replaceAll("a", “sa”) 用正则表达式替换指定字符 sdsa -> sda
replaceFirst(“wa”, “sa”) 只替换第一匹配到的字符

字符串进行比较

str.equals(str2) 内容相同则返回 true，地址可以不相同
== 内容和地址都需要相同

栈（Stack类）

实践

1. 无重复字符的最长子串

无重复字符的最长子串

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。

示例 2:

输入: “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。

示例 3:

输入: “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。

题解:
这道题主要用到思路是：滑动窗口

什么是滑动窗口？

其实就是一个队列,比如例题中的 abcabcbb，进入这个队列（窗口）为 abc 满足题目要求，当再进入 a，队列变成了 abca，这时候不满足要求。所以，我们要移动这个队列！
最后移动为 bca 队列

class Solution {
public int lengthOfLongestSubstring(String s) {
int max = 0;
int cur_length = 0;
int cur_position = 0; // 头字符的位置
HashSet hs = new HashSet(); // 设置滑动窗，存储大量无序元素
for (int i = 0; i < s.length(); i++) {
// 移除重复元素以及其之前的元素
while(hs.contains(s.charAt(i))) {
hs.remove(s.charAt(cur_position));
cur_position++;
}
// 将元素加入到队列当中
hs.add(s.charAt(i));
cur_length = i - cur_position + 1;
if (cur_length >= max) max = cur_length;
}
return max;
}
}

2. 罗马数字转整数

罗马数字转整数
示例 1:
输入: “III”
输出: 3

示例 2:
输入: “IV”
输出: 4

示例 3:
输入: “IX”
输出: 9

示例 4:
输入: “LVIII”
输出: 58
解释: L = 50, V= 5, III = 3.

示例 5:
输入: “MCMXCIV”
输出: 1994
解释: M = 1000, CM = 900, XC = 90, IV = 4.

题解
将所有的组合添加到哈希表当中，取字符串中的子字符串，依次和哈希表中的组合进行对比（先对比双字符，再对比单个字符）

class Solution {
public int romanToInt(String s) {
// 将所有罗马数字存入map中
HashMap<String, Integer> map = new HashMap<>();
map.put("I", 1);
map.put("IV", 4);
map.put("V", 5);
map.put("IX", 9);
map.put("X", 10);
map.put("XL", 40);
map.put("L", 50);
map.put("XC", 90);
map.put("C", 100);
map.put("CD", 400);
map.put("D", 500);
map.put("CM", 900);
map.put("M", 1000);
int ans = 0;
int i = 0;
while(i < s.length() - 1) {
if (map.get(s.substring(i, i + 2)) != null) { // 存在双字符
ans += map.get(s.substring(i, i + 2));
i += 2;
} else {
ans += map.get(s.substring(i, i + 1));
i++;
}
}
if (i < s.length()) // 对最后一个字符进行判断
ans += map.get(s.substring(i, i + 1));
return ans;
}
}

3.最长公共前缀

最长公共前缀
编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 “”。

示例 1:
输入: [“flower”,“flow”,“flight”]
输出: “fl”

示例 2:
输入: [“dog”,“racecar”,“car”]
输出: “”
解释: 输入不存在公共前缀。

题解
第一个字符和下一个字符进行比较，相同前缀的字符再和下一个字符进行比较，以此类推得到所有字符的相同前缀

class Solution {
public String longestCommonPrefix(String[] strs) {
if(strs.length == 0) return "";
String ans = strs[0];
// 用第一个字符串和剩余的字符串进行比较
for(int i = 1; i < strs.length; i++) {
boolean isCom = false;
for(int j = minLength(ans, strs[i]); j > 0; j--) {
if (ans.substring(0, j).equals(strs[i].substring(0, j))) { // 如果前缀相同
isCom = true;
ans = ans.substring(0, j);
break;
}
}
if (!isCom) return ""; // 如果均不相同，则返回空
}
return ans;
}
private int minLength(String str1, String str2) {
if (str1.length() < str2.length()) return str1.length();
else return str2.length();
}
}

4.有效的括号

有效的括号
给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。

有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。

示例 1:
输入: “()”
输出: true

示例 2:
输入: “()[]{}”
输出: true

示例 3:
输入: “(]”
输出: false

示例 4:
输入: “([)]”
输出: false

示例 5:
输入: “{[]}”
输出: true

题解
运用栈的数据结构，遇到左括号进栈，遇到右括号和栈顶元素进行比较，若栈已为空或栈顶元素不匹配，则返回 false，否则返回栈是否为空。

class Solution {
public boolean isValid(String s) {
// 用栈实现
HashMap<Character, Character> map = new HashMap();
map.put('(', ')');
map.put('{', '}');
map.put('[', ']');
// 开辟一个新栈
// 遇到左括号入栈，遇到右括号和栈顶元素进行比较，若不匹配返回false，否则和左括号一起出栈
Stack<Character> stack = new Stack();
for(int i = 0; i < s.length(); i++) {
if (map.containsKey(s.charAt(i))) { // 遇到左括号入栈
stack.push(s.charAt(i));
} else {
if(stack.empty() || map.get(stack.pop()) != s.charAt(i)) { // 栈已经为空，或栈顶元素不匹配
return false;
}
}
}
return stack.empty();
}
}

5.IP 地址无效化

IP 地址无效化

给你一个有效的 IPv4 地址 address，返回这个 IP 地址的无效化版本。
所谓无效化 IP 地址，其实就是用 “[.]” 代替了每个 “.”。

示例 1：
输入：address = “1.1.1.1”
输出：“1[.]1[.]1[.]1”

示例 2：
输入：address = “255.100.50.0”
输出：“255[.]100[.]50[.]0”

class Solution {
public String defangIPaddr(String address) {
return address.replace(".","[.]");
}
}
class Solution {
public String defangIPaddr(String address) {
StringBuffer sb = new StringBuffer();
for(int i = 0; i < address.length(); i++) {
if(address.charAt(i) == '.') {
sb.append("[.]");
continue;
}
sb.append(address.charAt(i));
}
return sb.toString();
}
}

最后

以上就是务实睫毛膏为你收集整理的Java字符串字符串栈（Stack类）实践的全部内容，希望文章能够帮你解决Java字符串字符串栈（Stack类）实践所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。