Java字符串

字符串

总结 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 -> sd\a
replaceFirst(“wa”, “sa”) 只替换第一匹配到的字符

字符串进行比较

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

栈（Stack类）

序号	函数说明
1	boolean empty( ) 测试堆栈是否为空
2	Object peek( ) 查看堆栈顶部的对象，但不从堆栈中移除它。
3	Object pop( ) 移除堆栈顶部的对象，并作为此函数的值返回该对象。
4	Object push(Object element) 把项压入堆栈顶部。
5	int search(Object element) 返回对象在堆栈中的位置，以 1 为基数。

实践

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();
    }
}