java面试笔试题汇总（陆续补充）

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/nb7474/article/details/79644777

最近自己也在准备面试的一方面东西，遇到一些不太熟悉的地方我会陆续补充上来。

1.选择排序和冒泡排序

/**
     * 选择排序
     * @param arr
     * @return
     */
    public static int[] ChooseSort(int[] arr){

        for(int i=0;i<arr.length;i++){

            int min=i;
            for(int j=i+1;j<arr.length;j++){
                if(arr[min]>arr[j]){
                    min=j;
                }
            }
            int temp=arr[min];
            arr[min]=arr[i];
            arr[i]=temp;

        }

        return arr;
    }

    /**
     * 冒泡排序
     * @param arr
     * @return
     */
    public static int[] BubbleSort(int[] arr){

        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }

        return arr;
    }

2.求10000个随机数中找出最大1000个，写代码

public static void main(String[] args) {
        int[] arr=RandomCommon();

        for(int i=0;i<1000;i++){
            for(int j=0;j<arr.length-i-1;j++){
                if(arr[j]<arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        for(int i=0;i<1000;i++){
            System.out.print(arr[i]+",");
        }
    }

    /**
     * 得到1w个随机数
     * @return
     */
    public static int[] RandomCommon(){

        int max=100000; //最大随机数
        int min=1;  //最小随机数
        int n=10000; //随机数个数
        int[] result=new int[n]; //一个长度10000的数组
        int count=0;

        while(count<n){
            int num=(int) (Math.random()*(max-min)+min);
            boolean flag=true;
            for(int i=0;i<result.length;i++){
                if(result[i]==num){
                    flag=false;
                    break;
                }
            }
            if(flag){
                result[count]=num;
                count++;
            }
        }

        return result;
    }

3.求出两个偶数的素数(只能被1和本身整除的数)之和

public static void main(String[] args) {
        System.out.println(PrimeSum(68)+PrimeSum(98));
    }

    public static int PrimeSum(int a){

        int sum=0;

        //素数的个数不确定，所以使用集合来存放素数
        List<Integer> prime=new ArrayList<Integer>();
        for(int i=2;i<=Math.sqrt(a);i++){
        //这样做可以减少循环次数，素数是因子为1和本身， 如果数c不是素数，则还有其他因子，其中的因子，假如为a,b.其中必有一个大于sqrt(c) ，一个小于sqrt(c) 。
            while(true){
                if(a%i==0){
                    a/=i;
                    prime.add(i);//元素存放到集合中
                }else{
                    break;  //if不是循环 跳出while循环
                }
            }
        }
        if(a!=1){
            prime.add(a); //当最后a！=1的时候 即为最大的素数
        }

        //set的中不能存放重复的元素  使用set.add()判断所插入的元素是否重复
        Set set=new HashSet();
        for (int i = 0; i < prime.size(); i++) {
            if(set.add(prime.get(i))){
                sum+=prime.get(i);
            }
        }
        return sum;
    }

4.求0-1000的数求平方根，保留小数位0.00001,不能借助jdk中现有的工具类

public static void main(String[] args) {
        int n=555;  //要求的数
        double x =1;
        double temp =1;
        double result=0;
        do{
        temp = x;                //保存上一次计算的值
        x = 0.5*(x + n/x);    //这个就是牛顿迭代法的基本公式
        result=x-temp;
        result=result <= 0.0D ? 0.0D - result : result;  //Math.abs去绝对值的源码方法 result是否比零小 小则取相反数

        }while(result>0.00001); //精确度在5位小数以上

        System.out.println(String.format("%.5f", x)); //只保留5位小数
    }

5.有两个数字A,B, 他们都是有500位的数字, 如何规定不能使用BigDecimal 去运算的话怎么求的A+B的结果

public static void main(String[] args) {

        String a="123345567789";
        String b="987765543321";
        System.out.println(a.charAt(11));//charAt得到第从0开始第11位的字符

        int c=0;
        LinkedList value=new LinkedList();
        boolean isNeedCarry=false;

        for(int i=a.length()-1;i>=0;i--){
            boolean isAdded=false; //是否已经加上进位过来的1
            c=Integer.parseInt(String.valueOf(a.charAt(i)))+Integer.parseInt(String.valueOf(b.charAt(i)));

            if(isNeedCarry){  //如果进位标志为true 则加上进位的1，且是否加1的标志为true
                isAdded=true;  
                value.addFirst(String.valueOf(c+1).substring(1));  //例：相加后的c为9，加上进位1等于10，截取字符串后取得数字位0，存入linkedlist中
                c+=1;
            }

            isNeedCarry=isAddCarry(c); //第二次判断相加后的c是否需要进位  

            if(isNeedCarry){  //如果需要进位 则进行字符串截取后一位存入linkedList
                if(!isAdded){  
                    value.addFirst(String.valueOf(c).substring(1));
                }
            }else{  //如果不需要进位，说明是个一位数，直接存入LinkedList
                value.addFirst(String.valueOf(c));
            }

            if(isNeedCarry&&i==0){
                //最后一次判断是否进位，如果进位两个12位相加则变成一个13位的数字
                value.addFirst(1);
            }
        }
        for(int i=0;i<value.size();i++){
            System.out.print(value.get(i));
        }
    }

    public static boolean isAddCarry(int i){

        boolean flag=false;

        if(i>=10){
            flag=true;
        }

        return flag;
    }

6.删除一个文件夹中所有的文件

public static void main(String[] args) {
        DelAllFile("D:/downloads/ipsw");
    }
    /**
     * 删除文件
     * @param path
     * @return
     */
    public static boolean DelAllFile(String path){

        boolean flag=false;
        File file=new File(path);

        if(!file.exists()){
            return flag;
        }

        if(!file.isDirectory()){
            //如果这个path表示的文件是一个目录则返回true
            return flag;
        }
        String[] templist=file.list();//返回文件夹下的文件目录
        File temp=null;
        for(int i=0;i<templist.length;i++){
            if(path.endsWith(File.separator)){//File.separator返回的是文件的分隔符，在这里是'/'
                //path的最后有 '/' 直接进行路径的拼接，temp为path路径下的子文件的路径
                temp=new File(path+templist[i]);
            }else{
                //path的最后没有 '/'  进行路径+'/'+子文件的拼接，temp为path路径下的子文件的路径
                temp=new File(path+File.separator+templist[i]);
            }

            if(temp.isFile()){ //temp是文件
                temp.delete();
            }
            if(temp.isDirectory()){  //temp是目录
                DelAllFile(temp.getPath()); //先删除下面的文件
                temp.delete();          //再删除这个空文件夹
                flag=true;
            }
        }

        return flag;
    }

7.序列化和反序列化

public static void main(String[] args) throws Exception {
        test1();
        test2();
    }

    /**
     * 序列化
     * @throws Exception
     */
    public static void test1() throws Exception{
        OutputStream op=new FileOutputStream("D:/downloads"+File.separator+"a.txt");
        ObjectOutputStream oop=new ObjectOutputStream(op);
        oop.writeObject(new Person("zhangsan", 12));
        oop.close();
    }

    /**
     * 反序列化
     * @throws Exception
     */
    public static void test2() throws Exception{

        InputStream in=new FileInputStream("D:/downloads"+File.separator+"a.txt");
        ObjectInputStream ois=new ObjectInputStream(in);
        byte[] buffer=new byte[10];
        int len=-1;
        Person p=(Person) ois.readObject();
        System.out.println(p);
        ois.close();
    }