字符串基础练习

小鱼儿 2022-11-25 04:24 141阅读 0赞

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

/* * 判断一个字符串是否有重复字符 * 思路： * 如果考虑用的是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();
    	}
    }