第三天02

数组

元素类型[ ] 数组名 ( 推荐使用) 元素类型 数组名 [ ]

int [] a;               //声明一个数组
a = new int[10];        //创建一个数组   

int [] a= new int[10];    //等价于上方两个语句

数组的For-Each循环

for(int array:数组名){
         System.out.println(array);
}

数组的反转操作

public static int[] reverse(int[] b){
        int[] rusult=new int[b.length];
            for (int i = 0,j=b.length-1; i < b.length; i++,j--) {         //数组的小标注意越界
                rusult[i]=b[j];
            }
            return rusult;
    }

数组越界异常 ArrayIndex out of bounds for length ···

Arrays类的使用

• 打印数组元素 System.out.println(Arrays.toString( 数组名));
• 数组进行排序 （升序） Arrays.sort(数组名)

冒泡排序

public static int[] bubbleSort(int[] a){
    //冒泡排序 时间复杂O(n^2)
    int temp=0;
    for (int j = 0; j < a.length ; j++) {
        for (int i = 0; i <a.length-1; i++) {
           if (a[i]>a[i+1]){
             temp =a[i+1];
             a[i+1]= a[i];
             a[i] = temp;
            }
       }
   }
    return a;
}

稀疏数组

public class SparseArray {
    //打印二维数组
    public static void printArray(int[][] a) {
     for (int[] array : a) {
        for (int anInt : array) {
            System.out.print(anInt + "\t");
        }
        System.out.println();          //换行
    }
    }

    // 得出有效元素的个数
        public static int counting(int[][] b){
            int sum = 0;
            for (int i = 0; i < b.length; i++) {
                for (int j = 0; j < b.length; j++) {
                    if (b [i][j] != 0) sum++;
                }
            }
            return sum;
        }

    //还原稀疏数组
    public static int[][] reduction(int[][] b, int sum) {
        int [][] rearray= new int[b[0][0]][b[0][1]];
        for (int i = 1; i <=sum ; i++) {
            rearray[b[i][0]][b[i][1]]=b[i][2];
        }
        return rearray;
    }

    
    public static void main(String[] args) {
        int[][] a = new int[10][10];
        a[1][2] = 13;
        a[3][6] = 24;
        a[7][5] = 31;
        System.out.println("输出原始的数组");
        printArray(a);
        int sum = counting(a);           //有效元素的个数 sum
        System.out.println(sum);

        //创建数组
        int[][] array1 = new int[sum+1][3];
        array1 [0][0] = a.length;
        array1 [0][1] = a[1].length;
        array1 [0][2] = sum;                //存入首行元素

        //遍历二维数组，将有效元素，存放入稀疏数组中
        int num =0;
        for (int i = 0; i <a.length ; i++) {
            for (int j = 0; j < a.length; j++) {
                if (a[i][j]!=0) {
                    num++;
                    array1[num][0]=i;
                    array1[num][1]=j;
                    array1[num][2]=a[i][j];
                }
            }
        }
        System.out.println("稀疏数组");
          printArray(array1);

        System.out.println("还原后的数组");
        printArray(reduction(array1,sum));

    }
}

Java内存机制

• 栈:自动分配连续的空间,后进先出,放置局部变量

• 堆:不连续,放置new出来的对象

• 方法区:也是堆,放置类的代码信息,静态变量,常量池