精华内容
下载资源
问答
  • NULL 博文链接:https://pridesnow.iteye.com/blog/1453660
  • Java对象数组按照其属性排序的方法

    千次阅读 2018-11-14 23:17:04
    也就是需要对象数组按照其属性排序 一 类定义时实现Comparable接口,定义自身的比较算法。 要排序就要有比较的方法, 因为是自定义的类, 系统不知道怎么做两个自定义类的比较, 所以我们要自己在类内写两个类的...

    问题描述:

    开发时我们希望用一个类表示某种物品, 用其域来描述物品的特性, 

    当我们有一组物品也就是一个对象数组时,我们会希望这组物品按照它的某个属性来排序

    也就是需要对象数组按照其属性排序

    一 类定义时实现Comparable接口,定义自身的比较算法。

    要排序就要有比较的方法, 因为是自定义的类, 系统不知道怎么做两个自定义类的比较,

    所以我们要自己在类内写两个类的比较的方法,也就是告诉按照那个属性或者那种方式来给对象数组排序

    自定义比较算法也就是实现Comparable接口:(会自动生成需要自己写的方法如下图)

    补全类:

    public class Good implements Comparable<Good>
    {
    	String name;
    	int price;
    	public Good(String name,int price) 
    	{
    		this.name=name;
    		this.price=price;
    	}
    	@Override
    	public int compareTo(Good good) {
    		// TODO Auto-generated method stub
    		return this.price-good.price;
    	}
    	
    }

    调用Collections.sort(); 

    public static void main(String[] args) 
    	{
    		 ArrayList<Good> goods = new ArrayList<Good>();
    		 goods.add(new Good("二", 2));
    		 goods.add(new Good("三", 3));
    		 goods.add(new Good("一", 1));
    		 
    		 System.out.println("排序前:");
    	     for (Good good : goods)
    	         System.out.println("姓名:"+good.name+" 价格:"+good.price);
    	     
    	     Collections.sort(goods);
    	     
    	     System.out.println("排序后:");
    	     for (Good good : goods)
    	         System.out.println("姓名:"+good.name+" 价格:"+good.price);
    	}

     

    内容参考如下博主:

    https://blog.csdn.net/wangtaocsdn/article/details/71500500

    https://www.cnblogs.com/ygj0930/p/5950971.html

    展开全文
  • Java对象数组按照某属性排序

    千次阅读 2020-10-15 15:58:19
    排序就要有比较的方法, 因为是自定义的类, 系统不知道怎么做两个自定义类的比较,所以我们要自己在类内写两个类的比较的方法,也就是告诉按照那个属性或者那种方式来给对象数组排序,自定义比较算法也就是实现...

    有时候需要对对象列表或数组进行排序,下面提供两种简单方式:

    方法一、将要排序的对象类实现< Comparable >接口。

    要排序就要有比较的方法, 因为是自定义的类, 系统不知道怎么做两个自定义类的比较,

    所以我们要自己在类内写两个类的比较的方法,也就是告诉按照那个属性或者那种方式来给对象数组排序

    自定义比较算法也就是实现Comparable接口:(会自动生成需要自己写的方法如下图)

    public class Good implements Comparable<Good>
    {
    	String name;
    	int price;
    	public Good(String name,int price) 
    	{
    		this.name=name;
    		this.price=price;
    	}
    	@Override
    	public int compareTo(Good good) {
    		// TODO Auto-generated method stub
    		return this.price-good.price;
    	}
    	
    }
    

    调用Collections.sort();

    public static void main(String[] args) 
    	{
    		 ArrayList<Good> goods = new ArrayList<Good>();
    		 goods.add(new Good("二", 2));
    		 goods.add(new Good("三", 3));
    		 goods.add(new Good("一", 1));
    		 
    		 System.out.println("排序前:");
    	     for (Good good : goods)
    	         System.out.println("姓名:"+good.name+" 价格:"+good.price);
    	     
    	     Collections.sort(goods);
    	     
    	     System.out.println("排序后:");
    	     for (Good good : goods)
    	         System.out.println("姓名:"+good.name+" 价格:"+good.price);
    	}
    

    方法二:使用Comparator匿名内部类实现。

    class Student {
    
        String name;
        int age;
        int score;
    
        public Student(String name, int age,int score) {
            this.name = name;
            this.age = age;
            this.score = score;
        }
    }
    
    public class Test {
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            ArrayList<Student> students = new ArrayList<>();
            students.add(new Student("大铭", 19, 89));
            students.add(new Student("来福", 26, 90));
            students.add(new Student("仓颉", 23, 70));
            students.add(new Student("王磊", 18, 80));
    
            System.out.println("排序前:");
            for (Student student : students) {
                System.out.println("姓名:"+student.name+" 年龄:"+student.age+" 成绩:"+student.score);
            }
    
            Collections.sort(students,new Comparator<Student>() {
    
                @Override
                public int compare(Student o1, Student o2) {
                    // TODO Auto-generated method stub
                    return o1.age-o2.age;
                }
            });
    
            System.out.println("排序后:");
            for (Student student : students) {
                System.out.println("姓名:"+student.name+" 年龄:"+student.age+" 成绩:"+student.score);
            }
        }
    }
    

    本文参考:
    Java对对象按照其属性排序的两种方法

    Java对象数组按照其属性排序的方法

    展开全文
  • 最近遇到了一道多条件排序题,类似于“something有A,B,C三个属性,先比较A,A条件相同时再比较B,B条件相同时再比较C,排序输出”的形式。这类题目用C/C++解决起来会很顺手,可以用结构体,结合sort和compare,就能...
    最近遇到了一道多条件排序题,类似于“something有A,B,C三个属性,先比较A,A条件相同时再比较B,B条件相同时再比较C,排序输出”的形式。这类题目用C/C++解决起来会很顺手,可以用结构体,结合sort和compare,就能完成整个思路。但是我们如何用Java来解决这个问题呢。Java是面向对象的语言,没有结构体的概念,我们应该定义类。
    比方说,用一个球队排名问题来举例子。
    现在对象是球队信息Info,有四个属性:球队名name、球队的积分x、净胜球y、进球数z。那么我们这样定义类:

    class Info {
    		private String name;
    		private int x;
    		private int y;
    		private int z;
    
    		public String getName() {
    			return name;
    		}
    
    		public void setName(String name) {
    			this.name = name;
    		}
    
    		public int getx() {
    			return x;
    		}
    
    		public void setx(int x) {
    			this.x = x;
    		}
    
    		public int gety() {
    			return y;
    		}
    
    		public void sety(int y) {
    			this.y = y;
    		}
    
    		public int getz() {
    			return z;
    		}
    
    		public void setz(int z) {
    			this.z = z;
    		}
    	}

    每一个属性相应分别有get和set两个方法,简要解释一下,比方说name属性的setName( ) 方法,作用是设置名称,我们在主函数里对对象的name属性进行赋值时就需要调用它,通过具体的参数值告诉程序你把他设置成什么名称,这是不需要返回值的,也就是定义类型是void的原因;那么getName( )方法,作用就是获取名称了,它不需要参数,程序把name通过返回值传回来,所以它的返回值类型是string。剩余几个举一反三即可,原理一样。

    那么下面的问题是,主函数怎么写。
    我们考虑最复杂的一种情况,就是首先输入数据组数N,然后依次输入每组数据,每组属性里均包含对象的四个属性,这里就要用到对象数组来实现,引入对象数组a [ ] , a[ i ] 中依次存入第 i 组数据对象的四个属性。接着,把对象数组add到集合b中,这样做方便我们进行多属性的条件排序。

                    Scanner sc = new Scanner(System.in);
    		int N = sc.nextInt();
    		String temp = sc.nextLine(); // 输入N后按回车键会被读成nextline,如果这里不用temp过滤掉这个回车键,对下面会有一定影响
    		Info[] a = new Info[N+1];
    		List<Info> b = new ArrayList();
    		
    		for (int i = 0; i < N; i++) {
    			String str = sc.nextLine();
    			String[] s = str.split(" ");
    			a[i] = new Info(); //这一行很重要
    			a[i].setName(s[0]);
    			a[i].setx(Integer.parseInt(s[1]));
    			a[i].sety(Integer.parseInt(s[2]));
    			a[i].setz(Integer.parseInt(s[3]));
    			b.add(a[i]);
    		}


    剩下的问题是,怎样实现多属性的排序,假设我们这样规定:先比较积分x,如果积分x相同则比较净胜球y,如果积分x、净胜球y都相同则比较进球数z。刚刚我们已经将对象数组存在了集合里,其实下面很简单,运用Collections.sortComparator就可以解决:


    		Collections.sort(b, new Comparator<Info>() {
    			public int compare(Info team1, Info team2) {
    				int x = team1.getx() - team2.getx();
    				int y = team1.gety() - team2.gety();
    				int z = team1.getz() - team2.getz();
    				if (x == 0) { 
    					if (y == 0) { 
    						return z; 
    					}
    					return y;
    				}
    				return x;
    			}
    		});

    现在我们再去考虑一种复杂一点的,假设我们把规定改为:先比较积分x,积分x高者名次在前,如果积分x相同则比较净胜球y,净胜球y多者名次在前,如果积分x、净胜球y都相同则比较进球数z,进球数多者名次在前。也就是说,我们需要讲这些多属性多条件进行降序排序,应该如何修改上面的代码呢。思考一下再进行参考:

    		Collections.sort(b, new Comparator<Info>() {
    			public int compare(Info team1, Info team2) {
    				int x = team1.getx() - team2.getx();
    				int y = team1.gety() - team2.gety();
    				int z = team1.getz() - team2.getz();
    				if (x != 0) {
    					return x > 0 ? -1:1;
    				}
    					if (y != 0) {
    						return y > 0 ? -1:1;
    					}
    					return z > 0 ? -1:1;
    			}
    		});

    再延伸一点,很多题目会出现要求当前面的属性x,y,z都相同时,按照球队名称字典序排列。其实这也不难,在上面的基础上加几行就可以:

    		Collections.sort(b, new Comparator<Info>() {
    			public int compare(Info team1, Info team2) {
    				int x = team1.getx() - team2.getx();
    				int y = team1.gety() - team2.gety();
    				int z = team1.getz() - team2.getz();
    				if (x != 0) {
    					return x > 0 ? -1:1;
    				}
    					if (y != 0) {
    						return y > 0 ? -1:1;
    					}
    					if(z!=0) {
    					return z > 0 ? -1:1;
    					}
    					return team1.name.compareTo(team2.name);
    			}
    		});

    最后,我们假设这里只要求输出排序后的球队名称:

    		for (Info result : b) {
    			System.out.println(result.getName());
    		}

    整个思路就都完成了。

    另外还需要提一点,我们的main函数是static静态的,但是我们定义的类Info默认属于内部动态类,这会导致调试的时候出错,所以在完善程序的时候,我们可以把类也定义成static。最后整理一下全部思路是这样的:(按照提到的第二种降序输出)

    import java.util.*;
    
    public class Main {
    	static class Info {
    		private String name;
    		private int x;
    		private int y;
    		private int z;
    
    		
    		public String getName() {
    			return name;
    		}
    
    		public void setName(String name) {
    			this.name = name;
    		}
    
    		public int getx() {
    			return x;
    		}
    
    		public void setx(int x) {
    			this.x = x;
    		}
    
    		public int gety() {
    			return y;
    		}
    
    		public void sety(int y) {
    			this.y = y;
    		}
    
    		public int getz() {
    			return z;
    		}
    
    		public void setz(int z) {
    			this.z = z;
    		}
    
    	}
    
    	@SuppressWarnings("unchecked")
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		
    		int N = sc.nextInt();
    		String temp = sc.nextLine();
    		Info[] a = new Info[N+1];
    		List<Info> b = new ArrayList();
    		
    		for (int i = 0; i < N; i++) {
    			String str = sc.nextLine();
    			String[] s = str.split(" ");
    			a[i] = new Info();
    			a[i].setName(s[0]);
    			a[i].setx(Integer.parseInt(s[1]));
    			a[i].sety(Integer.parseInt(s[2]));
    			a[i].setz(Integer.parseInt(s[3]));
    			b.add(a[i]);
    		}
    		
    		
    		Collections.sort(b, new Comparator<Info>() {
    			public int compare(Info team1, Info team2) {
    				int x = team1.getx() - team2.getx();
    				int y = team1.gety() - team2.gety();
    				int z = team1.getz() - team2.getz();
    				if (x != 0) {
    					return x > 0 ? -1:1;
    				}
    					if (y != 0) {
    						return y > 0 ? -1:1;
    					}
    					if(z!=0) {
    					return z > 0 ? -1:1;
    					}
    					return team1.name.compareTo(team2.name);
    			}
    		});
    
    		for (Info result : b) {
    			System.out.println(result.getName());
    		}
    	}
    }

    现在假设我们的输入数据是这样的:


    那么以上程序的最终运行结果为:





    展开全文
  • java中对对象数组排序

    千次阅读 多人点赞 2019-06-27 13:52:04
    1. 我们在编写程序的时候有时候会遇到...在比较器对象中我们需要重写compare方法,在这个方法里面规定按照对象中的某个属性排序的规则,这样就可以对对象数组进行排序了 需要注意的一个问题是对象数组每一个元素...

    1. 问题描述:

    我们在编写程序的时候有时候会遇到需要对当前的对象数组按照对象中的每一个属性来进行排序,这个时候就需要使用到我们的Arrays.sort( )方法了,在方法中需要传入的第一个参数是需要排序的对象数组,第二个参数是传入比较器的对象,在比较器对象中我们需要重写compare方法,在这个方法里面规定按照对象中的某个属性排序的规则,这样就可以对对象数组进行排序了

    需要注意的一个问题是对象数组每一个元素都是一个对象我们在创建对象数组的时候需要对其对象数组的每一个元素进行初始化,也就是对对象数组中的每一个数组元素都赋予一个创建的对象

    2. 下面是根据学生的分数由高到低进行排序:

    import java.util.Arrays;
    import java.util.Comparator;
    public class Main {
    	public static void main(String[] args) {
    		Student stus[] = new Student[3];
    		for(int i = 0; i < stus.length; ++i){
    			stus[i] = new Student();
    		}
    		stus[0].name = "xiaoming";
    		stus[0].age = 21;
    		stus[0].grade = 89;
    		stus[1].name = "xiaohong";
    		stus[1].age = 18;
    		stus[1].grade = 97;
    		stus[2].name = "xiaoliang";
    		stus[2].age = 24;
    		stus[2].grade = 78;
    		Comparator<Student> comp = new Comparator<Main.Student>() {
    			@Override
    			public int compare(Student o1, Student o2) {
    				if(o1.grade < o2.grade){
    					return 1;
    				}else if(o1.grade > o2.grade){
    					return -1;
    				}
    				return 0;
    			}
    		};
    		Arrays.sort(stus, comp);
    		for(int i = 0; i < stus.length; i++){
    			System.out.println(stus[i]);
    		}
    	}
    	
    	public static class Student{
    		String name;
    		int age;
    		int grade;
    		public String getName() {
    			return name;
    		}
    		public void setName(String name) {
    			this.name = name;
    		}
    		public int getAge() {
    			return age;
    		}
    		public void setAge(int age) {
    			this.age = age;
    		}
    		public int getGrade() {
    			return grade;
    		}
    		public void setGrade(int grade) {
    			this.grade = grade;
    		}
    		@Override
    		public String toString() {
    			return "Student [name=" + name + ", age=" + age + ", grade=" + grade + "]";
    		}
    	}
    }
    

     

    展开全文
  • java的学习笔记(资料来源自尚硅谷)简介附上代码代码过程如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片 简介 本文主要目的是编写一个StudenTest对象,实现一下几个功能: 创建20个学生对象,学号为1到...
  • 对象数组中,按对象中的某个属性两辆比较属性大小,再按从大到小排序。 虽然可以直接调用属性进行排序,可是如果重写了对象的compareTo方法,或者其他因素就不行了,所以在这里记录一下两两比较,使用计数法来...
  • 使用sort(fn)按属性对象数组进行排序 信不信由你,JavaScript提供给您JavaScript库之外的辅助方法和类还比JavaScript多得多。 不,像兄弟一样认真; 这些JavaScript提供的方法确实存在。 这些方法之一是sort...
  • 下面小编就为大家分享一篇java根据List内对象属性排序方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 定义类Student,包含三个属性:学号number(int),年级state(int) ,成绩score(int)。创建20个学生对象,学号为1到20号,年级和成绩都由随机数确定。 问题1:打印出3年级(state值为3)的学生信息。 问题2:使用...
  • 在我们现实生产中我们手中获得的数据并不一定就是我们想要的数据,因此我们经常要对其进行加工、锤炼,闲话少说,今天我们谈一下如何将对象数组按对象中的某一个属性进行排序。主要用到的技术是javajava.util....
  • Js--使用sort根据数组对象的某一个属性值进行排序博客说明文章所涉及的资料来自互联网整理和个人总结,意在于个人学习和经验汇总,如有什么地方侵权,请联系本人删除,谢谢!说明在开发的时候时常会遇到这样的问题...
  • 有一个数组,里面装的都是对象.var array=[{"id": 52354541,"name": "比率","value": "55"},{"id": 43563123,"name": "比率","value": "88"},{"id": 32525763,"name": "比率","value": "76"}];如果是查找最大值 可以...
  • 当我们想对一个对象数组(集合)根据某一属性进行排序时,我们可以使用list中的Collection.sort(),这是一种较快捷的方式。 先放对象类型 public class Student { String name; double MathScore; double ...
  • Java对象数组的使用

    万次阅读 多人点赞 2019-04-11 22:36:09
    给你一组学生的数据,比如姓名,性别,学号,成绩,然后根据成绩排序,这时你就得用对象数组
  • 有个js对象数组 var ary=[{id:1,name:”b”},{id:2,name:”b”}] 需求是根据name 或者 id的值来排序,这里有个风骚的函数 函数定义: 代码如下: function keysrt(key,desc) {  return function(a,b){  return desc ...
  • 让需要进行排序的对象实现Comparable接口,重写其中的compareTo(T o)方法,在其中定义排序规则,那么就可以直接调用java.util.Arrays.sort()来排序对象数组。在这个方法中,如果返回-1,则当前对象排前面,返回1,就...
  • 1 普通数组使用Arrays.sort方法排序 本专题首发于简书-码农先生 在Arrays工具类中,sort函数可以对普通数组进行排序,如以下代码所示: int[] hello = {18888,8888,5888,13888}; Arrays.sort(hello); System....
  • 对象类型(Object[])的数组(数组中存放的是指向Java对象中的引用)一个能通用于两种不同类型数组的函数:GetArrayLength(jarray array);首先来看一下怎么处理基本类型的数组:(1) GetArrayElements(Array arr , jboolean...
  • 如何使用 Java 对 List 中每个对象元素按时间顺序进行排序Java 实现import java.text.SimpleDateFormat;import java.util.ArrayList;import java.util.Date;import java.util.List;public class TestListSort {...
  • java8 对象数组转集合的简单操作

    千次阅读 2020-05-12 15:13:39
    java8对象数组转集合的简单操作 java8版本对传统的集合类的简单操作结合拉姆达表达式相比之前版本方便快捷,很大程度减少了代码量。相对数据库而言大大的减少了数据处理数据的压力。部分统计可以转移在程序中处理。...
  • Java数组的定义与使用

    2021-02-26 13:30:55
    格式数据类型[] 数组名=new 数据类型[元素个数]"数据类型"表示该数组中可以存放哪一类型的数据"[]" 表示当前变量的数据类型为数组类型"元素个数" 限制了当前数组中可以存放的数据个数创建数组时,java系统自动设置...
  • 7 Java数组,冒泡排序

    2021-03-07 11:10:22
    1. 包装类(Wrapper Class)。针对于原生数据类型的包装。所有的包装类(8 个)都位于 java.lang 包下。Java 中的 8 个包装类分别是:Byte,Short, Integer, Long, Float, Double, Character, Boolean...2. 数组(Array):...
  • Java对象数组使用 一、Java数组的使用二、Java的对象数组2.1 问题提出2.2 问题解析2.3 问题拆分2.4 代码实现 一、Java数组的使用 对象数组其实和Java的数组类似的,所以要很清楚Java的数组是如何...
  • vb中的sortedList和java中的 vb中sortedList集合了数组和散列表的特征,可以像数组,ArrayList等索引获取值,也可以像hashtable,hashmap等散列表通过键值对获取值 随机推荐 QQ--模拟登录 QQ--模拟登录 使用PC端模拟...
  • 下面小编就为大家带来一篇根据list中对象属性去重和排序小结(必看篇)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • /* Json格式的数组形式 */ JSONObject obj; /* json格式的单个对象形式 */ for (int i = 0; i (); i++ ) { obj = new JSONObject(); obj.put( "dnum", kdDynamics.get(i).getDnum() ); obj.put( "dtime", df.format...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 94,838
精华内容 37,935
关键字:

java对象数组属性排序

java 订阅