数组、排序

1. 数据结构：计算机存储、组织数据得方式
2. 数组
   数组：
   声明规则：数组类型 数组名[]
                     数组类型[] 数组名
           静态声明：

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

   
           动态声明：

   int[] arr2 = new int[100];

   数组的内存模型：
           1）数组的所有元素保存在堆内存中
           2）创建数组就是在堆中创建数组对象
           3）数组创建后拥有默认值
           4）下标（索引）是从0开始
           5）连续分配
   数组操作：
           1）增、删（对于单个数组没有该操作）
           2）查 arr[0]
           3）改
3. 遍历数组
   遍历：把每一项都拿出来
   数组的遍历是利用for循环和数组的下标实现的
   for循环：

           for (int i = 0; i < arr1.length; i++) {
               System.out.println(arr1[i]);
           }

   增强for循环：
    

           for (int every: arr1) {
               System.out.println(every);
           }

4. 数组的异常
   常见错误：
           1）下标越界：报错ArrayIndexOutOfBoundsException
           2）空指针：报错NullPointerException
           3）传值与传址（重点）
                

   public static void main(String[] args) {
   //      传值和传址
           int x=10;
           System.out.println(x);   //10
           a(x);
           System.out.println(x);//  10
           int[] f={1,2,3,4,5};
           System.out.println(f[0]);//1
           b(f);
           System.out.println(f[0]);//10
       }
       public static int a(int y){
           y++;
           System.out.println(y+10);//21
           return y;
       }
       public static int[]  b(int[] t){
           t[0]=10;
           return t;
       }

   
    
5. 二维数组

    二维数组：
   声明规则：数组类型 数组名[][]
                     数组类型[][] 数组名
           静态声明：

   int[][] a={{1,2,3,4},{1,2,3},{1,2}};

   
           动态声明：

       int[][] a = new int[5][];
       int[][] b = new int[5][6];
   //  int[][] c = new int[][6] 二维数组不能这么定义
   

6. 二维数组遍历
   for循环

           int[][] a={{1,2,3,4},{1,2,3},{1,2}};
           for (int i = 0; i < a.length; i++) {
               for (int j = 0; j < a[i].length; j++) {
                   System.out.print(a[i][j]+" ");
               }
               System.out.println();
           }

   增强for循环

           for (int[] eve:a) {
               for (int every:eve) {
                   System.out.print(every+" ");
               }
               System.out.println();
           }

7. 数组的复制

           System.arraycopy(a,1,b,1,3);
   //      第一个参数，源数组
   //      第二个参数，源数组开始的位置
   //      第三个参数，目标数组
   //      第四个参数，目标数组开始的位置
   //      第五个参数，复制的长度

8. 算法排序
           1）冒泡排序：相邻元素比较，如果第一个大于第二个元素，就交换

           for (int i = 0; i < a.length-1; i++) {
               for (int j = 0; j < a.length-1-i; j++) {
                   if(a[j] >a[j+1]){
                       int c=a[j];
                       a[j]=a[j+1];
                       a[j+1]=c;
                   }
               }
           }
           for (int eve:a) {
               System.out.println(eve);
           }

   
           2）选择排序：将第一个元素与后面比较，如果第一个大于第二个则交换位置，交换之后运行上面得步骤。

           for (int i = 0; i < a.length-1; i++) {
               int min=i;
               for (int j = i+1; j <=a.length-1 ; j++) {
                   if(a[min] >a[j]){
                       min=j;
                   }
               }
               if(min!=i){
                   int c=a[min];
                   a[min]=a[i];
                   a[i]=c;
               }
           }
           for (int eve:a) {
               System.out.println(eve);
           }

   
           3）调用api排序

          Arrays.sort(a);
           for (int eve:a) {
               System.out.println(eve);
           }