String 是 Java 编程中最广泛使用的类,这就是为什么 String 程序在 java 采访中被用来访问编码技能的原因。
Java 中的 String 程序
在这里,我提供一些字符串程序在Java,以帮助你刷新你的编码技能. 请尝试自己解决这些问题,在检查答案以更好地学习之前. 我正在尝试使用Java中引入的所有最新功能,如 [Stream]( / 社区 / 教程 /java-8 流), [lambda表达式]( / 社区 / 教程 /java-lambda-expression), [功能界面]( / 社区 / 教程 /java-8 功能界面)等。
如何在一个字符串中获得不同的字符及其计数?
1package com.journaldev.java.string;
2
3import java.util.HashMap;
4import java.util.List;
5import java.util.Map;
6import java.util.stream.Collectors;
7
8public class DistinctCharsCount {
9
10 public static void main(String[] args) {
11
12 printDistinctCharsWithCount("abc");
13 printDistinctCharsWithCount("abcab3");
14 printDistinctCharsWithCount("hi there, i am pankaj");
15 }
16
17 private static void printDistinctCharsWithCount(String input) {
18 Map<Character, Integer> charsWithCountMap = new HashMap<>();
19
20 // using Map merge method from Java 8
21 for (char c : input.toCharArray())
22 charsWithCountMap.merge(c, 1, Integer::sum);
23 System.out.println(charsWithCountMap);
24
25 // another way using latest Java enhancements and no for loop, a bit complex though
26 List<Character> list = input.chars().mapToObj(c -> (char) c).collect(Collectors.toList());
27
28 list.stream().forEach(c -> charsWithCountMap.merge(c, 1, Integer::sum));
29
30 System.out.println(charsWithCountMap);
31
32 }
33
34}
写一个Java程序来扭转一个字符串?
有很多方法可以扭转一个 String. 一些常见的方法是:
- StringBuilder/StringBuffer
reverse()方法 - 使用 char/byte 数组并向相反方向穿越并填充结果字符串
但是,如果您不确定输入 String 内容,请始终使用 StringBuilder 内置的 reverse() 方法. 因为使用 char 和 byte 数组可能会产生不必要的结果. 我在 Java 中的 Reverse a String中为此提供了完整的解释。
1package com.journaldev.java.string;
2
3public class ReverseAString {
4
5 public static void main(String[] args) {
6
7 reverseInputString("abc");
8 reverseInputString("ç©∆˙¨˚ø"); //special chars
9 }
10
11 private static void reverseInputString(String input) {
12 StringBuilder sb = new StringBuilder(input);
13 String result = sb.reverse().toString();
14 System.out.println(result);
15 }
16
17}
如何检查一个字符串是否是巴林德罗?
一个 palindrome 字符串是其反面也是相同的字符串的字符串,所以我们可以逆转输入字符串并检查这两个字符串是否相等,或者我们可以聪明地使用 String charAt(int index) 方法来检查 palindrome 字符串。
1package com.journaldev.java.string;
2
3public class PalindromeString {
4
5 public static void main(String[] args) {
6
7 checkPalindromeString("abc");
8 checkPalindromeString("abcba");
9 checkPalindromeString("ç∂©∂ç");
10 }
11
12 private static void checkPalindromeString(String input) {
13 boolean result = true;
14 int length = input.length();
15 for(int i=0; i < length/2; i++) {
16 if(input.charAt(i) != input.charAt(length-i-1)) {
17 result = false;
18 break;
19 }
20 }
21 System.out.println(input + " is palindrome = "+result);
22
23 }
24
25}
如何从输入字符串中删除特定字符的所有发生?
在 String 类中没有删除函数,但我们可以在这种情况下使用replaceAll()。
1package com.journaldev.java.string;
2
3public class RemoveCharFromString {
4
5 public static void main(String[] args) {
6
7 removeCharFromString("abcbcdjfkd", 'c');
8 removeCharFromString("Pankaj", 'a');
9 removeCharFromString("ç∂©∂ç", '©');
10
11 }
12
13 private static void removeCharFromString(String input, char c) {
14 String result = input.replaceAll(String.valueOf(c), "");
15 System.out.println(result);
16 }
17
18}
如何证明 String 在程序上是不可变的?
我們知道 String is immutable in java,但新的開發人員仍然會對此感到困惑。
1String s1 = "Java";
2
3s1 = "Python";
在上面的代码片段中,我们可以说 s1 值已经改变了,它是一个 String 对象,所以我们如何说 String 是不可变的?理解的最重要点是如何在 Java 中创建 Strings。当我们使用字母字符串创建 String 时,它不会改变原始 String 的值。它在字符串池中创建一个新的 String 并改变变量的参考。所以原始字符串值从未改变,这就是为什么 Strings 是不可变的。
1package com.journaldev.java.string;
2
3public class StringImmutabilityTest {
4
5 public static void main(String[] args) {
6
7 String s1 = "Java"; // "Java" String created in pool and reference assigned to s1
8
9 String s2 = s1; //s2 is also having the same reference to "Java" in the pool
10
11 System.out.println(s1 == s2); // proof that s1 and s2 have same reference
12
13 s1 = "Python";
14 //s1 value got changed above, so how String is immutable?
15
16 //well, in above case a new String "Python" got created in the pool
17 //s1 is now referring to the new String in the pool
18 //BUT, the original String "Java" is still unchanged and remains in the pool
19 //s2 is still referring to the original String "Java" in the pool
20
21 // proof that s1 and s2 have different reference
22 System.out.println(s1 == s2);
23
24 System.out.println(s2);
25 // prints "Java" supporting the fact that original String value is unchanged, hence String is immutable
26
27 }
28
29}
写一个程序来计算一个字符串中的单词数量?
这个程序的简单解决方案似乎是input.split(" ").length,但如果你的字符串没有正确格式化,它包含引导和追踪空间,重复多个空间和卡。
1package com.journaldev.java.string;
2
3public class CountNumberOfWordsInString {
4
5 public static void main(String[] args) {
6
7 countNumberOfWords("My name is Pankaj");
8 countNumberOfWords("I Love Java Programming");
9 countNumberOfWords(" This is not properly formatted line ");
10
11 }
12
13 private static void countNumberOfWords(String line) {
14 //System.out.println(line.split(" ").length); //won't work with tabs and multiple spaces
15
16 String trimmedLine = line.trim();
17 int count = trimmedLine.isEmpty() ? 0 : trimmedLine.split("\\s+").length;
18
19 System.out.println(count);
20 }
21
22}
写一个程序来检查是否有两个具有相同字符的字符串?
首先,我们必须从输入字符串中创建一个字符集,然后使用 Set equals() 方法来检查它们是否包含相同的字符。
1package com.journaldev.java.string;
2
3import java.util.Set;
4import java.util.stream.Collectors;
5
6public class CheckSameCharsInString {
7
8 public static void main(String[] args) {
9 sameCharsStrings("abc", "cba");
10 sameCharsStrings("aabbcc", "abc");
11 sameCharsStrings("abcd", "abc");
12 sameCharsStrings("11", "1122");
13 sameCharsStrings("1122", "11");
14 }
15
16 private static void sameCharsStrings(String s1, String s2) {
17
18 Set<Character> set1 = s1.chars().mapToObj(c -> (char) c).collect(Collectors.toSet());
19 Set<Character> set2 = s2.chars().mapToObj(c -> (char) c).collect(Collectors.toSet());
20 System.out.println(set1.equals(set2));
21 }
22
23}
阅读两个字符串用户输入并检查第一个是否包含第二个字符串?
这是一个简单的程序,我们可以使用 String contains() 方法来检查指定的字符串是否是这个字符串的一部分,但是我们必须使用 Scanner class来读取用户输入。
1package com.journaldev.java.string;
2
3import java.util.Scanner;
4
5public class StringContainsSubstring {
6
7 public static void main(String[] args) {
8 Scanner scanner = new Scanner(System.in);
9 System.out.println("Enter First String:");
10 String s1 = scanner.nextLine();
11
12 System.out.println("Enter Second String:");
13 String s2 = scanner.nextLine();
14
15 scanner.close();
16
17 boolean result = stringContainsSubstring(s1, s2);
18 System.out.println(s1+" contains "+s2+" = "+result);
19 }
20
21 private static boolean stringContainsSubstring(String string, String substring) {
22 boolean result = false;
23 result = string.contains(substring);
24 return result;
25 }
26
27}
以下是上面的程序的样本输出:
1Enter First String:
2Pankaj
3Enter Second String:
4an
5Pankaj contains an = true
如何交换两个字符串而不使用第三个变量?
我们可以使用 String substring() 方法做到这一点,这里有一个简单的代码片段来展示这一点:
1String s1 = "abc";
2String s2 = "def";
3
4s1 = s1.concat(s2);
5s2 = s1.substring(0,s1.length()-s2.length());
6s1 = s1.substring(s2.length());
如果我们必须写一个函数来做这件事? 由于 String 是不可变的,方法中的 String 引用值的变化将在方法结束后消失。 此外,我们不能在 java 中从一种方法返回多个对象,所以我们将不得不创建一个容器来保持输入字符串,然后在方法中执行上述逻辑。
1package com.journaldev.java.string;
2
3import java.util.Scanner;
4
5public class SwapTwoStrings {
6
7 public static void main(String[] args) {
8
9 Container container = new Container();
10 Scanner scanner = new Scanner(System.in);
11 System.out.println("Enter First String:");
12 container.setFirstString(scanner.nextLine());
13
14 System.out.println("Enter Second String:");
15 container.setSecondString(scanner.nextLine());
16 scanner.close();
17 System.out.println(container);
18 container = swapStrings(container);
19 System.out.println(container);
20 }
21
22 private static Container swapStrings(Container container) {
23 container.setFirstString(container.getFirstString().concat(container.getSecondString())); //s1 = s1+s2
24 container.setSecondString(container.getFirstString().substring(0, container.getFirstString().length()-container.getSecondString().length())); // s2=s1
25 container.setFirstString(container.getFirstString().substring(container.getSecondString().length()));
26 return container;
27 }
28
29}
30
31class Container{
32 private String firstString;
33 private String secondString;
34
35 public String getFirstString() {
36 return firstString;
37 }
38 public void setFirstString(String firstString) {
39 this.firstString = firstString;
40 }
41 public String getSecondString() {
42 return secondString;
43 }
44 public void setSecondString(String secondString) {
45 this.secondString = secondString;
46 }
47
48 @Override
49 public String toString() {
50 return "First String = "+firstString+", Second String = "+secondString;
51 }
52}
样品产量:
1Enter First String:
2Java
3Enter Second String:
4Python
5First String = Java, Second String = Python
6First String = Python, Second String = Java
写一个程序,从输入字符串中找出第一个不重复的字符?
1package com.journaldev.java.string;
2
3import java.util.ArrayList;
4import java.util.List;
5
6public class FindNonRepeatingChar {
7
8 public static void main(String[] args) {
9
10 System.out.println(printFirstNonRepeatingChar("abcaabcdedxy"));
11 System.out.println(printFirstNonRepeatingChar("abca"));
12 System.out.println(printFirstNonRepeatingChar("aaa"));
13
14 }
15
16 private static Character printFirstNonRepeatingChar(String string) {
17 char[] chars = string.toCharArray();
18
19 List<Character> discardedChars = new ArrayList<>();
20
21 for (int i = 0; i < chars.length; i++) {
22 char c = chars[i];
23
24 if (discardedChars.contains(c))
25 continue;
26
27 for (int j = i + 1; j < chars.length; j++) {
28 if (c == chars[j]) { // match found
29 discardedChars.add(c);
30 break;
31 } else if (j == chars.length - 1) { // no match found till end
32 return c;
33 }
34 }
35 }
36 return null;
37 }
38
39}
提供两种方式来检查一个字符串是否只包含数字?
我们可以使用常规表达式来检查一个字符串是否是数字的,另一种方法是将它解析为长,如果它是一个非数字的字符串,那么它会扔NumberFormatException。
1package com.journaldev.java.string;
2
3public class CheckIfStringContainsDigitsOnly {
4
5 public static void main(String[] args) {
6 digitsOnlyString("111");
7 digitsOnlyString("111a 1");
8 digitsOnlyString("111 222");
9 digitsOnlyString("111L");
10
11 }
12
13 private static void digitsOnlyString(String string) {
14 if(string.matches("\\d+")) System.out.println("Digit Only String ::"+string);
15
16 try {
17 long l = Long.parseLong(string);
18 System.out.println("Digit Only String ::"+string);
19 }catch(Exception e){
20 System.out.println("Non Digit Only String ::"+string);
21 }
22
23 }
24
25}
如何执行 Deep Copy for String?
字符串是不可变的,所以我们不必担心深层复制或浅层复制,我们可以简单地使用分配运算符 (=)来复制一个字符串到另一个字符串。
你可以从我的 GitHub 存储库下载示例。