精华内容
下载资源
问答
  • 要求:叠罗汉过程中,站在某个人肩上人应该既比自己矮又比自己瘦,或相等。*/public class CircusTroup {static class People{int num;int weight;int height;public People(int num,int weight,int height){this....

    要求:叠罗汉过程中,站在某个人肩上的人应该既比自己矮又比自己瘦,或相等。

    */

    public class CircusTroup {

    static class People{

    int num;

    int weight;

    int height;

    public People(int num,int weight,int height){

    this.num=num;

    this.weight=weight;

    this.height=height;

    }

    }

    public static void main(String[] args) {

    Scanner scanner=new Scanner(System.in);

    int N;

    while (scanner.hasNext()){

    N=scanner.nextInt();

    String inValid=scanner.nextLine();//无效

    People[] peoples=new People[N];

    for(int i=0;i

    String[] str=scanner.nextLine().split(" ");

    peoples[i]=new People(Integer.valueOf(str[0]),Integer.valueOf(str[1]),Integer.valueOf(str[2]));

    }

    //第一处:注意地方

    //先按照体重升序,再按照身高降序

    //为什么身高要降序?因为:体重相同时,只有身高也相同才可以站在自己肩上,比自己矮是不能站在自己肩上的。

    //而身高降序就保证了:体重相同时,身高不同为降序,不是升序序列,则不能站在自己肩上.

    Arrays.sort(peoples,new Comparator() {

    @Override

    public int compare(People o1,People o2) {

    if(o1.weight==o2.weight){

    return o2.height-o1.height;

    }else{

    return o1.weight-o2.weight;

    }

    }

    });

    //第二处:注意地方 db部分开始

    //按身高求最大升序子序列,不是太会

    int[] dp=new int[N];

    dp[0]=1;

    int level=0;

    for(int i=1;i

    dp[i]=1;

    for(int j=0;j代码,可以知道:子序列并不需要连续,只要满足if条件就可以

    if(peoples[j].height<=peoples[i].height && dp[j]+1>dp[i])

    dp[i]=dp[j]+1;

    }

    }

    Arrays.sort(dp);

    level=dp[N-1];

    System.out.println(level);

    }

    }

    }

    展开全文
  • Java自定义排序

    千次阅读 2019-07-20 19:56:29
    Java自定义排序可以通过实现Comparator接口或Comparable接口来完成。 关键:实现Comparator接口的关键在于重写compare()方法,Comparable接口的关键在于重写compareTo()方法。JDK中大部分类都实现了Comparable...

    Java中自定义排序可以通过实现Comparator接口或Comparable接口来完成。
    关键:实现Comparator接口的关键在于重写compare()方法,Comparable接口的关键在于重写compareTo()方法。JDK中大部分的类都实现了Comparable接口,拥有compareTo方法。如Integer,String等。但是对于自己定义类,如果需要自定义排序,则要实现Comparable接口并重写compareTo()方法,若不重写就进行自定义排序,会报错。
    方法:将实现好的接口作为参数传入Arrays.sort()中或Collections.sort()中即可。


    上述两个静态方法都可以进行排序,简单区别:
    1.Arrays.sort()方法可以对原始类型(基本数据类型)和对象类型进行排序,而Collections.sort()只能对List进行排序。
    2.查看源码发现,Collections.sort()也是通过Arrays.sort()方法实现的


    Comparator具体使用方法:

    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;
    
    public class CustomSort {
    	public static void main(String args[]){
    		Integer numbers1[] = {32, 3, 321};
    		List<Integer> list1 = Arrays.asList(numbers1);
    		//注意list1中元素类型必须是对象类型,写原始类型会报错
    		Collections.sort(list1, new MyComparator2());
    		for (Integer integer : list1) {
    			System.out.print(integer+" ");
    		}
    		
    		System.out.println("\n---------------");
    		
    		//使用arrays.sort()方法自定义排序
    		Integer numbers2[] = {1,51,6,1,465,496,-156};
    		Arrays.sort(numbers2, new MyComparator2());
    		for (Integer integer : numbers2) {
    			System.out.print(integer+" ");
    		}
    		
    		System.out.println("\n*************************");
    		
    		Student2 st1 = new Student2(123, "Bob");
    		Student2 st2 = new Student2(122, "Bob");
    		Student2 st3 = new Student2(124, "Allen");
    		//使用collections.sort()方法
    		List<Student2> list3 = new ArrayList<>();
    		list3.add(st1);list3.add(st2);list3.add(st3);
    		Collections.sort(list3, new MyComparator2());
    		for (Student2 student : list3) {
    			System.out.print(student);
    		}
    
    		System.out.println("\n---------------");
    		
    		Student2 ss1[] = {st1, st2, st3};
    		//使用Arrays.sort()方法
    		Arrays.sort(ss1, new MyComparator2());
    		for (Student2 student : ss1) {
    			System.out.print(student);
    		}
    	}
    }
    class MyComparator2 implements Comparator<Object>{
    	@Override
    	public int compare(Object o1, Object o2){
    		//如果两个都是整数才调用该比较方法
    		if(o1 instanceof Integer && o2 instanceof Integer){
    			Integer i1 = (Integer) o1;
    			Integer i2 = (Integer) o2;
    			return -i1.compareTo(i2);
    		}
    		//如果两个都是student2类型
    		if(o1 instanceof Student2 && o2 instanceof Student2){
    			Student2 s1 = (Student2)o1;
    			Student2 s2 = (Student2)o2;
    			//先按名字字典序排序,再按学号升序排序
    			int t = s1.getName().compareTo(s2.getName());
    			if(t == 0){
    				return s1.getId().compareTo(s2.getId());
    			}else return t;
    		}
    		return 0;
    	}
    }
    //自定义一个学生类,然后对学生进行排序
    class Student2{
    	Integer id;
    	String name;
    	
    	public Student2(Integer id, String name) {
    		super();
    		this.id = id;
    		this.name = name;
    	}
    	public Integer getId() {
    		return id;
    	}
    	public void setId(Integer id) {
    		this.id = id;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	@Override
    	public String toString() {
    		return "[id=" + id + ", name=" + name + "] ";
    	}
    }
    

    运行结果:

    321 32 3 
    ---------------
    496 465 51 6 1 1 -156 
    *************************
    [id=124, name=Allen] [id=122, name=Bob] [id=123, name=Bob] 
    ---------------
    [id=124, name=Allen] [id=122, name=Bob] [id=123, name=Bob] 
    

    Comparable具体使用方法:

    public class TestComparable {
    	public static void main(String args[]){
    		Student3 st1 = new Student3(123, "Bob");
    		Student3 st2 = new Student3(122, "Bob");
    		Student3 st3 = new Student3(124, "Allen");
    		//使用Collections.sort()方法进行排序
    		List<Student3> list1 = new ArrayList<>();
    		list1.add(st1);list1.add(st2);list1.add(st3);
    		Collections.sort(list1);
    		for (Student3 student : list1) {
    			System.out.print(student);
    		}
    		
    		System.out.println("\n-------------");
    		
    		//使用Arrays.sort()方法进行排序
    		Student3 s[] = {st1, st2, st3};
    		Arrays.sort(s);
    		for (Student3 student : s) {
    			System.out.print(student);
    		}
    	}
    }
    //实现Comparable接口
    class Student3 implements Comparable<Student3>{
    	Integer id;
    	String name;
    	
    	public Student3(Integer id, String name) {
    		super();
    		this.id = id;
    		this.name = name;
    	}
    	public Integer getId() {
    		return id;
    	}
    	public void setId(Integer id) {
    		this.id = id;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	@Override
    	public String toString() {
    		return "[id=" + id + ", name=" + name + "] ";
    	}
    	//重写compareTo方法,自定义排序规则
    	@Override
    	public int compareTo(Student3 stu){
    		//先按名字字典序排序,再按学号升序排序
    		int t = this.name.compareTo(stu.name);
    		if(t == 0){
    			return this.id.compareTo(stu.id);
    		}else return t; 
    	}
    }
    

    运行结果:

    [id=124, name=Allen] [id=122, name=Bob] [id=123, name=Bob] 
    -------------
    [id=124, name=Allen] [id=122, name=Bob] [id=123, name=Bob] 
    

    弄懂Java中排序的一些使用方法后,手是不是有点痒。试试下面这个题目吧。
    题目出处参考《剑指offer》:把数组排成最小的数
    题目描述
       输入一个正整数数组,把数组里所有数字拼接起来排成一个数,打印能拼接出的所有数字中最小的一个。
    例如输入数组{3,32,321},则打印出这三个数字能排成的最小数字为321323。

    输入描述
       多组输入
    每组测试样例第一行为n,表示数组有n个整数,接下来一行n个整数

    输入描述
       每组输入输出一行,整个数组排成的最小的数字
    sample input
       5
    6 2 87 15 2
    3
    3 32 321

    sample output
       1522687
    321323

    source
       《剑指offer》:把数组排成最小的数

        起初可能会没有思路,但是仔细想想过后,你会发现这是一道排序题,通过自定义排序规则就可以做到排出来的数字最小。
    思路:假设两个数m和n,试考虑m和n应该怎么排列才能使得m和n拼接的数字最小?这个应该很好办,无非就是两种拼接方式都试一遍,比较一下mn和nm的大小即可。这样一来,两个数扩展到n个数也是一样的。我们只需要两两进行拼接进行比较,知道最后全部比完,这也就相当于一个排序。
        当mn < nm时,我们想要的是mn这种拼接方式,所以m应该排在n前面。而当mn = nm时,无论哪种方式都可以。同理当mn > nm时,我们定义n排在m前面。
        那么问题来了,怎么进行拼接?很直观的可以想到两个数值拼接起来,但是这样是有可能溢出的。所以我们采用字符串拼接,把数字看成字符串,然后进行比较。下面代码中调用的是String自带的compareTo方法(按照字典序)。
    示例代码:

    import java.util.Arrays;
    import java.util.Comparator;
    import java.util.Scanner;
    
    public class OfferSort {
    	public static void main(String args[]){
    		Scanner sc = new Scanner(System.in);
    		int n;
    		
    		while(sc.hasNext()){
    			n = sc.nextInt();
    			//输入
    			int arr[] = new int[n];
    			for(int i = 0; i < n; i++)
    				arr[i] = sc.nextInt();
    			
    			//转化为字符串
    			String s[] = new String[arr.length];
    			for(int i = 0; i < arr.length; i++)
    				s[i] = String.valueOf(arr[i]);
    			
    			//按照自定义的规则排序
    			Arrays.sort(s, new MyComparator5());
    			//组装答案并输出
    			String ans = "";
    			for (String str : s) 
    				ans += str;
    			System.out.println(ans);
    		}
    	}
    }
    class MyComparator5 implements Comparator<Object>{
    	@Override
    	public int compare(Object o1, Object o2){
    		if(o1 instanceof String && o2 instanceof String){
    			String s1 = (String)o1;
    			String s2 = (String)o2;
    			String s3 = s1+s2;
    			String s4 = s2+s1;
    			int t = s3.compareTo(s4);
    			if(t > 0)//若s3>s4,即s1s2 > s2s1,所以我们s2排在s1的前面
    				return 1;
    			else if(t < 0)//s3<s4, 所以s1应该排在s2前面
    				return -1;
    			else return 0;
    		}
    		return 0;
    	}
    }
    
    展开全文
  • java 自定义排序

    2019-10-13 23:47:01
    有两种自定义排序的方法, 实现Comparable接口 public int compareTo(Object o) {} 实现Comparator接口 public class Main implements Comparable{ public int age; public String name; public Main(int ...

    有两种自定义排序的方法,

    1. 实现Comparable接口
      public int compareTo(Object o) {}

    2. 实现Comparator接口

    public class Main implements Comparable{
    	public int age;
    	public String name;
    	public Main(int age,String name) {
    		// TODO Auto-generated constructor stub
    		this.age=age;
    		this.name=name;
    	}
    	public Main() {
    		// TODO Auto-generated constructor stub
    	}
        public static void main(String[] args) {
    		Random random=new Random(100);
    		List<Main> list=new ArrayList<Main>();
    		for(int i=0;i<10;i++) {
    			list.add(new Main(random.nextInt(100),random.nextInt(100)+""));//随机生成age
    		}
    		Collections.sort(list);
    		for(Main i:list) {
    			System.out.println(i.age+" "+i.name);
    		}
    	}
        // <font color="red">实现compareTo方法</font>
    	@Override
    	public int compareTo(Object o) {
    		// TODO Auto-generated method stub
    		Main toCompare=(Main)o;
    		if (this.age>toCompare.age) {
    			return 1;
    		}
    		else if (this.age==toCompare.age) {
    			return 0;
    		}
    		else {
    			return -1;
    		}
    	}
    }
    
    package HOMEWORK;
    import java.util.*;
    import java.io.*;
    
    
    public class Main {
    	public int age;
    	public String name;
    	public Main(int age,String name) {
    		// TODO Auto-generated constructor stub
    		this.age=age;
    		this.name=name;
    	}
    	public Main() {
    		// TODO Auto-generated constructor stub
    	}
        public static void main(String[] args) {
    		Random random=new Random(100);
    		Main[] list=new Main[10];
    		for(int i=0;i<10;i++) {
    			list[i]=new Main(random.nextInt(100),random.nextInt(100)+"");
    		}
    		System.out.println("未修改前:");
    		for(Main i:list) {
    			System.out.print(i.age+" ");
    		}
    		System.out.println();
    		Arrays.sort(list,new Comparator<>() {
    			
    			@Override
    			public int compare(Main o1, Main o2) {
    				// TODO Auto-generated method stub
    		    	return o1.age-o2.age;
    			}
    		});
    		System.out.println("修改后:");
    		for(Main i:list) {
    			System.out.print(i.age+" ");
    		}
    	}
       
    }
    
    展开全文
  • 下面小编就为大家带来一篇java中实现Comparable接口实现自定义排序的示例。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Collections.sort(List<T> list,Comparator<? super T> c);方法 例如有如下集合: List<Map<String, Object>> list = new ArrayList<...集合内值为: {name=zs, a...

    Collections.sort(List<T> list,Comparator<? super T> c);方法

     

    例如有如下集合:

    List<Map<String, Object>> list = new ArrayList<Map<String,Object>>();

    集合内的值为:

    {name=zs, age=23},

    {name=ls, age=25},

    {name=ww, age=22},

    {name=zl, age=37},

    {name=qq, age=18}

     

     

    我们要根据age的值给集合中的元素排序

    使用Collections.sort(List<T> list,Comparator<? super T> c);方法

    Collections.sort(list, new Comparator<Map<String, Object>>()
    {
        @Override
        public int compare(Map<String, Object> o1, Map<String, Object> o2)
        {
            return 0;
        }
    });

     

     

    Comparator接口实现compare方法

    经过踩坑,知道了compare方法两个参数代表的意义

    o1代表后一个元素,o2代表前一个元素

    例如上述list集合,当方法进行第一次比较时,o1是{name=ls, age=25},o2是{name=zs, age=23}

     

    compare方法的返回值是0、正整数、负整数

    当返回0或正整数时,元素排序不变

    当返回负整数时,元素调换位置

     

    例如我们要将上述list集合按照升序排列,代码如下:

    Collections.sort(list, new Comparator<Map<String, Object>>()
    {
        @Override
        public int compare(Map<String, Object> o1, Map<String, Object> o2)
        {
            // o1代表着后一个元素,o2代表前一个元素
            int ageF = (int)o1.get("age");
            int ageB = (int)o2.get("age");
            
            // 容易理解的代码
            if (ageF >= ageB)
            {// 如果后一个元素的值大于或等于前一个元素的值,元素位置不变
                return 1;
            }
            else
            {// 如果后一个元素的值小于前一个元素的值,代码位置调换
                return -1;
            }
            
            // 上述代码可简化为:
            // return ageF - ageB;
        }
    });

    遍历执行后的集合:

    list.forEach(map->System.out.println(map.get("name").toString() + ":" + map.get("age")));得到结果:

     

    展开全文
  • 在日常写程序时,或做笔试题时总会遇到自己定义类或者数据结构,如果把自己定义类存入List这样数组中,排序是很麻烦,比如:下面定义了一个Person类class Person{String name;int age;public Person(String ...
  • 刷leetcode时遇到一道题,一种解法需要使用用户自定义的排序方式,于是顺便学习了Comparator接口的使用方法,记录一下 class Solution { public boolean isAlienSorted(String[] words, String order) { Map<...
  • 1、原则Comparator接口可以实现自定义排序,实现Comparator接口时,要重写compare方法:int compare(Object o1, Object o2) 返回一个基本类型整型如果要按照升序排序,则o1 小于o2,返回-1(负数),相等返回0,01...
  • 本文实例讲述了Java针对ArrayList自定义排序的2种实现方法。分享给大家供大家参考,具体如下:Java中实现对list的自定义排序主要通过两种方式1)让需要进行排序的对象的类实现Comparable接口,重写compareTo(T o)方法...
  • 需要Map按key值进行排序,就需要...TreeMap的自定义排序的构造方法如下:publicTreeMap(ComparatorsuperK>comparator){this.comparator=comparator;}自定义排序案例代码如下:importjava.util.Comparator;impor...
  • 实例如下所示: class ... } } } 以上这篇java中实现comparable接口实现自定义排序的示例就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持萬仟网。 希望与广大网友互动?? 点此进行留言吧!
  • Map接口的哈希表和链接列表实现,具有可预知迭代顺序。此实现与HashMap不同之处在于,后者维护着一个运行于所有条目双重链接列表。此链接列表定义了迭代顺序,该迭代顺序通常就是将将键插入到映射中顺序...
  • Comparator Comparator是比较器接口。 @FunctionalInterface public interface Comparator<T> { int compare(T o1, T o2)...o1表示前面字符,o2表示后面字符,Java默认升序。 返回值 返回值大于0,表示o...
  • 除了利用数据库sql语句排序还可以利用java的Comparable接口自定义排序。 import java.util.ArrayList; import java.util.Collections; import java.util.List; public class Employee implements Comparable&...
  • Java使用Comparable接口自定义排序

    千次阅读 2017-04-19 21:01:01
    默认情况下,保存在List集合中的数组是不进行排序的,不过可以通过使用Comparable接口自定义排序规则并自动排序。本实例将介绍如何使用Comparable接口自定义排序规则并自动排序。   实现过程 新建一个Java类,...
  • Java中提供了Arrays和Collections类能够帮助我们来实现排序,但是前提是数组或者集合中元素都必须实现Comparable接口,基本数据类型对应类都已经实现了Comparable接口了,所以我们才能够直接对含有基本类型...
  • 如果想对自定义的类进行自定义排序的话,这个类就必须实现Comparable或者Comparator接口。Example:首先定义一个person类,里面有字段name和age。先按name排序,name相同在按照age排序。注:使用了Lombok插件,如何...
  • 主要介绍了JAVA使用Comparator接口实现自定义排序,文中通过示例代码介绍非常详细,对大家学习或者工作具有一定参考学习价值,需要朋友们下面随着小编来一起学习学习吧
  • Lucene中的自定义排序功能和Java集合中的自定义排序的实现方法差不多,都要实现一下比较接口. 在Java中只要实现Comparable接口就可以了.但是在Lucene中要实现SortComparatorSource接口和ScoreDocComparator接口.在...
  • JAVA 使用Comparator接口实现自定义排序 1、原则 Comparator接口可以实现自定义排序,实现Comparator接口时,要重写compare方法: int compare(Object o1, Object o2) 返回一个基本类型整型 ...
  • 2、使用Comparator接口规则:编写多个排序方式类实现Comparator接口,并重写新Comparator接口compare()方法。升序是前者减去后者,降序是后者减去前者。 3、代码测试:同时也是牛客网中某题。 题目描述: 搜狐...
  • Java自定义的类排序: Comparable接口 Comparable接口作用: comparaTo方法: 利用comparator接口实现排序的方法步骤: 例程源码: 例题: Java自定义的类排序: Comparable接口 Comparable接口作用: ...
  • 排序的算法,大家都不陌生,有冒泡排序、选择排序、插入排序,快速排序等等。如果现在有学生类,学校添加了很多学生,要你给学生按照学号... 咱们java功能很强大,库里自带给数组排序的方法Arrays.sort(); 来看看...
  • Comparator接口可以实现自定义排序,实现Comparator接口时,要重写compare方法: int compare(Object o1, Object o2) 返回一个基本类型整型 如果要按照升序排序,则o1 小于o2,返回-1(负数),相等返回0,01大于02...
  • Arrays.sort()方法可对任何实现compareble接口的对象数组排序。 源代码 EmployeeSortTest.java import java.util.*; /** * This program demonstrates the use of the Comparable interface. * @version 1.30...
  • Java中实现对list的自定义排序主要通过两种方式 1)让需要进行排序的对象的类实现Comparable接口,重写compareTo(T o)方法,在其中定义排序规则,那么就可以直接调用Collections.sort()来排序对象数组 public ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,000
精华内容 400
关键字:

java自定义排序的接口

java 订阅