por - ¿Cómo ordenar una matriz de objetos en Java?

ordenar objeto java

Question

Mi matriz no contiene ninguna cadena. Pero contiene referencias de objeto. Cada referencia de objeto devuelve nombre, id, autor y editorial mediante el método toString.

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

Ahora necesito ordenar esa matriz de objetos por el nombre. Sé cómo ordenar, pero no sé cómo extraer el nombre de los objetos y ordenarlos.

Answer 1

Java 8

Usando expresiones 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");
}
}

Salida:

--- 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''}
]

Usar referencias de método

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

donde compareThem tiene que ser agregado en MyType.java :

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

Answer 2

A veces, desea ordenar una matriz de objetos en un valor arbitrario. Como compareTo () siempre usa la misma información sobre la instancia, es posible que desee utilizar una técnica diferente. Una forma es usar un algoritmo de clasificación estándar. Supongamos que tiene una matriz de libros y desea ordenarlos según su altura, que se almacena como un int y se puede acceder a través del método getHeight (). Así es como puedes ordenar los libros en tu matriz. (Si no desea cambiar la matriz original, simplemente haga una copia y ordene eso).

`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;
}`

Cuando se completa este código, la matriz del objeto Libro se ordenará por altura en orden descendente: ¡el sueño de un diseñador de interiores!

Answer 3

Puede implementar la interfaz "Comparable" en una clase cuyos objetos desea comparar.

Y también implementar el método "compareTo" en eso.

Agregue las instancias de la clase en ArrayList

Entonces el método "java.utils.Collections.sort ()" hará la magia necesaria.

Aquí está ---> ( https://deva-codes.herokuapp.com/CompareOnTwoKeys ) un ejemplo de trabajo donde los objetos se ordenan en base a dos claves primero por el id y luego por el nombre.

Answer 4

Puedes probar algo como esto:

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

Answer 5

Tienes dos formas de hacerlo, ambos usan la clase de utilidad Arrays

1. Implemente un Comparator y pase su matriz junto con el comparador al método de clasificación, que lo toma como segundo parámetro.
2. Implementa la interfaz Comparable en la clase de la que son tus objetos y pasa tu matriz al método de ordenamiento que toma solo un parámetro.

Ejemplo

class Book implements Comparable<Book> {
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<Book>() {
@Override
public int compare(Book o1, Book o2) {
return o1.id.compareTo(o2.id);
}
});
System.out.println(Arrays.asList(books));
}

Salida

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

Answer 6

con Java 8 utilizando el método de referencia

podrías agregar el método de compare a tu clase de Book

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

y luego podrías hacer esto:

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

aquí hay un ejemplo 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);
}

Answer 7

import java.util.Collections;
import java.util.List;
import java.util.ArrayList;
public class Test {
public static void main(String[] args) {
List<Student> str = new ArrayList<Student>();
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);
}
}
}

Answer 8

public class Student implements Comparable<Student> {
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;
}
}