数组加强1

数组概念

数组是存储同一种数据类型多个元素的集合。也可以看成一个容器。

数组即可以存储基本数据类型，也可以存储引用数据类型

定义格式

 

 什么是数组初始化

java中的必须先初始化，然后才能使用

所谓的初始化，就是为数组中的数组元素分配内存空间。并为每个数组元素赋值

 

初始化分类；

a;动态初始化；指定长度，由系统给出初始值

b;静态初始化；给出初始化值，由系统决定长度

注意事项；这两种方式只能使用一种，不能进行动静结合

 

动态初始化的格式与获取

      数据类型[] 数组名 = new 数据类型[数据长度]

      数据长度其实就是数组中元素的个数

    

   在数组初始化时，会为每一个元素索引（角标）这个索引从0开始。通过索引取出某个元素。也是通过索引会给元素重新赋值。

   例： int num = arr[1];

           

数组的常见操作

1；数组元素的遍历

2；数组常见的角标越界异常

3；数组元素的反向遍历

4；获取数组元素的最大值最先值

5；数组元素的反转

 

1；数组遍历

使用for循环来遍历数组

public class Outer {
    public static void main(String[] args) {
        int [] arr ={10,20,30,40,50};
        for(int i =0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }


}
反向遍历

public class Outer {
    public static void main(String[] args) {
        int [] arr ={10,20,30,40,50};
        for(int i = arr.length-1;i>=0;i--){
            System.out.println(arr[i]);
        }
    }


}
2；获取数组最值
获取数组中的最大值或者最小值

public class Outer {
    public static void main(String[] args) {
        int [] arr ={10,20,36,21,67,40,50};
        //获取数组中的最值
        //定义一个参照值
        
        int max=arr[0];
        for(int i = 1;i< arr.length;i++){
            if(arr[i]>max){
                max = arr[i];
            }
        }
        System.out.println("数组最值"+max);
    }


}

3；反转数组元素

public class Outer {
    public static void main(String[] args) {
        int[] arr = {10, 20, 36, 21, 67, 40, 50};
        //反转数组中的元素
        // 思路；首尾元素互换

        for (int i=0;i< arr.length/2;i++){
            int t =arr[i];
            arr[i]=arr[arr.length-1-i];
            arr[arr.length-1-i] =t;
        }

    }
}

4；二维数组

（1）二维数组的概述
：二维数组中的每一个元素为一个一维数组


（2）二维数组的定义格式
：  数据类型[][]变量名 = new 数据类型[][];
:m表示这个二维数组中有多少个一维数组
：n表示每一个一维数组的元素个数

public class Outer {
    public static void main(String[] args) {
        //定义方式一。动态定义
        int[][] arr =new int[3][2] ;
        
        //定义方式二。静态定义
        int[][] arr1 ={{20,62,4},{80,30,95},{10,10}};
        
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[0][0]);
        //给二维数组里面的每一个元素赋值
        arr[0] = new int[2];
        arr[1] = new int[2];
        arr[2] = new int[2];


    }
}

（3）二维数组的遍历

 //定义方式二。静态定义
 int[][] arr1 ={{20,62,4},{80,30,95},{10,10}};

 System.out.println(arr);
 System.out.println(arr[0]);
 System.out.println(arr[0][0]);
 //给二维数组里面的每一个元素赋值
 arr[0] = new int[2];
 arr[1] = new int[2];
 arr[2] = new int[2];

//遍历  双重for循环
 for (int i = 0; i < arr1.length; i++) {
    // System.out.println(arr[i]);
     for (int j = 0; j < arr1[i].length; j++) {
         
     }
     
 }

（4）二维数组的联系

求和

 int[][] arr ={{22,66,44},{77,33,88},{25,45,65},{11,66,99}};

 //定义一个变量用来接受结果
 int sum =0;

//遍历  双重for循环
 for (int i = 0; i < arr.length; i++) {
     for (int j = 0; j < arr[i].length; j++) {
   sum+=arr[i][j];
     }

杨辉三角

import java.util.Scanner;

public class Outer {
    public static void main(String[] args) {


       //键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("清输入行数");
        int n =sc.nextInt();

        //定义一个二维数组
        int[][] arr =new int[n][n];
      //把每一行的第一列跟最后一列设置为1
        for (int i = 0; i < arr.length; i++) {
            arr[i][0]=1;
            arr[i][i]=1;
        }

        //添加中间量
        for (int i = 2; i < arr.length; i++) {
            for (int j = 1; j <= i; j++) {
             arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
            }
        }


        //遍历二维数组
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j <= i; j++) {
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }

    }
    }

（5）数组查找与二等分查找
1；遍历数组查找

public class Outer {
    public static void main(String[] args) {


        //定义一个二维数组
        int[]arr ={12,23,41,12,45,64,20,35,24};

        //根据元素查找该元素在数组中的第一次出现的索引
        int index =getIndexBYELE(arr,20);
        System.out.println("该元素在数组中第一次出现的索引时"+index);

        }

    private static int getIndexBYELE(int[] arr,int i) {
        //遍历数组
        for (int i1 = 0; i1 < arr.length; i1++) {
            if(i==arr[i1]){
                return i1;
            }
        }
        return -1;//没有找到返回-1
    }

}

2；二等分查找
二分查找前提时数组中元素必须有序

import java.util.Scanner;

public class Outer {
    public static void main(String[] args) {


        //定义一个二维数组
        int[] arr = {10, 20, 30, 40, 50, 60, 70, 80,90 };

       int index =getIndexBELE(arr,10);
        System.out.println(index);
    }

    private static int getIndexBELE(int[] arr, int i) {
        //定义最小索引，中间索引，最大索引
        int minIndex = 0;
        int maxIndex = arr.length-1;
        int centerIndex = (minIndex + maxIndex) / 2;

        //如果这个元素等于中间索引对应的元素就直接返回中间索引

        while (minIndex <= maxIndex) {
            if (i == arr[centerIndex]) {
                return centerIndex;

                //如果大于中间索引，就更改最小索引
            } else if (i > arr[centerIndex]) {
                minIndex = centerIndex + 1;
                //如果小于中间索引，更改最大索引
            } else if (i < arr[centerIndex]) {
                maxIndex = centerIndex - 1;
            }
            //重新计算中间索引
            centerIndex = (minIndex + maxIndex) / 2;
        }
            return -1;
        }

}