数组（入门向）

什么是数组

数组是用来存储一组相同类型数据的数据结构，它是一组连续的空间

数组包含 数组名 、数组类型、下标、值

如何使用数组

1.声明数组

数据类型  数组名[ ] ; 或 数据类型[ ]  数组名 ;

例: int scores[ ]; 或者 int[ ] scores;

2.分配空间

数组名 = new 数据类型[空间大小] ;                         //空间大小也叫长度 length

例: socores= new int[5];

上面两步合在一起

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

int scores[ ]= new int[5];

int[ ] scores= new int[5];

3.赋值

向分配的格子里放数据(x注意下标是从0开始)

例：

scores[0] = 89;

scores[1] = 79;

scores[2] = 76;

scores[3] = 43;

scores[4] = 45;

情形一：静态赋值，边声明边赋值

数据类型[ ] 数组名 =｛｝;                         //用于确定一组数，但创建数组并赋值的方式必须在一条语句中完成

例：int[ ] scores = {89,79,76,43,45};

我们也可以在定义数组的同时一并完成赋值操作，如：

数据类型[ ] 数组名 = new 数据类型[ ]｛值1，值2，... 值n｝

情形二: 动态地从键盘录入信息并赋值。这里数组会和for循环结合在一起使用，循环遍历数组赋值

int[]  scores=new int[5];

Scanner input = new Scanner(System.in);

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

scores[i] = input.nextInt();

}

4.处理数据

通过下标来使用数据

增强for 格式： for(类型 临时变量；数组名)｛｝                 //临时变量相当于数组中的每一个值

例：

for（int i；scores）{

System.out.println(i);

}

快捷键  数组名.fori

应用

1.利用数组求最值

先初始化最值变量（让数组中的第一个值赋给变量）

循环遍历数组、依次与变量比较，不符合条件的，替换变量的值

循环结束后，得到的变量即为最值

public class Demo1 {
    public static void main(String[] args) {
        int[] arr=new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i]=(int)(Math.random()*100);
        }
        for (int i1 : arr) {
            System.out.print(i1+" ");
        }
        System.out.println();
        int Max=arr[0];
        for (int i : arr) {
            if (Max<=i) Max=i;
        }
        System.out.println(Max);
    }
}

2.数组修改/删除

先赋一个初始变量

循环遍历数组，找到要修改的值下标，赋给变量

直接删除/修改

如果是删除的话，从要删除的位置往后的值向前移一位，把最后一位赋值为初始值

3.数组插入值（数组本身有序，插入要保证不会越界）

数组扩容（新数组最后一个数据为默认值）

从后向前遍历，最后一个除外

比较数值大小，遇到大的值，直接在后一个插入，跳出遍历；遇到小的值，该值后移

如果从头到尾都没有插入，则插入在首位

public class Demo2 {
    public static void main(String[] args) {
        int[] arr={99,85,82,62,60};
        int[] b=new int[arr.length+1];
        for (int i = 0; i < arr.length; i++) {
            b[i]=arr[i];
        }
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个数：");
        int num=sc.nextInt();
        int flag=0;
        for (int i = b.length-2; i>= 0; i--) {
            if (num<=b[i]){
                flag=1;
                b[i+1]=num;
                break;
            }else b[i+1]=b[i];
        }
        if(flag==0) b[0]=num;
        System.out.println(Arrays.toString(b));
    }
}

4.冒泡排序法

public class Bubble1 {
    public static void main(String[] args) {
        int[] a=new int[10];
        for (int i = 0; i < a.length; i++) {
            a[i]=(int)(Math.random()*100);
        }
        System.out.println(Arrays.toString(a));
        //冒泡排序
        //从前向后遍历，大循环表示轮数，每一轮确定一个值，n个数排序只需n-1轮
        for (int i = 0; i < a.length-1; i++) {
            int flag=0; //每轮开始先初始判断值
        //小循环每次从头开始，因为每一轮会确定一个值，那就有i个数确定，为避免对后面的数重复比较，因此-i
            for (int j = 0; j < a.length-1-i; j++) {
                if (a[j]>a[j+1]) {
                    flag=1;       //若相邻的两个数，前一个数较大，则需要交换，判断值改变为1
                    int temp=a[j]; //三变量交换法
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
            if (flag==0) {    //经过小循环之后，判断值没有改变，则表明没有需要交换的数，则满足从小到大排列，退出大循环，排序结束
                System.out.println("经过"+(i+1)+"轮排序完毕");
                break;
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

5.插入排序法

public class InsertionSort1 {
    public static void main(String[] args) {
        int[] a=new int[10];
        for (int i = 0; i < a.length; i++) {
            a[i]=(int)(Math.random()*100);
        }
        System.out.println(Arrays.toString(a));
        //插入排序
        //1.从第二个值开始，向后扩展轮数
        //2.从后向前遍历，执行插入元素的过程
        for (int i = 1; i < a.length; i++) {   //大循环从第二个数开始，一直到最后一个数
            int temp=a[i];  //每轮要插入的值
            boolean flag=true;  //查看是否需要插入
            for (int j = i-1; j >= 0; j--) {//因为从后向前遍历，a[i]先和a[i-1]比较，小循环从i-1一直到0
                if (temp<a[j]) {
                    a[j+1]=a[j];   //不满足条件，被比较的值后移
                }else{              //满足条件，该值插入在被比较值后面
                    flag=false;    //已找到位置，不需要插入到首位
                    a[j+1]=temp;
                    break;
                }
            }
            if (flag) {        //经过小循环过后，该数没有插入
                a[0]=temp;    //将该数插入到首位
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

6.选择排序法

public class SelectionSort1 {
    public static void main(String[] args) {
        int[] a=new int[10];
        for (int i = 0; i < a.length; i++) {
            a[i]=(int)(Math.random()*100);
        }
        System.out.println(Arrays.toString(a));
        //选择排序
        //1.每一轮确定一个基准值，向后遍历，找到最值，交换位置
        //2.每一轮确定一个最值，再对剩下的数选择替换，
        for (int i = 0; i < a.length-1; i++) {  //大循环表示轮数，每一轮确定一个值，n个数排序只需n-1轮
            int min=a[i];    //确定基准值
            int minposition=i;  //确定基准值位置
            //小循环从a[i]下一个开始，一直到最后一个数
            for (int j = i+1; j < a.length; j++) {
                if (min>a[j]) {   //在每一轮中找最小的数
                    min=a[j];     //若满足条件，更新基准值为该数值
                    minposition=j;  //更新并记录基准值位置
                }
            }
            a[minposition]=a[i];  //  将a[i]的值和得到基准值的那个数的值互换
            a[i]=min;             //
        }
        System.out.println(Arrays.toString(a));
    }
}

二维数组

从内存分配的角度上来说，Java中只有一维数组。二维数组实际上是一个一维数组，它的每个元素又是一个一维数组。

1.初始化二维数组

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

2.二维数组的遍历

使用for循环遍历二维数组

Arrays类

1.比较两个数组是否相等(长度及元素)

Arrays.equals(数组名1,数组名2)                    返回类型boolean

2.对数组的元素进行升序排列

Arrays.sort(数组名)                                        返回类型void

3.将数组转换成字符串

Arrays.toString(数组名)                                 返回类型String

4.将数组所有元素赋值为相同的值

Arrays.fill(数组名,替换值）                            返回类型void

5.将数组复制成一个长度为设定值的新数组

Arrays.copyOf(数组名，长度设定值)             返回类型与数组名的数据类型一致

6.查询元素在数组中的下标

Arrays.binarySearch(数组名，待查元素)      返回类型为int