数组

只要是数组操作都是操作的地址，数组传只用的是引用传递。

public class T6 {
    public static void main(String[] args) {
        int a[] = {15, 10, 1};
        int b[] = new int[3];
        b[0]=a[0];
        System.out.println(b[0]);//这里用的是引用传递，传的是值的地址
    }
}

数组介绍：数组前身就是指针控制，申请连续的内存地址，通过地址控制里面存储的数据，连续的内存地址控制。

能让一个变量存储多个值,以后经常会使用到数组，但你见不到，很多数据存储内核都是用数组实现，在Java中数组一旦定制长度不可改变。

string 类型的内核就是数组组成的，以前是char类型的，但是后期优化了byte类型的

public class T6 {
    public static void main(String[] args) {
        int[] i;//这里只是声明这是一个数组而已
        int[] i=new int[5];//只是申请了数组，定制了长度
        int[] i={12,3,4,5,76,7,8};//申请了一个int类型的数组,长度由初始值个数决定
        int[] i=new int[]{12312,123,1,23,123,12};//申请了一个int类型的数组,长度由初始值个数决定，这个感觉是没啥卵用型
        
    }
}

数组的访问：

                   使用下标访问，下标从0开始

                   越界？ 就是你的下标大于等于数组的长度,小于了0 

                   int[] ints=new int[9];   0~8  有效的下标

                   在声明的时候可以用变量值代表长度

                   访问的时候也可以使用变量名 代表下标

import java.util.Scanner;

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

        Scanner input=new Scanner(System.in);
        int[] nums=new int[input.nextInt()];
        for(int i=0;i<nums.length;i++){
            nums[i]=input.nextInt();//通过控制台决定数组长度，并且通过循环选择下标，并给下标赋值
        }
        for(int i=0;i<nums.length;i++){
            System.out.println(nums[i]);
        }

    }
}
 

数组下标为什么从零开始
因为变量指向的是第一片内存地址，没有必要向下移动（因为零代表没有，代表第一个）

数组的内存结构

第一个如果是0 第二个地址就是4 第三个就是8 第四个就是12 因为数组只会就记录第一个地址（因为没必要全记，这是系统操作的）

for循环数组；可以赋值一额可以取值。

                    1.简单

                    2.用于拿取所有的数值

                    接受数据类型 类型只要能存储下就可以

public class T6 {
    public static void main(String[] args) {//取值实验
    int i[]={15,13,35,64,65,48};
        for (int j = 0; j <i.length ; j++) {
            System.out.print(i[j]+"\t");
        }
    }
}

import java.util.Scanner;

public class T6 {
    public static void main(String[] args) {//取值实验
        int i[] = new int[3];
        Scanner input = new Scanner(System.in);
        for (int j = 0; j <i.length ; j++) {//这里是赋值
            System.out.println("请您输入数字");
           i[j]=input.nextInt(); 
        }
        for (int j = 0; j <i.length ; j++) {
            System.out.print(i[j]+"\t");//有赋值那肯定得有取值 
        }
    }
}

Arrays 数组操作类：sort(基本数据类型数组都可以找它排序 ，toString(数组变量) 把数组打印出来

import java.util.Arrays;
public class T6 {
    public static void main(String[] args) {//取值实验
        int i[] = {15, 20, 6};
        Arrays.sort(i);//这里是排序
        for (int j = 0; j <i.length ; j++) {
            System.out.println(i[j]);//这里是取值
        }
        System.out.println(Arrays.toString(i));//也可以这样取值
    }
}

数组引用：引用？  就是指针的理论 指向别人的地址

                 引用？  除了基本数据类型 其他的都是引用
                 除了基本数据类 其他的交换都是内存地址

随机数：Math.random()  出来的值是 0.0~1 范围内的 double值

public class T6 {
    public static void main(String[] args) {
        int i[] = {15, 36, 56, 48, 21};
        int a = (int) (Math.random() * i.length);//随机拿出一个下标
        System.out.println(i[a]);

    }
}

二维数组：

              数组嵌套,数组中嵌套数组，数组中引用数组

              c语言的二维数组的内存是连续的，java中内存不是连续，使用引用操作的

             二维数组，是一张表  有行有列

public class T6 {
    public static void main(String[] args) {
        int b[][] = {{}, {}};//声明二维数组格式
        int a[][] = {{1, 5, 354, 16, 1}, {15, 645, 13, 354, 1}, {15, 64, 21, 1}, {35, 15, 32, 5, 2}};
        
    }
}

二维数组排序

import java.util.Arrays;

public class T6 {//二维数组排序例题

    public static void main(String[] args) {
        int b[];
        int a[][] = {{1, 5, 354, 16, 1}, {15, 645, 13, 354, 1}, {15, 64, 21, 1}, {35, 15, 32, 5, 2}};
        int length = 0;//定义一个变量计算数组所需要的下标长度
        for (int i = 0; i < a.length; i++) {
            length += a[i].length;
        }
        b = new int[length];//决定一维数组的长度
        int index = 0;//声明下标从零开始
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                b[index++] = a[i][j];//将二维数组的值赋值给一维数组
            }
        }
        Arrays.sort(b);//将二维数组赋值给的一维数组的值，进行排序。
        length=0;//在这声明从零开始，下标
        for (int[] num : a) {
            for (int i = 0; i <num.length ; i++) {
               num[i]=b[length++];//将排序好的一维数组值，赋值给二维数组
            }
        }
        for (int i = 0; i < a.length; i++) {
            for (int i1 : a[i]) {
                System.out.println(i1);
            }
        }
    }
}

import java.util.Scanner;

public class Test9 {//一个用循环决定下标数的值的实验

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        int[] select = new int[100];
        int index = 0;//先控制下标从零开始

        while (true) {
            System.out.println("1.葡萄");
            System.out.println("2.香蕉");
            System.out.println("3.黄瓜");
            System.out.println("4.苦瓜");
            System.out.println("5.退出");
            System.out.print("请选择:");
            int s = input.nextInt();
            if (s == 5) {
                break;
            }
            select[index++] = s;//这里选择数字进行累计，并赋值给一维数组
        }

        System.out.println("您选择的是:");
        for (int i = 0; i < select.length; i++) {
            if (select[i] == 0) {
                break;
            }
            if (select[i] == 1) {
                System.out.println("葡萄");
            } else if (select[i] == 2) {
                System.out.println("香蕉");
            } else if (select[i] == 3) {
                System.out.println("黄瓜");
            } else if (select[i] == 4) {
                System.out.println("苦瓜");
            }
        }

    }
}

public class T6 {//二维数组随机数实验
    public static void main(String[] args) {
        int a[][] = {{1, 54, 56, 54}, {485, 354, 321, 546, 1}, {5, 464, 8, 243, 44, 5}};
        int i = (int) (Math.random() * a.length);
        int b = (int) (Math.random() * a[i].length);
        System.out.println(a[i][b]);
    }
}