首页 > 代码库 > java 数组比较，元素的比较，Comparable，Comparator比较的应用实现，排序，查找示例
java 数组比较，元素的比较，Comparable，Comparator比较的应用实现，排序，查找示例
java 数组比较，元素的比较，自定义Comparator的实现，排序，查找示例
package org.rui.array.compar;
import java.util.Arrays;
import java.util.Random;
import org.rui.generics.anonymity.Generator;
/**
* 程序设计的基本目标是“将保持不变的事物与会发生改变的事物相分离”
* 而这是，不变的是通用的排序算法，变化的是各种对象相互比较的方式，
* 因此，不是将进行比较的代码编写成不同的子程序，而是使用 策略设计模式。
* 通过使用策略，可以将 会发生变化的代码 封装在单独的类中（策略对象）
* 你可以将策略对象传递给总是相同的代码，这些代码将使用策略来完成其算法。
* 通过这种方式，你能够用不同的对象来表示不同的比较方式，
* 然后将它们传递给相同的非序代码。
*
* java有两中方式提供比较功能。
* 第一种是实现java.lang.Comparable，
* 如果当前对象小于参数则返回负值。相同=0，大于 =正数
*
* @author lenovo
*
*/
public class CompType implements Comparable<CompType>
{
int i;
int j;
private static int count=1;
@Override
public String toString()
{
String result= "CompType [i=" + i + ", j=" + j + "]";
if(count++%3==0)
result+="\n";
return result;
}
public CompType(int i, int j)
{
this.i = i;
this.j = j;
}
@Override
public int compareTo(CompType o)
{
return (i<o.i?-1:(i==o.i?0:1));
}
/////////////////////////////////
private static Random r=new Random(47);
public static Generator<CompType> generator()
{
return new Generator<CompType>()
{
public CompType next()
{
return new CompType(r.nextInt(100),r.nextInt(100));
}
};
}
///////////////////////////////////////////////////////////////////////
public static void main(String[] args)
{
CompType[] a=Generated.array(new CompType[12],generator());
System.out.println("befoe sorting:"+Arrays.toString(a));
Arrays.sort(a);
System.out.println("after sorting"+Arrays.toString(a));
}
}
/**
* output:
befoe sorting:[CompType [i=58, j=55], CompType [i=93, j=61], CompType [i=61, j=29]
, CompType [i=68, j=0], CompType [i=22, j=7], CompType [i=88, j=28]
, CompType [i=51, j=89], CompType [i=9, j=78], CompType [i=98, j=61]
, CompType [i=20, j=58], CompType [i=16, j=40], CompType [i=11, j=22]
]
after sorting[CompType [i=9, j=78], CompType [i=11, j=22], CompType [i=16, j=40]
, CompType [i=20, j=58], CompType [i=22, j=7], CompType [i=51, j=89]
, CompType [i=58, j=55], CompType [i=61, j=29], CompType [i=68, j=0]
, CompType [i=88, j=28], CompType [i=93, j=61], CompType [i=98, j=61]
]
*/
package org.rui.array.compar;
import java.lang.reflect.Array;
import org.rui.generics.anonymity.Generator;
public class Generated {
public static <T> T[] array(T[]a,Generator<T> gen)
{
return new CollectionData<T> (gen,a.length).toArray(a);
}
@SuppressWarnings("unchecked")
public static <T> T[] array(Class<T> type,Generator<T> gen,int size)
{
T[] a=(T[]) Array.newInstance(type, size);
return new CollectionData<T>(gen,size).toArray(a);
}
}
package org.rui.array.compar;
import java.util.ArrayList;
import org.rui.generics.anonymity.Generator;
public class CollectionData<T> extends ArrayList<T>
{
public CollectionData(Generator<T> gen,int quantity)
{
for(int i=0;i<quantity;i++)
{
add(gen.next());
}
}
//
public static <T> CollectionData<T>
list(Generator<T> gen,int quantity)
{
return new CollectionData<T>(gen,quantity);
}
}
package org.rui.array.compar;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
/**
* 编写自已的compartor
*
* @author lenovo
*
*/
class CompTypeComparator implements Comparator<CompType>
{
//j排序
public int compare(CompType o1, CompType o2) {
return (o1.j<o2.j?-1:(o1.j==o2.j?0:1));
}
}
public class ComparatorTest {
public static void main(String[] args)
{
CompType[] a =Generated.array(
new CompType[12],CompType.generator()
);
System.out.println("before:"+Arrays.toString(a));
Arrays.sort(a,new CompTypeComparator());
System.out.println("after:"+Arrays.toString(a));
}
}
/**
before:[CompType [i=58, j=55], CompType [i=93, j=61], CompType [i=61, j=29]
, CompType [i=68, j=0], CompType [i=22, j=7], CompType [i=88, j=28]
, CompType [i=51, j=89], CompType [i=9, j=78], CompType [i=98, j=61]
, CompType [i=20, j=58], CompType [i=16, j=40], CompType [i=11, j=22]
]
after:[CompType [i=68, j=0], CompType [i=22, j=7], CompType [i=11, j=22]
, CompType [i=88, j=28], CompType [i=61, j=29], CompType [i=16, j=40]
, CompType [i=58, j=55], CompType [i=20, j=58], CompType [i=93, j=61]
, CompType [i=98, j=61], CompType [i=9, j=78], CompType [i=51, j=89]
]
*/package org.rui.array.compar;
import java.util.Arrays;
import java.util.Collections;
/**
* Collections.reverseOrder
* 反转自然排序
* @author lenovo
*
*/
public class Revers
{
public static void main(String[] args)
{
//System.out.println(CompType.generator());
CompType[]a=Generated.array(
new CompType[12],
CompType.generator()//
);
System.out.println("before:"+Arrays.toString(a));
Arrays.sort(a,Collections.reverseOrder());
System.out.println("after:"+Arrays.toString(a));
}
}
/*
before:[CompType [i=58, j=55], CompType [i=93, j=61], CompType [i=61, j=29]
, CompType [i=68, j=0], CompType [i=22, j=7], CompType [i=88, j=28]
, CompType [i=51, j=89], CompType [i=9, j=78], CompType [i=98, j=61]
, CompType [i=20, j=58], CompType [i=16, j=40], CompType [i=11, j=22]
]
after:[CompType [i=98, j=61], CompType [i=93, j=61], CompType [i=88, j=28]
, CompType [i=68, j=0], CompType [i=61, j=29], CompType [i=58, j=55]
, CompType [i=51, j=89], CompType [i=22, j=7], CompType [i=20, j=58]
, CompType [i=16, j=40], CompType [i=11, j=22], CompType [i=9, j=78]
]
* */
package org.rui.array.compar;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
/**
* String 排序 查找
* @author lenovo
*/
public class StringSorting {
public static void main(String[] args)
{
String[] a ={"a","d","b","C",
"A","B","D","c",};
System.out.println("before:"+Arrays.toString(a));
Arrays.sort(a);
System.out.println("after:"+Arrays.toString(a));
Arrays.sort(a,Collections.reverseOrder());
System.out.println("reverseOrder:"+Arrays.toString(a));
Arrays.sort(a,String.CASE_INSENSITIVE_ORDER);
System.out.println("CASE_INSENSITIVE_ORDER:"+Arrays.toString(a));
//查找
int index=Arrays.binarySearch(a, a[3]);
System.out.println("index::"+index+" val:"+a[index]);
}
}
/**
before:[a, d, b, C, A, B, D, c]
after:[A, B, C, D, a, b, c, d]
reverseOrder:[d, c, b, a, D, C, B, A]
CASE_INSENSITIVE_ORDER:[a, A, b, B, c, C, d, D]
index::3 val:B
*///Generator.java
package org.rui.generics.anonymity;
public interface Generator<T> {
//返回泛型的内型对象
T next();
}
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。