JAVA-数组

一、数组
数组：一组有顺序(指的是每一个元素都有一个编号–下标–索引)的数据，可以保存若干个数据。每一个数据我们称之为元素
一旦开辟空间之后。所有的元素都会由系统分配一个默认值。整数型：0，浮点型：0.0 boolean：false char 0 复合数据类型的：null
数组只能保存一种数据类型，数据类型可以是任意的类型
数组：有顺序，下标的顺序，从0开始，最大下标为length-1。
使用数组的时候经常会遇到的异常：java.lang.ArrayIndexOutOfBoundsException 数组越界的一个异常 可能你的下标是一个负数，或者是一个大于length-1的一个值。

数组有三种初始化的方式：
1：动态初始化：定义和分配空间可以分开进行。也可以同时进行。
int[] ints; ints = new int[10];
2：静态初始化：只能声明和初始化一同进行，放到同一行。
int[] ints = {1,2,3};
3：动静结合：int[] ints = new int[]{1,2,3};
4：如何访问数组元素
数组名+下标 例如：ints[0]。

二、增强for循环
foreach
优点：语法简单，使用方便。
缺点：不能修改数组元素的内容。foreach 遍历的内容为原数组的拷贝。只能用来遍历数组。
说它是增强的for循环，其实功能减弱了。

1：通过数组的下标去访问数组的元素
2：通过内容去查找某一个元素

查找数组中的最大值和最小值。
int min = ints[0];
思路：挨个对数组中的元素进行比较，只要当前元素比max大，那么就把元素的值赋值给max，然后继续比较下一个。

        for (int i = 1; i < ints.length; i++) {            if(ints[i] < min){                min = ints[i];            }        }        System.out.println("当前数组的最小值为："+min);

数组的元素删除
//找到不和谐内容的索引

        final String str = "土豆";        final int len = names.length;        int index = 0;//存储不和谐内容的索引        for (int i = 0; i < len; i++) {            if(names[i].equals(str)){                index = i;                System.out.println("不和谐内容索引为："+index);                break;            }        }        //不和谐元素后面的内容全部前移一个元素        for (int i = index; i < len-1; i++) {            names[i] = names[i+1];        }        //将最后一个元素设置为null        names[len-1] = null;        //遍历打印        for (String string : names) {            System.out.println( string);        }

数组的优点和缺点
优点：
按照数组的索引访问数组的元素速度很快。遍历数组的元素非常快。
缺点：
1：数组的长度一旦确定不能更改，对于有扩容需求的数据是无法满足。
2：删除数组的元素效率比较低。需要自己封装方法。数组的封装程度比较低。
没有提供足够的对元素操作的方法。所有的对元素的操作都需要自己手动实现。

冒泡排序的实现原理

        for (int i = 0; i < len-1; i++) {            for (int j = 0; j < len-i-1 ; j++) {                if(ints[j]>ints[j+1]){                    int temp = ints[j];                    ints[j]  =ints[j+1];                    ints[j+1] = temp;                }            }        }

三、Arrays
封装了大量操作数组的方法
Arrays类—构造器 是 private修饰 private Arrays() {}
不能创建对象，如果我想要访问Arrays类其中的方法：只能通过 类名.方法名访问（因为Arrays类里面的方法 都是静态方法 都用static修饰）
常用方法：
sort 排序 升序排序
binarySearch 二分法查找
copyOf 拷贝 返回生成新的数组
fill 填充 将制定的数组，填充为制定的内容
equals 比较两个数组是否相等
toString 打印指定的数组的内容

四、二维数据

一维数组的元素又是一个一维数组 那么该数组就是一个二维数组
一个一维数组的元素是一个二维数组，那么该数组就是三维数组。
语法：
int[][] ints = new int[3][4];

public static void main(String[] args) {        //定义高纬度的元素个数        int[][] ints = new int[9][];        //定义低纬度的元素个数                for (int i = 0; i < ints.length; i++) {            ints[i] = new int[i+1];        }        //        for (int i = 0; i < ints.length; i++) {//代表行数            for (int j = 0; j < ints[i].length; j++) {//第i行的列数                ints[i][j] = (i+1)*(j+1);                System.out.print("  "+(j+1) +"*"+(i+1)+" = "+ ints[i][j]);            }            System.out.println();        }}

可变参数
语法：(int … ints)

public int add(int ... ints){        int sum = 0;        for (int i = 0; i < ints.length; i++) {            sum += ints[i];        }        return sum;}

特点：
1：可变参数，必须当做数组来处理。
2：可变参数可以接收参数的数量？0-N个。
3：方法调用中传递参数，在进行方法匹配的时候，优先匹配定长的参数的方法。
4：如果一个方法中有可变参数，那么该参数必须在参数列表的末尾。
5：一个方法中，最多只能有一个可变参数。
6：可变参数可以接收n个和参数类型一致的数据。还可以接收一个与参数类型相同的数组。

强调一点：可变参数的方法。底层就是使用数组实现的。

可变参数和数组作为参数的相同点和不同点
相同点：
1：都可以接收数组作为实参进行匹配。
2：方法内部处理可变参数和 数组参数，都只能当做数组进行处理。

不同点：
1：数组参数只能接收数组，变参可以接收数组，还可以接收与变参类型相同的类型的若干(0—n)数据。
2: 数组作为参数，可以有多个数组的形参。变参最多只能有一个，而且只能在参数列表的末尾。