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


java 数组比较,元素的比较,Comparable,Comparator比较的应用实现,排序,查找示例,布布扣,bubuko.com

java 数组比较,元素的比较,Comparable,Comparator比较的应用实现,排序,查找示例

上一篇:delphi xe6 for android 自带控件LocationSensor优先使用GPS定位的方法


下一篇:一入python深似海--while-loop与for-loop