list倒序java
㈠ java怎麼對list進行排序
1,使用Comparator 介面
Student類 結構如下:(省略getter,setter方法)
public class Student {
/***
* 姓名
*/
private String name;
private int age;
private String address;
/***
* 考試得分
*/
private int score;
//省略getter,setter方法
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", score=" + score
+ "]";
}
}
測試方法:
@Test
public void test_ListComparator(){
List<Student>students=new ArrayList<Student>();
Student stu=null;
stu=new Student();
stu.setName("whuang");
stu.setAge(12);
stu.setScore(80);
students.add(stu);
stu=new Student();
stu.setName("rong");
stu.setAge(11);
stu.setScore(90);
students.add(stu);
stu=new Student();
stu.setName("zhu");
stu.setAge(15);
stu.setScore(100);
students.add(stu);
Collections.sort(students,new SystemHWUtil. ListComparator(true,"age"));
System.out.println(students);
}
運行結果:
[Student [name=rong, age=11, score=90], Student [name=whuang, age=12, score=80], Student [name=zhu, age=15, score=100]]
核心類:
public static class ListComparator implements Comparator{
/***
* 是否轉化為Int之後再比較
*/
private boolean isConvertInteger;
/***
* 對哪個列進行排序
*/
private String comparedProperty;
public ListComparator(boolean isConvertInteger,String comparedProperty) {
super();
this.isConvertInteger = isConvertInteger;
this.comparedProperty=comparedProperty;
}
public int compare(Object o1, Object o2) {
if(null!=o1&&null!=o2)
{
try {
Object obj1=ReflectHWUtils.getObjectValue(o1, comparedProperty);
Object obj2=ReflectHWUtils.getObjectValue(o2, comparedProperty);
if(isConvertInteger){
int num1;
int num2;
if(obj1 instanceof Integer){
num1=(Integer)obj1;
num2=(Integer)obj2;
}else{
num1=Integer.parseInt(obj1.toString());
num2=Integer.parseInt(obj2.toString());
}
if(num1>num2){
return 1;
}else if(num1<num2){
return -1;
}else{
return 0;
}
}else{
return obj1.toString().compareTo(obj2.toString());
}
} catch (SecurityException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
return 0/*等於*/;
}
}
2,可以指定是升序還是降序
實例:
@Test
public void test_ListComparator(){
List<Student>students=new ArrayList<Student>();
Student stu=null;
stu=new Student();
stu.setName("whuang");
stu.setAge(12);
stu.setScore(80);
students.add(stu);
stu=new Student();
stu.setName("rong");
stu.setAge(11);
stu.setScore(90);
students.add(stu);
stu=new Student();
stu.setName("zhu");
stu.setAge(15);
stu.setScore(100);
students.add(stu);
SortList<Student> sortList = new SortList<Student>();
sortList.Sort(students, "getAge", "asc");
System.out.println(students);
}
注意:sortList.Sort 的第二個參數是方法名,不是成員變數名.
核心代碼
package com.common.util;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class SortList<E> {
public void Sort(List<E> list, final String method, final String sort) {
Collections.sort(list, new Comparator() {
public int compare(Object a, Object b) {
int ret = 0;
try {
Method m1 = ((E) a).getClass().getMethod(method, null);
Method m2 = ((E) b).getClass().getMethod(method, null);
if (sort != null && "desc".equals(sort))// 倒序
ret = m2.invoke(((E) b), null).toString()
.compareTo(m1.invoke(((E) a), null).toString());
else
// 正序
ret = m1.invoke(((E) a), null).toString()
.compareTo(m2.invoke(((E) b), null).toString());
} catch (NoSuchMethodException ne) {
System.out.println(ne);
} catch (IllegalAccessException ie) {
System.out.println(ie);
} catch (InvocationTargetException it) {
System.out.println(it);
}
return ret;
}
});
}
}
㈡ java linked list里的元素順序反過來
定義一個LinkedList<Integer> templist = new LinkedList<>();來存儲list裡面的值，通過迭代list，將值插入在templist的頭上，那麼templist就是list的反轉了，最後將templist賦值給list就行了！
如下代碼：
publicvoidreverse(){
LinkedList<Integer>list=newLinkedList<>();
LinkedList<Integer>templist=newLinkedList<>();
inti=0;
while(i<6){
list.add(i);
i++;
}
Iterator<Integer>it=list.iterator();
intm;
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.。這種實現機制是fail-fast，對外部的修改並不能提供任何保證。
Iterator是工作在一個獨立的線程中，並且擁有一個 mutex鎖，就是說Iterator在工作的時候，是不允許被迭代的對象被改變的。
Iterator被創建的時候，建立了一個內存索引表（單鏈表），這個索引表指向原來的對象，當原來的對象數量改變的時候，這個索引表的內容沒有同步改變，所以當索引指針往下移動的時候，便找不到要迭代的對象，於是產生錯誤。
List、Set等是動態的，可變對象數量的數據結構，但是Iterator則是單向不可變，只能順序讀取，不能逆序操作的數據結構，當 Iterator指向的原始數據發生變化時，Iterator自己就迷失了方向。
所以如果像下面這么寫就會拋出異常java.util.
：
publicvoidreverse(){
LinkedList<Integer>list=newLinkedList<>();
inti=0;
while(i<6){
list.add(i);
i++;
}
Iterator<Integer>it=list.iterator();
intm;
while(it.hasNext()&&i>=0){
m=it.next();
list.add(m);
list.remove(0);
i--;
}
System.out.println(list);
}
㈢ java 集合中怎麼將元素倒序排列
方法一：實現Comparable介面排序package collsort.comparable;
package com.cvicse.sort.comparable;
public class Cat implements Comparable<Cat> {
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() {
......
List<Cat> listCat1 = new ArrayList<Cat>();
Cat cat1 = new Cat(34, "hehe");
Cat cat2 = new Cat(12, "haha");
Cat cat3 = new Cat(23, "leimin");
Cat cat4 = new Cat(13, "lavasoft");
listCat1.add(cat1);
listCat1.add(cat2);
listCat1.add(cat3);
......
System.out.println("調用Collections.sort(List<T> 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("數組轉換為列表");
List<String> 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 Comparator<Person> {
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("升序排序測試:");
List<Person> listPerson = new ArrayList<Person>();
Person person1 = new Person(34, "lavasoft");
Person person2 = new Person(12, "lavasoft");
Person person3 = new Person(23, "leimin");
Person person4 = new Person(13, "sdg");
listPerson.add(person1);
listPerson.add(person2);
listPerson.add(person3);
Comparator<Person> ascComparator = new PersonComparator();
System.out.println("排序後集合為:");
// 利用Collections類靜態工具方法對集合List進行排序
Collections.sort(listPerson, ascComparator);
System.out.println("\n降序排序測試:");
// 從升序排序對象產生一個反轉(降序)的排序對象
Comparator<Person> descComparator = Collections
.reverseOrder(ascComparator);
System.out.println("利用反轉後的排序介面對象對集合List排序並輸出:");
Collections.sort(listPerson, descComparator);
outCollection(listPerson);
}
}
㈣ java怎麼把list元素倒轉
這個比較簡單：
ArrayList<String> list=new ArrayList<String>();
for(int i=0;i<=5;i++){
list.add("num"+i);
}
StringBuilder b = new StringBuilder(list.toString());
System.out.println(b.reverse());
好多方法，不會問我
㈤ java中LinkedList 倒序輸出
public static void printReverse(List list){
for (int i=list.size()-1;i>=0;i-- ){
if(list.get(i) instanceof String){
System.out.println(list.get(i));
}
}
}
這樣？
㈥ java請隨機輸入10個數字保存到List中,並按倒序顯示出來
smile_bug 說的這個我還真沒想過，想想覺得很行啊
找了手冊，才知道java的list沒tree的，懶得寫個，汗
那隻能二樓的方法
public static void main(final String[] args) {
final List<Integer> integers = new ArrayList<Integer>();
final Scanner scanner = new Scanner(System.in);
for (int i = 1; i <= 3; i++) {
try {
System.out.println("輸入第" + i + "個數吧");
final int input = Integer.parseInt(scanner.next());
integers.add(input);
}
catch (final Throwable e) {
System.err.println("這不是個數字，我可是超級程序");
i--;
continue;
}
}
Collections.sort(integers);// 自然排
Collections.reverse(integers);// 倒排
for (final Integer integer : integers) {
System.out.println(integer);
}
}
㈦ java中list反向遍歷問題，幫忙看下
造成這個結果，相信題主也debug，從最終結果來看，代碼進入了FbianLi方法，但是沒有輸出結果，那肯定就說明it.hasPrevious()返回了false
那為啥這里it.hasPrevious()返回了false呢，那我們直接去看這個方法的注釋，由於是JDK提供的方法，那肯定也有很詳盡的注釋
從中可以看到，該方法表示在迭代器里以相反順序遍歷看是否還有元素，還有元素就返回true，否則就返回false
肯定題主會說，沒錯啊，相反順序遍歷肯定有元素啊
沒錯，按照題主所說的相反順序遍歷是肯定有元素的，但這里的相反順序是說在Iterator，也就是迭代器的基礎上的，這涉及到對迭代器的理解
迭代器本身就是順序循環，那指針就是從第一個元素開始的，所以這個時候it.hasPrevious()方法執行的含義代表指針所指反向順序是否還有元素，第一個元素之前肯定沒有元素吖，所以返回了false