String-Programme in Java – Leitfaden für Entwickler
String ist die am häufigsten verwendete Klasse in der Java-Programmierung für Entwickler. Daher werden String-Programme in Java-Interviews verwendet, um die Programmierfähigkeiten zu bewerten.
String-Programme in Java
Hier stelle ich einige String-Programme in Java vor, um Ihnen beim Auffrischen Ihrer Programmierkenntnisse zu helfen. Bitte versuchen Sie, diese Fragen selbst zu lösen, bevor Sie die Antworten überprüfen, um besser zu lernen. Ich versuche, alle neuesten Funktionen zu verwenden, die in Java eingeführt wurden, wie Stream, Lambda-Ausdrücke, funktionale Schnittstellen usw.
Wie erhält man unterschiedliche Zeichen und deren Anzahl in einem String?
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 list = input.chars().mapToObj(c -> (char) c).collect(Collectors.toList());
list.stream().forEach(c -> charsWithCountMap.merge(c, 1, Integer::sum));
System.out.println(charsWithCountMap);
}
}
Schreibe ein Java-Programm, um einen String umzukehren?
Es gibt viele Möglichkeiten, einen String umzukehren. Einige der gängigen String-Programme sind: StringBuilder/StringBuffer reverse()-Methode, Verwendung von char/byte Array und in umgekehrter Richtung durchlaufen und den Ergebnisstring füllen. Wenn Sie sich jedoch nicht sicher über den Inhalt des Eingabe-Strings sind, verwenden Sie immer die eingebaute reverse()-Methode von StringBuilder. Denn die Verwendung von char und byte Array kann unerwünschte Ergebnisse liefern. Eine vollständige Erklärung dafür finden Sie in Reverse a String in 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);
}
}
Wie überprüft man, ob ein String ein Palindrom ist?
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);
}
}
Wie entfernt man alle Vorkommen eines bestimmten Zeichens aus einem Eingabe-String?
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);
}
}
Wie beweist man, dass String unveränderlich ist?
String s1 = "Java";
s1 = "Python";
Im obigen Codeschnipsel können wir sagen, dass der Wert von s1 geändert wurde und es sich um ein String-Objekt handelt. Wie können wir also sagen, dass String unveränderlich ist? Der wichtigste Punkt, den man verstehen muss, ist, wie Strings in Java erstellt werden. Wenn wir einen String mit einem String-Literal erstellen, wird der Wert des ursprünglichen Strings nicht geändert. Es wird ein neuer String im String-Pool erstellt und die Referenz der Variablen geändert. Der ursprüngliche Wert der Zeichenkette wird also nicht verändert, weshalb Strings unveränderlich sind. Das folgende Programm beweist unsere Aussage, lesen Sie die Kommentare, um das Konzept richtig zu verstehen.
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
}
}
Wie schreibe ich ein Programm, um die Anzahl der Wörter in einem String zu zählen?
Die einfache Lösung für dieses Programm scheint input.split(“ „).length zu sein, aber das wird nicht funktionieren, wenn Ihre Zeichenkette nicht richtig formatiert ist und führende und nachfolgende Leerzeichen, doppelte Mehrfachleerzeichen und Tabulatoren enthält. Glücklicherweise nimmt die Funktion String split() reguläre Ausdrücke als Argument und wir können sie verwenden, um die Anzahl der Wörter in einer Zeichenkette zu zählen.
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);
}
}
Wie schreibe ich ein Programm, um zu überprüfen, ob zwei Strings mit denselben Zeichen erstellt wurden?
Zunächst müssen wir eine Gruppe von Zeichen aus den eingegebenen Strings erstellen. Dann verwenden Sie die Methode Set equals(), um zu prüfen, ob sie die gleichen Zeichen enthalten oder nicht. Hier ist ein einfaches Programm, um zu prüfen, ob zwei Strings mit gleichen Zeichen erstellt wurden.
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 set1 = s1.chars().mapToObj(c -> (char) c).collect(Collectors.toSet());
Set set2 = s2.chars().mapToObj(c -> (char) c).collect(Collectors.toSet());
System.out.println(set1.equals(set2));
}
}
Wie lese ich zwei Benutzereingaben für Strings und prüfe, ob der erste den zweiten enthält?
Dies ist ein einfaches String-Programm und wir können die Methode String contains() verwenden, um zu prüfen, ob die angegebene Zeichenfolge Teil dieser Zeichenfolge ist. Allerdings müssen wir die Klasse Scanner verwenden, um Benutzereingaben zu lesen.
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;
}
}
Hier ist eine Beispiel-Output des obigen Programms:
Enter First String:
Pankaj
Enter Second String:
an
Pankaj contains an = true
Wie tauscht man zwei Strings ohne eine dritte Variable?
Wir können es mit der String-Programm substring()-Methode machen. Hier ist ein einfacher Code-Schnipsel, der dies zeigt:
String s1 = "abc";
String s2 = "def";
s1 = s1.concat(s2);
s2 = s1.substring(0,s1.length()-s2.length());
s1 = s1.substring(s2.length());
Was ist, wenn wir eine Funktion schreiben müssen, um dies zu tun? Da String unveränderlich ist, wird die Änderung der Werte der String-Referenzen in der Methode verschwinden, sobald die Methode endet. Außerdem können wir in Java nicht mehrere Objekte aus einer Methode zurückgeben. Wir müssen also einen Container erstellen, der die Eingabestrings aufnimmt, und dann die obige Logik in der Methode ausführen. Der folgende Code zeigt, wie dies geschehen kann, auch wenn es komplex aussehen mag, aber die Logik ist dieselbe wie oben.
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;
}
}
Beispiel Output
Enter First String:
Java
Enter Second String:
Python
First String = Java, Second String = Python
First String = Python, Second String = Java
Wie schreibe ich ein Programm, um das erste nicht wiederholte Zeichen aus einem Eingabe-String zu finden?
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 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;
}
}
Wie zwei Möglichkeiten nennen, um zu überprüfen, ob ein String nur aus Ziffern besteht?
We can use regular expression to check if a String is numeric or not. Another way is to parse it to Long and if it’s a non numeric string then it will throw 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);
}
}
}
Wie führt man eine Deep Copy für String durch?
String ist unveränderlich, daher müssen wir uns keine Gedanken über Deep oder Shallow Copy machen. Wir können einfach den Zuweisungsoperator (=) verwenden, um einen String auf einen anderen zu kopieren.
