Java数组

1.什么是数组？

    数组是属于数据结构中的一个内容。

    数组是数据结构中访问与存储速度最快的一种数据结构。

    可以直接通过下标进行定位到指定的数据位置。

 

    Java中数组在定义时必须要指定数组的长度。

    数组是存储指定数据类型和固定长度的数据容器。

 

    数组在内存中的存储方式是怎样的？

        数组名存储的是首地址

        一维数组存储数据的是一个连续的存储空间

        二维数组存储数据的是多个一维数组数组。

 

2.数组的定义

    一维数组

        数据类型 [] 数组名 = {值,...};

        数据类型 [] 数组名 = new 数据类型[长度];

 

        数据类型 [] 数组名 = new 数据类型[]{值,...};

        数据类型 [] 数组名;

 

        数组名 = new 数据类型[]{值,...};

        数组名 = new 数据类型[长度];

        数组名 = {值,...};   错误的方式

 

    二维数组

        数据类型 [][] 数组名 = {{值,...},...};

        数据类型 [][] 数组名 = new 数据类型[行][列];

 

        数据类型 [][] 数组名 = new 数据类型[][]{{值,...},...};

        数据类型 [][] 数组名;

 

        数组名 = new 数据类型[][]{{值,...},...};

        数组名 = new 数据类型[行][列];

 

3.数组的使用

    数组是Java中的引用数据类型（类）,那么数组只提供了一个唯一的属性length，

    length是用来获取数组中能存储的元素总数。

 

    一维数组的使用：

        获取一维数组中能存储多少个元素？

            数组名.length

        获取或设置某一个位置的数据：

            数组名[下标]

    二维数组的使用：

        获取二维数组有多少行？

            数组名.length

        获取二维数组某一行有多少列？

            数组名[行下标].length

        获取或设置某一个位置的数据：

            数组名[行下标][列下标]

 

4.数组的内存分配示意图

 

5.使用事例：

package study.array160423;

 

public class SortArray {

    //程序入口：测试冒泡，选择，插入，希尔四种排列方式

    public static void main(String [] args){

        //取得要排序的原数组

        int [] srcA=createSrcArray(5);

        System.out.println("冒泡排列数组的值顺序:");

        printArray(srcA);

 

 

        //打印冒泡排列的结果

        System.out.println("\n冒泡排列的结果：");

        int [] tem=maopao(srcA);

        printArray(tem);

 

        //选择排序前数组的值

        srcA=createSrcArray(6);

        System.out.println("\n选择排序前数组的排序：");

        printArray(srcA);

        //打印选着排序

        System.out.println("\n选择排序的结果：");

        tem=xuanze(srcA);

        printArray(tem);

 

 

        //插入排序

        srcA=createSrcArray(7);

        System.out.println("\n插入排序前数组的值顺序：");

        printArray(srcA);

        //打印插入排序的结果

        System.out.println("\n打印插入排序的结果：");

        tem=caRU(srcA);

        printArray(tem);

 

        //希尔排序

        srcA=createSrcArray(8);

        System.out.println("\n希尔排序前数组的值的排序顺序：");

        printArray(srcA);

        System.out.println("\n希尔排序的结果：");

        tem=caRU(srcA);

        printArray(tem);

 

    }

 

    //生成一个乱序的，指定长度的原始数组

    public static int[] createSrcArray(int len){

        //初始化要排列的数组中的值

        int [] base=new int[len];

        for(int i=0;i<base.length;i++){

            //创建一个随机对象

            java.util.Random ran=new java.util.Random();

            //调用随机对象，每次循环是生成一个0~100间随机数

            int value=ran.nextInt(100);

            //给数组中指定位置填上随机值

            base[i]=value;

        }

        return base;

 

    }

    //打印出数组中的元素

    public static void printArray(int [] ia){

        //如果要打印的数组为null，则不打印。

        if(null==ia){

            return;

        }

        for(int i=0;i<ia.length;i++){

            System.out.print("   "+ia[i]);

        }

        System.out.print("");

    }

    //冒泡排序

    public static int[] maopao(int[] x){

        for(int i=0;i<x.length;i++){

            for(int j=i+1;j<x.length;j++){

                if(x[i]>x[j]){

                    int temp=x[i];

                    x[i]=x[j];

                    x[j]=temp;

                }

 

            }

        }

        return x;

    }

    //选择排序

    public static int[] xuanze(int [] x){

        for(int i=0;i<x.length;i++){

            int lowerIndex=i;

            //找出最小的一个索引

            for(int j=i+1;j<x.length;j++){

                if(x[j]<x[lowerIndex]){

                    lowerIndex=j;

                }

            }

            //交换

            int temp=x[i];

            x[i]=x[lowerIndex];

            x[lowerIndex]=temp;

        }

        return x;

    }

    //插入排序

    public static int[] caRU(int[] x){

        for(int i=1;i<x.length;i++){

            for(int j=i;j>0;j--){

                if(x[j]<x[j-1]){

                    int temp=x[j];

                    x[j]=x[j-1];

                    x[j-1]=temp;

 

                }

            }

        }

        return x;

 

    }

    //希尔排序

    public static int[] shell(int[] x){

        //分组

        for(int increment=x.length/2;increment>0;increment/=2){

            //每个组内排序

            for(int i=increment;i<x.length;i++){

                int temp=x[i];

                int j=0;

                for(j=i;j>=increment;j-=increment){

                    if(temp<x[j-increment]){

                        x[j]=x[j-increment];

                    }else{

                        break;

                    }

                }

                x[j]=temp;

            }

        }

        return x;

 

    }

 

}