Pausa para café #136. Classifique um array em ordem crescente ou decrescente usando Arrays.sort(). Qual é a diferença entre as interfaces List e Set?

Classifique um array em ordem crescente ou decrescente usando Arrays.sort()

Fonte: FreeCodeCamp Com esta postagem, você aprenderá como classificar um array em ordem crescente ou decrescente em Java. Em Java, usamos arrays para armazenar um conjunto de variáveis ​​(com o mesmo tipo de dados) em uma única variável. Mas às vezes os valores armazenados no array aparecem em ordem aleatória. Graças à classe Arrays em Java, temos várias maneiras de manipular arrays, incluindo classificá-los. Um dos métodos que usaremos da classe Arrays é o método sort() , que classifica o array em ordem crescente. Para classificar um array em ordem decrescente, use o método reverseOrder() da classe Collections em Java.

Como classificar um array em ordem crescente em Java usando Arrays.sort()

Aqui está um exemplo de como podemos usar o método sort() para classificar um array em ordem crescente.

import java.util.Arrays;

class ArraySort {
    public static void main(String[] args) {
        int[] arr = { 5, 2, 1, 8, 10 };
        Arrays.sort(arr);

        for (int values : arr) {
            System.out.print(values + ", ");
            // 1, 2, 5, 8, 10,
        }
    }
}

A primeira coisa que fizemos no exemplo acima foi importar a classe Arrays : import java.util.Arrays; . Isso nos dá acesso a todos os métodos da classe Arrays . Em seguida criamos um array com números em ordem aleatória: int[] arr = { 5, 2, 1, 8, 10 }; . Para classificar esse array em ordem crescente, passamos o array como parâmetro para o método sort() : Arrays.sort(arr); . Observe que a classe Arrays é escrita primeiro, antes de acessar o método sort() usando notação de ponto. Por fim, criamos um loop e imprimimos o array no console. O resultado é uma matriz classificada: 1, 2, 5, 8, 10 . Agora vamos falar sobre a classificação de um array em ordem decrescente.

Como classificar um array em ordem decrescente em Java usando Collections.reverseOrder()

Para classificar um array em ordem decrescente, você deve usar reverseOrder() , que pode ser acessado na classe Collections . Ainda usaremos Arrays.sort(); , mas neste exemplo serão necessários dois parâmetros - uma matriz para classificar e Collections.reverseOrder() .

import java.util.Arrays;
import java.util.Collections;

class ArraySort {
    public static void main(String[] args) {
        Integer[] arr = { 5, 2, 1, 8, 10 };
        Arrays.sort(arr, Collections.reverseOrder());

        for (int values : arr) {
            System.out.print(values + ", ");
            // 10, 8, 5, 2, 1,
        }
    }
}

A primeira coisa que fizemos foi importar as classes Arrays e Collections porque usaremos os métodos fornecidos por essas classes. Em seguida, criamos um array de números em ordem aleatória: Integer[] arr = { 5, 2, 1, 8, 10 }; . Como você pode ver, usamos Integer[] em vez de int[] como no exemplo anterior. Caso contrário, ocorrerá um erro. Para classificar o array em ordem decrescente, fizemos o seguinte: Arrays.sort(arr, Collections.reverseOrder()); . O primeiro parâmetro é um array arr que será classificado em ordem crescente. O segundo parâmetro, Collections.reverseOrder() , reverterá a ordem do array classificado para que fique em ordem decrescente. Quando repetido e impresso, o array ficará assim: 10, 8, 5, 2, 1 .

Conclusão

Neste artigo, discutimos sobre a classificação de arrays em Java - como eles podem ser classificados em ordem crescente ou decrescente. Para fazer isso, podemos usar o método sort() , que pode ser acessado a partir da classe Arrays . O método sort() usa um array para classificar como parâmetro. Para classificar o array em ordem decrescente, usamos o método reverseOrder() fornecido pela classe Collections. Ele é passado como o segundo parâmetro para o método sort() para que o array classificado possa ser reordenado em ordem decrescente.

Coleção Java. Qual é a diferença entre as interfaces List e Set?

Fonte: Rrtutors List e Set são interfaces Java para estender a interface Collection . Nesta postagem, veremos as principais diferenças entre os dois e como eles podem ser usados.

Diferenças entre interfaces Set e List em Java

Vamos definir as principais diferenças entre as interfaces List e Set com base nos seguintes parâmetros principais:

Implementação

List implementa ArrayLists , enquanto HashSet implementa Set .

Indexação

Você pode usar ListIterator para avançar e retroceder em um List , mas não em um Set . Em vez disso, use Iterator (que funciona com List e Set ).

Ordem

A interface Set não oferece suporte a nenhuma ordem de conjunto específica. Uma coleção do tipo Set já está ordenada de acordo com sua própria regra e não pode ser ordenada assim. Lista é uma lista ordenada. Os objetos são armazenados na ordem em que foram adicionados à lista. Os elementos da lista são acessados ​​por índice.

Objeto nulo

List não tem restrições e suporta adição de valores nulos, enquanto Set permite no máximo um valor nulo.

Duplicatas

A lista pode conter duplicatas, mas o conjunto não. Set não permite elementos duplicados porque todos os seus elementos devem ser únicos. Se você inserir um elemento duplicado em Set , o valor existente será substituído.

Quando você deve usar List e Set?

Set é a melhor escolha quando você precisa apenas armazenar valores únicos, já que é para isso que foi projetado. Mas se você quiser preservar o pedido de inserção apesar da duplicação, List é a melhor escolha .

Conjunto de exemplos

import java.util.ArrayList;

import java.util.LinkedList;

import java.util.List;

public class ListExample {

            public static void main(String[] args) {

                        List<String> al = new ArrayList<String>();

                          al.add("Rohit");

                          al.add("Panjab");

                          al.add("Kamir");

                          System.out.println("My ArrayList Items: ");

                          System.out.print(al);

                          List<String> ll = new LinkedList<String>();

                          ll.add("Shobit");

                          ll.add("Raul");

                          ll.add("Ketel");

                          System.out.println("\n My LinkedList Items: ");

                          System.out.print(ll);

            }

}

Lista de exemplos

import java.util.HashSet;

import java.util.Set;

import java.util.TreeSet;

public class SetExample {

            public static void main(String[] args) {

                          int myList[] = {60, 70, 80, 40 };

                            Set<Integer> dispSet = new HashSet<Integer>();

                            try{

                              for(int i = 0; i<4; i++){

                                dispSet.add(myList[i]);

                              }

                              System.out.println(dispSet);

                              TreeSet<Integer> treeset = new TreeSet<Integer>(dispSet);

                              System.out.println("Sorting in Asceding order:");

                              System.out.println(treeset);

                            }

                            catch(Exception e){

                                e.printStackTrace();

                            }

            }

}