java 数组

一维数组

数组相当于一个容器,可以存放一组相同类型的数据运算的时候有很多数据参与运算,那么首先需要做的是什么.不是如何运算而是如何保存这些数据以便于后期的运算，那么数组就是一种用于存储数据的方式，能存数据的地方我们称之为容器，容器里装的东西就是数组的元素, 数组可以装任意类型的数据，虽然可以装任意类型的数据,但是定义好的数组只能装一种元素， 也就是数组一旦定义，那么里边存储的数据类型也就确定了。

数组声明规范

元素类型[] 数组名 = new  初值类型[元素长度]

如 int[] array = new int[5];//声明长度为5的数组,长度一旦声明,不可在改变

元素类型[] 数组名 = new 初值类型[]{元素1,元素2,....}

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

堆内存的特点

1,有初始值,2有内存地址3,堆内存垃圾回收机制

数组中取一个值  数组名[下角标]

array=null;//array指向一个空的地方
NullpointerException空指针异常访问了一个可能不存在的区域

数组遍历

注意数组的问题都和遍历有关

//随机10个数随机区间[15,150]
        //1,十个数放入数组中 2打印最大值
        //注意:数组方面的问题都和遍历有关

``` python

int[] array = new int[10];
        for (int i = 0; i < array.length; i++) {
            int num = (int)(Math.random()*(150-15+1)+15);
            array[i]=num;
        }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"+max);

```

函数名字按照小驼峰规则编写

根据索引找元素

实例:封装一函数,传入数字一,则返回星期一

```

public static char findNumber(int a) {
        // 需要一个容器吧中文数据保存下来,按传入数字,查找对应值
        
        char[] array = new char[] { '一', '二', '三', };
        return array[a - 1];
        
    }

```

根据元素找索引

实例:定义一个数组,数组的值分别为3,6,11,22

在数组中查找11的位置

public static int findIndex(int number,int array[] ){

int index = -1;

for (int i = 0 ; i < array.length; i++){

if(array[i] == number){

index = i;

 break;
            }
        }return index;
    }

public static void main(String[] args) {

int[] array = new int[] {3,6,11,12,25,3};
        int d = findIndex(3,array);
        System.out.println(d);}

数组元素反转

```  python

public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] array = new int[] {1,2,3,4,5,6,7,8,9};
        //num 表示 交换的次数
        int num = array.length/2;
        for (int i = 0; i < num; i++) {
            //array[i]和array[array.length-1-i]
            int temp = 0;
            temp = array[i];
            array[i] = array[array.length-1-i];
            array[array.length-1-i] = temp;
            
        }
        System.out.println(num);
        System.out.println(Arrays.toString(array));

```

实际开发中,已系统函数为准Arrays.sort(数组名)

    public static void main(String[] args) {
        int[] array = new int[] { 1,2,3,9,5,6,7 };
        // 该方法无返回值,实际上这个方法操作的是原数组
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
    }

冒泡排序

核心思想:相连的两个数比较大小,并交换位置

*传入的数组相当于将数组的首地址传递进去,拿到地址,就可随便更改数组元素的位置
 *这在sort函数中 就是对原数组进行的操作

//外层循环控制比较的回合数,内层比较每回合次数
        //外循环-1 避免数组越界
        //内循环-i-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;
                }
            }System.out.println(Arrays.toString(array));
        }System.out.println(Arrays.toString(array));
    }

选择排序

选择一个数与下一个数比较(用这个数和数组中的每一个数进行比较)

public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] array = new int[] {1,2,3,4,5};
        //外循环减一,最后同一个数不用比较
        //内循环j的初是指从1开始
        //因为array[0]和array[0]不用比较
        //内循环加i:每一次比较确定一个数
                //每次都可以少比一个数
        for (int  i= 0;  i< array.length-1; i++) {
            for (int j = 0+1; j < array.length; j++) {
                //交换谁和谁
                //array[j]
                if(array[j] < array[i]) {
                   int temp = array[j];
                    array[j] = array [i];
                    array[i] = temp;
                }
                
                
            }
        }System.out.println(Arrays.toString(array));

    }

折半查找

int min = 0;
        
        int[] array = new int[] {1,2,3,4,5,6,11};
        //生命角标
        int max = array.length - 1;
        int mid = (max + min)/2;
        int key =11;
        //声明查找值
        //循环查找 循环里顶要有折班的操作
        //为什么使用while 阴我已明确知道循环什么时候停止
        //key 和中建交表的值比较,如相等循环停止
        while (key != array[mid]) {
            if (key > array[mid]) {
                min = mid + 1;
            } else if (key <array[mid]) {
                max = mid - 1;
            //如果数组中没有这个数会早成死循环,需要出口停止程序
            }mid = (min + max) /2;
            if (min > max) {
                mid = -1;
                break;
            }
        }
        System.out.println(mid);
        

    }

二维数组

二位数组也是容器 ,保存的是多个一维数组,并且是相同类型的一维数组

声明方式:数组类型[][] 数组名 = 初值

int[][] array = new int [1][1];

int[][] array = new int [][]{

{1,2,3,4},{4,5,6},{7,8,}

};

遍历二维数组

public static void main(String[] args) {
        // TODO Auto-generated method stub
        //声明了一个有2个一维数组且每个一维数组是三个元素的二维数组
        //声明时 需要把几个一维数组声明出来
        int[][] array = new int[3][8];
        array [0][0] = 8;
        System.out.println(array[0][0]);
        
        //声明一个有三个一维数组并且每个一维数组中有4个元素哦二维数组
        int[][] arra = new int [][] {
            {1,2,3},{5,6,7,8},{5,1}
        };
        //遍历二维数组
        //array.length 二位数组长度指的是有几个一维数组
        for (int i = 0; i < arra.length; i++) {
            for (int j = 0; j < arra[i].length; j++) {
                System.out.print(arra[i][j]);
            }System.out.println("");
        }

    }