1. java comparator突然迷惑了 你這里兩個參數 是怎麼比較出三個及其以上數據的

Comparator的comparator方法只是告訴程序你想怎麼比較大小，比如你這個Student，是按年齡呢，還是按照身高，還是按照成績呢？？？
至於你說的三個及其以上數據怎麼比較，，這應該就是排序了，這個就看使用什麼排序演算法了，但是排序的前提就是要能比較大小

2. Java中，如果想要排序,實現Comparator介面 //與Comparable 的區別

comparator介面與Comparable介面的區別
1. Comparator 和 Comparable 相同的地方

他們都是java的一個介面, 並且是用來對自定義的class比較大小的,

什麼是自定義class: 如 public class Person{ String name; int age }.

當我們有這么一個personList,裡麵包含了person1, person2, persion3....., 我們用Collections.sort( personList ), 是得不到預期的結果的. 這時肯定有人要問, 那為什麼可以排序一個字元串list呢:

如 StringList{"hello1" , "hello3" , "hello2"}, Collections.sort( stringList ) 能夠得到正確的排序, 那是因為 String 這個對象已經幫我們實現了 Comparable介面 , 所以我們的 Person 如果想排序, 也要實現一個比較器。

2. Comparator 和 Comparable 的區別

Comparable

Comparable 定義在 Person類的內部:

public class Persion implements Comparable {..比較Person的大小..},

因為已經實現了比較器,那麼我們的Person現在是一個可以比較大小的對象了,它的比較功能和String完全一樣,可以隨時隨地的拿來比較大小,因為Person現在自身就是有大小之分的。Collections.sort(personList)可以得到正確的結果。

Comparator

Comparator 是定義在Person的外部的, 此時我們的Person類的結構不需要有任何變化,如

public class Person{ String name; int age },

然後我們另外定義一個比較器:

public PersonComparator implements Comparator() {..比較Person的大小..},

在PersonComparator裡面實現了怎麼比較兩個Person的大小. 所以,用這種方法,當我們要對一個 personList進行排序的時候, 我們除了了要傳遞personList過去, 還需要把PersonComparator傳遞過去,因為怎麼比較Person的大小是在PersonComparator裡面實現的, 如:

Collections.sort( personList , new PersonComparator() ).

3. Comparator 和 Comparable 的實例

Comparable:

實現Comparable介面要覆蓋compareTo方法, 在compareTo方法裡面實現比較：
public class Person implements Comparable {
String name;
int age
public int compareTo(Person another) {
int i = 0;
i = name.compareTo(another.name); // 使用字元串的比較
if(i == 0) { // 如果名字一樣,比較年齡, 返回比較年齡結果
return age - another.age;
} else {
return i; // 名字不一樣, 返回比較名字的結果.
}
}
}
這時我們可以直接用 Collections.sort( personList ) 對其排序了.

Comparator:

實現Comparator需要覆蓋 compare 方法：
public class Person{
String name;
int age
}

class PersonComparator implements Comparator {
public int compare(Person one, Person another) {
int i = 0;
i = one.name.compareTo(another.name); // 使用字元串的比較
if(i == 0) { // 如果名字一樣,比較年齡,返回比較年齡結果
return one.age - another.age;
} else {
return i; // 名字不一樣, 返回比較名字的結果.
}
}
}
Collections.sort( personList , new PersonComparator()) 可以對其排序

4:總結

兩種方法各有優劣, 用Comparable 簡單, 只要實現Comparable 介面的對象直接就成為一個可以比較的對象,但是需要修改源代碼, 用Comparator 的好處是不需要修改源代碼, 而是另外實現一個比較器, 當某個自定義的對象需要作比較的時候,把比較器和對象一起傳遞過去就可以比大小了, 並且在Comparator 裡面用戶可以自己實現復雜的可以通用的邏輯,使其可以匹配一些比較簡單的對象,那樣就可以節省很多重復勞動了。

3. java comparator定義規則

一、實體類Step
package com.ljq.entity;

/**
* 運號單流程
*
* @author Administrator
*
*/
public class Step{
/** 處理時間 */
private String acceptTime = "";
/** 快件所在地點 */
private String acceptAddress = "";

public Step() {
super();
}

public Step(String acceptTime, String acceptAddress) {
super();
this.acceptTime = acceptTime;
this.acceptAddress = acceptAddress;
}

public String getAcceptTime() {
return acceptTime;
}

public void setAcceptTime(String acceptTime) {
this.acceptTime = acceptTime;
}

public String getAcceptAddress() {
return acceptAddress;
}

public void setAcceptAddress(String acceptAddress) {
this.acceptAddress = acceptAddress;
}

}

二、實現Comparator介面

package com.ljq.entity;

import java.util.Comparator;
import java.util.Date;

import com.ljq.util.UtilTool;

/**
* 對Step類進行排序
*
* @author Administrator
*
*/
public class StepComparator implements Comparator<Step>{

/**
* 如果o1小於o2,返回一個負數;如果o1大於o2，返回一個正數;如果他們相等，則返回0;
*/
@Override
public int compare(Step o1, Step o2) {
Date acceptTime1=UtilTool.strToDate(o1.getAcceptTime(), null);
Date acceptTime2=UtilTool.strToDate(o2.getAcceptTime(), null);

//對日期欄位進行升序，如果欲降序可採用before方法
if(acceptTime1.after(acceptTime2)) return 1;
return -1;
}

}

三、測試

package junit;

import java.util.Collection;
import java.util.Collections;
import java.util.List;

import org.junit.Test;

public class StepComparatorTest {

@Test
public void sort() throws Exception{
List<Step> steps=new ArrayList<Step>;
//對集合對象進行排序
StepComparator comparator=new StepComparator();
Collections.sort(steps, comparator);
if(steps!=null&&steps.size()>0){
for(Step step:steps){
System.out.println(step.getAcceptAddress());
System.out.println(step.getAcceptTime());
}
}

}
}

4. Java Arraylist 如何使用 Comparator排序

用Comparator是策略模式（strategy design pattern），就是不改變對象自身，而用一個策略對象（strategy object）來改變它的行為。
比如：你想對整數採用絕對大小來排序，Integer是不符合要求的，你不需要去修改Integer類（實際上你也不能這么做）去改變它的排序行為，只要使用一個實現了Comparator介面的對象來實現控制它的排序就行了。

示例代碼如下：

//AbsComparator.java
import java.util.*;
public class AbsComparator implements Comparator {
public int compare(Object o1, Object o2) {
int v1 = Math.abs(((Integer)o1).intValue());
int v2 = Math.abs(((Integer)o2).intValue());
return v1 > v2 ? 1 : (v1 == v2 ? 0 : -1);
}
}

//Test.java
import java.util.*;
public class Test {
public static void main(String[] args) {

//產生一個20個隨機整數的數組（有正有負）
Random rnd = new Random();
Integer[] integers = new Integer[20];
for(int i = 0; i < integers.length; i++)
integers[i] = new Integer(rnd.nextInt(100) * (rnd.nextBoolean() ? 1 : -1));

System.out.println("用Integer內置方法排序：");
Arrays.sort(integers);
System.out.println(Arrays.asList(integers));

System.out.println("用AbsComparator排序：");
Arrays.sort(integers, new AbsComparator());
System.out.println(Arrays.asList(integers));
}
}

5. java中的Comparator

看你數組里存的是什麼類型的數據咯，如果是基礎類型或者java中已經有的對象類型，就可以直接比較大小，一般java中的對象類型都已經實現了比較大小的方法。如果是保存自定義的類型，則需要自定義的類型實現Comprable或者Comparator這兩個介面。這兩者的差別可以參考下面的網頁。

6. java 關於實現comparator介面

首先一點你寫的所有java類都是默認繼承Object這個類的, 而Object這個類裡面實現一個默認的equals方法,所以你的PointComparator 類是有equal方法的

你要是不信呢,可以隨便寫個類,都可以調用equals方法, 雖然默認比較的是2個對象的引用地址