java数组学习

SHX20010129

已于 2023-08-02 11:11:46 修改

阅读量33

点赞数

文章标签： java

于 2023-07-25 19:24:56 首次发布

本文链接：https://blog.csdn.net/SHX20010129/article/details/131904610

版权

1. 一维数组

1.1 概念

数组的常见概念：
变量：在内存开辟一块空间。
数组：也是变量，在内存中开辟一串连续的空间。数组长度一旦确定，就不能修改
数组名：数组名也是变量名，按照变量的命名规范来命名。
下标(或索引)
元素
数组的长度

1.2 基本用法

1.2.1 格式

格式 1：数据类型[] 数组名，属于只创建了数组引用名，并未在内存创建数组空间
格式 2：数据类型[] 数组名称 = new 数据类型[数组长度];
格式 3：数据类型[] 数组名称 = {数组内容 1,数组内容 2,数组内容 3…数组内容 n};
格式 4：数据类型[] 数组名称 = new 数据类型[]{内容 1,内容 2,内容 3…内容 n}

1.2.2 代码

public static void main(String[] args){
// 1、声明数组
//1.1 先声明，后开辟空间：数据类型[] 数组名称;
int[] arr1;//声明
arr1=new int[4];//开辟空间：数组名称=new 数据类型[数组长度]; 数组的长度一旦确定，不可以改变
//1.2 声明数组的同时开辟空间
double[] arr2=new double[5];
System.out.println(arr1);
System.out.println(arr2);
//1.3 声明数组
String[] arr3;//只是声明，没有在内存中开辟数组空间
//System.out.println(arr3);
//1.4 声明数组的同时赋值 数据类型[] 数组名称=new 数据类型[]{数组值1,数组值2,数组值3,数组值4......数组值n};
//此时数组的长度由赋值的个数决定
int[] arr4=new int[]{1,2,3,4,5};
System.out.println(arr4);
//1.5 声明数组的同时赋值 数据类型[] 数组名称={数组值1,数组值2,数组值3,数组值4......数组值n};
//此时数组的长度由赋值的个数决定
double[] arr5= {1.5,3.6,5.8,4.0};
}

1.3 内存结构

1.4 数组实战

1.4.1 读取数组

public static void main(String[] args) {
//1、声明数组并开辟空间
int[] arr1=new int[4];
//2、给数组赋值：数组名称[下标索引]=值；下标索引从0开始，最大比数组长度小1
//数组长度:数组名称.length获取
//原始赋值方式：
/*
* arr1[0]=2;
* arr1[1]=4;
* arr1[2]=6;
* arr1[3]=8;
*/
//推荐使用循环的方式数组
for(int i=0;i<arr1.length;i++) {
arr1[i]=i+1;
}
//3、使用数组
for(int i=0;i<arr1.length;i++) {
System.out.println(arr1[i]);
}
}

1.4.2 数组的默认值

public static void main(String[] args) {
//int类型数组元素的默认值是0
int[] arr1=new int[4];
for(int i=0;i<arr1.length;i++) {
System.out.println(arr1[i]);
}
//double类型数组元素的默认值是0.0
double[] arr2=new double[4];
for(int i=0;i<arr2.length;i++) {
System.out.println(arr2[i]);
}
//String类型数组元素的默认值是null
String[] names=new String[5];
for(int i=0;i<names.length;i++) {
System.out.println(names[i]);
}
//char类型数组元素的默认值是' '
char[] genders=new char[5];
for(int i=0;i<genders.length;i++) {
System.out.println(genders[i]);
}
//boolean类型数组元素的默认值是false
System.out.println("over");
}

1.4.3 求极值问题

public static void main(String[] args) {
//找出指定数组{12,43,-45,567,13}中的最大值和最小值
int[] arr= {12,43,-45,567,13};
//定义极值：一定数组元素，一般把第一个元素作为最大值的初始值
int max=arr[0];//12
int min=arr[0];
//循环比对
for(int i=1;i<arr.length;i++) {
if(arr[i]>max) {
max=arr[i];
}
if(arr[i]<min) {
min=arr[i];
}
}
System.out.println("最大值是:"+max);
System.out.println("最小值是:"+min);
}

1.5 练习

从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
成绩>=最高分-10 等级为’A’
成绩>=最高分-20 等级为’B’
成绩>=最高分-30 等级为’C’
其余等级为’D’
提示：先读入学生人数，根据人数创建int数组，存放学生成绩
在这里插入图片描述

public class Zbc {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入学生人数：");
        int num= scanner.nextInt();
        int score[]=new int[num];
        System.out.println("请输入学生的成绩：");
        int maxscore=0;
        for (int i = 0; i < score.length; i++) {
            score[i]=scanner.nextInt();
            if (maxscore<score[i]) {
                maxscore=score[i];
            }
        }
        System.out.println("最高分是："+maxscore);
        char levl;
        for (int i = 0; i < score.length; i++) {
            if(maxscore-score[i]<10){
                levl='A';
            } else if (maxscore-score[i]<20) {
                levl='B';
            } else if (maxscore-score[i]<30) {
                levl='C';
            }
            else{
                levl='D';
            }
            System.out.println("学生"+(i+1)+"的分数是"+score[i]+",成绩是"+levl);
        }
    }
}

在这里插入图片描述

2. 二维数组

2.1 概念

对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存
在。其实，从数组底层的运行机制来看，其实没有多维数组

2.1.1 格式一

int[][] arr = new int[3][2]

定义了名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中有2个元素
一维数组的名称分别为arr[0], arr[1], arr[2]
给第一个一维数组1脚标位赋值为78写法是： arr[0][1] = 78

2.1.2 格式二

 int[][] arr = new int[3][];

二维数组中有3个一维数组。
每个一维数组都是默认初始化值null (注意：区别于格式1）
可以对这个三个一维数组分别进行初始化 arr[0] = new int[3]; arr[1] = new int[1];
arr[2] = new int[2];
注： int[][] arr = new int[][3] 非法

2.1.3 格式三

int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};

定义一个名称为arr的二维数组，二维数组中有三个一维数组
每一个一维数组中具体元素也都已初始化
第一个一维数组 arr[0] = {3,8,2};
第二个一维数组 arr[1] = {2,7};
第三个一维数组 arr[2] = {9,0,1,6};
第三个一维数组的长度表示方式：arr[2].length;

2.2 二维数组的使用

2.2.1 方式一

int[][] arr1 = new int[3][2];
arr1[0][1] = 3;

2.2.2 方式二

int[][] arr2 = new int[3][];
arr2[0] = new int[3];
arr2[1] = new int[4];
arr2[0][1] = 3;

2.2.3 方式三

public static void main(String[] args) {
//方式3
int[][] arr2 = new int[][]{{3,8,2},{2,7}, {9,0,1,6}};
//取值
for (int i = 0; i < arr2.length; i++) {
for (int j = 0; j < arr2[i].length; j++) {
System.out.println(arr2[i][j]);
}
System.out.println("------------------");
}
}

2.3 练习

基本都跟循环打交道；一维数组数组一重循环；2维数组数组2重循环；
基本离不开坐标问题；一维数组一个下标索引；二维数组一定就是两个坐标（横纵坐标）

/*
* 二维数组练习：
* 数组中常见的异常： NullPointerException异常 空指针异常
* ArrayIndexOutOfBoundsException 数组下标越界
* */
public class Demo23 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
//1、计算3个班级所有学生的平均分：每个班级有n个人，要求先输出各个班级的自己的平均
分
double[][] score=new double[3][];//列数省略，需要自己去开辟空间
for(int i=0;i<score.length;i++) {
double sum=0;
System.out.print("请输入第"+(i+1)+"个班级的学生人数:");
int num=input.nextInt();
score[i]=new double[num];//不开空间默认null,会报出
NullPointerException异常
//System.out.println(score[i]);
for(int j=0;j<num;j++) {
System.out.print("请输入第"+(j+1)+"个同学的成绩：");
score[i][j]=input.nextDouble();
sum+=score[i][j];
}
System.out.println("第个班级的平均分是："+sum/num);
}
}
}

3 数组中的常见算法

3.1 二分查找

public static void main(String[] args) {
String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
//数组的复制(区别于数组变量的赋值：arr1 = arr)
String[] arr1 = new String[arr.length];
for(int i = 0;i < arr1.length;i++){
arr1[i] = arr[i];
}
//数组的反转
// for(int i = 0,j = arr.length - 1;i < j;i++,j--){
// String temp = arr[i];
// arr[i] = arr[j];
// arr[j] = temp;
// }
//遍历
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + "\t");
}
System.out.println();
//查找（或搜索）
//线性查找：
String dest = "BB";
dest = "CC";
boolean isFlag = true;
for(int i = 0;i < arr.length;i++){
if(dest.equals(arr[i])){
System.out.println("找到了指定的元素，位置为：" + i);
isFlag = false;
break;
}
}
if(isFlag){
System.out.println("很遗憾，没有找到的啦！");
}
//二分法查找：(熟悉)
//前提：所要查找的数组必须有序。
int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
int dest1 = -34;
dest1 = 35;
int head = 0;//初始的首索引
int end = arr2.length - 1;//初始的末索引
boolean isFlag1 = true;
while(head <= end){
int middle = (head + end)/2;
if(dest1 == arr2[middle]){
System.out.println("找到了指定的元素，位置为：" + middle);
isFlag1 = false;
break;
}else if(arr2[middle] > dest1){
end = middle - 1;
}else{//arr2[middle] < dest1
head = middle + 1;
}
}
if(isFlag1){
System.out.println("很遗憾，没有找到的啦！");
}
}

在这里插入图片描述

3.2 冒泡算法

public static void main(String[] args) {
int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
//冒泡排序
for(int i = 0;i < arr.length - 1;i++){
for(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;
}
}
}
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + "\t");
}
}

3.3 Arrys工具类

public static void main(String[] args) {
//1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
int[] arr1 = new int[]{1,2,3,4};
int[] arr2 = new int[]{1,2,3,4};
boolean isEquals = Arrays.equals(arr1, arr2);
System.out.println(isEquals);
//2.String toString(int[] a):输出数组信息。
System.out.println(Arrays.toString(arr1));
//3.void fill(int[] a,int val):将指定值填充到数组之中。
Arrays.fill(arr1,10);
System.out.println(Arrays.toString(arr1));
//4.void sort(int[] a):对数组进行排序。
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));
//5.int binarySearch(int[] a,int key)
int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
int index = Arrays.binarySearch(arr3, 210);
if(index >= 0){
System.out.println(index);
}else{
System.out.println("未找到");
}
}