7-咸鱼学Java-Java中的数组

数组的定义初始化

    int [] array = {0,1,2,3,4,5,6,7,8,9};
    int [] array1 = new int[]{0,1,2,3,4,5,6,7,8,9};
    int [] array2 = new int[10];

3种定义方式，其中前两种都已经初始化完成，第三中数组中的元素默认是0，需要手动输入其每个下标对应的值。

array2[0]=1;

这样就初始化了array2中0号下标的元素为1；

数组的遍历

    //array.length可以获取当前数组的长度
    //1.for循环
    for (int i = 0; i < array.length; i++) {
        System.out.println(array[i]);
    }
    //2.foreache
    for (int i : array) {
        System.out.println(i);
    }

第一种为for循环的方式，for循环的好处是每次通过下标访问，所以可以通过改变下标来访问不同的元素，比如如果要访问偶数下标的元素，用for循环就会特别方便。
第二种方式为增强for循环，foreach循环方便了开发，可是foreach并不能控制数组的下标，只会按顺序获取每个元素，然后进行处理。
总体而言每个都有其好处，也有其坏处，所以应该根据情况进行使用。

数组的Copy

1.直接copy地址

    int[] array = {1,2,3,4,5};
    int[] array1 = array;

这种copy其实只是将array的地址赋给了array1，其实两个数组引用访问的是同一块空间，所以在改变array中的值的时候array1中的值也会改变
如图

2.直接copy
1）对于基本类型

    int [] array = {1,2,3,4,5};
    int [] array2 = new int[array.length];
    for (int i = 0; i < array2.length; i++) {
        array2[i] = array[i];
    }

这种copy方式获得的是一个全新的数组，array改变并不会影像，array2。
如图

2）对于对象

class testArray{
    public int temp=10;

    public int getTemp() {
        return temp;
    }

    public void setTemp(int temp) {
        this.temp = temp;
    }
}

testArray[] a = new testArray[3];
    a[0] = new testArray();
    a[1] = new testArray();
    a[2] = new testArray();
    testArray[] a2 = new testArray[a.length];

    for (int i = 0; i < a2.length; i++) {
        a2[i] = a[i];
    }
    a2[0].setTemp(30);
    show2(a);
    show2(a2);

结果为
30 10 10
30 10 10
这种copy对于对象来说相当于浅copy。
如图

其只是拷贝了对象的地址，所以在操作某个对象的时候，两个数组内的对象都会发生改变。
3.clone拷贝
1）对于基本类型

    int[] array = {1,2,3,4,5};
    int[] array2 =new int[array.length];
    array2 = array.clone();

这种方法相当于新new一个数组再拷贝过去，原理和2.1相同。
2）对于对象

    testArray[] a = new testArray[3];
    a[0] = new testArray();
    a[1] = new testArray();
    a[2] = new testArray();
    testArray[] a2 = new testArray[a.length];
    a2 = a.clone();

这种方法存入的也是地址，原理等同2.2。都是浅拷贝。
4.System.arraycopy
参数

        src   原数组
        srcPos 原数组开始copy位置
        dest  拷贝到目标数组
        destPos拷贝到目标数组的位置   
        length copy长度
System.arraycopy(src, srcPos, dest, destPos, length);

1）对于基本类型

    int[] array = {1,2,3,4,5};
    int[] array2 =new int[array.length];
    System.arraycopy(array, 0, array2, 0, array.length);

这种方法相当于新new一个数组再拷贝过去，原理和2.1相同。
2）对于对象

testArray[] a = new testArray[3];
    a[0] = new testArray();
    a[1] = new testArray();
    a[2] = new testArray();
    testArray[] a2 = new testArray[a.length];
    System.arraycopy(a, 0, a2, 0, a.length);

这种方法存入的也是地址，原理等同2.2。都是浅拷贝。
5.Arrays.copyOf

  original     原来数组
  newLength 新数组长度
Arrays.copyOf(original, newLength)

这种方法的底层为System.arraycopy方法，所以结果和上面相同。

冒泡排序

import java.util.Arrays;

/**
 * 冒泡排序
 * @author 焦焱
 *时间复杂度
 *稳定性：有没有跳跃式的比较
 */
public class paixu {
public static void maopao(int[] a)
{   long start =System.currentTimeMillis();
    int temp;
    for (int i = 0; i < a.length; i++) {
        for (int j = 0; j < a.length-1-i; j++) {
            if(a[j]>a[j+1])
            {
                temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
            }
        }
    }
    System.out.println(System.currentTimeMillis()-start);
}
public static void main(String[] args) {

//  int[] array = {12,43,2,34,1,4};
    int[] array = new int[5];
    for (int i = 0; i < array.length; i++) {
        array[i] = (int) (Math.random()*100+1);
    }
    maopao(array);
    System.out.println(Arrays.toString(array));
}
}

结果
[71, 90, 9, 37, 79]
0
[9, 37, 71, 79, 90]
第一个输出的是原数组，因为采用随机生成的方法，所以每次结果都不同，此次用此组数据来分析。
0为算法执行时间，因为数据规模小所以显示为0。
最后输出为排序后的