String ist die am häufigsten verwendete Klasse in der Java-Programmierung. Deshalb werden String-Programme in Java-Interviews verwendet, um die Codierungskenntnisse zu überprüfen.
String-Programme in Java
Hier stelle ich einige String-Programme in Java zur Verfügung, um Ihnen beim Auffrischen Ihrer Codierungskenntnisse zu helfen. Versuchen Sie bitte, diese Fragen selbst zu lösen, bevor Sie die Antworten überprüfen, um auf eine bessere Weise zu lernen. Ich versuche, alle neuesten Funktionalitäten zu nutzen, die in Java eingeführt wurden, wie z.B. Stream, Lambda-Ausdrücke, funktionale Schnittstellen usw.
Wie können distinkte Zeichen und ihre Anzahl in einem String erhalten werden?
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<>();
// Verwendung der Map-Merge-Methode ab Java 8
for (char c : input.toCharArray())
charsWithCountMap.merge(c, 1, Integer::sum);
System.out.println(charsWithCountMap);
// Eine andere Möglichkeit unter Verwendung der neuesten Java-Verbesserungen und ohne Schleifen, obwohl etwas komplex.
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);
}
}
Schreiben Sie ein Java-Programm, um einen String umzukehren?
Es gibt viele Möglichkeiten, einen String umzukehren. Einige der üblichen Methoden sind:
- StringBuilder/StringBuffer
reverse()Methode - Verwendung von char/byte Array und Traversieren in umgekehrter Richtung und Befüllen des Ergebnisstrings
Wenn Sie jedoch nicht sicher sind, was den Inhalt des Eingabe-Strings betrifft, verwenden Sie immer die integrierte reverse() Methode von StringBuilder. Die Verwendung von char- und Byte-Arrays kann nämlich unerwünschte Ergebnisse erzeugen. Eine vollständige Erklärung dazu habe ich in Reverse a String in Java bereitgestellt.
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?
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);
}
}
Wie entfernt man alle Vorkommen eines bestimmten Zeichens aus einem Eingabe-String?
Es gibt keine Entfernungsfunktion in der String-Klasse, aber wir können replaceAll() in diesem Fall verwenden. Hier ist das einfache Programm, das zeigt, wie es gemacht wird.
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 kann man programmgesteuert beweisen, dass String unveränderlich ist?
Wir wissen, dass String in Java unveränderlich ist, aber neue Entwickler sind immer noch verwirrt darüber. Versuchen wir, den Grund für diese Verwirrung zu verstehen.
String s1 = "Java";
s1 = "Python";
In obigem Code-Schnipsel 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 zu verstehen ist, wie Strings in Java erstellt werden. Wenn wir einen String mit einem Zeichenkettenliteral erstellen, ändert es nicht den Wert des originalen Strings. Es erstellt einen neuen String im String-Pool und ändert die Referenz der Variablen. Daher wird der ursprüngliche Stringwert nie geändert, und deshalb sind Strings unveränderlich. Das folgende Programm beweist unsere Aussage, lesen Sie die Kommentare für ein besseres Verständnis des Konzepts.
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-Wert wurde oben geändert, daher ist der String jetzt unveränderlich?
//Nun, in diesem Fall wurde ein neuer String "Python" im Pool erstellt
//s1 verweist jetzt auf den neuen String im Pool
//ABER der originale String "Java" bleibt unverändert und verbleibt im Pool
//s2 verweist weiterhin auf den ursprünglichen String "Java" im Pool
//Beweis dafür, dass s1 und s2 unterschiedliche Referenzen haben
System.out.println(s1 == s2);
System.out.println(s2);
//gibt "Java" aus, was die Tatsache unterstützt, dass der originale String unverändert ist, daher ist der String unveränderlich
}
}
Programm zum Zählen der Wörter in einem String schreiben?
Die einfache Lösung für dieses Programm scheint input.split(" ").length zu sein, aber dies funktioniert nicht, wenn Ihr String nicht korrekt formatiert ist und führende und abschließende Leerzeichen, doppelte Leerzeichen und Tabs enthält. Glücklicherweise akzeptiert die String split()-Funktion einen regulären Ausdruck als Argument, den wir verwenden können, um die Anzahl der Wörter in einem String 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); //funktioniert nicht mit Tabs und mehreren Leerzeichen
String trimmedLine = line.trim();
int count = trimmedLine.isEmpty() ? 0 : trimmedLine.split("\\s+").length;
System.out.println(count);
}
}
Programmieren Sie ein Programm, um zu überprüfen, ob zwei Strings mit denselben Zeichen erstellt wurden?
Zunächst müssen wir eine Menge von Zeichen aus den Eingabezeichenketten erstellen. Verwenden Sie dann die Methode Set equals(), um zu überprüfen, ob sie dieselben Zeichen enthalten oder nicht. Hier ist ein einfaches Programm, um zu überprüfen, ob zwei Zeichenketten mit denselben 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<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));
}
}
Lesen Sie zwei Zeichenkettenbenutzereingaben und überprüfen Sie, ob die erste die zweite enthält?
Dies ist ein einfaches Programm, und wir können die Methode String contains() verwenden, um zu überprüfen, ob die angegebene Zeichenkette Teil dieser Zeichenkette ist. Allerdings müssen wir die Scanner-Klasse verwenden, um die 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 Beispielausgabe des obigen Programms:
Enter First String:
Pankaj
Enter Second String:
an
Pankaj contains an = true
Wie tauscht man zwei Strings aus, ohne eine dritte Variable zu verwenden?
Wir können dies mit der String-Methode substring() tun. Hier ist ein einfacher Codeausschnitt, 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, werden die Änderungen der String-Verweise in der Methode verschwinden, sobald die Methode endet. Außerdem können wir in Java keine mehreren Objekte aus einer Methode zurückgeben. Daher müssen wir einen Container erstellen, um die Eingabestrings zu halten, und dann die oben genannte Logik in der Methode ausführen. Der unten gezeigte Code zeigt, wie dies gemacht werden kann, obwohl er 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-Ausgabe:
Enter First String:
Java
Enter Second String:
Python
First String = Java, Second String = Python
First String = Python, Second String = Java
Schreiben Sie ein Programm, um das erste nicht wiederholte Zeichen aus dem 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<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;
}
}
Geben Sie zwei Möglichkeiten an, um zu überprüfen, ob ein String nur aus Ziffern besteht?
Wir können reguläre Ausdrücke verwenden, um zu überprüfen, ob ein String numerisch ist oder nicht. Eine andere Möglichkeit besteht darin, ihn zu Long zu analysieren, und wenn es sich um einen nicht numerischen String handelt, wird eine NumberFormatException ausgelöst.
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 einen String durch?
Ein String ist unveränderlich, daher müssen wir uns keine Gedanken über Deep Copy oder Shallow Copy machen. Wir können einfach den Zuweisungsoperator (=) verwenden, um einen String in einen anderen zu kopieren. Weitere Details finden Sie unter Java String kopieren.
Sie können die Beispiele von meinem GitHub-Repository herunterladen.
Source:
https://www.digitalocean.com/community/tutorials/string-programs-in-java