2021-09-01数组

数组概述

1、数组：相同类型数据的有序集合
2、若干数据按照一定的先后次序排列组合而成
3、每个数据叫做数组的一个元素，每个数组可以通过一个下标来访问，数组下表从0开始

---

数组声明创建

数组的声明和创建

1、数组需要先声明后使用

数组类型【】 数组名//首选
数组类型 数组名【】

2、使用new操作符来出案件数组
数组类型【】 数组名=new 数组类型【数组大小】

3、数组元素通过索引访问，下标从0开始

4、arrays.length获取数组长度

package arrays;

public class Demo01 {
    public static void main(String[] args) {
        int[] array=new int[11];
        for (int i=1;i<=10;i++){
            array[i-1]=i;
            System.out.println("第"+(i-1)+"个元素为："+array[i-1]);
        }
        array[10]=12;
        System.out.println("第10个元素为"+array[10]);
        System.out.println("数组长度为："+array.length);

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

内存分析

java内存分析：
1、堆：存放new的对象和数组（可以被所有线程共享，不存放别的对象引用）
2、栈：存放基本变量类型，包括该基本类型的具体数值（引用对象的变量，会存放该引用在对里面的具体地址）
3、方法区：可以被所有线程共享，包含了所有的class和static变量

三种初始化

1、静态初始化

int[] a={1,2,3};
Man[] mans={new Man(1,1),new Man(2,2)}

2、动态初始化

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

3、数组的默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分哦诶空间，其中的每个元素也按照实例变量相同的方式被隐式初始化。

数组的四个基本特点

1、长度确定，一旦被创建，大小不可以改变
2、元素必须是相同类型的数据
3、可以使任何类型，包括基本类型和引用类型
4、数组变量属于引用类型，数组可看成对象，元素相当该对象的成员变量，数组本身就是对象，对象在堆中，无论数据是什么类型，数组对象本身是在堆中

数组边界

1、下标合法边界【0，length-1】，如果越界就会报错
2、java.lang.ArrayIndexOutOfBoundsException：数组下标越界

小结

1、数组是相同的任意类型数据的有序集合
2、数组是对象，元素相当于对象的成员变量
3、数组长度确定的，不可变，越界报错，报java.lang.ArrayIndexOutOfBoundsException

---

数组使用

1、for-each循环

//没有下标
    for(int i:array){
            System.out.println(i);
        }
//有下标
        for (int i=0;i<array.length;i++){
            sum=sum+array[i];
        }

2、数组作方法入参

    public static void printArray(int[] arrays) {
        for (int i=0;i<arrays.length;i++){
            System.out.println(arrays[i]);
        }
    }

3、数组作返回值

        System.out.println("_______________________________");
        int[] reverse = new int[11];
           reverse  =  reverse(array);
           for (int i:reverse){
        System.out.println(i);}
    }
        public static int[] reverse(int[] arrays){
            int[] arrays1=new int[arrays.length];
            for (int i = 0; i < arrays.length; i++) {
                arrays1[(arrays.length-i-1)]=arrays[i];
            }
            return arrays1;
        }

---

多维数组

多维数组可以看成数组的数组
二维数组：

int a[][]=new int[2][5];
2行5列的数组

---

Arrays类

1、数组的工具类：java.util.Arrays
2、Arrays类中的方法都是static修饰的静态方法，在使使用调用类名
3、具体功能：
对数组赋值：fill
对数组排序：sort升序
比较数组：equals，比较元素值是否相等
查找数组元素：binarySearch二分查找法

package arrays;

import java.util.Arrays;

public class Demo02 {
    public static void main(String[] args) {
        int[] a={1,2,5644,3,89,4,555,6};
        int[] b={1,2,5644,3,89,4,555,6};
        System.out.println(Arrays.equals(a,b));
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.binarySearch(a,2));
        System.out.println(Arrays.equals(a,b));
    }
}

冒泡排序

排序总共有8中，冒泡最出名
冒泡就是两层循环，外层冒泡轮数，里层依次比较

冒泡排序
1、比较数组中两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
2、每一次比较，都会产生出一个最大，或者最小的数字
3、则下一轮，可以少一次排序
4、依次循环直到结束

package arrays;

import java.util.Arrays;

public class Demo03 {
//    冒泡排序
//    1、比较数组中两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
//    2、每一次比较，都会产生出一个最大，或者最小的数字
//    3、则下一轮，可以少一次排序
//    4、依次循环直到结束
        public static int[] sort(int[] arrary) {
            int temp=0;
            //外侧循环，判断我们要走多少次
        for (int i=0;i<arrary.length-1;i++){
            //内侧循环，如果第一个数比第二个数大，我们就交换他们的位置
            for(int j=0;j<arrary.length-1-i;j++){
                if (arrary[j+1]<arrary[j]){
                    temp=arrary[j];
                    arrary[j]=arrary[j+1];
                    arrary[j+1]=temp;
                }
            }
        }
        return arrary;
}

    public static void main(String[] args) {
            int[] a={1, 2, 5644, 3, 89, 4, 555, 6};
             System.out.println(Arrays.toString(sort(a)));
    }
}

---

稀疏数组

1、稀疏数组是指：当数组中元素大部分为0，或者为同一个值的数组时，可以使用稀疏数组来保存
2、稀疏数组的处理方式：
记录数组一共几行几列，有多少个不同值。
把具体的不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

结构就是
总共多少行 总共多少列 总共有多少个不为0或者不相同的值
%%%%% %%%%%% %%%%%%%%%%
%%%%% %%%%%% %%%%%%%%%%
%%%%% %%%%%% %%%%%%%%%%
%%%%% %%%%%% %%%%%%%%%%
…
把数组转换成3列的数组，3列的数组只记载多维数组中不为0或者不相同的值。三列分别是总共多少行 总共多少列 总共有多少个不为0或者不相同的值

package arrays;

public class Demo04
{
    public static void main(String[] args) {
        int[][] a=new int[10][10];
        a[1][2]=1;
        a[2][3]=2;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.print(a[i][j]+"\t");
            }
            System.out.println();
        }


        System.out.println("======================================");
        System.out.println("转化为稀疏数组");
        int sum=0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (a[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("总共有"+sum+"个不为0或者不相同的数");

        int[][] b=new int[sum+1][3];
        b[0][0]=a.length;
        b[0][1]=a[0].length;
        b[0][2]=sum;
        int count=0;
        for (int i = 0; i <a.length ; i++) {
            for (int j = 0; j <a[i].length; j++) {
                if (a[i][j]!=0){
                    count++;
                    b[count][0]=i;
                    b[count][1]=j;
                    b[count][2]=a[i][j];
                }
            }
        }

        System.out.println("========================");
        System.out.println("稀疏矩阵：");
        for (int i = 0; i < b.length; i++) {
            for (int j = 0; j < b[i].length; j++) {
                System.out.print(b[i][j]+"\t");
            }
            System.out.println();
        }

        System.out.println("===========================");
        System.out.println("稀疏矩阵转化为原来的形式");
        int e=b[0][0];
        int f=b[0][1];
        int[][] c =new int[e][f];
        for (int k = 1; k <b.length ; k++) {
                c[(b[k][0])][(b[k][1])]=b[k][2];
        }


        System.out.println("===========================");
        System.out.println("原来的形式为：");
        for (int[] is:a){
            for (int ii:is){
                System.out.print(ii+"\t");
            }
            System.out.println();
        }

    }
}