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;
}
}
![Nestjs与Vue实现多人聊天[简易版]](https://img-blog.csdnimg.cn/direct/fcde7eabc7c54616950045323e62ea30.jpeg)
