Java数组小白版

一、数组概念

一、数组定义

数组就是指在计算机内存中开辟的连续存储空间 ，用于存放程序运行中需要用到的一组相同类型数据的容器。

二.数组的声明 +数组的长度

定义数组时需要确定数组的长度（元素的个数），确定后不能更改；

获取数组长度：数组名.length

1. 格式1（默认初始值）

• 数据类型 [ ] 数组名 = new 数据类型 [ 数组的个数 ]

  例：int [ ] money = new int [ 100 ];

  数组长度：money.length(100);

2.格式2（赋予初始值）

• 数据类型 [ ] 数组名 = new 数据类型 [ ]

  例：int [ ] money = new int [ ]{100,200,300，...n};

  数组长度：money.length(n);

3.格式3（格式2简写）

• 数据类型 [ ] 数组名 =

​ 例：int [ ] money = {100,200,300};

​ 数组长度：money.length(3);

三、数组的访问

例：

int [ ] money = new int [ 100 ]; //声明一个包含100个元素的数组

访问第一个元素（数组下标索引从0开始）

money[ 0 ] = 100;

访问第二个元素

money [ 1 ] =200;

​ ...

访问第100个元素

money [ 99 ] = 1000;

访问第101 个元素（数组下越界异常，数组越界，不会显示编译错误，而是运行时报错）

money[ 100 ]= 1100;

四、数组的遍历

例：

int [] arr = new int [6];
for(index = 0;index < arr.index.length;index++){
    System.out.println(arr[index])
}

五、数组的特点

1.数组长度一旦指定，就无法更改；

2.数组一旦声明类型后，数组中只能存放同一类型的数据数组；

3.数组类型可以是任何数据类型，包括基本类型和引用类型；

数组有索引：从零开始，到数组.length-1结束。

六、数组的缺点

1.数组长度指定后，就不能更改；

2.删除、添加元素效率低；

3.数组中实际元素的数量没办法获取，没有提供对应的方法或属性来获取；

七、实例

/**
 * @author yeye
 * @desc 数组访问示例
 * @date 2024
 */
public class ArrayVisitDemo {
    public static void main(String[] args) {
        int [] arr = new int [5];
        arr [0] = 1;
        arr [1] = 2;
        arr [2] = 3;
        arr [3] = 4;
        arr [4] = 5;
//        arr [5] = 6;//数组越界，不会显示编译错误，而是运行时报错
        System.out.println("数组的长度是："+arr.length);
        //数组遍历
        for(int index = 0;index <arr.length;index++){
            System.out.println(arr[index]);
        }
        System.out.println("数组元素为："+arr[0]+" "+arr[1]+" "+arr[2]+" "+arr[3]+" "+arr[4]);
    }
}

二、一维数组和二维数组

一、一维数组定义

数组中每个元素都只带一个下标，这样的数组称为一维数组。使用Java数组前，应声明数组并为数组分配存储空间。

二、声明一维数组

1.类型标识符 [ ] 数组名 =null； 例：

int [ ] list = null; //声明list为一维类型数组

2.类型标识符 数组名 [ ] = null;例：

int list [ ] = null; //声明list为一维类型数组

三、初始化一维数组

1.通过直接指定初值来初始化数组，例：

int [ ] list = {1,2,3};

2.利用new关键字初始化

利用new 关键字初始化数组，不仅能为数组分配需要的存储空间，还能按照Java的默认初始化原则为数组元素赋值。

四、二维数组

例：int money [ ] = new int [3] [12];

二维数组的遍历

int money [ ] = new int [3] [12];

for(int row = 0;row <3;++row){
     for(int column = 0;column<13;++column){
           money[row][column] =100;
     }
}

三、数组的算法（冒泡排序法）

口诀 ：

冒泡排序要知道；内外循环两层套；外环数组遍历到；内环边界计算好；左右元素判大小；临时变量交换好。

//外层循环遍历整个数组(最后一个数组不需要遍历)
for(i = 0;i < (数组长度-1);i++){
    //内存循环控制元素交换即冒泡，一般为数组长度-外层循环遍历-1
    for(j = 0;j <(数组长度-i-1)；j++){
        //升序--如果前面大于后面则交换;降序--如果后面大于前面则交换
        if(array[j] > array[j+1]){
            //引进temp变量作为交换媒介
            int temp = array[j+1]; //临时变量
             array[j+1] = array[j];
             array[j] = temp;
         }
    }
         
}

实例：

package array;

/**
 * @author yeye
 * @desc 冒泡排序法
 * @date 2024
 */
public class BubbleSortDemo {
    public static void main(String[] args) {
        // 定义数组
        int[] arr =new int [] {3,2,5,8,6,1,4,7};
        //冒泡排序
        for(int i = 0;i < arr.length;i++){
            for(int j =0;j <arr.length-i-1;j++){
                if(arr[j] > arr[j+1] ){
                    int temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        // 输出排序后的数组
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i]);
        }
    }
}