java类比较

Ⅰ 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 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中用于比较的类和方法有哪些

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

Ⅳ 在Java中，如何比较两种数据类型是否属于同一种数据类型

对于两个
引用类型
对象obj1和obj2，判断它们的运行时类是否相同：
obj1.getClass() == obj2.getClass()对于一个基本类型对象
pt1
以及一个引用类型对象obj2，它们的类型必然不同，无需判断。
对于两个基本类型对象pt1以及
pt2
，它们的定义必然已经出现在方法定义中或是类定义的代码中，同样无需判断。

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

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

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

Ⅵ java 内部类和外部类的区别

1. Java项目一般从src目录开始有com...A.java这样的目录结构。这就是包结构。所以一般编译后的结构是跟包结构一模一样的，这样的结构保证了import时能找到正确的class引用包访问权限就是指同包下的类可见。
import 一般加上全路径，并且使用.*时只包含当前目录的所有类文件，不包括子目录。
2. 外部类只有public和default两种修饰，要么全局可访问，要么包内可访问。
3. 内部类可以有全部访问权限，因为它的概念就是一个成员变量，所以访问权限设置与一般的成员变量相同。
非静态内部类是外部类的一个成员变量，只跟外部类的实例有关。
静态内部类是独立于外部类存在的一个类，与外部类实例无关，可以通过外部类.内部类直接获取Class类型。
想要了解更多可以跟我一起讨论哦

Ⅶ 如何在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五个最常用的集合类之间的区别和联系

常用的集合类有一下几种：
List结构的集合类：ArrayList类，LinkedList类，Vector类，Stack类
Map结构的集合类：HashMap类，Hashtable类
Set结构的集合类：HashSet类，TreeSet类
Queue结构的集合：Queue接口

HashMap和Hashtable的区别：
HashMap和Hashtable都是java的集合类，都可以用来存放java对象，这是他们的相同点
以下是他们的区别：
1.历史原因：
Hashtable是基于陈旧的Dictionary类的，HashMap是java 1.2引进的Map接口的一个现实。
2.同步性：
Hashtable是同步的，这个类中的一些方法保证了Hashtable中的对象是线程安全的，而HashMap则是异步的，因此HashMap中的对象并不是线程安全的，因为同步的要求会影响执行的效率，所以如果你不需要线程安全的结合那么使用HashMap是一个很好的选择，这样可以避免由于同步带来的不必要的性能开销，从而提高效率，我们一般所编写的程序都是异步的，但如果是服务器端的代码除外。
3.值：
HashMap可以让你将空值作为一个表的条目的key或value
Hashtable是不能放入空值（null）的

ArrayList和Vector的区别：
ArrayList与Vector都是java的集合类，都是用来存放java对象，这是他们的相同点，
区别：
1.同步性：
Vector是同步的，这个类的一些方法保证了Vector中的对象的线程安全的，而ArrayList则是异步的，因此ArrayList中的对象并不 是线程安全的，因为同步要求会影响执行的效率，所以你不需要线程安全的集合那么使用ArrayList是一个很好的选择，这样可以避免由于同步带来的不必 要的性能开销。
2.数据增长：
从内部实现的机制来讲，ArrayList和Vector都是使用数组（Array）来控制集合中的对象，当你向两种类型中增加元素的时候，如果元素的数目超过了内部数组目前的长度他们都需要扩展内部数组的长度，Vector缺省情况下自动增长原来一倍的数组长度，ArrayList是原来的50%，所以最后你获得的这个集合所占的空间总是比你实际需要的要大，所以如果你要在集合中保存大量的数据，那么使用Vector有一些优势，因为你可以通过设置集合的初始大小来避免不必要的资源开销。

总结：
1）如果要求线程安全，使用Vector，Hashtable
2）如果不要求线程安全，使用ArrayList，LinkedList，HashMap
3)如果要求键值对，则使用HashMap，Hashtable
4）如果数据量很大，又要求线程安全考虑Vector

1．ArrayList: 元素单个，效率高，多用于查询
2．Vector: 元素单个，线程安全，多用于查询
3．LinkedList:元素单个，多用于插入和删除
4．HashMap: 元素成对，元素可为空
5．HashTable: 元素成对，线程安全，元素不可为空

ArrayList
底层是Object数组，所以ArrayList具有数组的查询速度快的优点以及增删速度慢的缺点。
而在LinkedList的底层是一种双向循环链表。在此链表上每一个数据节点都由三部分组成：前指针（指向前面的节点的位置），数据，后指针（指向后面的节点的位置）。最后一个节点的后指针指向第一个节点的前指针，形成一个循环。
双向循环链表的查询效率低但是增删效率高。
ArrayList和LinkedList在用法上没有区别，但是在功能上还是有区别的。

LinkedList
经常用在增删操作较多而查询操作很少的情况下：队列和堆栈。
队列：先进先出的数据结构。
栈：后进先出的数据结构。
注意：使用栈的时候一定不能提供方法让不是最后一个元素的元素获得出栈的机会。

Vector
（与ArrayList相似，区别是Vector是重量级的组件，使用使消耗的资源比较多。）
结论：在考虑并发的情况下用Vector（保证线程的安全）。
在不考虑并发的情况下用ArrayList（不能保证线程的安全）。

面试经验（知识点）：
java.util.stack（stack即为堆栈）的父类为Vector。可是stack的父类是最不应该为Vector的。因为Vector的底层是数组，且Vector有get方法（意味着它可能访问到并不属于最后一个位置元素的其他元素，很不安全）。
对于堆栈和队列只能用push类和get类。
Stack类以后不要轻易使用。
实现栈一定要用LinkedList。
（在JAVA1.5中，collection有queue来实现队列。）

Set-HashSet实现类：
遍历一个Set的方法只有一个：迭代器（interator）。
HashSet中元素是无序的（这个无序指的是数据的添加顺序和后来的排列顺序不同），而且元素不可重复。
在Object中除了有finalize()，toString()，equals()，还有hashCode()。
HashSet底层用的也是数组。
当向数组中利用add(Object o)添加对象的时候，系统先找对象的hashCode：
int hc=o.hashCode(); 返回的hashCode为整数值。
Int I=hc%n;（n为数组的长度），取得余数后，利用余数向数组中相应的位置添加数据，以n为6为例，如果I=0则放在数组a[0]位置，如果I=1,则 放在数组a[1]位置。如果equals()返回的值为true，则说明数据重复。如果equals()返回的值为false，则再找其他的位置进行比 较。这样的机制就导致两个相同的对象有可能重复地添加到数组中，因为他们的hashCode不同。
如果我们能够使两个相同的对象具有相同hashcode，才能在equals()返回为真。
在实例中，定义student对象时覆盖它的hashcode。
因为String类是自动覆盖的，所以当比较String类的对象的时候，就不会出现有两个相同的string对象的情况。
现在，在大部分的JDK中，都已经要求覆盖了hashCode。
结论：如将自定义类用hashSet来添加对象，一定要覆盖hashcode()和equals()，覆盖的原则是保证当两个对象hashcode返回相同的整数，而且equals()返回值为True。
如果偷懒，没有设定equals()，就会造成返回hashCode虽然结果相同，但在程序执行的过程中会多次地调用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的程序里date类型怎么比较大小呀

有两个方法：

方法一：

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

(10)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);

}

}