当前位置:首页 » 编程语言 » list倒序java

list倒序java

发布时间: 2022-07-26 00:26:01

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

热点内容
cf弹道脚本 发布:2025-01-26 15:36:40 浏览:54
我的世界花钱买的服务器 发布:2025-01-26 15:34:50 浏览:89
php环境部署 发布:2025-01-26 15:28:09 浏览:17
python实现svm 发布:2025-01-26 15:24:25 浏览:381
易语言写ip全局代理服务器 发布:2025-01-26 15:04:01 浏览:668
gm命令在哪个文件夹 发布:2025-01-26 15:03:12 浏览:307
javadate类 发布:2025-01-26 14:58:54 浏览:352
领航s1配置怎么样 发布:2025-01-26 09:58:10 浏览:763
公司局域网搭建服务器搭建 发布:2025-01-26 09:16:56 浏览:433
android裁剪圆形图片 发布:2025-01-26 09:05:56 浏览:411