数组

数组的定义

• 数组是相同类型数据的有序集合

• 数组描述的是相同类型的若干个数据，按照一定的先后顺序排列组合而成。

• 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问他们。

数组声明创建

• 首先必须声明数组变量，才能在程序中使用数组。

dataType[] arrayRefVar; //首选方法
或
dataType arrayRefVar[];//效果相同但不是首选方法

• Java语言使用new操作符来创建数组，语法如下：

dataType[]arrayRefVer = new dataType[arraySize];

• 数组的元素是通过索引访问的，数组索引(下标值)从0开始。

• 获取数组的v长度 arrays.length

• 如果没有给数组某个元素赋值的话 默认值 为 类型的默认值

int	double	String	boolean	char
0	0.0	null	false

public class ArratRes {
    public static void main(String[] args) {
        int [] array ;//定义一个数组
        array = new int [10];//创建了一个数组，这里面可以存放10个int类型的数字
    //给数组元素赋值
        array[0]=1;
        array[1]=2;
        array[2]=3;
        array[3]=4;
        array[4]=5;
        array[5]=6;
        array[6]=7;
        array[7]=8;
        array[8]=9;
        array[9]=10;

    }
}

三种初始化

静态初始化

int [] a ={1,2,3};
man [] mans = {new Man(1,1,new Man(2,2))}

动态初始化

int [] a = new int [2];
a[0]=1;
a[1]=2;

数组的默认初始化

数组是引用类型，他的元素相当于类的实例变量，因此数组一经分配空间，其中每个元素也被按照实例变量同样的方式被隐式初始化。

• 数组的四个基本特点

• 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。

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

• 数组中的原始可以是任何数据类型，包括基本类型和引用类型。

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

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

数组的使用

• For -Each循环

• 数组作为方法入参数

• 数组作为返回值

public class ArrayTres {
    public static void main(String[] args) {
        int [] num = {10,20,30,40,50};
        for (int i = 0;i<num.length;i++){//打印数组内所有元素
        System.out.println(num[i]);
        }
        System.out.println("=========");
        int sun = 0;
        for (int i = 0; i< num.length;i++){
            sun +=num[i];
            //打印数组元素之和
        }
        System.out.println("sum"+sun);
        System.out.println("=========");

        int max = num[0];
        //输出数组元素最大值
        for (int i=1;i<num.length;i++){
            if (num[i]>max){
                max=num[i];
            }
        }
        System.out.println("max="+max);
    }
}

数组的进阶用法

//反转数组

public class ArrayTres01 {
    public static void main(String[] args)  {
        int [] num = {10,20,30,40,50};
//        //进阶数组 ,jdk 1.5 后 适合打印数组 ，如果操作数组下标元素 不适合。
//        for (int i : num) {
//            System.out.println(i);
//        }
       int[] reverse = reverse(num);
        printArray(reverse);

    }

    //反转数组
    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;
    }

    //打印数组的方法
    public static  void printArray(int [] arrays){
        for (int i = 0 ; i< arrays.length;i++){
            System.out.println(arrays[i]+" ");
        }
    }
}

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个以为数组

二维数组

int a [] [] = new int [2][5];

解析：以上二维数组a可以看成一个两行五列的数组。

数组总共有八大排序!

冒泡排序

冒泡排序无疑是最为出名的排序算法之一。

冒泡的代码还是相当简单的 ，两层循环，外层冒泡轮数，里层依次比较，江湖人人皆知晓。

public class ArratRMP {
    public static void main(String[] args) {
    /*
    * 冒泡排序
    * 1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
    * 2.每一次比较，都会产生出一个最大，或者最小的数字；
    * 3.下一轮则可以少一次排序！
    * 4.依次排序，知道结束！
    *
    * */
    int[] a = {1,3,5,9,8,4,22};
        int [] sorts = sorts(a);
        //调用完我们自己写的排序方法以后，返回一个排序后的数组
        System.out.println(Arrays.toString(sorts));
    }
    public static int[] sorts(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;
    }
}

优化冒泡排序

import java.util.Arrays;

public class ArratRMP {
    public static void main(String[] args) {
        /*
         * 冒泡排序
         * 1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
         * 2.每一次比较，都会产生出一个最大，或者最小的数字；
         * 3.下一轮则可以少一次排序！
         * 4.依次排序，知道结束！
         *
         * */
        int[] a = {1,3,5,9,8,4,22};
        int [] sorts = sorts(a);
        //调用完我们自己写的排序方法以后，返回一个排序后的数组
        System.out.println(Arrays.toString(sorts));
    }
    public static int[] sorts(int [] array){
        int temp = 0;
        boolean fans = false;
        //外层循环，判断我木门这个要走多少次;
        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;
                    fans=true;
                }
            }if (fans==false){
                break;
            }
        }
        return array;
    }

}

稀疏数组

• 当一个数组中大部分元素为0，或者为统一值的数组时，可以用稀疏数组来保存该数组。

• 稀疏数组的处理方式是：

  • 记录数组一共有几行几列，有多少个不同的值

  • 把具有不用值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

import java.util.Arrays;

public class ArratRet {
    public static void main(String[] args) {
        //1.创建了一个二位数组 11* 11 0：没有棋子 1：黑棋 2：白棋
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;
        //输出原始数组
        for (int[] ints : array) {
            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 (array[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值个数:"+sum);
        //创建一个稀疏数组的数组
        int [][] array1 = new int[sum+1][3];
        array1[0][0] = 11;
        array1[0][1] = 11;
        array1[0][2] = sum;
        //遍历二维数组，将非零的值，存放在稀疏数组中
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j <array[i].length ; j++) {
                if (array[i][j]!=0){
                    count++;
                    array1[count][0]=i;
                    array1[count][1]=j;
                    array1[count][2]=array[i][j];

                }
            }
        }
    //输出稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i <array1.length ; i++) {
            System.out.println(array1[i][0]+"\t"
                            + array1[i][1]
                         +"\t"+array1[i][2]+"\t");
        }
        System.out.println("=============");
        System.out.println("还原");
        //读取稀疏数组
        int [][] array2 = new int[array1[0][0]][array1[0][1]];
        //给其中的元素还原值
        for (int i = 1; i < array1.length; i++) {
            array2[array1[i][0]][array1[i][1]]=array1[i][2];

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