手撕数据结构笔记day01：数组

1数组

数组的本质就是：用来存储一组数的器皿。
定义：在内存中开辟一块连续的内存区域，用来存储相同的有序集合。

1.1.1为什么要存储相同类型

元素地址= 元素首地址+（索引*元素宽度）

1.1.2指定不同的数组类型，返回值也是不同的

int 类型是0 而 string类型则是null

1.13不同类型的数组的内存分析图

赋有初始值的情况

普通类型

ps:第⼀步，创建int数组对象时，内存结构
1>、会在堆内存当中开辟5个⻓度的连续的存储空间，⽤来存储int类型的元素。
2>、由于当前数组的类型是int类型，所以每个存储空间的元素都是int的默认值0填充。如果是String类型则默
认值为null。
3>、将堆内存的地址付给arrs变量存储

ps：第⼆步，将索引是1的元素的位置改为10，注意索引是从0开始，length-1结束
在按照元素的索引获取元素值时，注意图中的索引，我们都是安装元素的索引对于数组中的元素进⾏获取和修改。

1.14为什么说数组是不可变的

    老数组和新数组只不过是指向不同的值

1.15静态数组初始化

public class shu_2 {
    //    2.如何遍历如下的一维数组，每个数之间用逗号隔开
//
//    int[] arr = new int[]{8，5，6，7，3，5};
    public static void main(String[] args) {
        int[] arr = {8, 5, 6, 7, 3, 5};//静态初始化，给定数组的初始化值为：8,5，6,7，3,5
        for (int x = 0; x < arr.length; x++) {

                System.out.print(arr[x] + ",");
        }
    }
}

1.16动态数组初始化

public static void main(String[] args) {
        //动态数组
        int [] arr= new int[5];
        arr[0]=1;
        arr[5]=2;
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]+",");
            
        }
    }

1.16动态数组中的增删查改CRUD

 public static void main(String[] args) {
        //动态数组
        int[] arr = {4, 5, 67, 8, 9, 98, 7};
        //使用Arrays中的tostrin方法
        System.out.println(Arrays.toString(arr));
        //使用foreach循环
        int index = 0;
        for (int i : arr
        ) {
            System.out.println("每个" + index + "位置上的元素" + i);
            index++;
        }
    }

2多维数组

2.1多维数组的初始化

public static void main(String[] args) {
        /*动态初始化*/
        int[][] ars = new int[2][3];
        System.out.println(Arrays.toString(ars[0]));//[0, 0, 0]
        System.out.println(ars[0][1]);//0

        //创建一个一维数组，这个一维数组的的长度是3，每个位置上都是一个新的一维数组，
        //这个数组的长度为2
        String[][] strs = {{"niaho", "heihei"}, {"嘿嘿", "哈哈"}, {"乐字节", "郭威"}};
        System.out.println(strs[0][1]);
        //创建数组的两种不同的书写方式
        String [][] strings= {{"niaho", "heihei"}, {"嘿嘿", "哈哈"}, {"乐字节", "郭威"}};
        System.out.println(strings[1][0]);
        int[][] arrs = new int[2][];//创建了一个长度为一的一维数组，每个位置元素也是一个一维数组
//        System.out.println(arrs[0][2]);//会有一个空指针异常
        System.out.println(arrs.length);
        //添加新的元素
        arrs[0] = new int[3];
        arrs[1]= new int[5];
        System.out.println(Arrays.toString(arrs));//[[I@880ec60, [I@3f3afe78]书组中存放了两个数组对象
        System.out.println(arrs[0][1]);//结果为零
    }

2.2 多维数组的迭代，和CRUD

 public static void main(String[] args) {
        int[][] ars = new int[3][];
        ars[0]= new int []{1,23,4};
        ars[1] = new int[] {3, 45, 6};
        ars[2] = new int[]{23,45,6};

        for (int i = 0; i < ars.length; i++) {
            for (int j = 0; j < ars[i].length; j++) {
                System.out.print(ars[i][j]+"\t");
            }
            System.out.println();

        }
        System.out.println("=====================");
        //foreach循环
        for (int[] ar:ars){
            for (int num :ar
                 ) {
                System.out.print(num+"\t");
            }
            System.out.println();
        }
    }

3数组的可变参数

可变参数一定要保证在形式参数的列表的末尾
对于参数列表而言，你的形参列表中有且只有一个可变参数。

3.1可变参数的一些坑，可能以笔试题的方式出现

看看到底会靠近谁呢，这里是有一比价简单的顺序。

第二题：如果父类定义成了可变参数，二子类定义成了数组，这样重载四否回报错
注意这⾥并不会出现报错，很多⼈好奇的原因是由于这⾥⼦类重写的⽅法的参数列表和⽗类的不⼀样呀，为
什么@Override难道不会报错吗？这⾥注意确实不会报错，我们通过反编译⼯具可以看到F类反编译的代码如
下，你看懂了吗？
:本质上最后编译的.class⽂件中我们发现可变参数会变成⼀个与之对应的数组。

报错的原因：如果传入单个数字就是自动转成数组，如果本身就是一个数组的话，就没有办法转换了。

问题3： null值可以转换成任意的类型容易出现2异性
问题4) 可变参数+null值问题的重载⽅法
这是原腾讯的⼀道笔试题，通过阅读请找出问题原因以及解决⽅案? i、⼀下测试⽤例会不会出问题?原因是什么?

public class Test06 { public static void main(String[] args) { 
invoke(null,1);//会调⽤哪个⽅法呢？ } static void invoke(Object obj,Object ... args
){ System.out.println("obj = [" + obj + "], args = [" + args + "]"); } 
static void invoke(String str,Object obj,Object ... args){ 
System.out.println("str = [" + str + "], obj = [" + obj + "], args = [" + args + "]");
 }}

结果：string 都是引用的最近最优这⾥出现问题的原因是由于null值是可以转换为任意引⽤类型。

问题5导致这⾥⽅法调⽤就会出现**⼆义性，**编译器