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]);

        }

    }

}