字符串是Java编程中最广泛使用的类。这就是为什么在Java面试中使用字符串程序来评估编码技能的原因。
Java中的字符串程序
在这里，我提供了一些Java中的字符串程序，以帮助您提高编码技能。在查看答案之前，请尽量自己解决这些问题，以更好地学习。我正在尝试使用Java引入的所有最新功能，比如流（Stream），lambda表达式，函数接口等。
如何获取字符串中不同字符及其数量？
package com.journaldev.java.string;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class DistinctCharsCount {
public static void main(String[] args) {
printDistinctCharsWithCount("abc");
printDistinctCharsWithCount("abcab3");
printDistinctCharsWithCount("hi there, i am pankaj");
}
private static void printDistinctCharsWithCount(String input) {
Map charsWithCountMap = new HashMap<>();
// 使用Java 8的Map合并方法
for (char c : input.toCharArray())
charsWithCountMap.merge(c, 1, Integer::sum);
System.out.println(charsWithCountMap);
// 另一种方法使用最新的Java增强功能，没有for循环，虽然有点复杂
List list = input.chars().mapToObj(c -> (char) c).collect(Collectors.toList());
list.stream().forEach(c -> charsWithCountMap.merge(c, 1, Integer::sum));
System.out.println(charsWithCountMap);
}
}
编写一个Java程序来反转字符串？
有许多方法可以反转字符串。其中一些常见的方法包括：
- 使用StringBuilder/StringBuffer的
reverse()方法 - 使用字符/字节数组，反向遍历并填充结果字符串
但是，如果您不确定输入字符串的内容，请始终使用StringBuilder内置的reverse()方法。因为使用字符和字节数组可能会产生意外的结果。我在Java中反转字符串中对此进行了详细说明。
package com.journaldev.java.string;
public class ReverseAString {
public static void main(String[] args) {
reverseInputString("abc");
reverseInputString("ç©∆˙¨˚ø"); //special chars
}
private static void reverseInputString(String input) {
StringBuilder sb = new StringBuilder(input);
String result = sb.reverse().toString();
System.out.println(result);
}
}
如何检查字符串是否是回文？
A palindrome string is one whose reverse is also same string. So we can reverse the input string and check if both strings are equal for this. Or we can be smart and use the String charAt(int index) method to check for palindrome string.
package com.journaldev.java.string;
public class PalindromeString {
public static void main(String[] args) {
checkPalindromeString("abc");
checkPalindromeString("abcba");
checkPalindromeString("ç∂©∂ç");
}
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 + " is palindrome = "+result);
}
}
如何从输入字符串中删除所有给定字符的出现？
没有String类中的删除函数，但是在这种情况下我们可以使用replaceAll()。下面是一个简单的程序示例。
package com.journaldev.java.string;
public class RemoveCharFromString {
public static void main(String[] args) {
removeCharFromString("abcbcdjfkd", 'c');
removeCharFromString("Pankaj", 'a');
removeCharFromString("ç∂©∂ç", '©');
}
private static void removeCharFromString(String input, char c) {
String result = input.replaceAll(String.valueOf(c), "");
System.out.println(result);
}
}
如何通过程序证明String是不可变的？
我们知道在java中String是不可变的，然而新手开发者仍然会对此感到困惑。让我们试着理解这种困惑的原因。
String s1 = "Java";
s1 = "Python";
在上面的代码片段中，我们可以说s1的值已经改变了，它是一个String对象。那么我们怎么说String是不可变的呢？要理解的最重要的一点是如何在java中创建字符串。当我们使用字符串字面值创建一个字符串时，它不会改变原始字符串的值。它在字符串池中创建一个新的字符串，并改变变量的引用。因此原始字符串的值永远不会改变，这就是为什么String是不可变的。下面的程序证明了我们的说法，请仔细阅读注释以正确理解这个概念。
package com.journaldev.java.string;
public class StringImmutabilityTest {
public static void main(String[] args) {
String s1 = "Java"; // "Java" String created in pool and reference assigned to s1
String s2 = s1; //s2 is also having the same reference to "Java" in the pool
System.out.println(s1 == s2); // proof that s1 and s2 have same reference
s1 = "Python";
//在上面，s1的值发生了变化，那么字符串为什么是不可变的呢？
//嗯，在上面的情况下，一个新的字符串 "Python" 在池中被创建
//现在s1指向池中的新字符串
//但是，原始字符串 "Java" 仍然保持不变，并且仍然存在于池中
//s2仍然指向池中原始字符串 "Java"
//证明s1和s2具有不同的引用
System.out.println(s1 == s2);
System.out.println(s2);
//打印 "Java"，证明原始字符串值未更改，因此字符串是不可变的
}
}
编写一个程序来计算字符串中单词的数量？
这个程序的简单解决方案似乎是 input.split(" ").length，但如果您的字符串格式不正确并且包含前导和尾随空格、重复多个空格和制表符，则这种方法将无效。幸运的是，String split() 函数接受正则表达式作为参数，我们可以使用它来计算字符串中单词的数量。
package com.journaldev.java.string;
public class CountNumberOfWordsInString {
public static void main(String[] args) {
countNumberOfWords("My name is Pankaj");
countNumberOfWords("I Love Java Programming");
countNumberOfWords(" This is not properly formatted line ");
}
private static void countNumberOfWords(String line) {
//System.out.println(line.split(" ").length); //无法处理制表符和多个空格
String trimmedLine = line.trim();
int count = trimmedLine.isEmpty() ? 0 : trimmedLine.split("\\s+").length;
System.out.println(count);
}
}
编写一个程序来检查两个字符串是否由相同字符组成？
首先，我们需要从输入的字符串中创建一个字符集。然后使用字符集的 equals() 方法来检查它们是否包含相同的字符。以下是一个简单的程序，用于检查两个字符串是否由相同的字符创建。
package com.journaldev.java.string;
import java.util.Set;
import java.util.stream.Collectors;
public class CheckSameCharsInString {
public static void main(String[] args) {
sameCharsStrings("abc", "cba");
sameCharsStrings("aabbcc", "abc");
sameCharsStrings("abcd", "abc");
sameCharsStrings("11", "1122");
sameCharsStrings("1122", "11");
}
private static void sameCharsStrings(String s1, String s2) {
Set<Character> set1 = s1.chars().mapToObj(c -> (char) c).collect(Collectors.toSet());
Set<Character> set2 = s2.chars().mapToObj(c -> (char) c).collect(Collectors.toSet());
System.out.println(set1.equals(set2));
}
}
读取两个字符串用户输入并检查第一个是否包含第二个？
这是一个简单的程序，我们可以使用 String 的 contains() 方法来检查指定的字符串是否是这个字符串的一部分。然而，我们将需要使用 Scanner 类 来读取用户输入。
package com.journaldev.java.string;
import java.util.Scanner;
public class StringContainsSubstring {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Enter First String:");
String s1 = scanner.nextLine();
System.out.println("Enter Second String:");
String s2 = scanner.nextLine();
scanner.close();
boolean result = stringContainsSubstring(s1, s2);
System.out.println(s1+" contains "+s2+" = "+result);
}
private static boolean stringContainsSubstring(String string, String substring) {
boolean result = false;
result = string.contains(substring);
return result;
}
}
以下是上述程序的示例输出：
Enter First String:
Pankaj
Enter Second String:
an
Pankaj contains an = true
如何在不使用第三个变量的情况下交换两个字符串？
我们可以使用String的substring（）方法来实现。这里是一个简单的代码片段来展示这个：
String s1 = "abc";
String s2 = "def";
s1 = s1.concat(s2);
s2 = s1.substring(0,s1.length()-s2.length());
s1 = s1.substring(s2.length());
如果我们需要编写一个函数来实现这个呢？由于String是不可变的，在方法中对String引用的值的更改将在方法结束时消失。而且在Java中我们无法从一个方法中返回多个对象。因此，我们需要创建一个容器来保存输入字符串，然后在方法中执行上述逻辑。下面的代码展示了如何实现这一点，虽然它看起来可能比较复杂，但逻辑与上述相同。
package com.journaldev.java.string;
import java.util.Scanner;
public class SwapTwoStrings {
public static void main(String[] args) {
Container container = new Container();
Scanner scanner = new Scanner(System.in);
System.out.println("Enter First String:");
container.setFirstString(scanner.nextLine());
System.out.println("Enter Second String:");
container.setSecondString(scanner.nextLine());
scanner.close();
System.out.println(container);
container = swapStrings(container);
System.out.println(container);
}
private static Container swapStrings(Container container) {
container.setFirstString(container.getFirstString().concat(container.getSecondString())); //s1 = s1+s2
container.setSecondString(container.getFirstString().substring(0, container.getFirstString().length()-container.getSecondString().length())); // s2=s1
container.setFirstString(container.getFirstString().substring(container.getSecondString().length()));
return container;
}
}
class Container{
private String firstString;
private String secondString;
public String getFirstString() {
return firstString;
}
public void setFirstString(String firstString) {
this.firstString = firstString;
}
public String getSecondString() {
return secondString;
}
public void setSecondString(String secondString) {
this.secondString = secondString;
}
@Override
public String toString() {
return "First String = "+firstString+", Second String = "+secondString;
}
}
示例输出：
Enter First String:
Java
Enter Second String:
Python
First String = Java, Second String = Python
First String = Python, Second String = Java
编写一个程序，找出输入字符串中第一个不重复的字符？
package com.journaldev.java.string;
import java.util.ArrayList;
import java.util.List;
public class FindNonRepeatingChar {
public static void main(String[] args) {
System.out.println(printFirstNonRepeatingChar("abcaabcdedxy"));
System.out.println(printFirstNonRepeatingChar("abca"));
System.out.println(printFirstNonRepeatingChar("aaa"));
}
private static Character printFirstNonRepeatingChar(String string) {
char[] chars = string.toCharArray();
List<Character> discardedChars = new ArrayList<>();
for (int i = 0; i < chars.length; i++) {
char c = chars[i];
if (discardedChars.contains(c))
continue;
for (int j = i + 1; j < chars.length; j++) {
if (c == chars[j]) { // match found
discardedChars.add(c);
break;
} else if (j == chars.length - 1) { // no match found till end
return c;
}
}
}
return null;
}
}
提供两种检查字符串是否仅包含数字的方法？
我们可以使用正则表达式来检查一个字符串是否为数字。另一种方法是将其解析为Long类型，如果它是一个非数字字符串，那么它将抛出NumberFormatException异常。
package com.journaldev.java.string;
public class CheckIfStringContainsDigitsOnly {
public static void main(String[] args) {
digitsOnlyString("111");
digitsOnlyString("111a 1");
digitsOnlyString("111 222");
digitsOnlyString("111L");
}
private static void digitsOnlyString(String string) {
if(string.matches("\\d+")) System.out.println("Digit Only String ::"+string);
try {
long l = Long.parseLong(string);
System.out.println("Digit Only String ::"+string);
}catch(Exception e){
System.out.println("Non Digit Only String ::"+string);
}
}
}
如何对字符串执行深拷贝？
字符串是不可变的，因此我们不需要担心深拷贝或浅拷贝。我们可以简单地使用赋值运算符（=）将一个字符串复制到另一个字符串。在Java字符串复制中查看更多详情。
您可以从我的GitHub仓库下载示例。
Source:
https://www.digitalocean.com/community/tutorials/string-programs-in-java