Shulou(Shulou.com)06/02 Report--

This article mainly introduces "summing up 12 exquisite Java string operation tips". In daily operation, I believe many people have doubts in summarizing 12 exquisite Java string operation tips. The editor consulted all kinds of materials and sorted out simple and easy-to-use operation methods. I hope it will be helpful for you to answer the questions of "summing up 12 exquisite Java string operation tips". Next, please follow the editor to study!

How do I get different characters and their numbers in a string?

The problem can be broken down into two steps: the first step is to find out the different characters, and the second step is to count the number of them. It's a bit of nonsense, isn't it? Let me give you an answer first.

Public class DistinctCharsCount {public static void main (String [] args) {printDistinctCharsWithCount ("itwanger"); printDistinctCharsWithCount ("chenmowanger");} private static void printDistinctCharsWithCount (String input) {Map charsWithCountMap = new LinkedHashMap (); for (char c: input.toCharArray ()) {Integer oldValue = charsWithCountMap.get (c) Int newValue = (oldValue = = null)? 1: Integer.sum (oldValue, 1); charsWithCountMap.put (c, newValue);} System.out.println (charsWithCountMap);}}

The result of the program output is:

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1

Let's talk about my train of thought:

1) declare a LinkedHashMap, you can also use HashMap, but the former can maintain the order of the split strings, and the result looks clearer at a glance.

Why use Map? Because the key of Map does not allow repetition, it is just enough to accumulate the number of repeated characters.

2) split the string into characters and traverse it.

3) if key is null, it means that the number of characters should be + 1; otherwise, just + 1 on the previous value, and then re-put to the Map, thus overwriting the previous number of characters.

The train of thought is very clear, is it correct? I can't help giving myself a round of applause.

Well, after JDK 8, Map added a powerful method, merge (), to assign values to multiple keys at once:

Private static void printDistinctCharsWithCountMerge (String input) {Map charsWithCountMap = new LinkedHashMap (); for (char c: input.toCharArray ()) {charsWithCountMap.merge (c, 1, Integer::sum);} System.out.println (charsWithCountMap);}

Is it very good? One line of code is done. The first parameter is the key, the second parameter is the value, and the third parameter is a BiFunction, which means that if the key already exists, the new value is recalculated based on the BiFunction.

If the character appears for the first time, the value is assigned to 1; otherwise, the previous value sum 1 is set.

02. How to reverse a string?

If the students are familiar with StringBuilder and StringBuffer, this question is very simple. Just reverse () is done. Is that correct?

Public class ReverseAString {public static void main (String [] args) {reverseInputString (Silent King II);} private static void reverseInputString (String input) {StringBuilder sb = new StringBuilder (input); String result = sb.reverse () .toString (); System.out.println (result);}}

The output is as follows:

The second king is silent.

To say more, StringBuffer and StringBuilder are very similar, the former is synchronous, all public methods add the synchronized keyword, can be used in multithreading; the latter is not synchronous, there is no synchronized keyword, so the performance is better, there is no concurrency requirements, then use StringBuilder.

03. How to tell if a string is symmetrical?

What do you mean? It's like a string with a 90% discount before and after, it's symmetrical. It's like standing in front of the mirror and seeing a Yushu facing the wind and shyness of the moon.

Public class PalindromeString {public static void main (String [] args) {checkPalindromeString ("Silent King II"); checkPalindromeString ("Silent King II Silence");} private static void checkPalindromeString (String input) {boolean result = true; int length = input.length (); for (int I = 0; I)

< length / 2; i++) { if (input.charAt(i) != input.charAt(length - i - 1)) { result = false; break; } } System.out.println(input + " 对称吗？ " + result); } } 输出结果如下所示： 沉默王二 对称吗？ false 沉默王二 二王默沉 对称吗？ true 说一下我的思路：要判断字符串对折后是否对称，很简单，从中间劈开，第一个字符对照最后一个字符，一旦找到不等的那个，就返回 false。 注意三点： 1)for 循环的下标从 0 开始，到 length/2 结束。 2)下标 i 和 length-i-1 是对称的。 3)一旦 false 就 break。 04、如何删除所有出现的指定字符? 字符串类没有提供 remove() 方法，但提供了 replaceAll() 方法，通过将指定的字符替换成空白字符就可以办得到，对吧? public class RemoveCharFromString { public static void main(String[] args) { removeCharFromString("沉默王二", '二'); removeCharFromString("chenmowanger", 'n'); } private static void removeCharFromString(String input, char c) { String result = input.replaceAll(String.valueOf(c), ""); System.out.println(result); } } 输出结果如下所示： 沉默王 chemowager 05、如何证明字符串是不可变的? 字符串不可变的这个事我曾写过两篇文章，写到最后我都要吐了。但是仍然会有一些同学弄不明白，隔段时间就有人私信我，我就不得不把之前的文章放到收藏夹，问的时候我就把链接发给他。 之所以造成这个混乱，有很多因素，比如说，Java 到底是值传递还是引用传递?字符串常量池是个什么玩意? 这次又不得不谈，虽然烦透了，但仍然要证明啊! public class StringImmutabilityTest { public static void main(String[] args) { String s1 = "沉默王二"; String s2 = s1; System.out.println(s1 == s2); s1 = "沉默王三"; System.out.println(s1 == s2); System.out.println(s2); } } 输出结果如下所示： true false 沉默王二 1)String s1 = "沉默王二"，Java 在字符串常量池中创建"沉默王二"这串字符的对象，并且把地址引用赋值给 s1 2)String s2 = s1，s2 和 s1 指向了同一个地址引用——常量池中的那个"沉默王二"。 所以，此时 s1 == s2 为 true。 3)s1 = "沉默王三"，Java 在字符串常量池中创建"沉默王三"这串字符的对象，并且把地址引用赋值给 s1，但 s2 仍然指向的是"沉默王二"那串字符对象的地址引用。 所以，此时 s1 == s2 为 false，s2 的输出结果为"沉默王二"就证明了字符串是不可变的。 06、如何统计字符串中的单词数? 这道题呢?主要针对的是英文字符串的情况。虽然中文字符串中也可以有空白字符，但不存在单词这一说。 public class CountNumberOfWordsInString { public static void main(String[] args) { countNumberOfWords("My name is Wanger"); countNumberOfWords("I Love Java Programming"); countNumberOfWords(" Java is very important "); } private static void countNumberOfWords(String line) { String trimmedLine = line.trim(); int count = trimmedLine.isEmpty() ? 0 : trimmedLine.split("\\s+").length; System.out.println(count); } } 输出结果如下所示： 4 4 4 split() 方法可以对字符串进行拆分，参数不仅可以是空格，也可以使正则表达式代替的空白字符(多个空格、制表符);返回的是一个数组，通过 length 就可以获得单词的个数了。 如果对 split() 方法很感兴趣的话，可以查看我之前写的一篇文章，很饱满，很丰富。 咦，拆分个字符串都这么讲究 07、如何检查两个字符串中的字符是相同的? 如何理解这道题呢?比如说，字符串"沉默王二"和"沉王二默"就用了同样的字符，对吧?比如说，字符串"沉默王二"和"沉默王三"用的字符就不同，理解了吧? public class CheckSameCharsInString { public static void main(String[] args) { sameCharsStrings("沉默王二", "沉王二默"); sameCharsStrings("沉默王二", "沉默王三"); } private static void sameCharsStrings(String s1, String s2) { Set set1 = s1.chars().mapToObj(c ->

(char) c) .cake (Collectors.toSet ()); System.out.println (set1); Set set2 = s2.chars (). MapToObj (c-> (char) c) .Collectors.toSet (); System.out.println (set2); System.out.println (set1.equals (set2));}}

The output is as follows:

[Mo, Shen, Wang, II] [Mo, Shen, Wang, II] true [Mo, Shen, Wang, II] [Mo, Shen, three, Wang] false

The above code uses the Stream stream, which looks strange, but it is easy to understand that the string is split into characters and then collected into Set. Set is a collection that does not allow repeating elements, so different characters in the string are collected.

08. How can I tell that one string contains another?

This problem is a little simple, isn't it? The last one also used the Stream stream, so this question was directly given points? Don't doubt yourself, just use the contains () method of the string class.

Public class StringContainsSubstring {public static void main (String [] args) {String S1 = "Silent King II"; String S2 = "Silence"; System.out.println (s1.contains (S2));}}

The output is as follows:

True

The indexOf () method is actually called inside the contains () method:

Public boolean contains (CharSequence s) {return indexOf (s.toString ()) > = 0;}

09. How do I exchange two strings without using the third variable?

This question is kind of interesting, isn't it? In particular, the prerequisite does not use the third variable.

Public class SwapTwoStrings {public static void main (String [] args) {String S1 = "Silence"; String S2 = "Wang er"; S1 = s1.concat (S2); S2 = s1.substring (0journal s1.length ()-s2.length ()); S1 = s1.substring (s2.length ()); System.out.println (S1); System.out.println (S2);}}

The output is as follows:

Wang er is silent.

Let's talk about my train of thought:

1) concatenate two strings together by the concat () method.

2) then fetch the second string and the first string through the substring () method.

10. How to find the first non-repeating character from a string?

Come on, let's understand this problem in the last example. For example, the string "Silence Wang Shen Silence II", the first non-repetitive character is "Wang", right? Because "Shen" is repeated, "silent" is repeated.

Public class FindNonRepeatingChar {public static void main (String [] args) {System.out.println (printFirstNonRepeatingChar); System.out.println (printFirstNonRepeatingChar); System.out.println (printFirstNonRepeatingChar);} private static Character printFirstNonRepeatingChar (String string) {char [] chars = string.toCharArray (); List discardedChars = new ArrayList () For (int I = 0; I < chars.length; iTunes +) {char c = chars [I]; if (discardedChars.contains (c)) continue; for (int j = I + 1; j < chars.length; jacks +) {if (c = = chars [j]) {discardedChars.add (c) Break;} else if (j = = chars.length-1) {return c;} return null;}}

The output is as follows:

Wang Mo null

Let's talk about my train of thought:

1) split the string into an array of characters.

2) declare a List and put the duplicate characters in it.

3) the outer for loop, starting with the first character, and if it is already in List, proceed to the next round.

4) the nested for loop, traversing from the next character of the first character (j = I + 1), adds it to the List if it repeats the previous character, and jumps out of the inner loop; if the last (j = = chars.length-1) is not found, it is the first character that does not repeat, right?

11. How do I check that there are only numbers in a string?

There is a silly solution, which is to use Long.parseLong (string) to forcibly convert a string. If the string is not transformed into a shape, it must not just contain numbers, right?

But this method is too undesirable, so another ingenious way is to use regular expressions.

Public class CheckIfStringContainsDigitsOnly {public static void main (String [] args) {digitsOnlyString ("123Silence King"); digitsOnlyString ("123");} private static void digitsOnlyString (String string) {if (string.matches ("\\ d + ")) {System.out.println (" string containing only numbers: "+ string);}

The output is as follows:

Contains only the number: 123

12. How to make a deep copy of a string?

Because strings are immutable, you can directly use the "=" operator to copy one string to another without affecting each other.

Public class JavaStringCopy {public static void main (String args []) {String str = "Silent King II"; String strCopy = str; str = "Silent King III"; System.out.println (strCopy);}}

The output is as follows:

Silent King two

This example is almost no different from the previous example that proved that the string is immutable, right? This is really because the string is immutable, and if it is a mutable object, the depth copy should be noted, and it is best to use the new keyword to return the new object.

Public Book getBook () {Book clone = new Book (); clone.setPrice (this.book.getPrice ()); clone.setName (this.book.getName ()); return clone;} this ends the study of "summing up 12 exquisite tips for manipulating Java strings", hoping to solve everyone's doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.