Java Collections sort()

אחת הפונקציות הנפוצות ביותר שאנו צריכים כמפתחים העוסקים בנתונים היא מיון - על ידי היכולת למיין את הנתונים שלנו, נוכל לייעל את האלגוריתמים שלנו כך שיפעלו הרבה יותר מהר, ולמצוא את הנתונים הדרושים להם בשבריר מהזמן שהוא היה לוקח אחרת. בשיעור של היום, נדבר על Java Collections sort(). כניסוי מחשבתי מהיר: דמיינו שאתם מחפשים שם דרך סגל האוניברסיטה. בבית הספר הזה יכולים להיות עשרות אלפי תלמידים. אם הסגל שקיבלת לא היה בסדר אלפביתי, תצטרך לדפדף בכל עמוד ולחפש היטב כדי לוודא שלא דילגת על שם אחד בשום מקום, עד שלבסוף תמצא את השם שאתה מחפש. מצד שני, אם הסגל היה בסדר אלפביתי, לא רק שאתה צריך להיות פחות קפדני בחיפוש שלך, אלא שאתה יכול בקלות לקפוץ למדור בסגל עם אותה אות ראשונה, ולהמשיך לקפוץ בין דפים בקפיצות גדולות עד שאתה נוחת על האדם שחיפשת. ככל שאתה עובד עם יותר נתונים, כך חשוב יותר שתשתמש בהם בצורה יעילה ויעילה ככל האפשר. במאמר זה נעבור על איך למיין כל מימוש רשימה ב-Java (כולל ArrayList) באמצעות שיטת המיון Collections.

כיצד למיין ArrayList ב-Java באמצעות שיטת המיון של Java Collections

בואו נדבר על שיטת 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() כדי למיין לפי סדר עולה רשימה של מספרים שלמים, צפים או כל סוג נתונים פשוט אחר לצורך העניין. אבל מה אם תרצה למיין בסדר יורד? בהחלט יש מקרים שבהם זה הגיוני - תארו לעצמכם שהייתה לכם רשימה של ציוני מבחנים עבור כיתה מסוימת, ורציתם להבין מי הם התלמידים בעלי הציון הגבוה ביותר. זה יהיה הרבה יותר הגיוני למיין את הרשימה בסדר יורד (הציונים הגבוהים ביותר קודם), כך שהתשובות שאתה מחפש נמצאות ממש בראש. למרבה המזל, Collections.sort() מוחלף עם פרמטר שני אופציונלי, המאפשר לך לעשות בדיוק את זה:

sort(List l, Comparator c)

אבל מה זה משווה? ובכן, משווה הוא פשוט פונקציה שמשווה בין שני כניסות ומחזירה מספר המייצג איזה קלט מגיע קודם. אם אתה ממיין ArrayList של סוגי נתונים פרימיטיביים, אז Java Collections כבר מספק לך משווה reverseOrder(). אפשר לקרוא לזה ככה:

Collections.sort(colors, Collections.reverseOrder());

כעת, הצבעים מוינו הפוך במקום כך שאם תדפיס אותו, תקבל את הפלט הבא:

[Red, Orange, Green, Blue]

כיצד להשתמש באוספים כדי למיין סוגי נתונים לא פרימיטיביים ב-Java

עד כה, ראית שמיון ArrayLists של מחרוזות או ints ב-Java באמצעות שיטת Collections.sort() הוא קל כמו שורת קוד אחת. אבל לעתים קרובות, ArrayLists שלך יאחסנו סוגי נתונים לא פרימיטיביים. כאשר אתה עובד עם נתונים שיש להם תכונות מורכבות יותר, תרצה לכתוב מחלקות כדי לייצג את האובייקטים הללו וכיצד הם יושוו זה לזה באמצעות התכונות שלהם. כדי לחקור דוגמה לכך, בואו נחזור על הדוגמה של מיון רשימת צבעים, אבל הפעם, במקום למיין מחרוזות, נמיין אובייקטים של צבע. שיעור הצבעים הבסיסי שלנו עשוי להיראות בערך כך:

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

כדי להפוך את מחלקת הצבע שלנו לתואמת ל- Collections.sort(), כדי שאוסףים יוכלו להבין כיצד להשוות ולמיין אובייקטי Color, עלינו לבצע שני שינויים קטנים:

1. הפוך את צבע לאובייקט בר-השוואה (הוסף יישומים Comparable<Object>)
2. לעקוף את שיטת 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 של המחרוזת; המיון יתבצע לפי סדר אלפביתי. אם נרצה למיין לפי ערך אדום בסדר עולה, למשל, נוכל להחליף את הצהרת return ב- return this.r - cr; (אם נרצה למיין לפי ערך ירוק בסדר יורד, זה יהיה return cg - this.g;). עכשיו, אם נתקשר

Collections.sort(colors);

ב-ArrayList של צבעים ולא רק ב-Strings, זה יעבוד כי Collections מבינים כיצד להשוות בין אובייקטי צבע. אם אינך רוצה לגרום לאובייקט שלך ליישם Comparable<Object>, אתה יכול לחלופין לכתוב השוואת עבור המחלקה שלך, ולהעביר את זה לשיטת 2-פרמטר Collections.sort() . משווה עוקף שיטה 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, והיא עדיין תעבוד. לפעמים, תראה שזה נעשה בשורה, באמצעות פונקציות למבדה. פונקציית למבדה היא בעצם פונקציה חסרת שם שאתה יכול להגדיר בתוך שורת הקוד, שקוראת לה. הם שימושיים כאשר אתה רק צריך לקרוא לפונקציה עבור מופע ספציפי אחד ולא רוצה להגדיר פונקציה נפרדת שלמה במקום אחר. ניתן להגדיר את משווה SortByName בשורה, באמצעות פונקציית lambda, כך:

Collections.sort(colors, (a, b)-> {
          return a.name.compareTo(b.name)});

כפי שאפשר לנחש, (א, ב) מייצג את הפרמטרים של פונקציות הלמבדה (שני האובייקטים שיש להשוות). ה-> מסמל שמה שאחריו הוא הגדרת פונקציית למבדה. זה בערך הכול! כעת ראית את השיטות הפופולריות ביותר למיון ArrayLists ב-Java באמצעות חבילת Collections.