java array List排序

系统管理员 2022-09-17 11:17 160阅读 0赞

**在java 中 对list排序用 **

//Collections.sort( userlist, comparator);

Collections.*sort* (userlist); // User 类需要继承实现Comparable

对数组排序可直接用：

Arrays. *sort*(intArray );

**package**  com.czy.sort;

**public**   **class**  User  **implements**  Comparable<User> \{

String  name ;

String  age ;

**public**  User(String name, String age) \{

**this** .  name  = name;

**this** .  age  = age;

**public**  String getAge() \{

**return**   age  ;

**public**   **void**  setAge(String age) \{

**this** .  age  = age;

**public**  String getName() \{

**return**   name  ;

**public**   **void**  setName(String name) \{

**this** .  name  = name;

@Override

**public**   **int**  compareTo(User user) \{

**int**  flag =  **this** .getAge().compareTo(user.getAge());

**if**  (flag == 0) \{

**return**   **this**  .getName().compareTo(user.getName());

\}  **else**  \{

**return**  flag;

**package**  com.czy.sort;

**import**  java.util.Comparator;

**public**   **class**  ComparatorUser  **implements**  Comparator\{

**public**   **int**  compare(Object arg0, Object arg1) \{

User user0 = (User ) arg0;

User user1 = (User ) arg1;

// 首先比较年龄，如果年龄相同，则比较名字

**int**  flag = user0.getAge().compareTo(user1.getAge());

**if**  (flag == 0) \{

**return** user0.getName().compareTo(user1.getName());

\}  **else**  \{

**return**  flag;

**package**  com.czy.sort;

**import**  java.util.ArrayList;

**import**  java.util.Collections;

**import**  java.util.List;

**public**   **class**  SortTest \{

**public**   **static**   **void**  main(String\[\] args) \{

List userlist =  **new**  ArrayList();

userlist.add(  **new**  User(  "dd" ,  "4"  ));

userlist.add(  **new**  User(  "aa" ,  "1"  ));

userlist.add(  **new**  User(  "ee" ,  "5"  ));

userlist.add(  **new**  User(  "bb" ,  "2"  ));

userlist.add(  **new**  User(  "ff" ,  "5"  ));

userlist.add(  **new**  User(  "cc" ,  "3"  ));

userlist.add(  **new**  User(  "gg" ,  "6"  ));

//ComparatorUser comparator = new ComparatorUser();

//Collections.sort( userlist, comparator);

Collections.*sort* (userlist); // User 类需要继承实现Comparable

**for**  (  **int**  i = 0; i < userlist.size(); i++) \{

User user\_temp = (User) userlist.get(i);

System.  *out* .println(user\_temp.getAge() +  ","  \+ user\_temp.getName());

**在java 内部 还是将list 转换成array，然后再对数组进行排序**

Object\[\] a = list.toArray();

Arrays. *sort*(a);

ListIterator<T> i = list.listIterator();

**for**  (  **int**  j=0; j<a.  length ; j++) \{

i.next();

i.set((T)a\[j\]);

**再看 sort：**

**public**   **static**   **void**  sort(Object\[\] a) \{

Object\[\] aux = (Object\[\])a.clone();

*mergeSort*(aux, a, 0, a. length  , 0);

**再看 mergeSort（归并排序）：**

**private**   **static**   **void**  mergeSort (Object\[\] src,

Object\[\] dest,

**int**  low,

**int**  high,

**int**  off) \{

**int**  length = high - low;

// Insertion sort on smallest arrays

**if**  (length <  *INSERTIONSORT\_THRESHOLD*  ) \{

**for**  (  **int**  i=low; i<high; i++)

**for**  (  **int**  j=i; j>low &&

((Comparable) dest\[j-1\]).compareTo(dest\[j\])>0; j--)

*swap*(dest, j, j-1);

**return**  ;

// Recursively sort halves of dest into src

**int**  destLow  = low;

**int**  destHigh = high;

low  += off;

high += off;

**int**  mid = (low + high) >>> 1;

*mergeSort*(dest, src, low, mid, -off);

*mergeSort*(dest, src, mid, high, -off);

// If list is already sorted, just copy from src to dest.  This is an

// optimization that results in faster sorts for nearly ordered lists.

**if**  (((Comparable)src\[mid-1\]).compareTo(src\[mid\]) <= 0) \{

System. *arraycopy*(src, low, dest, destLow, length);

**return**  ;

// Merge sorted halves (now in src) into dest

**for** (  **int**  i = destLow, p = low, q = mid; i < destHigh; i++) \{

**if**  (q >= high || p < mid && ((Comparable)src\[p\]).compareTo(src\[q\])<=0)

dest\[i\] = src\[p++\];

**else**

dest\[i\] = src\[q++\];

java array List排序

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Java 数组和列表相互转换（Array to List and List to Array）

相关 java的list排序

相关 java arrays排序_java – 使用Arrays.sort()对并行数组进行排序

相关 java list对象排序函数_java List对象排序

相关 java array List排序

相关 java List 排序 Collections.sort() 对 List 排序

相关 java之Map，List，Array

相关 Java list 三级排序

相关 java List实体排序

相关 java list Comparator排序