Mijn array bevat geen enkele tekenreeks. Maar het bevat objectreferenties. Elk object Referentie retourneert naam, ID, auteur en uitgever door Tostring-methode.
public String toString() {
return (name + "\n" + id + "\n" + author + "\n" + publisher + "\n");
}
Nu moet ik die reeks objecten op de naam sorteren. Ik weet hoe ik moet sorteren, maar ik weet niet hoe ik de naam van de objecten kan extraheren en ze sorteren.
Antwoord 1, Autoriteit 100%
U hebt twee manieren om dat te doen, beide gebruiken de arrays Hulpprogramma’s
- Implementeer een comparator en passeer je array samen met de comparator Naar de Sorteermethode die het als tweede parameter nemen.
- Implementeer de vergelijkbare interface in de klasse zijn uw objecten van En geef uw array door op de Sorteer methode die slechts één parameter nodig heeft.
voorbeeld
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));
}
Uitvoer
[(bar, 2, author2, pub2), (foo, 1, author1, pub1)]
[(foo, 1, author1, pub1), (bar, 2, author2, pub2)]
Antwoord 2, autoriteit 97%
Je kunt zoiets als dit proberen:
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);
}
});
Antwoord 3, autoriteit 80%
Java 8
lambda-expressies gebruiken
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));
}
}
MijnType.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");
}
}
Uitvoer:
--- 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'}
]
met behulp van methode referenties
Arrays.sort(myTypes, MyType::compareThem);
Waar compareThemmoet worden toegevoegd in mytype.java :
public static int compareThem(MyType a, MyType b) {
return a.name.compareTo(b.name);
}
Antwoord 4, Autoriteit 25%
Update voor Java 8 Constructs
Veronderstellen van een BookKlasse met een nameVELD GETTER, U kunt Arrays.sortmethode door een extra ComparatorGespecificeerd met Java 8 Constructs – comparator standaardmethode & amp; methode referenties .
Arrays.sort(bookArray, Comparator.comparing(Book::getName));
Het is ook mogelijk om te vergelijken op meerdere velden met thenComparingmethoden.
Arrays.sort(bookArray, Comparator.comparing(Book::getName)
.thenComparing(Book::getAuthor))
.thenComparingInt(Book::getId));
Antwoord 5, Autoriteit 5%
Met Java 8 kunt u een referentiemethode gebruiken.
U kunt comparemethode op uw Bookklasse
class Book {
public static int compare(Book a, Book b) {
return a.name.compareTo(b.name);
}
}
En dan zou u dit kunnen doen:
Arrays.sort(books, Book::compare);
Hier is het volledige voorbeeld:
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);
}
}
Antwoord 6, Autoriteit 2%
[Employee(name=John, age=25, salary=3000.0, mobile=9922001),
Employee(name=Ace, age=22, salary=2000.0, mobile=5924001),
Employee(name=Keith, age=35, salary=4000.0, mobile=3924401)]
public void whenComparing_thenSortedByName() {
Comparator<Employee> employeeNameComparator
= Comparator.comparing(Employee::getName);
Arrays.sort(employees, employeeNameComparator);
assertTrue(Arrays.equals(employees, sortedEmployeesByName));
}
Resultaat
[Employee(name=Ace, age=22, salary=2000.0, mobile=5924001),
Employee(name=John, age=25, salary=3000.0, mobile=9922001),
Employee(name=Keith, age=35, salary=4000.0, mobile=3924401)]
Antwoord 7, Autoriteit 2%
Arrays.sort(yourList,new Comparator<YourObject>() {
@Override
public int compare(YourObjecto1, YourObjecto2) {
return compare(o1.getYourColumn(), o2.getYourColumn());
}
});
Antwoord 8
Soms wilt u een reeks objecten op een willekeurige waarde sorteren. Omdat vergelijken () altijd dezelfde informatie over het exemplaar gebruikt, wilt u misschien een andere techniek gebruiken. Eén manier is om een standaard sorteeralgoritme te gebruiken. Laten we zeggen dat je een scala aan boeken hebt en je ze op hun hoogte wilt sorteren, die wordt opgeslagen als een int en toegankelijk via de methode Getheight (). Hier is hoe je de boeken in je array kunt sorteren. (Als u de originele array niet wilt wijzigen, maakt u eenvoudig een kopie en sorteer dan dat.)
`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;
}`
Als deze code is voltooid, wordt de reeks Book-objecten gesorteerd op hoogte in aflopende volgorde – de droom van een interieurontwerper!
Antwoord 9
Je kunt de “Vergelijkbare” interface implementeren op een klasse waarvan je de objecten wilt vergelijken.
En implementeer daarin ook de “compareTo”-methode.
Voeg de instanties van de klasse toe aan een ArrayList
Dan zal de “java.utils.Collections.sort()” methode de nodige magie doen.
Hier is—>(https://deva-codes.herokuapp.com/CompareOnTwoKeys) een werkend voorbeeld waarbij objecten worden gesorteerd op basis van twee sleutels, eerst op id en vervolgens op naam.
Antwoord 10
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;
}
}
Antwoord 11
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);
}
}
}