 |
|
||||
Você está aqui: Java ::: Desafios e Lista de Exercícios Resolvidos ::: Java Básico |
Escreva um programa Java para exibir a soma dos cubos de dois números informados pelo usuário. Faça a leitura da entrada do usuário - Exercícios Resolvidos de JavaQuantidade de visualizações: 486 vezes |
|
Pergunta/Tarefa: Escreva um programa Java para exibir a soma dos cubos de dois números informados pelo usuário. Faça a leitura da entrada do usuário como um número inteiro tanto para o primeiro número quanto para o segundo. A saída do seu código deverá ser a soma do primeiro número elevado ao cubo mais o segundo número também elevado ao cubo. Sua saída deve ser parecida com: Informe o primeiro número: 4 Informe o segundo número: 3 A soma dos cubos dos dois números é: 91.0 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) {
// para ler a entrada do usuário
Scanner entrada = new Scanner(System.in);
// vamos ler os dois números
System.out.print("Informe o primeiro número: ");
int n1 = Integer.parseInt(entrada.nextLine());
System.out.print("Informe o segundo número: ");
int n2 = Integer.parseInt(entrada.nextLine());
// agora vamos obter a soma dos cubos dos dois números
double soma = Math.pow(n1, 3) + Math.pow(n2, 3);
// e mostramos o resultado
System.out.println("A soma dos cubos dos dois números é: " +
soma);
}
}
|
 Link para compartilhar na Internet ou com seus amigos: |
Java ::: Dicas & Truques ::: Expressões Regulares |
Como usar expressões regulares em Java - Expressões regulares para iniciantesQuantidade de visualizações: 48591 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 |
Manipulação de arquivos em Java - Como ler o conteúdo de um arquivo um byte de cada vezQuantidade de visualizações: 11078 vezes |
|
Nesta dica mostrarei como ler texto de um arquivo um byte de cada vez. Para isso vamos usar o método readByte() da classe DataInputStream, do pacote java.io. Note que este método retorna um inteiro com sinal na faixa de -128 até 127. Neste exemplo faremos um cast do byte lido para um char, já que estaremos lendo um arquivo de texto. Sim, é isso mesmo que você pensou. Se houver caracteres acentuados no arquivo texto, os mesmo não serão exibidos corretamente. A idéia do exemplo é mostrar o funcionamento do método readByte(). Veja o código Java 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;
import java.io.*;
public class Estudos{
public static void main(String[] args){
try {
DataInputStream in = new DataInputStream(new BufferedInputStream(
new FileInputStream("C:\\java\\conteudo.txt")));
while (in.available() != 0){
System.out.print((char) in.readByte());
}
}
catch (IOException e){
System.out.println("Erro: " + e.getMessage());
}
System.exit(0);
}
}
Ao executarmos este código nós teremos o seguinte resultado: Primeira linha do arquivo Segunda linha do arquivo Terceira linha do arquivo |
Java ::: Fundamentos da Linguagem ::: Variáveis e Constantes |
Regras para a escolha de nomes de variáveis e constantes em JavaQuantidade de visualizações: 15669 vezes |
|
Cada linguagem de programação tem seu conjunto próprio de regras e convenções para os tipos de nomes que você pode usar, e Java não é diferente. As regras e convenções para nomear variáveis em Java são as seguintes: 1) Nomes de variáveis são sensíveis a minúsculas e maiúsculas. Isso quer dizer que "cliente" é diferente de "Cliente". O nome de uma variável pode ser qualquer identificador legal: Uma sequência sem limites de tamanho de letras Unicode e dígitos, começando com uma letra, "$" ou o caractere de sublinhado "_" (underscore). A convenção, contudo, é sempre começar um nome de variável com uma letra e não "$" ou "_". Além disso, por convenção, o caractere $ nunca é usado. Você pode encontrar situações em que nomes gerados automaticamente podem conter o sinal $, mas evite usá-lo sempre que possível. O mesmo acontece com "_". Embora permitido, evite começar nomes de variáveis com "_". Espaços não são permitidos em nomes de variáveis. 2) Caracteres subsequentes podem ser letras, dígitos, $ ou "_". Convenções (e senso comum) se aplicam a esta regra também. Quando escolher nomes para suas variáveis, use nomes completos em vez de abreviações confusas. Isso tornará seu código mais legível. Nomes tais como "cliente", "nota", "quantidade", etc, são bem mais fáceis de entender e lembrar que "cl", "n", "qt", etc. Tenha também em mente que palavras-chaves e palavras reservadas da linguagem não podem ser usadas como nomes de variáveis. 3) Se o nome de variável que você escolher consistir de apenas um palavra, escreva-a toda em letras minúsculas. Ex.: cliente. Se consistir de mais de uma palavra, escreva a primeira letra da segunda palavra usando letra maiúscula. Ex.: nomeCliente. Se o nome for de uma constante, ele deve ser escrito todo em letras maiúsculas. Ex.: MODELO = 102. Se o nome da constante possuir mais de uma palavra, separe-as com o caractere "_". Ex.: NIVEL_BOLETO = 2. |
Java ::: Dicas & Truques ::: Threads |
Java Threads - Como interromper a execução de uma thread em suas aplicações JavaQuantidade de visualizações: 15429 vezes |
|
A classe Thread fornece um método chamado interrupt() que serve para interrompermos a execução de uma determinada thread. Os métodos sleep() e yield() transferem a thread sendo executada no momento do estado "executando" para o estado "pronta". O método interrupt(), por sua vez, faz com que uma thread vá para o estado "finalizada", ou seja, ela não voltará mais a ser executada. O problema é que, nem sempre, o método interrupt() parece surtir o efeito desejado, ou seja, fazer com que a thread pare de executar imediatamente. Por esta razão, a forma mais fácil de "matar" uma thread é forçar a saída de seu método run(). Veja um 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
----------------------------------------------------------------------
// criamos uma classe que servirá como thread
class MinhaThread extends Thread{
private String nome;
public MinhaThread(String nome){
this.nome = nome;
}
public void run(){
for(int i = 1; i <= 20; i++){
System.out.println(nome + ": " + i);
if((i >= 3) && (nome.equals("Thread 1"))){
try{
System.out.println(nome + " foi eliminada");
return; // interrompe a execução do método run()
}
catch(SecurityException e){
System.out.println(e.getMessage());
}
}
}
}
}
public class Estudos{
public static void main(String[] args){
// vamos criar duas threads
MinhaThread t1 = new MinhaThread("Thread 1");
t1.start();
MinhaThread t2 = new MinhaThread("Thread 2");
t2.start();
}
}
Ao usar a instrução return nós forçamos a saída do método run() e consequentemente, o fim da tarefa sendo realizada pela thread. |
Java ::: Dicas & Truques ::: Programação Orientada a Objetos |
Como usar o modificador abstract em suas classes e métodos Java - Programação Orientada a Objetos em Java - Java POOQuantidade de visualizações: 18202 vezes |
O modificador abstract pode ser aplicado a classes e métodos. Seu uso com variáveis pode causar o erro abaixo:
abstract String nome;
Estudos.java:2: modifier abstract not
allowed here
abstract String nome;
^
1 error
Classes abstratas não podem ser instanciadas, ou seja, não podemos chamar seu construtor. Veja um 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
----------------------------------------------------------------------
public class Estudos{
public static void main(String args[]){
Cliente cliente = new Cliente();
System.exit(0);
}
}
abstract class Cliente{
public Cliente(){
}
}
Ao tentarmos compilar esta classe teremos o seguinte erro:
Estudos.java:3: Cliente is abstract; cannot be
instantiated
Cliente cliente = new Cliente();
^
1 error
A função principal de classes abstratas é forçar a implementação para as sub-classes. Desta forma, seus métodos são declarados com o modificador abstract e sem corpo. Veja: ----------------------------------------------------------------------
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
----------------------------------------------------------------------
abstract class Cliente{
abstract void obterNome();
}
Sempre que suas classes contiverem um ou mais métodos abstratos, você deverá declará-la abstrata. Não seguir esta regra provocará o seguinte erro:
class Cliente{
abstract void obterNome();
}
Estudos.java:9: Cliente is not abstract and does
not override abstract method obterNome() in Cliente
class Cliente{
^
1 error
As situações que fazem com que uma classe deva ser declarada abstract são:
Para finalizar, abstract é o oposto de final. Uma classe final não pode ter sub-classes. Uma classe abstract precisa ter sub-classes. |
Java ::: Desafios e Lista de Exercícios Resolvidos ::: Programação Orientada a Objetos |
Algorítmos Resolvidos de Java - A classe Retangulo (construtores, getters e setters, encapsulamento e static)Quantidade de visualizações: 15116 vezes |
|
Exercícios Resolvidos de Java - A classe Retangulo (construtores, getters e setters, encapsulamento e static) Pergunta/Tarefa: Escreva uma classe Retangulo para representar um retângulo. A classe deve conter: a) Dois campos de dados do tipo double chamados largura e altura que especificam a largura e a altura do retângulo. Os valores padrões são 1 tanto para a largura quanto para a altura. b) Um campo de dado do tipo String chamado cor que especifica a cor do retângulo. Para este exercício em particular, assuma que TODOS os retângulos possuirão a mesma cor. A cor padrão é branco. c) Um construtor sem argumentos que cria um retângulo padrão. d) Um construtor que cria um retângulo com a largura e altura especificadas. e) Métodos get() e set() para os três campos de dados da classe. f) Um método chamado getArea() que retorna a área do retângulo. g) Um método chamado getPerimetro() que retorna o perímetro do retângulo. Escreva um programa de teste que cria dois objetos da classe Retangulo. Sua saída deverá ser parecida com:  Resposta/Solução: Veja a resolução comentada deste exercício usando Java console: Retangulo.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;
public class Retangulo {
private double largura; // largura do retângulo
private double altura; // altura do retângulo
// O exercício pede que TODOS os retângulos tenham a mesma cor
// consulte a dica http://www.arquivodecodigos.net/dicas/1158 para mais
// detalhes sobre o modificador static
private static String cor = "branco"; // cor do retângulo
// construtor sem argumentos
public Retangulo(){
this.largura = 1;
this.altura = 1;
}
// construtor que permite especificar a largura e a altura
public Retangulo(double largura, double altura){
this.largura = largura;
this.altura = altura;
}
// obtém a altura
public double getAltura() {
return altura;
}
// define a altura
public void setAltura(double altura){
this.altura = altura;
}
// obtém a largura
public double getLargura(){
return largura;
}
// define a largura
public void setLargura(double largura){
this.largura = largura;
}
// obtém a cor de TODOS os retângulos
public static String getCor(){
return cor;
}
// define a cor de TODOS os retângulos
public static void setCor(String cor){
Retangulo.cor = cor;
}
// este método retorna a área do retângulo (em metros quadrados)
public double getArea(){
return (this.largura * this.altura);
}
// este método retorna o perímetro do retângulo (em metros)
public double getPerimetro(){
return ((2 * this.largura) + (2 * this.altura));
}
}
Agora o teste no método main(): ----------------------------------------------------------------------
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;
public class Estudos {
public static void main(String[] args) {
// vamos criar uma instância da classe Retangulo com
// os valores padrões
Retangulo a = new Retangulo();
// agora vamos informar a largura e a altura
Retangulo b = new Retangulo(10, 5);
// os dois retângulos terão a cor verde
Retangulo.setCor("verde");
// vamos mostrar os resultados do primeiro retângulo
System.out.println("Primeiro retângulo");
System.out.println("Largura: " + a.getLargura());
System.out.println("Altura: " + a.getAltura());
System.out.println("Cor: " + Retangulo.getCor());
System.out.println("Área: " + a.getArea() + " metros quadrados");
System.out.println("Perímetro: " + a.getPerimetro() + " metros");
// vamos mostrar os resultados do segundo retângulo
System.out.println("\nSegundo retângulo");
System.out.println("Largura: " + b.getLargura());
System.out.println("Altura: " + b.getAltura());
System.out.println("Cor: " + Retangulo.getCor());
System.out.println("Área: " + b.getArea() + " metros quadrados");
System.out.println("Perímetro: " + b.getPerimetro() + " metros");
}
}
|
Java ::: Coleções (Collections) ::: HashMap |
Java HashMap - Como fornecer uma chave e obter seu valor correspondente em um HashMapQuantidade de visualizações: 9137 vezes |
O uso de um HashMap só se justifica quando podemos guardar os mapeamentos e recuperá-los de forma rápida e fácil. Para isso, a classe HashMap nos fornece o método get(). Este método recebe a chave a ser pesquisada e retorna o valor associado a ela. Veja sua assinatura:public V get(Object key) Veja um exemplo no qual usamos o método get() para retornar o valor associado à chave informada: ----------------------------------------------------------------------
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.util.*;
public class Estudos{
public static void main(String[] args){
// vamos criar uma instância de HashMap
HashMap<Integer, String> clientes = new HashMap<Integer, String>();
// vamos adicionar três chaves e seus valores
clientes.put(new Integer(1), "Osmar J. Silva");
clientes.put(new Integer(2), "Salvador Miranda de Andrade");
clientes.put(new Integer(3), "Marcos da Costa Santos");
// vamos obter o valor correspondente à chave 2
String c = clientes.get(2);
// vamos exibir o resultado
if(c != null){
System.out.println("O valor para esta chave é: " + c);
}
else{
System.out.println("O HashMap não contém a chave informada.");
}
System.exit(0);
}
}
Ao executarmos este código Java nós teremos o seguinte resultado: O valor para esta chave é: Salvador Miranda de Andrade |
Java ::: Classes e Componentes ::: JMenuBar, JMenu, JMenuItem e Afins |
Java Swing - Como usar objetos da classe JCheckBoxMenuItem como itens de menu de suas aplicações Java SwingQuantidade de visualizações: 8809 vezes |
|
Neste exemplo mostrarei como usar objetos da classe JCheckBoxMenuItem como itens de um menu. Tais itens podem ser usados quando o usuário puder marcar uma ou mais opções, em um grupo relacionado de opções. Veja o resultado na imagem abaixo:  E agora 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;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Estudos extends JFrame{
JCheckBoxMenuItem cores[];
Color valCores[] = {Color.red, Color.white,
Color.green};
String nomeCores[] = {"Vermelho", "Branco",
"Verde"};
public Estudos(){
super("Menus");
// Cria a barra de menus
JMenuBar barra = new JMenuBar();
setJMenuBar(barra);
// Cria um menu
JMenu formatar = new JMenu("Formatar");
// Cria o menu de cor de fundo
JMenu item1 = new JMenu("Cor de Fundo");
// Adiciona o segundo JMenu ao primeiro
formatar.add(item1);
cores = new JCheckBoxMenuItem[valCores.length];
Gerenciador gerenciador = new Gerenciador();
for(int i = 0; i < valCores.length; i++){
cores[i] = new JCheckBoxMenuItem(nomeCores[i]);
item1.add(cores[i]);
cores[i].addItemListener(gerenciador);
}
// Adiciona o menu à barra de menus
barra.add(formatar);
setSize(300, 150);
setVisible(true);
}
public static void main(String args[]){
Estudos app = new Estudos();
app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
private class Gerenciador implements ItemListener{
public void itemStateChanged(ItemEvent e){
String marcadas = "As checkbox marcadas são:\n\n";
for(int i = 0; i < cores.length; i++){
if(cores[i].isSelected()){
marcadas += nomeCores[i] + "\n";
}
}
JOptionPane.showMessageDialog(null, marcadas);
}
}
}
|
Vamos testar seus conhecimentos em Fenômeno de Transportes e Hidráulica |
| (TRE-MT - Analista Judiciário - Engenharia Civil) Em hidráulica, no que diz respeito à classificação dos escoamentos quanto à direção na trejetória das partículas, o escoamento pode ser A) forçado. B) laminar. C) permanente. D) livre. E) transitório. Verificar Resposta Estudar Cards Todas as Questões |
Vamos testar seus conhecimentos em Engenharia Civil - Construção Civil |
| Processos e técnicas construtivas de instalações elétricas e hidráulicas As instalações elétricas são compostas por dispositivos cuja função é distribuir a energia elétrica, proveniente da rede de abastecimento, entre os pontos de utilização. Analise as afirmativas a seguir, referentes aos dispositivos que compõem as instalações elétricas. I. O quadro de distribuição consiste no dispositivo responsável pela divisão dos circuitos elétricos de uma edificação. II. Os condutores consistem em fios ou cabos de cobre ou alumínio, cuja função é transmitir a corrente elétrica. III. As tomadas de corrente são dispositivos cuja função é gerar corrente elétrica, permitindo a alimentação de equipamentos. IV. Os dispositivos de manobra são aqueles que permitem a interrupção da transmissão da corrente elétrica. Assinale a alternativa que apresenta somente as afirmativas corretas. A) Apenas a afirmativa I está correta. B) Apenas a afirmativa III está correta. C) Apenas as afirmativas II e III estão corretas. D) Apenas as afirmativas I, II e IV estão corretas. E) As afirmativas I, II, III e IV estão corretas. Verificar Resposta Estudar Cards Todas as Questões |
Vamos testar seus conhecimentos em Python |
| Qual é a forma correta de se retornar o primeiro caractere de uma string em Python? A) letra = "BRASIL".char(0) B) letra = "BRASIL"[0] C) letra = "BRASIL".substring(0, 1) D) letra = "BRASIL".sub(0, 1) E) letra = sub("BRASIL", 0, 1) Verificar Resposta Estudar Cards Todas as Questões |
Vamos testar seus conhecimentos em Fenômeno de Transportes e Hidráulica |
| Turbinas hidráulicas Turbinas hidráulicas têm como principal aplicação a geração de energia, transformando energia cinética da água em energia mecânica, que será posteriormente convertida em energia elétrica. Sobre as turbinas hidráulicas, marque a alternativa correta: A) Uma turbina do tipo Francis apresenta uma baixa eficiência e pode ser operada apenas em baixas vazões. B) Uma turbina do tipo Francis tem eficiência relativamente baixa, porém tem ampla faixa de operação. C) A turbina do tipo Pelton tem um conjunto de pás fixas que podem ajustar o ângulo de entrada da água. D) A turbina do tipo Kaplan foi adaptada a partir da turbina de hélice e pode ser operada em grandes vazões. E) Uma turbina do tipo Pelton tem suas pás em formato de conchas e são operadas em grandes vazões. Verificar Resposta Estudar Cards Todas as Questões |
Vamos testar seus conhecimentos em |
| Vigas a flexão simples: seções retangulares Além da preocupação com segurança e economia, o projetista estrutural precisa também se preocupar com a execução da obra. Vigas super armadas dificultam a concretagem, podendo resultar nos vazios do concreto, popularmente chamadas de bicheiras. Tendo isso em mente, qual é a largura mínima para uma viga com 3 barras de 16mm de armadura principal, dispostas na mesma camada, e estribo de 6,3mm? Considere que não há parede apoiada sobre a viga, a agressividade ambiental é classe III e o concreto tem brita 1. A) 12cm. B) 14cm. C) 19cm. D) 15cm. E) 20cm. 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 |
|
C - Como escrever uma função C personalizada que copia os caracteres de uma string para outra string Delphi - Como selecionar um item de uma ListBox do Delphi em tempo de execução usando a propriedade ItemIndex |
E-Books em PDF |
||||
|
||||
|
||||
Linguagens Mais Populares |
||||
|
1º lugar: Java |
