Една от най-често срещаните функции, от които се нуждаем като разработчици, работещи с данни, е сортирането – като можем да сортираме нашите данни, можем да оптимизираме алгоритмите си да работят много по-бързо и да намираме данните, от които се нуждаем, за част от времето, което би предприел по друг начин. В днешния урок ще говорим за Java Collections sort(). Като бърз мисловен експеримент: представете си, че търсите име в списъка на университета. В това учorще може да има десетки хиляди ученици. Ако списъкът, който ви е даден, не е в азбучен ред, ще трябва да прелистите всяка отделна page и да погледнете много внимателно, за да сте сигурни, че не сте пропуснали нито едно име, докато най-накрая намерите името, което търсите. От друга страна, ако списъкът е подреден по азбучен ред, не само трябва да бъдете по-малко взискателни в търсенето си, но можете лесно да преминете към секцията в списъка със същата първа буква и да продължите да прескачате страниците с големи скокове, докато не стигнете до човека, когото търсите. С колкото повече данни работите, толкова по-важно е да ги използвате възможно най-ефективно и ефикасно. В тази статия ще разгледаме How да сортирате всяка реализация на List в Java (включително ArrayList) с помощта на метода за сортиране на колекции.
Как да сортирате ArrayList в Java с помощта на метода за сортиране на колекциите на Java
Нека поговорим за метода Java Collections.sort. Пакетът java.util съдържа много полезни помощни програми и пакети, които често се използват от разработчиците, включително ArrayList. Да предположим, че имате следната проста програма:
import java.util.*;
import java.io.*;
class Main{
public static void main(String[] args){
List<String> colors = new ArrayList<String>();
colors.add("Red ");
colors.add("Orange");
colors.add("Green");
colors.add("Blue");
}
}
Искате да можете да отпечатате списъка с цветове, но по азбучен ред. Как бихте могли да направите това? Използвайки java.util.Collections, сортирането е толкова лесно, колкото едноредов:
Collections.sort(colors);
Та-да! Вашият списък с цветове вече е сортиран на място. Ако трябваше да отпечатате списъка като такъв:
System.out.println(colors);
Тогава ще получите следния изход:
[Blue, Green, Orange, Red]
Колко лесно беше това?! Би било също толкова лесно да използвате Collections.sort(), за да сортирате във възходящ ред списък с цели числа, плаващи числа or всеки друг прост тип данни. Но Howво ще стане, ако искате да сортирате в низходящ ред? Определено има случаи, в които това има смисъл – представете си, че имате списък с резултати от тестове за определен клас и искате да разберете кои са учениците с най-добри резултати. Би било много по-логично да сортирате списъка в низходящ ред (първо най-високите резултати), така че отговорите, които търсите, да са точно в горната част. За щастие, Collections.sort() е презаписан с незадължителен втори параметър, който ви позволява да правите точно това:
sort(List l, Comparator c)
Но Howво е компаратор? Е, компараторът е просто функция, която сравнява два входа и връща число, представляващо кой вход е първи. Ако сортирате ArrayList от примитивни типове данни, тогава Java Collections вече ви предоставя reverseOrder() компаратор. Може да се нарече така:
Сега цветовете са сортирани обратно на място, така че ако го отпечатате, ще получите следния резултат:
[Red, Orange, Green, Blue]
Как да използвате колекции за сортиране на непримитивни типове данни в Java
Досега видяхте, че сортирането на ArrayLists от низове or int в Java с помощта на метода Collections.sort() е лесно като един ред code. Но често вашите ArrayLists ще съхраняват непримитивни типове данни. Когато работите с данни, които имат по-сложни атрибути, ще искате да напишете класове, които да представят тези обекти и How те ще бъдат сравнени един с друг, използвайки техните атрибути. За да разгледаме пример за това, нека преразгледаме примера за сортиране на списък от цветове, но този път, instead of да сортираме низове, ще сортираме цветни обекти. Нашият основен клас цвят може да изглежда така:
public class Color{
private int r;
private int g;
private int b;
private String name;
Color(String name, int red, int green, int blue){
this.name = name;
this.r = red;
this.g = green;
this.b = blue;
}
}
За да направим нашия клас Color съвместим с Collections.sort(), така че Collections да могат да разберат How да сравняват и сортират Color обекти, трябва да направим две малки модификации:
направете Color a Comparable обект (добавете implements Comparable<Object>)
замени метода compareTo в класа (замени public int compareTo(Object o))
С тези модификации нашият клас сега изглежда така:
public class Color implements Comparable<Object>{
private int r;
private int g;
private int b;
private String name;
Color(int red int green, int blue, String name){
this.r = red;
this.g = green;
this.b = blue;
this.name = name;
}
@Override
public int compareTo(Object o) {
Color c = (Color) o;
return this.name.compareTo(c.name);
}
}
Забележете, че методът compareTo на Color просто извиква метода compareTo на String; сортирането ще се извършва по азбучен ред. Ако искаме да сортираме по червена стойност във възходящ ред, например, бихме могли да заменим израза return с return this.r - cr; (ако искаме да сортираме по зелена стойност в низходящ ред, ще бъде return cg - this.g;). Сега, ако се обадим
Collections.sort(colors);
на ArrayList от цветове, а не само на низове, ще работи, защото Collections разбира How да сравнява цветни обекти. Ако не искате вашият обект да изпълнява Comparable<Object>, можете алтернативно да напишете компаратор за вашия клас и да го предадете в метода Collections.sort() с 2 параметъра. Сравнителят заменя метод public int compare(Object one, Object two), а методът Collections.sort() използва това, за да сравнява обекти по време на сортиране. Пример за компаратори SortByName и SortByRed са внедрени по-долу:
class SortByName implements Comparator<Color>
{
public int compare(Color a, Color b)
{
return a.name.compareTo(b.name);
}
}
class SortByRGB implements Comparator<Color>
{
public int compare(Color a, Color b)
{
return a.r - b.r;
}
}
С това вече можете да се обадите
Collections.sort(colors, new SortByName());
без класът Color действително да прилага Comparable и пак ще работи. Понякога ще видите, че това се прави на линия, като се използват ламбда функции. Ламбда функцията е по същество безименна функция, която можете да дефинирате в реда на codeа, който я извиква. Те са полезни, когато трябва да извикате функция само за един конкретен случай и не искате да дефинирате цяла отделна функция другаде. Сравнителят SortByName може да бъде дефиниран в линия, като се използва ламбда функция, като тази:
Както може би се досещате, (a, b) представлява параметрите на ламбда функциите (двата обекта за сравнение). -> означава, че това, което следва, е дефиниция на ламбда функция. Това е всичко! Вече видяхте най-популярните методи за сортиране на ArrayLists в Java с помощта на пакета Collections.
GO TO FULL VERSION