java中list倒序的簡單介紹

• 1、java linked list里的元素順序反過來
• 2、對List集合倒序排序怎麼排
• 3、java怎麼把list元素倒轉
• 4、求java一個程序補全（list逆序輸出與查找）
• 5、java 中,如何將1~100的偶數所組成的List集合倒序排列,謝謝!
• 6、java 集合中怎麼將元素倒序排列

定義一個LinkedListInteger templist = new LinkedList();來存儲list裡面的值，通過迭代list，將值插入在templist的頭上，那麼templist就是list的反轉了，最後將templist賦值給list就行了！

如下代碼：

public void reverse() {

LinkedListInteger list = new LinkedList();

LinkedListInteger templist = new LinkedList();

int i = 0;

while (i  6) {

list.add(i);

i++;

}

IteratorInteger it = list.iterator();

int m;

while (it.hasNext()  i = 0) {

m = it.next();

templist.addFirst(m);

i–;

}

list = templist;

System.out.println(list);

}

運行結果為：

5 4 3 2 1 0

從API中可以看到List等Collection的實現並沒有同步化，如果在多線程應用程序中出現同時訪問，而且出現修改操作的時候都要求外部操作同步化；調用Iterator操作獲得的Iterator對象在多線程修改Set的時候也自動失效，並拋出java.util.ConcurrentModificationException。這種實現機制是fail-fast，對外部的修改並不能提供任何保證。

Iterator是工作在一個獨立的線程中，並且擁有一個 mutex鎖，就是說Iterator在工作的時候，是不允許被迭代的對象被改變的。

Iterator被創建的時候，建立了一個內存索引表（單鏈表），這個索引表指向原來的對象，當原來的對象數量改變的時候，這個索引表的內容沒有同步改變，所以當索引指針往下移動的時候，便找不到要迭代的對象，於是產生錯誤。

List、Set等是動態的，可變對象數量的數據結構，但是Iterator則是單向不可變，只能順序讀取，不能逆序操作的數據結構，當 Iterator指向的原始數據發生變化時，Iterator自己就迷失了方向。

所以如果像下面這麼寫就會拋出異常java.util.ConcurrentModificationException

：

public void reverse() {

LinkedListInteger list = new LinkedList();

int i = 0;

while (i  6) {

list.add(i);

i++;

}

IteratorInteger it = list.iterator();

int m;

while (it.hasNext()  i = 0) {

m = it.next();

list.add(m);

list.remove(0);

i–;

}

System.out.println(list);

}

[size=large][color=red]要對List排序,你要對List里裝的這種類型的類實現排序介面(Comparable).

舉個例子:

下面這個例子是對ListMyObject進行排序.使用Collections.sort(List list);方法,此方法會調用MyObject的compareTo方法.所以在MyObject類定義里要實現compareTo方法.

Java代碼

public class ListSort {

/**

* main()

* 2010-4-2,下午09:25:57

*/

public static void main(String[] args) {

// TODO Auto-generated method stub

ListMyObject lists = new ArrayListMyObject();

MyObject obj1 = new MyObject(“d”);

MyObject obj2 = new MyObject(“a”);

lists.add(obj1);

lists.add(obj2);

Collections.sort(lists);

for (MyObject myObject : lists) {

System.out.println(myObject.getContent());

}

}

}

class MyObject implements ComparableMyObject{

private String content;

public MyObject(String _content) {

this.content = _content;

}

public String getContent() {

return content;

}

public void setContent(String content) {

this.content = content;

}

public int compareTo(MyObject obj) {

// TODO Auto-generated method stub

if (null == obj) return 1;

else {

return this.content.compareTo(obj.content);

}

}

}

下面是Collections.sort方法

Java代碼

public static T extends Comparable? super T void sort(ListT list) {

Object[] a = list.toArray();

Arrays.sort(a);

ListIteratorT i = list.listIterator();

for (int j=0; ja.length; j++) {

i.next();

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

}

}

實際上我們的MyObject類的方法compareTo是在Arrays.sort()中被調用的…

請看..

Java代碼

public static void sort(Object[] a) {

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

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

}

Java代碼

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; ihigh; i++)

for (int j=i; jlow

((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++];

}

}

[/color][/size]

當然,這是一種實現排序的辦法.還有一種是實現Comparator,實現這個介面,然後使用

Collections.sort(List list,Comparator c);這個方法來排序..

這個比較簡單：

ArrayListString list=new ArrayListString();

for(int i=0;i=5;i++){

list.add(“num”+i);

}

StringBuilder b = new StringBuilder(list.toString());

System.out.println(b.reverse());

好多方法，不會問我

不會又是你吧。剛好我今天沒什麼事

// Q2

    static void DisplayReverse(ListString element) {

        System.out.print(“null”);

        ListString [] ls=new ListString[numOfElements];

        int i=0;

        while (element != null) {

            ls[i]=element;

            element = element.next;

            i++;

        }

        for (int j = ls.length-1; j =0; j–) {

            System.out.print(“–“+ls[j].name + “[” + ls[j].id + “]” );

        }

    }

    // Q3

    static void Search(String query, ListString head) {

        int i=0;

        while (head != null) {

            if(head.name.equals(query)){

                i++;

            }

            head = head.next;

        }

        if(i0){

            System.out.println(“[Search] found:”+query+”[“+i+”]”);

        }else{

            System.out.println(“[Search] not found: “+query);

        }

    }

public class SortNums {

public static void main(String[] s){

ListInteger list = new ArrayListInteger();

for(int i=1;i=100;i++){

if(i%2==0){

list.add(i);

}

}

System.out.println(list);

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

System.out.println(list);

}

}

好簡單的，輸出結果為：

[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100]

[100, 98, 96, 94, 92, 90, 88, 86, 84, 82, 80, 78, 76, 74, 72, 70, 68, 66, 64, 62, 60, 58, 56, 54, 52, 50, 48, 46, 44, 42, 40, 38, 36, 34, 32, 30, 28, 26, 24, 22, 20, 18, 16, 14, 12, 10, 8, 6, 4, 2]

方法一：實現Comparable介面排序package collsort.comparable;

package com.cvicse.sort.comparable;

public class Cat implements ComparableCat {

private int age;

private String name;

public Cat(int age, String name) {

this.age = age;

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

……

public int compareTo(Cat o) {

return this.getAge() – o.getAge();

}

……

}

通過實現Comparable介面實現個性化排序測試。排序測試，Collection.sort(list)升序排列Collections.sort(list, Collections.reverseOrder());降序排列；Collections.reverse(list);反轉排序，先輸出列表最後一個元素

public class TestComparable {

public static void main(String args[]) {

test();

test2();

}

public static void test() {

……

ListCat listCat1 = new ArrayListCat();

Cat cat1 = new Cat(34, “hehe”);

Cat cat2 = new Cat(12, “haha”);

Cat cat3 = new Cat(23, “leizhimin”);

Cat cat4 = new Cat(13, “lavasoft”);

listCat1.add(cat1);

listCat1.add(cat2);

listCat1.add(cat3);

……

System.out.println(“調用Collections.sort(ListT list)listCat2升序排序：”);

Collections.sort(listCat1);

System.out.println(“降序排列元素:”);

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

System.out.println(“Collections.reverse 從列表中最後一個元素開始輸出:”);

Collections.reverse(listCat1);

……

}

/**

* 針對數組的排序

*/

public static void test2() {

String[] strArray = new String[] { “z”, “a”, “C” };

System.out.println(“數組轉換為列表”);

ListString list = Arrays.asList(strArray);

System.out.println(“順序排序列表”);

Collections.sort(list);

System.out

.println(“按String實現的Comparator對象String.CASE_INSENSITIVE_ORDER排序—-“);

Collections.sort(list, String.CASE_INSENSITIVE_ORDER);

System.out.println(“倒序排序列表”);

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

……

}

}

方法二：實現Comparator介面排序

public class Person {

private int age;

private String name;

……

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

……

}

實現了Comparator介面，重寫了compare方法

import java.util.Comparator;

public class PersonComparator implements ComparatorPerson {

public int compare(Person o1, Person o2) {

return o1.getAge() – o2.getAge();

}

}

測試方法

public class TestComparator {

public static void main(String args[]) {

test1();

}

public static void test1() {

System.out.println(“升序排序測試:”);

ListPerson listPerson = new ArrayListPerson();

Person person1 = new Person(34, “lavasoft”);

Person person2 = new Person(12, “lavasoft”);

Person person3 = new Person(23, “leizhimin”);

Person person4 = new Person(13, “sdg”);

listPerson.add(person1);

listPerson.add(person2);

listPerson.add(person3);

ComparatorPerson ascComparator = new PersonComparator();

System.out.println(“排序後集合為:”);

// 利用Collections類靜態工具方法對集合List進行排序

Collections.sort(listPerson, ascComparator);

System.out.println(“\n降序排序測試:”);

// 從升序排序對象產生一個反轉(降序)的排序對象

ComparatorPerson descComparator = Collections

.reverseOrder(ascComparator);

System.out.println(“利用反轉後的排序介面對象對集合List排序並輸出:”);

Collections.sort(listPerson, descComparator);

outCollection(listPerson);

}

}