数组

数组：一组类型相同，存储空间连续的数据
可以理解为用来装元素的容器
数组的基本使用：
1.如何创建一个数组对象：
    int[] data1 = new int[3];// 3表示底层开辟3块连续的存储空间
    int[] data2 = new int[]{45,23,77,91,33};
    int[] data3 = {34,56,91,22};
2.如何得到某一个元素
    数组对象[下标] -> 下标从0开始
    System.out.println(data[0]);
3.如何得到数组的大小
    数组对象.length;
    System.out.println(data.length);
4.遍历数组
    for + 下标 -> data[x]:元素
    for(int x = 0; x < data.length; x++){
        System.out.println(data[x]);//x --> 下标
    }

    foreach forin since jdk5.0 -> x ： 元素
    for(int x : data){
        System.out.println(x);//x --> 元素
    }
数组的复制：
1.错误的复制方式 只是内存里面的对象多了一个引用而已
public class Test01{
    public static void main(String[] args){
        int[] data1 = new int[]{45,56,43,32};
        int[] data2 = data1;

        data1[0] = 55;
        System.out.println(data2[0]);//打印结果  55
    }
}
2.笨重的复制方式 需要程序员挨个进行手动复制
public class Test02{
    public static void main(String[] args){
        int[] data1 = new int[]{45,32,22,12};
        int[] data2 = new int[data1.length << 1];
        data2[0] = data1[0];
        data2[1] = data1[1];
        data2[2] = data1[2];
        data2[3] = data1[3];

        data1[0] = 55;
        System.out.println(data2[0]);
    }
}
3."克隆"方法,复制完全相同的两个数组 不符合正常的应用场景
public class Test03{
    public static void main(String[] args){
        int[] data1 = new int[]{45,32,21,33};
        int[] data2 = data1.clone();

        for(int x : data2){
            System.out.println(x);
        }
    }
}
4.System.arraycopy(1,2,3,4,5);注意copy小写
    1:要复制的原数组对象
    2:原数组的起始下标位置
    3:要复制到的目标数组对象
    4:目标数组的起始下标位置
    5:要复制的长度
public class Test04{
    public static void main(String[] args){
        int[] data1 = new int[]{45,23,12,32};
        int[] data2 = new int[data1.length << 1];
        System.arraycopy(data1,0,data2,0,data1.length);
        for(int x : data2){
            System.out.println(x);
        }
    }
}
*：当我们调用System.arraycopy()方法的时候，他的1，3参数可以是同一个数组对象，从而实现一个数组的前后移动
*：ArrayList的remove()方法底层就是通过System.arraycopy()方法实现的

数组的排序：
1.手动排序（冒泡排序）
    int[] data = new int[]{77,32,10,91,28};
    77 32 10 91 28
    [0]    [1]    [2]    [3]    [4]
    [0] vs [1]    前大后小      需要交换

    32 77 10 91 28
    [0]    [1]    [2]    [3]    [4]
        [1]  vs [2]    前大后小      需要交换

    32 10 77 91 28
    [0]    [1]    [2]    [3]    [4]
          [2] vs  [3]    前小后大      不需要交换

    32 10 77 91 28
       [0]    [1]    [2]    [3]    [4]
                [3] vs  [4]    前大后小      需要交换
                [y] vs  [y + 1]
    32 10 77 28 91 -》 大
    [0]    [1]    [2]    [3]    [4]
    可以看到一次排序的结果：找到一个最大值
    for(int x = 0 ; x < data.length - 1 ; x++){ //外层循环控制需要查找多少次最值
        for(int y = 0 ; y < data.length - 1 - x ; y++){ //内层循环控制前后比较
            if(data[y] > data[y+1]){
                //如果需要交换的是数字，可以用异或进行交换
                data[y] = data[y] ^ data[y+1];
                data[y+1] = data[y] ^ data[y+1];
                data[y] = data[y] ^ data[y+1];
            }
        }
    }
面试题：按照个位数从小到大排序
public class Test05{
    public static void main(String[] args){
        int[] data = new int[]{45,32,321,34,67};
        for(int x = 0 ; x < data.length - 1; x++){
            for(int y = 0 ;y < data.length - 1 - x ; y++){
                //对个位数进行比较
                int a = data[y] % 10;
                int b = data[y+1] % 10;
                if(a > b){
                    data[y] = data[y] ^ data[y+1];
                    data[y+1] = data[y] ^ data[y+1];
                    data[y] = data[y] ^ data[y+1];
                }
            }
        }
    }
}
2.自动排序
Arrays.sort(数组对象)
    *：这种排序规则只会从小到大进行排序
    *：import java.util.*;
import java.util.*;
public class Test06{
    public static void main(String[] args){
        int[] data = new int[]{45,32,43,54,67};
        Arrays.sort(data);

        for(int x : data){
            System.out.println(x);
        }
    }
}