java类的比较

① java String类型比较

string类型比较有很多种，我们主要来讲一下用的比较多的两种（equals和==）
例如：
String s1,s2,s3 = "abc", s4 ="abc" ;
s1 = new String("abc");
s2 = new String("abc");
那么：
s1==s2 是 false //两个变量的内存地址不一样，也就是说它们指向的对象不 一样，故不相等。
s1.equals(s2) 是 true //两个变量的所包含的内容是abc，故相等。
总结："=="比较的是两个变量的内存地址，equals比较的是内容；
左上角有我头像，欢迎来学习交流；

② 在java的程序里date类型怎么比较大小呀

有两个方法：

方法一：

两个Date类型的变量可以通过compareTo方法来比较。此方法的描述是这样的：如果参数 Date 等于此 Date，则返回值 0；如果此 Date 在 Date 参数之前，则返回小于 0 的值；如果此 Date 在 Date 参数之后，则返回大于 0 的值。

(2)java类的比较扩展阅读：

Date类可以在java.util包中找到，用一个long类型的值表示一个指定的时刻。它的一个有用的构造函数是Date(),它创建一个表示创建时刻的对象。

getTime()方法返回Date对象的long值。在下面的程序中，我使用Date()构造函数创建一个表示程序运行时刻的对象，并且利用getTime()方法找到这个日期代表的毫秒数量：

import java.util.*;

public class Now {

public static void main(String[] args) {

Date now = new Date();

long nowLong = now.getTime();

System.out.println("Value is " + nowLong);

}

}

③ 在Java中用于比较的类和方法有哪些

对于Class A;Class B两个类，比较它们有两种比较
A == B 比较内存地址
A.equals(B)默认比较hashcode
第一种一般不达不到我们要的效果，所以一般选择覆盖类的equals方法来实现比较类
一般比较两个类，会比较是不是一种类，类里的私有变量是否相等，具体看你的逻辑要求是什么样的！

④ 如何在java里面对Object的类型值进行一个大小的比较

作者：Tao Li
链接：https://www.hu.com/question/36897771/answer/69763955
来源：知乎
着作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

java中类的比较一般有两种方法，一种就是类本身实现Comparable<T>这个接口，比如通过对用户的姓名进行比较排序：

package com.ailot.compare;

public class User implements Comparable<User> {

private String name;
private int age;
private String sex;

public User(String name,int age,String sex){
this.name = name;
this.age = age;
this.sex = sex;
}
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 String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}

@Override
public String toString() {
return "User [name=" + name + ", age=" + age + ", sex=" + sex + "]";
}

@Override
public int compareTo(User u) {
// TODO Auto-generated method stub
int c = this.name.compareTo(u.name);
if(c==0){
return 0;
}else if(c > 0){
return 1;
}else{
return -1;
}
}
}

Test.java

package com.ailot.compare;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

public class Test {

public static void main(String[] args) {
List<User> userList = new ArrayList<User>();
for(int i=0;i<10;i++){
int s = new Random().nextInt(20);
User u = new User(s+"张三",i,"男");
userList.add(u);
}
Collections.sort(userList);
for(User user : userList){
System.out.println(user.toString());
}
}

}

排序的话直接用 Collections.sort( userList ) ;就可以了。
作者：Tao Li
链接：https://www.hu.com/question/36897771/answer/69763955
来源：知乎
着作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

另一种就是类没有实现Comparable<T>这个接口，这就需要自己新建一个比较的类，通过实现Comparator<T>来对类进行比较，还是对User类的姓名进行比较排序：

User.java

package com.ailot.compare;

public class User {

private String name;
private int age;
private String sex;

public User(String name,int age,String sex){
this.name = name;
this.age = age;
this.sex = sex;
}

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 String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}

@Override
public String toString() {
return "User [name=" + name + ", age=" + age + ", sex=" + sex + "]";
}
}

UserCompare.java

package com.ailot.compare;

import java.util.Comparator;

public class UserCompare implements Comparator<User> {

@Override
public int compare(User u1, User u2) {
// TODO Auto-generated method stub
int c = u1.getName().compareTo(u2.getName());
if(c == 0){
return 0;
}else if(c < 0){
return -1;
}else{
return 1;
}
}

}

Test.java

package com.ailot.compare;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

public class Test {

public static void main(String[] args) {
List<User> userList = new ArrayList<User>();
for(int i=0;i<10;i++){
int s = new Random().nextInt(20);
User u = new User(s+"张三",i,"男");
userList.add(u);
}
Collections.sort(userList,new UserCompare());
for(User user : userList){
System.out.println(user.toString());
}
}

}

排序的话直接用 Collections.sort(userList,new UserCompare());就可以了。

⑤ Java类的可比较属性的多个排序

我知道你想从程序设计的角度去考虑问题，但是一般都有个个人认知的局限，程序设计鼓励思考，但是也同样有些规则，比如类和方法的单一功能性。复杂问题可以多步解决，不是一部就是最好的，你可以一步调用一个排序方法，对外只能看到这个方法，但是你内部解决各个排序的时候是调用不同的实现排序接口的类，这样以后维护起来阅读和修改都非常清楚。
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class goTest1 {
public static List<Person> sortBy(List<Person> list,String key){
if(key == "Height"){
list.sort(new sortByHeight());
}
//自己写其他的
return list;

}

public static void main(String[] agrs){
Person A = new Person("Alex","001", 180.2, 160, 6000);
Person B = new Person("Tom","002", 160.2, 180, 2000);
Person C = new Person("Jerry","003",171.2, 170, 3000);
Person D = new Person("Bob","004", 150.2, 120, 6200);
List<Person> list = new ArrayList<Person>();
list.add(A);
list.add(B);
list.add(C);
list.add(D);
for(Person p:list){
System.out.println(p.name);
}
System.out.println();
// list.sort(new sortByHeight());
goTest1.sortBy(list, "Height");
for(Person p:list){
System.out.println(p.name);
}

}

}
class sortByHeight implements Comparator<Person>{

@Override
public int compare(Person arg0, Person arg1) {
return Double.compare(arg0.height, arg1.height);
}
}
class Person{
String name;
String id;
double height;
double weight;
double income;
public Person(String name, String id, double height, double weight,
double income) {
super();
this.name = name;
this.id = id;
this.height = height;
this.weight = weight;
this.income = income;
}

}

⑥ java 怎么比较 类中数据 是否相等

你没有重写class a的equals方法，此时equals是直接使用基础父类Object的equals方法，而你看源代码或者看API手册都可以知道Object.equals()的实现就是使用"=="，即直接比较指针的地址
所以你的写法不行

你需要在class a中重写equals方法来定制比较相等的策略

⑦ Java中如何比较两种数据类型为同一种类型

public boolean equals(Object anObject) { if (this == anObject) { return true; } if (anObject instanceof String) { String anotherString = (String) anObject; int n = value.length; if (n == anotherString.value.length) { char v1[] = value; char v2[] = anotherString.value; int i = 0; while (n-- != 0) { if (v1[i] != v2[i]) return false; i++; } return true; } } return false; }

这是String中equals的实现，b1是Boolean类型的，不是instanceof String，所以返回了false，然后就没有输出了。

⑧ java比较实体类

这种情况你可以使用反射去写一个通用的方法，不过前提是你的那些实体类都是简单的包装类，稍后奉上代码。代码如下：

packagepojo;

/**
*Createdbyliaokaion2017/11/170017.
*/
publicclassPerson{
privateStringname;
privateintage;

publicPerson(Stringname,intage){
this.name=name;
this.age=age;
}

publicStringgetName(){
returnname;
}

publicvoidsetName(Stringname){
this.name=name;
}

publicintgetAge(){
returnage;
}

publicvoidsetAge(intage){
this.age=age;
}

@Override
publicbooleanequals(Objecto){
if(this==o)returntrue;
if(o==null||getClass()!=o.getClass())returnfalse;

Personperson=(Person)o;

if(age!=person.age)returnfalse;
returnname!=null?name.equals(person.name):person.name==null;

}

@Override
publicinthashCode(){
intresult=name!=null?name.hashCode():0;
result=31*result+age;
returnresult;
}

@Override
publicStringtoString(){
return"Person{"+
"name='"+name+'''+
",age="+age+
'}';
}
}

packageutil;

importpojo.Person;

importjava.lang.reflect.Field;
importjava.util.ArrayList;
importjava.util.HashMap;
importjava.util.List;
importjava.util.Map;

/**
*Createdbyliaokaion2017/11/170017.
*/
publicclassCompareUtil<T>{

publicList<Map>compareT(Tt1,Tt2,StringclassName){
List<Map>list=newArrayList<Map>();
//内容没改变直接返回
if(t1.equals(t2)){
returnlist;
}
try{
Classc=Class.forName(className);
//读取t1和t2中的所有属性
Field[]fields=c.getDeclaredFields();

for(inti=0;i<fields.length;i++){
Fieldfield=fields[i];
field.setAccessible(true);
Objectvalue1=field.get(t1);
Objectvalue2=field.get(t2);
//判断这两个值是否相等
if(!isValueEquals(value1,value2)){
Mapmap=newHashMap();
map.put("name",field.getName());
map.put("before",value1);
map.put("after",value2);
list.add(map);
}

}

}catch(ClassNotFoundExceptione){
e.printStackTrace();
}catch(IllegalAccessExceptione){
e.printStackTrace();
}
returnlist;
}

privatebooleanisValueEquals(Objectvalue1,Objectvalue2){
if(value1==null&&value2==null){
returntrue;
}
if(value1==null&&value2!=null){
returnfalse;
}
if(value1.equals(value2)){
returntrue;
}
returnfalse;

}

}

packagepojo;

importutil.CompareUtil;

/**
*Createdbyliaokaion2017/11/170017.
*/
publicclassTest{

publicstaticvoidmain(String[]args){
Personp1=newPerson("张三",14);
Personp2=newPerson("张三",15);
Personp3=newPerson("李四",15);
CompareUtil<Person>compareUtil=newCompareUtil<Person>();
System.out.println(compareUtil.compareT(p1,p1,Person.class.getName()));
System.out.println(compareUtil.compareT(p1,p2,Person.class.getName()));
System.out.println(compareUtil.compareT(p1,p3,Person.class.getName()));
System.out.println(compareUtil.compareT(p2,p3,Person.class.getName()));
}
}

//运行结果
[]
[{before=14,name=age,after=15}]
[{before=张三,name=name,after=李四},{before=14,name=age,after=15}]
[{before=张三,name=name,after=李四}]

⑨ java 判断两个类是否相同

应该没有判断两个类是否相同的方法。
1、如果说两个对象的判断可以使用
equals，或者
==。
2、如果判断对象是否某个类
可以使用
instanceof
，isInstance
3、如果两个类的比较
可以使用
isAssignableFrom，但只能得到是否是自身或者子类的结果，不能完全确定是否相同。

⑩ Java的基本类型和普通类的区别

1. Java基本类型包括八种：int、byte 、short、long、double、boolean、char、float。

2. 基本类型之间可以通过 "=="来比较，普通类的对象无法直接通过==来比较。

其实这之间就有一个“对象引用”的概念。基本类型是“值”的概念，普通类是“对象引用”的概念。