Como classificar uma matriz de objects em Java?

Meu array não contém nenhuma string. Mas contém referências a objects. Cada referência de object retorna o nome, o id, o autor e o editor pelo método toString.

public String toString() { return (name + "\n" + id + "\n" + author + "\n" + publisher + "\n"); } 

Agora preciso classificar essa matriz de objects pelo nome. Eu sei como classificar, mas não sei como extrair o nome dos objects e organizá-los.

Você tem duas maneiras de fazer isso, ambas usam a class de utilitário Arrays

  1. Implemente um Comparador e passe sua matriz junto com o comparador para o método de sorting, que o utiliza como segundo parâmetro.
  2. Implemente a interface Comparable na class da qual seus objects são e passe sua matriz para o método de sorting que usa apenas um parâmetro.

Exemplo

 class Book implements Comparable { public String name, id, author, publisher; public Book(String name, String id, String author, String publisher) { this.name = name; this.id = id; this.author = author; this.publisher = publisher; } public String toString() { return ("(" + name + ", " + id + ", " + author + ", " + publisher + ")"); } @Override public int compareTo(Book o) { // usually toString should not be used, // instead one of the attributes or more in a comparator chain return toString().compareTo(o.toString()); } } @Test public void sortBooks() { Book[] books = { new Book("foo", "1", "author1", "pub1"), new Book("bar", "2", "author2", "pub2") }; // 1. sort using Comparable Arrays.sort(books); System.out.println(Arrays.asList(books)); // 2. sort using comparator: sort by id Arrays.sort(books, new Comparator() { @Override public int compare(Book o1, Book o2) { return o1.id.compareTo(o2.id); } }); System.out.println(Arrays.asList(books)); } 

Saída

 [(bar, 2, author2, pub2), (foo, 1, author1, pub1)] [(foo, 1, author1, pub1), (bar, 2, author2, pub2)] 

Você pode tentar algo assim:

 List books = new ArrayList(); Collections.sort(books, new Comparator(){ public int compare(Book o1, Book o2) { return o1.name.compareTo(o2.name); } }); 

Java 8


Usando expressões lambda

 Arrays.sort(myTypes, (a,b) -> a.name.compareTo(b.name)); 

Test.java

 public class Test { public static void main(String[] args) { MyType[] myTypes = { new MyType("John", 2, "author1", "publisher1"), new MyType("Marry", 298, "author2", "publisher2"), new MyType("David", 3, "author3", "publisher3"), }; System.out.println("--- before"); System.out.println(Arrays.asList(myTypes)); Arrays.sort(myTypes, (a, b) -> a.name.compareTo(b.name)); System.out.println("--- after"); System.out.println(Arrays.asList(myTypes)); } } 

MyType.java

 public class MyType { public String name; public int id; public String author; public String publisher; public MyType(String name, int id, String author, String publisher) { this.name = name; this.id = id; this.author = author; this.publisher = publisher; } @Override public String toString() { return "MyType{" + "name=" + name + '\'' + ", id=" + id + ", author='" + author + '\'' + ", publisher='" + publisher + '\'' + '}' + System.getProperty("line.separator"); } } 

Saída:

 --- before [MyType{name=John', id=2, author='author1', publisher='publisher1'} , MyType{name=Marry', id=298, author='author2', publisher='publisher2'} , MyType{name=David', id=3, author='author3', publisher='publisher3'} ] --- after [MyType{name=David', id=3, author='author3', publisher='publisher3'} , MyType{name=John', id=2, author='author1', publisher='publisher1'} , MyType{name=Marry', id=298, author='author2', publisher='publisher2'} ] 

Usando referências de methods

 Arrays.sort(myTypes, MyType::compareThem); 

onde compareThem tem que ser adicionado em MyType.java :

 public static int compareThem(MyType a, MyType b) { return a.name.compareTo(b.name); } 

Às vezes você deseja classificar uma matriz de objects em um valor arbitrário. Como compareTo () sempre usa as mesmas informações sobre a instância, convém usar uma técnica diferente. Uma maneira é usar um algoritmo de sorting padrão. Digamos que você tenha uma matriz de livros e queira classificá-los em sua altura, que é armazenada como um int e acessível através do método getHeight (). Veja como você pode classificar os livros em sua matriz. (Se você não quiser alterar o array original, simplesmente faça uma cópia e classifique isso.)

 `int tallest; // the index of tallest book found thus far Book temp; // used in the swap for(int a = 0; a < booksArray.length - 1; a++) { tallest = a; // reset tallest to current index // start inner loop at next index for(int b = a + 1; b < booksArray.length; b++) // check if the book at this index is taller than the // tallest found thus far if(booksArray[b].getHeight() > booksArray[tallest].getHeight()) tallest = b; // once inner loop is complete, swap the tallest book found with // the one at the current index of the outer loop temp = booksArray[a]; booksArray[a] = booksArray[tallest]; booksArray[tallest] = temp; }` 

Quando este código é feito, a matriz do object Book será ordenada por altura em ordem decrescente – o sonho de um designer de interiores!

com java 8 usando o método de referência

você pode adicionar o método compare à sua class Book

 class Book { public static int compare(Book a , Book b) { return a.name.compareTo(b.name); } } 

e então você poderia fazer isso:

 Arrays.sort(books , Book::compare); 

aqui está o exemplo completo:

 static class Book { String name; String author; public Book(String name, String author) { this.name = name; this.author = author; } public static int compareBooks(Book a , Book b) { return a.name.compareTo(b.name); } @Override public String toString() { return "name : " + name + "\t" + "author : " + author; } } public static void main(String[] args) { Book[] books = { new Book("Book 3" , "Author 1"), new Book("Book 2" , "Author 2"), new Book("Book 1" , "Author 3"), new Book("Book 4" , "Author 4") }; Arrays.sort(books , Book::compareBooks); Arrays.asList(books).forEach(System.out::println); } 

Você pode implementar a interface “Comparável” em uma class cujos objects você deseja comparar.

E também implementar o método “compareTo” nisso.

Adicione as instâncias da class em uma ArrayList

Então o método “java.utils.Collections.sort ()” fará a mágica necessária.

Aqui está —> ( https://deva-codes.herokuapp.com/CompareOnTwoKeys ) um exemplo de trabalho onde os objects são classificados com base em duas chaves primeiro pelo id e depois pelo nome.

 public class Student implements Comparable { private int sid; private String sname; public Student(int sid, String sname) { super(); this.sid = sid; this.sname = sname; } public int getSid() { return sid; } public void setSid(int sid) { this.sid = sid; } public String getSname() { return sname; } public void setSname(String sname) { this.sname = sname; } @Override public String toString() { return "Student [sid=" + sid + ", sname=" + sname + "]"; } public int compareTo(Student o) { if (this.getSname().compareTo(o.getSname()) > 1) { return toString().compareTo(o.getSname()); } else if (this.getSname().compareTo(o.getSname()) < 1) { return toString().compareTo(o.getSname()); } return 0; } } 
 import java.util.Collections; import java.util.List; import java.util.ArrayList; public class Test { public static void main(String[] args) { List str = new ArrayList(); str.add(new Student(101, "aaa")); str.add(new Student(104, "bbb")); str.add(new Student(103, "ccc")); str.add(new Student(105, "ddd")); str.add(new Student(104, "eee")); str.add(new Student(102, "fff")); Collections.sort(str); for(Student student : str) { System.out.println(student); } } }