Day05_Java的数组

1.一维数组

1.1 一维数组的声明与创建

$在Java中，想要使用数组必须\ast \ast 先声明\ast \ast ，然后再\ast \ast 创建\ast \ast 数组$

  	//1. 声明数组变量，声明了才能用
      int[] numbs;//数组的声明  int numbs[];也可以这样写

      //2. 当声明numbs为数组变量，通过new来创建数组变量.
      numbs = new int[10];//这也叫数组的实例化，给数组分配空间。此时数组元素为默认值

      //上面两步可以合起来用
      int[] numbs = new int[10];

1.2 一维数组的初始化（三种）

• $静态初始化：直接将创建（实例化）与赋值放在一起。$

例如：
    int[] numbs1 = {1,2,3,4,5,6};
	int numbs2[] = {1,2,3,4,5,6};

	char[] c = {'A','B','C','D'}；
    char c[] = {'A','B','C','D'}；
        
    String[] str= {"How","are","you"};//有点像c语言中的指针变量
	String str[]= {"How","are","you"};//有点像c语言中的指针变量

• $动态初始化$

int a[] = new int[2];//默认的值都为0
a[0] = 1;
a[1] = 2;

• $默认初始化：如果进行了声明、创建(实例化)之后，不对其进行赋值，系统会默认进行赋值$

int numbs[] = new int[10];//默认初始化

char ch[] = new char[10];//默认初始化

String str[] = new String[];//默认初始化

数组的声明、创建（实例化）	数组元素的系统默认数值
boolean b[] = new boolean[10]	false
char c[] = new char[10]	‘\0’(如果用printlns输出，无显示)
int i[] = new int[10]	0
byte by[] = new byte[10]	0
short sh[] = new short[10]	0
long l[] = new long[10]	0
float f[] = new float[10]	0.0
double d[] = new double[10]	0.0
引用类型（还没学）	null

1.3 数组的特点

• 数组就是对象，可以使用 “ . ” 引出很多的方法。

//比如：
    int a[] = {1,2,3,4,5}; 
	int x = a.length;//求出其长度

1.4 数组的用法

1.4.1普通用法：数组可以使用普通的for循环来遍历

public class Demo02 {
    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]);
        }
    }
}    

1.4.2 数组for进阶用法(增强for循环)

        int a[] ={1,2,3,4,5,6,7,8,9};
        //增强型for循环，适用于遍历，不适用于对数组操作。a+.+for+回车自动生成
        for (int i : a) {//i是a中的每一个变量，a是数组。没有下标，适合打印输出。不利于操作元素
            System.out.println(i);
        }

1.4.3 数组做方法的形参

//数组for的进阶用法，使用增强型的for循环
public class Demo03 {
    public static void main(String[] args) {

        int a[] ={1,2,3,4,5,6,7,8,9};
        printfArrary(a);
    }
    
    //数组做方法的参数。例如打印每一个数组元素
    public static void printfArrary(int a[]){
        for (int i : a) {
            System.out.println(i);
        }
    }
}

1.4.4数组做返回值

//数组for的进阶用法，使用增强型的for循环
public class Demo03 {
    public static void main(String[] args) {

        int a[] ={1,2,3,4,5,6,7,8,9};
        //数组做返回值
        int x[] = reberseArrary(a);
        printfArrary(x);
    }

    //数组做方法的参数。例如打印每一个数组元素
    public static void printfArrary(int a[]){
        for (int i : a) {
            System.out.println(i);
        }
    }

    //数组做返回值。例如反转数组
    public static int[] reberseArrary(int a[]){ //定义返回值是数组类型
        int reverse[] = new int[a.length];
        for (int i = a.length-1, j = 0; i >=0; i--,j++) {
            reverse[j] = a[i];
        }
        return reverse;
    }


}

2.内存管理

1. 声明数组。int[] array 。在栈里会压入array，在堆里是空的。
2. 创建数组（数组实例化）。array = new int[10]。在堆里开辟了空间，空间里存放10个int类型数据。
3. 给数组的元素赋值。array[0] = 1; array[1]=2 ; array[2] =3…

3. 二维数组

3.1二维数组定义

int a[][] = new int[2][5];
//或者
int[][] a = new int[2][5];

3.2二维数组的使用

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

        int a[][] = {{1,2,3,4,5},{7,8,9,10,1}};
        System.out.println("a的第一个下标为："+a.length);
        System.out.println("a的第二个下标为："+a[0].length);
        //打印第一行
        printfArrary(a[0]);
        System.out.println();
        
        //打印全部，可以用两个for
        System.out.println("打印全部法一");
        for (int i = 0; i < a.length; i++) 
        {
            for (int j = 0; j < a[0].length; j++) 
            {
                System.out.print(a[i][j]+" ");
            }
        }
        System.out.println();
        
        System.out.println("打印全部法二");
        for (int i = 0; i < a.length; i++) 
        {
            printfArrary(a[i]);//调用打印一维数组方法（函数）
        }
    }
    
    //打印一维数组
    public static void printfArrary(int a[])
    {
        for (int i : a) {
            System.out.print(i+" ");
        }
    }

}

4.Arrays类

• 常用的Arrays函数

import java.util.Arrays;
public class Demo05 {
    public static void main(String[] args) {
        int[] a = {2,45,3,233,56};
        //打印数组元素 Arrays.toString(a)
        System.out.println(Arrays.toString(a));
        //数组的排序,升序 Arrays.sort(a);
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        //fill填充方法 Arrays.fill(a,0);   Arrays.fill(a,2,4,1);
        Arrays.fill(a,0);//将0全部填充到a  
        System.out.println(Arrays.toString(a));
        Arrays.fill(a,2,4,1);//在2-4之间的元素填充为1。也就是2-3位被填充
        System.out.println(Arrays.toString(a));
    }
}

5.冒泡排序----排序算法

import java.util.Arrays;
public class Demo6 {
    public static void main(String[] args) {
        int[] a = {2,45,3,233,56};
        mao_paoSort(a);//自己写的冒泡排序
        System.out.println(Arrays.toString(a));//输出数组
    }
    
    public static void mao_paoSort(int[] a)//类似于c语言，传进去的是地址，可以在函数里用a[i]对地址内的值直接操作
    {
        int x;
        for (int i = 0; i < a.length-1; i++) {
            for (int j = 0; j < a.length-1-i; j++) {
                if(a[j] > a[j+1])
                {
                    x = a[j];
                    a[j] = a[j+1];
                    a[j+1] = x;
                }
            }
        }
    }
}

6. 稀疏数组-----数据结构

//稀疏数组
public class Demo07 {
    public static void main(String[] args) {
        //创建一个二维数组 11*11 0代表没有棋子 1代表黑棋  2代表白棋
        int[][] arry1 = new int[11][11];
        arry1[1][2] = 1;
        arry1[2][3] = 2;
        //输出原始的数组,二维数组的遍历。这边用的是增强型方法
        System.out.println("输出原始的数组：");
        for (int[] ints : arry1) {//二维数组的前一个下标的值ints
            for (int anInt : ints) {//二维数组对应前一个下标的第二个小标的值anInt
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        //=====================================================================================
        //转换为稀疏数组来保存
        //1.获取有效值个数
        int value=0;//有效值
        for (int i = 0; i < arry1.length; i++) {
            for (int j = 0; j < arry1[0].length; j++) {
                if(arry1[i][j]!=0)
                {
                    value=value+1;
                }
            }
        }
        System.out.println("有效值的个数:"+value);


        //2.创建一个稀疏数组, 行数为有效值的个数+1, 列数固定3列
        int[][] array2 = new int[value+1][3];

        //3.给稀疏数组赋值
        array2[0][0] = 11;//第0行，第0个元素，是存了多少行
        array2[0][1] = 11;//第0行，第1个元素，是存了多少列
        array2[0][2] = value;//第0行，第2个元素，是存了多少有效值

        //遍历二维数组，将有效值本身与行列位置存放到稀疏数组中
        int count =1;//在将二维数组的有效值存入到稀疏数组中，cout是确定稀疏数组的第几行或者是第几个数
        for (int i = 0; i < arry1.length; i++) {
            for (int j = 0; j < arry1[i].length; j++) {
                if(arry1[i][j] != 0){
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = arry1[i][j];
                    count=count+1;
                }
            }
        }

        //4.输出稀疏数组
        System.out.println("输出稀疏数组：");
        for (int[] ints : array2) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        //=====================================================================================
        //稀疏数组的还原
        System.out.println("稀疏数组的还原：");
        int[][] array3 = new int[array2[0][0]][array2[0][1]];

        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];

        }
        //输出稀疏矩阵 
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}