Java中的字符串程序-IGI

时间：2020-02-23 14:37:26 　来源:igfitidea点击:

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

Java中的字符串程序

其中我提供了一些Java字符串程序来帮助您提高编码技巧。
请尝试自己解决这些问题，然后再检查答案以更好地学习。

我正在尝试使用Java中引入的所有最新功能，例如Stream，lambda表达式，功能接口等。

如何在字符串中获取不同的字符及其数量？

package com.theitroad.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 hyman");
	}

	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()方法
使用char/byte数组并反向遍历并填充结果字符串

但是，如果不确定输入的String内容，请始终使用StringBuilder内置的reverse()方法。
因为使用char和byte数组可能会产生不需要的结果。
我已经在Java中颠倒字符串中提供了完整的解释。

package com.theitroad.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.theitroad.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中删除所有出现的给定字符？

String类中没有remove函数，但是在这种情况下，我们可以使用replaceAll()。
这是显示如何执行此操作的简单程序。

package com.theitroad.java.string;

public class RemoveCharFromString {

	public static void main(String[] args) {

		removeCharFromString("abcbcdjfkd", 'c');
		removeCharFromString("hyman", 'a');
		removeCharFromString("ç∂©∂ç", '©');

	}

	private static void removeCharFromString(String input, char c) {
		String result = input.replaceAll(String.valueOf(c), "");
		System.out.println(result);
	}

}

如何通过编程证明String是不可变的？

我们知道String在Java中是不可变的，但是新开发人员对此仍然感到困惑。

让我们尝试了解造成这种混乱的原因。

String s1 = "Java";

s1 = "Python";

在上面的代码段中，我们可以说s1值已更改，它是一个String对象。
那么我们怎么能说String是不可变的呢？

要理解的最重要一点是如何在Java中创建字符串。
当我们使用字符串文字创建String时，它不会更改原始String的值。
它在字符串池中创建一个新的String并更改变量的引用。
因此原始字符串值永远不会改变，这就是字符串不可更改的原因。

在程序下面证明我们的语句，读出注释以正确理解概念。

package com.theitroad.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.theitroad.java.string;

public class CountNumberOfWordsInString {

	public static void main(String[] args) {
		
		countNumberOfWords("My name is hyman");
		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.theitroad.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用户输入，并检查第一个是否包含第二个？

这是一个简单的程序，我们可以使用Stringcontains()方法来检查指定的字符串是否是该字符串的一部分。
但是，我们将不得不使用Scanner类来读取用户输入。

package com.theitroad.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:
hyman
Enter Second String:
an
hyman 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.theitroad.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

编写程序以从输入String中找出第一个非重复字符？

package com.theitroad.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;
	}

}

提供两种方法来检查字符串是否仅包含数字？

我们可以使用正则表达式来检查String是否为数字。
另一种方法是将其解析为Long，如果它是非数字字符串，则将抛出NumberFormatException。

package com.theitroad.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中的字符串程序