LinkedList 实现排序

 1 import java.util.Collections;
 2 import java.util.Comparator;
 3 import java.util.LinkedList;
 4
 5 class Person{
 6     private float height;
 7     private String name;
 8
 9     Person(float height)
10     {
11         this.height=height;
12     }
13
14     public float getHeight() {
15         return height;
16     }
17
18     public void setHeight(float height) {
19         this.height = height;
20     }
21
22     public String getName() {
23         return name;
24     }
25
26     public void setName(String name) {
27         this.name = name;
28     }
29 }
30
31 class PersonHeight implements Comparator<Person>{
32
33     @Override
34     public int compare(Person e1, Person e2) {
35         if(e1.getHeight() < e2.getHeight()){
36             return 1;
37         } else {
38             return -1;
39         }
40     }
41 }
42
43
44 public class Question3 {
45
46     public static void main(String[] args) {
47         Person p1=new Person(23.4f);
48         p1.setName("Stud1");
49         Person p2=new Person(2.34f);
50         p2.setName("Stud2");
51         Person p3=new Person(34.32f);
52         p3.setName("Stud3");
53         Person p4=new Person(56.45f);
54         p4.setName("Stud4");
55         Person p5=new Person(21.4f);
56         p5.setName("Stud5");
57
60         LinkedList<Person> al=new LinkedList<Person>();
61         al.add(p1);
62         al.add(p2);
63         al.add(p3);
64         al.add(p4);
65         al.add(p5);
66
67
68
69         Collections.sort(al,new PersonHeight());
70         for(Person p:al)
71             System.out.println(p.getName()+" "+p.getHeight());
72
73     }
74
75 }


  Collections.sort(al,new PersonHeight());

结果:Stud4 56.45Stud3 34.32Stud1 23.4Atud5 21.4Stud2 2.34

 1 package com.cn.aug26;
 2
 3
 4 import java.util.Collections;
 5 import java.util.LinkedList;
 6 7
 8 class Person1 implements Comparable <Person1>{
 9     private Float height;
10     private String name;
11
12     Person1(float height)
13     {
14         this.height=height;
15     }
16
17     public Float getHeight() {
18         return height;
19     }
20
21     public void setHeight(float height) {
22         this.height = height;
23     }
24
25     public String getName() {
26         return name;
27     }
28
29     public void setName(String name) {
30         this.name = name;
31     }
32
33     @Override
34     public int compareTo(Person1 p) {
35         if(this.getHeight()<p.getHeight()){
36             return 1;
37
38         }else if(this.getHeight()>p.getHeight()){
39             return -1;
40         }else{
41             return 0;
42         }
43
44     }
45 }
46
47
48 public class Question3_1 {
49
50     public static void main(String[] args) {
51         Person1 p1=new Person1(23.4f);
52         p1.setName("Stud1");
53         Person1 p2=new Person1(2.34f);
54         p2.setName("Stud2");
55         Person1 p3=new Person1(34.32f);
56         p3.setName("Stud3");
57         Person1 p4=new Person1(56.45f);
58         p4.setName("Stud4");
59         Person1 p5=new Person1(21.4f);
60         p5.setName("Stud5");
61
62         LinkedList<Person1> al=new LinkedList<Person1>();
63
64         al.add(p1);
65         al.add(p2);
66         al.add(p3);
67         al.add(p4);
68         al.add(p5);
69
70         Collections.sort(al);//降序
71
72         for(Person1 p:al)
73             System.out.println(p.getName()+" "+p.getHeight());
74
75     }
76
77 }


结果:Stud4 56.45Stud3 34.32Stud1 23.4Stud5 21.4Stud2 2.34

 Collections.sort(al,Collections.reverseOrder());//升序

结果:Stud2 2.34Stud5 21.4Stud1 23.4Stud3 34.32Stud4 56.45
 
时间: 2024-11-04 22:56:24

LinkedList 实现排序的相关文章

java的list几种实现方式的效率(ArrayList、LinkedList、Vector、Stack),以及 java时间戳的三种获取方式比较

一.list简介 List列表类,顺序存储任何对象(顺序不变),可重复. List是继承于Collection的接口,不能实例化.实例化可以用: ArrayList(实现动态数组),查询快(随意访问或顺序访问),增删慢.整体清空快,线程不同步(非线程安全).数组长度是可变的百分之五十延长 LinkedList(实现链表),查询慢,增删快. Vector(实现动态数组),都慢,被ArrayList替代.长度任意延长.线程安全(同步的类,函数都是synchronized) Stack(实现堆栈)继承

Collection-&gt;List-&gt;ArrayList、LinkedList实现原理

我们在开发中会进场用到List来进行数据的处理尤其是它的两个实现ArrayList.LinkedList 但是这两种实现究竟有什么区别,这个在之前一直是没有仔细考虑的,一般写代码就直接一个ArrayList实现初始化对象,在企业级的互联网开发中比较少有数据处理超过100万的,这导致了我们在开发中对这两个实现的具体适合的应用场景有所忽略. 那么下面我们从这两种实现类的存储原理.源代码处理逻辑来进行分析,找出这两种类的区别以及何时的使用场景. 环境JDK8 一. 存储原理:1.ArrayList内存

java面试题001

hibernate中离线查询去除重复项怎么加条件?? dc.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY); http协议及端口,smtp协议及端口 http:超文本传输协议    端口 80 smtp:简单邮件传输协议 端口25 编写程序,完成文件复制功能 Servlet创建过程及生命周期Servlet 在容器中运行时,其实例的创建及销毁等是由容器进行控制. Servlet 的创建有两种方法. 客户端请求对应的 Servlet 时,创建

Java中List效率的比较

Java Collections Framework(JCF) 是Java SE中一个基本的类集,几乎所有的项目都会用到,其中的List 则是JCF中最最常用的一个接口.围绕List 接口,有很多实现,诸如常用的ArrayList .LinkedList .Vector.Stack ,还有Java5之后引入的CopyOnWriteArrayList ,也有不少List 的开源实现,如Apache commons-collections中的各类List . 这么多的List 实现,如何选择?他们的

java成神之——集合框架之ArrayList,Lists,Sets

集合 集合种类 ArrayList 声明 增删改查元素 遍历几种方式 空集合 子集合 不可变集合 LinkedList Lists 排序 类型转换 取交集 移动元素 删除交集元素 Sets 集合特点 常用方法 根据set创建list 集合 集合种类 List<String> list = new ArrayList<>(data); Set<String> set1 = new HashSet<>(data); // 值不重复 SortedSet<St

20182301 2019-2020-1 《数据结构与面向对象程序设计》实验9报告

20182301 2019-2020-1 <数据结构与面向对象程序设计>实验9报告 课程:<程序设计与数据结构> 班级: 1823 姓名: 赵沛凝 学号:20182301 实验教师:王志强 实验日期:2019年12月2日 必修/选修: 必修 1.实验内容 初始化:根据屏幕提示(例如:输入1为无向图,输入2为有向图)初始化无向图和有向图(可用邻接矩阵,也可用邻接表),图需要自己定义(顶点个数.边个数,建议先在草稿纸上画出图,然后再输入顶点和边数)(2分) 图的遍历:完成有向图和无向图

力扣90——子集 II

原题 给定一个可能包含重复元素的整数数组 nums,返回该数组所有可能的子集(幂集). 说明:解集不能包含重复的子集. 示例: 输入: [1,2,2] 输出: [ [2], [1], [1,2,2], [2,2], [1,2], [] ] 原题url:https://leetcode-cn.com/problems/subsets-ii/ 解题 递归 这道题,针对已经刷了不少题目的我们而言,应该第一想到的就是递归了,从第1个数开始,每次遍历1个数,如果和之前的数相同则跳过,然后以下一个数为起点,

基于LinkedList实现桶排序

需要考虑以下问题: 1.桶的大小,这里我们可以根据输入的元素的个数来确定桶的大小. 2.怎么样确定当前元素进入哪一个桶,这里我们使用到的是通过一个哈希函数来进行计算. int index = (element * length) / (max + 1); element为当前元素的值,length为桶的大小,max为数组中最大元素的值 3.因为输入的数据是随机的,所以有可能在一个桶中分布着好几个数据,那么怎么样维持在一个桶中的顺序呢?因为涉及到桶中元素的数量的不确定性,所以我们可以使用动态的数据

Map集合按照value和key进行排序

最近由于特殊的业务需求,需要做相关数据排序,下面就贴出其中的将map集合中按照value或者key进行排序的代码,后面再具体详说. 1 /** 2 * map 集合排序 3 * @param map 4 * @return 5 */ 6 public static <K, V extends Comparable<? super V>> Map<K, V> sortMap(Map<K, V> map) 7 { 8 List<Map.Entry<K