java回调机制：
Java中没有像C++这样的函数指针，所以不能将一个函数通过参数传递给另一个函数。因此Java中没有回调函数，但仍然可以有回调的机制。Java是一种纯面向对象的语言，它的回调可以通过面向对象的特性实现。
依然采用Person的例子，用Java实现回调。如下：
ICompare接口：
public interface ICompare {
public int comparable(ICompare obj);
}
Person类：
public class Person implements ICompare {
private int age;
private float height;
private float weight;
public Person(int age, float height, float weight) {
super();
this.age = age;
this.height = height;
this.weight = weight;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public float getHeight() {
return height;
}
public void setHeight(float height) {
this.height = height;
}
public float getWeight() {
return weight;
}
public void setWeight(float weight) {
this.weight = weight;
}
@Override
public int comparable(ICompare obj) {
Person p = (Person)obj;
return this.age - p.age;
}
}
测试：
public class CallBackTest {
public static void Sort(ICompare[] objs) {
int n = objs.length;
for(int i = 0; i < n-1; i ++) {
for(int j = 0; j < n-i-1; j ++) {
if(objs[j].comparable(objs[j + 1]) > 0)
{
ICompare temp = objs[j];
objs[j] = objs[j + 1];
objs[j + 1] = temp;
}
}
}
}
public static void showArray(Person persons[]){
for(int i = 0; i < persons.length; i ++) {
System.out.println("age:" + persons[i].getAge() + " weight:" + persons[i].getWeight() + " height:" + persons[i].getWeight());
}
}
/**
* @param args
*/
public static void main(String[] args) {
Person[] persons = new Person[]{
new Person(2, 54.5f, 0.82f),
new Person(31, 74.5f, 1.80f),
new Person(54, 44.5f, 1.59f),
new Person(23, 62.0f, 1.78f),
new Person(16, 45.7f, 1.60f)
};
System.out.println("before sort:");
showArray(persons);
Sort(persons);
System.out.println("after sort:");
showArray(persons);
}
}
java.util.Arrays中的Sort就用到了这种技术，从Java的API中可以看出：
public static void sort(Object[] a)
根据元素的自然顺序，对指定对象数组按升序进行排序。数组中的所有元素都必须实现 Comparable 接口。此外，数组中的所有元素都必须是可相互比较的（也就是说，对于数组中的任何 e1 和 e2 元素而言，e1.compareTo(e2) 不得抛出 ClassCastException）。
回调之编程思想
在软件模块调用中，主要有三种机制：同步调用，异步调用和回调。
同步调用是调用方（A）call被调用方（B）的接口，并等待B处理完给出一个回执后A才继续执行，这期间是“阻塞”的。
异步调用是调用方（A）call被调用方（B）的接口后，不等待B执行完，且B在被调用后会直接回执A。
回调是调用方（A）call被调用方（B）时，B也回调（callback）被调用方，双方互调接口，只不过call动作是由A发起的。
同步调用是最简单的，异步调用一般是在回调的基础上实现的。所以了解“回调”的机制是至关重要的。
/**
* 输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。
* 样例输入：
* 8 4 4 5 1 6 2 7 3 8
* 样例输出：
* 1 2 3 4
*/
创建大小为k的堆，当容器满时：
1、在k个数中找到最大数，
2、删除容器最大数，然后调整堆；
3、插入一个新数，调整堆；
适合海量数据，时间复杂度O（nlgk）
public List<Integer> getMinList(Integer[] num,int k){
List<Integer> list = new ArrayList<Integer> ();
for(Integer i:num){
list = addInteger(list,i,0,list.size()==0?0:list.size()-1,k);
}
return list;
}
public List<Integer> addInteger(List<Integer> list ,int a,int startIndex,int endIndex,int length){
if(list.size()==0){
list.add(a);
return list;
}
//如果小于最小的插入前面
if(a<=list.get(startIndex)){
list.add(startIndex,a);
if(list.size()>length){
list.remove(list.size()-1);
}
return list;
}
//如果大于最大的插入后面
if(a >= list.get(endIndex)){
list.add((endIndex+1),a);
if(list.size()>length){
list.remove(list.size()-1);
}
return list;
}
//如果位于两者之间，插入
if(list.get(startIndex)<a &&((endIndex -startIndex)==1) && list.get(endIndex)>a){
list.add((startIndex+1),a);
if(list.size()>length){
list.remove(list.size()-1);
}
return list;
}
//如果以上都不执行，二分查找比较插入
int middle;
if((endIndex - startIndex)%2!=0){
middle = (endIndex - startIndex+1)/2;
}else{
middle = (endIndex - startIndex)/2;
}
if(a>list.get(middle)){
return addInteger(list,a,middle,endIndex,length);
}else{
return addInteger(list,a,startIndex,middle,length);
}
}
/**
* @param args
* Administrator
* 2013-4-13 上午10:26:50
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
FindMinKFromN f = new FindMinKFromN();
Integer[] a = {4,5,1,6,2,7,3,8};
List<Integer> list = f.getMinList(a, 4);
for(Integer b:list){
System.out.println(b);
}
}
}