Java的学习笔记（05）数组

数组01：什么是数组
数组是同类型数据的集合

数组的下标从0开始

数组02：数组的声明和创建
首先必须声明数组变量，才能在程序中使用数组。

dataType[] arrayRefVar; //首选方法
或
dataType arrayReVar[];
java语言使用new操作符来创建数组，语法如下：

dataType[] arrayReVar = new dataType[arraySize];
package array;

public class ArrayDemo01 {

public static void main(String[] args) {
    //变量类型  变量名字 = 变量的值；
    //数组类型

    int[] nums; //首选方法√
    int nums2[];  //不是首选方法

    //new一个数组
    nums = new int[10];  //长度为10的int类型数组；或者说这个数组可以存放10个int类型数据

}

}
package array;

public class ArrayDemo01 {

public static void main(String[] args) {
    //变量类型  变量名字 = 变量的值；
    //数组类型

    int[] nums; //首选方法√   声明一个数组

    nums = new int[10];  //创建一个数组
    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;

    //计算所有元素的和
    int sum = 0;
    for (int i = 0; i < nums.length; i++) {
        sum = sum + nums[i];
    }
    System.out.println(sum);
}

}
经典二合一

// int[] nums; //首选方法√ 声明一个数组
// nums = new int[10]; //创建一个数组

      int[] nums = new int[10];    //经典二合一

获取数组的长度 arraty.length 数组名.length

数组03：三种初始化及内存分析
静态初始化

动态初始化

数组的默认初始化

package array;

public class ArrayDemo02 {

public static void main(String[] args) {
    //静态初始化: 创建+赋值
    int[]a = {1,2,3,4,5,6,7,8,9};
    Man[] men = {new Man(1,1),new Man(2,2)};

    //动态初始化:包含默认初始化
    int[]b = new int[10];

}

}
数组04：下标越界及小结
数组一旦被创建，长度大小不可改变。

数组元素必须是相同类型，不允许出现混合类型。

数组元素可以是任何数据类型，包括基本类型和引用类型。

数组属于引用类型，数组也可以看作是对象，数组的每个元素相当于该对象的成员变量。

数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的

数组05：数组的使用
package array;

public class ArrayDemo03 {

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

    int max =arrsys[0];
    for (int i = 0; i < arrsys.length; i++) {
        if (arrsys[i]>max){
            max=arrsys[i];
        }
    }
    System.out.println("max=" + max);
}

}
package array;

public class ArrayDemo04 {

public static void main(String[] args) {
    int[] arrays = {1,2,3,4,5};
    //直接for循环，无下标
    for (int array : arrays){
        System.out.println(array);
    }

    printArrsy(arrays);
    System.out.println( );
    System.out.println("========================");
    int[] reverse = reverse(arrays);
    printArrsy(reverse);
}

//打印数组元素
public static void printArrsy(int[] arrays){
    for(int i = 0; i<arrays.length;i++){
        System.out.print(arrays[i]+" ");
    }
}

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

    return result;
}

}
数组06：二维数组、多维数组
package array;

public class ArratDemo05 {

public static void main(String[] args) {
    int[][] array = {{1,2},{2,3},{3,4},{4,5}};

    /**
     * array[0][0] = 1    array[0][1] = 2   {1,2}
     * array[1][0] = 2    array[1][1] = 3   {2,3}
     */

    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array[i].length; j++) {
            System.out.println(array[i][j]);
        }
    }
}

}
数组07：Arrays类讲解
数组的工具类 java.util.Arrays

package array;

import java.lang.reflect.Array;
import java.util.Arrays;

public class ArrayDemo06 {

public static void main(String[] args) {
    int[] array = {1,2,36565,895645,5648754,87,68,12,3};
    System.out.println(Arrays.toString(array));     //打印数组全部内容
    Arrays.sort(array);                            //数组排序，从小到大
    System.out.println(Arrays.toString(array));

    Arrays.fill(array,0);
    System.out.println(Arrays.toString(array));
}

}
查看JDK帮助文档，知道具体方法。

给数组赋值 fill方法
对数组排序 sort方法
比较数组 equals方法
查找数组元素 binarySearch方法（能对排序好的数组进行二分查找）
数组08：冒泡排序
八大排序算法之一

package array;

import java.util.Arrays;

public class ArrayDemo07 {

public static void main(String[] args) {
    //冒泡排序
    int[] a = {1,3,6,2,9,8,0};
    int[] sort = sort(a);
    System.out.println(Arrays.toString(sort));

}

public static int[] sort(int[] array){
    int temp = 0;
    for (int i = 0; i < array.length-1; i++) {

        boolean flag = false;
        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){
            break;
        }
    }
    return array;
}

}
数组09：稀疏数组
数据结构的内容，减少存储空间的使用

for .each循环，遍历数组的简单写法。

for(int[] ints : 数组名){

}
package array;

public class ArrayDemo08 {

public static void main(String[] args) {
    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();
    }

    //转换为稀疏数组
    /**
     *
     */
    //获取有效值的个数
    int sum = 0;
    for (int i = 0; i < 11; i++) {
        for (int j = 0; j < 11; j++) {
            if (array1[i][j]!=0){
                sum++;
            }
        }
    }

    //创建一个稀疏数组
    int[][] array2 = new int[sum+1][3];
    array2[0][0] = 11;
    array2[0][1] = 11;
    array2[0][2] = sum;

    //遍历二维数组，将非0的值，存放在稀疏数组中
    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];
            }
        }

    }
    System.out.println("==============================");
    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("==============================");
    //读取稀疏数组
    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];

    }
    System.out.println("输出还原数组");
    for (int[] ints :array3){
        for (int anInt : ints) {
            System.out.print(anInt+"\t");
        }
        System.out.println();
    }
}

}