java之数组的索引,排序以及二维数组

数组的索引
1,通过索引查找数组的元素
即通过元素的下标来查找该元素

int[] array = new int[] {1,2,3,4,5};
    int num = array[2];
    System.out.println(num);

输出为:3.
要注意的是,数组中元素的下标是从0开始计数的
2.通过元素查找索引,即查找元素在数组中的下标

    int num = 5;//查找该元素在数组中的位置
    int index = -1;//定义一个变量用来记录元素的下标
    int[] array = new int[] {1,2,3,4,5,6};
    for (int i = 0; i < array.length; i++) 
    {
        if (array[i]==num) 
        {
            index = i;//当数组中的元素与要查找的元素的值一样时,则查到了
            break;//跳出循环
        }
    }
    System.out.println("在数组中的位置为"+index);//如果输出为-1,则说明该元素不在数组中

输出为

在数组中的位置为4

数组元素的反转:即数组中的元素对称交换位置
例:封装一个函数,用来对数组反转

public static int[] change(int[]array)
{
    int num = array.length/2;   //确定要交换的次数,即循环的次数
    for (int i = 0; i < num; i++) 
    {
        int temp = array[i];        //需要定义一个变量作为中间值
        array[i] = array[array.length-1-i];
        array[array.length-1-i] = temp;
    }
    return array;
}

再写一个函数,有来交换两个数的值

public static void changeNumber(int a,int b)
{
    int temp = a;
    a = b ;
    b = temp;
}
public static void main(String[] args) {
    int a = 10; 
    int b = 100;
    changeNumber(10, 100);
    System.out.println("a的值为"+a +",b的值为"+b);
    }

则输出结果是a = 10,b =100,
那么为什么两个数的值并没有交换,而数组中的元素却交换了?

因为,所有的函数都是存在于栈内存中的,而数组是存在堆内存中,在数组的元素交换中,数组传入函数中的是,数组的地址,函数内部是通过地址找到堆内存中的数组,并对数组进行操作的,
但是仅仅是交换两个数的值时,两个数值都是存在于main函数中,也是存在栈内存中,传入changNumber函数的俩值其实就是俩常数,并未将main函数中的a,b传进去.
⚠️栈内存的特点是当函数运行完毕时,系统会立即释放内存,但是堆内存中的垃圾回收机制(GC)有滞后性.
数组的排序
数组的排序的方法有很多:冒泡排序,选择排序,插入排序等.另外系统中也给我提供了排序的方法
1.系统提供的排序方法

int[]array = new int[] {2,3,8,1,5,6};
    Arrays.sort(array);
    System.out.println(Arrays.toString(array));

输出为:[1, 2, 3, 5, 6, 8]
可以看出系统提供的是升序排列的方法
2.冒泡排序
冒泡排序的流程是:比较相邻俩元素的大小,然后根据需要交换位置

int[]array = new int[] {2,3,8,1,5,6};
//冒泡排序的外层控制的是需要确定元素的次数
    for (int i = 0; i < array.length-1; i++) {
    //内层循环控制的是每个数需要比较的次数,-i是因为有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; 
            }
        }
            System.out.println(Arrays.toString(array));

输出结果为:

[1, 2, 3, 5, 6, 8]

3.选择排序
选择排序的原理:选择一个数和数组中的其它数都进行一次比较,然后根据大小进行交换位置,一般第一个数会选择下标为0的数

    for (int i = 0; i < array.length-1; i++) 
    {
    //i+1是因为每次重新开始循环就说明确定了一个值,则比较的次数就少1
        for (int j = i+1; j < array.length; j++) 
        {
            if (array[i]>array[j]) 
            {
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }
    }
    System.out.println(Arrays.toString(array));

输出结果为

[1, 2, 3, 5, 6, 8]

折半查找
折半查找的前提是数组要是一个有序的数组
折半查找的原理是先把要查找的值和数组的中间值进行比较,如果小于中间值,则再和左半边数组的中间值进行比较,一直到找出值为止,或者倒最后也没有找到(也可以理解为最小下标和最大下标的移动)
例:求出15在下列数组中的位置

int[] array = new int[] {3,6,8,11,13,19,25};

int num = 15;
    int min = 0;
    int max = array.length - 1;
    int mid = (min + max)/2;
    while (array[mid]==num)
    {
        if (array[mid]>num)
        {
            max = mid-1;
        }else if (array[mid]<num) 
        {
            min = mid +1;
        }
        mid = (min + max)/2;
        if (min>max) 
        {
            mid = -1;
        }
    }
    System.out.println("该元素在数组中的位置为:"+mid);

输出结果是:该元素在数组中的位置为:-1,则说明15不在数组中.
二维数组
二维数组的定义:将一组数据类型相同的一维数组放在一起,二维数组也是一个容器
声明二维数组的方法:

 int[][] arr = new int[5][6];//二维数组中有5个一维数组,每个一维数组中又装了6个元素,切元素都是int类型的

二维数组的声明只需要把二维数组的长度声明了即可,也可以不声明一维数组的长度

 int[][] arr = new int[5][];

//直接在后面写出数组中的元素也是可以的
int[][] arr = new int[][] {
        {1,2,5,4,9},
        {6,7,3,6,8},
        {2,4,1,5,3}
    };

二维数组的遍历
即:将数组中的元素全部访问一遍

int[][] arr = new int[][] {
        {1,2,5,4,9},
        {6,7,3,6,8},
        {2,4,1,5,3}
    };
    for (int i = 0; i < arr.length; i++) {
        for (int j = 0; j < arr[i].length; j++) //将二维数组中的一维数组全部遍历一遍
        {
            if (i==arr.length-1 &&j == arr[arr.length-1].length-1) 
            {
            System.out.println(arr[i][j]);  
            }
            else
            {
        System.out.print(arr[i][j]+",");
        }
        }

    }

输出结果为

1,2,5,4,9,6,7,3,6,8,2,4,1,5,3