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

}

}