java数组(数组复制+数组排序(冒泡排序+快速排序))

java数组(引用数据类型)
    数组可以存储多个同类型的数据
    在堆中占用的是连续的内存空间
    数组在申请完空间之后就不能动态增长空间(只能申请更大的空间)

1.数组的定义

一维数组:
    数据类型[] 数组名称=new 数据类型[长度];

    ●int[] a;//不占用堆内存,程序中可以使用,但是运行时会报空指针异常

    ●int[] a=new int[5];//在堆中申请了内存,数组元素有5个,每个数组元素默认值为0
        a[0]=0 a[1]=0 a[2]=0 a[3]=0 a[4]=0
    等价于:
        int[] a;
        a=new int[5];
        
    ●int[] a={1,2,3,4,5};

    ●int[] a=new int[]{1,2,3,4,5};//[]里不可以个数字,不可以分开写
      int[] a=new int[5]{1,2,3,4,5};//错误
      int[] ages=new int[4];ages={20,22,25,35};//错误

二维数组:
    数据类型[][] 二维数组的名称=new 数据类型[行数][列数];

    ●int[][] a={{1,2,3},{4,5,6}};

    a[0].length;//3

    a[1].length;//3

    a.length;//2

 

    增强for循环遍历二维数组:

    for(int[] i:a1){
            for(int j:i){
                System.out.print(j+"\t");
            }
            System.out.println();
        }

    ●int[][] a=new int[3][4];//声明数组并在堆空间中申请12整型空间
        a[0]  a[0][0] a[0][1] a[0][2] a[0][3]
        a[1]  a[1][0] a[1][1] a[1][2] a[1][3]
        a[2]  a[2][0] a[2][1] a[2][2] a[2][3]
         
二维数组实际上是由多个一维数组组成
实际上上面的二维数组是由 a[0]  a[1] a[2]三个一维数组组成

2.获取数组的长度
    int length=数组名称.length;
        int[] a={1,2,3,4};
        a.length;//4
        
3.数组的复制

●System.arraycopy(Object src,int srcpos,Object dest,int destpos,int length);
    src:源数组
    srcpos:源数组中的起始位置
    dest:目标数组
    destpos:目标数组中的起始位置
    length:要复制的数组元素的数量
例:     

    int[] a={1,2,3,4,5};
    int[] b=new int[7];
    int[] c=new int[7];
    System.arraycopy(a, 0, b, 0, 5);
    for(int s:b){
        System.out.print(s+" ");//1 2 3 4 5 0 0  
    }
    System.arraycopy(a, 0, c, 1, 5);
    for(int s:c){
        System.out.print(s+" ");//0 1 2 3 4 5 0  
    }

    
●Arrays.copyOf(original,int newLength);    
    original:数组名
    newLength:要复制数组的长度
    所产生的数组可以大于原数组的长度,也可以小于原数组的长度
例:

    int[] a={1,2,3,4,5};
    int[] b=Arrays.copyOf(a, 4);
    int[] c=Arrays.copyOf(a, 6);
    for(int s:b){
        System.out.print(s+" ");//1 2 3 4  
    }
    for(int s:c){
        System.out.print(s+" ");//1 2 3 4 5 0   
    }

4.数组的排序
●Arrays.sort(要排序的数组的名称);

例:

    int[] a={55,44,22,66,11};
    Arrays.sort(a);
    for(int s:a){
        System.out.print(s+" ");//11 22 44 55 66 
    }

●快速排序

例:

    int[] a={55,44,22,66,11};
        for(int i=0;i<a.length-1;i++){
            for(int j=i+1;j<a.length;j++){
                int temp=0;
                if(a[i]>a[j]){
                    temp=a[j];
                    a[j]=a[i];
                    a[i]=temp;
                }
            }
        }
        for(int s:a){
            System.out.print(s+" ");//11 22 44 55 66 
        }

●冒泡排序

    int[] a={55,44,22,66,11};
        for(int i=0;i<a.length;i++){
            for(int j=0;j<a.length-1-i;j++){
                int temp=0;
                if(a[j]>a[j+1]){
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
        for(int s:a){
            System.out.print(s+" ");//11 22 44 55 66 
        }

过程:
55,44,22,66,11
每一轮都是从第一个数开始
 * 第一轮
 * ①.55和44 44,55,22,66,11
 * ②.55和22 44,22,55,66,11
 * ③.55和66 44,22,55,66,11
 * ④.66和11 44,22,55,11,66
 * 第二轮
 * ①.44和22 22,44,55,11,66
 * ②.44和55 22,44,55,11,66
 * ③.55和11 22,44,11,55,66
 * 第三轮
 * ①.22和44 22,44,11,55,66
 * ②.44和11 22,11,44,55,66
 * 第四轮
 * ①.22和11 11,22,44,55,66