java笔试题+代码+解释

输出到100的质数（素数）除了1与自身不能被其他整除，需要剔除1与2，所以从3开始。

public static void main(String[] args) {
        boolean bool;
        for (int i = 3; i <= 100; i += 2) {
            bool = true;
            for (int j = 3; j < i ; j++) {
                if (i % j == 0) {
                    bool = false;
                    break;
                }
            }
            if (bool){
                System.out.println(i);
            }
        }
    }

冒泡排序 稳定 最好O(N) 最坏O(N²)，自己理解的对不对，N²并不是两个嵌套循环就是相乘或者平方，而是内部数据移动位置的次数，来个明白人解释下，感谢。

int[] arr = new int[]{996, 33, 78, 600,5, 8, 9};
        for (int i = 0 ; i <  arr.length ; i++) {
            for (int j = i + 1 ; j <  arr.length ; j++) {
                System.out.println(" 比较次数"+ i +  "\t" + j);
                int temp;
                if (arr[i] > arr[j]){
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
               }
        }
}
System.out.println(Arrays.toString(arr));

Java数组中最大值与最小值，有内置函数。或者写排序取出第一个和最后一个元素。

Integer[] arr = new Integer[]{1, 33, 78, 600,5, 8, 9};
System.out.println(Collections.max(Arrays.asList(arr)));
System.out.println(Collections.min(Arrays.asList(arr)));

100-999的水仙花数，意思是个位十位百位数值的立方相加等于原数字，例如153拆分为1、5、3
1的立方是1*1*1=1，5的立方是5*5*5=125，3的立方是3*3*3=27，那么就是1+125+27=153。

public void test() {
	int count = 999;
	int x = 0;
	int y = 0;
	int z = 0;
	for (int i = 100; i <= count; i++) {
		x = i / 100;        //取百位
		y = (i / 10) % 10;  //取十位
		z = i % 10;         //取个位
		int num = x*x*x + y*y*y + z*z*z;
		if (i == num){
			System.out.println(i);
		}
	}
}

最大公约数：如12能被1、2、3、4、6整除，16能被1,、2、4、8整除，那么12与16的公约数就是1、2、4，最大公约数是4。
最小公倍数：如4的倍数有4、8、12……等等无限大，6的倍数有6、12、14、24,4与6的公有倍数为12、24那么最小的就是12。
名词解释：https://baike.baidu.com/item/%E6%9C%80%E5%A4%A7%E5%85%AC%E7%BA%A6%E6%95%B0/869308?fr=aladdin

/**
     * 思路 就是用大的数取余小的数，什么时候等于0了，那么就返回模数也就是 X % Y 的Y。
     * 如 24 % 12 等于0，最大公约数就是12，
     * 然后两个数相加 12 * 24 / 12 等于24，最小公倍数就是24.
     *
     * 在举例32与23
     * 过程32 % 23 = 9，23 % 9 = 5,9 % 5 = 4,5 % 4 = 1,4 % 1 = 0。这个时候返回 1 也就是32与23的最大公约数
     * 然后32 * 23 / 1 = 736，736 就是它们最小公倍数
     * @param a
     * @param b
     * @return
     */
    public static void main(String args[]) throws Exception {
        int m = 32;
        int n = 23;
        int c = gys(m,n);
        System.out.println(m*n/c);
        System.out.println(c);
    }
    public static int gys(int a ,int b){
        while (true){
            if((a = a % b ) == 0){
                return b;
            }
            if((b = b % a ) == 0){
                return a;
            }
        }
    }

编程实现1000内的完数，0和1不是，一万以内的就4个6、28、496、8128，一万开外耗时太长没事建议别玩（上亿亿级别的运算）。
概念，一个数的所有约数（自身除外）相加等于自身就是完数，例如6的约数是1、2、3、6。28是1、2、4、7、14、28，除去自身剩下的相加等于自身。

for (int i = 1; i < 10000; i++) {
    int sum = 0;
    for (int j = 1;j < i ; j++){
        if (i % j == 0){
        sum += j;
        }
    }
    if (i == sum){
        System.out.println(sum);
    }
}

一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在   第10次落地时，共经过多少米？第10次反弹多高？需要注意第一次下落的100米也计算在内，并且每次反弹后落地是双距离。

double s = 100; //总米数
double t = 100; //当前高度
for(int i=1;i<=10;i++){
    //这么写容易理解
    t = t/2;//当前高度 = 上次高度/2；
    s += t*2; //总米数= 当前米数 += 当前高度 * 一个来回，也就是2.
}
System.out.println(s);
System.out.println(t);
299.8046875
0.09765625

实现产生一个int数组，长度为100，并向其中随机插入1-100，并且不能重复。
这个怎么理解？我理解为一个长度为100的空数组，使用随机的方法向数组插入数据，要求插入的数据数组中不存在。老铁没毛病666.

int[] array = new int[100];
int j = 0;
while (true) {
    boolean isAdd = true;
    int random = (int)(Math.random() * 101);
    for (int i = 0; i < array.length; i++) {
        if (array[i] == random){
            isAdd = false;
            break;
        }
    }
    if (isAdd) {
        array[j] = random;
        j++;
        if (j == 100){
            break;
        }
    }
}
Arrays.sort(array);
System.out.println(Arrays.toString(array));

将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。 （如果想输出1、2、3、5、7、9、11这样的数值就把i改成1）
思路：找到这个数最小的约数，然后输出约数，在将这个数除约数，将得到的这个数在找到它的最小约数如此循环，最后退出的机制是当它除约数等于1的时候，也就是约数等于自身的时候退出。

public static  void main(String[] args) {
    int value = 90;//输入的数值
    int i = 2;//约数 从2开始
    System.out.print(value + " = ");
    while (true){
        if (value % i == 0){
            value = value / i;
            if (value == 1){
                System.out.print(i);
                break;
            }else {
                System.out.println(i + "*");
            }
            continue;
        }
        i++;
    }
}