A classe String é a mais amplamente utilizada na programação Java. É por isso que programas de String são empregados em entrevistas de emprego em Java para avaliar as habilidades de codificação.
Programas de String em Java
Estou fornecendo aqui 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 mais eficaz. Estou tentando utilizar todas as funcionalidades mais recentes introduzidas no Java, como Stream, expressões lambda, interfaces funcionais, etc.
Como obter caracteres distintos e a contagem deles 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 do Java 8
for (char c : input.toCharArray())
charsWithCountMap.merge(c, 1, Integer::sum);
System.out.println(charsWithCountMap);
// outra maneira usando aprimoramentos mais recentes do Java e sem laço for, um pouco mais complexo, 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 inversa para popular a String de resultado
No entanto, se você não tem certeza do conteúdo da String de entrada, sempre use o método reverse() incorporado do 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 da String de entrada?
Não há uma função de remoção na classe String, mas podemos usar replaceAll() neste caso. Aqui está o programa simples que mostra 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 programaticamente que String é imutável?
Sabemos que String é imutável em Java, no entanto, novos desenvolvedores ainda ficam confusos com isso. Vamos tentar entender a razão 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 as Strings são criadas em Java. Quando criamos uma String usando um literal de string, ela não altera o valor da String original. Ela cria uma nova String no pool de strings e altera a referência da variável. Portanto, o valor original da string nunca é alterado, e é por isso que as Strings são imutáveis. O programa abaixo comprova nossa afirmação; leia os comentários para entender corretamente o conceito.
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 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 não é alterado, portanto a 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 formatada corretamente e ela contiver espaços iniciais e finais, espaços múltiplos duplicados e tabulações. Felizmente, a função split() de String aceita uma 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 tabulações 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?
Primeiramente, teremos que criar um conjunto de caracteres a partir das Strings de entrada. Em seguida, utilize o método equals() do conjunto para verificar se eles 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() da String para verificar se a string especificada faz parte desta 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 para o 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() de String. Aqui está um pequeno trecho de código para mostrar 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 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 vários objetos de um método em java. Então teremos que criar um Contêiner para armazenar as strings de entrada e então executar a lógica acima no método. O código abaixo mostra como isso pode ser feito, embora possa parecer complexo, mas a lógica é a mesma que acima.
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 descobrir o primeiro caractere não repetido da 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 parsing para Long e se for uma string não numérica, então ela lançará 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?
A String é imutável, então não precisamos nos preocupar com cópia profunda ou cópia 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