第五章
5.1 一维数组的基本使用
1.数组的声明和初始化
2.数组元素的调用
3.数组长度:用来描述数组容器中容量的大小
4.如何遍历数组
5.数组元素的默认初始化值
6.数组的内存解析
package com.one.atczy1;
/**
* ClassName: OneArrayText
* Package: atczy1.one
* Description:
* 一维数组的基本使用
*
* @Author Ziyun Chen
* @Create 2023/9/20 12:37
* @Version 1.0
*/
public class OneArrayText {
public static void main(String argc[])
{
// 1.数组的声明和初始化
// 复习：变量的定义格式： 变量类型 变量名 = 变量值
int num1 = 18;// 声明+初始化
int num2;// 声明
num2 = 20;// 初始化
// 1.1 声明数组
double[] prices;
// 1.2 数组的初始化
// 静态初始化
prices = new double[]{20.32, 43.21, 43.22};
// 数组的声明和初始化
// 动态初始化：数组变量的赋值和数组元素的赋值操作分开进行
String[] foods = new String[2];
// 其他正确方式
int[] arr = new int[4];
int[] arr1 = {1, 2, 3, 4};// 类型推断
// 2.数组元素的调用
// 通过角标的方式，获取数组元素
// 角标范围：0~length-1
System.out.println(prices[0]);
System.out.println(prices[1]);
System.out.println(prices[2]);
// System.out.println(prices[3]);// 报异常：ArrayIndexOutOfBoundsException
foods[0] = "拌海蜇";
foods[1] = "龙须菜";
// foods[2] = "玉兰片"; // 报异常：ArrayIndexOutOfBoundsException
// 3.数组长度:用来描述数组容器中容量的大小
// 用length属性表示
System.out.println(foods.length);// 2
System.out.println(prices.length);// 3
// 4.如何遍历数组
for (int i = 0; i < foods.length; ++i)
{
System.out.println(foods[i]);
}
}
}
package com.one.atczy1;
/**
* ClassName: OneArrayText1
* Package: atczy1.one
* Description:
* 一维数组的基本使用
* @Author Ziyun Chen
* @Create 2023/9/21 19:16
* @Version 1.0
*/
public class OneArrayText1 {
public static void main(String[] args){
// 5.数组元素的默认初始化值
// 整数类型的默认初始值 0 and 0.0
int[] arr1 = new int[4];
System.out.println(arr1[0]);// 0
float[] arr2 = new float[4];
System.out.println(arr2[1]);// 0.0
byte[] arr3 = new byte[4];
System.out.println(arr3[1]);// 0
// 字符类型数组元素的默认初始值：0 \u0000
char[] arr4 = new char[4];
System.out.println(arr4[1]);
if (arr4[1] == 0)
System.out.println("arr4[1] == 0");
if (arr4[1] == '0')
System.out.println("arr4[1] == '0'");
if (arr4[1] == '\u0000')
System.out.println("arr4[1] == '\\u0000'");
// boolean类型数组元素的默认值为false
boolean[] arr5 = new boolean[4];
System.out.println(arr5[0]);
// 引用数据类型数组元素默认值：null or “null”
String[] arr6 = new String[4];
System.out.println(arr6[0]);// null
System.out.println(arr6[0] == null);// true
System.out.println(arr6[0] == "null");// false
// 6.数组的内存解析
int[] a1 = new int[]{1,2,3};
int[] a2 = a1;
a2[1] = 10;
System.out.println(a1[1]);
System.out.println(a1 == a2);
System.out.println(a1);
}
}
练习一：破解房东电话
* 升景坊单间短期出租4个月，550元/月（水电煤公摊，网费35元/月），空调、卫生间、厨房齐全。屋内均是IT行业人士，喜欢安静。
* 所以要求来租者最好是同行或者刚毕业的年轻人，爱干净、安静。
package com.one.atczy1.exer3.exer2.exer1;
/**
* ClassName: ArrayExer
* Package: exer1
* Description:
* 破解房东电话
* 升景坊单间短期出租4个月，550元/月（水电煤公摊，网费35元/月），空调、卫生间、厨房齐全。屋内均是IT行业人士，喜欢安静。
* 所以要求来租者最好是同行或者刚毕业的年轻人，爱干净、安静。
* @Author Ziyun Chen
* @Create 2023/9/21 20:10
* @Version 1.0
*/
public class ArrayExer {
public static void main(String[] argc){
int[] arr = new int[]{8,2, 1, 0, 3};
int[] index = new int[]{2,0,3,2,4,0,1,3,2,3,3};
String tel = "";
for (int i = 0; i < index.length; ++i)
{
int value = index[i];
tel += arr[value];
}
System.out.println(tel);// 18013820100
}
}
练习二：
输出英文星期几 用一个数组，保存星期一到星期天的7个英语单词，从键盘输入1-7，显示对应的单词 {"Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"}
package com.one.atczy1.exer3.exer2;
import java.util.Scanner;
/**
* ClassName: ArrExer02
* Package: atczy1.one.exer2
* Description:
* 输出英文星期几
* 用一个数组，保存星期一到星期天的7个英语单词，从键盘输入1-7，显示对应的单词
* {"Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"}
* @Author Ziyun Chen
* @Create 2023/9/21 20:21
* @Version 1.0
*/
public class ArrExer02 {
public static void main(String[] argc){
// 从键盘获取指定的数值，使用Scanner
Scanner scanner = new Scanner(System.in);
int index = scanner.nextInt();
// 定义包含7个单词的数组
String[] arr = new String[]{"Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"};
System.out.println(arr[index]);
scanner.close();
}
}
练习三：
从键盘读入学生成绩，找出最高分，并输出学生成绩等级。 - 成绩>=最高分-10 等级为’A’ - 成绩>=最高分-20 等级为’B’ - 成绩>=最高分-30 等级为’C’ - 其余 等级为’D’ 提示：先读入学生人数，根据人数创建int数组，存放学生成绩。
package com.one.atczy1.exer3;
import java.util.Scanner;
/**
* ClassName: ArrExer03
* Package: atczy1.one.exer3
* Description:
* ：从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
* - 成绩>=最高分-10 等级为’A’
* - 成绩>=最高分-20 等级为’B’
* - 成绩>=最高分-30 等级为’C’
* - 其余 等级为’D’
* 提示：先读入学生人数，根据人数创建int数组，存放学生成绩。
* @Author Ziyun Chen
* @Create 2023/9/21 20:29
* @Version 1.0
*/
public class ArrExer03 {
public static void main(String[] argc){
// 1.从键盘获取数值
Scanner scan = new Scanner(System.in);
System.out.println("请输入学生人数：");
int nums = scan.nextInt();
// 2.获取学生成绩元素 +++ 3.寻找最大值
int[] student = new int[nums];
System.out.println("请输入" + nums + "个成绩");
int max = student[0];// 最大值
for (int i = 0; i < student.length; ++i){
student[i] = scan.nextInt();
max = max>student[i] ? max : student[i];
}
System.out.println("最高分为：" + max);
// 4.输出等级
for (int i = 0; i < student.length; ++i){
System.out.print("Student " + (i+1) + " score is " + student[i] + " grade is ");
switch ((max-student[i])/10){
case 0:
System.out.println("A");break;
case 1:
System.out.println("B");break;
case 2:
System.out.println("C");break;
default:
System.out.println("D");
}
}
scan.close();
}
}
5.2 二维数组的基本使用
1.数组元素的初始化
2.数组元素的调用
3.数组的长度
4.如何遍历数组
5.数组元素的默认初始值
6.二维数组的内存解析
package atczy2.two;
/**
* ClassName: TwoArrayTest
* Package: atczy2.two
* Description:
* 二维数组的基本使用
* @Author Ziyun Chen
* @Create 2023/9/22 14:37
* @Version 1.0
*/
public class TwoArrayTest {
public static void main(String[] argc){
// 1.数组元素的初始化
// 一维数组
int[] arr1 = new int[4];
// 二维数组
// 方式1：静态初始化：数组变量的赋值和数组元素的赋值同时进行
int[][] arr2 = new int[][]{{1,2}, {2,3,4}, {4,5,6}};
// 方式2：动态初始化1：数组变量的赋值和数组元素的赋值分开进行
String[][] arr3 = new String[3][4];
// 方式2：动态初始化2
double[][] arr4 = new double[4][];
// 其他正确的写法
int arr5[][] = new int[][]{{1,2,3},{2,3,4}};
int[] arr6[] = new int[2][3];
int[][] arr7 = {{1,3,4},{4,5,6}};// 类型推断
String arr8[][] = new String[3][4];
// 2.数组元素的调用
// 针对arr2来说，外层元素{1,2}，{2,3,4}，{4,5,6} 内层元素：1,2,2,3,4,4,5,6
// 调用内层元素
System.out.println(arr2[0][0]);
System.out.println(arr2[1][1]);
// 调用外层元素
System.out.println(arr2[0]);//[I@776ec8df
// 测试arr3，arr4
arr3[0][1] = "czy";
System.out.println(arr3[0][1]);
System.out.println(arr3[0]);
arr4[0] = new double[4];
arr4[0][1] = 1.0;
// 3.数组的长度
System.out.println(arr2.length);// 3
System.out.println(arr2[0].length);// 2
System.out.println(arr2[1].length);// 3
System.out.println(arr2[2].length);// 3
// 4.如何遍历数组
for (int i = 0; i < arr2.length; ++i)
{
for (int j = 0; j < arr2[i].length;++j)
System.out.print(arr2[i][j] + "\t");
System.out.println();
}
}
}
练习一：
获取arr数组中所有元素的和。
package atczy2.two.exer1;
/**
* ClassName: TwoArrayExer01
* Package: atczy2.two.exer1
* Description:
* 获取arr数组中所有元素的和。
* @Author Ziyun Chen
* @Create 2023/9/22 18:25
* @Version 1.0
*/
public class TwoArrayExer01 {
public static void main(String[] argc){
// 1.构造二维数组 ---> 静态初始化，不建议使用动态初始化
int[][] arr = new int[][] {{3,5,8}, {12,9}, {7,0,6,4}};
// 2.遍历数组，将数组元素相加
int sum = 0;// 记录总和
for (int i = 0; i < arr.length; ++i){
for (int j = 0; j < arr[i].length; ++j){
sum += arr[i][j];
}
}
System.out.println("数组各元素之和为： " + sum);
}
}
练习二：
声明：int[] x,y[]; 在给x,y变量赋值以后，以下选项允许通过编译的是： a) x[0] = y; //no b) y[0] = x; //yes c) y[0][0] = x; //no d) x[0][0] = y; //no e) y[0][0] = x[0]; //yes f) x = y; //no 提示： 一维数组：int[] x 或者int x[] 二维数组：int[][] y 或者 int[] y[] 或者 int y[][]
package atczy2.two.exer2;
/**
* ClassName: TwoArrayExer
* Package: atczy2.two.exer2
* Description:
* 声明：int[] x,y[]; 在给x,y变量赋值以后，以下选项允许通过编译的是：
* a) x[0] = y; //no
* b) y[0] = x; //yes
* c) y[0][0] = x; //no
* d) x[0][0] = y; //no
* e) y[0][0] = x[0]; //yes
* f) x = y; //no
*
* 提示：
* 一维数组：int[] x 或者int x[]
* 二维数组：int[][] y 或者 int[] y[] 或者 int y[][]
*
* @Author Ziyun Chen
* @Create 2023/9/22 18:32
* @Version 1.0
*/
public class TwoArrayExer {
}
练习三：
使用二维数组打印一个 10 行杨辉三角。 提示： 1. 第一行有 1 个元素, 第 n 行有 n 个元素 2. 每一行的第一个元素和最后一个元素都是 1 3. 从第三行开始, 对于非第一个元素和最后一个元素的元素。即： yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
package atczy2.two.exer3;
/**
* ClassName: TwoArrayExer1
* Package: atczy2.two.exer3
* Description:
* 使用二维数组打印一个 10 行杨辉三角。
* 提示：
* 1. 第一行有 1 个元素, 第 n 行有 n 个元素
* 2. 每一行的第一个元素和最后一个元素都是 1
* 3. 从第三行开始, 对于非第一个元素和最后一个元素的元素。即：
* yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
* @Author Ziyun Chen
* @Create 2023/9/22 18:43
* @Version 1.0
*/
public class TwoArrayExer1 {
public static void main(String[] argc){
// 1.初始化数组10*10
int[][] yanghui = new int[10][10];
// 2.给数组元素进行赋值 ---》 遍历数组 + 并打印输出
for (int i = 0; i < yanghui.length; ++i){
for (int j = 0; j <= i; ++j){
if (j == 0 || i == j){
// 2.1 判断是否j=0 | i = j,对其赋值为1
yanghui[i][j] = 1;
}else{
// 2.2 为其他元素进行赋值 yanghui[i][j] = yanghui[i-1][j-1]+yanghui[i-1][j]
yanghui[i][j] = yanghui[i-1][j-1]+yanghui[i-1][j];
}
System.out.print(yanghui[i][j] + "\t");
}
System.out.println();
}
}
}5.3 数组从常用算法
练习一：
特征值计算：定义个int类型的一维数组，包含10个元素，分配一些随机整数，求出这些元素的的最大值，最小值，总和，平均值 要求：随机数为两位数[10,99]
package com.atczy3.common_algorithm.exer1;
/**
* ClassName: ArrayExer01
* Package: com.atczy3.common_algorithm.exer1
* Description:
* 特征值计算：定义个int类型的一维数组，包含10个元素，分配一些随机整数，求出这些元素的的最大值，最小值，总和，平均值
*
* 要求：随机数为两位数[10,99]
* （int）(Math.random() * (b-a+1) + a)
* @Author Ziyun Chen
* @Create 2023/9/22 19:21
* @Version 1.0
*/
public class ArrayExer01 {
public static void main(String[] argc){
// 1.数组初始化：动态初始化
int[] arr = new int[10];
int max = arr[0]; // 最大值
int min = 100; // 最小值 --> 初始为最大值，可以在初始化的同时进行求最小值
int sum = 0; // 总和
int avg = 0; // 平均值
// 2.求最大值，最小值，总和，平均值 <--- 遍历数组
for (int i = 0; i < arr.length; ++i){
arr[i] = (int)(Math.random()*(99-10+1) + 10);
System.out.print(arr[i] + "\t");
max = max > arr[i] ? max : arr[i];
min = min > arr[i] ? arr[i] : min;
sum += arr[i];
}
System.out.println();
avg = sum / arr.length;
System.out.println("最大值：" + max + " 最小值：" + min + " 总和：" + sum + " 平均值:" + avg);
}
}
练习二：
分析以下需求，并用代码实现：
（1）在编程竞赛中，有10位评委为参赛的选手打分，分数分别为：5，4，6，8，9，0，1，2，7，3 *（2）求选手的最后得分（去掉一个最高分和一个最低分后其余8位评委打分的平均值）
package com.atczy3.common_algorithm.exer2;
/**
* ClassName: ArrayExer01
* Package: com.atczy3.common_algorithm.exer2
* Description:
* 分析以下需求，并用代码实现：
* （1）在编程竞赛中，有10位评委为参赛的选手打分，分数分别为：5，4，6，8，9，0，1，2，7，3
* （2）求选手的最后得分（去掉一个最高分和一个最低分后其余8位评委打分的平均值）
* @Author Ziyun Chen
* @Create 2023/9/22 19:50
* @Version 1.0
*/
public class ArrayExer01 {
public static void main(String[] argc){
// 1.使用一维数组对成绩进行存储
int[] scores = new int[]{5,4,6,8,9,0,1,2,7,3};
// 2.找到最高分和最低分 <--- 遍历数组
int max = scores[0];
int min = scores[0];
int sum = 0;
for (int i = 0; i < scores.length; ++i){
max = max > scores[i] ? max : scores[i];
min = min > scores[i] ? scores[i] : min;
sum += scores[i];
}
// 3.求剩下8位评委的平均值 sum-1个最大值和最小值
int avg = (sum-max-min)/8;
System.out.println("剩下8位评委的平均值为： " + avg);
}
}
练习三：
创建一个长度为6的int型数组，要求数组元素的值都在1-30之间，且是随机赋值。同时，要求元素的值各不相同。
package com.atczy3.common_algorithm.exer3;
/**
* ClassName: ArrayExer01
* Package: com.atczy3.common_algorithm.exer3
* Description:
* 创建一个长度为6的int型数组，要求数组元素的值都在1-30之间，且是随机赋值。同时，要求元素的值各不相同。
* @Author Ziyun Chen
* @Create 2023/9/23 10:31
* @Version 1.0
*/
public class ArrayExer01 {
public static void main(String[] argc){
// 1.建立长度为6的int型数组
int[] arr = new int[6];
// 2.给数组元素赋值 --- 遍历数组
for (int i = 0; i < arr.length; ++i){
arr[i] = (int)(Math.random()*(30-1+1)+1);
// 2.1 判断元素是否和前面元素值相同
for (int j = 0; j < i; ++j){
if (arr[j] == arr[i]){
// 2.2 重新为重复元素赋值，进行判断是否相同
arr[i] = (int)(Math.random()*(30-1+1)+1);
j = 0;
}
}
}
// 3.打印输出数组元素
for (int i = 0; i < arr.length; ++i)
System.out.println(arr[i]);
}
}
练习四：
案例：遍历扑克牌 * 遍历扑克牌，效果如图所示：
提示：使用两个字符串数组，分别保存花色和点数，再用一个字符串数组保存最后的扑克牌。
String[] hua = {"黑桃","红桃","梅花","方片"};
String[] dian = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
package com.atczy3.common_algorithm.exer4;
/**
* ClassName: Exer1
* Package: com.atczy3.common_algorithm.exer4
* Description:
* 案例：遍历扑克牌
* 遍历扑克牌，效果如图所示：
*
* 提示：使用两个字符串数组，分别保存花色和点数，再用一个字符串数组保存最后的扑克牌。
* String[] hua = {"黑桃","红桃","梅花","方片"};
* String[] dian = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
* @Author Ziyun Chen
* @Create 2023/9/23 11:07
* @Version 1.0
*/
public class Exer1 {
public static void main(String[] argc){
// 1.创建花色和点数两个数组
String[] hua = {"黑桃","红桃","梅花","方片"};
String[] dian = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
// 2.双层循环，进行输出
for (int i = 0; i < hua.length; ++i){
for (int j = 0; j < dian.length; ++j){
System.out.print(hua[i] + dian[j] + "\t");
}
System.out.println();
}
}
}练习五：
回形数 从键盘输入一个整数（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
package com.atczy3.common_algorithm.exer4;
import java.util.Scanner;
/**
* ClassName: Exer1
* Package: com.atczy3.common_algorithm.exer5
* Description:
* 回形数
* 从键盘输入一个整数（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
* @Author Ziyun Chen
* @Create 2023/9/23 11:15
* @Version 1.0
*/
public class Exer2 {
public static void main(String[] argc){
// 1.创建容纳数字的数组和元素
Scanner scan = new Scanner(System.in);
System.out.println("请输入矩阵大小： ");
int len = scan.nextInt();
int[][] arr = new int[len][len];
int num = len*len;
// 方法二：
// 2.根据minX和maxX的范围进行赋值
int s = 1;
int minX = 0, maxX = len-1;
int minY = 0, maxY = len-1;
while (minX <= maxX){
// 向右
int y = minY;
int x = minX;
for (x = minX; x <= maxX; ++x){
arr[y][x] = s;
++s;
}
++minY;--x;
// 向下
for (y = minY; y <= maxY; ++y){
arr[y][x] = s;
++s;
}
--maxX;--y;
// 向左
for (x = maxX; x >= minX; --x){
arr[y][x] = s;
++s;
}
--maxY;++x;
// 向上
for (y = maxY; y >= minY; --y){
arr[y][x] = s;
++s;
}
++minX;++y;
}
// 3.输出二维数组
for (int m = 0; m < arr.length; ++m) {
for (int n = 0; n < arr.length; ++n) {
System.out.print(arr[m][n] + "\t");
}
System.out.println();
}
}
}
练习五的方法二：
package com.atczy3.common_algorithm.exer4;
import java.util.Scanner;
/**
* ClassName: Exer1
* Package: com.atczy3.common_algorithm.exer5
* Description:
* 回形数
* 从键盘输入一个整数（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
* @Author Ziyun Chen
* @Create 2023/9/23 11:15
* @Version 1.0
*/
public class Exer2 {
public static void main(String[] argc){
// 1.创建容纳数字的数组和元素
Scanner scan = new Scanner(System.in);
System.out.println("请输入矩阵大小： ");
int len = scan.nextInt();
int[][] arr = new int[len][len];
int num = len*len;
// 方法二：
// 2.根据minX和maxX的范围进行赋值
int s = 1;
int minX = 0, maxX = len-1;
int minY = 0, maxY = len-1;
while (minX <= maxX){
// 向右
int y = minY;
int x = minX;
for (x = minX; x <= maxX; ++x){
arr[y][x] = s;
++s;
}
++minY;--x;
// 向下
for (y = minY; y <= maxY; ++y){
arr[y][x] = s;
++s;
}
--maxX;--y;
// 向左
for (x = maxX; x >= minX; --x){
arr[y][x] = s;
++s;
}
--maxY;++x;
// 向上
for (y = maxY; y >= minY; --y){
arr[y][x] = s;
++s;
}
++minX;++y;
}
// 3.输出二维数组
for (int m = 0; m < arr.length; ++m) {
for (int n = 0; n < arr.length; ++n) {
System.out.print(arr[m][n] + "\t");
}
System.out.println();
}
}
}
练习六：数组对称位置的元素互换。
package com.atczy3.common_algorithm.exer5;
/**
* ClassName: Exer1
* Package: com.atczy3.common_algorithm.exer5
* Description:
* 数组对称位置的元素互换。
* @Author Ziyun Chen
* @Create 2023/9/23 16:49
* @Version 1.0
*/
public class Exer1 {
public static void main(String[] argc){
// 1. 定义个数组
int[] arr = new int[]{1,2,3,4,5,6,7,8,9};
// 2.从两边出发，进行交换数组，循环条件为min<=max
int min = 0, max = arr.length-1;
int tmp = 0;
while (min < max){
// 2.1 交换操作
tmp = arr[min];
arr[min] = arr[max];
arr[max] = tmp;
++min;--max;
}
// 3.打印数组
for (int i = 0; i < arr.length; ++i){
System.out.print(arr[i] + "\t");
}
System.out.println();
}
}
5.3 查找、排序算法
练习一：现有数组 int[] arr = new int[]{1,2,3,4,5}; ，现将数组长度扩容1倍，并将10,20,30三个数据添加到arr数组中，如何操作？
package com.atczy4.search_sort;
/**
* ClassName: ArrayExer01
* Package: com.atczy.search_sort
* Description:
* 现有数组 int[] arr = new int[]{1,2,3,4,5}; ，现将数组长度扩容1倍，并将10,20,30三个数据添加到arr数组中，如何操作？
* @Author Ziyun Chen
* @Create 2023/9/23 17:07
* @Version 1.0
*/
public class ArrayExer01 {
public static void main(String[] argc){
int[] arr = new int[]{1,2,3,4,5};
// 扩容
// 1.定义一个新的数组
int[] newArr = new int[arr.length << 1];
// 2.将原数组元素复制到新数组中
for (int i = 0; i < arr.length; ++i){
newArr[i] = arr[i];
}
// 3.将10,20,30添加到新数组中
for (int i = 0; i < 3; ++i){
newArr[arr.length+i] = 10*(i+1);
}
arr = newArr;// 将新数组赋值给原数组
// 4.打印新数组元素
for (int i = 0; i < arr.length; ++i){
System.out.print(arr[i] + "\t");
}
System.out.println();
}
}
练习二： 数组的缩容
题目：现有数组 int[] arr={1,2,3,4,5,6,7}。现需删除数组中索引为4的元素。
package com.atczy4.search_sort;
/**
* ClassName: ArrayExer02
* Package: com.atczy4.search_sort
* Description:
* 数组的缩容
* 题目：现有数组 int[] arr={1,2,3,4,5,6,7}。现需删除数组中索引为4的元素。
*
* @Author Ziyun Chen
* @Create 2023/9/23 17:20
* @Version 1.0
*/
public class ArrayExer02 {
public static void main(String[] argc){
// 方式一：不新建新数组
// 1.建立数组
int[] arr = new int[]{1,2,3,4,5,6,7};
int index = 4;
// 2.删除元素 + 后面的元素前移
for (int i = index; i < arr.length-1; ++i){
arr[i] = arr[i+1];
}
// 修改最后一个元素,设置为默认值
arr[arr.length-1] = 0;
// 3.打印元素
for (int i = 0; i < arr.length; ++i)
System.out.print(arr[i] + "\t");
System.out.println();
// 方式二：新建一个数组
}
}
练习三：线性查找
顺序查找：挨个查看
要求：对数组元素的顺序没要求
package com.atczy4.search_sort;
/**
* ClassName: LinearSearchTest
* Package: com.atczy4.search_sort
* Description:
* 顺序查找：挨个查看
* 要求：对数组元素的顺序没要求
* @Author Ziyun Chen
* @Create 2023/9/23 17:36
* @Version 1.0
*/
public class LinearSearchTest {
public static void main(String[] argc){
// 1.定义数组
int[] arr = new int[]{3,25,46,66};
int num = 0;
// 2.遍历数组，对数组元素进行对比。
int index = 0;
for (index = 0; index < arr.length; ++index){
if (arr[index] == num)
break;
}
// 3.输出元素所在位置索引
if (index < arr.length)
System.out.println("元素" + num + "所在位置索引为： " + index);
else
System.out.println("未找到");
}
}
练习四：二分查找
package com.atczy4.search_sort;
/**
* ClassName: BinarySearchText
* Package: com.atczy4.search_sort
* Description:
* 二分查找
* @Author Ziyun Chen
* @Create 2023/9/23 17:53
* @Version 1.0
*/
public class BinarySearchText {
public static void main(String[] argc){
int[] arr = new int[]{2,5,6,9,10,25,66};
int num = 0;
// 1.定义head、mid、end
int head = 0, end = arr.length-1, mid = (head+end)/2;
boolean flag = false;// 标志位---初始化为没找到
// 2.所找元素与mid进行比较 --- 循环条件 head <= end
while (head <= end){
if (arr[mid] == num){
flag = true; // 找到
break; // 2.1 num = mid 找到
}
if (arr[mid] < num)
head = mid+1; // 2.2 num > mid --- head = mid+1
if (arr[mid] > num)
end = mid-1; // 2.3 num < mid --- end = mid-1;
mid = (head+end)/2;
}
// 3.输出结果
if (flag) {
System.out.println("找到了该元素，下标为： " + mid);}else{
System.out.println("未找到");
}
}
}
练习五：冒泡排序
package com.atczy4.search_sort;
/**
* ClassName: BubbleSort
* Package: com.atczy4.search_sort
* Description:
* 冒泡排序
* 使用冒泡排序，实现整形数组元素的排序操作
* 比如 int[] arr = new int[]{34,35,3,2,65,7,34,5,76,34,67}
* @Author Ziyun Chen
* @Create 2023/9/25 3:49
* @Version 1.0
*/
public class BubbleSortTest {
public static void main(String[] argc){
int[] arr = new int[]{34,35,3,2,65,7,34,5,76,34,67};
int tmp = 0;
// 1.排序，排最大、次大...最小---趟数arr.length
for (int i = 0; i < arr.length-1; ++i){
// 2.每一趟，需要比较的次数 arr.length-趟数-1
for (int j = 0; j < arr.length-i-1; ++j){
// 4.对原冒泡排序进行优化
// 4.1 进行标志位设置，假设原数组是有序的
boolean flag = true;
if (arr[j] > arr[j+1]){// 2.2 如果arr[j] > arr[j+1]--- 交换位置
tmp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tmp;
flag = false;// 4.2 如果进行交换，说明数组不是有序的
}
// 2.1 如果arr[j] <= arr[j+1]--- 不变
if (flag)
break;// 如果本来就是有序的，可以不用再排序了
}
}
// 3.打印数组
for (int i = 0; i < arr.length; ++i)
System.out.println(arr[i]);
}
}
5.4 Arrays的使用
package com.atczy5.arrays;
import java.util.Arrays;
/**
* ClassName: ArrayTest
* Package: com.atczy5.arrays
* Description:
* 测试数组工具类：Arrays的使用 （了解）
* @Author Ziyun Chen
* @Create 2023/9/25 7:25
* @Version 1.0
*/
public class ArrayTest {
public static void main(String[] argc){
// 1.boolean equals(int[] a, int[] b):比较两个数组的元素是否依次相等
int[] arr1 = new int[]{1,2,3,4,5};
int[] arr2 = new int[]{1,2,3,4,5};
System.out.println(arr1 == arr2);// 比较存储数字的首地址
System.out.println(Arrays.equals(arr1, arr2));// 比较存储的元素
// 2.String toString(int[] a):输出数组元素信息
int[] arr3 = new int[]{1,2,3,4,5,6,7,9,8};
System.out.println(Arrays.toString(arr3));// 将数组，变为String类型
// 3.void fill(int[] a, int val):将指定值填充到数组之中
System.out.println(Arrays.toString(arr1));
Arrays.fill(arr1, 10);
System.out.println(Arrays.toString(arr1));
// 4.void sort(int[] a):使用快速排序算法实现排序
Arrays.sort(arr3);
System.out.println(Arrays.toString(arr3));
// 5.int binarySearch(int[] a, int key); 二分查找 返回索引值，如果是负数，没找到
// 使用前提：当前数组必须是有序的
int index = Arrays.binarySearch(arr3, 5);
if (index >= 0)
System.out.println("找到了，索引值为： " + index);
else
System.out.println("未找到");
}
}
5.6 企业真题
求数组的最大子序列和
输入一个整形数组，数组里有正数也有负数。数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。
求所有子数组的和的最大值。要求时间复杂度为O(n)。
例如：输入的数组为1, -2, 3, 10, -4, 7, 2, -5，和最大的子数组为3, 10, -4, 7, 2，
因此输出为该子数组的和18。
package com.atczy6.sum;
import java.util.Arrays;
/**
* ClassName: sumTest
* Package: com.atczy6.sum
* Description:
* 求数组的最大子序列和
* 输入一个整形数组，数组里有正数也有负数。数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。
* 求所有子数组的和的最大值。要求时间复杂度为O(n)。
* 例如：输入的数组为1, -2, 3, 10, -4, 7, 2, -5，和最大的子数组为3, 10, -4, 7, 2，
* 因此输出为该子数组的和18。
* @Author Ziyun Chen
* @Create 2023/9/25 8:12
* @Version 1.0
*/
public class sumTest {
public static void main(String[] argc){
// 1.初始化数组
int[] arr = new int[]{1,-2,3,10,-4,7,2,-5};
System.out.println(Arrays.toString(arr));
int tmp = 0, max = 0;
int begin = 0, end = 0;
// 2.遍历数组 tmp 和 max进行比较
for (int i = 0; i < arr.length; ++i) {
tmp += arr[i];
if (tmp < 0){
tmp = 0;// 是否要重新设置起点
begin = i+1;
}
if (max < tmp){
max = tmp;// 是否是最大值
end = i;
}
}
// 3.打印结果
System.out.println("最大值为： " + max);
System.out.println("起点：" + begin + " 终点： " + end);
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
