数组

数组

package array;

public class ArrayDemo01 {
    //变量的类型    变量名    =  变量值
    public static void main(String[] args) {
        int[] nums;//1.定义 int 类型的数组
        nums = new int[10];//创建一个数组，可以存放10个int类型的数字；
        //给数组元素赋值
        nums[0] = 1;
        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;
       /* System.out.println(nums[9]);输出  */
        //计算所有元素的和
        int sum = 0;
        //或许数组长度可以用： arrays.Length
        for (int i = 0; i < nums.length; i++) {
            sum = sum +nums[i];
        }
        System.out.println(sum);
    }
}

内存分析

声明一个数组的时候，只是在栈里插入了一个数组

int[] array = null;

只有在创建数据的时候，才会在堆里产生

array =new int [10];

初始化

package array;

public class ArrayDemo02 {
    public static void main(String[] args) {
        //静态初始化：创建 + 赋值
        int[] a= {1,2,3};
        System.out.println(a[0]);//输出为1

        //动态初始化：包含默认初始化
        int[] b = new int[10];
        b[0] = 1;
        System.out.println(b[0]);
        System.out.println(b[1]);//没有赋值，默认初始化，输出为“0”
    }
}

数组边界

数组的使用

package array;

public class ArrayDemo03 {
    public static void main(String[] args) {
        //静态初始化：创建 + 赋值
        int[] a= {1,2,3};
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
        System.out.println("==========");
        //求和
        int sum = 0;
        for (int i = 0; i <a.length ; i++) {
            sum = sum + a[i];
        }
        System.out.println("和等于"+ sum);
        //求最大值
        int max = a[0];
        for (int i = 1; i < a.length; i++) {
            if (a[i]>max){
                max = a[i];
            }
        }
        System.out.println("最大值"+ max);
    }
}

package array;

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};
        //int array ”数组里面的每一个元素“: arrays “数组”  没有下标
        for (int array : arrays) {
            System.out.println(array);//输出数组元素，但是取不到下标
        }
    }
}

多维数组

冒泡排序

package array;

import java.util.Arrays;
import java.util.concurrent.ForkJoinPool;

public class ArrayDemo05 {
    public static void main(String[] args) {

        int[] a ={1,5,6,7,8,10,65,14,2,2,66};
        int[] sort = sort(a);//调用完自己写的排序方法后，返回一个排序后的数组
        System.out.println(Arrays.toString(sort));//打印
    }
    //冒泡排序
    //1.比较数组中，俩个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
    //2.每一次比较，都回产生一个最大，或者最小的数字
    //3.下一轮则可以少一次排序@
    //4.依次循环，直到结束！
    public static int[] sort(int[] array){
        //临时变量
        int temp = 0;
        for (int i = 0; i < array.length-1; i++) {
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j+1]<array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] =temp;
                }
            }
        }
        return array;
    }
}

优化

---

package array;

import java.util.Arrays;
import java.util.concurrent.ForkJoinPool;

public class ArrayDemo05 {
    public static void main(String[] args) {

        int[] a ={1,5,6,7,8,10,65,14,2,2,66};
        int[] sort = sort(a);//调用完自己写的排序方法后，返回一个排序后的数组
        System.out.println(Arrays.toString(sort));//打印
    }
    //冒泡排序
    //1.比较数组中，俩个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
    //2.每一次比较，都回产生一个最大，或者最小的数字
    //3.下一轮则可以少一次排序@
    //4.依次循环，直到结束！
    public static int[] sort(int[] array){
        //临时变量
        int temp = 0;
        //外层循环，判断要走多少次。
        for (int i = 0; i < array.length-1; i++) {
            boolean flag =false;   //通过flag标识位减少没有意义的比较
            //内层循环 比较判断俩个数，如果第一个数，比第二个数小，则交换位置
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j+1]<array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] =temp;
                    flag =true;
                }
            }
            if (flag==false);{ //如果flag等于 flase则跳出循环。
                break;
            }
        }
        return array;
    }
}

稀疏数组

package array;

public class ArrrayDemo08 {
    public static void main(String[] args) {
        //1.创建一个二维数组 11*11   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();
        }
        System.out.println("=========");
        //转换稀疏数组保存
        //获取有效值的个数
        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];//有效值+1行数。3列
        array2[0][0] = 11;//11行
        array2[0][1] = 11;//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){//当前数组中不等于0，存入稀疏数组中
                    count++;
                    array2[count][0]=i;//行坐标
                    array2[count][1]=j;//纵坐标
                    array2[count][2]=array1[i][j];//值
                }
            }
        }
        //输出稀疏数组
        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]+"\t");
        }
        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++) {//第0行是头部信息，数值从1开始
            array3[array2[i][0]][array2[i][1]] = array2[i][2];//获取横纵坐标，当前值array2[i][2]
        }
        //打印
        System.out.println("输出原始数组");
        for (int[] ints:array1){
            for (int anInt:ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}