Esta pregunta introduce dos métodos sort () de la clase de herramienta de colecciones, como sigue:
1. Dos métodos de clasificación () de la clase de herramienta de colecciones
Formato 1: Public Static <t se extiende comparable <? Super t >> sort void (lista <t> list)
Nota: Los genéricos <t> en este método son todas las subclases de la interfaz comparable, es decir, solo los datos del tipo de subclase de interfaz comparable se pueden comparar y ordenar. Si se van a comparar y ordenar otros tipos de datos, la interfaz comparable debe ser heredada y
Anular los métodos iguales () y comparación (). Entre ellos, la clase de cadena y la clase entera son subclases de interfaz comparables y se pueden ordenar, mientras que los tipos básicos no se pueden clasificar. Los elementos de comparación se especifican dentro de la clase
Formato 2: Public Static <T> void sort (List <T> List, Comparator <? Super t> c)
Nota: Este método especifica el comparador del método de comparación <? super t> c, es decir, c debe implementar el comparador <? Super t> interfaz, anule el método Compareto () para especificar el elemento de comparación. Los elementos de comparación se especifican fuera de la clase, que es más flexible
2. Ejemplo
Formas comunes de obtener cadenas y números en el ejemplo:
/ *** Genere cadenas aleatorias y no repetitivas: el número genere el número de cadenas*/ public static list <String> GenerAtEtring (int number) {list <string> listString = new ArrayList <> (); // utilizado para almacenar la lista de valores de retorno <integer> longitud = null; // longitud de cadena StringBuffer sb = new StringBuffer (); // variable intermedia int control = 0; // Número de control String [] chars = new String [] {"A", "B", "C", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", ",", ",", ",", ",", ",", ",", ",", ",", ",", ",", ",", ",", ",", ",", ",", ",", ",", ",", ",", ",", ",", ",", ",", ",", ",", "Z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "b", "c", "d", "e", "f", "g", "h", "j", "k", "l", "m", "n" o "o", "p", ",", ",", "," p ",", "," p "," p ",", ",", "o", "o", "o", "o", "o", "o", ". "S", "t", "u", "v", "w", "x", "y", "z"}; while (true) {// End of Control if (control == number) {break; } // Generar un número aleatorio y generar 36 bit 2AAAB761-4341-4968-ACEB-3861EE3824B2 UUID Type Data String uuid = uuid.randomuuid (). ToString (). Reemplace ("-", ""); sb.setLength (0); // Obtener la longitud de una cadena aleatoria, la longitud no es 0 do {longitud = getDiffno (1, 11); } while (longitud.get (0) == 0); // Patch String String para (int i = 0; i <longitud.get (0); i ++) {string str = uuid.substring (i*3, (i*3+3)); // Convierta la cadena STR a hexadecimal y obtenga su valor int x = integer.parseInt (str, 16); // Obtener el resto: x % 0x3e-0x3e = 3*16 + 14 = 62, donde Chars tiene 62 caracteres sb.append (chars [x % 0x3e]); } listString.Add (sb.ToString ()); control ++; } return listString; }/ *** Genere números aleatorios y no repetitivos: n Generar números MAX Genere el rango*/ Lista estática pública <integer> getDiffno (int n, int max) {// Generar [0-n] números aleatorios no repetitivos // Lista utilizada para guardar estos números aleatorios <inger> list = new ArrayList <> (); Aleatorio aleatorio = new Random (); Entero k; for (int i = 0; i <n; i ++) {do {k = random.nextint (max); } while (list.contains (k)); list.add (k); } Lista de retorno; } 1. Ordene la lista de genéricos enteros
/*** 1. Ordene la lista de genéricos enteros a través del método Collections.sort (); * Cree una lista de genéricos enteros, inserte diez enteros aleatorios no repetitivos dentro de 100 y llame al método Collections.sort () para ordenarlos* 2. Ordenar reglas: primer número y luego letras, números 0-9, el orden de letras az*/ public void listegersort () {// insertar diez no repetitivos de intregers aleatorios dentro de 100 list <ineger> integerlist = getDiffiffiFfersor System.out.println("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- integer : integerList) { System.out.println ("Elemento:" + Integer); System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ----------------------------------------------------------------------------------------------- 2. Ordene la lista de genéricos de cadenas
/*** 1. Ordene la lista de genéricos de cadena; Cree una lista de genéricos de cadena, agregue elementos de cadena fuera de orden, * llame al método de clasificación y emita el orden de clasificación nuevamente */ public void listStringsort () {list <string> stringList = new ArrayList <String> (); StringList.Add ("eipjlcx"); StringList.Add ("wvqrufc"); StringList.Add ("J"); StringList.Add ("HDAU2G"); StringList.Add ("M0WSWHD3"); System.out.println ("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- / *** Ordene la lista de genéricos de cadena, que requiere una generación aleatoria de 10 cadenas no repetitivas, y la longitud de la cadena está dentro de 10*/ public void listStringRandomsort () {// Generar una lista de cadenas aleatorias <String> ListString = GenerAtEdring (10); System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.out.println ("-----------------------------------------------------");3. Lista de clasificación de otros tipos de genéricos
Implementación de la clase de curso
/** * clase de curso * @Author Administrator * */Public Class Course {public String id; nombre de cadena pública; Curso público (ID de cadena, nombre de cadena) {this.id = id; this.name = name; } curso público () {} @Override public int hashcode () {final int prime = 31; int resultado = 1; resultado = prime * resultado + ((name == null)? 0: name.hashcode ()); resultado de retorno; } @Override public boolean iguales (objeto obj) {if (this == obj) return true; if (obj == null) return false; if (! (OBJ instancia de curso)) devuelve falso; Curso otro = (curso) obj; if (name == null) {if (other.name! = null) return false; } else if (! name.equals (other.name)) return false; devolver verdadero; }} La clase de estudiantes implementa una interfaz comparable y establece elementos de comparación dentro de la clase
import java.util.hashset; import java.util.set;/** * clase de estudiante * @author administrador * */public class Student implementa comparable <estudiante> {ID de cadena pública; nombre de cadena pública; Cursos de Set Public Set <cutor>; Public Student (ID de cadena, nombre de cadena) {this.id = id; this.name = name; this.Courses = new Hashset <cursual> (); } @Override public int hashcode () {final int prime = 31; int resultado = 1; resultado = prime * resultado + ((name == null)? 0: name.hashcode ()); resultado de retorno; } @Override public boolean iguales (objeto obj) {if (this == obj) return true; if (obj == null) return false; if (! (obj instancia de alumno)) devuelve falso; Estudiante otro = (estudiante) obj; if (name == null) {if (other.name! = null) return false; } else if (! name.equals (other.name)) return false; devolver verdadero; } @Override public int Compareto (Student O) {// Establecer ID como elemento de comparación // TODO Método Generado automático returación this.id.compareto (O.ID); }} Implementar la interfaz de comparación y establecer elementos de comparación fuera de la clase
import java.util.comparator; Public Class StudentComparator Comparador de implementos <deudent> {@Override public int Compare (Student O1, Student O2) {// TODO Auto Generado Método Stub Return o1.name.compareto (O2.Name); }} Comparación de clases de estudiantes
/*** Listas de clasificación de otros tipos de genéricos, tomando al estudiante como ejemplo. */ public void listComParatorSort () {list <deudent> studentList = new ArrayList <Estudio> (); List <integer> list = getDiffno (4, 1000); StudentList.Add (nuevo estudiante (list.get (0) + "", "Mike")); StudentList.Add (nuevo estudiante (list.get (1) + "", "Angela")); StudentList.Add (nuevo estudiante (list.get (2) + "", "Lucy")); StudentList.add (nuevo estudiante (1000 + "", "beyonce")); System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ----------------------------------------------------------------------------------------------- System.out.println ("Student:" + Student.id + ":" + Student.name); System.out.println("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.