String é a classe mais amplamente utilizada na programação Java. É por isso que programas de String são usados em entrevistas de Java para avaliar as habilidades de codificação.
Programas de String em Java
Aqui estou fornecendo alguns programas de String em Java para ajudar você a aprimorar suas habilidades de codificação. Tente resolver essas perguntas por conta própria antes de verificar as respostas para aprender de uma maneira melhor. Estou tentando usar todas as últimas funcionalidades introduzidas no Java, como Stream, expressões lambda, interfaces funcionais, etc.
Como obter caracteres distintos e sua contagem em uma 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 charsWithCountMap = new HashMap<>();
// usando o método merge do Map a partir do Java 8
for (char c : input.toCharArray())
charsWithCountMap.merge(c, 1, Integer::sum);
System.out.println(charsWithCountMap);
// outra maneira usando as últimas melhorias do Java e sem loop for, um pouco mais complexa, no entanto
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);
}
}
Escreva um programa Java para inverter uma String?
Há muitas maneiras de inverter uma String. Algumas das mais comuns são:
- Método
reverse()de StringBuilder/StringBuffer - Usando um array de char/byte e percorrendo na direção reversa para popular a string de resultado
No entanto, se não tiver certeza do conteúdo da String de entrada, sempre use o método reverse() embutido em StringBuilder. Porque usar array de char e byte pode produzir resultados indesejados. Eu forneci uma explicação completa para isso em Inverter uma String em 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);
}
}
Como verificar se uma String é um Palíndromo?
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);
}
}
Como remover todas as ocorrências de um caractere específico de uma String de entrada?
Não há função de remoção na classe String, mas podemos usar replaceAll() neste caso. Aqui está o programa simples mostrando como fazer isso.
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);
}
}
Como provar que String é imutável programaticamente?
Sabemos que String é imutável em Java, no entanto, novos desenvolvedores ainda se confundem com isso. Vamos tentar entender o motivo dessa confusão.
String s1 = "Java";
s1 = "Python";
No trecho de código acima, podemos dizer que o valor de s1 foi alterado e é um objeto String. Então, como podemos dizer que String é imutável? O ponto mais importante a entender é como Strings são criadas em Java. Quando criamos uma String usando um literal de string, isso não altera o valor da String original. Ele cria uma nova String no pool de strings e altera a referência da variável. Portanto, o valor da string original nunca é alterado e é por isso que as Strings são imutáveis. O programa abaixo prova nossa afirmação, leia os comentários para entender o conceito adequadamente.
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 valor foi alterado acima, então como a String é imutável?
//bem, no caso acima uma nova String "Python" foi criada no pool
//s1 agora está se referindo à nova String no pool
//MAS, a String original "Java" ainda está inalterada e permanece no pool
//s2 ainda está se referindo à String original "Java" no pool
//prova de que s1 e s2 têm referências diferentes
System.out.println(s1 == s2);
System.out.println(s2);
//imprime "Java" apoiando o fato de que o valor original da String está inalterado, portanto, String é imutável
}
}
Escreva um programa para contar o número de palavras em uma String?
A solução simples para este programa parece ser input.split(" ").length mas isso não funcionará se sua string não estiver devidamente formatada e ela contiver espaços em branco no início e no final, espaços múltiplos duplicados e guias. Felizmente a função split() da String aceita expressão regular como argumento e podemos usá-la para contar o número de palavras em uma string.
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); //não funcionará com guias e espaços múltiplos
String trimmedLine = line.trim();
int count = trimmedLine.isEmpty() ? 0 : trimmedLine.split("\\s+").length;
System.out.println(count);
}
}
Escreva um programa para verificar se duas Strings são criadas com os mesmos caracteres?
Primeiro, teremos que criar um conjunto de caracteres a partir das Strings de entrada. Em seguida, use o método equals() do conjunto para verificar se elas contêm os mesmos caracteres ou não. Aqui está um programa simples para verificar se duas strings são criadas com os mesmos caracteres.
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));
}
}
Leia duas Strings de entrada do usuário e verifique se a primeira contém a segunda?
Este é um programa simples e podemos usar o método contains() de String para verificar se a string especificada faz parte dessa string. No entanto, teremos que usar a classe Scanner para ler as entradas do usuário.
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;
}
}
Aqui está uma saída de exemplo do programa acima:
Enter First String:
Pankaj
Enter Second String:
an
Pankaj contains an = true
Como trocar duas Strings sem usar uma terceira variável?
Podemos fazer isso usando o método substring() da classe String. Aqui está um trecho de código simples para demonstrar isso:
String s1 = "abc";
String s2 = "def";
s1 = s1.concat(s2);
s2 = s1.substring(0,s1.length()-s2.length());
s1 = s1.substring(s2.length());
E se precisarmos escrever uma função para fazer isso? Como a classe String é imutável, as alterações nos valores das referências de String no método serão perdidas assim que o método terminar. Além disso, não podemos retornar objetos múltiplos de um método em Java. Portanto, teremos que criar um recipiente para armazenar as strings de entrada e depois executar a lógica acima no método. O código abaixo mostra como isso pode ser feito, embora possa parecer complexo, a lógica é a mesma que a mencionada anteriormente.
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;
}
}
Saída de Exemplo:
Enter First String:
Java
Enter Second String:
Python
First String = Java, Second String = Python
First String = Python, Second String = Java
Escreva um programa para encontrar o primeiro caractere não repetido em uma String de entrada?
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;
}
}
Fornecer duas maneiras de verificar se uma String contém apenas dígitos?
Podemos usar expressão regular para verificar se uma String é numérica ou não. Outra maneira é fazer o parse para Long e, se for uma string não numérica, lançará uma 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);
}
}
}
Como realizar uma cópia profunda de uma String?
String é imutável, então não precisamos nos preocupar com cópia profunda ou rasa. Podemos simplesmente usar o operador de atribuição (=) para copiar uma string para outra. Leia mais detalhes em Cópia de String em Java.
Você pode baixar os exemplos do meu Repositório no GitHub.
Source:
https://www.digitalocean.com/community/tutorials/string-programs-in-java