程序员必须会手写的Java代码

要是不会默写一下这几段代码真的出去别说自己是程序员，基本上属于面试必考。

A.通过接口回调进行类与类直接参数的传递

1.定义一个接口,里面的代码是抽象方法

public interface ScrollVIewListener{
    //抽象方法:就是把我们这个类想要暴露出去实现的具体逻辑和传递对应参数(view的监听对象要有)
    void onScrollChanger(ObservableScrollView scrollView,int l, int t, int oldl, int oldt );

}

2.定义一个接口的成员变量,假的对象(接口不能创建对象)

private ScrollVIewListener mScrollVIewListener;

3.提供方法,让外界可以设置ScrollView的监听对象,也就是我们要暴露出去的唯一方法

public void setScrollVIewListener(ScrollVIewListener scrollVIewListener){
    mScrollVIewListener = scrollVIewListener ;
}

4.接口的具体使用,可以狸猫换太子的应用逻辑

if (mScrollVIewListener !=null){
    mScrollVIewListener.onScrollChanger(this,l,t,oldl,oldt);
}

5.外部创建实现接口的对象,使用回调实现接口的对象() ycf=new 实现接口的对象();

ycf.setScrollVIewListener(this);

B.单例模式(饿汉式,懒汉式)

1.饿汉式

//饿汉式 
public class Singleton {

	private final static Singleton INSTANCE = new Singleton();
	
	private Singleton(){}
	
	public static Singleton getInstance(){ 
    	return INSTANCE; 
	} 
}

优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。

缺点：在类装载的时候就完成实例化，没有达到懒加载的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。

2.懒汉式

//懒汉式
public class Singleton {

    private static volatile Singleton singleton;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

优点：线程安全；延迟加载；效率较高:进行了两次if (singleton == null)检查，这样就可以保证线程安全了。这样，实例化代码只用执行一次，后面再次访问时，判断if (singleton == null)，直接return实例化对象。

C.冒泡排序

/**

 * 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 

* 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 

* 针对所有的元素重复以上的步骤，除了最后一个。

* 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 

* @param numbers 需要排序的整型数组 */


public static void bubbleSort(int[] numbers){

 	int temp = 0;

 	int size = numbers.length;

 	for(int i = 0 ; i < size-1; i ++){

	 	for(int j = 0 ;j < size-1-i ; j++){

		 	if(numbers[j] > numbers[j+1]) {

				//交换两数位置
				temp = numbers[j];
				numbers[j] = numbers[j+1];
				numbers[j+1] = temp;
			}
		}
 	}
}

D.二分法查找

public static int binary(int[] array, int value){

	int low = 0;

	int high = array.length - 1;

	while(low <= high){

		int middle = (low + high) / 2;

		if(value == array[middle]){
		    return middle;
    	}

		if(value > array[middle]){
		    low = middle + 1;
		}
		
		if(value < array[middle]){
		    high = middle - 1;
		}
	}
	return -1;
}

//具体使用
public static void main(String[] args){

	int[] a = {1, 2, 3, 4, 5, 6, 7, 8, 9};
	
    int value = binary(a, 9);
    
	System.out.println(value);
}

E.快速排序

/**
     * 查找出中轴（默认是最低位low）的在numbers数组排序后所在位置
     * @param numbers 带查找数组
     * @param low   开始位置
     * @param high  结束位置
     * @return  中轴所在位置 */
    public static int getMiddle(int[] numbers, int low,int high){
    
        int temp = numbers[low]; //数组的第一个作为中轴
        
        while(low < high){
        
        	while(low < high && numbers[high] > temp){
	            high--;
       		}
       		
	        numbers[low] = numbers[high];//比中轴小的记录移到低端
        	
        	while(low < high && numbers[low] < temp){
	            low++;
    	    }
        
        	numbers[high] = numbers[low] ; //比中轴大的记录移到高端
        }
        
        numbers[low] = temp ; //中轴记录到尾
        
        return low ; // 返回中轴的位置
    }

参考网址

单例模式：https://www.cnblogs.com/zhaoyan001/p/6365064.html

排序：https://www.cnblogs.com/0201zcr/p/4763806.html