【Java学习】数组的初始化、特点及基础操作（冒泡排序）

一、使用

1.声明数组

int[] a;

2.分配空间

a = new int[5];

3.赋值

a[0] = 8;

4.处理数据

a[0] = a[0]*10;

 

二、初始化

类型[] 数组名 = new 类型[] {元素,元素,……};        //动态初始化

动态初始化：定义数组时只指定数组的长度，由系统自动为元素赋初值的方式称作动态初始化。

类型[] 数组名 = {元素,元素,元素,……};        //静态初始化

静态初始化：定义数组的同时为每个元素赋值，称为静态初始化。

 

三、特点

1.数组中存放的数据数据类型相同；（基本数据类型、引用数据类型）

2.数组在定义时必须给定大小，且大小不可变；

3.下标从0开始，可通过下标值获取数据；

4.数组中插入的数据是有序集合，此时有序不是指大小排序，而是指插入的顺序；

5.数组的默认值取决于所定义数组的类型。

 

四、操作

1.数组遍历

public class ArrayTraversal {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5};      //定义数组
        //使用for循环遍历数组元素
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);     //通过索引访问元素
        }
    }
}

结果：
1
2
3
4
5

2.数组最值

public class ArrayMax {
    public static void main(String[] args) {
        int[] arr={4,1,6,3,9,8};        //定义一个数组
        int max =getMax(arr);           //调用获取数组最大值的方法
        System.out.println("数组最大值是："+max);  //打印输出最大值
    }

    static int getMax(int[] arr){
        int max = arr[0];       //定义变量max用于记住最大值，并假设第一个元素为最大值
        //使用for循环遍历数组元素
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]> max){        //比
                // 较arr[i]的值是否大于max中存的值
                max=arr[i];         //若条件成立，则将arr[i]的值赋给max
            }
        }
        return max;     //返回最大值
    }
}

结果：
数组最大值是：9

3.数组排序（冒泡）

public class ArrayRank {
    public static void main(String[] args) {
        int[] arr={9,8,3,5,2};
        System.out.print("冒泡排序前：");
        printArray(arr);            //打印数组元素
        bubbleSort(arr);            //调用排序方法
        System.out.print("冒泡排序后：");
        printArray(arr);            //打印数组元素
        
    }

    public static void printArray(int[] arr) {
        //使用for循环遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");       //打印元素和空格
        }
        System.out.print("
");           //打印换行符
    }
    //定义冒泡排序方法
    public static void bubbleSort(int[] arr){
        //定义外层循环
        for (int i = 0; i < arr.length-1; i++) {
            //定义内层循环
            for (int j = 0; j < arr.length-i-1; j++) {
                if (arr[j]>arr[j+1]){   //比较相邻元素
                    //将这两个相邻元素交换位置
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
            System.out.print("第"+(i+1)+"轮排序后：");
            printArray(arr);            //每轮比较结束打印数组元素
        }
    }
}

结果：
冒泡排序前：9 8 3 5 2 
第1轮排序后：8 3 5 2 9 
第2轮排序后：3 5 2 8 9 
第3轮排序后：3 2 5 8 9 
第4轮排序后：2 3 5 8 9 
冒泡排序后：2 3 5 8 9 

五、实例

public class saleroom {

    public static void main(String[] args) {
        int [][] arr = new int[3][];
        arr[0] = new int[]{11,12};
        arr[1] = new int[]{21,22,23};
        arr[2] = new int[]{31,32,33,34};
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            int groupSum = 0;
            for (int j = 0; j < arr[i].length; j++) {
                groupSum = groupSum = arr[i][j];
            }
            sum = sum = groupSum;
            System.out.println("第"+(i+1)+"小组销售额为："+groupSum+"万元。");
        }
        System.out.println("总销售额为："+sum+"万元。");
    }
}

结果：
第1小组销售额为：12万元。
第2小组销售额为：23万元。
第3小组销售额为：34万元。
总销售额为：34万元。

六、算法总结