java题库（基础）

文章目录

• • 1、题目：两数之和
  • 2、题目：输出所有水仙花数
  • 3、题目：输入两个数m, n 求最大公约数和最小公倍数
  • 4、题目：找出100以内所有的素数（质数）？100000以内呢？
  • 5、题目：使用二维数组打印一个10行杨辉三角
  • 6、题目：评委打分
  • 7、题目：创建一个长度为6的int型数组，要求数组元素的值都在1-30之间。且是随机赋值，且是随机赋值。同时，要求元素的值各不相同
  • 8、题目：回形数
  • 9、题目：数组的扩容
  • 10、题目：数组的缩容
  • 11、题目：线性查找
  • 12、题目：二分查找
  • 13、题目：冒泡排序
  • 14、题目：Arrays库的使用
  • 15、题目：求数组的最大子序列和
  • 16、题目：OOP小练习
  • 17、题目：对象数组
  • 18、题目：递归函数应用
  • 19、题目：不死神兔
  • 21、题目：
  • 22、题目：

1、题目：两数之和

题目描述：
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。
示例：

输入：nums = [3,2,4], target = 6
输出：[1,2]

题目解答
方法一：暴力枚举

class Solution {public int[] twoSum(int[] nums, int target) {int n = nums.length;for (int i = 0; i < n; ++i) {for (int j = i + 1; j < n; ++j) {if (nums[i] + nums[j] == target) {return new int[]{i, j};}}}return new int[0];}
}

方法二：哈希表

class Solution {public int[] twoSum(int[] nums, int target) {Map<Integer, Integer> hashtable = new HashMap<Integer, Integer>();for (int i = 0; i < nums.length; ++i) {if (hashtable.containsKey(target - nums[i])) {return new int[]{hashtable.get(target - nums[i]), i};}hashtable.put(nums[i], i);}return new int[0];}
}

2、题目：输出所有水仙花数

// 输出所有水仙花数，各个位数的数字立方和等于其本身
// 153 = 1*1*1 + 3*3*3 + 5*5*5
for (int i = 100; i < 1000; i++) {int ge = i % 10;int shi = (i / 10) % 10;int bai = i / 100;if (i == bai * bai * bai + ge * ge * ge + shi * shi * shi) {System.out.println(i);}
}

3、题目：输入两个数m, n 求最大公约数和最小公倍数

//最大公约数
int m = 12;
int n = 20;
int min = (m > n) ? m : n;
for (int i = min; i >= 1; i--) {if (m % i == 0 && n % i == 0) {System.out.println("最大公倍数：" + i);break;}
}
//最小公倍数
int max = (m > n) ? m : n;
for (int i = max; i < m * n; i++) {if (i % m == 0 && i % n == 0) {System.out.println("最小公约数：" + i);break;}
}

4、题目：找出100以内所有的素数（质数）？100000以内呢？

方法一：

// 找出100以内所有的素数（质数）？100000以内呢？
//什么是质数？ 除了1和它本身能整除的自然数。例如：2、3、5、7、11、13、17……
for (int i = 2; i < 100; i++) {//记录i的约束的个数（从2开始，到i-1为止）int number = 0;for (int j = 2; j < i; j++) {if (i%j==0){number++;}}if (number==0){System.out.println(i);}
}

方法二：

// 找出100以内所有的素数（质数）？100000以内呢？
//什么是质数？ 除了1和它本身能整除的自然数。例如：2、3、5、7、11、13、17……
//标记
boolean isFlag = true;
for (int i = 2; i < 100; i++) {for (int j = 2; j < i; j++) {if (i%j==0){isFlag=false;}}if (isFlag==true){System.out.println(i);}// 重置标记isFlag = true;
}

100000以内的质数个数，体会不同的算法实现，其性能差别。

方式一：

        // 找出100以内所有的素数（质数）？100000以内呢？//什么是质数？ 除了1和它本身能整除的自然数。例如：2、3、5、7、11、13、17……//标记boolean isFlag = true;int count = 0; // 记录质数的个数//获取当前系统的时间long start = System.currentTimeMillis();for (int i = 2; i < 100000; i++) {for (int j = 2; j < i; j++) {if (i % j == 0) {isFlag = false;}}if (isFlag == true) {count++;}// 重置标记isFlag = true;}long end = System.currentTimeMillis();System.out.println("质数总共有：" + count);System.out.println("花费的时间为：" + (end - start));

结果：
质数总共有：9592
花费的时间为：6726

方式二：
对方式一进行优化

//标记
boolean isFlag = true;
int count = 0; // 记录质数的个数//获取当前系统的时间
long start = System.currentTimeMillis();for (int i = 2; i < 100000; i++) {for (int j = 2; j < i; j++) {if (i % j == 0) {isFlag = false;break; //针对非质数有效果}}if (isFlag == true) {count++;}// 重置标记isFlag = true;
}
long end = System.currentTimeMillis();
System.out.println("质数总共有：" + count);
System.out.println("花费的时间为：" + (end - start));

结果：
质数总共有：9592
花费的时间为：722

方式三：对方式二进行优化

//标记
boolean isFlag = true;
int count = 0; // 记录质数的个数//获取当前系统的时间
long start = System.currentTimeMillis();for (int i = 2; i < 100000; i++) {for (int j = 2; j <= Math.sqrt(i); j++) {if (i % j == 0) {isFlag = false;break; //针对非质数有效果}}if (isFlag == true) {count++;}// 重置标记isFlag = true;
}
long end = System.currentTimeMillis();
System.out.println("质数总共有：" + count);
System.out.println("花费的时间为：" + (end - start));

结果：
质数总共有：9592
花费的时间为：7

5、题目：使用二维数组打印一个10行杨辉三角

package com.aiguigu.oneArray;
/*** ClassName: YangHuiTest* Description:* 案例：使用二维数组打印一个10行杨辉三角* 提示：* 1、第一行有一个元素，第n行有第n个元素* 2、每一行的第一个元素和最后一个元素都是1* 3、从第三个元素开始，对于非第一个元素和最后一个元素的元素。即：* yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];*/
public class YangHuiTest {public static void main(String[] args) {// 1、创建二维数组int[][] yanghui = new int[10][];//2、使用循环结构，初始化外层数组元素for (int i = 0; i < yanghui.length; i++) {yanghui[i] = new int[i + 1];//3、给数组的元素赋值// (1)将首末元素初始化为 1yanghui[i][0] = yanghui[i][i] = 1;//(2)计算杨辉三角for (int j = 1; j < yanghui[i].length - 1; j++) {yanghui[i][j] = yanghui[i - 1][j - 1] + yanghui[i - 1][j];}}// 遍历二维数组for (int i = 0; i < yanghui.length; i++) {for (int j = 0; j < yanghui[i].length; j++) {System.out.print(yanghui[i][j] + "\t");}System.out.println();}}}

结果：

1	
1	1	
1	2	1	
1	3	3	1	
1	4	6	4	1	
1	5	10	10	5	1	
1	6	15	20	15	6	1	
1	7	21	35	35	21	7	1	
1	8	28	56	70	56	28	8	1	
1	9	36	84	126	126	84	36	9	1

6、题目：评委打分

• 案例：评委打分
• （1）在编程比赛中，10位评委为参赛选手打分，分数分别为：5, 4, 6, 8, 9, 0, 1, 2, 7, 3
• （2）求选手最后得分（去除掉以恶最低分和一个最高分之后其余8位评委打分的平均值）

package com.aiguigu.oneArray;/*** ClassName: OneArrayExer02* Description:* 案例：评委打分* （1）在编程比赛中，10位评委为参赛选手打分，分数分别为：5, 4, 6, 8, 9, 0, 1, 2, 7, 3* （2）求选手最后得分（去除掉以恶最低分和一个最高分之后其余8位评委打分的平均值）*/
public class OneArrayExer02 {public static void main(String[] args) {int[] score = {5, 4, 6, 8, 9, 0, 1, 2, 7, 3};int max = score[0];int min = score[0];int sum = 0;for (int i = 0; i < score.length; i++) {// 求最低分if (score[i] < min) {min = score[i];}//求最高分if (max < score[i]) {max = score[i];}// 求总和sum += score[i];}System.out.println("max = " + max);System.out.println("min = " + min);System.out.println("sum = " + sum);// 评委的平均分（去除最高分和一个最低分）sum = sum - min - max;double avgValue = sum / 8.0;System.out.println("评委得分平均值为：" + avgValue);}
}

7、题目：创建一个长度为6的int型数组，要求数组元素的值都在1-30之间。且是随机赋值，且是随机赋值。同时，要求元素的值各不相同

方法一：常规思路

package com.aiguigu.oneArray;public class OneArrayExer03 {public static void main(String[] args) {int[] arry = new int[6];int tmp = 0;for (int i = 0; i < arry.length; i++) {// 给第i个赋值arry[i] = (int) (Math.random() * (30 - 1 + 1) + 1);// 设置标记，表示是否重复boolean flag = false;while (true){// 判断新加入元素是否重复for (int j = 0; j < i; j++) {if (arry[i] == arry[j]){// 如果重复，flag变为trueflag = true;break;  // 不在判断以后的元素}}// 若重复重新赋值if (flag){arry[i] = (int) (Math.random() * (30 - 1 + 1) + 1);flag = false;// 继续判断continue;}break;}}// 展示数组for (int i = 0; i < arry.length; i++) {System.out.print(arry[i]+"\t");}}
}

方法二：打开思维

package com.aiguigu.oneArray;/*** ClassName: OneArrayExer03* Description:* 创建一个长度为 6 的int型数组，要求数组元素的值都在1-30之间。且是随机赋值，且是随机赋值。同时，要求元素的值各不相同**/
public class OneArrayExer03 {public static void main(String[] args) {int[] arry = new int[20];int tmp = 0;for (int i = 0; i < arry.length; i++) {// 给第i个赋值arry[i] = (int) (Math.random() * (30 - 1 + 1) + 1);// 判断新加入元素是否重复for (int j = 0; j < i; j++) {if (arry[i] == arry[j]){// 如果重复，重新赋值i--;break;}}}// 展示数组for (int i = 0; i < arry.length; i++) {System.out.print(arry[i]+"\t");}}
}

8、题目：回形数

从键盘输入一个整数（1~20） ，则以该数字为矩阵的大小，把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。

例如： 输入数字2，则程序输出：
1 2
4 3

输入数字3，则程序输出：
1 2 3
8 9 4
7 6 5
输入数字4， 则程序输出：
1 2 3 4
12 13 14 5
11 16 15 6
10 9 8 7

//方式1
public class RectangleTest {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("输入一个数字");int len = scanner.nextInt();int[][] arr = new int[len][len];int s = len * len;/** k = 1:向右* k = 2:向下* k = 3:向左* k = 4:向上*/int k = 1;int i = 0,j = 0;for(int m = 1;m <= s;m++){if(k == 1){if(j < len && arr[i][j] == 0){arr[i][j++] = m;}else{k = 2;i++;  j--;m--;}}else if(k == 2){if(i < len && arr[i][j] == 0){arr[i++][j] = m;}else{k = 3;i--;j--;m--;}}else if(k == 3){if(j >= 0 && arr[i][j] == 0){arr[i][j--] = m;}else{k = 4;i--;j++;m--;}}else if(k == 4){if(i >= 0 && arr[i][j] == 0){arr[i--][j] = m;}else{k = 1;i++;j++;m--;}}}//遍历for(int m = 0;m < arr.length;m++){for(int n = 0;n < arr[m].length;n++){System.out.print(arr[m][n] + "\t");}System.out.println();}}
}

方式二：

//方式2
/*01 02 03 04 05 06 07 24 25 26 27 28 29 08 23 40 41 42 43 30 09 22 39 48 49 44 31 10 21 38 47 46 45 32 11 20 37 36 35 34 33 12 19 18 17 16 15 14 13 */
public class RectangleTest1 {public static void main(String[] args) {int n = 7;int[][] arr = new int[n][n];int count = 0; //要显示的数据int maxX = n-1; //x轴的最大下标int maxY = n-1; //Y轴的最大下标int minX = 0; //x轴的最小下标int minY = 0; //Y轴的最小下标while(minX<=maxX) {for(int x=minX;x<=maxX;x++) {arr[minY][x] = ++count;}minY++;for(int y=minY;y<=maxY;y++) {arr[y][maxX] = ++count;}maxX--;for(int x=maxX;x>=minX;x--) {arr[maxY][x] = ++count;}maxY--;for(int y=maxY;y>=minY;y--) {arr[y][minX] = ++count;}minX++;}for(int i=0;i<arr.length;i++) {for(int j=0;j<arr.length;j++) {String space = (arr[i][j]+"").length()==1 ? "0":"";System.out.print(space+arr[i][j]+" ");}System.out.println();}}
}

9、题目：数组的扩容

现有数组 int[] arr = new int[]{1,2,3,4,5}; ，现将数组长度扩容1倍，并将10,20,30三个数据添加到arr数组中，如何操作？

package com.study.search_sort;/*** ClassName: ArrayExpansion* Package: com.study.search_sort* Description: 案例： 数组扩容* 现有数组 int[] arr = new int[]{1,2,3,4,5}; ，现将数组长度扩容1倍，并将10,20,30三个数据添加到arr数组中，如何操作？** @Author ShiQiFei* @Create 2023/6/9 16:31* @Version 1.0*/
public class ArrayExpansion {public static void main(String[] args) {int[] arr = new int[]{1,2,3,4,5};// 扩容一倍// int[] newArr = new int[arr.length * 2];// or// 左移一位int[] newArr = new int[arr.length << 1];// 将原有数组元素赋值到新数组中for (int i = 0; i < arr.length; i++) {newArr[i] = arr[i];}// 将新元素赋值newArr[arr.length] = 10;newArr[arr.length+1] = 20;newArr[arr.length+2] = 30;// 将新数组地址赋给原有数组变量arr = newArr;// showfor (int i = 0; i < arr.length; i++) {System.out.print(arr[i]+"\t");}}
}

10、题目：数组的缩容

现有数组 int[] arr={1,2,3,4,5,6,7}。现需删除数组中索引为4的元素。

package com.study.search_sort;/*** ClassName: ArrayScaling* Package: com.study.search_sort* Description:* 现有数组 int[] arr={1,2,3,4,5,6,7}。现需删除数组中索引为4的元素。** @Author ShiQiFei* @Create 2023/6/10 10:01* @Version 1.0*/
public class ArrayScaling {public static void main(String[] args) {int[] arr = {1, 2, 3, 4, 5, 6, 7};int deleteIndex = 4;// 方法一：修改原有数组// 删除元素，后面的元素向前移for (int i = deleteIndex; i < arr.length-1; i++) {arr[i] = arr[i+1];}// 将最后一个元素设为默认值arr[arr.length-1] = 0;// 结果：1	2	3	4	6	7	0// 方法二：创建新数组// 删除元素，创建一个新数组，将剩余元素存放到新数组中int[] newArr = new int[arr.length - 1];for (int i = 0; i < arr.length; i++) {// 索引为4删除if (i == deleteIndex) {continue;}// 赋值if (i > deleteIndex) {newArr[i - 1] = arr[i];} else {newArr[i] = arr[i];}}// 将新地址赋值给arrarr = newArr;// 结果：1	2	3	4	6	7// showfor (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + "\t");}}
}

11、题目：线性查找

• 定义数组：int[] arr = {34, 54, 3, 2, 65, 7, 34, 5, 76, 34, 67};
• 查找数组元素 5 是否在上述数组中出现过？若出现，数组对应的索引值。

package com.study.search_sort;/*** ClassName: LinearSearch* Package: com.study.search_sort* Description: 线性查找* 定义数组：int[] arr = {34, 54, 3, 2, 65, 7, 34, 5, 76, 34, 67};* 查找数组元素 5 是否在上述数组中出现过？若出现，数组对应的索引值。** @Author ShiQiFei* @Create 2023/6/10 10:32* @Version 1.0*/
public class LinearSearch {public static void main(String[] args) {int[] arr = {34, 54, 3, 2, 65, 7, 34, 5, 76, 34, 67};int target = 5;// 线性查找：从第一个元素挨个查找数组中的元素，若有存在即返回当前元素的索引值。// 方式一：根据标志判断又没找到
//        boolean isFlag = false;
//        for (int i = 0; i < arr.length; i++) {
//            if (target == arr[i]){
//                System.out.println("找到了，索引为 "+i);
//                isFlag = true;
//                break;
//            }
//        }
//        if (!isFlag){
//            System.out.println("未找到了！！！");
//        }// 方式二：根据数组长度判断是否找到int i = 0;for (; i < arr.length; i++) {if (target == arr[i]){System.out.println("找到了，索引为 "+i);break;}}if (i==arr.length){System.out.println("未找到了！！！");}}}

12、题目：二分查找

• 前提：数组内元素必须是有序的！！！
• 定义数组：int[] arr = {2, 4, 5, 8, 12, 15, 19, 26, 37, 49, 51, 66, 89, 100};
• 查找数组元素 5 是否在上述数组中出现过？若出现，数组对应的索引值。
• 实现逻辑：
  
• 实现代码

package com.study.search_sort;/*** ClassName: BinarySearch* Package: com.study.search_sort* Description:* 定义数组：int[] arr = {2, 4, 5, 8, 12, 15, 19, 26, 37, 49, 51, 66, 89, 100};* 查找数组元素 5 是否在上述数组中出现过？若出现，数组对应的索引值。** @Author ShiQiFei* @Create 2023/6/10 10:57* @Version 1.0*/
public class BinarySearch {public static void main(String[] args) {int[] arr = {2, 4, 5, 8, 12, 15, 19, 26, 37, 49, 51, 66, 89, 100};int target = 5;// 默认首索引int head = 0;// 默认尾索引int end = arr.length - 1;// 设置标志。判断是都找到boolean isFlag = true;while (head <= end) {// 中间索引int middle = (head + end) / 2;//判断目标值与数组中间值是否相等if (target == arr[middle]) {System.out.println("找到了，索引为 " + middle);isFlag = false;break;} else if (target < arr[middle]) { //查找左边元素end = middle - 1;} else { //查找右边元素head = middle + 1;}}if (isFlag){System.out.println("么有找到了!!! ");}}
}

13、题目：冒泡排序

对现有数组进行排序：
int[] arr = {34, 54, 3, 2, 65, 7, 34, 5, 76, 34, 67, 100};

package com.study.search_sort;/*** ClassName: BubbleSort* Package: com.study.search_sort* Description: 冒泡排序* 思想：每一次比较“相邻（位置相邻）”元素，如果它们不符合目标顺序（例如：从小到大），* 就交换它们，经过多轮比较，最终实现排序。* （例如：从小到大）	 每一轮可以把最大的沉底，或最小的冒顶。** @Author ShiQiFei* @Create 2023/6/10 12:47* @Version 1.0*/
public class BubbleSort {public static void main(String[] args) {int[] arr = {34, 54, 3, 2, 65, 7, 34, 5, 76, 34, 67, 100};// 遍历for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + "\t");}// 比较for (int i = 0; i < arr.length - 1; i++) {boolean flag = true;   //假设数组是有序的// 交换一次，将最大的元素一直到了最右边// 小优化：可知已将最大的放到了最左边，可以就不用与最后一个相比即：第一轮结束后 arr.length - 1 - 1for (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;flag = false; // 如果元素发生了交换，说明数组没有排好序}}if (flag){break;}}// 排序后数组System.out.println();for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + "\t");}}
}

14、题目：Arrays库的使用

package com.study.arrays;import java.util.Arrays;/*** ClassName: ArraysTest* Package: com.study.search_sort* Description: 数组工具类的使用** @Author ShiQiFei* @Create 2023/6/10 15:58* @Version 1.0*/
public class ArraysTest {public static void main(String[] args) {int[] arr1 = new int[]{1, 4, 7, 10, -30};int[] arr2 = new int[]{1, 4, 7, 10, -30};// int[] arr2 = new int[]{1, 4, 7, 10, -30};  // false// 1、 boolean equals(int[] a, int[] b); 比较数组元素是否依次相等boolean isEquals = Arrays.equals(arr1, arr2);  // 注意 if(arr1==arr2)判断的是地址是否相等System.out.println(isEquals); // true// 2、String toString(int[] a): 输出数组元素信息System.out.println(arr1); //[I@4eec7777System.out.println(Arrays.toString(arr1)); // [9, -16, 30, 23, -30, -49, 25, 21, 30]// 3、void fill(int[] a, int val):将指定值填充到数组之中Arrays.fill(arr1, 33);System.out.println(Arrays.toString(arr1)); // [33, 33, 33, 33, 33]// 4、void sort(int[] a): 使用快速排序算法实现的排序int[] arr3 = new int[]{1, 4, 7, 10, -30};Arrays.sort(arr3);System.out.println(Arrays.toString(arr3)); // [-30, 1, 4, 7, 10]// 5、int binarySearch(int[] a, int key): 二分查找int index = Arrays.binarySearch(arr3, 5);System.out.println(index);  // -4 负数代表没找到, 若大于等于0则找到了}}

15、题目：求数组的最大子序列和

• 输入一个整形数组，数组里有正数也有负数。数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。
• 求所有子数组的和的最大值。要求时间复杂度为O(n)。
  例如：输入的数组为1, -2, 3, 10, -4, 7, 2, -5，和最大的子数组为3, 10, -4, 7, 2，
  因此输出为该子数组的和18。

public class ArrDemo {public static void main(String[] args) {int[] arr = new int[]{1, -2, 3, 10, -4, 7, 2, -5};int i = getGreatestSum(arr);System.out.println(i);}public static int getGreatestSum(int[] arr){int greatestSum = 0;if(arr == null || arr.length == 0){return 0;}int temp = greatestSum;for(int i = 0;i < arr.length;i++){temp += arr[i];if(temp < 0){temp = 0;}if(temp > greatestSum){greatestSum = temp;}}if(greatestSum == 0){greatestSum = arr[0];for(int i = 1;i < arr.length;i++){if(greatestSum < arr[i]){greatestSum = arr[i];}}}return greatestSum;}
}

16、题目：OOP小练习

• 案例：
• （1）声明一个MyDate类型，有属性：年year 月month 日day
• （2）声明一个Employee类型，包含属性:编号、姓名、年龄、薪资、生日（MyDate类型）
• （3）在EmployeeTest测试类中的main（）中，创建两个员工对象，并为他们的姓名和生日赋值、并显示。

MyDate类

package com.study.field.Exer01;/*** ClassName: MyDate* Package: com.study.field.Exer01* Description:** @Author ShiQiFei* @Create 2023/6/10 20:40* @Version 1.0*/
public class MyDate {String year;String month;String day;
}

Employee类

package com.study.field.Exer01;/*** ClassName: Employee* Package: com.study.field.Exer01* Description:** @Author ShiQiFei* @Create 2023/6/10 20:31* @Version 1.0*/
public class Employee {MyDate birthday;int id;String name;int age;double salary;
}

EmployeeTest类

package com.study.field.Exer01;/*** ClassName: EmployeeTest* Package: com.study.field.Exer01* Description: OOP* 案例：* （1）声明一个MyDate类型，有属性：年year 月month 日day* （2）声明一个Employee类型，包含属性:编号、姓名、年龄、薪资、生日（MyDate类型）* （3）在EmployeeTest测试类中的main（）中，创建两个员工对象，并为他们的姓名和生日赋值、并显示。** @Author ShiQiFei* @Create 2023/6/10 20:31* @Version 1.0*/
public class EmployeeTest {public static void main(String[] args) {Employee employee = new Employee();employee.id = 123;employee.name = "tom";employee.age = 12;employee.salary = 10000;employee.birthday = new MyDate();employee.birthday.year = "2022";employee.birthday.month = "12";employee.birthday.day = "01";Employee employee1 = new Employee();employee1.id = 1223;employee1.name = "som";employee1.age = 18;employee1.salary = 20000;employee1.birthday = new MyDate();employee1.birthday.year = "2002";employee1.birthday.month = "22";employee1.birthday.day = "06";System.out.println(employee.id + " " + employee.name + " " + employee.age + " " + employee.salary+ " " + employee.birthday.year+":"+ employee.birthday.month+":"+ employee.birthday.day);System.out.println(employee1.id + " " + employee1.name + " " + employee1.age + " " + employee1.salary+ " " + employee1.birthday.year+":"+ employee1.birthday.month+":"+ employee1.birthday.day);}
}

17、题目：对象数组

案例

定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一：打印出3年级(state值为3）的学生信息。
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
提示：

1. 生成随机数：Math.random()，返回值类型double;
2. 四舍五入取整：Math.round(double d)，返回值类型long。

代码：
Student

package com.study.field.Exer05;/*** ClassName: Student* Package: com.study.field.Exer05* Description:** @Author ShiQiFei* @Create 2023/6/11 18:37* @Version 1.0*/
public class Student {//学号int number;// 年级int state;// 成绩int score;// 声明一个方法打印属性public String show(){return "学号：" + number + " 年级：" + state + " 成绩：" + score;}
}

StudentTest

package com.study.field.Exer05;/*** ClassName: StudentTest* Package: com.study.field.Exer05* Description:** @Author ShiQiFei* @Create 2023/6/11 18:38* @Version 1.0*/
public class StudentTest {public static void main(String[] args) {// 对象数组Student[] students = new Student[20];// 为学生赋值for (int i = 0; i < students.length; i++) {// 创建第一个学生对象students[i] = new Student();students[i].number = i + 1;// 学生随机分到1-6年级students[i].state = (int) (Math.random() * 6 + 1);// 分数随机[0,100]students[i].score = (int) (Math.random() * 101);}// 打印出三年级的学生for (int i = 0; i < students.length; i++) {Student stu = students[i];if (stu.state == 3) {// System.out.println("学号：" + stu.number + " 年级：" + stu.state + " 成绩：" + stu.score);//System.out.println(stu.show());}}// 冒泡排序按学生成绩，遍历所有学生成绩
//        for (int i = 0, j = 1; i < students.length-1, j < (students.length-1-i); i++, j++) {
//
//        }for (int i = 0; i < students.length - 1; i++) {for (int j = 0; j < students.length - 1 - i; j++) {if (students[j].score > students[j + 1].score) {// 注意！！！ 此处交换的为对象，而不是对象的成绩Student temp = students[j];students[j] = students[j + 1];students[j + 1] = temp;}}}for (int i = 0; i < students.length; i++) {System.out.println(students[i].show());}//System.out.println(Arrays.toString());//System.out.println(Arrays.toString(student));}
}

18、题目：递归函数应用

要求：利用递归函数实现

public class RecursionTest {public static void main(String[] args) {RecursionTest rt = new RecursionTest();// 1-100的和System.out.println(rt.getSum(100));  // 5050// 10！System.out.println(rt.getFactorial(10)); // 3628800// 斐波那契数列 第10个数为多少System.out.println(rt.f(10)); // 55System.out.println(rt.f2(10)); // -3771System.out.println(rt.f3(10)); // 89}/** 举例1；计算1-100内自然数的总和** */public int getSum(int num) {if (num == 1) {return 1;}return num + getSum(num - 1);}/** 举例2：计算n的阶乘** */public int getFactorial(int num) {if (num == 1) {return 1;}return num * getFactorial(num - 1);}/** 举例3：斐波那契数列* 1 1 2 3 5 8 13 21* 从第三个开始，第三个数 = 第一个数+第二个数** */public int f(int n) {if (n == 1) {return 1;} else if (n == 2) {return 1;} else {return f(n - 1) + f(n - 2);}}/** 举例4：已知一个数列：f(20) = 1, f(21) = 4, f(n+2) = 2*f(n+1)+f(n)* 其中n是大于0的整数，求f(10)的值。** */public int f2(int n) {if (n == 20) {return 1;} else if (n == 21) {return 4;} else {return f2(n + 2) - 2 * f2(n + 1); // 注意方程式要朝着已知的方向去推断}}/** 举例5：已知一个数列：f(0) = 1, f(1) = 4, f(n+2) = 2*f(n+1)+f(n)* 其中n是大于0的整数，求f(10)的值。** */public int f3(int n) {if (n == 0) {return 1;} else if (n == 1) {return 4;} else {return 2 * f(n - 1) + f(n - 2); // 注意方程式要朝着已知的方向去推断}}
}

19、题目：不死神兔

案例:不死神兔
用递归实现不死神兔:故事得从西元1202年说起，话说有一位意大利青年，名叫斐波那契(Fibonacci)。
在他的一部著作中提出了一个有趣的问题:假设一对刚出生的小兔一个月后就能长成大兔，
再过一个月就能生下一对小兔，并且此后每个月都生一对小兔，没有发生死亡，
问:现有一对刚出生的兔子2年后(24个月)会有多少对兔子?

package com.study.field.Exer06;/*** ClassName: RabbitExer* Package: com.study.field.Exer06* Description:* 案例:不死神兔* 用递归实现不死神兔:故事得从西元1202年说起，话说有一位意大利青年，名叫斐波那契(Fibonacci)。* 在他的一部著作中提出了一个有趣的问题:假设一对刚出生的小兔一个月后就能长成大兔，* 再过一个月就能生下一对小兔，并且此后每个月都生一对小兔，没有发生死亡，* 问:现有一对刚出生的兔子2年后(24个月)会有多少对兔子?* 
* 推断：* 月份         1   2   3   4     5* 兔子(对)数    1   1   2   3     5* * 可以发现本质就是斐波那契数列！！！* * @Author ShiQiFei* @Create 2023/6/12 21:21* @Version 1.0*/
public class RabbitExer {public static void main(String[] args) {RabbitExer rabbit = new RabbitExer();int month = 24;System.out.println("兔子的对数为："+rabbit.getRabbitNumber(month));}public int getRabbitNumber(int month) {if (month == 1) {return 1;} else if (month == 2) {return 1;}return getRabbitNumber(month - 1) + getRabbitNumber(month - 2);}}

拓展：走台阶问题
假如有10阶台阶，小朋友每次只能向上走1阶或者2阶，请问有几种走法？

推断：
阶数 1 2 3 4 ……
走法 1 2 3 5 ……
从n为3开始：
f（n）= f（n-1）+f（n-2）

【奇妙的属性】随着数列的增加，斐波那契数列前一个数与后一个数的比值越来越逼近黄金分割比例0.618。

21、题目：

22、题目：

待更新！！！！！

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！