java基础常见笔试题,编程题

一写出冒泡排序法

public class Test1_BubbleSort {
	public static void main(String[] args) {
		//1、定义  无序 数组
		int[]  a = {  92,34,68,6,56  };
		System.out.println("交换前："+Arrays.toString(a));
		//2、开始排序
		//-1是因为，5个数字只需要比4次。
		for( int i = 0 ; i < a.length  -1  ; i++ ) {
			//-1是因为相邻元素比较时，会获取j+1的情况，不能越界
			//-i 是因为，内循环，每轮都会冒出来一个大的值，不参与比较，所以每轮要少执行1次。
			//当i=0时，第一轮循环开始，内循环j比较了4次。因为 j=0，j< 5-1-0
			//当i=1时，第二轮循环开始，内循环j比较了3次。因为 j=0，j< 5-1-1
			for( int j = 0 ; j < a.length - 1 - i ; j++) {
				//相邻元素比较，判断，
				if(a[ j]  > a[ j+1] )  {//如果前面的数字大
					//交换位置
					int t  =  a[j];
					a[j] = a[j+1] ;
					a[j+1] = t;
				}
			}
		}
		Arrays.sort(a);//工具底层已经完成了排序算法，用的快速排序算法
		System.out.println("交换后："+Arrays.toString(a));
	}
}

二:爱因斯坦台阶问题

有人走台阶若每步走2级，则最后剩1级。若每步走3级则最后剩2级。若每步走4级，则最后剩3级。若每步走5级，则最后剩4级。若每步走6级， 则最后剩5级。若每步走7级，则刚好不剩。试编制程序求此台阶数。
代码实现如下:

三求1+2!+3!+… +20!的和?

代码实现如下:

一个数的阶乘等于这个数的本身乘前一个数的阶乘，所以源码中num在运算过程中，是随着I的变化依次相乘作为每一个数的阶乘项， 直接参与相加即可,这个体可以使用两层for循环进行计算，但是两层for循环会增加时间复杂度。

四.试编写程序，从一个给定的字符串中删去某个给定的字符。

五.试编写一个程序，输入一个字符串，统计其中有多少各单词？单词之间用空格分开。

六…某班级有 40 个学生，学号为 180201-180240，全部参加 Java 集合阶段检测，给出所有同学的成绩（可随机产生，范围为 50-100），请编写程序将本班各位同学成绩从高往低排序打印输出，注：成绩相同时学号较小的优先打印要求：打印的信息包含学号、姓名（姓名统一为“同学 J”[J=10,11,12。。。]）和成绩。

思路分析：
1.随机产生所有同学的成绩：Math.random()；
2.所有同学学号，姓名，成绩存储：ArrayList /TreeSet/PriorityQueue；
3.成绩进行从高到低比较：实现比较器类，Collections.sort()；

代码实现:

//将学生信息封装成一个类
public class Student {
    private int id;
    private String name;
    private int score;

    public Student(int id,String name,int score){
        this.id = id;
        this.name = name;
        this.score = score;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }
}
public class IOTest01 {
    private ArrayList<Student> arrayList = new ArrayList<Student>();
    public void save(){
        Random random = new Random();
        //保存40位同学的姓名、学号、成绩
        for (int i = 0,j = 10; i <= 40; i++) {
            int id = 180201 + i;
            String name = "同学" + j++;
            int score = random.nextInt(51) + 50;
            this.arrayList.add(new Student(id,name,score));
        }
    }
    public void sort(){

        //进行排序,成绩按照从高往低排序，成绩相同时学号小的排在前优先打印
        Comparator<Student> comparator = new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o2.getScore()> o1.getScore() ? 1 : o2.getScore() < o1.getScore() ?
                        -1 : o1.getId() - o2.getId();
            }
        };
        Collections.sort(arrayList,comparator);
    }
    public void print(){
        Iterator<Student> iterator = this.arrayList.iterator();
        while (iterator.hasNext()){
            Student value = iterator.next();
            System.out.println("学号："+ value.getId() +"姓名："+value.getName() +
                    "成绩："+ value.getScore());
        }
    }
    public static void main(String[] args) {
        IOTest01 ioTest01 = new IOTest01();

        ioTest01.save();
        ioTest01.sort();
        ioTest01.print();
    }
}

七.有两个有序的集合，集合的每个元素都是一段范围，求其交集，例如交集{[4,8],[9,13]}和{[6,12]}的交集是{[6,8],[9,12]}。

/**
* @param collects1：集合 1
* @param collects2：集合 2
*/
public static void intersectionWithColletion
(List<List<Integer>> collects1, List<List<Integer>>
collects2) {}

思路分析：
1.对两个集合进行合法性判断，是否是一个集合，是否符合符合题目集合中每个元素都是一段范围的要求；
2.求交集，将每个集合中的范围都相互求交集。
注意： 重点在于求两个集合范围的交集；以及使用的数据存储。
具体实现：

在这里插import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * Description：
 * Author: zker
 * Date: Created in 23:45 2019/3/31
 * Copyright: Copyright (c) 2018
 */
public class IOTest02 {
     /*
     * 参数校验的方法，检验是否集合，并且
     */
    private static boolean isVaild(ArrayList<ArrayList<Integer>> collects) {
        if (collects.size() < 1) {             //判断集合中是否有元素
            System.out.println("集合为空");
            return false;
        }
        Iterator <ArrayList <Integer>> iterator = collects.iterator();
        while (iterator.hasNext()) {         //判断是否符合要求，集合是一段范围
            List <Integer> list = iterator.next();
            if (list.size() != 2) {
                System.out.println("集合区间不合法");
                return false;
            }
            if (list.get(0) > list.get(1)) {
                System.out.println("集合区间不是有序的");
                return false;
            }
        }
        return true;
    }

    public static void intersectionWithColletion(ArrayList <ArrayList<Integer>> collects1, ArrayList <ArrayList <Integer>> collects2) {
        //合法性校验
        if (!(isVaild(collects1) && isVaild(collects2))) {
            return;
        }
        //把每个集合中的小集合都与其他的做交集判断
        Iterator<ArrayList<Integer>> iterator1 = collects1.iterator();
        while (iterator1.hasNext()) {
            List<Integer> list1 = iterator1.next();
            Iterator <ArrayList <Integer>> iterator2 = collects2.iterator();
            while (iterator2.hasNext()) {
                List <Integer> list2 = iterator2.next();
                intersection(list1, list2);
            }
        }
    }

    //交集过程
    private static void intersection(List<Integer> list1, List<Integer> list2) {

        Integer a1 = list1.get(0);//集合list1的起始
        Integer a2 = list1.get(1);//集合list1的结束
        Integer b1 = list2.get(0);//集合list2的起始
        Integer b2 = list2.get(1);//集合list2的结束

        if (a1 > b2 || b1 > a2) {
            return;
        }

        if (a1 == b2) {
            System.out.println("["+a1+"]");
        }

        if (a2 == b1) {
            System.out.println("["+a2+"]");
        }

        if (a1 > b1) {
            System.out.print("[" + a1 + ",");
            if (b2 < a2) {
                System.out.println(b2 + "]");
            } else {
                System.out.println(a2 + "]");
            }
        }

        if (b1 >=  a1) {
            System.out.print("["+b1+",");
            if (b2 < a2) {
                System.out.println(b2 + "]");
            } else {
                System.out.println(a2 + "]");
            }
        }

    }
  
    public static void main(String[] args) {
        ArrayList <Integer> a1 = new ArrayList <Integer>();
        a1.add(4);
        a1.add(8);
        ArrayList <Integer> a2 = new ArrayList <Integer>();
        a2.add(9);
        a2.add(13);
        ArrayList <ArrayList <Integer>> a = new ArrayList <ArrayList <Integer>>();
        a.add(a1);
        a.add(a2);
        
        ArrayList <Integer> b1 = new ArrayList <Integer>();
        b1.add(6);
        b1.add(12);
        ArrayList <ArrayList <Integer>> b = new ArrayList <ArrayList <Integer>>();
        b.add(b1);

        intersectionWithColletion(a,b);
    }
}
//output:
[6,8]
[9,12]
入代码片