![]() |
|
||||
![]() Diga adeus às planilhas do Excel e tenha 100% de controle sobre suas contas a pagar e a receber, gestão de receitas e despesas, cadastro de clientes e fornecedores com fotos e histórico de atendimentos. Código fonte completo e funcional, com instruções para instalação e configuração do banco de dados MySQL. Fácil de modificar e adicionar novas funcionalidades. Clique aqui e saiba mais |
Você está aqui: Java ::: Desafios e Lista de Exercícios Resolvidos ::: Estruturas de Dados - Listas Ligadas |
Como remover no final de uma lista ligada em Java - Escreva um programa Java que cria uma lista dinamicamente encadeada - Desafio de Programação Resolvido em JavaQuantidade de visualizações: 664 vezes |
Pergunta/Tarefa: Escreva um programa Java que cria uma lista dinamicamente encadeada (lista singularmente encadeada) e peça para o usuário inserir 5 elementos do tipo inteiro. Em seguida faça a remoção do nó no final da lista ligada e retorne o seu valor. Sua saída deve ser parecida com: Inserindo 5 valores na lista Informe o 1.o valor: 8 Informe o 2.o valor: 5 Informe o 3.o valor: 3 Informe o 4.o valor: 9 Informe o 5.o valor: 4 Valores na lista: 8 -> 5 -> 3 -> 9 -> 4 -> null Removendo no final da lista O nó removido foi: 4 Valores na lista novamente: 8 -> 5 -> 3 -> 9 -> null Na saída podemos ver que a lista contém os valores 8, 5, 3, 9 e 4. Depois que o nó no final é removido, os elementos da lista ficam 8, 5, 3 e 9. Veja a resolução comentada deste exercício usando Java: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- package estudos; import java.util.Scanner; // classe interna usada para representar um // nó na lista ligada class No { int valor; // valor do nó No proximo; // aponta para o novo nó // construtor cheio da classe No public No(int valor, No proximo) { this.valor = valor; this.proximo = proximo; } // construtor vazio da classe No public No() { this.valor = 0; this.proximo = null; } } public class Estudos { // vamos criar uma referência para o início da lista static No inicio = null; public static void main(String args[]){ // para ler a entrada do usuário Scanner entrada = new Scanner(System.in); // vamos inserir 5 valores inteiros na lista ligada int valor; System.out.println("Inserindo 5 valores na lista\n"); for (int i = 0; i < 5; i++) { System.out.print("Informe o " + (i + 1) + ".o valor: "); valor = Integer.parseInt(entrada.nextLine()); // vamos inserir este valor no final da lista inserirFinal(valor); } // vamos exibir os valores na lista ligada System.out.print("\nValores na lista: "); exibirLista(); // vamos remover o nó no final da lista ligada System.out.println("\nRemovendo no final da lista"); No removido = removerFinal(); System.out.println("O nó removido foi: " + removido.valor); // vamos exibir os valores na lista ligada System.out.print("\nValores na lista novamente: "); exibirLista(); } // método que permite remover e retornar um nó no final da lista public static No removerFinal(){ // a lista está vazia? if (inicio == null){ return null; } // precisamos de nós auxiliares para chegar até o nó // antes do último No p = inicio, q = null, proximo = inicio.proximo; // só existe um nó na lista? if (proximo == null) { inicio = null; // retorna o nó removido return p; } // existe mais de um nó na lista while((proximo = p.proximo) != null) { // avançamos os ponteiros dos nós q = p; p = proximo; } // ajustamos o próximo como null q.proximo = null; // retorna o nó removido return p; } // função que permite adicionar um nó no final da // lista ligada public static void inserirFinal(int valor) { // vamos apontar para o nó inicial No atual = inicio; // criamos um novo nó No novo = criarNo(valor); // a lista ligada ainda está vazia? if (atual == null){ // inicio recebe o novo nó inicio = novo; } else { // temos um ou mais nós na lista ligada // vamos localizar o último nó while (atual.proximo != null) { atual = atual.proximo; } // encontramos o último nó. Agora vamos inserir // o novo nó depois dele atual.proximo = novo; } } // função usada para construir e retornar um novo nó public static No criarNo(int valor) { // cria o novo nó No no = new No(valor, null); // retorna o nó criado return no; } // função usada para percorrer a lista ligada e // exibir os valores contidos em seus nós public static void exibirLista() { // vamos apontar para o início da lista No temp = inicio; // a lista está vazia? if (temp == null) { System.out.println("A lista está vazia."); } else { // esse laço se repete enquanto tempo for // diferente de null while (temp != null) { // vamos mostrar o valor desse nó System.out.print(temp.valor + " -> "); // avança para o próximo nó temp = temp.proximo; } // mostra o final da lista System.out.println("null"); } } } |
![]() |
Java ::: Desafios e Lista de Exercícios Resolvidos ::: Recursão (Recursividade) |
Exercícios Resolvidos de Java - Um método recursivo que recebe uma String e retorna a quantidade de letras maiúsculas encontradasQuantidade de visualizações: 5845 vezes |
Pergunta/Tarefa: Escreva um método recursivo que recebe uma palavra ou frase e retorna a quantidade de caracteres (letras) maiúsculos. Seu método deverá possuir a seguinte assinatura: public static int contarMaiusculas(String frase){ // sua implementação aqui } Sua saída deverá ser parecida com: Digite uma palavra ou frase: Arquivo de Códigos A palavra ou frase contém 2 letras maiúsculas Veja a resolução comentada deste exercício usando Java console: Observação importante: Este código criará uma cadeia de chamadas recursivas. Cada chamada ao método contarMaiusculas() receberá uma cópia menor da palavra ou frase fornecida. Quando a última chamada recursiva do método receber uma string vazia, a cadeia começa a retornar. Note que os valores acumulados nas várias chamadas ao método vão sendo acumulados na variável quantidade. ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- package exercicio; import java.util.Scanner; public class Exercicio { public static void main(String[] args) { // cria um novo objeto da classe Scanner Scanner entrada = new Scanner(System.in); // solicita uma palavra ou frase ao usuário System.out.print("Digite uma palavra ou frase: "); // lê a palavra ou frase String frase = entrada.nextLine(); int quantMaiusculas = contarMaiusculas(frase); System.out.println("A palavra ou frase contém " + quantMaiusculas + " letras maiúsculas"); } // método recursivo que recebe uma palavra ou frase e retorna // a quantidade de letras maiúsculas public static int contarMaiusculas(String frase){ /* Este código criará uma cadeia de chamadas recursivas. Cada * chamada ao método contarMaiusculas() receberá uma cópia menor * da palavra ou frase fornecida. Quando a última chamada recursiva do * método receber uma string vazia, a cadeia começa a retornar. Note * que os valores acumulados nas várias chamadas ao método vão sendo * acumulados na variável quantidade */ int quantidade = 0; // o tamanho da string é maior que 0? if(frase.length() > 0){ if(Character.isUpperCase(frase.charAt(0))){ quantidade = 1 + contarMaiusculas(frase.substring(1)); } else{ quantidade = contarMaiusculas(frase.substring(1)); } } return quantidade; } } |
Java ::: Dicas & Truques ::: Strings e Caracteres |
Java para iniciantes - Como pesquisar uma substring em uma string e retornar sua posição inicialQuantidade de visualizações: 93 vezes |
Nesta dica mostrarei como é possível usar o método indexOf() da classe String para obter o índice (começando em 0) da primeira ocorrência de uma substring em uma string. Se a substring não for encontrada, o retorno será -1. Veja o código completo para o exemplo: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- package arquivodecodigos; public class Estudos{ public static void main(String[] args){ String frase = "Programar em Java é muito bom"; System.out.println("Frase: " + frase); // verifica se a frase contém a palavra Java int res = frase.indexOf("Java"); if(res > 0){ System.out.println("A substring foi encontrada " + " na posicao (índice): " + res); } else{ System.out.println("A substring nao foi encontrada"); } System.exit(0); } } Ao executar este código Java nós teremos o seguinte resultado: Frase: Programar em Java é muito bom A substring foi encontrada na posicao (índice): 13 |
Java ::: Dicas & Truques ::: Expressões Regulares |
Como usar expressões regulares em Java - Expressões regulares para iniciantesQuantidade de visualizações: 48585 vezes |
O suporte a expressões regulares ou regex tem sido parte da plataforma Java desde a versão 1.4. Contidas no pacote java.util.regex, as classes regex suportam a comparação de padrões de forma similar à linguagem Perl, mas, usando classes e a sintáxe da linguagem Java. Todo o pacote se limita a três classes: Pattern, Matcher e PatternSyntaxException. A versão 1.5 introduziu a interface MatchResult. Use as duas classes Pattern e Matcher juntas. Defina e expressão regular com a classe Pattern. Então use a classe Matcher para verificar o padrão em relação à fonte de entrada. Uma exceção é lançada quando o padrão tem um erro de sintáxe na expressão. Estas classes não possuem construtores. Em vez disso, compilamos uma expressão regular para obter um padrão, e então usamos o Pattern retornado para obter seu Matcher baseado na fonte de entrada: Pattern pattern = Pattern.compile(<regular expression>); Matcher matcher = pattern.matcher(<input source>); Uma vez que tenhamos um Matcher, tipicamente processamos a fonte de entrada a fim de encontrarmos as similaridades contidas. Usa-se o método find() para localizar similaridades do padrão na fonte de entrada. Cada chamada a find() continua a partir do ponto onde a última chamada parou, ou na posição 0 para a primeira chamada. As similaridades encontradas são retornadas pelo método group(): ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- while(matcher.find()){ System.out.printf"Found: \"%s\" from %d to %d.%n", matcher.group(), matcher.start(), matcher.end()); } O código a seguir mostra um programa básico de expressões regulares, que pede ao usuário que informe tanto a expressão regular quanto a string que será comparada: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- import java.util.regex.*; import java.io.*; public class Regex{ public static void main(String args[]){ Console console = System.console(); // Obtém a expressão regular String regex = console.readLine("%nInforme a expressão: "); Pattern pattern = Pattern.compile(regex); // Obtém a entrada String source = console.readLine("Informe a entrada: "); Matcher matcher = pattern.matcher(source); // Mostra as similaridades while(matcher.find()){ System.out.printf("Encontrado: \"%s\" de %d à %d.%n", matcher.group(), matcher.start(), matcher.end()); } } } Mas, o que realmente é uma expressão regular? A classe Pattern fornece detalhes mais profundos, mas, basicamente uma expressão regular é uma sequência de caracteres que tenta encontrar semelhanças em outra sequencia de caracteres. Por exemplo, podemos procurar o padrão literal de "eles" duplos "ll" na string "Hello, World". O programa anterior encontraria o padrão "ll" começando na posição 2 e terminando na posição 4. A posição final é a posição do próximo caractere depois do fim do padrão de semelhança. Strings de padrão como "ll" não são muito interessantes, relatando somente onde elas estão literalmente na fonte de entrada. Padrões de expressões regulares podem incluir meta-caracteres especiais. Meta-caracteres fornecem habilidades poderosas de comparação. É possível usar os 15 caracteres "([{\^-$|]})?*+." como meta-caracteres em expressões regulares. Alguns meta-caracteres indicam o agrupamento de caracteres. Por exemplo, os caracteres de colchetes [ e ] permitem especificar um grupo de caracteres nos quais uma similaridade ocorre se qualquer um dos caracteres entre colchetes for encontrado no texto. Por exemplo, o padrão "co[cl]a" retornará similaridade com "coca" e "cola". Ele não se igualará a "cocla", uma vez que [] é usado para igualar apenas um caractere. Veremos mais sobre quantificadores mais adiante, quando quisermos encontrar alguma coisa múltiplas vezes. Além de tentar encontrar caracteres individuais, podemos usar os colchetes [ e ] para igualar uma faixa de caracteres, tais como as letras de j-z, definidas como [j-z]. Isso pode também ser combinado com um literal string, como em "foo[j-z]" que encontraria "fool", mas não encontraria "food", uma vez que l está na faixa de j à z e d não está. Podemos também usar o caractere ^ para representar negação, com um literal string ou uma faixa. O padrão "foo[^j-z]" encontrará palavras que começam como foo mas que não terminem com uma letra de j à z. Assim a string food agora seria encontrada. Faixas múltiplas podem ser combinadas como em [a-zA-Z] para informar as letras de a à z maiúsculas ou minúsculas. Enquanto literais strings são ótimos como primeira lição sobre expressões regulares, as coisas mais típicas que a maioria das pessoas usam em expressões regulares são as classes de caracteres pré-definidos. É aqui que os meta-caracteres . e \ são importantes. O ponto . é usado para representar qualquer caractere. Assim, a expressão regular ".oney" encontraria money e honey, e qualquer outro conjunto de 5 caracteres que terminem em oney. O caractere \ por sua vez, é usado com outros caracteres para representar um conjunto completo de letras. Por exemplo, enquanto podemos usar [0-9] para representar um conjunto de dígitos, podemos também usar \d. Podemos ainda usar [^0-9] para representar um conjunto de caracteres que não sejam dígitos. Ou podemos usar o caractere \D. Todas estas strings de classes de caracteres são definidas na documentação da plataforma Java para a classe Pattern, uma vez que elas não são fáceis de serem lembradas. Eis aqui um sub-conjunto de algumas classes de caracteres pré-definidos especiais: * \s -- whitespace (espaço em branco) * \S -- non-whitespace (não seja espaço em branco) * \w -- word character [a-zA-Z0-9] (caractere de palavra) * \W -- non-word character (não caractere de palavra) * \p{Punct} -- punctuation (pontuação) * \p{Lower} -- lowercase [a-z] (minúsculas) * \p{Upper} -- uppercase [A-Z] (maiúsculas) Se você quiser usar uma destas strings no programa Regex mostrado acima, você as define como mostrado. \s se iguala ao espaço em branco. Se, contudo, você quiser definir a expressão regular via código, você precisa se lembrar que o caractere \ tem tratamento especial. Devemos escapar a string no código fonte: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- String regexString = "\\s"; Aqui, os caracteres \\ representam uma única barra invertida na string. Há outras strings especiais para representar literais strings: * \t -- tab (tabulação) * \n -- newline (nova linha) * \r -- carriage return (retorno de carro) * \xhh -- hex character 0xhh (caractere hexadecimal) * \uhhhh -- hex character 0xhhhh (caractere hexadecimal) Os quantificadores tornam as expressões regulares mais interessantes, pelo menos quando combinados com outras expresssões tais como classes de caracteres. Por exemplo, se quisermos encontrar uma string de três caracteres de a-z, poderíamos usar o padrão "[a-z][a-z][a-z]". Mas não precisamos fazer isso. Em vez de repetir a string, adicionamos um quantificador após o padrão. Para este exemplo específico, "[a-z][a-z][a-z]" pode ser representado como "[a-z]{3}". Para uma quantidade específica, o número vai dentro das chaves {}. Podemos também usar ?, * ou + para representar zero ou uma vez, zero ou mais vezes, ou uma ou mais vezes, respectivamente. O padrão [a-z]? encontra um caractere de a-z zero ou uma vez. O padrão [a-z]* encontra um caractere de a-z zero ou mais vezes. O padrão [a-z]+ encontra um caractere de a-z uma ou mais vezes. Use quantificador com cuidado, prestando muita atenção aos quantificadores que permitem zero similaridades. Quando usamos as chaves {} como quantificadores, devemos definir uma faixa. {3} significa exatamente 3 vezes, mas poderíamos dizer {3,}, que define no mínimo três vezes. O quantificador {3,5} encontra um padrão de 3 a 5 vezes. Há mais sobre expressões regulares que o que mostramos aqui. A arte de usá-las envolve descobrir a expressão regular correta para a situação atual. Tente diferente expressões com o programa Regex e veja se ele encontra o que você está esperando. Certifique-se de tentar diferentes quantificadores para entender realmente suas diferenças. Observe que quantificadores geralmente tentam incluir o maior número de caracteres para uma similaridade possível. |
Java ::: Dicas & Truques ::: Arquivos e Diretórios |
Como verificar se um diretório já existe em Java usando o método exists() da classe FileQuantidade de visualizações: 32 vezes |
Em algumas situações nós precisamos verificar se um determinado diretório existe antes de efetuarmos alguma tarefa, talvez gravar um novo arquivo ou listar os arquivos contidos em um diretório. Para isso nós podemos o método exists() da classe File da linguagem Java. A classe File faz parte do pacote java.io. A função exists() da classe File retorna um valor true se o diretório existir, e false em caso contrário. Veja um exemplo de seu uso: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- package arquivodecodigos; import java.io.File; public class Estudos{ public static void main(String args[]){ // Este exemplo mostra como verificar a existência de um // diretório usando Java File diretorio = new File("c:\\java"); // vamos checar se o diretório existe if(diretorio.exists()){ System.out.println("Diretorio ja existe no sistema"); } else{ System.out.println("Diretorio ainda nao existe no sistema"); } } } Ao executar este código Java nós teremos o seguinte resultado: O diretório já existe no sistema. |
Java ::: Desafios e Lista de Exercícios Resolvidos ::: Java Básico |
Exercícios Resolvidos de Java - Um programa que lê um salário e concede um aumento de 20% para os salários inferiores a R$ 800,00Quantidade de visualizações: 4727 vezes |
Exercícios Resolvidos de Java - Um programa que lê um salário e concede um aumento de 20% para os salários inferiores a R$ 800,00 Pergunta/Tarefa: A empresa XYZ decidiu conceder um aumento de 20% aos funcionários com salários inferiores a R$ 800,00. Faça um programa Java que solicita o salário do funcionário e mostre o valor do salário reajustado ou uma mensagem, caso o funcionário não tenha direito ao aumento. Sua saída deverá ser parecida com: Informe o salário: 520 O salário informado foi: 520.0 O salário reajustado é: 530.4 Veja a resolução comentada deste exercício usando Java: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- package estudos; import java.util.Scanner; public class Estudos { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // vamos solicitar o salário do funcionário System.out.print("Informe o salário: "); double salario = Double.parseDouble(entrada.nextLine()); System.out.println("O salário informado foi: " + salario); // vamos conceder o aumento ao salário inferior a 800,00 if(salario < 800.00){ double novoSalario = salario + (salario * (2.0 / 100.00)); System.out.println("O salário reajustado é: " + novoSalario); } else{ System.out.println("Não tem direito ao reajuste."); } System.out.println("\n"); } } |
Java ::: Dicas & Truques ::: Arrays e Matrix (Vetores e Matrizes) |
Como retornar o tamanho de um array em Java usando a propriedade length do objeto ArrayQuantidade de visualizações: 11165 vezes |
Nesta dica mostrarei como usar a propriedade length de um vetor (array de uma linha e várias colunas) para retornar a quantidade de elementos que ele possui. Este retorno é um número inteiro. Veja o código completo: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- package arquivodecodigos; public class Estudos{ public static void main(String[] args){ // cria um vetor de cinco elementos String[] pessoas = {"Fábio", "Fernanda", "Francisco", "João", "Osmar"}; // obtém o tamanho do vetor int quant = pessoas.length; System.out.println("Este array possui " + quant + " elementos"); System.exit(0); } } Ao executarmos este código nós teremos o seguinte resultado: Este array possui 5 elementos Este código foi revisado e testado no Java 8. |
Java ::: Dicas & Truques ::: Fuso Horários |
Como representar fuso horário em Java usando a classe TimeZoneQuantidade de visualizações: 12970 vezes |
A classe abstrata TimeZone (do pacote java.util) representa um determinado fuso horário e também identifica o horário de verão (daylight savings) de um determinado país ou região. Veja sua posição na hierarquia de classes Java:java.lang.Object java.util.TimeZone A melhor forma de entender o fuso horário, é consultando suas configurações regionais no Painel de Controle de seu sistema. É comum, em máquinas brasileiras encontrarmos o fuso horário "GMT -03:00 - Brasilia". Isso quer dizer que a hora oficial do Brasil é -3 horas em relação ao horário de Greenwich, Londres. Não podemos nos esquecer do horário de verão, que reduz esta diferença para -2 horas na maior parte do país. Por padrão, A JVM detecta e trabalha com o fuso horário da máquina na qual está sendo executada. Veja um trecho de código que obtém este TimeZone padrão: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- import java.util.*; public class Estudos{ public static void main(String args[]){ TimeZone timeZone = TimeZone.getDefault(); System.out.println(timeZone.getDisplayName()); System.out.println(timeZone.getID()); } } Ao executar este código você terá um resultado semelhante à: Brasilia Time America/Sao_Paulo Aqui nós usamos o método estático getDefault() para retornar o TimeZone padrão e os métodos de instância getDisplayName() e getID() para obter as informações sobre o fuso horário. |
Java ::: Dicas & Truques ::: Strings e Caracteres |
Como usar o método replace() da classe String do Java para substituir palavras em uma frase ou texto - RevisadoQuantidade de visualizações: 253 vezes |
Nesta dica mostrarei como substituir substrings em uma string, ou seja, substituir uma palavra (ou parte de uma palavra) em uma frase ou texto. Para isso podemos usar o método replace() da classe String da linguagem Java. Note que o método replace() da classe String retorna uma nova string com todas as ocorrências substituídas. Veja o exemplo: ---------------------------------------------------------------------- Se precisar de ajuda para ajustar o código abaixo de acordo com as suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar) Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar a manter o site livre de anúncios. Ficaremos eternamente gratos ;-) Nosso PIX é: osmar@arquivodecodigos.com.br ---------------------------------------------------------------------- package arquivodecodigos; public class Estudos{ public static void main(String[] args){ String frase = "Programar em Java é bom."; System.out.println(frase); // substitui todas as ocorrências de "Java" por "C#" String frase2 = frase.replace("Java", "C#"); System.out.println(frase2); System.exit(0); } } Ao executar este exemplo nós teremos o seguinte resultado: Programar em Java é bom. Programar em C# é bom. Esta dica foi revisada e testada no Java 8. |
Vamos testar seus conhecimentos em Hidrologia |
(IFTM 2018) O Brasil possui uma das mais extensas e diversificadas redes fluviais do mundo, dividida em 12 regiões hidrográficas: Bacia Amazônica, Bacia Tocantins-Araguaia, Bacia do Paraguai, Bacia Atlântico Nordeste Ocidental, Bacia Atlântico Nordeste Oriental, Bacia do Paraná, Bacia do Parnaíba, Bacia do São Francisco, Bacia do Atlântico Leste, Bacia do Atlântico Sudeste, Bacia do Atlântico Sul e Bacia do Uruguai. Disponível em: http://www.brasil.gov.br/noticias/meioambiente/2009/10/rios-e-bacias-do-brasil-formam-uma-dasmaiores-redes-fluviais-do-mundo. Adaptado. Acesso em: 16 de out de 2018. Marque a alternativa que apresenta apenas as bacias hidrográficas que banham a Região Centro-Oeste. A) Paraná, Paraguai, Tocantins-Araguaia, Amazônica. B) Tocantins-Araguaia, Atlântico Sul, Uruguai, Paraguai. C) Paraguai, Uruguai, São Francisco e Atlântico Nordeste. D) Atlântico Nordeste, Paraguai, Amazônica, Parnaíba. E) Amazônica, Atlântico Leste, Tocantins-Araguaia e São Francisco. Verificar Resposta Estudar Cards Todas as Questões |
Vamos testar seus conhecimentos em |
Resistência do concreto Utilizando como base os critérios para avaliação da resistência à tração do concreto, expostos no item 8.2.5 da NBR 6118/2014 - Projeto de Estruturas de Concreto - Procedimento, na falta de ensaios específicos, determine qual seria a resistência característica à tração superior e inferior de um concreto com fck = 30 MPa. A) fctk,inf = 1,8 MPa; fctk,sup = 3,3 MPa. B) fctk,inf = 2 Mpa; fctk,sup = 3,8 MPa. C) fctk,inf = 2,3 MPa; fctk,sup = 4,2 MPa. D) fctk,inf = 2,5 MPa; fctk,sup = 4,6 MPa. E) fctk,inf = 2,7 MPa; fctk,sup = 4,9 MPa. Verificar Resposta Estudar Cards Todas as Questões |
Vamos testar seus conhecimentos em Ética e Legislação Profissional |
Princípios específicos do Direito do Consumidor A Política Nacional das Relações de Consumo tem por objetivo o atendimento das necessidades dos consumidores, o respeito à sua dignidade, saúde e segurança, a proteção de seus interesses econômicos, a melhoria da sua qualidade de vida, bem como a transparência e harmonia das relações de consumo, atendido, dentre outros, o princípio da ação governamental, que se manifesta: A) Pela garantia dos produtos e serviços com padrões adequados de qualidade, segurança, durabilidade e desempenho. B) Pela presença do Estado no mercado estrangeiro. C) Pelo monopólio estrangeiro no mercado nacional. D) Pelo incentivos à criação e desenvolvimento de associações lucrativas. E) Pela iniciativa indireta. Verificar Resposta Estudar Cards Todas as Questões |
Vamos testar seus conhecimentos em Ética e Legislação Profissional |
O exercício do direito à propriedade Ainda sobre as ações judiciais correlatas aos direitos de vizinhança, mais especificamente sobre as ações de demarcação e divisão de propriedades, retificação de registros imobiliários e relação entre esses procedimentos, assinale a alternativa correta no que toca aos seus objetivos, às hipóteses de cabimento e às demais peculiaridades: A) A ação de demarcação serve para esclarecer os limites divisórios entre dois prédios de dois proprietários diferentes. B) O procedimento de retificação de matrícula serve para individualizar em matrículas separadas um bem que é de propriedade conjunta (condomínio). C) A ação de demarcação dispensa memorial descritivo e prova pericial no processo. D) As ações demarcatória e divisória não podem ser cumuladas na mesma ação, pois têm objetos diferentes. E) Os procedimentos ou as ações de marcação e divisão de propriedades só podem ser realizados judicialmente. Verificar Resposta Estudar Cards Todas as Questões |
Vamos testar seus conhecimentos em AutoCAD Civil 3D |
COGO Points no AutoCAD Civil 3D Qual parâmetro do COGO point é controlado pela configuração Point Identity na barra de ferramentas Create Points? A) Point location (Localização do ponto) B) Point name (Nome do ponto) C) Point description (Descrição do ponto) D) Point number (Número de ponto) Verificar Resposta Estudar Cards Todas as Questões |
Desafios, Exercícios e Algoritmos Resolvidos de Java |
Veja mais Dicas e truques de Java |
Dicas e truques de outras linguagens |
E-Books em PDF |
||||
|
||||
|
||||
Linguagens Mais Populares |
||||
1º lugar: Java |