数组基础

数组的定义

• 数组是相同类型数据的集合
• 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
• 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问他们

数组的声明和创建

---

package Array;

public class ArrayDemo01 {
    //变量的类型   变量的名字  =  变量的值
    public static void main(String[] args) {
        int[]nums; //首选方法 //1.声明一个数组
        nums=new int[10];//2.创建一个数组
        
        int nums2[];//这种定义方法也行，但不首选
        int []a=new int[10]//声明创建一并完成
        
        //3.给数组元素中赋值
        nums[0]=1;  //数组下标是从0开始的
        nums[1]=2;
        nums[2]=3;
        nums[3]=4;
        nums[4]=5;
        nums[5]=6;
        nums[6]=7;
        nums[7]=8;
        nums[8]=9;
        nums[9]=10;
        
        //计算所有元素的和
        int sum=0;
        for (int i=0;i<nums.length;i++) { //nums.length=10
            sum += nums[i];
        }
        System.out.println(sum);
        System.out.println(nums[9]); //输出下标为9的数组元素
    }
}

---

数组的四个基本特点

---

内存分析

package Array;

public class ArrarDemo02 {
    public static void main(String[] args) {
        //1.静态初始化： 创建+赋值
        int[] a ={1,2,3,4,5,6,7,8};
        System.out.println(a[0]);
        //2.动态初始化:包含3.默认初始化，未赋值元素默认为0
        int[] b=new int[10];
        b[0]=10;
        b[1]=10;
        System.out.println(b[0]);//输出10
        System.out.println(b[1]);//输出10
        System.out.println(b[2]);//输出0  //未赋值 默认为0
        System.out.println(b[3]);//输出0  //未赋值 默认为0
    }
}

---

数组边界

int[] a ={1,2,3,4,5,6,7,8};
for (int i=0;i<a.length;i++) { //如果i<=a.length,就会输出数组下标越界异常
    System.out.println(a[i]);
}

---

数组使用

打印数组中的全部元素

//打印数组
public class Text01 {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }
    }
}

//打印数组
public class Text01 {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};
        for (int array : arrays) {    //arrays.for          
            System.out.println(array);//输出array
        }
    }
    //也可
    int[] array = {1, 2, 3, 4, 5};    
    for(int i:array){               //array.for
    System.out.println(i);          //输出i
    }

//打印数组
public class Text01 {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};
        a(arrays);
    }
    public static void a(int[] b){
        for (int i = 0; i < b.length; i++) {
            System.out.print(b[i]+" ");
        }
    }
}

计算所有素的和

//计算所有元素的和
public class Text01 {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            sum += arrays[i];
        }
        System.out.println("sum="+sum);
    }
}

查找最大元素

public class ArrayText01 {
    public static void main(String[] args) {
        int []arrays={1,2,3,4,5};
        int max=arrays[0];
        for (int i = 0; i < arrays.length; i++) {
            if (arrays[i]>max){
                max=arrays[i];
            }
        }
        System.out.println("max="+max);
    }
}

反转数组并打印

public class ArrayText01 {
    public static void main(String[] args) {
        int []a={1,2,3,4,5};
        int []b=reverse(a);
        printArray(b);
    }
    public static int[] reverse(int []arrays){
        int []b=new int[arrays.length];
        for (int i = 0,j=b.length-1; i < arrays.length; i++,j--) {
            b[j]=arrays[i];
        }
        return b;
    }
    public static void printArray(int []arrays){
        for (int array : arrays) {
            System.out.print(array+" ");
        }
    }
}

---

二维数组

public class ArrayDemo05 {
    public static void main(String[] args) {
        int [][]array={{1,2},{2,3},{3,4},{4,5}};
        //4行2列
        /**
         * 1,2  array[0]
         * 2,3  array[1]
         * 3,4  array[2]
         * 4,5  array[3]
         */
        for (int i = 0; i <array.length ; i++) {  //array.length=4
            for (int j = 0; j < array[i].length; j++) {//array[i].length=2
                System.out.print(array[i][j]+" ");//输出所有的元素：1，2，2，3，3，4，4，5
            }
        }
    }
}

---

Arrays类

指着Arrays，按住ctrl点击Arrays，再点击Structure,就可以看到Arrays类，例如：toString:输出数组；sort:排序；fill：填充

---

用toString直接输出数组a

输出特殊编码；

打印数组元素Arrays.toString

这是调用已经写好的程序，我们也可以自己写

    int[] a = {1, 2, 3, 4, 9999, 9, 9, 4};
    printArray(a);

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]+", ");
        }
    }

对比结果

---

用sort对数组元素进行升序排序

int[] a = {1, 2, 3, 4, 9999, 9, 9, 4};
Arrays.sort(a); //数组进行排序，升序
System.out.println(Arrays.toString(a));

---

用fill填充指定元素

填充：将指定字节值分配给指定字节数组的每个元素

int[] a = {1, 2, 3, 4, 9999, 9, 9, 4};
    Arrays.fill(a,0);//数组填充
    System.out.println(Arrays.toString(a));
}

---

填充指定范围内的元素

int[] a = {1, 2, 3, 4, 9999, 9, 9, 4};
Arrays.fill(a,2,4,0);//填充数组下标2-4之间的元素（左开右闭）
System.out.println(Arrays.toString(a));

左开右闭（2，4]，所以第3，4个元素被填充。

其他方法可以结合 jdk api 1.8.CHM,来查找作用和实际

操作

---

冒泡排序

• 冒泡排序无疑是最为出名的排序算法之一，总共有八大排序！
• 冒泡的代码还是相当简单的，两层循环，外层冒泡轮数，里层依次比较，江湖中人人尽皆知。
• 我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为O(n2).

public class ArrayText01 {
    public static void main(String[] args) {
        int []a ={561,123,1,1,54,645};
        int [] b=sort(a);
        System.out.println(Arrays.toString(b));
    }
    //冒泡排序
    //1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
    //2.每一次比较，都会产生出一个最大，或者最小的数字；
    //3.下一轮则可以少一次排序！
    //4.依次循环，直到结束
    public static int[] sort(int[] array) {
        //临时变量
        int temp = 0;
        //外层循环，判断我们这个要走多少次；
        for (int i = 0; i < array.length; i++) {
            //内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置
            for (int j = 0; j < array.length - 1; j++) {
                if (array[j + 1] < array[j]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
        return array;
    }
}

---

稀疏数组

---

普通数组压缩成稀疏数组

​ 1.输出上图数组

//无棋为0，黑棋为1，白棋为2
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();
}

​ 2.转换为稀疏数组

//获取有效值的个数
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   即1和2
    }
}

//创建一个稀疏数组
int [][]array2=new int[sum+1][3];  //由有效个数值可知稀疏数组是一个3行3列的数组
array2[0][0]=11;
array2[0][1]=11;
array2[0][2]=sum;
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];
        }
    }
}
for (int i = 0; i < array2.length; i++) {
    for (int j = 0; j <array2[i].length; j++) {
        System.out.print(array2[i][j]+"\t");
    }
    System.out.println();
}

读取稀疏数组

​ 1.读取稀疏数组的值

int [][]array3=new int[array2[0][0]][array2[0][1]]; //读取稀疏数组，这是一个11行，11列的数组

​ 2.给其中的元素还原它的值

for (int i = 1; i < array2.length; i++) {
    array3[array2[i][0]][array2[i][2]]=array2[i][2];
} // 将array2的第i行第2列，array3中的第array2[i][0]行，第array2[i][1]列，
  //例如array2中的第1行1，2，1(i=1)。将array2的第i行第2列(即1)，赋值给array3的第array2[i][0](即1)行，第array2[i][2](即2)列。
  //即将1赋值给array3中的第1行第2列
  

​ 3.打印数组

int[][] array3 = new int[arrays2[0][0]][arrays2[0][1]];
        for (int i = 1; i <sum+1; i++) {
                array3[arrays2[i][0]][arrays2[i][1]] = arrays2[i][2];
            }
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + " ");
            }
            System.out.println();
        }

全代码:

public class ArrayText01 {
    public static void main(String[] args) {
        
        //1.定义上述数组
        int[][] arrays1 = new int[11][11];  //无棋为0，黑棋为1，白棋为2
        arrays1[1][2] = 1;  //2行3列为黑棋为1
        arrays1[2][3] = 2;  //3行4列为白棋为2
        for (int[] ints : arrays1) {
            for (int anInt : ints) {
                System.out.print(anInt + " ");
            }
            System.out.println(); // 除了2行3列为1，3行4列为2外，其他位置默认为0
        }
        a(arrays1);  //调用方法a，实参为array1
    }
    public static void a(int[][] arrays) {  //定义方法a，形参为二维数组
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (arrays[i][j] != 0) {
                    sum++;   //计算二维数组里的有效个数
                }
            }
        }
        
        //2.转化为稀疏数组
        int[][] arrays2 = new int[sum + 1][3];//创建一个稀疏数组，他是一个sum+1行3列的数组
        
        // 给稀疏数组第一行元素赋值
        arrays2[0][0] = 11; //稀疏数组第1行第1列为原始数组的行数
        arrays2[0][1] = 11; //稀疏数组第1行第2列为原始数组的列数
        arrays2[0][2] = sum;  //稀疏数组第1行第3列为原始数组的有效数值个数sum
        
        int count = 0;  //定义一个数值
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                if (arrays[i][j] != 0) {  //判断是否为有效数值
                    
                    count++;  //第count个有效数值
                    arrays2[count][0] = i; //稀疏数组的第count行第1列为当前有效数值的所在行
                    arrays2[count][1] = j; //稀疏数组的第count行第2列为当前有效数值的所在列
                    arrays2[count][2] = arrays[i][j]; //稀疏数组的count行第3列为当前有效数值的值
                    
                }
            }
        }
        
        //3.输出稀疏数组
        for (int[] ints : arrays2) {
            for (int anInt : ints) {
                System.out.print(anInt + " ");
            }
            System.out.println();//输出稀疏数组
        }
        
        //4.读取稀疏数组
        int[][] array3 = new int[arrays2[0][0]][arrays2[0][1]]; //读取稀疏数组第一行元素信息，它是一个 (稀疏数组第1行第1列元素) 行，(第1行第2列元素) 列的数组
        for (int i = 1; i <sum+1; i++) {
                array3[arrays2[i][0]][arrays2[i][1]] = arrays2[i][2]; //读取稀疏数组剩余元素信息，将 (稀疏数组的第i~sum+1行第3列的元素)赋值给还原数组的第 (稀疏数组第i~sum+1行第1列元素) 行，第 (稀疏数组第1~sum+1行第2列元素) 列
            }
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + " ");
            }
            System.out.println(); //输出还原的数组
        }
    }
}

最终效果