字符串基础练习

一、判断字符串中字符是否重复

/*
 * 判断一个字符串是否有重复字符
 * 思路：
 * 如果考虑用的是ASCII码，每个字符的大小在0-127之间
 * 可以创建一个数组，长度为128
 * 遍历字符串中的每个字符，将数组中索引为该字符的ASCII码的位置加1。
 * 比如，如果字符是a，则将下标为97的位置加1，以标明字符出现的次数
 * 如果数组中有元素大于1，则字符串有重复元素
 */
public class RepeatString {
	public static void main(String[] args) {
		String str = "apple";
		System.out.println(isRepeatString(str));
	}

	public static boolean isRepeatString(String str) {
		//如果字符串为空，返回true
		if(str.isEmpty()) {
			return true;
		}
		//定义一个数组，标明每个字符出现的次数
		int[] charNum = new int[128];
		for(int i = 0;i<str.length();i++) {
			char ch = str.charAt(i);
			//如果该字符对应的ASCII码的下标位置大于0，说明字符已经出现重复
			if(charNum[ch] > 0) {
				return false;
			}else {
				charNum[ch]++;
			}
		}
		return true;
	}
}

二、翻转字符串

//翻转字符串
//翻转字符串
public class ReverseString {
	public static void main(String[] args) {
		String str = "Happy New Year";
		System.out.println(reverseString_1(str));
		System.out.println(reverseString_2(str));
		
	}
	//使用数组
	public static String reverseString_1(String str) {
		int len = str.length();
		char[] reverseStr = new char[len];
		for(int i = 0;i < len;i++) {
			reverseStr[i] = str.charAt(len-1-i);
		}
		return new String(reverseStr);
	}
	//使用StringBuilder
	public static String reverseString_2(String str) {
		StringBuilder sb = new StringBuilder(str);
		return sb.reverse().toString();
	}
}

三、变形词问题

/*
 * 给定两个字符串，确定其中一个字符串的字符重新排列后，能否变成另一个字符串，返回boolean
 * 规定大小写为不同字符且考虑字符串中的空格
 * 可见，如果是true，两个字符串的字符和个数是一样的，只是顺序不一样
 */
public class IsSameString {
	public static void main(String[] args) {
		String strA = "abcde";
		String strB = "edcba";
		System.out.println(isSame_1(strA,strB));
		System.out.println(isSame_2(strA,strB));
	}


	/*
	 * 方法一：
	 * 比对两个字符串的长度，不相等直接返回 false
	 * 将两个字符串转为字符数组，利用Arrays类的sort方法进行排序
	 * 判断排序后两个数组是否相同，返回true
	 * 因为有排序，时间复杂度比较大
	 */
	public static boolean isSame_1(String strA, String strB) {
		int lenA = strA.length();
		int lenB = strB.length();
		if(lenA!=lenB)
			return false;
		char[] chArrayA = strA.toCharArray();
		char[] chArrayB = strB.toCharArray();
		Arrays.sort(chArrayA);
		Arrays.sort(chArrayB);
		return Arrays.equals(chArrayA, chArrayB);
	}
	/*
	 * 方式二：
	 * 创建一个数组，把字符的ASCII码(或Unicode码)作为数组下标
	 * 遍历第一个字符串，遍历到每一个字符后将数组对应下标位置加1
	 * 遍历第二个字符串，每遍历一个字符，将数组对应下标位置减1
	 * 遍历整个数组，若元素不全为0，返回false
	 */
	
	public static boolean isSame_2(String strA, String strB) {
		int[] charNum = new int[128];
		char ch;
		for(int i = 0;i<strA.length();i++) {
			ch = strA.charAt(i);
			charNum[ch]++;
		}
		for(int i = 0;i<strB.length();i++) {
			ch = strB.charAt(i);
			charNum[ch]--;
			if(charNum[ch]<0)
				return false;
		}
		for(int i = 0;i<charNum.length;i++) {
			if(charNum[i]!=0)
				return false;
		}
		return true;
	}
}

四、压缩字符串

/*
 * 编写方法，实现基本的字符串压缩功能
 * 比如，字符串“abbeeddfffgggg”会压缩成“a1b2e2d2f3g4”
 * 若压缩后的字符串没有变短，则返回原先的字符串
 */
public class ZipString {
	public static void main(String[] args) {
		String str = "abbeeddfffgggg";
		System.out.println(zipStr(str));
	}

	public static String zipStr(String str) {
		int count = 0;
		char last = 0;
		StringBuilder sb = new StringBuilder();
		for(int i = 0;i<str.length();i++) {
			char ch = str.charAt(i);
			if(sb.length() == 0) {
				sb.append(ch);
				count++;
			}else {
				if(last == ch) {
					count++;
				}else {
					sb.append(count).append(ch);
					count=1;
				}
			}
			last = ch;
		}
		if(count >= 1) {
			sb.append(count);
		}
		if(str.length() <= sb.length())
			return str;
		return sb.toString();
	}
}

五、判断字符串的字符集是否相同

/*
 * 判断两个字符串的字符集是否相同
 */
public class HasSameChars {
	public static void main(String[] args) {
		String strA = "ava";
		String strB = "avg";
		System.out.println(hasSame_1(strA,strB));
		System.out.println(hasSame_2(strA,strB));
		
	}
	//方法一
	public static boolean hasSame_1(String strA, String strB) {
		int[] charNum = new int[128];
		char ch;
		for(int i = 0;i<strA.length();i++) {
			ch = strA.charAt(i);
			if(charNum[ch]==0)
				charNum[ch] = 1;
		}
		for(int i = 0;i<strB.length();i++) {
			ch = strB.charAt(i);
			if(charNum[ch] == 0) //strB出现了strA没有的字符
				return false;
			charNum[ch] = 0;//把比较过的字符下标置为0
		}
		for(int i = 0;i<strA.length();i++) {
			ch = strA.charAt(i);
			if(charNum[ch] == 1)
				return false;
		}
		return true;
	}
	
	//方法二
	public static boolean hasSame_2(String strA, String strB) {
		Map<Character,Integer> mapA = new HashMap<Character,Integer>();
		Map<Character,Integer> mapB = new HashMap<Character,Integer>();
		char ch;
		for(int i = 0;i<strA.length();i++) {
			ch = strA.charAt(i);
			if(mapA.get(ch)==null)
				mapA.put(ch, 1);
		}
		for(int i = 0;i<strB.length();i++) {
			ch = strB.charAt(i);
			if(mapB.containsKey(ch))continue;
			if(mapB.get(ch)==null)
				mapB.put(ch, 1);
		}
		if(mapA.size()!=mapB.size())
			return false;
		if(!mapA.keySet().equals(mapB.keySet()))
			return false;
		return true;
	}
}

六、旋转词

/*
 * 判断字符串A是否是字符串B的旋转字符串
 * strA:adefa  strB:defaa --> true
 * strA:adefa  strB:efada --> false
 * 如果strB是strA的旋转字符串，则strB+strB中一定包含strA
 */
public class IsRotate {
	public static void main(String[] args) {
		String strA = "adefa";
		String strB = "defaa";
		System.out.println(isRotate(strA,strB));
	}
	public static boolean isRotate(String strA, String strB) {
		return (strB+strB).contains(strA);
	}
}

七、将字符串中按字符翻转

/*
 * 将字符串按单词翻转，如Thank you，翻转成you Thank
 * 先将全部字符翻转，再将每个单词翻转
 */
public class WordReverse {
	public static void main(String[] args) {
		String str = "Thank you";
		System.out.println(reverseWord(str)); 
	}

	public static String reverseWord(String str) {
		String strWord = reverseString(str);
		String[] words = strWord.split("\\s");
		StringBuilder sb = new StringBuilder();
		for(int i = 0;i<words.length;i++) {
			sb.append(reverseString(words[i])+" "); 
			System.out.println(words[i]);
		}
		return sb.deleteCharAt(sb.length()-1).toString();
	}
	public static String reverseString(String str) {
		StringBuilder sb = new StringBuilder(str);
		return sb.reverse().toString();
	}
}

八、去掉字符串中连续出现的k次0

/*
 * 移除字符串中连续出现的k个0
 */
public class RemoveZero {
	public static void main(String[] args) {
		String str="100100001110000";
		int k = 3;
		System.out.println(removeZero(str,4));
	}

	public static String removeZero(String str,int k) {
		StringBuilder sb = new StringBuilder();
		int count = 0;
		char ch;
		for(int i = 0;i<str.length();i++) {
			ch = str.charAt(i);
			if(ch == '0') {
				count++;
			}else {
				for(int j = 0;j<count%k;j++) {
					sb.append('0');
				}
				sb.append(ch);
				count = 0;
			}
		}
		//如果字符串末尾都是0
		if(count!=0) {
			for(int m = 0;m<count%k;m++) {
				sb.append('0');
			}
		}
		return sb.toString();
	}
}