 |
|
Você está aqui: Java ::: Pacote java.util ::: Comparator |
Usando o método compare() da interface Comparator para definir como os elementos de uma coleção serão ordenadosQuantidade de visualizações: 4073 vezes |
O perfeito entendimento do método compare() da interface Comparator é a chave para conseguirmos um maior controle sobre a forma que os elementos de uma coleção (ArrayList, Vector, TreeSet, etc) serão ordenados. Este método possui a seguinte assinatura:---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- int compare(T o1, T o2) Veja que o método recebe dois argumentos do tipo T e retorna um valor inteiro. O valor retornado será um inteiro negativo se o primeiro argumento for menor que o segundo, um inteiro positivo se o primeiro argumento for maior que o segundo e zero se os dois argumentos forem iguais. Vamos ver como isso funciona? Comece criando a seguinte classe: ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
package estudos;
public class Livro{
// para simplificar o exemplo não usarei encapsulamento de dados
String titulo;
int paginas;
// construtor não padrão
public Livro(String titulo, int paginas){
this.titulo = titulo;
this.paginas = paginas;
}
}
Veja que temos uma classe Livro com dois atributos: titulo e paginas. Nossa intenção é criar uma ArrayList de objetos da classe Livro e em seguida ordenar os livros pela quantidade de paginas, da menor para a maior. Eis o código para a classe principal: ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
package estudos;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Estudos{
public static void main(String[] args) {
// vamos criar uma ArrayList de objetos da classe Livro
ArrayList<Livro> livros = new ArrayList();
livros.add(new Livro("Programando em Java", 259));
livros.add(new Livro("A Bíblia do Delphi", 1043));
livros.add(new Livro("Aprenda PHP e MySQL", 427));
livros.add(new Livro("Tutorial Básico de JSF", 41));
// vamos ordenar os elementos do ArrayList usando o método sort() da classe Collections
// o critério de ordenação é por paginas ascendente
Collections.sort(livros, new Comparator<Livro>(){
@Override
public int compare(Livro a, Livro b){
if(a.paginas < b.paginas){
// se a.paginas for menor que b.paginas devemos retornar um valor negativo
return -1;
}
else if(a.paginas > b.paginas){
// se a.paginas for maior que b.paginas devemos retornar um valor positivo
return 1;
}
else{ // os objetos são iguais....devemos retornar 0
return 0;
}
}
});
// vamos percorrer e exibir os valores dos elementos
for(Livro livro : livros){
System.out.println("Título: " + livro.titulo + "; Páginas: " + livro.paginas);
}
}
}
Ao executarmos este exemplo teremos o seguinte resultado: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- Título: Tutorial Básico de JSF; Páginas: 41 Título: Programando em Java; Páginas: 259 Título: Aprenda PHP e MySQL; Páginas: 427 Título: A Bíblia do Delphi; Páginas: 1043 Se quisermos modificar a ordem da classificação basta trocarmos os operadores relacionais. Há uma forma interessante de se evitar os testes condicionais no método compare(). Veja: ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
// vamos ordenar os elementos do ArrayList usando o método sort() da classe Collectons
// o critério de ordenação é por paginas ascendente
Collections.sort(livros, new Comparator<Livro>(){
@Override
public int compare(Livro a, Livro b){
return a.paginas - b.paginas;
}
});
Mas é claro que este truque só funciona para a classificação em ordem crescente. O método compare() da interface Comparator pode atirar duas exceções: NullPointerException se um dos argumentos for null e o comparador não permitir elementos nulos e ClassCastException se os tipos dos argumentos não permitirem a comparação. |
 Link para compartilhar na Internet ou com seus amigos: |
Java ::: Coleções (Collections) ::: ArrayList |
Como adicionar todos os elementos de uma ArrayList ou coleção à uma outra ArrayList do Java usando o método addAll()Quantidade de visualizações: 15492 vezes |
Em algumas situações pode ser necessário adicionar todos os elementos de uma ArrayList ou outra coleção a uma determinada ArrayList já existente. Isso pode ser feito por meio do uso do método addAll() da classe ArrayList. Na versão 1.5 do Java, este método possui duas assinaturas. Veja a primeira:public boolean addAll(Collection<? extends E> c) Aqui nós podemos adicionar à uma ArrayList existente todos os elementos de uma determinada coleção, desde que, é claro, esta coleção implemente ou descenda de alguma classe que implemente a interface Collection. Note também o uso de genéricos na coleção a ser fornecida como argumento. É importante observar que, se passarmos uma coleção de tipos diferentes daquela na qual estamos chamando o método addAll() teremos um erro de compilação. Veja um exemplo no qual adicionamos todos os elementos de uma ArrayList no final de outra: ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
import java.util.ArrayList;
public class Estudos{
public static void main(String[] args){
// cria uma ArrayList que conterá strings
ArrayList<String> nomes = new ArrayList<String>();
// cria uma segunda ArrayList que conterá mais strings
ArrayList<String> nomes2 = new ArrayList<String>();
// adiciona itens na primeira lista
nomes.add("Carlos");
nomes.add("Maria");
nomes.add("Fernanda");
// adiciona itens na segunda lista
nomes2.add("Osmar");
nomes2.add("Zacarias");
// vamos adicionar os elementos da segunda lista
// no final da primeira lista
nomes.addAll(nomes2);
// vamos exibir o resultado
for(int i = 0; i < nomes.size(); i++){
System.out.println(nomes.get(i));
}
System.exit(0);
}
}
A segunda assinatura do método addAll() nos permite definir a posição no ArrayList alvo a partir da qual os elementos da coleção fonte serão adicionados. Veja: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- public boolean addAll(int index, Collection<? extends E> c) Eis um exemplo no qual inserimos os elementos de uma ArrayList a partir do segundo elemento da ArrayList alvo. Note que os itens existentes têm suas posições alteradas de forma a acomodar os novos elementos: ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
import java.util.ArrayList;
public class Estudos{
public static void main(String[] args){
// cria uma ArrayList que conterá strings
ArrayList<String> nomes = new ArrayList<String>();
// cria uma segunda ArrayList que conterá mais strings
ArrayList<String> nomes2 = new ArrayList<String>();
// adiciona itens na primeira lista
nomes.add("Carlos");
nomes.add("Maria");
nomes.add("Fernanda");
// adiciona itens na segunda lista
nomes2.add("Osmar");
nomes2.add("Zacarias");
// vamos adicionar os elementos da segunda lista
// a partir do segundo elemento da primeira lista
nomes.addAll(1, nomes2);
// vamos exibir o resultado
for(int i = 0; i < nomes.size(); i++){
System.out.println(nomes.get(i));
}
System.exit(0);
}
}
Como resultado da execução deste código nós teremos: Carlos Osmar Zacarias Maria Fernanda |
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: 11039 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 com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
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 ::: Desafios e Lista de Exercícios Resolvidos ::: Métodos, Procedimentos e Funções |
Exercícios Resolvidos de Java - Como escrever uma função Java que recebe dois números inteiros e retorna a soma desses dois valores como um inteiroQuantidade de visualizações: 9574 vezes |
|
Pergunta/Tarefa: Escreva um método estático em Java chamado somar() que recebe dois números inteiros e retorna a soma desses dois valores como um inteiro. Este método deverá ter a seguinte assinatura:
public static int somar(int a, int b){
// sua implementação aqui
}
Sua saída deverá ser parecida com: Informe o primeiro número: 4 Informe o segundo número: 3 A soma dos dois números é: 7 Veja a resolução comentada deste exercício usando 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 fazer a leitura usando a classe Scanner
Scanner entrada = new Scanner(System.in);
// vamos pedir ao usuário que informe dois valores inteiros
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());
// vamos efetuar uma chamada ao método somar() e obter seu retorno
int resultado = somar(n1, n2);
// finalmente mostramos o resultado
System.out.println("A soma dos dois números é: " + resultado);
}
// método estático que recebe dois inteiros e retorna a soma como um número inteiro
public static int somar(int a, int b){
int soma = a + b; // soma os dois números
return soma; // retorna a soma para o método chamado
}
}
|
Mais Desafios de Programação e Exercícios e Algoritmos Resolvidos de Java |
Veja mais Dicas e truques de Java |
Dicas e truques de outras linguagens |
|
JavaScript - Como usar objetos Set em seus códigos JavaScript |
Códigos Fonte |
 Software de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimentoDiga 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 funcionalidadesTenha 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 |
