java数组

Java 语言中提供的数组是用来存储固定大小的同类型元素。

其实数组和python中的列表是一样的 ，但是声明和定义的是不一样但是意义是一样的

数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型

创建数组对象会在内存地址中开辟一整块连续的空间，而数组名引用的是这块连续空间的首地址

数组的程度一旦确定就不能更改

我们可以直接通过下标（索引）的方式调用制定位置的元素，速度很快

数组的分类：

按照维度：一维数组、二维数组、三维数组....
按照匀速的数据类型分类：基本数据类型元素的数组、引用数据类型的数组（即对象数组）

一维数组：

数组的定义声明

静态初始化：就是定义好数组内的元素

首先我们要先声明这个数组：
数组内存放的类型  []  数组名字 = new 数组类型[] {数组内的元素}；
eg:
    int [] ids = new int[]{1,2,3};  //定义一个数组ids内部存放int的类型的数组。它的值都是1 2 3


还可以写成：
int array [] = new int []{};
或者：
　　int array [] = {1, 2} //直接进行赋值

动态初始化：只定义数组的长度 内部的元素可以自己添加

数组元素类型 []  数组名 = new 数组元素类型  [数组存放的元素个数];
String [] names= new String[5];  // 定义一个names数组 里面可以存放5个字符串 这个数组的长度就是5

数组的取值也是通过下标来进行。也是默认从0开始。

数组的程度可以通过length这个关键字来查看的

直接数组名.length就可以查看数组长度

数组的默认元素的初始化：

public class array {
    public static void main(String[] args) {
        int [] arr = new int [5];   // 声明一个长度为5的数组
        for(int i = 0; i < arr.length; i++){  // 循环 判断不能超过数组长度
            System.out.println(arr[i]);  // 通过下标来打印出数组的元素
        }
    }

}


// 得到的结果都是0

如上图所示。首先。你再创建数组的时候会现在内存地址中开辟两块区域一块是栈一块儿是堆。栈存放的是数组的名字 堆存放的时候数组元素，内存地址开辟好后 数组先默认都是0，当开辟完成之后 你的堆空间会为你的存放的数据开辟一个首地址值然后把这个首地址值赋给栈空间 然后 访问的时候栈空间就会通过首地址值来找到对应的堆空间

练习：

从键盘读入学生成绩，找出最高分， 并输出学生成绩等级。 成绩>=最高分-10 等级为’A’ 成绩>=最高分-20 等级为’B’ 成绩>=最高分-30 等级为’C’
其余 等级为’D’

提示:先读入学生人数，根据人数创建int数组， 存放学生成绩。

import java.util.Scanner;

public class array {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入学生的个数");
        int number = scan.nextInt();
        int [] arry = new int [number];// 定义数组的额长度
        for(int i = 0; i < arry.length; i++){
            System.out.println("请输入第"+(i+1)+"个学生的成绩");
            int chengji = scan.nextInt();
            arry[0] = chengji;
        }
        //获取数组中的最大值 是用简单的数学基础来进行比较
        //首先定义一个受罪用所有的成绩都和它比较 最后赋值最大的成绩
        int Maxscore = 0;
        for(int i = 0; i < arry.length; i++){
            if(Maxscore < arry[i]){
                Maxscore = arry[i];  // 把每一次的比较的值都赋值给他
            }
        }
        System.out.println("成绩对最好的是"+Maxscore);
        // 然后是输出每个学生的成绩等级
        // 成绩>=最高分-10 等级为’A’
        // 成绩>=最高分-20 等级为’B’
        // 成绩>=最高分-30 等级为’C’
        //其余 等级为’D’

        char level;  // 让它来表示等级
        for(int i = 0; i < arry.length; i++){
            if(arry[i] >= Maxscore -10){
                 level = 'A';
            }else if(arry[i] >= Maxscore-20){
                level = 'B';
            }else if(arry[i] >= Maxscore-30){
                level = 'C';
            }else{
                level = 'D';
            }
            System.out.println("student"+i+"score is" +arry[i]+"grade is"+level);
        }

    }

}

二维数组

对于二维数组的理解 其实可以理解为数组的嵌套，例如以为数组array1又作为另一个一维数组array的元素而存在。其实从数组的底层来看没有多维数组

二维数组的定义：

数组类型 [][] 数组名 = new 数组类型[][]；
eg:
    int [][] array1 = new int[][];  //定义一个array1的二维数组

其实二维数组也就是多个[]但是[]内的元素放置也是有其他含义的：

int [][] array1 = new int[3][2];  
这个是定义了一个array1 的二维数组。这个数组中有3个一维数组 每个数组的元素有2个；

也就是前面的[]代表有几个一维数组后面的[] 代表每个一维数组的元素个数

二维数组的静态初始化：

int [][] array = new int[][]{{1, ,2, 3}{1, 2}{0, 1, 2, 3}; //前面必须是两个[][]

定义一个二维数组内部有3个一维数组，第一个一维数组的长度是3有三个元素分别是：1 2 3，
第二个一维数组长度是2 元素分别是：1 2 第三个一维数组的长度是4元素分别是 0 1 2 3

二维数组的动态初始化：int [][] array1 = new int [3][];

int [][] array1 = new int [3][];

二维数组中有3个一维数组每一个一维数组中的默认初始化值是null
可以对这个三个一维数组分别赋值
array1[0] = new int[3]

获取二维数组中的元素：

int [][] array =  new int [][]{{1, 2, 3},{0, 1}{3, 4, 5}}


获取第一个一维数组的第二个元素：arrayp[0][2]   //前面的第一个元素获取第一个一维数组 然后再根据下标或者这个数组中的元素

int [][] array = new int [2][3];

array[0][0] = 7;  // 对二维数组中第一个数组中的第一个元素赋值
array[1][0] = 3;  // 对二维数组中第二个数组中的第一个元素赋值
array[1][1] = 3;   // 对二维数组中第二个数组中的第二个元素赋值

System.out.println(array[1][0]);  //3
System.out.println(array); //[[I@61bbe9ba   打印的是这个数组的内存地址值和python不一样打印的不是它的元素 是他的地址值

循环遍历二维数组：

public class array{
    public static void main(String[] args) {
        int [][] array = new int [][]{ {1,2},{0,1},{8,9}};
        for(int i = 0;i<array.length; i++){
            for(int j= 0;j<array[i].length;j++){
                System.out.println(array[i][j]+"	");
            }

        }

    }
}

 数组元素的复制：

public class array{
    public static void main(String[] args) {
        String [] arr = new String []{"jj", "dd", "bb", "GG"};

        // 数组的复制
        String [] arri = new String[arr.length];

        for(int i = 0; i < arr.length; i++){
            arri[i] = arr[i];

        }
        System.out.println(arri[2]);
    }
}

二分查找算法：

import java.util.Scanner;
public class sort {
    public static void main(String [] args){
        int[]arry = new int []{-99, -54, -2, 0, 2, 33, 43, 256, 999};  //二分查找要确保这个数组是有序的
//        Scanner scan = new Scanner(System.in);
//        int num = scan.nextInt();
        int num = 33;  // 要找的数字
        int head = 0;  //首索引位置
        int end = arry.length -1;
        boolean flag = false;  //标致位用来表示  是否找到

        while(head <= end){   // 要保证左边不能超过右边的
            int middle = (head + end)/2;
            if(num == arry[middle]){
                System.out.println("找到了指定的元素 位置为"+middle);
                flag = true;
                break;

            }else if(num > arry[middle]){   // 右边进行比较
                head = middle+1;

            }else if(num < arry[middle]){
                end = middle -1;
            }

        }
        if(flag == false){
            System.out.println("很遗憾没有找到");
        }
    }
}

冒泡排序：

public class sort{
    public static void main(String[] args) {
        int [] array = new int []{1, 3, 2, 5, 7, 6, 89, 45};
        //冒泡排序


        for(int i = 0; i < array.length; i++){
            for( int j = 0; j < array.length -i -1; j++){  // 去掉上一次遍历的原有的数字
                if(array[j] > array[j+1]){
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                }
            }
        }
        for(int i = 0; i < array.length; i++){  // 输出数组
            System.out.print(array[i]+"	");
        }
    }
}

 Arrays工具类的使用：数组的操作方法

首先要先倒入java.util.Arrays

import java.util.Arrays;  // 倒入操作数组的工具包
public class sort{
    public static void main(String[] args) {
       // boolean equals = Arrays(array1, array2) //判断两个数组是否相等
        int [] arr1 = new int[]{1, 2, 3, 4};
        int [] arr2 = new int[]{1, 3, 2, 4};
        int [] arr3 = new int[]{1, 2, 3, 4, 5};
        boolean isEquals = Arrays.equals(arr1,arr2);
        boolean flag = Arrays.equals(arr1, arr3);
        System.out.println(isEquals); // true
        System.out.println(flag);  //false

        // 输出数组信息： String toString(int [] a)
        System.out.println(Arrays.toString(arr1));  //[1, 2, 3, 4]

        // 将指定数组的值进行替换 void.fill(int [] a, int val)

        Arrays.fill(arr1,10);  // 把数组arr1 的值都替换成10
        System.out.println(Arrays.toString(arr1));  //[10, 10, 10, 10]

        // 对数组进行排序： void sort(int [] a)

        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));  //[1, 2, 3, 4]
    }
}