基础知识——数组

1、什么是数组

2、数组的声明创建

public class ArrayDemo01 {
    public static void main(String[] args) {
        //定义数组
        int[] nums;
        //创建一个数组
        nums = new int[5];

        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        //输出num[4]的值
        System.out.println(nums[4]);
        //计算数组内所有元素的和
        int sum = 0;
        for (int i = 0; i <nums.length; i++) {
            sum = sum + nums[i];
        }
        System.out.println("总和为：" + sum);
    }
}

3、内存分析

4、数组的三种初始化状态

1、静态初始化

public class ArraryDemo02 {
    public static void main(String[] args) {
        int[] ints = new int[3];
        ints[0] = 1;
        ints[1] = 2;
        ints[2] = 3;
        for (int i = 1; i <= ints.length; i++) {
            System.out.println(i);
        }
        System.out.println("===============");

        int[] a ={1,2,3,4,5};
        for (int i = 1; i <= a.length; i++) {
            System.out.println(i);
        }
    }
}

2、动态初始化

        //静态初始化
        int[] a ={1,2,3,4,5};
        for (int i = 1; i <= a.length; i++) {
            System.out.println(i);
        }
        System.out.println("==============");
        //动态初始化
        int[] b = new int[10];
        b[0] = 10;

5、数组的四个基本特点

• 长度确定，一但创建，他的大小是不可改变的；
• 一个数组中的元素必须是同一个类型的数据；
• 数组中的数据可以是任何数据类型，可以是基本数据类型，也可以引用数据类型；
• 数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素可以看作是该对象的成员变量；
• 数组本身就是对象，java中对象在堆中，无论是保存原始类型还是其他对象类型，数组对象本身实在堆中的；

6、数组下标越界异常ArrayIndexOutOfBoundsException

7、数组的使用

增强for循环遍历数组

public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        //遍历数组
        for (int array : arrays
             ) {
            System.out.println(array);
        }
    }
}

反转数组：

多维数组：

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[][] a = {{1,2},{3,4},{1,4}};
    }
}

8、Arrays类

1. Arrays.sort排序方法

import java.util.Arrays;

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5,93,29,34};
        //使用Arrays类的sort排序方法，对数组进行顺序的排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

2. 冒泡排序
   

public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] a = {1,32,4,35,5,3,2,9,3};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));
        //冒泡排序
        //1、比较数组中的两个元素，如果第一个数比第二个数大，就交换他们的位置
        //2、每一次比较都会产生一个最大的数和一个最小，或者最小的数字
        //3、下一轮则可以少一次排序
        //4、依次循环直到结束
    }
    public static int[] sort(int[] array){
        //临时变量，用于交换数据
        int temp = 0;
        //外层循环，判断这个循环要走多少次
        for (int i = 0; i < array.length; i++) {
            boolean flag = false;
            //内层循环，比较判断连个数，如果第一个数比第二个数大，则交换位置
            for (int j = 0; j < array.length-1-i; j++) {
            //从大到小使用<
            //从小到大使用>
                if (array[j+1] < array[j]) {
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }
            if (flag = false){
                break;
            }
        }
        return array;
    }
}

3. 稀疏数组