JAVA的数组①

java的数组
数组的定义:
数组就是一个容器 容器中存放了一组数据 这组数据的类型时相同的
数组的存放规则:
是以角标来存放 并且下标从0开始
数组的声明规范:
数据类型 变量名 = 初值;
数据类型 指的就是数组中存放的数据的类型
两种格式:
1:
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
2:
元素类型[] 数组名 = new 元素类型[]{所有的元素};

数组就相当于在堆内存中开辟了一块连续的空间
堆内存
堆内存的特点:
1.有初始值 默认为0
2.有内存地址
3.也有垃圾回收机制
int[] array保存了堆内存的收地址

数组的遍历
基本上只要有数组的问题 就离不开数组的遍历
遍历: 打印出数组中所有的元素

int array[] = new int[] {1,4,2,3};
    for (int i = 0; i < array.length; i++) {
        System.out.print(array[i]);
    }

结果

1423

数组中元素的反转
反转就是把元素中的位置进行交换
但是编写一个函数 是不能进行元素交换的
因为堆内存和栈内存是两个不同的空间
数组的排序
1.冒泡排序
核心: 相邻两个数比较大小 交换位置
我们先写一下交换看一下
原数: 3 2 5 1
第一趟交换
2 3 5 1
2 3 5 1
2 3 1 5 // 确定一个数(最大值 最后面)
第二趟交换
2 3 1 5
2 1 3 5 // 再次确定一个数
第三趟交换
1 2 3 5 // 确定最后一个数
因为第一次确定了最后一个数 所以第二次的交换不需要和最后一个数相比 同理 最后一趟交换只需要比一次
int array = int[]{3,2,5,1}

public static void sort(int[] array){
    for (int i = 0; i < array.length - 1; i++){
        for(int j = 0; j < array.length - 1 - i; j++){
            if(array[j] > array[j + 1]){
            int temp = array[j];
            array[j] = array[j + 1]
            array[j+1] = temp;
            }
        }
    }
}

结果

[1 , 2, 3, 5]

当输入一个0的数组的时候 输出的结果和数组的角标为0时 时冲突的所以i < array.length要写成i < array.length - 1
内循环 - 1 可以避免数组越界
又因为每一趟比较都会确定一个数 下一趟比较就会少比较一次
因为i是同样递增的 所以j < array.length - 1可以写成j < array.length - 1 - i可以让运算更加快 运算负荷小

2选择排序
核心: 选择一个数和下一个数相比较 换位(一般选第0个数)
写一下交换
原数[3,2,5,1]
第一趟交换
2 3 5 1
2 3 5 1
1 3 5 2 //确定一个数(最小的数 最前面)
第二趟交换
1 3 5 2
1 2 5 3
第三趟交换
1 2 3 5
因为每一次比较都会确定一个数 所以接下来的每一趟比较都会少一次
代码

int[] array = new int[]{3,2,5,1}
    for(int i = 0; i < array.length - 1; i++){
        for(int j = 1 + i; j < array.length; j++){
            if (array[j] < array[i]){
                int temp = array[j];
                array[j] = array[i];
                array[i] = temp;

        }
    }
}

结果

[1, 2, 3, 5]

因为array[0]不用和array[0]比较所以内循环的j要从1开始
因为每趟比较后确定一个数 所以内循环要加上i

折半查找
前提: 必须要有个有序的数组
因为如果不是有序的数组 折半没有意义
代码

int[] array = new int[]{1,3,5,6.9,22]
int min = 0;
int max = array.length - 1;
int mid = (max + min) / 2;
int key = 9;
while(key !=array[mid]){
      if(key > array[mid]){
        min = mid + 1;
    } else if(key < array[mid]){
        max = mid - 1;
    }
    mid = (max + min) / 2;
    if (min > max){
        mid = -1;
        break;
    }
}

结果

4

如果查找的是一个数组里不存在的数 就会造成死循环
所以要在第二次折半操作之后加上条件if (min > max)
当最小值大于最大值的时候停止循环并且输出-1 因为数组里的角标是不能为-1的 就是说当输出-1的时候 表示数组里没有这个数

二维数组
定义: 二维空间是多个一维空间组成的
同样二维数组是多个一维数组组成的 而且是多个相同类型的一维数组
声明方式
1
int [][] array = new int [2][3];
意思是有2个一维数组 并且每个一维数组里面有8个元素

2

int[][] array = new int [][]{
    {1,2,3,4}
    {2,3,1,4}
    {3,5,1,2}
};

意思是有3个一维数组 并且每个一维数组有4个元素
和声明方式1不同的是它表明了所有一维数组中的元素
在二维数组中array.length表明的是二维数组的长度 也就是有几个一维数组
我们来遍历一下声明方式2的二维数组
代码

for(int i = 0; i < array.length; i++){
    for(int j = 0; j < array[i].length; i++){
        System.out.print(array[i][j] + " ");
    }
    System.out.println();
}

结果

1 2 3 4
2 3 1 4
3 5 1 2

其中array[i].length声明的是二维数组中第i个一位数组的长度