Day_05

1数组

1.1数组

        数组是引用数据类型 里面有序保存多个数据

1.2 数组特性

        链序存储 长度确定后不会改变长度

        当添加数据时，需要新建数组然后复制过去，然后添加

        删除类似

        数组长度 arr.length

        查询修改效率高 增加删除低

1.3数组声明

        静态数组 数据类型 [ ] 数组名={，，，} //简化

                        int [ ] arr={1,2,3};

                        数据类型 [ ] 数组名=new 数据类型[ ] {，，，}

                        int [ ] arr=new int[]{1,2,3}

        动态数组 数据类型 [ ] 数组名 =new 数据类型 [长度];

                        int [] arr =new int[10]

    1.4数组在内存的存储形式

        main{

                arr[];

        }

        

            方法区加载class文件

            在jvm栈里面是数组 但是数组里面保存的是地址，改地址是堆里面新创建的数组对象地址

             堆里面是数组的内容

1.5 数组使用

        1.5.1获取数据

                arr[0];

                arr[arr.length-1] 最后一个数据

                arr.length 长度

        1.5.2更改数据

                arr[i]=*;

        1.5.3遍历数组

        for（int i=0；i<arr.length;i++）{

        syso(arr[i]);

}

        1.5.4常见异常

        下标越界

Exception in thread "main" 123java.lang.ArrayIndexOutOfBoundsException: 4
    at _day_05.Demo_02.main(Demo_02.java:19)

     1.5.5 数组传递

public static void main(String[] args) {
        // TODO Auto-generated method stub
        int i = 1;
        n(i);
        n(1);
        //字面量
        int arr[]={1,2};
        n(new int[]{1,2}); //静态方法创建
        n(arr);

    }

    public static void n(int n) {
    }

    public static void n(int[] arr) {

    }

1.6传值和传址☆

        引用类型传递：传递地址，两个变量会指向同一个堆内存对象数据

        当把某一个数据修改后，另一个也会修改

        public class Demo_04 {
    public static void main(String[] args) {
    int i=10;
    n(i); //11
    System.out.println(i); //10
    int[] arr={1,2,3};
    n(arr); //0
    System.out.println(arr[0]); //0
    
    
    }
    public static void n(int n) {
        n++;
        System.out.println(n);
    }
    public static void n(int[] arr) {
        arr[0]=0;
        System.out.println(arr[0]);
    
    }

1.7数组替换复制

        public static void main(String[] args) {
        int[] src={1,2,3,4,4,6};
        int[] dest={5,6,7,8,8,9};
        //arraycopy(src,1,dest,1,2);将源数组src从下标为1的地方拿取长度为2的数据替换目标数组dest从下标为1的数据开始
        arraycopy(src,1,dest,1,2);
        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);
        }
    }
    public static void arraycopy(int[]src,int srcIndex,int[]dest,int destIndex,int length){
        for(int i=0;i<length;i++){
            dest[destIndex]=src[srcIndex];
            destIndex++;
            srcIndex++;
        }
        
    }

1.8数组插入复制

public static void main(String[] args) {
    int src[]={1,2,3,4};
    int dest[]={5,6,7,8}; 
    arrayCopy(src, 1, dest, 2, 3);//把源数组src从下标开始的位置复制到新数组下标的后面
    
    
    
    }
    public static void arrayCopy(int src[],int srcIndex,int dest[],int destIndex,int length) {
        int [] dest2=new int[dest.length+length];
        for (int i = 0; i <= destIndex; i++) {
            dest2[i]=dest[i];
        }
        int index=destIndex;
        for (int i = srcIndex; i <srcIndex+length; i++) {
            index++;
            
            dest2[index]=src[i];
        }
        for (int i = destIndex+1; i < dest.length; i++) {
            index++;
            dest2[index]=dest[i];
            
        }
        for (int i = 0; i < dest2.length; i++) {
            System.out.println(dest2[i]);
        }
        
    }

2二维数组

        数组中保存数据类型的是数组

2.1声明方式

       静态声明：

                       int[] [] arr={{1,2,3}，{1,2}}；

        动态声明

                        int[] [] arr=new int [n][m] //二维数组中有n个一位数组 每个数组中有m个元素

2.2内存的存储形式

        

        2.3使用方式

         2.3.1获取数据

                arr[ i]  [ k]

                获取第一个一维数组的最后一个元素

                int [] arr2=arr[ arr.length-1];

         2.3.2 遍历

                public static void main(String[] args) {
        int[][] arr={{1,2,3},{1,2}};
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]);
            }
            System.out.println();
        }
    }
        2.3.4动态声明锯齿状 杨辉三角

        public static void main(String[] args) {
        int [][] arr=new int[10][];
        for (int i = 0; i < arr.length; i++) {
            arr[i]=new int[i];
        }
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (j==0||j==arr[i].length-1) {
                    arr[i][j]=1;
                    
                }
                else {
                    arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
                }
                
            }
        }
        for (int  i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]);
            }
            System.out.println();
        }
        
    }

3交换变量

        //中间变量

        int a= 1;

        int b=2;

        int c;

        c=a'

        a=b;

        b=c;

        //异或运算

        a=a^b;

        b=a^b;

        a=a^b;

        //相加运算

        a=a+b;

        b=a-b;

        a=a-b;