javabasic笔记7----数组

数组

数组，是一种数据结构，是用来存储一堆类型相同并且是有序的数据的容器。可以通过数组名以及一个不会越界的下标值(索引)来访问其中的元素。

数组，没有固定的类名，每一个数组都是对象；

基本数据类型的数据，称为值，不是对象。

数组的特点

1. 数组是一个固定长度的容器，长度一旦固定，将不能够改变；
2. 数组的长度，代表了数组中能够存储多少个元素；
3. 元素，即存储在数组中的每一个数据。

数组的实例化

动态初始化以下两种形式：

格式1：

使用new关键字，实例化数组对象，同时初始化具体的元素

数据类型[ ]  变量名 = new 数据类型[ ]{元素1，元素2，元素3.....元素n };

格式2：

使用new关键字，只规定数组长度

数据类型[ ]  变量名 = new 数据类型[长度];

静态初始化如下： 

 格式：
直接使用{ }进行初始化数组元素，注意：该方式不能先声明，再初始化。

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

数组的元素访问

1.通过下标访问： 下标就是元素对应的索引值。下标从0开始，最后一个元素下标length-1
2.数组的长度：  数组变量名.length

常见的异常

ArrayIndexOutOfBoundsException:

数组下标越界异常。
当访问数组中的元素的时候，使用了错误的下标。

NullPointerException:

空指针异常。
一个引用为null的情况下，尝试进行空间访问。

遍历数组

遍历数组就是指依次获取数组中的每一个元素。

1.经典for循环：

for(int i = 0; i<array.length;i++）{
    //通过下标获取元素
    int element = array[i];
    System.out.println(element);
}

2.增强for循环：

int[] array  new int[]{1,2,3,4,5};
//将数组array中的元素依次给ele进行赋值
for(int ele:array){
    System.out.println(ele);
}

两者的比较：
1. 增强for循环中，没有下标的概念
2. 增强for循环中，不能对数组中的元素进行改动
3. 增强for循环比遍历下标的执行效率要高

元素排序

选择排序

原理：
从0索引处开始，与后边的元素依次进行比较，如果满足条件就交换，这样小的元素一直在0索引处，一轮下来，就得到了最小值；

接着从1索引处开始继续判断，与后面的元素依次进行比较，满足条件就交换，保证1索引处一直都是比较后的最小值，一轮下来，得到第二个较小值，依次每轮都是这样循环下去。

public static void main(String[] args){
    int[] nums = {6,5,3,2,4,1};
    //外层控制轮数
    for(int i = 0; i<nums.length-1;i++){
        //内存控制每轮的比较
        for(int j = i+1;j<nums.length;j++){
            if(nums[i] >nums.[j]{
                //定义一个临时变量，用来交换
                int temp = nums[i];
                nums[i] = nums[j];
                nums[j] = temp;
            }
        }
    }
    System.out.println(Array.toString(nums));
}

插入排序

原理：

将数组的第一个元素看作是一个有序数组，从第二个元素开始，将其与前面有序元素从左往右依次进行比较，当小于等于某一元素时将其插入，保证插入后也是有序的，依次将数组所有元素插入。

public static void main(String[] args){
    int[] nums = {4,6,1,3,2,7};
    int j;
    for(int i = 1;i<nums.length;i++){
        if(nums[i] < nums[i-1]{
            int temp = nums[i];
            for(j = i-1; j>=0 && temp< nums[j]; j--){
                nums[j+1] = nums[j];
            }
            nums[j+1] = temp;
        }
    }
    System.out.println(Arrays.toString(nums));
 }

        

冒泡排序

原理：

从第一个元素开始，依次比较两个相邻的元素，将较大的数往后移，这样就将最大的数放在了最后。第二轮将第二大的数放在了倒数第二个，以此类推。

public static void main(String[] args){
    int[] nums = {6,2,4,7,1,5};
    for(int i = 0; i<nums.length-1;i++){
        for(int j = 0; j<num.length-1;j++
            if(nums[j] > nums[j+1]{
                int temp = nums[j];
                nums[j] = nums[j+1];
                nums[j+1] = temp;
            }
        }
    }
    System.out.println(Arrays.toString(nums));
}