java学习 java -- 数组

所谓数组，就是一个元素的序列。若将这个序列起一个名字就是数组名，组成这个序列中的每一个变量叫做 数组的元素 在区分数组的各个元素的数字标号称作下标，这个下标一般从零开始。这些无序排列的同类数据元素的集合就叫数组。

数组相当于一个容器，可以储存多个相同类型数据的集合。

数组的分类：一维数组，二维数组，多维数组。

一维数组：

1.数组的声明：方式一
数据类型[] 数组名 = 初值；
举个例子：int[] array = new int[5];

那么数组既然是一个容器，那么这个容器是放在了电脑的什么位置呢？

我做了一个图可以看一下

栈内存和堆内存
我们在main函数中声明的这个 int a = 10；的变量 是放在栈内存中的 栈内存的特点就是存放的是函数的参数值，执行完毕 会立即释放 释放是被系统释放掉 不用你来管理

在之前的例子中 new 是什么意思呢？
这是在堆内存中开辟了一块空间，数组是在堆内存之中开了一块连续的空间

那我们在main函数中声明之后是保存在栈内存中的 如何与 堆内存取得联系呢 ？

当你在声明的时候，他会在栈中开辟一个地址空间, 同时 也会在堆中开辟一块连续的空间，栈中的空间指向堆的首地址
堆内存的特点：
1.堆内存 有初始值
2.堆内存 有内存地址
3堆内存 有垃圾回收机制
方式二：
数组声明方式二（语法糖）
直接声明出 数组中保存的值
说到这里 我们要说一下随机数
见名知意，随机数就是 随机的数，范围是[0 - 1)之间的小数，使用的是math类
例题
需求 【5 - 10】
* 6 –> [0 - 5]
+ 5 –> [5 - 10]

需求 【18 - 200】
* 183 –> [0 - 182]
+ 18 –> [18 - 200]
分析得出公式：*（最大值 - 最小值 + 1） + 最小值

例题：随机 【15 - 200】的整数 10个并打印出最大值

    int max = 0;    for (int i = 0; i < 10; i++) {        int num = (int)((Math.random() * (200 - 15 + 1) + 15);        System.out.println(num);        if (max<num) {            max = num;        }    }    System.out.println(max);

二、数组的遍历

int[] array = new int[] {1,3,5,7,9};
打印数组中所有的值
array.length –> 数组的长度

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

Arrays.toString(array) 将数组 转化成字符串 来输出

    System.out.println(Arrays.toString(array));

例题练习：需求：随机10 个数 随机的区间为【15 - 150】
1.把这个 10个数放入数组中
2.打印最大值

    int[] array = new int[10];    for (int i = 0; i < 10; i++) {        int number = (int)((150 - 15 + 1) * Math.random() + 15);        array[i] = number; // 随机数放入数组中    }    System.out.println(Arrays.toString(array));    int max = 0;    for (int i = 0; i < array.length; i++) {        // 判断最大值        if (max < array[i]) {            max = array[i];        }    }    System.out.println(max);

数组 的练习
1.根据索引找元素
需求：封装一个函数 传入数字1 返回星期一

//  查表发 public static char findNumber(int a) {//  需要一个容器  把中文数据保存一下//  按传入的数字  查找对应的值    char[] array = new char[] {'一','二','三','四','五','六','日'};    return array[a - 1];}public static void main(String[] args) {    char rel = findNumber(7);    System.out.println(rel);}

2.根据元素找索引
需求：定义一个数组 数组的值分别为 3 6 11 22
在数组中 查找 11 的位置

  public staic int findIndex(int[] array, int number){  定义一个索引 为返回值        int index = 0;  遍历数组  查找对应索引        for(int i = 0; i < array.lenth; i++) {        如果值相等  就保存索引            if(array[i] = number) {                index = i;                只要有相等值就  停止循环                break;            }        }        return index;   }    public static void main(String[] args) {    int[] array = new int[]{3, 6, 11, 22};    int rel = findIndex(array, 11);    System.out.println(rel);

数组元素 反转（把数组中的元素 位置进行改变）

如何交换两个数的值

    int a = 6;    int b = 7;    int temp = 0;    temp = a;    a = b;    b = temp;

这样的一段代码 就可以实现 将a和b的值进行位置的 改变
那么 如何将数组的元素进行反转呢
分析：就是将数组的所有的元素位置反转 int[] array = new int[] {1,2,3,4,}
这里的反转我们要的结果是{4，3，2，1}，也就是说只要将4 和 1的位置改变一下，还有3 和 2的位置改变一下就可以了，如果是5个元素也是如此，因为中间的元素位置不许改变。我们可以利用数组的下标 来区分元素

在这个交换的过程中我们需要交换的次数可能很多所以我们用for来控制 交换的过程

 for (int i = 0; i < number; i++) {          array[0]  和  array[array.lenth - 1 - 0]          array[1]  和  array[array.lenth - 1 - 1]          array[2]  和  array[array.lenth - 1 - 2]          array[i]  和  array[array.lenth - 1 - i]  交换

根据以上分析 代码：

    int[] array = new int[] {1,2,3,4,5,6};    //  number 标示  交换的次数    int number = array.length / 2;    for (int i = 0; i < number; i++) {        int temp1 = 0;        temp = array[i];        array[i] = array[array.length - 1 - i];        array[array.length - 1 - i] = temp;    }    System.out.println(Arrays.toString(array));

那么 将这个交换的功能封装成一个函数

为什么封装后不可以 实现这个功能呢？
附图说明

数组的排序
1.冒泡排序
1.冒泡排序
* 核心：相邻两个数 比较大小 交换位置
*分析：
原数 3 2 5 1
*第一趟
*2 3 5 1
*2 3 5 1 array.lenth - 1 - 0
*2 3 1 5 确定了一个数（把最大值放在了最后面 2跟3比较 确定了一个5）
*第二趟
*2 3 1 5 array.lenth - 1 - 1
*2 1 3 5 有确定了一个数（3跟1比较）
*第三趟 array.lenth - 1 - 2
*1 2 3 5 又确定了一个数（2跟1比较）

    int[] array = new int[] {5,8,2,4,3,9,1,7};    System.out.println("数组排序之前的顺序：");    System.out.println(Arrays.toString(array));    //  外层循环控制了 趟数    for (int i = 0; i < array.length - 1; i++) {        //  内循环 - 1：避免越界        //  内循环 - ：一趟比较 确定一个数 就以为 下一次比较可以少比一次        for (int j = 0; j < array.length - i - 1 ; j++) {            if (array[j] > array[j + 1]) {                int temp = array[j];                array[j] = array[j + 1];                array[j + 1] = temp;            }        }        System.out.println("第" + ++i + "趟的排序：");        System.out.println(Arrays.toString(array));    }    System.out.println("最终排序结果：");    System.out.println(Arrays.toString(array));