De acordo com o acordo, ao usar programação Java, você deve usar bibliotecas de classes existentes tanto quanto possível. É claro que você também pode escrever um método ou estrutura de classificação, mas quantas pessoas podem escrever melhor do que aquelas no JDK? Outro benefício de usar classes existentes é que o código é fácil de ler e manter. Este artigo fala principalmente sobre como usar bibliotecas de classes existentes para classificar matrizes e vários contêineres de coleção (alguns exemplos no artigo vêm do "Java Developers Almanac 1.4》). )
Primeiro de tudo, você precisa conhecer duas classes: java.util.Arrays e java.util.Collections (observe a diferença com Collection). Collection é a interface de nível superior da estrutura de coleção e Collections contém muitos métodos estáticos. Usamos Arrays para classificar arrays e Collections para classificar contêineres de quadros combinados, como ArraysList, LinkedList, etc.
Import java.util.* e outros códigos shell, como classes e métodos principais estáticos, devem ser adicionados aos exemplos. Escreverei todos os códigos no primeiro exemplo e os omitirei sem exceção no seguinte.
Classificar matriz
Por exemplo, existe uma matriz de inteiros:
Copie o código do código da seguinte forma:
int[] intArray = new int[] {4, 1, 3, -23};
Como podemos resolver isso? Você está pensando no algoritmo de classificação rápida neste momento? Dê uma olhada em como isso é feito:
Copie o código do código da seguinte forma:
importar java.util.*;
classe pública Classificar{
public static void main(String[] args){
int[] intArray = new int[] {4, 1, 3, -23};
Arrays.sort(intArray);
}
}
Desta forma, usamos o método estático sort() de Arrays para classificar o intArray em ordem crescente. Agora o array se tornou {-23,1,3,4}.
Se for uma matriz de caracteres:
Copie o código do código da seguinte forma:
String[] strArray = new String[] {"z", "a", "C"};
Nós usamos:
Copie o código do código da seguinte forma:
Arrays.sort(strArray);
O resultado após a classificação é {C, a, z}, e sort() classificará em ordem crescente de acordo com a ordem natural dos elementos. Se você quiser não diferenciar maiúsculas de minúsculas, você pode escrever:
Copie o código do código da seguinte forma:
Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);
Claro, também podemos especificar uma determinada seção do array para classificar. Por exemplo, se quisermos classificar as partes 0-2 do array (assumindo que o comprimento do array seja maior que 3) e as outras partes permanecerem inalteradas. pode usar:
Copie o código do código da seguinte forma:
Arrays.sort(strArray,0,2);
Desta forma, classificamos apenas os três primeiros elementos sem afetar as partes seguintes.
É claro que algumas pessoas vão pensar: como faço para classificar em ordem decrescente? Entre os muitos métodos de classificação, uma cópia do código é a seguinte:
classificar(T[] a, Comparador<? super T> c)
Podemos usar o Comparator para obter um comparador na ordem inversa. O Comparator será explicado mais tarde.
Copie o código do código da seguinte forma:
Arrays.sort(intArray,Comparator.reverseOrder());
Desta forma, o resultado que obtemos é {4,3,1,-23}. Se não quisermos modificar o código original também podemos usar:
Copie o código do código da seguinte forma:
Collections.reverse(Arrays.asList(intArray));
Obtenha a ordem inversa da matriz. O resultado também é 4,3,1,-23}.
Agora a situação mudou. Nosso array não é mais um array de tipo de dados primitivo (tipo primitivo) ou tipo String, mas um array de objetos. A ordem natural deste array é desconhecida, então precisamos implementar a interface Comparable para esta classe. Por exemplo, temos uma classe Name:
Copie o código do código da seguinte forma:
nome da classe implementa Comparable<Nome>{
public String primeiroNome,sobrenome;
nome público(String primeiroNome,String últimoNome){
this.primeiroNome=primeiroNome;
this.lastName=sobrenome;
}
public int compareTo(Name o) { //Implementa a interface
int lastCmp=lastName.compareTo(o.lastName);
return (lastCmp!=0?lastCmp:firstName.compareTo(o.firstName));
}
public String toString(){ //Conveniente para teste de saída
return nome+" "+sobrenome;
}
}
Dessa forma, quando classificarmos esse array de objetos, primeiro compararemos lastName, depois compararemos firstName e, em seguida, obteremos a ordem dos dois objetos, assim como o que é implementado em compareTo(Name o). Você também pode tentar com o programa:
Copie o código do código da seguinte forma:
importar java.util.*;
classe pública NomeSort {
public static void main(String[] args) {
Nome nomeArray[] = {
novo nome("John", "Lennon"),
novo Nome("Karl", "Marx"),
novo Nome("Groucho", "Marx"),
novo nome("Oscar", "Grouch")
};
Arrays.sort(nomeArray);
for(int i=0;i<nomeArray.length;i++){
System.out.println(nomeArray[i].toString());
}
}
}
O resultado é o que esperávamos:
Copie o código do código da seguinte forma:
Oscar Grouch
John Lennon
Groucho Marx
Carlos Marx
Classificar quadros de coleção
Se você entendeu Arrays.sort() para classificar arrays, o uso da estrutura de coleção é semelhante. Basta substituir Arrays por Collections. Observe que Collections é uma classe e Collection é uma interface. Embora haja apenas uma diferença "s", seus significados são completamente diferentes.
Suponha que exista uma lista vinculada:
Copie o código do código da seguinte forma:
lista LinkedList=new LinkedList();
lista.add(4);
lista.add(34);
lista.add(22);
lista.add(2);
Só precisamos usar:
Copie o código do código da seguinte forma:
Coleções.sort(lista);
Você pode classificar os elementos em ll de pequeno a grande e o resultado será:
Copie o código do código da seguinte forma:
[2, 4, 22, 34]
Se os elementos no LinkedList forem Strings, eles também serão classificados de pequeno a grande, como os tipos de dados básicos.
Se você deseja implementar a classificação reversa, ou seja, desde a classificação até a classificação pequena:
Copie o código do código da seguinte forma:
Collections.sort(lista,Collectons.reverseOrder());
Se os elementos no LinkedList forem objetos personalizados, você pode implementar a interface Comparable como o objeto Name acima e deixar Collection.sort() classificá-los para você.
Se quiser classificar um objeto de acordo com suas próprias ideias, você pode usar o código copiado da seguinte maneira:
sort(Lista<T> lista, Comparador<? super T> c)
Este método realiza a classificação. Antes de dar um exemplo, devemos primeiro explicar o uso do Comparator e o formato da interface Comparable:
Copie o código do código da seguinte forma:
interface pública Comparador<T> {
int comparar(T o1, T o2);
}
Na verdade, o método de escrita do método int compare(T o1,T o2) no Comparator é semelhante ao método de escrita do método compareTo() no Comparable. Na classe Name acima, nossa comparação começa com LastName. Este é o hábito dos ocidentais. Na China, queremos iniciar a comparação com fristName sem modificar o código original.
Copie o código do código da seguinte forma:
final Comparador<Nome> FIRST_NAME_ORDER=novo Comparador<Nome>() {
public int compare(Nome n1, Nome n2) {
int primeiroCmp=n1.firstName.compareTo(n2.firstName);
retornar (primeiroCmp!=0?primeiroCmp:n1.lastName.compareTo
(n2.primeiroNome));
}
};
Desta forma, nosso Comparador customizado FIRST_NAME_ORDER é escrito.
Converta o array de nomes do exemplo anterior em uma Lista:
Copie o código do código da seguinte forma:
List<Nome> list=Arrays.asList(nomeArray);
Coleções.sort(lista,FIRST_NAME_ORDER);
Desta forma, definimos com sucesso a classificação usando nosso próprio comparador definido.