您的位置:

java中list倒序的简单介绍

本文目录一览:

java linked list里的元素顺序反过来

定义一个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);

}

对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);这个方法来排序..

java怎么把list元素倒转

这个比较简单:

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());

好多方法,不会问我

求java一个程序补全(list逆序输出与查找)

不会又是你吧。刚好我今天没什么事

// 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);

        }

    }

java 中,如何将1~100的偶数所组成的List集合倒序排列,谢谢!

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]

java 集合中怎么将元素倒序排列

方法一:实现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);

}

}