Il tipo di dati String è la classe più ampiamente utilizzata nella programmazione Java. Ecco perché i programmi basati su String sono utilizzati durante i colloqui Java per valutare le competenze di codifica.
Programmi String in Java
Qui fornisco alcuni programmi su stringhe in Java per aiutarti a migliorare le tue competenze di codifica. Ti prego di cercare di risolvere questi problemi da solo prima di controllare le risposte, per imparare in modo più efficace. Sto cercando di utilizzare tutte le ultime funzionalità introdotte in Java, come Stream, espressioni lambda, interfacce funzionali, ecc.
Come ottenere caratteri distinti e il loro conteggio in una stringa?
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<>();
// utilizzando il metodo merge di Map da Java 8
for (char c : input.toCharArray())
charsWithCountMap.merge(c, 1, Integer::sum);
System.out.println(charsWithCountMap);
// un altro modo utilizzando le ultime migliorie di Java e senza ciclo for, anche se un po' complesso.
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);
}
}
Scrivi un programma Java per invertire una stringa?
Ci sono molti modi per invertire una stringa. Alcuni dei più comuni sono:
- Metodo
reverse()di StringBuilder/StringBuffer - Utilizzando un array di char/byte e attraversandolo in direzione inversa per popolare la stringa risultato
Tuttavia, se non sei sicuro del contenuto della stringa di input, utilizza sempre il metodo reverse() integrato di StringBuilder. Perché utilizzare un array di char e byte potrebbe produrre risultati indesiderati. Ho fornito una spiegazione completa per questo in Invertire una stringa 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);
}
}
Come verificare se una stringa è un palindromo?
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);
}
}
Come rimuovere tutte le occorrenze di un dato carattere dalla stringa di input?
Non esiste una funzione di rimozione nella classe String, ma possiamo utilizzare replaceAll() in questo caso. Ecco il programma semplice che mostra come farlo.
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);
}
}
Come dimostrare programmaticamente che String è immutabile?
Sappiamo che String è immutabile in Java, tuttavia i nuovi sviluppatori possono ancora confondersi a riguardo. Cerchiamo di capire il motivo di questa confusione.
String s1 = "Java";
s1 = "Python";
Nel frammento di codice sopra, possiamo dire che il valore di s1 è cambiato ed è un oggetto String. Quindi come possiamo dire che String è immutabile? Il punto più importante da capire è come vengono create le Stringhe in Java. Quando creiamo una Stringa utilizzando una letterale di stringa, non cambia il valore della Stringa originale. Crea una nuova Stringa nel pool delle stringhe e cambia il riferimento della variabile. Quindi il valore della stringa originale non cambia mai ed è per questo che le Stringhe sono immutabili. Il programma sottostante dimostra la nostra affermazione, leggi i commenti per comprendere correttamente il concetto.
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 valore è stato cambiato sopra, quindi come è immutabile String?
//beh, in caso di cui è stato creato un nuovo String "Python" nel pool
//s1 ora si riferisce al nuovo String nel pool
//MA, il String originale "Java" è ancora invariato e rimane nel pool
//s2 si riferisce ancora al String originale "Java" nel pool
// prova che s1 e s2 hanno riferimenti diversi
System.out.println(s1 == s2);
System.out.println(s2);
// stampa "Java" supportando il fatto che il valore originale del String è invariato, quindi String è immutabile
}
}
Scrivi un programma per contare il numero di parole in una stringa?
La soluzione semplice a questo programma sembra essere input.split(" ").length ma questo non funzionerà se la tua stringa non è correttamente formattata e contiene spazi vuoti iniziali e finali, duplica spazi multipli e schede. Fortunatamente la funzione split() di String prende un espressione regolare come argomento e possiamo usarlo per contare il numero di parole in una stringa.
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); //non funzionerà con le schede e spazi multipli
String trimmedLine = line.trim();
int count = trimmedLine.isEmpty() ? 0 : trimmedLine.split("\\s+").length;
System.out.println(count);
}
}
Scrivi un programma per verificare se due stringhe sono create con gli stessi caratteri?
Innanzitutto dovremo creare un insieme di caratteri dalle stringhe di input. Quindi usa il metodo equals() dell’insieme per verificare se contengono gli stessi caratteri o meno. Ecco un programma semplice per verificare se due stringhe sono create con gli stessi caratteri.
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));
}
}
Leggi due input da utente e verifica se il primo contiene il secondo?
Questo è un programma semplice e possiamo utilizzare il metodo contains() della stringa per verificare se una stringa specificata fa parte di questa stringa. Tuttavia, dovremo utilizzare la classe Scanner per leggere gli input dell’utente.
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;
}
}
Ecco un esempio di output del programma sopra:
Enter First String:
Pankaj
Enter Second String:
an
Pankaj contains an = true
Come scambiare due stringhe senza utilizzare una variabile di supporto?
Possiamo farlo usando il metodo substring() della classe String. Ecco uno snippet di codice semplice per mostrare questo:
String s1 = "abc";
String s2 = "def";
s1 = s1.concat(s2);
s2 = s1.substring(0,s1.length()-s2.length());
s1 = s1.substring(s2.length());
Cosa succede se dobbiamo scrivere una funzione per farlo? Poiché la classe String è immutabile, le modifiche nei valori dei riferimenti String nel metodo verranno perse non appena il metodo termina. Inoltre non possiamo restituire più oggetti da un metodo in Java. Quindi dovremo creare un contenitore per contenere le stringhe di input e quindi eseguire la logica sopra descritta nel metodo. Il codice seguente mostra come questo possa essere fatto, anche se potrebbe sembrare complesso ma la logica è la stessa di prima.
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;
}
}
Output di esempio:
Enter First String:
Java
Enter Second String:
Python
First String = Java, Second String = Python
First String = Python, Second String = Java
Scrivi un programma per trovare il primo carattere non ripetuto dalla stringa di input?
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;
}
}
Fornire due modi per verificare se una stringa contiene solo cifre?
Possiamo usare le espressioni regolari per verificare se una stringa è numerica o meno. Un altro modo è analizzarla in Long e se è una stringa non numerica allora solleverà un 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);
}
}
}
Come eseguire una copia profonda per String?
La stringa è immutabile, quindi non c’è bisogno di preoccuparsi della copia profonda o della copia superficiale. Possiamo semplicemente usare l’operatore di assegnazione (=) per copiare una stringa in un’altra. Leggi ulteriori dettagli su Copia di stringhe in Java.
Puoi scaricare gli esempi dal mio Repository GitHub.
Source:
https://www.digitalocean.com/community/tutorials/string-programs-in-java