La classe String est la plus largement utilisée dans la programmation Java. C’est pourquoi les programmes de chaînes de caractères sont utilisés lors des entretiens Java pour évaluer les compétences en codage.
Programmes de chaînes de caractères en Java
Ici, je fournis quelques programmes de chaînes de caractères en Java pour vous aider à perfectionner vos compétences en codage. Veuillez essayer de résoudre ces questions par vous-même avant de vérifier les réponses pour apprendre de manière plus efficace. J’essaie d’utiliser toutes les dernières fonctionnalités introduites en Java, telles que Stream, expressions lambda, interfaces fonctionnelles, etc.
Comment obtenir les caractères distincts et leur compte dans une chaîne de caractères ?
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<>();
// en utilisant la méthode merge de la classe Map de Java 8
for (char c : input.toCharArray())
charsWithCountMap.merge(c, 1, Integer::sum);
System.out.println(charsWithCountMap);
// une autre façon d'utiliser les dernières améliorations de Java, sans boucle for, un peu plus complexe cependant
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);
}
}
Écrivez un programme Java pour inverser une chaîne de caractères?
Il existe plusieurs façons d’inverser une chaîne de caractères. Certaines des plus courantes sont :
- La méthode
reverse()de StringBuilder/StringBuffer - Utiliser un tableau de caractères/octets et parcourir dans la direction inverse pour remplir la chaîne de résultat
Cependant, si vous n’êtes pas sûr du contenu de la chaîne d’entrée, utilisez toujours la méthode intégrée reverse() de StringBuilder. Car l’utilisation de tableaux de caractères et d’octets peut produire des résultats non souhaités. J’ai fourni une explication complète à ce sujet dans Inverser une chaîne en 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);
}
}
Comment vérifier si une chaîne est un palindrome?
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);
}
}
Comment supprimer toutes les occurrences d’un caractère donné d’une chaîne d’entrée?
Il n’y a pas de fonction de suppression dans la classe String, mais nous pouvons utiliser replaceAll() dans ce cas. Voici un programme simple montrant comment le faire.
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);
}
}
Comment prouver que la classe String est immuable de manière programmatique ?
Nous savons que la classe String est immuable en java, cependant les nouveaux développeurs sont encore confus à ce sujet. Essayons de comprendre la raison de cette confusion.
String s1 = "Java";
s1 = "Python";
Dans l’exemple de code ci-dessus, nous pouvons dire que la valeur de s1 a été modifiée et c’est un objet de type String. Comment pouvons-nous donc dire que la classe String est immuable ? Le point le plus important à comprendre est comment les Strings sont créées en java. Lorsque nous créons une String en utilisant une littérale de chaîne, cela ne modifie pas la valeur de la String d’origine. Cela crée une nouvelle String dans le pool de chaînes et change la référence de la variable. Ainsi, la valeur de la chaîne d’origine n’est jamais modifiée et c’est pourquoi les Strings sont immuables. Le programme ci-dessous prouve notre affirmation, lisez les commentaires pour comprendre correctement le concept.
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
}
}
Écrivez un programme pour compter le nombre de mots dans une chaîne de caractères?
La solution simple à ce programme semble être input.split(" ").length mais cela ne fonctionnera pas si votre chaîne de caractères n’est pas correctement formatée et qu’elle contient des espaces avant et après, des espaces multiples et des tabulations. Heureusement, la fonction split() de la classe String prend une expression régulière comme argument et nous pouvons l’utiliser pour compter le nombre de mots dans une chaîne de caractères.
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); //ne fonctionnera pas avec des tabulations et des espaces multiples
String trimmedLine = line.trim();
int count = trimmedLine.isEmpty() ? 0 : trimmedLine.split("\\s+").length;
System.out.println(count);
}
}
Écrivez un programme pour vérifier si deux chaînes sont créées avec les mêmes caractères?
Tout d’abord, nous devrons créer un ensemble de caractères à partir des chaînes d’entrée. Ensuite, utilisez la méthode Set equals() pour vérifier s’ils contiennent les mêmes caractères ou non. Voici un programme simple pour vérifier si deux chaînes sont créées avec les mêmes caractères.
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));
}
}
Lisez deux entrées utilisateur de type String et vérifiez si la première contient la seconde?
C’est un programme simple et nous pouvons utiliser la méthode String contains() pour vérifier si la chaîne spécifiée fait partie de cette chaîne. Cependant, nous devrons utiliser la classe Scanner pour lire les entrées utilisateur.
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;
}
}
Voici un exemple de sortie du programme ci-dessus:
Enter First String:
Pankaj
Enter Second String:
an
Pankaj contains an = true
Comment échanger deux chaînes sans utiliser de variable temporaire?
Nous pouvons le faire en utilisant la méthode substring() de String. Voici un extrait de code simple pour illustrer ceci :
String s1 = "abc";
String s2 = "def";
s1 = s1.concat(s2);
s2 = s1.substring(0,s1.length()-s2.length());
s1 = s1.substring(s2.length());
Et si nous devons écrire une fonction pour faire cela ? Puisque String est immuable, le changement de valeurs des références String dans la méthode disparaîtra dès que la méthode se termine. De plus, nous ne pouvons pas retourner plusieurs objets à partir d’une méthode en java. Nous devrons donc créer un conteneur pour contenir les chaînes d’entrée, puis exécuter la logique ci-dessus dans la méthode. Le code ci-dessous montre comment cela peut être fait, bien qu’il puisse sembler complexe, mais la logique est la même que ci-dessus.
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;
}
}
Sortie d’exemple :
Enter First String:
Java
Enter Second String:
Python
First String = Java, Second String = Python
First String = Python, Second String = Java
Écrivez un programme pour trouver le premier caractère non répété dans une chaîne d’entrée ?
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;
}
}
Fournissez deux façons de vérifier si une chaîne ne contient que des chiffres ?
Nous pouvons utiliser une expression régulière pour vérifier si une chaîne est numérique ou non. Une autre façon est de la convertir en Long et si c’est une chaîne non numérique, elle lancera 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);
}
}
}
Comment effectuer une copie profonde pour une chaîne de caractères ?
La chaîne de caractères étant immuable, nous n’avons pas besoin de nous préoccuper de la copie profonde ou de la copie superficielle. Nous pouvons simplement utiliser l’opérateur d’assignation (=) pour copier une chaîne dans une autre. Consultez plus de détails sur la copie de chaîne Java.
Vous pouvez télécharger les exemples depuis mon Dépôt GitHub.
Source:
https://www.digitalocean.com/community/tutorials/string-programs-in-java