package cn.temptation;
import java.util.Scanner;
public class Sample01 {
public static void main(String[] args) {
// 需求：定义一个数组存储星期一、星期二、...星期日，打印该数组形式为[星期一, 星期二, ...星期日]，根据用户输入的数字（1~7），显示是星期几？
// 写法一、考虑使用字符串类型的数组
// // 1、创建一个数组来存储星期一、星期二、...星期日
// String[] weekDayArr = { "星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"};
// printArray(weekDayArr);
//
// // 2、接收键盘录入
// System.out.println("输入一个数字就可以找到对应是星期几：");
// Scanner input = new Scanner(System.in);
// int weekDay = input.nextInt();
// input.close();
//
// // 3、判断输入的数字和数组中某个元素的索引之间的关系
// if (weekDay >= 1 && weekDay <= 7) {
// System.out.println("选择的是：" + weekDayArr[weekDay - 1]);
// } else {
// System.out.println("输入的数字不在范围内！");
// }
// 写法二、考虑使用int类型的数组
// 1、创建一个数组来存储星期一、星期二、...星期日
int[] weekDayArr = { 1, 2, 3, 4, 5, 6, 7 };
printArray(weekDayArr);
// 2、接收键盘录入
System.out.println("输入一个数字就可以找到对应是星期几：");
Scanner input = new Scanner(System.in);
int weekDay = input.nextInt();
input.close();
// 3、判断输入的数字和数组中某个元素的索引之间的关系
if (weekDay >= 1 && weekDay <= 7) {
System.out.println("选择的是：" + convertNumberToString(weekDayArr[weekDay - 1]));
} else {
System.out.println("输入的数字不在范围内！");
}
}
/**
* 打印数组
* @param arr：字符串数组
*/
public static void printArray(String[] arr) {
System.out.print("[");
// 遍历数组
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
System.out.print(arr[i] + "]");
} else {
System.out.print(arr[i] + ",");
}
}
// 换行
System.out.println();
}
/**
* 打印数组（重载方法）
* @param arr：int数组
*/
public static void printArray(int[] arr) {
System.out.print("[");
// 遍历数组
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
System.out.print(arr[i] + "]");
} else {
System.out.print(arr[i] + ",");
}
}
// 换行
System.out.println();
}
/**
* 数字转换为星期字符串的方法
* @param i：数字
* @return：星期字符串
*/
public static String convertNumberToString(int i) {
String result = "";
switch (i) {
case 1:
result = "星期一";
break;
case 2:
result = "星期二";
break;
case 3:
result = "星期三";
break;
case 4:
result = "星期四";
break;
case 5:
result = "星期五";
break;
case 6:
result = "星期六";
break;
case 7:
result = "星期日";
break;
default:
result = "输入错误！";
break;
}
return result;
}
}
package cn.temptation;
public class Sample02 {
public static void main(String[] args) {
// 需求：给定一个int类型的数组，实现如下功能：将数组反转，比如：{1, 2, 3} -----> {3, 2, 1}, {1, 2, 3, 4} -----> {4, 3, 2, 1}
// 思路：
// 1、可能有两种情况，一种数组的长度为奇数，一种数组的长度为偶数
// 2、如果长度为奇数，中间那个元素不动，第一个元素和最后一个元素对调，第二个元素和倒数第二个元素对调，...，
// 中间那个元素的前一个元素和中间那个元素的后一个元素对调
// 3、如果长度为偶数，第一个元素和最后一个元素对调，第二个元素和倒数第二个元素对调，...，
// 中间位置的前一个元素和中间位置的后一个元素对调
int[] arr1 = { 1, 2, 3 };
System.out.println("反转前的数组：");
printArray(arr1);
// 调用方法
// reversalArray1(arr1);
reversalArray2(arr1);
System.out.println("反转后的数组：");
printArray(arr1);
System.out.println("------------------------------");
int[] arr2 = { 1, 2, 3, 4 };
System.out.println("反转前的数组：");
printArray(arr2);
// reversalArray2(arr2);
reversalArray1(arr2);
System.out.println("反转后的数组：");
printArray(arr2);
// 注意：
// 1、代码写完后，自己再考虑一下，不要抱着糊完任务的心态
// 2、思考问题的时候是区分了数组为奇数长度和偶数长度的，在编写代码时，发现对于奇数长度，因为其中间元素不参与反转，相当于反转时把中间元素拿掉
// 即其操作次数：(数组长度 - 1) / 2， 和 偶数长度数组的操作次数是一致的
}
/**
* 打印数组
* @param arr：int数组
*/
public static void printArray(int[] arr) {
System.out.print("[");
// 遍历数组
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
System.out.print(arr[i] + "]");
} else {
System.out.print(arr[i] + ",");
}
}
// 换行
System.out.println();
}
/**
* 奇数长度的数组反转（因为后续的显示操作也是使用堆内存中的内容，所以该方法使用void：无返回即可）
* @param arr
*/
public static void reversalArray1(int[] arr) {
// 下面写法逻辑错误，这样会对调两次，等于没有对调
// for (int i = 0, j = arr.length - 1; i < arr.length; i++, j--) {
for (int i = 0, j = arr.length - 1; i < arr.length / 2; i++, j--) {
// 对调：第一个元素和最后一个元素对调，第二个元素和倒数第二个元素对调，...，
// 中间那个元素的前一个元素和中间那个元素的后一个元素对调
// 定义临时变量接收
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
/**
* 偶数长度的数组反转（因为后续的显示操作也是使用堆内存中的内容，所以该方法使用void：无返回即可）
* @param arr
*/
public static void reversalArray2(int[] arr) {
for (int i = 0; i < arr.length / 2; i++) {
// 对调：第一个元素和最后一个元素对调，第二个元素和倒数第二个元素对调，...，
// 中间位置的前一个元素和中间位置的后一个元素对调
// 定义临时变量接收
int temp = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = temp;
}
}
}
package cn.temptation;
public class Sample03 {
public static void main(String[] args) {
int[] arr = { 10, 20, 30 };
System.out.println(arr); // [I@15db9742
System.out.println(arr[0]); //
arr = null;
// 产生异常：java.lang.NullPointerException 空指针异常
// 有警告：Null pointer access: The variable arr can only be null at this location
// System.out.println(arr[0]);
// 产生异常：java.lang.NullPointerException 空指针异常
// 有警告：Null pointer access: The variable arr can only be null at this location
// System.out.println(arr.length);
// 下句语句执行时无异常
System.out.println(arr); // null
// 注意：
// 1、设置引用类型变量的值为null，其实就是让其栈中声明的引用类型变量 与 在堆中开辟的空间之间的联系断开
// 2、堆中原来开辟的空间并不会立即消失
// null是一个特殊值，类比boolean类型的特殊值true 和 false
// null表示的是引用数据类型的空值，引用数据类型的默认值是null
// 如下两种写法意义相同
// int[] arrExtend;
// int[] arrExtend = null;
// null不能用于给基本数据类型（值类型）赋值，null只能用于引用数据类型
// 语法错误：Type mismatch: cannot convert from null to int
// int i = null;
}
}
package cn.temptation;
public class Sample04 {
public static void main(String[] args) {
// int[] arr = { 1, 2, 3 };
// printArray(arr);
// 匿名数组：没有显示定义数组名的数组
// 这里匿名数组使用new关键字直接在内存的堆中开辟元素个数长度的空间，并存储这些元素，然后作为实参传递给方法的形参供方法使用
// printArray(new int[] { 1, 2, 3 });
// 匿名数组的优点：直接new出来使用，不用再做声明
// 匿名数组的缺点：只能使用一次（因为没有声明数组变量，一次使用完毕后就找不到了）
// 注意：匿名数组定义时，不能使用静态初始化的简写形式，语法出错
// 语法错误：Syntax error on token "printArray", @ expected before this token
// printArray({ 4, 5, 6 });
// 注意：匿名数组定义时，可以使用动态初始化的形式，但是这样定义后，无法进行元素的填充
printArray(new int[3]);
}
/**
* 打印数组
* @param arr：int数组
*/
public static void printArray(int[] arr) {
System.out.print("[");
// 遍历数组
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
System.out.print(arr[i] + "]");
} else {
System.out.print(arr[i] + ",");
}
}
// 换行
System.out.println();
}
}
package cn.temptation;
public class Sample05 {
public static void main(String[] args) {
// 给方法传递值类型参数 和 给方法传递引用数据类型参数
int i = 1;
System.out.println(i); // 1
// 调用方法
show(i); //
System.out.println(i); //
System.out.println("------------------------------");
int[] arr = { 1, 2, 3 };
printArray(arr); // [1,2,3]
// 调用方法
show(arr); // [3,4,5]
printArray(arr); // [3,4,5]
}
// 方法接收的是值类型的参数
// i为形参，它接受show方法调用时传递过来的实参
// show方法中使用的i叫做局部变量，声明该局部变量的地方是形参定义的地方，也是它的作用域开始的地方，作用域结束的地方是show方法右侧的大括号
public static void show(int i) {
i += 2;
System.out.println("方法内的参数值为：" + i);
}
// 方法接收的是引用类型的参数
// 传递引用类型的参数，其实传递的是堆内存中开辟的空间的地址（也就是所谓的把引用传递了过去）
public static void show(int[] arr) {
// 遍历数组
for (int i = 0; i < arr.length; i++) {
arr[i] += 2;
}
// 打印数组
printArray(arr);
}
/**
* 打印数组
* @param arr：int数组
*/
public static void printArray(int[] arr) {
System.out.print("[");
// 遍历数组
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
System.out.print(arr[i] + "]");
} else {
System.out.print(arr[i] + ",");
}
}
// 换行
System.out.println();
}
}
package cn.temptation;
public class Sample06 {
public static void main(String[] args) {
// 可变长参数：Java中当作数组处理
// 可变长参数一般出现在方法的形参中
// 调用方法
show(1, new double[] { 2, 3, 4 });
double[] arr = { 5, 6, 7 };
show(9, arr);
}
// 正确形式使用可变长参数
public static void show(int i, double... ds) {
System.out.println(i); //
System.out.println(ds); // [D@15db9742
System.out.println(ds.length); // 3
// 遍历
for (double item : ds) {
System.out.println(item);
}
}
// 注意：一个方法只能有一个可变长参数，且必须位于参数列表的最后位置
// 语法错误：The variable argument type double of the method test must be the last parameter
// public static void test(int i, double... ds, char... ch) {
// // 想创建多个可变长参数的方法
// }
// 语法错误：The variable argument type double of the method test must be the last parameter
// public static void test(int i, double... ds, boolean flag) {
// // 想创建可变长参数不在最后位置的方法
// }
}
package cn.temptation;
public class Sample07 {
public static void main(String[] args) {
// 排序
// 冒泡排序（两两位置比较，每轮最大数字出现在右侧，依次向左）
// 思路：
// 1、第一轮，比较第1个位置和第2个位置上的数，将较小的数放在第1个位置上，较大的数放在第2个位置上
// 比较第2个位置和第3个位置上的数，将较小的数放在第2个位置上，较大的数放在第3个位置上
// 以此类推直到第一轮结束（最后一个位置不用参与比较，因为它的右侧没有位置了）,最大的数字在最右侧
// 2、第二轮，还是比较第1个位置和第2个位置上的数，将较小的数放在第1个位置上，较大的数放在第2个位置上
// 比较第2个位置和第3个位置上的数，将较小的数放在第2个位置上，较大的数放在第3个位置上
// 以此类推直到第二轮结束（倒数第二个位置不用参与比较，因为它的右侧已经是最大的数了），第二大的数字在倒数第二个
// 3、后续的轮以此类推
int[] arr = { 2, 1, 0, 4, 3 };
System.out.println("排序前：");
printArray(arr);
// 冒泡排序算法
for (int i = 0; i < arr.length - 1; i++) { // 外层循环的轮数是数组长度 - 1，i表示的是当前为第几轮
for (int j = 0; j < arr.length - 1 - i; j++) { // j表示的当前轮中的位置
// 相邻的两个位置上的数做比较
if (arr[j] > arr[j + 1]) {
// 对调
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
// 可以使用打印数组的方法查看当轮排序结果
printArray(arr);
}
System.out.println("排序后：");
printArray(arr);
}
/**
* 打印数组
* @param arr：int数组
*/
public static void printArray(int[] arr) {
System.out.print("[");
// 遍历数组
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
System.out.print(arr[i] + "]");
} else {
System.out.print(arr[i] + ",");
}
}
// 换行
System.out.println();
}
}
package cn.temptation;
public class Sample08 {
public static void main(String[] args) {
// 排序
// 选择排序
// 思路：
// 1、第一轮，把在第一个位置上的元素依次和后续位置上的元素进行比较，如果被比较的元素比第一个位置上的元素小，就对调，直到比较到最后一个位置上的元素
// 第一轮操作完成后，在第一个位置上得到最小的那个元素
// 2、第二轮，把在第二个位置上的元素依次和后续位置上的元素进行比较，如果被比较的元素比第二个位置上的元素小，就对调，直到比较到最后一个位置上的元素
// 第二轮操作完成后，在第二个位置上得到次小的那个元素
// 3、以此类推
int[] arr = { 2, 1, 0, 4, 3 };
System.out.println("排序前：");
printArray(arr);
// 选择排序算法
for (int i = 0; i < arr.length - 1; i++) { // 外层循环的i既表示轮数，又表示比较的位置
// 第一轮，把在第一个位置上的元素依次和后续位置上的元素进行比较，如果被比较的元素比第一个位置上的元素小，就对调，直到比较到最后一个位置上的元素
// if (arr[0] > arr[1]) {
// // 对调
// int temp = arr[0];
// arr[0] = arr[1];
// arr[1] = temp;
// }
// if (arr[0] > arr[2]) {
// // 对调
// int temp = arr[0];
// arr[0] = arr[2];
// arr[2] = temp;
// }
// 归纳上述语句，可以得到规律
for (int j = i + 1; j < arr.length; j++) { // 内层循环的j表示其他被比较的位置
if (arr[i] > arr[j]) {
// 对调
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
// 可以使用打印数组的方法查看当轮排序结果
printArray(arr);
}
System.out.println("排序后：");
printArray(arr);
}
/**
* 打印数组
* @param arr：int数组
*/
public static void printArray(int[] arr) {
System.out.print("[");
// 遍历数组
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
System.out.print(arr[i] + "]");
} else {
System.out.print(arr[i] + ",");
}
}
// 换行
System.out.println();
}
}
package cn.temptation;
public class Sample09 {
public static void main(String[] args) {
// 排序
// 插入排序
// 思路：
// 1、第一轮，从第2个位置开始，和其左侧的紧靠着它的位置的数（第1个位置上的数）进行比较，小的数放前面，大的数放后面
// 2、第二轮，从第3个位置开始，和其左侧的紧靠着它的位置的数（第2个位置上的数）进行比较，小的数放前面，大的数放后面
// 再看第2个位置，和其左侧的紧靠着它的位置的数（第1个位置上的数）进行比较，小的数放前面，大的数放后面
// 3、第三轮，从第4个位置开始，和其左侧的紧靠着它的位置的数（第3个位置上的数）进行比较，小的数放前面，大的数放后面
// 再看第3个位置，和其左侧的紧靠着它的位置的数（第2个位置上的数）进行比较，小的数放前面，大的数放后面
// 再看第2个位置，和其左侧的紧靠着它的位置的数（第1个位置上的数）进行比较，小的数放前面，大的数放后面
// 4、以此类推
int[] arr = { 2, 1, 0, 4, 3 };
System.out.println("排序前：");
printArray(arr);
// 插入排序算法
for (int i = 1; i < arr.length; i++) { // 外层循环的i既表示轮数，又表示位置
// // 第一轮操作
// if (arr[0] > arr[1]) {
// // 对调
// int temp = arr[0];
// arr[0] = arr[1];
// arr[1] = temp;
// }
//
// // 第二轮操作
// if (arr[1] > arr[2]) {
// // 对调
// int temp = arr[1];
// arr[1] = arr[2];
// arr[2] = temp;
// }
// if (arr[0] > arr[1]) {
// // 对调
// int temp = arr[0];
// arr[0] = arr[1];
// arr[1] = temp;
// }
// 归纳上述操作，得到规律
// 写法一
for (int j = i; j > 0; j--) { // 内层循环的j表示当前的这个位置
if (arr[j] < arr[j - 1]) { // // 内层循环的当前的这个位置上的数 和 其左侧紧靠着它的位置上的数进行比较
// 对调
int temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
}
}
// 写法二
// for (int j = 0; j < i; j++) { // 内层循环的j表示从第1个位置开始配合进行比较
// if (arr[j] > arr[i]) {
// // 对调
// int temp = arr[i];
// arr[i] = arr[j];
// arr[j] = temp;
// }
// }
}
System.out.println("排序后：");
printArray(arr);
}
/**
* 打印数组
* @param arr：int数组
*/
public static void printArray(int[] arr) {
System.out.print("[");
// 遍历数组
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
System.out.print(arr[i] + "]");
} else {
System.out.print(arr[i] + ",");
}
}
// 换行
System.out.println();
}
}
package cn.temptation;
import java.util.Arrays;
public class Sample10 {
public static void main(String[] args) {
// 初始化数组
int[] arr = { 2, 1, 0, 4, 3 };
System.out.println("排序前：");
printArray(arr);
// 可以调用Arrays类的sort方法进行排序
// 类 Arrays：此类包含用来操作数组（比如排序和搜索）的各种方法。
// 常用的成员方法：
// static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。
Arrays.sort(arr);
System.out.println("排序后：");
printArray(arr);
}
/**
* 打印数组
* @param arr：int数组
*/
public static void printArray(int[] arr) {
System.out.print("[");
// 遍历数组
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
System.out.print(arr[i] + "]");
} else {
System.out.print(arr[i] + ",");
}
}
// 换行
System.out.println();
}
}
