数组

数组

数组的定义

1.数组是相同几何数据的有序集合

2.数组描述的是相同类型的若干个有效数据，按照一定的先后次序排列组合而成

3.每一个数据被称作数组元素，通过一个下标来访问他们

数组的声明和创建

1.首先必须要声明一个数组，才能在程序中使用数组，下面为声明数组的语法

变量类型[] 变量名 //推荐使用

变量类型 变量名[] //不推荐使用

2.Java语言使用new操作符来创建数组

变量类型[] 变量名 = new 变量类型[]{数组元素}

3.获取素组长度：变量名.length

4.举例：

public class ArrayDemo1 {
    //变量类型     变量名字    =变量值；
    public static void main(String[] args) {
        int[] nums ;  //1.声明一个数组
        nums = new int[5];  //2.定义一个数组
        
        int[] nums1 = new int[]{10,20,30,40,50};
        System.out.println(nums1[4]);
        
        //3.给数组赋值
        nums[0] = 1; 
        nums[1] = 2; 
        nums[2] = 3; 
        nums[3] = 4; 
        nums[4] = 5; 
        System.out.println(nums[3]);
        
        //计算数组中的和
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum =sum+ nums[i];
        }
        System.out.println(sum);
    }
​
}
​

JAVA内存分析

1.堆：存放new的对象和数组

可以被所有线程共享，不会被别的对象引用

2.栈：存放基本变量类型（会包含这个基本变量类型的具体数值）

引用对象的变量（会存放这个引用在堆里的地址）

三种初始化状态

静态初始化数组

1.定义：定义数组的时候直接给数组赋值

2.格式：

数据类型[] 变量名 = new 数据类型[]{数组元素};

简化格式：

数据类型[] 变量名 ={数组元素};

3.注意：数组变量名中存储的是数组在内存中的地址，数组是引用类型

动态初始化数组

1.定义：定义数组的时候，只确定元素的类型和数组的长度，之后再存入具体数据

2.格式：

数据类型[] 变量名 = new 数组类型[长度]；

举例：

public class ArrayDemo2 {
    public static void main(String[] args) {
        //静态初始化数组:创建+.赋.值.
        int[]  nums =  {13,15,12,45,55};
        System.out.println(nums[3]);
        
        //动态初始化数组:包含默认初始化
        
        int[] a = new int[10];
        a[2]=10;
        System.out.println(a[6]);
        
    }
}
​

3.边界： java.lang.ArrayIndexOutOfBoundsException：数组下标越界异常

多维数组

1.格式：

变量类型[] [] 变量名 = {{元素}，元素}；

2.举例

public class ArrayDemo5 {
    public static void main(String[] args) {
        //打印出所有变量
        /**
         1,4,3   //arrays[0]
         1,0,3   //arrays[1]
         
         1,21,3   //arrays[2]
         1,213,3  //arrays[3]
         */
        int[][]  arrays = {{1,4,3},{1,0,3},{1,21,3},{1,213,3}};
        //System.out.print(arrays[1][2]);
        
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                System.out.println(arrays[i][j]);
            }
        }
        
    }
    //打印数组元素
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            
                System.out.print(arrays[i]);
            
        }
    }
​
}
​

Arrays类

1.给数组赋值：Arrays.fill方法

2.给数组排序：Arrats.sort方法，按升序排列

3.比较数组：Arrays.equals 比较数组中的元素是否相等

4.查找数组元素：Arrays.binarySearch(a, key) 能对排序好的数组进行二分查找法进行操作

举例：

import java.util.Arrays;
​
public class ArrayDemo6 {
    public static void main(String[] args) {
        int[] a = {12,45,2158,78265,426886,1,4};
        int[] a2 ={12,45,2158,78265,426886,1,4};
        System.out.println(a); //[I@18a992f
        //Arrays.toString:打印数组中的元素
        
        System.out.println(Arrays.toString(a));//[12, 45, 2158, 78265, 426886, 1, 4]
        //printArray(a);
        
        //比较数组中元素值是否相等
        Arrays.equals(a, a2);
        System.out.println(Arrays.equals(a, a2));//true
        
        //数组的升序排列
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));//[1, 4, 12, 45, 2158, 78265, 426886]
        
​
        
        
        //比较数组中元素值是否相等
        Arrays.equals(a, a2);
        System.out.println(Arrays.equals(a, a2));//false
        
        //数据的填充:Arrays.fill(变量名,填充区间,填充数字);
        Arrays.fill(a,2,5, 4);
        System.out.println(Arrays.toString(a));//[1, 4, 4, 4, 4, 78265, 426886]
        
        
    }
    public static void printArray(int[] a){
        for (int i = 0; i < a.length; i++) {
            if(i==0){
                System.out.print("[");
            }
            if(i==a.length-1){
                System.out.print(a[i]+"]");
            }else{
            System.out.print(a[i]+", ");
            }
        }
    }
​
}
​

冒泡排序

​
​
public class ArrayDemo7 {
    //冒泡排序
    //1.比较数组中，相邻的两个数，如果第一个数比第二个数大，则它们交换位置
    //2.每一次比较都会产生一个最大或最小的数
    //3.下一轮则可以减少一次排序
    //4.以此循环直到结束
    public static void main(String[] args) {
        int[] arrays = {45,75,128,789,65852};
        int[] sort = sort(arrays);//调用完我们自己写的排序数组之后，返回一个排序后的数组
        System.out.println(Arrays.toString(arrays));
    }
    public static int[] sort(int[] arrays){
        //临时变量
        int temp = 0;
        boolean flag = false;//通过flag标识位来减少没有必要的比较
        
        //外层循环，判断我们要走多少次
        for (int i = 0; i < arrays.length-1; i++) {
            //内层循环,比较两个数，如果一个数大，一个数小，则交换位置
            for (int j = 0; j < arrays.length-1-i; j++) {
                if(arrays[j+1]<arrays[j]){
                    arrays[j]=temp;
                    arrays[j+1]=arrays[j];
                    temp=arrays[j+1];
                    flag = true;
                }
                if(flag == false){
                    break;
                }
            }
        }
        
        
        
        return arrays;
    }
​
}
​

稀疏数组

1.当一个数组中大部分数值为0时，或者为同一数值的数组中，就可以用稀疏数组来保存

2.稀疏数组处理方式：

（1).记录数组有几行，几列，有多少个不同的值

（2).把具有不同值的行列和数值记录在一个小规模数组里，从而缩小程序规模

public class ArrayDemo8 {
    public static void main(String[] args) {
        //定义一个二维数组
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        
        //输出原始的数组
        System.out.println("/输出原始的数组:");
        
        //遍历数组元素
        for(int[] ints : array1){
            for(int anInt : ints){
                System.out.print(anInt+"\t");
            }System.out.println();
        }
        System.out.println("================");
        
        //转换为稀疏数组
        //1.获得有效值个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(array1[i][j] != 0){
                    sum++;
                }
            }
        }
        System.out.println("有效值个数:"+sum);
        
        //2.
        //创建一个稀疏数组
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;
        
        //3.遍历数组元素,将非零值存放在稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j =0 ; j < array1[i].length; j++) {
                if(array1[i][j] != 0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }
        
        //4.输出稀疏数组
        System.out.println("稀疏数组:");
        //遍历数组元素
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"
                    +array2[i][1]+"\t"
                    +array2[i][2]);
        }
        
        
        System.out.println("================");
        System.out.println("还原稀疏数组");
        
        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        
        //2.给其中的元素还原它的值
        
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array3[i][2];
        }
        
        //3.打印
        System.out.println("/输出还原的数组:");

//遍历数组元素
for(int[] ints : array1){
for(int anInt : ints){
System.out.print(anInt+"\t");
    }System.out.println();
    }
System.out.println("================");


    }
​
}
​