使用Arrays.sort()方法,以及涉及到的Comparable和Comparator
2012-08-14 15:30
423 查看
[java] view plaincopyprint?
Arrays.sort用法
package test;
import java.util.Arrays;
import java.util.Comparator;
public class ArraySortDemo {
/**
* 整数型数组排序
*/
public void sortIntArray() {
int[] arrayToSort = new int[] { 48, 5, 89, 80, 81, 23, 45, 16, 2 };
System.out.println("整数型数组排序,排序前:");
for (int i = 0; i < arrayToSort.length; i++){
System.out.print(arrayToSort[i]+",");
}
// 调用数组的静态排序方法sort
Arrays.sort(arrayToSort);
System.out.println();
System.out.println("排序后:");
for (int i = 0; i < arrayToSort.length; i++){
System.out.print(arrayToSort[i]+",");
}
}
/**
* 字符型数组排序demo
*/
public void sortStringArray() {
String[] arrayToSort = new String[] { "Oscar", "Charlie", "Ryan",
"Adam", "David","aff","Aff" };
System.out.println();
System.out.println("字符型数组排序,排序前:");
for (int i = 0; i < arrayToSort.length; i++){
System.out.print(arrayToSort[i]+",");
}
System.out.println();
System.out.println("排序后:");
// 调用数组的静态排序方法sort
Arrays.sort(arrayToSort);
for (int i = 0; i < arrayToSort.length; i++){
System.out.print(arrayToSort[i]+",");
}
}
/**
* 对象数组排序demo
*/
public void sortObjectArray() {
Dog o1 = new Dog("dog1", 1);
Dog o2 = new Dog("dog2", 4);
Dog o3 = new Dog("dog3", 5);
Dog o4 = new Dog("dog4", 2);
Dog o5 = new Dog("dog5", 3);
Dog[] dogs = new Dog[] { o1, o2, o3, o4, o5 };
System.out.println();
System.out.println("对象数组排序排序前:");
for (int i = 0; i < dogs.length; i++) {
Dog dog = dogs[i];
System.out.print(dog.getName()+"["+dog.getWeight()+"],");
}
Arrays.sort(dogs, new ByWeightComparator());
System.out.println();
System.out.println("排序后:");
for (int i = 0; i < dogs.length; i++) {
Dog dog = dogs[i];
System.out.print(dog.getName()+"["+dog.getWeight()+"],");
}
}
public static void main(String[] args) {
ArraySortDemo t = new ArraySortDemo();
t.sortIntArray();
t.sortStringArray();
t.sortObjectArray();
}
}
/**
* 定义了一个Dog类
*/
class Dog {
private String name;
private int weight;
public Dog(String name, int weight) {
this.setName(name);
this.weight = weight;
}
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
/**
* 因为要对对象进行排序,所以要实现java.util.Comparator接口的compare(T o1, T o2)方法,在该方法中自定义排序算法。
*/
class ByWeightComparator implements Comparator {
public final int compare(Object pFirst, Object pSecond) {
int aFirstWeight = ((Dog) pFirst).getWeight();
int aSecondWeight = ((Dog) pSecond).getWeight();
int diff = aFirstWeight - aSecondWeight;
if (diff > 0)
return 1;
if (diff < 0)
return -1;
else
return 0;
}
}
运行结果:
整数型数组排序,排序前:
48,5,89,80,81,23,45,16,2,
排序后:
2,5,16,23,45,48,80,81,89,
字符型数组排序,排序前:
Oscar,Charlie,Ryan,Adam,David,aff,Aff,
排序后:
Adam,Aff,Charlie,David,Oscar,Ryan,aff,
对象数组排序排序前:
dog1[1],dog2[4],dog3[5],dog4[2],dog5[3],
排序后:
dog1[1],dog4[2],dog5[3],dog2[4],dog3[5],
地方
List list = new ArrayList() ;
list.add("abcd") ;
list.add("abdc") ;
list.add("aadf") ;
list.add("aabf") ;
/*将list转为数组*/
String[] strs = new String[list.size()] ;
list.toArray(strs) ;
/*排序,只排2<=索引<4之间的数据*/
Arrays.sort(strs,2,4) ;
for(String str : strs){
System.out.println(str) ;
}
[java] view
plaincopyprint?
Arrays.sort 不区分大小写 排序
当需要排序的集合或数组不是单纯的数字型时,通常可以使用Comparator或Comparable,以简单的方式实现对象排序或自定义排序。
一、Comparator
强行对某个对象collection进行整体排序的比较函数,可以将Comparator传递给Collections.sort或Arrays.sort。
接口方法:
Java代码
/**
* @return o1小于、等于或大于o2,分别返回负整数、零或正整数。
*/
int compare(Object o1, Object o2);
/**
* @return o1小于、等于或大于o2,分别返回负整数、零或正整数。
*/
int compare(Object o1, Object o2);
案例:
Java代码
import java.util.Arrays;
import java.util.Comparator;
public class SampleComparator implements Comparator {
public int compare(Object o1, Object o2) {
return toInt(o1) - toInt(o2);
}
private int toInt(Object o) {
String str = (String) o;
str = str.replaceAll("一", "1");
str = str.replaceAll("二", "2");
str = str.replaceAll("三", "3");
//
return Integer.parseInt(str);
}
/**
* 测试方法
*/
public static void main(String[] args) {
String[] array = new String[] { "一二", "三", "二" };
Arrays.sort(array, new SampleComparator());
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
二、Comparable
强行对实现它的每个类的对象进行整体排序,实现此接口的对象列表(和数组)可以通过Collections.sort或Arrays.sort进行自动排序。
接口方法:
Java代码
/**
* @return 该对象小于、等于或大于指定对象o,分别返回负整数、零或正整数。
*/
int compareTo(Object o);
/**
* @return 该对象小于、等于或大于指定对象o,分别返回负整数、零或正整数。
*/
int compareTo(Object o);
假设对象User,需要按年龄排序:
Java代码
public class User {
private String id;
private int age;
public User(String id, int age) {
this.id = id;
this.age = age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
public class User {
private String id;
private int age;
public User(String id, int age) {
this.id = id;
this.age = age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
改造后的对象:
Java代码
import java.util.Arrays;
public class User implements Comparable {
private String id;
private int age;
public User(String id, int age) {
this.id = id;
this.age = age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public int compareTo(Object o) {
return this.age - ((User) o).getAge();
}
/**
* 测试方法
*/
public static void main(String[] args) {
User[] users = new User[] { new User("a", 30), new User("b", 20) };
Arrays.sort(users);
for (int i = 0; i < users.length; i++) {
User user = users[i];
System.out.println(user.getId() + " " + user.getAge());
}
}
}
三、Comparator和Comparable的区别
先看一下使用Comparator对User集合实现排序的方式:
Java代码
import java.util.Arrays;
import java.util.Comparator;
public class UserComparator implements Comparator {
public int compare(Object o1, Object o2) {
return ((User) o1).getAge() - ((User) o2).getAge();
}
/**
* 测试方法
*/
public static void main(String[] args) {
User[] users = new User[] { new User("a", 30), new User("b", 20) };
Arrays.sort(users, new UserComparator());
for (int i = 0; i < users.length; i++) {
User user = users[i];
System.out.println(user.getId() + " " + user.getAge());
}
}
}
一个类实现了Camparable接口则表明这个类的对象之间是可以相互比较的,这个类对象组成的集合就可以直接使用sort方法排序。
Comparator可以看成一种算法的实现,将算法和数据分离,Comparator也可以在下面两种环境下使用:
1、类的设计师没有考虑到比较问题而没有实现Comparable,可以通过Comparator来实现排序而不必改变对象本身
2、可以使用多种排序标准,比如升序、降序等
Arrays.sort用法
package test;
import java.util.Arrays;
import java.util.Comparator;
public class ArraySortDemo {
/**
* 整数型数组排序
*/
public void sortIntArray() {
int[] arrayToSort = new int[] { 48, 5, 89, 80, 81, 23, 45, 16, 2 };
System.out.println("整数型数组排序,排序前:");
for (int i = 0; i < arrayToSort.length; i++){
System.out.print(arrayToSort[i]+",");
}
// 调用数组的静态排序方法sort
Arrays.sort(arrayToSort);
System.out.println();
System.out.println("排序后:");
for (int i = 0; i < arrayToSort.length; i++){
System.out.print(arrayToSort[i]+",");
}
}
/**
* 字符型数组排序demo
*/
public void sortStringArray() {
String[] arrayToSort = new String[] { "Oscar", "Charlie", "Ryan",
"Adam", "David","aff","Aff" };
System.out.println();
System.out.println("字符型数组排序,排序前:");
for (int i = 0; i < arrayToSort.length; i++){
System.out.print(arrayToSort[i]+",");
}
System.out.println();
System.out.println("排序后:");
// 调用数组的静态排序方法sort
Arrays.sort(arrayToSort);
for (int i = 0; i < arrayToSort.length; i++){
System.out.print(arrayToSort[i]+",");
}
}
/**
* 对象数组排序demo
*/
public void sortObjectArray() {
Dog o1 = new Dog("dog1", 1);
Dog o2 = new Dog("dog2", 4);
Dog o3 = new Dog("dog3", 5);
Dog o4 = new Dog("dog4", 2);
Dog o5 = new Dog("dog5", 3);
Dog[] dogs = new Dog[] { o1, o2, o3, o4, o5 };
System.out.println();
System.out.println("对象数组排序排序前:");
for (int i = 0; i < dogs.length; i++) {
Dog dog = dogs[i];
System.out.print(dog.getName()+"["+dog.getWeight()+"],");
}
Arrays.sort(dogs, new ByWeightComparator());
System.out.println();
System.out.println("排序后:");
for (int i = 0; i < dogs.length; i++) {
Dog dog = dogs[i];
System.out.print(dog.getName()+"["+dog.getWeight()+"],");
}
}
public static void main(String[] args) {
ArraySortDemo t = new ArraySortDemo();
t.sortIntArray();
t.sortStringArray();
t.sortObjectArray();
}
}
/**
* 定义了一个Dog类
*/
class Dog {
private String name;
private int weight;
public Dog(String name, int weight) {
this.setName(name);
this.weight = weight;
}
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
/**
* 因为要对对象进行排序,所以要实现java.util.Comparator接口的compare(T o1, T o2)方法,在该方法中自定义排序算法。
*/
class ByWeightComparator implements Comparator {
public final int compare(Object pFirst, Object pSecond) {
int aFirstWeight = ((Dog) pFirst).getWeight();
int aSecondWeight = ((Dog) pSecond).getWeight();
int diff = aFirstWeight - aSecondWeight;
if (diff > 0)
return 1;
if (diff < 0)
return -1;
else
return 0;
}
}
运行结果:
整数型数组排序,排序前:
48,5,89,80,81,23,45,16,2,
排序后:
2,5,16,23,45,48,80,81,89,
字符型数组排序,排序前:
Oscar,Charlie,Ryan,Adam,David,aff,Aff,
排序后:
Adam,Aff,Charlie,David,Oscar,Ryan,aff,
对象数组排序排序前:
dog1[1],dog2[4],dog3[5],dog4[2],dog5[3],
排序后:
dog1[1],dog4[2],dog5[3],dog2[4],dog3[5],
地方
List list = new ArrayList() ;
list.add("abcd") ;
list.add("abdc") ;
list.add("aadf") ;
list.add("aabf") ;
/*将list转为数组*/
String[] strs = new String[list.size()] ;
list.toArray(strs) ;
/*排序,只排2<=索引<4之间的数据*/
Arrays.sort(strs,2,4) ;
for(String str : strs){
System.out.println(str) ;
}
[java] view
plaincopyprint?
Arrays.sort 不区分大小写 排序
当需要排序的集合或数组不是单纯的数字型时,通常可以使用Comparator或Comparable,以简单的方式实现对象排序或自定义排序。
一、Comparator
强行对某个对象collection进行整体排序的比较函数,可以将Comparator传递给Collections.sort或Arrays.sort。
接口方法:
Java代码
/**
* @return o1小于、等于或大于o2,分别返回负整数、零或正整数。
*/
int compare(Object o1, Object o2);
/**
* @return o1小于、等于或大于o2,分别返回负整数、零或正整数。
*/
int compare(Object o1, Object o2);
案例:
Java代码
import java.util.Arrays;
import java.util.Comparator;
public class SampleComparator implements Comparator {
public int compare(Object o1, Object o2) {
return toInt(o1) - toInt(o2);
}
private int toInt(Object o) {
String str = (String) o;
str = str.replaceAll("一", "1");
str = str.replaceAll("二", "2");
str = str.replaceAll("三", "3");
//
return Integer.parseInt(str);
}
/**
* 测试方法
*/
public static void main(String[] args) {
String[] array = new String[] { "一二", "三", "二" };
Arrays.sort(array, new SampleComparator());
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
二、Comparable
强行对实现它的每个类的对象进行整体排序,实现此接口的对象列表(和数组)可以通过Collections.sort或Arrays.sort进行自动排序。
接口方法:
Java代码
/**
* @return 该对象小于、等于或大于指定对象o,分别返回负整数、零或正整数。
*/
int compareTo(Object o);
/**
* @return 该对象小于、等于或大于指定对象o,分别返回负整数、零或正整数。
*/
int compareTo(Object o);
假设对象User,需要按年龄排序:
Java代码
public class User {
private String id;
private int age;
public User(String id, int age) {
this.id = id;
this.age = age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
public class User {
private String id;
private int age;
public User(String id, int age) {
this.id = id;
this.age = age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
改造后的对象:
Java代码
import java.util.Arrays;
public class User implements Comparable {
private String id;
private int age;
public User(String id, int age) {
this.id = id;
this.age = age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public int compareTo(Object o) {
return this.age - ((User) o).getAge();
}
/**
* 测试方法
*/
public static void main(String[] args) {
User[] users = new User[] { new User("a", 30), new User("b", 20) };
Arrays.sort(users);
for (int i = 0; i < users.length; i++) {
User user = users[i];
System.out.println(user.getId() + " " + user.getAge());
}
}
}
三、Comparator和Comparable的区别
先看一下使用Comparator对User集合实现排序的方式:
Java代码
import java.util.Arrays;
import java.util.Comparator;
public class UserComparator implements Comparator {
public int compare(Object o1, Object o2) {
return ((User) o1).getAge() - ((User) o2).getAge();
}
/**
* 测试方法
*/
public static void main(String[] args) {
User[] users = new User[] { new User("a", 30), new User("b", 20) };
Arrays.sort(users, new UserComparator());
for (int i = 0; i < users.length; i++) {
User user = users[i];
System.out.println(user.getId() + " " + user.getAge());
}
}
}
一个类实现了Camparable接口则表明这个类的对象之间是可以相互比较的,这个类对象组成的集合就可以直接使用sort方法排序。
Comparator可以看成一种算法的实现,将算法和数据分离,Comparator也可以在下面两种环境下使用:
1、类的设计师没有考虑到比较问题而没有实现Comparable,可以通过Comparator来实现排序而不必改变对象本身
2、可以使用多种排序标准,比如升序、降序等
相关文章推荐
- J2SE基础夯实系列之使用Arrays.sort()方法,以及涉及到的Comparable和Comparator
- Comparable和Comparator以及Arrays.sort方法
- Arrays.sort排序方法以及Comparator和Comparable接口的作用
- Collections.sort()方法的使用及Comparable和comparator的qubie
- 深入理解 Comparable 接口和 Comparator 接口以及Arrays.sort()
- Java Collections.sort和Arrays.sort使用comparator或者comparable接口的compare函数返回值
- Arrays.sort()使用两种方式(Comparable和Comparator接口)对对象或者引用进行排序
- JAVA中Arrays.sort()使用两种方式(Comparable和Comparator接口)对对象或者引用进行排序
- JAVA中Arrays.sort()使用两种方式(Comparable和Comparator接口)对对象或者引用进行排序
- JAVA中Arrays.sort()使用两种方式(Comparable和Comparator接口)对对象或者引用进行排序
- JAVA中Arrays.sort()使用两种方式(Comparable和Comparator接口)对对象或者引用进行排序
- JAVA中Arrays.sort()使用两种方式(Comparable和Comparator接口)对对象或者引用进行排序
- TreeSet(有序集合)对Comparable元素的排序(或使用Comparator)与元素equals方法的关系
- Comparable的使用(用于Arrays.sort)
- Collections.sort方法排序,以及java8前后版本的使用
- Arrays.sort、Comparable与Comparator两个接口的作用
- 关于comparator接口和comparable接口以及它们各自的方法compare()和compareTo()
- java list集合使用Collections中的sort方法进行排序(Comparator),超实用
- Java数组排序Arrays.sort,以及Comparator接口的用法
- Java数组排序Arrays.sort,以及Comparator接口的用法