精华内容
下载资源
问答
  • 一杯清水因滴入一滴污水而变污浊,一杯污水却不会因一滴清水的存在而变清澈。以前在上家公司的时候,需要做这么一个效果,...好了,我们归入正题,在java中,对象之间比较大小是根据一定的标准,当然这个标准由你来定

    一杯清水因滴入一滴污水而变污浊,一杯污水却不会因一滴清水的存在而变清澈。

    以前在上家公司的时候,需要做这么一个效果,就是将所有的人的名字按照自然顺序在手机上展示一个通讯录,有人就说了,这不是简单吗?你听我细说,当时公司返回来的是整个公司的员工的名字,然后最坑爹的是这些名字都是汉字,而不是拼音。。。。。。。。。。。。

    好了,我们归入正题,在java中,对象之间比较大小是根据一定的标准,当然这个标准由你来定,比如比较同学们的大小,那么就是比较他们的年龄了。其实很简单,那么我们应该怎么做呢??

    对,就是实现java中的Comparable和Comparator这两个接口,自己自定义一个,大兄弟,你看到也许会感叹,好久没用过这两个类了。

    如果实现Comparable,那么我们就要实现compareTo(T o)这个方法:我们来看下这个方法:

    int compareTo(T o)
    返回值为int
    返回值大于0,表示大于
    0,等于
    返回值小于0,表示小于

    如果是实现Comparator这个接口,那我们就要实现compare()方法:我们看下compare()这个方法:

    int compare(T o1, T o2)
    返回值为int
    返回值大于0,表示大于
    0,等于
    返回值小于0,表示小于

    其实大同小异,我们接下来写代码举个例子,对了,就举上面的例子,将人姓名的自然顺序打出来,先创建一个Person类:

    public class Person implements Comparable<Person>{
        private String name;
        private int age;
        private int apartMentId;
    
        public Person(String name, int age, int apartMentId) {
            this.name = name;
            this.age = age;
            this.apartMentId = apartMentId;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", apartMentId=" + apartMentId +
                    '}';
        }
    
        @Override
        public int compareTo(Person o) {
            return this.name.compareTo(o.name);
        }

    然后我们写到我们的主工程去实现一下看看效果

     public class Main {
        public static void main(String[] args){
    
            List<Person> listPerson = new ArrayList<>();
            Person person1 = new Person("zhangsan",18,200);
            Person person2 = new Person("lisi",20,200);
            Person person3 = new Person("wangwu",21,200);
    
            listPerson.add(person1);
            listPerson.add(person2);
            listPerson.add(person3); 
            Collections.sort(listPerson);
            System.out.println(listPerson.toString());
        }
    }
    

    看下运行效果:

    [Person{name='lisi', age=20, apartMentId=200}, Person{name='wangwu', age=21, apartMentId=200}, Person{name='zhangsan', age=18, apartMentId=200}]

    是不是感觉很简单,成热打铁,我们来实现另一种方式,这次我们用age来比较大小

    public class Main {
        public static void main(String[] args) {
    
            List<Person> listPerson = new ArrayList<>();
            Person person1 = new Person("zhangsan", 18, 200);
            Person person2 = new Person("lisi", 20, 200);
            Person person3 = new Person("wangwu", 21, 200);
    
            listPerson.add(person1);
            listPerson.add(person2);
            listPerson.add(person3);
    
            Collections.sort(listPerson, new Comparator<Person>() {
                @Override
                public int compare(Person o1, Person o2) {
                    if (o1.getAge() > o2.getAge()) {
                        return 1;
                    } else if (o1.getAge() < o2.getAge()) {
                        return -1;
                    } else if (o1.getAge() == o2.getAge()) {
                        return 0;
                    }
                    return 0;
                }
            });
            System.out.println(listPerson.toString());
        }

    看下结果:

    [Person{name='zhangsan', age=18, apartMentId=200}, Person{name='lisi', age=20, apartMentId=200}, Person{name='wangwu', age=21, apartMentId=200}]

    是不是已经达到我们想要的效果了呢??
    哈哈,就是这么简单,但是时间一长不用便就没那么容易了,本人是做android,如果你说你光做布局,不会用到,但是你想做更深层次的东西,java基础还是很重要的。
    好了,这里我们这个知识点就到这里。源码不再黏贴地址了,很简单,加油!

    展开全文
  • 创建了两个对象比较对象,就需要用专门的方法来完成: 1.实现Comparable接口,重写其中的Compare To方法(this和o之间比较) import java.util.ArrayList; import java.util.Collections; import java.util.List...

    Java中的 < > <= >= 只能针对数字类型来使用
    创建了两个对象来比较对象,就需要用专门的方法来完成:
    1.实现Comparable接口,重写其中的Compare To方法(this和o之间的比较)

    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    
    class Card implements Comparable<Card> {
        public String rank;
        public String suit;
    
        public Card(String rank, String suit) {
            this.rank = rank;
            this.suit = suit;
        }
        @Override
        public int compareTo(Card o) {
            //this, o
            //this < o, return < 0
            //this > o, return > 0
            //this = o, return 0
            //定义比较规则:扑克牌的点数来进行比较
            int rank1 = this.convertRank();
            int rank2 = o.convertRank();
            //升序排序
            return rank1 - rank2;
           //降序排序
          //return rank2 - rank1;
        }
        private int convertRank() {
        //把String类型的rank转成int值
        //2 - 10 =》2 - 10
        //J => 11 Q => 12 K => 13 A => 14
        if ("A".equals(rank)) {
            return 14;
        }
        if ("K".equals(rank)) {
            return 13;
        }
        if ("Q".equals(rank)) {
            return 12;
        }
        if ("J".equals(rank)) {
            return 11;
        }
        return Integer.parseInt(rank);
    }
    
    @Override
    public String toString() {
        return "Card{" +
                "rank='" + rank + '\'' +
                ", suit='" + suit + '\'' +
                '}';
    }
    
    public class TestCompare {
       
    
        public static void main(String[] args) {
            List<Card> cards = new ArrayList<>();
            cards.add(new Card("A", "红桃"));
            cards.add(new Card("J", "红桃"));
            cards.add(new Card("Q", "红桃"));
            cards.add(new Card("K", "红桃"));
            Collections.sort(cards);
            System.out.println(cards);
        }
    }

    2.实现Comparator接口,重写其中的Compare方法

    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;
    
    class Card {
        public String rank;
        public String suit;
    
        public Card(String rank, String suit) {
            this.rank = rank;
            this.suit = suit;
        }
    
    
    
        public int convertRank() {
            // 把 String 类型的 rank 转成 int 值.
            // 2 - 10 => 2 - 10
            // J => 11
            // Q => 12
            // K => 13
            // A => 14
            if ("A".equals(rank)) {
                return 14;
            }
            if ("J".equals(rank)) {
                return 11;
            }
            if ("Q".equals(rank)) {
                return 12;
            }
            if ("K".equals(rank)) {
                return 13;
            }
            return Integer.parseInt(rank);
        }
    
        @Override
        public String toString() {
            return "Card{" +
                    "rank='" + rank + '\'' +
                    ", suit='" + suit + '\'' +
                    '}';
        }
    }
    
    class CardComparator implements Comparator<Card> {
        @Override
        public int compare(Card o1, Card o2) {
            int rank1 = o1.convertRank();
            int rank2 = o2.convertRank();
            return rank1 - rank2;
        }
    }
    
    
    public class TestCompare2 {
        public static void main(String[] args) {
            List<Card> cards = new ArrayList<>();
            cards.add(new Card("A", "红桃"));
            cards.add(new Card("J", "红桃"));
            cards.add(new Card("K", "红桃"));
            cards.add(new Card("10", "红桃"));
            Collections.sort(cards, new CardComparator());
            System.out.println(cards);
        }
    
    }

    以上两个方法的比较:
    例如针对Card类来进行比较:
    1.对Comparable来说,必须要让Card类来实现Comparable
    2.对于Comparator来说,是创建一个新的类(CardComparator),让这个类实现Comparator,然后完成对Card比较
    3.Comparable 只能指定一种比较规则,而Comparator可以指定多种比较规则
    注:
    你想要比较的类可能修改不了(比如类是某个库的类,不是你自己写的类)

    最终结论:Comparator比Comparable适用范围更广泛

    展开全文
  • 首先定义一个对象,注意这个对象必须实现Comparable接口,并重写这个接口的compareTo方法package cn.demo;public class Student implements Comparable{private int number=0; //学号private String name=""; //学生...

    首先定义一个对象,注意这个对象必须实现Comparable接口,并重写这个接口的compareTo方法

    package cn.demo;

    public class Student implements Comparable{

    private int number=0; //学号

    private String name=""; //学生姓名

    private String gender=""; //性别

    public int getNumber(){

    return number;

    }

    public void setNumber(int number){

    this.number=number;

    }

    public String getName(){

    return name;

    }

    public void setName(String name){

    this.name=name;

    }

    public String getGender(){

    return gender;

    }

    public void setGender(String gender){

    this.gender=gender;

    }

    public int compareTo(Object obj){

    Student student=(Student)obj;

    if(this.number==student.number){

    return 0; //如果学号相同,那么两者就是相等的

    }else if(this.number>student.getNumber()){

    return 1; //如果这个学生的学号大于传入学生的学号

    }else{

    return -1; //如果这个学生的学号小于传入学生的学号

    }

    }

    }

    在上面的重写方法中标红的地方,如果是小于号,则是按照降序排列,但是在我贴上去的代码,则是按升序排列

    接下来就是测试类了:

    package cn.demo;

    import java.util.ArrayList;

    import java.util.Collections;

    import java.util.Iterator;

    public class Test {

    public static void main(String[] args) {

    Student student1=new Student();

    student1.setNumber(5);

    Student student2=new Student();

    student2.setNumber(2);

    Student student3=new Student();

    student3.setNumber(1);

    Student student4=new Student();

    student4.setNumber(4);

    ArrayList list=new ArrayList();

    list.add(student1);

    list.add(student2);

    list.add(student3);

    list.add(student4);

    System.out.println("-------排序前-------");

    Iterator iterator=list.iterator();

    while(iterator.hasNext()){

    Student stu=iterator.next();

    System.out.println(stu.getNumber());

    }

    //使用Collections的sort方法对list进行排序

    System.out.println("-------排序后-------");

    Collections.sort(list);

    iterator=list.iterator();

    while(iterator.hasNext()){

    Student stu=iterator.next();

    System.out.println(stu.getNumber());

    }

    }

    }

    如上所示,可以直接使用collections的sort方法进行排序

    -------排序前-------

    5

    2

    1

    4

    -------排序后-------

    5

    4

    2

    1

    补充知识:【JAVA】用Comparable接口学生的成绩做降序排序!请正确指定泛型;用Comparator实现按照姓名排序,请正确指定泛型!

    创建四个学生信息,分别包含姓名(String) , 年龄(int) ,分数(double)

    (1)用Comparable接口对下列四位同学的成绩做降序排序, 如果成绩一样,那在成绩排序的基础上按照年龄由小到大排序,请正确指定泛型;

    (2)用Comparator实现按照姓名排序,请正确指定泛型。

    //定义学生类,并实现Comparable接口

    public class Student implements Comparable{

    private String name;

    private int age;

    private double grade;

    public Student() {

    }

    public Student(String name, int age, double grade) {

    this.name = name;

    this.age = age;

    this.grade = 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 double getGrade() {

    return grade;

    }

    public void setGrade(double grade) {

    this.grade = grade;

    }

    @Override

    public String toString() {

    return "Student [姓名 :" + name +

    " 年龄 :" + age +

    " 分数" + grade + "]";

    }

    /**

    * 用Comparable接口对下列四位同学的成绩做降序排序,

    * 如果成绩一样,那在成绩排序的基础上按照年龄由小到大排序。请正确指定泛型

    * @param o

    * @return

    */

    @Override

    public int compareTo(Student o) {

    if(Double.compare(this.getGrade() , o.getGrade()) != 0){

    if(Double.compare(this.getGrade() , o.getGrade()) > 0){

    return 1;

    }else {

    return -1;

    }

    }

    return this.getAge() - o.getAge();

    }

    }

    *定义Student类,声明基本的属性,方法及完成对Comparable接口的实现,实现“对成绩实现降序,如果成绩一样,在成绩排序的基础上按照年龄由大到小的排序”的结果。

    public class Task {

    public static void main(String[] args) {

    //定义四个学生对象

    Student[] s1 = new Student[4];

    s1[0] = new Student("liusan" , 20 , 90.0);

    s1[1] = new Student("lisi" , 22 , 90.0);

    s1[2] = new Student("wangwu" , 20 , 99.0);

    s1[3] = new Student("sunliu" , 22 , 100.0);

    Arrays.sort(s1);

    System.out.println(Arrays.toString(s1));

    System.out.println("==================");

    //用Comparator实现按照姓名排序,请正确指定泛型

    Arrays.sort(s1, new Comparator() {

    @Override

    public int compare(Student o1, Student o2) {

    return o1.getName().compareTo(o2.getName());

    }

    });

    System.out.println(Arrays.toString(s1));

    }

    }

    以上这篇java使用compareTo实现一个类的对象之间比较大小操作就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持脚本之家。

    展开全文
  • 首先定义一个对象,注意这个对象必须实现Comparable接口,并重写这个接口的compareTo方法 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 package cn.demo;...

    首先定义一个对象,注意这个对象必须实现Comparable接口,并重写这个接口的compareTo方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    package cn.demo;
      
    public class Student implements Comparable{
     private int number=0;  //学号
     private String name="";  //学生姓名
     private String gender="";  //性别
     public int getNumber(){
     return number;
     }
     public void setNumber(int number){
     this.number=number;
     }
     public String getName(){
     return name;
     }
     public void setName(String name){
     this.name=name;
     }
     public String getGender(){
     return gender;
     }
     public void setGender(String gender){
     this.gender=gender;
     }
      
     public int compareTo(Object obj){
     Student student=(Student)obj;
     if(this.number==student.number){ 
      return 0;  //如果学号相同,那么两者就是相等的
     }else if(this.number>student.getNumber()){ 
      return 1;  //如果这个学生的学号大于传入学生的学号
     }else{ 
      return -1;  //如果这个学生的学号小于传入学生的学号
     }
     }
    }
    在上面的重写方法中标红的地方,如果是小于号,则是按照降序排列,但是在我贴上去的代码,则是按升序排列

    接下来就是测试类了:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    package cn.demo;
      
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Iterator;
      
    public class Test {
     public static void main(String[] args) {
     Student student1=new Student();
     student1.setNumber(5);
     Student student2=new Student();
     student2.setNumber(2);
     Student student3=new Student();
     student3.setNumber(1);
     Student student4=new Student();
     student4.setNumber(4);
     ArrayList<Student> list=new ArrayList<Student>();
     list.add(student1);
     list.add(student2);
     list.add(student3);
     list.add(student4);
     System.out.println("-------排序前-------");
     Iterator<Student> iterator=list.iterator();
     while(iterator.hasNext()){
      Student stu=iterator.next();
      System.out.println(stu.getNumber());
     }
     //使用Collections的sort方法对list进行排序
     System.out.println("-------排序后-------");
     Collections.sort(list); 
     iterator=list.iterator();
     while(iterator.hasNext()){
      Student stu=iterator.next();
      System.out.println(stu.getNumber());
     } 
      
     }
    }
    如上所示,可以直接使用collections的sort方法进行排序

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    -------排序前-------
    5
    2
    1
    4
    -------排序后-------
    5
    4
    2
    1
    补充知识:【JAVA】用Comparable接口学生的成绩做降序排序!请正确指定泛型;用Comparator实现按照姓名排序,请正确指定泛型!

    创建四个学生信息,分别包含姓名(String) , 年龄(int) ,分数(double)

    (1)用Comparable接口对下列四位同学的成绩做降序排序, 如果成绩一样,那在成绩排序的基础上按照年龄由小到大排序,请正确指定泛型;

    (2)用Comparator实现按照姓名排序,请正确指定泛型。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    //定义学生类,并实现Comparable接口<定义Student类型>
    public class Student implements Comparable<Student>{
     
      private String name;
      private int age;
      private double grade;
     
      public Student() {
      }
     
      public Student(String name, int age, double grade) {
        this.name = name;
        this.age = age;
        this.grade = 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 double getGrade() {
        return grade;
      }
     
      public void setGrade(double grade) {
        this.grade = grade;
      }
     
      @Override
      public String toString() {
        return "Student [姓名 :" + name +
            " 年龄 :" + age +
            " 分数" + grade + "]";
      }
     
     
      /**
       * 用Comparable接口对下列四位同学的成绩做降序排序,
       * 如果成绩一样,那在成绩排序的基础上按照年龄由小到大排序。请正确指定泛型
       * @param o
       * @return
       */
      @Override
      public int compareTo(Student o) {
        if(Double.compare(this.getGrade() , o.getGrade()) != 0){
          if(Double.compare(this.getGrade() , o.getGrade()) > 0){
            return 1;
          }else {
            return -1;
          }
        }
        return this.getAge() - o.getAge();
      }
    }
    *定义Student类,声明基本的属性,方法及完成对Comparable接口的实现,实现“对成绩实现降序,如果成绩一样,在成绩排序的基础上按照年龄由大到小的排序”的结果。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    public class Task {
     
      public static void main(String[] args) {
     
     //定义四个学生对象
        Student[] s1 = new Student[4];
        s1[0] = new Student("liusan" , 20 , 90.0);
        s1[1] = new Student("lisi" , 22 , 90.0);
        s1[2] = new Student("wangwu" , 20 , 99.0);
        s1[3] = new Student("sunliu" , 22 , 100.0);
     
        Arrays.sort(s1);
        System.out.println(Arrays.toString(s1));
     
        System.out.println("==================");
     
        //用Comparator实现按照姓名排序,请正确指定泛型
        Arrays.sort(s1, new Comparator<Student>() {
          @Override
          public int compare(Student o1, Student o2) {
            return o1.getName().compareTo(o2.getName());
          }
        });
     
        System.out.println(Arrays.toString(s1));
      }
    }
    以上这篇java使用compareTo实现一个类的对象之间比较大小操作就是小编分享给大家的全部内容了

    展开全文
  • 首先定义一个对象,注意这个对象必须实现Comparable接口,并重写这个接口的compareTo方法 package cn.demo; public class Student implements Comparable{ private int number=0; //学号 private String ...
  • 首先我们都知道java中的比较都是同一类对象与对象之间比较,就好像现实生活中比较人和人的年龄一样,你不会去把人的年龄和人的身高来比较,这显然是没有意义的。java中同类对象之间比较又分为两种,基本类型之间...
  • Java对象比较

    2018-04-27 17:32:18
    Java中实现对象比较:Comparable接口和Comparator接口在实际应用中,...所以Java中要比较对象大小或者要对对象的集合进行排序,需要通过比较这些对象的某些属性的大小来确定它们之间大小关系。一般,Java中通...
  • 所以Java中要比较对象大小或者要对对象的集合进行排序,需要通过比较这些对象的某些属性的大小来确定它们之间大小关系。一般,Java中通过接口实现两个对象比较比较常用就是Comparable接口和Compara
  • java-判断相同和对象比较大小

    千次阅读 2014-06-01 19:22:15
    第一种:使用==直接判断相同,它适用于两个变量之间、一个变量和一个对象之间比较。 如: int a=3,c=3; Integer b=new Integer(3); System.out.println(a==c); System.out.println(a==b);输出结果为: true ...
  • 一 Integer 类型对象之间大小比较 1. 使用 new Integer() 创建的对象 : 在实际开发中,基本类型的包装类更为常用,那么包装类型是怎样进行比较运算的呢? 1)对于==运算: Integer i = new Integer(100); Integer j...
  • 首先,我们知道,在java中,基本类型之间是可以做大小比较的,例如int i=1,int j=2,是可以直接使用关系运算符“&amp;lt;”、“&amp;gt;”、“==”等符号来做比较的。但在实际开发中,基本类型的包装类更为...
  • java中经常会涉及到对对象数组的排序问题,那么就涉及到对象之间比较问题,但是在java的对象中正常情况下只能使用 ==, != 不可使用 >, < 来比较两个对象的大小, 但是在开发中要比较对象的大小时,比较器就...
  • 所以Java中要比较对象大小或者要对对象的集合进行排序,需要通过比较这些对象的某些属性的大小来确定它们之间大小关系。一般,Java中通过接口实现两个对象比较比较常用就是Comparable接口和Compar...
  • 进行自定义对象比较时,因为包含很多属性,一般根据这些属性对自定义对自定义对象进行比较,所以java中要比较对象大小或者要对对象的集合进行排序,需要比较这些对象的属性的大小来确定它们之间大小关系。java...
  • 如何比较两个对象大小呢,我们可以有两种方法 方法一:重写Comparable接口中的Compareto方法 compareto 返回值 如果指定的数与参数相等返回0。 如果指定的数小于参数返回 -1。 如果指定的数大于参数返回 1。 ...
  • 8种基本类型以及其所对应的包装类型都可以直接比较大小,标准库自带的,知道如何比较 注意:用户自定义的类型不能比大小, 原因:标准库怎么知道类对象中有哪些成员,如何去比较 标准库: 可以制定一系列规则,只...
  • 为什么呢?原因就出现在常量池了。如果Integer的值在[-128,127]时,都会从常量池中取。这样所有这个区间的Integer的对象是完全相同的,...对象之间比较是否相等,一定要使用Equals来一块看看java.lang.Integer.Inte...
  • 所以Java中要比较对象大小或者要对对象的集合进行排序,需要通过比较这些对象的某些属性的大小来确定它们之间大小关系。 一般,Java中通过接口实现两个对象比较比较常用就是Comparable接口和Compa...
  • 在实际应用中,我们往往有需要比较两个自定义对象大小的地方。而这些自定义对象比较,就不像简单...所以Java中要比较对象大小或者要对对象的集合进行排序,需要通过比较这些对象的某些属性的大小来确定它们之间...
  • Java中经常会涉及到对象数组的排序问题,那么就涉及到对象之间比较问题。通常对象之间比较可以从两个方面去看:第一个方面:对象的地址是否一样,是否引用自同一个对象。这种方式可以直接使用“==“来完成。第二...
  • Java中,我们常常涉及到对象的比较问题,总体来说就两种:一种是比较是否相等,另一种就是比较两个对象之间大小关系。接下来一一介绍: 一、相等比较 通常我们在比较两个对象是否相等时,用到的就是“==”...
  • 一起跟随小编过来看看吧在Java中经常会涉及到对象数组的排序问题,那么就涉及到对象之间比较问题。通常对象之间比较可以从两个方面去看:第一个方面:对象的地址是否一样,也就是是否引用自同一个对象。这种方式...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 286
精华内容 114
关键字:

java对象之间比较大小

java 订阅