java数组2

一、数组概念

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

二、数组的定义格式

数据类型 [] 数组名

数据类型数组名 []

int []arrs=new int[10];
double arrs2[]=new double[10];

三、数组的初始化

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

初始化的分类

动态初始化：只定义长度，由系统给出初始化值
静态初始化：给出初始化值，由系统决定长度

public class Demo01 {
    public static void main(String[] args) {
        //动态初始化
        //推荐将中括号写在前面
        int[] arr=new int[10];
        for (int x:arr){
            System.out.println(x);
        }
        //静态初始化
        int arr2[]=new int[]{10,24,45,123};
        //静态初始化的简写方式
        int[] arr3={12,3,2,12,1};
    }
}

可以通过索引来进行数组元素的读取和重新写入

四、数组的常见操作

数组元素的遍历：通过for循环
注意数组越界异常：ArrayIndexOutOfBoundsException
求数组的最大值和最小值

    public static void main(String[] args) {
        int[] arrays={10,1312,41,24,1,515};
        int Max=arrays[0];
        for (int i = 1; i < arrays.length; i++) {//i从索引1开始
            if (arrays[i]>Max){//小于就是最小值
                Max=arrays[i];
            }
        }
        System.out.println(Max);
    }

数组的反向遍历

public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] arrays={10,1312,41,24,1,515};
        for (int i = arrays.length-1; i >=0; i--) {
            System.out.println(arrays[i]);
        }
    }
}

数组元素的反转

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] arrays={10,1312,41,24,1,515};
        for (int i = 0; i < arrays.length/2; i++) {
            int t=arrays[i];
            arrays[i]=arrays[arrays.length-1-i];
            arrays[arrays.length-1-i]=t;
        }
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }
    }
}

五、二维数组

二维数组就是一维数组的嵌套，就是一个数组里面存放的还是一个数组

二维数组的动态初始化(动态分配内存)：

    public static void main(String[] args) {
        int[][] arrays=new int[3][2];
        int[] array1={1,2};
        System.out.println(arrays);//输出二维数组的地址
        System.out.println(arrays[0]);//输出一维数组的地址
        arrays[0]=array1;//将数组重新赋值，改变的是地址的引用
        for (int[] a:arrays){
            for (int b:a) {
                System.out.println(b);
            }
        }
    }

静态初始化（在创建数组时直接赋值）：

    public static void main(String[] args) {
        //静态初始化
        int[][] array=new int[][]{{20,90,80},{90,5,53,145},{0,15}};
        System.out.println(array[0][2]);
        System.out.println(array[1][3]);
        System.out.println(array[array.length-1][array[array.length-1].length-1]);
        for (int[] a:array){
            for (int b:a
            ) {
                System.out.println(b);
            }
        }
        //简写
        int[][] array2={{20,90,80},{90,5,53,145},{0,15}};
    }

其它二维数组的定义方式

        //二维数组的其它定义方式
        int array3[][];
        int[] array4[];

注意以下语法

int [] a,z[];//注意这种语法，a为一维数组，z为二维数组
a=new int[1];
z=new int[1][1];

二维数组的遍历

public class ToArrayDemo03 {
    public static void main(String[] args) {
        //二维数组的遍历
        int[][] array2={{20,90,80},{90,5,53,145},{0,15}};
        for (int i = 0; i < array2.length; i++) {
            for (int j = 0; j < array2[i].length; j++) {
                System.out.println(array2[i][j]);
            }
        }
    }
}

打印杨辉三角

import java.util.Scanner;
public class TwoDimensionArraysPractice02 {
        //    输出杨辉三角，要求行数自行输入
        //    1.两边都是1
        //    2.从第三行开始，每行的数除了边是的都是上一行的前一列+当前列的值
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入行数:");
        int line = sc.nextInt();
        System.out.println(line);
        int[][] arrays=new int[line][line];
        //    1.两边都是1
        for (int i = 0; i < line; i++) {
            arrays[i][0]=1;
            arrays[i][i]=1;
        }
        //2.从第三行开始，每行的数除了边是的都是上一行的前一列+当前列的值
        for (int i = 2; i < arrays.length; i++) {
            for (int j = 1; j <= i-1; j++) {
                arrays[i][j]=arrays[i-1][j-1]+arrays[i-1][j];
            }
        }
        //遍历
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j <= i; j++) {
                System.out.print(arrays[i][j]+"\t");
            }
            System.out.println();
        }
        sc.close();
    }
}

六.数组元素查找

遍历数组挨个查找

public class ArraySearchDemo01 {
    //通过遍历的方式查找
    public static void main(String[] args) {
        int[] arrays={10,20,3,123,124,12,412,5334,6,47,457,9,20};
        int indexOFArray = getIndexOFArray(arrays, 20);
        System.out.println("索引为"+indexOFArray);
    }

    private static int getIndexOFArray(int[] arr,int num) {
        for (int i = 0; i < arr.length; i++) {
            if (num==arr[i]){
                return i;
            }
        }
        return -1;//返回-1为没查到
    }
}
//如果有重复，是按前面的顺序来算的

使用二分法查找（二分查找的前提是数组必须有序）

每次查找都比较中间的元素，可以减少一半的查找量
通过比较中间索引值的大小不断的改变最大索引位置或最小索引位置

public class TwoDivideSearch {
    public static void main(String[] args) {
        int[] arr={10,20,30,40,50,60,70,80,90};
        //使用二分法查找针对的是已经排序好的数组,其思想是将数组从中间切开，从中间开始查找，若是找不到，则
        //再进行中间切分
        int index=getIndexByTwoDivide(arr,90);
        System.out.println("查找的索引值为"+index);
    }
    private static int getIndexByTwoDivide(int[] arr, int i) {
        int MinIndex=0;//定义一个最小索引
        int MaxIndex=arr.length-1;//定义一个最大索引
        int MiddleIndex=(MinIndex+MaxIndex)/2;//定义一个中间索引
        while(MinIndex<=MaxIndex){
            if (i==arr[MiddleIndex]){
                //如果正好是中间索引对应的值，直接返回中间索引
                return MiddleIndex;
            }else if (i<arr[MiddleIndex]){
                //如果小于中间索引对应的值，则将中间索引设置为最大索引
                MaxIndex=MiddleIndex-1;
            }else if (i>arr[MiddleIndex]){
                //如果大于中间索引对应的值，则将中间索引设置为最小索引
                MinIndex=MiddleIndex+1;
            }
            //将中间索引生新赋值
            MiddleIndex=(MinIndex+MaxIndex)/2;
        }
        return -1;//没找到
    }
}

posted @ 2022-01-12 18:38 是韩信啊阅读(28) 评论(0) 编辑收藏举报

刷新页面返回顶部

先为不可胜，以待敌之可胜！