Java数组：数组的基本概念及作用、一维数组的的创建、访问与迭代、数组排序、二维数组的创建与迭代。

⁢⁢Mrx

已于 2022-07-23 17:15:44 修改

阅读量575

点赞数 2

文章标签： java

于 2022-05-04 09:00:00 首次发布

本文链接：https://blog.csdn.net/qq_55145932/article/details/124564431

版权

1.数组的基本概念及作用

数组是相同数据类型元素的集合。
数组本身是引用数据类型，属于对象。
数据可以储存基本数据类型，也可以储存引用数据类型。

2.一维数组

1)数组的创建

数据的声明方式有两种：

数据类型 [ ] 数组名字例如： int [] a;

数据类型数据名字 [ ] 例如： int a [];

注意：再声明中两种没有任何区别但是为了避免混淆数据类型，所以推荐第一种。

public class Demo1 {
    public static void main(String[] args) {
        //数组的定义,1.数据类型 数组名称[] 2..数据类型 [] 数组名称
        int a [],b;     //b不是数组,a为数组int
        int [] c,d;     //c d 都为数组
    }
}

数据的创建有三种方式：
1. 声明数组的同时，根据指定的长度分配内存，但数组中元素值都为默认的初始化值。
```
int [] arr0 = new int [10];
```
2. 声明数组并分配内存，同时将其初始化
```
int [] ary1 = new int [] {1,2,3,4,5};
```
3. 与第二种相似，语法简化一些
```
int [] arr2 = {1，2，3，4，5}; 
```

public class Demo1 {
    public static void main(String[] args) {
        char [] w = new char [5];           //默认值为 " "
        System.out.println(Arrays.toString(w));
        float [] e = new float[5];          //默认值为 0.0
        System.out.println(Arrays.toString(e));
        String [] r = new String[5];         //String默认为null
        System.out.println(Arrays.toString(r));
        int [] qwe0 = new int[]{1,2,4,4,6};  //这两种定义方式相同
        int [] qwe1 = {1,2,4,4,5,5};
        System.out.println(Arrays.toString(qwe0));
        System.out.println(Arrays.toString(qwe1));
    }
}

数组的创建还可以分为动态和静态两种

动态创建数组（用for循环来赋值）

int [ ] a = new int [5];

import java.util.Scanner;
public class Demo1 {
    public static void main(String[] args) {
       Scanner scanner = new Scanner(System.in);
       int [] a = new int[5];
       for(int i =0;i<5;i++){
            a[i] = scanner.nextInt();
       }
    }
}

静态创建数组，再创建的时候为每一个元素赋初值
```
int ary1 = new int[]{1,2,3,4,5};
```

数组的长度：length属性

public class Hello{
    public static void main(){
        int [] b1 = new int[]{1,2,3,4,5,6,7};
        System.out.println(b1.length);
    }
}

2)数组的访问与迭代

数组元素的访问：

数组名字[索引] 例如: a[0],a[1];
- 注意：
- 数组的索引从0开始。
- 索引的数据类型是整形
- 索引的最大值为长度-1

数组迭代的两种方式：

第一种：for循环

int [] b1 = new int [] {1,2,3,4,5};

数组的迭代

for(int i=0;i<b1.length;i++){
System.out.println(b1[i]);
}

增强for循环

for(数组元素的类型临时变量名：数组名称){

System.out.println(临时变量名);

}

int[] aq = {1, 2, 3, 4, 5};
//增强for循环
for(int t:aq){
System.out.println(t);//与for区别 不用索引 每次循环会取数组的一个元素赋值为t 直到循环全部完成
}

3)数组排序

冒泡排序

概念：它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（从大到小、首字母从Z到A)错误就把他们交换过来.走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。
- 思路：
  1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
  2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。每次的最后一个元素会是已经排好的。
  3. 针对所有元素重复以上步骤，除最后一个数。
  4. 每次对越来越少的元素重复上面的步骤，直到全部排好

import java.util.Arrays;
public class sort1 {
    public static void main(String[] args{
        int [] a = {234,13,14,15,19};
        for(int i=0;i<a.length-1;i++){
            for(int j=0;j<a.length-1-i;j++){
                if(a[j]>a[j+1]){
                    int temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

选择排序

概念：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。

思路：以升序为例
1. 在a[0]到a[n-1]中选出最小的数a[0]交换
2. 在a[1]到a[n-1]中选出最小的数a[1]交换
3. 以此类推直至完全排完

import java.util.Arrays;
public class sort2 {
    public static void main(String[] args) {
        int [] a = {24,13,16,15,19};
        for(int i=0;i<a.length-1;i++){
            for(int j = i+1;j<a.length;j++){
                if(a[i]>a[j]){
                    int temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

3.二维数组

定义：二维数组的每一个元素是一个一维数组。

int [] [] a = {{1,2,3},{2,3,4},{3,4,5}};

二维数组的声明：

int [] [] a;

int a2[] [] ;

注意：与一维数组相同推荐使用第一种，不容易混淆a的数据类型。

1)数组的创建

int [][] a = new int[3][3]; //定义了整型的二位数组，这个二位数组有三个一维数组，每个一维数组包含三个元素。
int [][] b = new int[3][]; //只定义了二位数组没有定义一维数组，里面的一维数组为null
int [][] c1 = new int[][]{{10,20,30,40},{5,20,40,60},{12,32,43,53}};//与第四种效果相同
int [][] c = {{10,20,30,40},{5,20,40,60},{12,32,43,53}};    //第三种的简化版

2)二维数组的访问与迭代

左索引决定行，右索引决定列

public class Demo3 {
    public static void main(String[] args) {
        int[][] c = {{10,20,30,40},{5,20,40,60},{12,32,43,53}};
        for(int i=0;i<c.length;i++){
            for(int j=0;j<c[i].length;j++){
                System.out.print(c[i][j]+" ");
            }
            System.out.println();
        }
    }
}