Você está aqui: Java ::: Classes e Componentes ::: JList

Exibindo imagens ao lado dos itens de uma JList

Quantidade de visualizações: 8960 vezes
/*
 Este exemplo mostra como aplicar exibir imagens
 como parte dos itens de uma JList. Neste exemplo
 mostro como exibir uma imagem para os itens
 selecionados e outra para os itens normais.

 Antes de executar o exemplo certifique-se de
 ter as imagens icon.gif e icon2.gif no diretório
 de execução. 
*/

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Estudos extends JFrame{
  JList lista;
  ImageIcon icone1, icone2;  

  public Estudos() {
    super("A classe JList");
    
    Container c = getContentPane();
    c.setLayout(new FlowLayout(FlowLayout.LEFT));
    
    // carrega as imagens
    icone1 = new ImageIcon("icon.gif");
    icone2 = new ImageIcon("icon2.gif");
 
    // Cria os itens da lista
    String nomes[] = {"Carlos", "Marcelo", "Fabiana",
      "Carolina", "Osmar"};

    // Cria a JList
    lista = new JList(nomes);
 
    // define o renderizados de células para a
    // JList
    lista.setCellRenderer(new Imagens());

    // Adiciona a lista à janela
    c.add(new JScrollPane(lista));

    setSize(350, 250);
    setVisible(true);
  }

  class Imagens extends JLabel implements ListCellRenderer{
    public Imagens(){
      setOpaque(true);
    }
 
    public Component getListCellRendererComponent(
      JList list, Object value, int index, boolean 
      isSelected,boolean cellHasFocus){
     
      setText(value.toString());

      if(!isSelected){
        setIcon(icone1);
        setBackground(list.getBackground());
      }
      else{
        setIcon(icone2);
        setBackground(list.getSelectionBackground());
      }
   
      return this;
    }  
  }
  
  public static void main(String args[]){
    Estudos app = new Estudos();
    app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
}


Link para compartilhar na Internet ou com seus amigos:

Java ::: Projetos Java Completos - Códigos Fonte Completos Java ::: Jogos (Games)

Como criar o jogo Pedra, Papel, Tesoura em Java - Jogo completo em Java com código comentado

Quantidade de visualizações: 5981 vezes
Faça o download do código-fonte Pedra, Papel, Tesoura em Java

Nesta dica mostrarei como criar o famoso joguinho Pedra, Papel, Tesoura na linguagem Java. Trata-se de um código bem simples e que vou comentar linha a linha, para que você extraia todo o conteúdo necessário para deixar a sua lógica de programação ainda mais afiada.

Nesta versão eu mostrarei como jogar Pedra, Papel, Tesoura contra o computador. Depois de entender todo o código você não terá dificuldade para implementar uma versão que lhe permitirá jogar contra seus amigos.

Antes de vermos o código, eis uma imagem do jogo em execução:



Quais técnicas de programação vou aprender com o código desse jogo?

O joguinho Pedra, Papel, Tesoura é ótimo para estudantes de programação que está iniciando em Java e que gostariam de aprimorar sua lógica de programação, afinal, se você desenvolver uma boa lógica de programação, você conseguirá desenvolver soluções em qualquer linguagem.

Além de entender como funciona o desenvolvimento de jogos em Java, você reforçará o seu conhecimento de laços, estrutura condicional if...else, entrada e saída e fluxo e desvio do algorítmo.

Veja, por exemplo, um trecho de código no qual testamos se o jogador escolheu Pedra, Papel ou Tesoura, e também a escolha feita pelo computador:

// o jogador escolheu Pedra?
else if(jogador == 1){
  // o computador escolheu Papel?
  if(computador == 2){
    System.out.println("Você perdeu. Papel embrulha Pedra");
    vitoriasComputador++; // aumenta as vitórias do computador
  }
  else{ // o computador escolheu Tesoura
    System.out.println("Você ganhou. Pedra amassa Tesoura");
    vitoriasJogador++; // aumenta as vitórias do jogador
  }
}
// o jogador escolheu Papel?
else if(jogador == 2){
  // o computador escolheu Tesoura?
  if(computador == 3){
    System.out.println("Você perdeu. Tesoura corta Papel");
    vitoriasComputador++; // aumenta as vitórias do computador
  }
  else{ // o ocmputador escolheu Pedra
    System.out.println("Você ganhou. Papel embrulha Pedra");
    vitoriasJogador++; // aumenta as vitórias do jogador
  }
}
Como posso obter este código fonte?

Os links para você baixar todas as versões deste projeto estão abaixo:

1) PEDPAPTESJC - Jogo Pedra, Papel, Tesoura em Java Console - NetBeans IDE - Faça o download do código-fonte Pedra, Papel, Tesoura em Java.

Não se esqueça: Uma boa forma de estudar o código é fazendo pequenas alterações e rodando para ver os resultados. Outra opção é começar um projeto Java do zero e ir adicionando trechos do código fonte para melhor entendimento de suas partes.


Java ::: Desafios e Lista de Exercícios Resolvidos ::: Arrays e Matrix (Vetores e Matrizes)

Exercício Resolvido de Java - Escreva um programa Java que efetue a soma dos elementos da diagonal principal de uma matriz

Quantidade de visualizações: 1402 vezes
Pergunta/Tarefa:

Em álgebra linear, a diagonal principal de uma matriz A é a coleção das entradas Aij em que i é igual a j. A diagonal principal de uma matriz quadrada une o seu canto superior esquerdo ao canto inferior direito (conforme mostrado na saída do problema proposto abaixo).

Escreva um programa Java que declara uma matriz 3x3 e pede ao usuário para informar seus valores. Em seguida mostre todos os valores da matriz e a soma dos elementos da diagonal principal. Sua saída deverá ser parecida com a imagem abaixo:



Resposta/Solução:

Veja a resolução comentada deste exercício em Java:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package estudos;

import java.util.Scanner;

public class Estudos{ 
  public static void main(String args[]){ 
    // vamos usar a classe Scanner para a leitura dos dados
    Scanner entrada = new Scanner(System.in);
    
    int matriz[][] = new int[3][3]; // uma matriz de três linhas e três colunas
    int soma_diagonal = 0; // guarda a soma dos elementos na diagonal principal

    // vamos ler os valores para os elementos da matriz
    for(int i = 0; i < 3; i++){ // linhas
      for(int j = 0; j < 3; j++){ // colunas
        System.out.print("Valor para a linha " + i + " e coluna " + j + ": ");
        matriz[i][j] = Integer.parseInt(entrada.nextLine());       
      }        
    }
  
    // vamos mostrar a matriz da forma que ela foi informada
    System.out.println("\nValores na matriz\n");
    
    for(int i = 0; i < 3; i++){
      for(int j = 0; j < 3; j++){
        System.out.printf("%5d ", matriz[i][j]);   
      }
    
      // passa para a próxima linha da matriz
      System.out.println();       
    }
  
    // vamos calcular a soma dos elementos da diagonal principal
    for(int i = 0; i < 3; i++){
      for(int j = 0; j < 3; j++){
        if(i == j){
          soma_diagonal = soma_diagonal + matriz[i][j];
        }
      }
    }
  
    System.out.println("\nA soma dos elementos da diagonal principal é: " + 
      soma_diagonal);
  }
}



Java ::: Dicas & Truques ::: Expressões Regulares

Como usar expressões regulares em Java - Expressões regulares para iniciantes

Quantidade de visualizações: 48459 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 com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

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 com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

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 com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

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.


Vamos testar seus conhecimentos em Python

Qual o resultado da execução do seguinte código Python?

for i in range(0, 10, 3):
  print(i, end="  ")

A) 0 3 6 9

B) 0 1 2 3

C) 3 6 9 12

D) 10 20 30 40

E) 0 0 0 0
Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em AutoCAD Civil 3D

COGO Points no AutoCAD Civil 3D

Qual das ordens de fluxo de trabalho abaixo é a correta para definir o estilo da label de um COGO point na janela Panorama?

A) Selecione Edit Points na aba Toolpace -> Prospector, botão direito no título da coluna Point Label Style, selecione o Point Label Style na lista e clique o botão OK.

B) Selecione Edit Points na aba Toolpace -> Prospector, duplo-clique na célula desejada na coluna Point Label Style, selecione o Point Label Style na lista e clique o botão OK.

C) Selecione Refresh na aba Toolpace -> Prospector, duplo-clique na célula desejada na coluna Point Label Style, selecione o Point Label Style na lista e clique o botão OK.

D) Selecione Edit Points na aba Toolpace -> Toolbox, duplo-clique no título da coluna Point Label Style, selecione o Point Label Style na lista e clique o botão OK.
Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em Ética e Legislação Profissional

Responsabilidade civil no código de defesa do consumidor

Qual é o prazo decadencial previsto em lei para reclamar o vício do produto, considerando que o vício está em um automóvel?

A) 5 dias.

B) 15 dias.

C) 30 dias.

D) 60 dias.

E) 90 dias.
Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em Hidrologia

O Brasil apresenta um grande volume de usinas hidrelétricas instaladas na sua rede hidrográfica. Marque a alternativa que faça uma associação correta entre o nome da usina hidrelétrica e a sua localização.

A) Usina de Furnas -> Bacia Platina.

B) Usina de Belo Monte -> Bacia Amazônica.

C) Usina de Três Marias -> Bacia do Uruguai.

D) Usina de Sobradinho -> Bacia do Tocantins.

E) Usina de Itaipu -> Bacia do São Francisco.
Verificar Resposta Estudar Cards Todas as Questões

Vamos testar seus conhecimentos em Fenômeno de Transportes e Hidráulica

Número de Froude

O número de Froude (Fr) é um coeficiente adimensional, frequentemente utilizado na hidráulica de condutos abertos para determinar a classificação do regime que o escoamento livre apresenta. Quando o Fr é igual a 1, o regime é classificado como crítico; com Fr > 1, o regime é supercrítico; e com Fr < 1, o regime é subcrítico.

Sobre esta classificação afirma-se que:

A) No regime crítico há equílibrio de forças e a velocidade é menor que a celeridade.

B) No regime supercrítico, o escoamento é mais influenciado pelas forças gravitacionais.

C) No regime supercrítico, o escoamento é regido pelas energias cinéticas e inerciais.

D) No regime subcrítico ou torrencial, as forças gravitacionais regem o escoamento.

E) No regime crítico não há equilíbrio entre as energias que influenciam o escoamento.
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ódigos Fonte

Programa de Gestão Financeira Controle de Contas a Pagar e a Receber com Cadastro de Clientes e FornecedoresSoftware de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimento
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
Controle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidadesControle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidades
Tenha o seu próprio sistema de controle de estoque web. com cadastro de produtos, categorias, fornecedores, entradas e saídas de produtos, com relatórios por data, margem de lucro e muito mais. Código simples e fácil de modificar. Acompanha instruções para instalação e criação do banco de dados MySQL. Clique aqui e saiba mais

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: Delphi
6º lugar: C
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby



© 2024 Arquivo de Códigos - Todos os direitos reservados
Neste momento há 56 usuários muito felizes estudando em nosso site.