1.说一说函数的按地址传递和按值传递，他们的区别是什么？

函数的参数传递方式可以分为按地址传递（也称为按引用传递）和按值传递两种方式。按值传递是指将实际参数的值复制给形式参数，即在函数调用时，实际参数的值被复制到函数的形式参数中。在函数内部对形式参数的修改不会影响到实际参数的值。按地址传递是指将实际参数的地址（指针）传递给形式参数，即在函数调用时，实际参数的地址被传递给函数的形式参数。在函数内部对形式参数的修改会影响到实际参数的值。区别如下：
1. 按值传递是将实际参数的值复制给形式参数，而按地址传递是将实际参数的地址传递给形式参数。
2. 按值传递不会改变实际参数的值，而按地址传递会改变实际参数的值。
3. 按值传递适用于基本数据类型，如int、float等，而按地址传递适用于引用类型，如数组、对象等。
4. 按值传递在函数调用时会产生额外的内存开销，因为需要复制实际参数的值，而按地址传递则不需要复制实际参数的值，只需要传递地址。需要注意的是，在Java中，所有的参数传递都是按值传递，即无论是基本数据类型还是引用类型，都是将实际参数的值复制给形式参数。但对于引用类型，复制的是对象的引用（地址），因此在函数内部可以修改对象的属性，但不能修改对象的引用。

2.如何获取数组中元素的个数

int[] array = {1, 2, 3, 4, 5};
int length = array.length;
System.out.println("数组中元素的个数为：" + length);

3.从内存的角度说一说什么是数组？

从内存的角度来说，数组是一段连续的内存空间，用于存储相同类型的多个元素。数组中的每个元素占据相同大小的内存空间，并按照顺序排列。在内存中，数组的元素可以通过索引来访问。索引是一个整数值，用于表示数组中元素的位置。数组的第一个元素的索引通常为0，第二个元素的索引为1，以此类推。当创建一个数组时，内存会分配足够的连续空间来存储数组的元素。数组的大小在创建时固定，无法动态改变。每个元素占据的内存空间取决于数组元素的类型，例如，一个int类型的数组中的每个元素通常占据4个字节的内存空间。通过索引，我们可以直接访问数组中的元素，而不需要遍历整个数组。这是因为数组的内存空间是连续的，通过索引可以计算出元素的内存地址，从而快速访问到指定位置的元素。需要注意的是，数组的大小在创建时就确定了，无法动态增加或减少。

4.从数据类型的角度说一说什么是数组？

从数据类型的角度来说，数组是一种数据结构，用于存储相同类型的多个元素。它是一个固定大小的、连续的内存区域，用于存储一系列的元素。数组的元素可以是任意数据类型，包括基本数据类型和引用数据类型。在创建数组时，需要指定数组的类型和大小。数组的大小在创建时确定，并且无法动态改变。通过索引，可以访问数组中的元素。索引是一个整数值，用于表示数组中元素的位置。数组的第一个元素的索引通常为0，第二个元素的索引为1，以此类推。数组的好处是可以通过索引快速访问和修改元素，因为数组的内存空间是连续的。此外，数组还可以进行一些基本的操作，如添加、删除、排序等。总结起来，从数据类型的角度来说，数组是一种用于存储相同类型元素的固定大小、连续的数据结构。它通过索引来访问和操作元素，提供了快速的数据访问和处理能力。

5.说说你目前知道的异常有？什么情况下会产生这些异常？

在Java中，有许多异常类型，每个异常类型都代表了不同的错误或异常情况。以下是一些常见的异常类型和它们可能发生的情况：1. NullPointerException（空指针异常）：当尝试访问一个空对象的属性或调用一个空对象的方法时，会抛出该异常。2. ArrayIndexOutOfBoundsException（数组下标越界异常）：当尝试访问数组中不存在的索引位置时，会抛出该异常。3. ClassCastException（类转换异常）：当试图将一个对象强制转换为不兼容的类类型时，会抛出该异常。4. ArithmeticException（算术异常）：当进行非法的算术运算，如除以零时，会抛出该异常。5. FileNotFoundException（文件未找到异常）：当试图打开或读取一个不存在的文件时，会抛出该异常。6. IOException（输入输出异常）：当发生输入或输出操作失败时，会抛出该异常，如读写文件、网络通信等。7. IllegalArgumentException（非法参数异常）：当传递给方法的参数不符合方法的预期要求时，会抛出该异常。8. InterruptedException（中断异常）：当一个线程在等待、休眠或阻塞状态时，被其他线程中断时，会抛出该异常。9. NumberFormatException(字符串解析异常) : 在Java中，如果需要将字符串转换为整数、浮点数等基本数据类型，可以使用相应的包装类提供的静态方法进行转换。如果字符串无法解析为相应的数据类型，这些方法会抛出NumberFormatException异常。这些异常是Java中常见的一些异常类型，它们代表了不同的错误或异常情况。在编写代码时，应该注意捕获和处理这些异常，以保证程序的稳定性和健壮性。

6.思考：不定义第三个变量的情况下，如何交换两个变量的值？

package _09182023.homework_06;/**** 不定义第三个变量的情况下，如何交换两个变量的值**/
public class _6 {public static void main(String[] args) {int a = 5;int b = 10;System.out.println("交换前：");System.out.println("a = " + a);System.out.println("b = " + b);a = a + b;b = a - b;a = a - b;System.out.println("交换后：");System.out.println("a = " + a);System.out.println("b = " + b);}}

7.编程：封装一个函数，任意输入一个数判断这个数是否是质数，如果是则返回true，不是在返回false

package _09182023.homework_06;/**** 封装一个函数，任意输入一个数判断这个数是否是质数，如果是则返回true，不是在返回false**/
public class _7 {public static void main(String[] args) {int num = 17;boolean isPrime = isPrimeNumber(num);System.out.println(num + " 是质数吗？ " + isPrime);}public static boolean isPrimeNumber(int num) {if (num <= 1) {return false;}for (int i = 2; i <= Math.sqrt(num); i++) {if (num % i == 0) {return false;}}return true;}}

8.编程：封装一个函数，对于区间[1,100]，输出这个区间内所有的质数

package _09182023.homework_06;/**** 封装一个函数，对于区间[1,100]，输出这个区间内所有的质数**/
public class _8 {public static void main(String[] args) {System.out.println("区间[1,100]内的质数有：");printPrimeNumbers(1, 100);}public static void printPrimeNumbers(int start, int end) {for (int num = start; num <= end; num++) {if (isPrimeNumber(num)) {System.out.print(num + " ");}}}public static boolean isPrimeNumber(int num) {if (num <= 1) {return false;}for (int i = 2; i <= Math.sqrt(num); i++) {if (num % i == 0) {return false;}}return true;}}

9.编程：封装一个函数，对于任意数组，将数组中的所有质数拼接成字符串形式[a,b,c]返回

package _09182023.homework_06;/**** 封装一个函数，对于任意数组，将数组中的所有质数拼接成字符串形式[a,b,c]返回**/
public class _9 {public static void main(String[] args) {int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};String primeNumbers = getPrimeNumbers(nums);System.out.println("数组中的质数为：" + primeNumbers);}public static String getPrimeNumbers(int[] nums) {StringBuilder sb = new StringBuilder();for (int num : nums) {if (isPrimeNumber(num)) {sb.append(num).append(",");}}if (sb.length() > 0) {sb.deleteCharAt(sb.length() - 1);}return "[" + sb.toString() + "]";}public static boolean isPrimeNumber(int num) {if (num <= 1) {return false;}for (int i = 2; i <= Math.sqrt(num); i++) {if (num % i == 0) {return false;}}return true;}}

10.分析并编程：自己准备数组画图分析冒泡排序算法的过程，并写出冒泡排序算法

冒泡排序算法是一种简单的排序算法，它的基本思想是将相邻的元素两两比较，如果前面的元素大于后面的元素，则交换它们的位置。通过一轮比较和交换，可以将最大的元素移动到数组的末尾。然后再对剩下的元素进行同样的操作，直到整个数组排序完成。下面是一个数组的冒泡排序过程的图示：原始数组：[5, 3, 8, 6, 4]第一轮排序：比较5和3，交换位置，比较5和8，不交换位置，比较8和6，交换位置，比较8和4，交换位置。此时数组变为：[3, 5, 6, 4, 8]第二轮排序：比较3和5，不交换位置，比较5和6，不交换位置，比较6和4，交换位置。此时数组变为：[3, 5, 4, 6, 8]第三轮排序：比较3和5，不交换位置，比较5和4，交换位置。此时数组变为：[3, 4, 5, 6, 8]第四轮排序：比较3和4，不交换位置。此时数组已经排好序，排序完成。通过上面的图示可以看出，在每一轮排序中，都会将当前未排序部分中最大的元素移动到末尾。因此，需要进行n-1轮排序，才能将整个数组排序完成。冒泡排序算法的时间复杂度为O(n^2)，其中n为数组的长度。

package _09182023.homework_06;/**** 冒泡排序**/import java.util.Scanner;public class _10 {public static void main(String[] args) {int[] target = { 5, 3, 8, 6, 4 };System.out.println( "原始数组为: " );for ( int v: target ) {System.out.print( v + "\t" );}bubbleSort( target );}/**** 冒泡排序* @param arr*/public static void bubbleSort(int[] arr) {int n = arr.length;// 需要进行n-1轮排序for (int i = 0; i < n-1; i++) {// 每一轮排序将最大的元素放到末尾for (int j = 0; j < n-i-1; j++) {if (arr[j] > arr[j+1]) {// 交换位置int temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}System.out.println( "\n" + "数组排序: " );for ( int v: arr ) {System.out.print( v + "\t" );}}}

11.分析并编程：自己准备数组画图分析选择排序算法的过程，并写出选择排序算法

选择排序算法是一种简单的排序算法，它的基本思想是每次从未排序部分选择最小（或最大）的元素，并将其放到已排序部分的末尾。通过不断选择最小（或最大）的元素，将数组逐步排好序。下面是一个数组的选择排序过程的图示：原始数组：[5, 3, 8, 6, 4]第一轮排序：找到最小的元素3，并将其与第一个元素交换位置。此时数组变为：[3, 5, 8, 6, 4]第二轮排序：在剩下的未排序部分中找到最小的元素4，并将其与第二个元素交换位置。此时数组变为：[3, 4, 8, 6, 5]第三轮排序：在剩下的未排序部分中找到最小的元素5，并将其与第三个元素交换位置。此时数组变为：[3, 4, 5, 6, 8]第四轮排序：在剩下的未排序部分中找到最小的元素6，并将其与第四个元素交换位置。此时数组变为：[3, 4, 5, 6, 8]经过n-1轮排序，整个数组排序完成。通过上面的图示可以看出，在每一轮排序中，都会从未排序部分选择最小的元素，并将其放到已排序部分的末尾。因此，需要进行n-1轮排序，才能将整个数组排序完成。选择排序算法的时间复杂度为O(n^2)，其中n为数组的长度。

package _09182023.homework_06;/**** 选择排序**/
public class _11 {public static void main(String[] args) {int[] arr = {5, 3, 8, 6, 4};System.out.println("原始数组: ");printArray(arr);selectionSort(arr);System.out.println("排序后数组: ");printArray(arr);}public static void selectionSort(int[] arr) {int n = arr.length;for (int i = 0; i < n-1; i++) {int minIndex = i;for (int j = i+1; j < n; j++) {if (arr[j] < arr[minIndex]) {minIndex = j;}}int temp = arr[minIndex];arr[minIndex] = arr[i];arr[i] = temp;System.out.println("第" + (i+1) + "轮排序后数组: ");printArray(arr);}}public static void printArray(int[] arr) {for (int num : arr) {System.out.print(num + " ");}System.out.println();}}

12.编程：封装一个函数，申明整型数组，存放用户循环输入的数据，首尾倒置输出。

package _09182023.homework_06;import java.util.Scanner;/**** 封装一个函数，申明整型数组，存放用户循环输入的数据，首尾倒置输出**/
public class _12 {public static void main(String[] args) {int[] nums = getUserInput();System.out.println("原始数组：");printArray(nums);reverseArray(nums);System.out.println("倒置数组：");printArray(nums);}public static int[] getUserInput() {Scanner scanner = new Scanner(System.in);System.out.print("请输入数组的长度：");int length = scanner.nextInt();int[] nums = new int[length];System.out.println("请输入数组的元素：");for (int i = 0; i < length; i++) {nums[i] = scanner.nextInt();}return nums;}public static void reverseArray(int[] nums) {int start = 0;int end = nums.length - 1;while (start < end) {int temp = nums[start];nums[start] = nums[end];nums[end] = temp;start++;end--;}}public static void printArray(int[] nums) {for (int num : nums) {System.out.print(num + " ");}System.out.println();}}

13.编程：申明浮点型数组，存放有序数据，让用户输入搜索数据，使用二分查询法查询用户输入的数据在索引为几的元素，或无此数据。

package _09182023.homework_06;import java.util.Scanner;/**** 申明浮点型数组，存放有序数据，让用户输入搜索数据，* 使用二分查询法查询用户输入的数据在索引为几的元素，或无此数据。**/
public class _13 {public static void main(String[] args) {double[] nums = {1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0, 10.1};System.out.print("请输入要搜索的数据：");Scanner scanner = new Scanner(System.in);double target = scanner.nextDouble();int index = binarySearch(nums, target);if (index != -1) {System.out.println("数据 " + target + " 在索引 " + index + " 的位置。");} else {System.out.println("无此数据。");}}public static int binarySearch(double[] nums, double target) {int left = 0;int right = nums.length - 1;while (left <= right) {int mid = (left + right) / 2;if (nums[mid] == target) {return mid;} else if (nums[mid] < target) {left = mid + 1;} else {right = mid - 1;}}return -1;}}