字符串

str.charAt(int index)

int compareTo(Object o)
String concat(String str)
boolean endsWith(String suffix)
boolean equals(Object anObject)
int indexOf(int ch)
int indexOf(String str)
int length()
String substring(int beginIndex, int endIndex)
char[] toCharArray()
String trim()
str.trim(); //去掉首尾空格
str.replace(" “,”"); //去除所有空格，包括首尾、中间

StringBuffer sBuffer = new StringBuffer(“菜鸟教程官网：”);
sBuffer.append(“www”);
sBuffer.append(".runoob");
sBuffer.append(".com");
sBuffer.reverse()
sBuffer.delete(int start, int end)
sBuffer.insert(int offset, int i)
sBuffer.toString()

System.out.println(sBuffer);

题目描述：最长回文子串（Longest Palindromic Substring）


给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
示例 1：
输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。
示例 2：
输入: "cbbd"
输出: "bb"


/**
 * 思想：循环遍历字符串，以每一个字符为中心，向两边扩散寻找回文串，也就是判断两侧字符是否相等
 * 由于回文字符串的长度可奇可偶，如'bob'奇数，正中间为单个字符，'noon'为偶数，正中间为两个相同的字符
 * 所以搜索方式要分奇偶，奇数情况，就以当前遍历的字符为中心，向两边扩散
 * 偶数情况，以当前字符及其下一个位置的字符当做偶数回文最中间的两个字符，向两边扩散
 * @author heimu
 * 
 */
public class test {
	public static String longestPalindrome(String s) {
		//如果长度小于2，证明是单个字符，直接返回
        if (s.length() < 2) return s;
        int n = s.length();
        //原C++代码使用了引用，这里使用数组实现引用的功能，也就是形参可以改变实参的内容
        int [] maxLen = {0};
        int [] start = {0};
        //循环字符串，以每一个字符为中心，向两边扩散来寻找
        for (int i = 0; i < n - 1; ++i) {
            searchPalindrome(s, i, i, start, maxLen);
            searchPalindrome(s, i, i + 1, start, maxLen);
        }
        //这个地方与原C++代码的返回不一样，特修改如下，经过测试，完全正确。
        return s.substring(start[0], start[0]+maxLen[0]);
    }
	
    static void searchPalindrome(String s, int left, int right, int [] start, int[] maxLen) {
    	//如果左右侧没有超越边界
    	//同时如果左侧字符等于右侧字符，那么直接向两边扩散，直到左右边界值不等，左边界左移，右边界右移
        while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
            --left; ++right;
        }
        if (maxLen[0] < right - left - 1) {
            //更新起始位置
        	start[0] = left + 1;
        	//更新找到的回文字符串的长度
        	//我觉得正常情况下，长度=右-左+1，但是注意的是上面的循环已经左边界左移，右边界右移，已经增大了两个长度
        	//所以本质上是长度=右-左-2+1
            maxLen[0] = right - left - 1;
        }
    }

	public static void main(String[] args) {
		String result = longestPalindrome("babad");
		System.out.println(result);
	}

}


/**
 * 思想：不使用子函数，直接遍历一遍字符串，已每一个字符为中心向两侧扩散；
 * 首先判断剩余的字符数是否小于等于maxlen的一半，是的话说明当前maxlen已经是最大值了；
 * 要注意的是，需要向右遍历跳过重复项；
 * @author heimu
 * 
 */
public class test {
	public static String longestPalindrome(String s) {
		//如果长度小于2，直接返回
		if (s.length() < 2) return s;
		//初始化
		int n = s.length(), maxLen = 0, start = 0;
		//比那里字符串
		for (int i = 0; i < n;) {
			//如果剩余的字符数小于等于maxlen的一半，说明maxlen无法变成了
			//注意i代表着当前遍历的字符，也就意味着是当前搜索到的maxlen回文字符串的中心
			//也就意味着i左右两侧各有maxlen/2个字符。（注意奇偶，这里不分开了）
			//如果右侧剩余的字符n-i小于等于maxlen/2，也就意味着我们的最大回文字符串查找结束了
			//也就是i后面的人任意一个字符，以此为中心，向两侧扩散得到的回文串的长度都不可能超过maxlen
		    if (n - i <= maxLen / 2) break;
		    int left = i, right = i;
		    //向右遍历跳过重复项，这种情况主要针对偶数情况
		    while (right < n - 1 && s.charAt(right + 1) == s.charAt(right)) ++right;
		    //更新i
		    i = right + 1;
		    //如果当前字符的左侧字符与右侧字符相等，向两边扩散
		    while (right < n - 1 && left > 0 && s.charAt(right + 1) == s.charAt(left - 1)) {
		        ++right; --left;
		    }
		    //注意，这个地方由于上述判断的是right+1与left+1字符是否相等，所以这个地方的right与left就是真实的回文串的左右边界
		    if (maxLen < right - left + 1) {
		        maxLen = right - left + 1;
		        start = left;
		    }
		}
		return s.substring(start, start+maxLen);
	}

	public static void main(String[] args) {
		String result = longestPalindrome("cbbd");
		System.out.println(result);
	}

}