Java面试题整理

1.对于一个有序数组，我们通常采用二分查找的方式来定位某一元素，请编写二分查找的算法，在数组中查找指定元素。

public class Solution{
  //if not found, return -1;
   public int binary_search(int[] array, int n){
      if (array == null || array.length < 1)
          return -1; //不需要寻找.
      int top = 0, button = array.length - 1;
      while (top <= button){
          int mid = top + (button - top) / 2;
          if (n < array[mid]){ //n在数组左边.
              button = mid - 1;
           }else if (n > array[mid]){ //n在数组右边.
              top = mid + 1;
           }else {
               return mid; //find.
           }
      }
  }
}

2.对于一个字符串，，请设计一个高效算法，找到第一次重复出现的字符。

解法一:

import java.util.ArrayList;
import java.util.List;
public class FirstRepeat {
    
    public static void main(String[] args) {
        System.out.println(findFirstRepeat("pmedmitjtckhxwhvpwemznhmhzhpueainchqrftkmbjlradhmjekcqzansyzkvqhwnrdgzdbzewdmxkzrscikdaugbvygntrifnolehdtrqjlasofuvzeijbmzehkxknmjekcxswqldknysfsxrqaqzp",152));
    }
    //返回:y
    public static char findFirstRepeat(String A, int n) {
        String[] str=A.split("");
        for(int x=0;x<n;x++){
            int index=0;
            int num=0;
            //对于每一个值，都需要从前开始遍历
            while(index<=x){
                if(str[index].equals(str[x])){
                    num++;
                }
                index++;
            }
            //该值出现了两次，说明重复了
            if(num>1){
                char flag='x';
                flag=str[x].toCharArray()[0];
                return flag;
            }
            
            
        }
        //返回该值说明已经没有重复的
        return 'p';
    }
}

解法二(Python实现):

#!/usr/bin/env python3
def find_str_repeat(s):
        d = {}
        for i in range(len(s)):
                if d.get(s[i]):
                        return s[i]
                else:
                        d[s[i]]= i
        return False

def find_str_repeat1(s):
        d = {}
        for i in s:
                if d.get(i):
                        return i
                else:
                        d[i] = i
        return False

if __name__ == "__main__":
        s = "qywyer23tdd"
        print(find_str_repeat(s))
        print(find_str_repeat1(s))

3.写一个Singleton出来
单例模式大致有五种写法，分别为懒汉，恶汉，静态内部类，枚举和双重校验锁。

3.1、懒汉写法，常用写法

class LazySingleton{
    private static LazySingleton singleton;
    private LazySingleton(){
    }
    public static LazySingleton getInstance(){
        if(singleton==null){
            singleton=new LazySingleton();
        }
        return singleton;
    }   
}

3.2、恶汉写法，缺点是没有达到lazy loading的效果

class HungrySingleton{
    private static HungrySingleton singleton=new HungrySingleton();
    private HungrySingleton(){}
    public static HungrySingleton getInstance(){
        return singleton;
    }
}

3.3、静态内部类，优点：加载时不会初始化静态变量INSTANCE，因为没有主动使用，达到Lazy loading

class InternalSingleton{
    private static class SingletonHolder{
        private final static  InternalSingleton INSTANCE=new InternalSingleton();
    }   
    private InternalSingleton(){}
    public static InternalSingleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

3.4、枚举，优点：不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象

enum EnumSingleton{
    INSTANCE;
    public void doSomeThing(){
    }
}

3.5、双重校验锁，在当前的内存模型中无效

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