TOC

Livro de receitas de pedidos de goiaba

Livro de receitas de pedidos de goiaba

1. Introdução

Este livro de receitas ilustrahow to use the Guava style Ordering and Comparators. É a continuação do livro de receitas e do formato de foco de exemplo que comecei emthe previous post about Guava collections.

2. The Cookbook

lidar com nulos em uma coleção

nulos primeiro 

List toSort = Arrays.asList(3, 5, 4, null, 1, 2);
Collections.sort(toSort, Ordering.natural().nullsFirst());
assertThat(toSort.get(0), nullValue());

nulos por último 

List toSort = Arrays.asList(3, 5, 4, null, 1, 2);
Collections.sort(toSort, Ordering.natural().nullsLast());
assertThat(toSort.get(toSort.size() - 1), nullValue());

ordenação natural 

List toSort = Arrays.asList(3, 5, 4, 1, 2);
Collections.sort(toSort, Ordering.natural());

assertTrue(Ordering.natural().isOrdered(toSort));

encadeando 2 pedidos 

List toSort = Arrays.asList(3, 5, 4, 1, 2);
Collections.sort(toSort, Ordering.natural().reverse());

inverter uma ordem 

List toSort = Arrays.asList(3, 5, 4, null, 1, 2);
Collections.sort(toSort, Ordering.natural().nullsLast().reverse());
assertThat(toSort.get(0), nullValue());

pedido personalizado - Strings por comprimento 

private class OrderingByLenght extends Ordering {
    @Override
    public int compare(String s1, String s2) {
        return Ints.compare(s1.length(), s2.length());
    }
}
List toSort = Arrays.asList("zz", "aa", "b", "ccc");
Ordering byLength = new OrderingByLenght();
Collections.sort(toSort, byLength);

Ordering expectedOrder = Ordering.explicit(Lists.newArrayList("b", "zz", "aa", "ccc"));
assertTrue(expectedOrder.isOrdered(toSort))

verificando ordem explícita 

List toSort = Arrays.asList("zz", "aa", "b", "ccc");
Ordering byLength = new OrderingByLenght();
Collections.sort(toSort, byLength);

Ordering expectedOrder = Ordering.explicit(Lists.newArrayList("b", "zz", "aa", "ccc"));
assertTrue(expectedOrder.isOrdered(toSort));

verificando a ordem das strings 

List toSort = Arrays.asList(3, 5, 4, 2, 1, 2);
Collections.sort(toSort, Ordering.natural());

assertFalse(Ordering.natural().isStrictlyOrdered(toSort));

ordenação secundária 

List toSort = Arrays.asList("zz", "aa", "b", "ccc");
Ordering byLength = new OrderingByLenght();
Collections.sort(toSort, byLength.compound(Ordering.natural()));

Ordering expectedOrder = Ordering.explicit(Lists.newArrayList("b", "aa", "zz", "ccc"));
assertTrue(expectedOrder.isOrdered(toSort));

exemplo de pedido personalizado complexo - com encadeamento 

List toSort = Arrays.asList("zz", "aa", null, "b", "ccc");
Collections.sort(toSort,
    new OrderingByLenght().reverse().compound(Ordering.natural()).nullsLast());
System.out.println(toSort);

classificar usando a representaçãotoString 

List toSort = Arrays.asList(1, 2, 11);
Collections.sort(toSort, Ordering.usingToString());

Ordering expectedOrder = Ordering.explicit(Lists.newArrayList(1, 11, 2));
assertTrue(expectedOrder.isOrdered(toSort));

classificar, depois localizar (pesquisa binária) 

List toSort = Arrays.asList(1, 2, 11);
Collections.sort(toSort, Ordering.usingToString());
int found = Ordering.usingToString().binarySearch(toSort, 2);
System.out.println(found);

encontre mín. / máx. sem ter que classificar (mais rápido) 

List toSort = Arrays.asList(2, 1, 11, 100, 8, 14);
int found = Ordering.usingToString().min(toSort);
assertThat(found, equalTo(1));

criando uma cópia classificada da lista de um pedido 

List toSort = Arrays.asList("aa", "b", "ccc");
List sortedCopy = new OrderingByLenght().sortedCopy(toSort);

Ordering expectedOrder = Ordering.explicit(Lists.newArrayList("b", "aa", "ccc"));
assertFalse(expectedOrder.isOrdered(toSort));
assertTrue(expectedOrder.isOrdered(sortedCopy));

criando uma cópia parcial classificada - o mínimo de poucos elementos 

List toSort = Arrays.asList(2, 1, 11, 100, 8, 14);
List leastOf = Ordering.natural().leastOf(toSort, 3);
List expected = Lists.newArrayList(1, 2, 8);
assertThat(expected, equalTo(leastOf));

ordenar por função intermediária 

List toSort = Arrays.asList(2, 1, 11, 100, 8, 14);
Ordering ordering = Ordering.natural().onResultOf(Functions.toStringFunction());
List sortedCopy = ordering.sortedCopy(toSort);

List expected = Lists.newArrayList(1, 100, 11, 14, 2, 8);
assertThat(expected, equalTo(sortedCopy));





-note: a lógica de classificação irá primeiro executar os números através da função - transformando-os em Strings - depois classificar com ordem natural nas Strings 








3. Mais livros de receitas de goiaba 






Guava é uma biblioteca abrangente e fantasticamente útil - aqui estão mais algumas APIs abordadas na forma de livro de receitas: 











Desfrutar. 










4. Conclusão 






Este formato experimental - o livro de receitas - tem um foco claro - simplicidade e velocidade, então a maioria das receitas temno additional explanation other than the code example itself. 






E como mencionei antes - isso comoa living document - novos exemplos e casos de uso são bem-vindos nos comentários, e continuarei adicionando meus próprios conforme os encontrar. 






A implementação de todos esses exemplos e trechos de códigocan be found over on GitHub - este é um projeto baseado em Maven, portanto, deve ser fácil de importar e executar como está. 







                    

                        


    
    
    
    
    
    
    
    
    
    
    
    





                    

                
                



            
            

                

    
    
    


                

    
    
    


                

    
Related