Introdução à classificação em Java
- A classificação em Java é basicamente organizar um grupo de elementos armazenados em algum lugar em uma ordem específica; essa ordem pode ser crescente ou decrescente. Existem muitos cenários na programação em tempo real, nos quais é necessário classificar os elementos, pois ele também procura um elemento específico é fácil, pois os elementos podem ser recuperados facilmente pelo índice de matrizes diretamente, se ordenados. Os elementos que precisam ser classificados podem ser armazenados em uma matriz ou em uma coleção. A coleção é de vários tipos em Conjuntos, Java, Árvore, Mapa, Heap, Lista, etc., embora existam tipos diferentes de Algoritmos de Classificação que são usados para classificar os elementos em uma Classificação de Bolha, Classificação de Heap, Classificação de Inserção, como Classificação de Bolha, Classificação de Heap e Classificação de Inserção, Seleção de seleção, Classificação de mesclagem etc.
- Os programadores usam algoritmos diferentes para classificar os elementos de acordo com seus requisitos específicos e a complexidade dos algoritmos. Esses algoritmos de classificação são implementados através do uso de vários loops e variáveis para iterá-lo. Além de usar os algoritmos de classificação para classificar os elementos em uma matriz, o Java fornece a função interna de classificação, que pode ajudar com o mesmo e o programador não precisa ficar preso em grandes ciclos e pensar em complexidade. Sim, você ouviu direito, na função Java sort () é usada para classificar os elementos armazenados em matrizes ou coleções e com muito menos complexidade de o (n (logn)). Embora a implementação do método em ambos seja um pouco diferente.
Sintaxe para matrizes:
Arrays.sort(array_name);
Para coleções
Collections.sort(array_name_list);
- Aqui array_name e array_name_list é o nome da matriz ou da coleção que precisa ser classificada.
- Matrizes são o nome das classes de Java.
- A coleção é uma estrutura em Java.
- sort () é a função de classificação embutida usada em Java.
Como a classificação é realizada em Java?
A seguir estão os pontos a seguir:
- Através do uso de algoritmos de classificação, a classificação também pode ser realizada com algoritmos que variam de ineficiente a eficiente e cada algoritmo tem sua própria complexidade de tempo e espaço.
- Às vezes, esses algoritmos têm uma complexidade muito alta e não podem ser usados em cenários reais em que é necessário lidar com grandes quantidades de dados.
- Como mencionado acima, na função embutida em Java, sort () é usado para classificar todos os elementos de uma matriz e coleção. De acordo com o Java DOC oficial, o Array.sort usa o quicksort, que é o pivô duplo e, comparativamente, muito mais rápido que o Quick Sort de um pivô.
- Uma das maiores vantagens disso é que ele fornece uma complexidade de O (n (logn)). Ele usa a implementação muito estável e iterativa do objeto de matriz de Merge Sort. Java fornece um método para classificar a matriz também em ordem inversa, de acordo com o requisito do programador de classificar em ordem crescente ou decrescente. O método Collections.reverseOrder () é usado para classificar os elementos em ordem inversa ou decrescente.
- O Java 8 também fornece a facilidade de classificar as matrizes paralelamente usando a classificação Parallel, que usa o conceito multithreading de Java e divide a matriz inteira em partes e as mescla após a classificação.
Tipos de classificação em Java
Abaixo mencionados, estão algumas das maneiras pelas quais a classificação pode ser executada em Classificação em Java:
1. classificação (array_name)
Isso é usado para classificar a matriz completa em ordem crescente. Por padrão, este método classifica os elementos da matriz em ordem crescente.
Código:
import java.util.Arrays;
public class SimpleSort
(
public static void main(String() args)
(
//Unsorted array of numbers
Integer() arr = new Integer() (100, 20, 10, 30, 80, 70, 90, 40, 50, 60);
//Sort function to sort the above array
Arrays.sort(arr);
//Printing the sorted array on console
System.out.println(Arrays.toString(arr));
)
)
Resultado:
2. Collection.reverseOrder ()
Este método em Java é usado para classificar a matriz em ordem inversa ou decrescente. Existem cenários em que precisamos classificar os elementos em ordem decrescente e o Java faz isso por meio do método interno.
Código:
import java.util.Arrays;
public class ReverseSort
(
public static void main(String() args)
(
//Unsorted array of numbers
Integer() arr = new Integer() ( 100, 20, 10, 30, 80, 70, 90, 40, 50, 60);
//Sort function to sort the above array
Arrays.sort(arr, Collections.reverseOrder());
//Printing the sorted array on console
System.out.println(Arrays.toString(arr));
)
)
Resultado:
3. sort (int () array_name, int findex, int lindex)
Se houver a necessidade de classificar parte de uma matriz em vez de toda a matriz, o Java fornece a facilidade de classificar esse tipo de matriz, especificando 3 parâmetros, por exemplo, nome da matriz, primeiro índice de onde a classificação precisa ser iniciada e a última indexe até quando a classificação precisar ser feita.
Código:
import java.util.Arrays;
public class ReverseSort
(
public static void main(String() args)
(
//Unsorted array of numbers
Integer() arr = new Integer() ( 100, 20, 10, 30, 80, 70, 90, 40, 50, 60);
//Sort function to sort the above array
Arrays.sort(arr, 1, 5);
//Printing the sorted array on console
System.out.println(Arrays.toString(arr));
)
Resultado:
4. Arrays.parllelSort (array_name)
Do Java 8, a nova API da classificação paralela foi lançada. Basicamente, na classificação paralela, a matriz é dividida em 2 sub-matrizes e, em seguida, a função básica Array.sort () é executada por um thread separado. As matrizes classificadas são então mescladas no final para formar a matriz totalmente classificada. Isso é feito para alavancar o uso de multiencadeamento.
Código:
import java.util.Arrays;
public class ParallelSort
(
public static void main(String() args)
(
//Unsorted array of numbers
Integer() arr = new Integer() ( 100, 20, 10, 30, 80, 70, 90, 40, 50, 60);
//parallel Sort function to sort the above array
Arrays.parallelSort(arr);
//Printing the sorted array on console
System.out.println(Arrays.toString(arr));
)
)
Resultado:
Como um Array.sort () normal, Arrays.parallelSort () também fornece a facilidade de classificar um intervalo específico de array ou classificá-lo em ordem inversa.
Sintaxe:
// to Sort a range of array by parallelsort
Arrays.parallelSort(array_name, findex, lindex);
// to sort an array in reverse order using parallelSort
Arrays.parallelSort(array_name, Collections.reverseOder());
5. Collection.sort ()
Este método é usado para classificar as coleções como list, map, Set, etc. Ele usa a classificação de mesclagem e fornece a mesma complexidade que Array.sort (), ou seja, O (n (logn)).
1. Classificando uma lista em ordem crescente
Código:
import java.util.Arrays;
import java.util.Collections;
public class ListSort
(
public static void main(String() args)
(
//Unsorted list
Integer() arr = new Integer() ( 100, 20, 10, 30, 80, 70, 90, 40, 50, 60 );
List arrList = Arrays.asList(arr);
//Sorting of list using the method
Collections.sort(arrList);
//Printing the list sorted above
System.out.println(arrList);
)
)
Resultado:
2. Classificando uma lista de matrizes em ordem decrescente
Código:
import java.util.Arrays;
import java.util.Collections;
public class ListSortRev
(
public static void main(String() args)
(
//Unsorted array list of Integers
Integer() arr = new Integer() (100, 20, 10, 30, 80, 70, 90, 40, 50, 60 );
List arrList = Arrays.asList(arr);
//Sorting of list using the method
Collections.sort(arrList);
//Printing the list sorted above
System.out.println(arrList);
)
)
Resultado:
3. Classificação do Conjunto
Existem três regras básicas ao classificar uma coleção 'Set' usando o método de classificação acima (array_name):
-
- Converta o conjunto na lista.
- Classifique a lista usando o método sort (array_name).
- Converta a lista classificada resultante novamente em Conjunto.
Código:
List numList = new ArrayList(num) ;
//Sorting the list retrieved above
Collections.sort(numList);
// Converting sorted List into Set
num = new LinkedHashSet(numList);
//Printing the Resulting Set on console
System.out.println(num);
)
)
Resultado:
4. Classifique um mapa
O Mapa de Coleta em Java é uma combinação de chave e valor. Portanto, a classificação pode ser feita nos dois sentidos, por chave ou por valor.
- Classificar um mapa por chave: Vamos ver o exemplo abaixo de Classificando um mapa por chave.
Código:
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
public class SortHashKey
(
public static void main(String() args)
(
HashMap map = new HashMap();
map.put(80, "Akshay");
map.put(20, "Akash");
map.put(10, "Bob");
map.put(30, “Nitika");
map.put(90, "Yashi");
map.put(100, "Dragisa");
TreeMap treeMap = new TreeMap(map);
System.out.println(treeMap);
)
)
Resultado:
Uma das maneiras mais fáceis de classificar os elementos do Mapa por Chaves é adicionando os elementos do mapa não classificados no TreeMap. O TreeMap classifica automaticamente os elementos na ordem crescente de Hash Keys. Embora collection.sort () também possa ser usado para fazer o mesmo, é um pouco complexo e precisa ser bem codificado.
- Classificar um mapa por valor: Abaixo mencionado, há um exemplo de como a classificação pode ser feita em um mapa usando valor.
Código:
import java.util.HashMap;
import java.util.Map;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.Map;
public class SortHashValue
(
public static void main(String() args)
(
HashMap map = new HashMap(); map.put(80, "Akshay");
map.put(20, "Akash");
map.put(10, "Bob");
map.put(30, “Nitika");
map.put(90, "Yashi");
map.put(100, "Dragisa");
LinkedHashMap sorted = new LinkedHashMap(); map.entrySet()
.stream()
.sorted(Map.Entry.comparingByValue())
.forEachOrdered(x -> sorted.put(x.getKey(), x.getValue()));
Resultado:
No exemplo acima de classificação do mapa por valor, primeiro definimos as entradas usando o map.entrySet () e, em seguida, o fluxo dessas entradas usando o método stream (), chame a matriz classificada usando o método classificado () comparando o valor no par. para cada ordenado () é usado para percorrer o fluxo para produzir o resultado.
5. Comparável
Comparable é uma interface e torna as classes comparáveis às suas instâncias.
Para comparar as duas instâncias da mesma classe, a interface Comparable precisa ser implementada e o método compareTo () precisa ser substituído. As classes que implementam essa interface e sua lista de objetos são classificadas automaticamente usando o método Collections.sort () e Arrays.sort ().
Código:
ArrayList list = new ArrayList();
// Adding the instance objects of class Employee in list
list.add(new Employee(10, "Akshay")));
list.add(new Employee(40, "Bob")));
list.add(new Employee(20, "Priyansh")));
list.add(new Employee(50, "Chandni")));
list.add(new Employee(70, "Yashi")));
Collections.sort(list);
// Printing the sorted list on Console
System.out.println(list);
Resultado:
Conclusão
Explicados acima, estão os métodos Classificação em Java que são usados em Java para vários cenários de Matrizes e Coleções. Um programador precisa ter em mente como o método sort () deve ser usado para diferentes tipos de coleção. Com o Java 8, a classificação também pode ser feita através do Lambdas para implementar a interface Comparator, o que facilita a classificação. Embora seja um pouco difícil aprender todas elas, pode ser fácil trabalhar com elas se todos os conceitos básicos de Java, especialmente fluxo de dados, matrizes e coleções, forem claros. Embora os algoritmos de classificação sejam sempre verdes e possam ser facilmente implementados em outras linguagens de programação semelhantes a Java, eles têm complexidade variada e a função interna sort () de Java facilita as coisas se os conceitos básicos forem aprendidos de cor.
Artigos recomendados
Este é um guia para Classificação em Java. Aqui discutimos como a classificação é executada em java e os tipos de classificação em java com diferentes códigos e saídas. Você também pode consultar nossos outros artigos relacionados para saber mais.
- JComboBox em Java
- Classificação em C
- Heap Classificar em C
- Bubble Classificar em JavaScript
- O que é classificação em C ++?
- Introdução à classificação em PHP
- Heap Sort em Python
- Inserção Ordenar em JavaScript
- Hashmap em Java
- Exemplo comparável em Java | Interface de coleção em Java