首页 > 代码库 > 2014.12.3笔记

2014.12.3笔记

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

2014.12.3笔记