2021-07-16

四.数组

1.数组的概述

• 数组是相同类型数据的有序集合

• 数组描述的是相同的类型的若干个数据，按照一定的先后顺序排列组合而成。

• 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问他们。

2.数组声明创建

package com.king.array;

public class Demo01 {
    //数组的类型  变量的名字 =变量的值
    //数组类型
    public static void main(String[] args) {
        //定义方式两种
        int[] arr1;//1.定义 声明一个数组  首选
        int arr2[];// 定义  次选

        // 2. 通过new操作符来创建数组，语法如下
        arr1=new int[10];//  这里可以存放10个 int类型的数字

        // 3. 给数组元素赋值
        arr1[0]=1;
        arr1[1]=2;
        arr1[2]=3;
        arr1[3]=4;
        arr1[4]=5;
        arr1[5]=6;
        arr1[6]=7;
        arr1[7]=8;
        arr1[8]=9;
        //数组长度 用 arr1.length
//        如果 int类型的数组 未定义的  会默认赋值为0
//        例如 arr1[9]未赋值  输出  会默认为0
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cKNNfNno-1626426954916)(C:\Users\UNINETS\AppData\Roaming\Typora\typora-user-images\image-20210716102555049.png)]

• 常见错误 java.lang.ArrayIndexOutOfBoundsException:1 下标越界了 例如你数组只有5个元素 你访问到底6个了 这样就会报这个错

3.数组使用

数组的四个基本特点

• 其长度是固定的，数组一旦创建，它的大小是不可以改变的
• 其元素必须是相同的类型，不允许出向混合类型
• 数组中的元素可以是任意类型，包括基本类型和引用类型
• 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的变量成员。数组本身就是对象，Java中对象是在堆中的，因此数组类型无论是保存基本类型还是引用类型，数组对象本省是在堆中的。

package com.king.array;

public class Demo02 {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5};

//        计算所有元素的和
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        System.out.println("sum="+sum);

        //查找最大的元素
        int max=arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i]>max){
                max=arr[i];
            }
        }
        System.out.println("max="+max);
    }
}

---

数组反转

public class Demo03 {
    public static void main(String[] args) {
        int[] arrs={1,2,3,4,5,6};

        //forEach JDK1.5版本 没有下标
//        for (int arr : arrs) {
//            System.out.println(arr);
//        }
        int[] res=reverse(arrs);
        for (int i = 0; i < res.length; i++) {
            System.out.print(res[i]);
        }
    }
    //反转数组
    public static int[] reverse(int[] arrays){
        //反转操作
        int num1=arrays.length/2;
        int[] dd=new int[arrays.length];

        for (int i = 0; i <= num1; i++) {
            dd[i]=arrays[arrays.length-i-1];
            dd[arrays.length-i-1]=arrays[i];
        }
        return dd;
    }
}

4.多维数组

• 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
• 二维数组

int a[][]=new int[2][5];

• 解析：以上二维数组a可以看成一个两行五例的数组

package com.king.array;

public class Demo04 {
    public static void main(String[] args) {
        
        int[][] arr={{1,2},{3,4},{5,6}};
        System.out.println(arr[0][0]);// 打印结果是 1 
        System.out.println(arr[1][1]);  //打印结果是 4
    }
}

5.Arrays类

• 数组的工具类java.util.Arrays
• 由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays提供我们使用，从而可以对数据对象进行一些基本的操作
• Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名调用，而”不用“使用对象来调用（注意：是不用，而不是 不能）
• 具有以下常用功能：
  • 给数组赋值：通过 fill 方法。
  • 对数组排序：通过sort 方法，按升序
  • 比较数组：通过equals 方法比较数组中元素值是否相等
  • 查找数组元素：通过binarySearch 方法能对拍好序的数组进行二分查找法操作

package com.king.array;

import java.util.Arrays;

public class Demo05 {
    public static void main(String[] args) {
        int[] arr={1,3,4,5332,88,99,2403};
        //打印数组元素Arrays.toString
        System.out.println(Arrays.toString(arr));
        printArry(arr);
    }
    //自己封装一下  但是不建议重复造轮子 只是为了了解原理  便于我们理解
    public static void printArry(int[] args) {
        for (int i = 0; i < args.length; i++) {
            if(i==0){
                System.out.print("[");
            }
            if (i==args.length-1){
                System.out.print(args[i]+"]");
            }else{
                System.out.print(args[i]+", ");
            }

        }
    }
}

冒泡排序

• 冒泡排序无疑是最为出名的排序算法之一，总共有八大排序

public static void BubbleSort(int [] a, int n){
	    int j , k;
	    int flag = n ;//flag来记录最后交换的位置，也就是排序的尾边界
 
	    while (flag > 0){//flag>0的话说明排序未结束
	        k = flag; //k 来记录遍历的尾边界
	        flag = 0;
	        for(j=1; j<k; j++){
	            if(a[j-1] > a[j]){//前面的数字大于后面的数字就交换
	                //交换a[j-1]和a[j]
	                int temp;
	                temp = a[j-1];
	                a[j-1] = a[j];
	                a[j]=temp;
 
	                //表示交换过数据;
	                flag = j;//记录最新的尾边界.
	            }
	        }
	    }
	}

6.稀疏数组

package com.king.array;

public class Demo06 {
    public static void main(String[] args) {
        //创建一个 9行 9列的二维数组
        int[][] arr=new int[9][9];
        arr[4][4]=1;
        arr[5][6]=2;
        //输出原始数组
        System.out.println("输出原始的数组====");
        for (int[] ints : arr) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println("");
        }

        //转换的稀疏数组
        //获取有效值的个数
        int sum=0;
        for (int i = 0; i <arr.length ; i++) {
            for (int j = 0; j < arr.length; j++) {
                if (arr[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("============================");
        System.out.println("有效值的个数"+sum);

//        2.创建一个稀疏数组的二维数组
        int[][] arr2=new int[sum+1][3];
        arr2[0][0]=9;
        arr2[0][1]=9;
        arr2[0][2]=sum;

        //遍历二维数组，将非零的值，存放到稀疏数组里面
        int count=0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if(arr[i][j]!=0){
                    count++;
                    arr2[count][0]=i;
                    arr2[count][1]=j;
                    arr2[count][2]=arr[i][j];
                }
            }
        }

        System.out.println("稀疏数组");

        for (int i = 0; i < arr2.length; i++) {
            System.out.println(
                arr2[i][0]+"\t"
                +arr2[i][1]+"\t"
                +arr2[i][2]);
        }

        System.out.println("=======================");
        System.out.println("还原稀疏数组");
        //1.读取稀疏数组
        int[][] arr3=new int[arr2[0][0]][arr2[0][1]];

        //2.给其中的元素还原它的值
        for (int i = 1; i < arr2.length; i++) {
            arr3[arr2[i][0]][arr2[i][1]]=arr2[i][2];
        }

        //3、打印
        System.out.println("输出还原的的数组====");
        for (int[] ints : arr3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println("");
        }
    }
}

打印台的输出效果
s\image-20210716171151253.png)]