Java 中的字符串程序

发表 admin at 2024年8月26日

类别

未分类

标签

String 是 Java 编程中使用最广泛的类。这就是为什么 Java 面试中使用 String 程序来测试编码技能的原因。

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<Character, Integer> charsWithCountMap = new HashMap<>();

		// using Map merge method from Java 8
		for (char c : input.toCharArray())
			charsWithCountMap.merge(c, 1, Integer::sum);
		System.out.println(charsWithCountMap);

		// another way using latest Java enhancements and no for loop, a bit complex though
		List<Character> 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/StringBufferreverse()方法
使用字符/字节数组并反向遍历并填充结果字符串

但是，如果您不确定输入的字符串内容，请始终使用 StringBuilder 内置的 reverse() 方法。因为使用 char 和字节数组可能会产生不必要的结果。我在 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);
	}

}

如何检查字符串是否是回文？

回文字符串是指其反向字符串也是相同的字符串。因此，我们可以反转输入字符串并检查两个字符串是否相等。或者我们可以聪明地使用 StringcharAt(int index)方法来检查回文字符串。

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 类中没有 remove 函数，但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 s1 = "Java";

s1 = "Python";

在上面的代码片段中，我们可以说 s1 值已更改，并且它是一个 String 对象。那么我们怎么能说 String 是不可变的呢？要理解的最重要的一点是 String 如何在 Java 中创建。当我们使用字符串文字创建 String 时，它不会改变原始 String 的值。它在字符串池中创建一个新的 String 并更改变量的引用。因此，原始字符串值永远不会改变，这就是 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 value got changed above, so how String is immutable?

		//well, in above case a new String "Python" got created in the pool
		//s1 is now referring to the new String in the pool
		//BUT, the original String "Java" is still unchanged and remains in the pool
		//s2 is still referring to the original String "Java" in the pool

		// proof that s1 and s2 have different reference
		System.out.println(s1 == s2);

		System.out.println(s2);
		// prints "Java" supporting the fact that original String value is unchanged, hence String is immutable

	}

}

编写一个程序来计算字符串中的单词数？

这个程序的简单解决方案似乎是，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); //won't work with tabs and multiple spaces

		String trimmedLine = line.trim();
		int count = trimmedLine.isEmpty() ? 0 : trimmedLine.split("\\s+").length;

		System.out.println(count);
	}

}

编写一个程序来检查两个字符串是否由相同的字符创建？

首先，我们必须从输入字符串中创建一个字符集。然后使用 Set 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));
	}

}

读取两个字符串用户输入并检查第一个是否包含第二个？

这是一个简单的程序，我们可以使用 Stringcontains()方法来检查指定的字符串是否是该字符串的一部分。但是，我们必须使用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 存储库下载示例。