```java
	数组的申明
        int[] a;  //推荐
        int b[]; //早期方便c 或 c++
定义
int[] a =new int[999]; 
//静态初始化 创建后不可改变
int[] a = {1,2,3,4,};

//动态初始化 ,默认初始化 为 0
int [] b new int [ 12];
```
int[] array =null; 在栈里建立一个 array变量 ，当array =new int【12】，arra变量在堆中建立一个空间存放数组 
![](https://kuangstudy.oss-cn-beijing.aliyuncs.com/bbs/2021/02/27/kuangstudy2647d226-3795-40b0-b71a-09dbc30b6eca.png)
# 数组的基本特点
![](https://kuangstudy.oss-cn-beijing.aliyuncs.com/bbs/2021/02/27/kuangstudy21a18124-1941-44d3-8cfc-a8873928da3b.png)
# 数组的使用
![](https://kuangstudy.oss-cn-beijing.aliyuncs.com/bbs/2021/02/27/kuangstudy0d89fb81-007b-4ec4-a136-03a4d26e69b6.png)
```java
package com.cjg.javaBasics;

public class Array {
    public static void main(String[] args) {
        //foreach 循环  i 存储元素 取消了下标  变量.for
        int[] array ={1,2,3,4,5};
        for (int i : array) {
            System.out.println(i);
        }

f(array);

f(reverse(array));
    }
    //删除数组
    public static void f(int[] a){

for (int i = 0; i <a.length ; i++) {
            System.out.print(a[i]);

}
        //换行
        System.out.println();
        //换行
        System.out.print("\n");

}
    //反转数组
    public static int[] reverse(int[] a){
        int[] b=new int[a.length];
        for (int i = 0,j=a.length-1; i <a.length ; i++,j--) {
            b[i]=a[j];
        }
       return b;

}
}

```
# 多维数组
```java
int[ ][ ] a ={ {1,2},{3,4},{5,6} }

package com.cjg.javaBasics;

public class Array1 {
    public static void main(String[] args) {
        int[ ][ ] a ={ {1,2},{3,4},{5,6} };
        //foreach只能输出一维 foreach两次降为 输出
        for (int[] ints : a) {
            for (int anInt : ints) {
                System.out.println(anInt);
            }
        }
        for (int i = 0; i <a.length ; i++) {
            for (int j = 0; j <a[i].length ; j++) {
                System.out.println(a[i][j]);
            }
        }

}
}

```
# 冒泡排序
![](https://kuangstudy.oss-cn-beijing.aliyuncs.com/bbs/2021/02/27/kuangstudyf849bfd2-824e-4b72-b971-1869383ee3b5.png)
24561
24516
24156
21456
12456
45621
56421
65421
```java
package com.cjg.javaBasics;

import java.util.Arrays;

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

int[] c ={1,2,54,5,45,5,6,5};
        System.out.println(Arrays.toString(f(c)));
    }
    public static int[] f(int [] a){
        //比较几轮
        for (int i = 0; i <a.length-1 ; i++) {
            //临时变量
            int t =0;
            //每轮比较几次
            for (int j = 0; j <a.length-1-i ; j++) {
                if (a[j]>a[j+1]){
                    t=a[j];
                    a[j]=a[j+1];
                    a[j+1]=t;
                }
            }
        }
        return a;
    }
}

```
# 稀疏数组 是一种数据结构 生成并还原稀疏数组
```java
package com.cjg.javaBasics;

import javax.sound.midi.Soundbank;

public class less {
    public static void main(String[] args) {
        //创建二维数组
        int [] [] a1 =new int[11][11];
        a1[1][1]=1;a1[0][3]=2;
        //设置标记，计算非0个数；
        int sum=0;
        for (int[] ints : a1) {
            for (int anInt : ints) {
                if (anInt!=0){
                    sum++;
                }
                System.out.print(anInt+" ");

}   System.out.println();

}
        System.out.println("=========================================");

System.out.println(sum);
        System.out.println("=========================================");

//创建稀疏数组
        int[][] less =new int[sum+1][3];
        less[0][0]=11; less[0][1]=11; less[0][2]=sum;
//        循环二维数组将非0赋值给稀疏数组
        int temp=0;
        for (int i = 0; i <a1.length ; i++) {
            for (int j = 0; j <a1[i].length ; j++) {
                if (a1[i][j]!=0){
                    temp++;
                    less[temp][0]=i;
                    less[temp][1]=j;
                    less[temp][2]=a1[i][j];
                }

}
        }
        for (int[] ints : less) {
            for (int anInt : ints) {
                System.out.print(anInt+" ");
            }
            System.out.println();
        }
        System.out.println("=========================================");

//稀疏数组转为二维数组
         int[][] re =new int[less[0][0]][less[0][1]];
        for (int[] ints : re) {
            for (int anInt : ints) {
                if (anInt != 0) {
                    sum++;
                }
                System.out.print(anInt + " ");

}  System.out.println();
        }
        System.out.println("=========================================");
        for (int i = 1; i <less.length ; i++) {
            re[less[i][0]][less[i][1]]=less[i][2];
        }
        for (int[] ints : re) {
            for (int anInt : ints) {
                System.out.print(anInt+" ");
            }
            System.out.println();
        }

}
}

```

Java回顾二数组的基本特点使用多维数组 Array类冒泡排序稀疏数组

总共已有 0 条评论

Java回顾二 数组的基本特点 使用 多维数组 Array类 冒泡排序 稀疏数组

总共已有 0 条评论

Java回顾二数组的基本特点使用多维数组 Array类冒泡排序稀疏数组