02-2021-07-14 java数组

数组的定义

数组是多个相同数据类型按一定的顺序排列的集合 并使用一个名字命名，并通过编号的方式对这些数据进行统一管理

1. 数组的常见概念

1. 数组名
2. 下标/索引
3. 元素

4. 长度

   2. 数组的特点

5. 数组是有序的排列

6. 数组属于引用数据类型变量，数组元素可以是普通数据类型，也可以是引用数据类型
7. 数组对象会在内存空间中开辟一段连续的空间

8. 数组长度固定后不能修改

   3. 数组的分类

9. 数组维度：一维数组 二维数组

10. 数组类型：基本数据类型数组 引用数据类型数组

    4. 数组的使用

11. 数组的申明和初始化

12. 调用数组指定索引位置的元素
13. 获取数组的长度
14. 数组的遍历
15. 数组默认的初始化值
16. 数组的内存解析

     public static void main(String[] args) {
         //1.数组的初始化和赋值
         //方式一 静态初始化 初始化和元素赋值一起进行
         int[] ids;
         ids = new int[]{1001, 1002, 1003, 1004};
         //方式二 动态初始化 初始化和元素赋值分开进行
         String[] names = new String[5];
         //2.调用数组指定位置的元素
         System.out.println(ids[1]); //1002
         //数组元素赋值
         names[0] = "xue";
         names[1] = "dong";
         names[2] = "zhi";
         //3. 数组的遍历
         for (int i = 0; i < names.length; i++) {
             System.out.println(names[i]);
         }
         //4. 数组长度获取 names.length
         //5。数组的默认初始化值
         //基本数据类型  int 0  boolean false
         //引用数据类型  null
     }

    jvm 栈 stack (局部变量) 堆 heap （new 的引用数据类型） 方法区
    1.常量池 (字符串常量) 2.静态域

5 二维数组的使用

1. 初始化方式一：
   1. String[][] names = new String[5][4];
   2. 访问外曾元素 names[0] 显示地址值
   3. 访问内曾元素 names[0][0] 和一维数组一样默认值

2. 初始化方式二：

   1. String[][] names = new String[5][];
   2. 访问外曾元素 names[0] 显示null
   3. 访问内曾元素 names[0][0] 显示空指针异常

      6 练习

      1. 杨辉三角

      public static void main(String[] args) {
        //杨辉三角
        //1.初始化二维数组
        int[][] yanghui = new int[10][];
        //2.二维数组赋值
        for (int i = 0; i < yanghui.length; i++) {
            yanghui[i] = new int[i + 1];
            yanghui[i][0] = yanghui[i][i] = 1;
            for (int j = 1; j < yanghui[i].length-1; j++) {
                yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
            }
        }
        //3.遍历二维数组
        for (int i = 0; i < yanghui.length; i++) {
            for (int j = 0; j < yanghui[i].length; j++) {
                System.out.print(yanghui[i][j]+"  ");
            }
            System.out.println();
        }
      }

      2. 数组反转

      public static void main(String[] args) {
        //数组顺序反转
        String[] mystr = new String[]{"aa","bb","cc","dd","ee"};
        for (int i = 0; i < mystr.length; i++) {
            System.out.print(mystr[i]+"  ");
        }
        System.out.println("");
        for (int i = 0; i < mystr.length / 2; i++) {
            String temp = mystr[i];
            mystr[i] = mystr[mystr.length-1];
            mystr[mystr.length-1] = temp;
        }
        for (int i = 0; i < mystr.length; i++) {
            System.out.print(mystr[i]+"  ");
        }
      }

      3. 线性查找

      public static void main(String[] args) {
        //线性查找
        String[] mystr = new String[]{"aa", "bb", "cc", "dd", "ee"};
        boolean fleg = false;
        String targ = "cc";
        for (int i = 0; i < mystr.length; i++) {
            if (targ.equals(mystr[i])) {
                fleg = true;
                System.out.println("find it positon: "+i);
                break;
            }
        }
        if (!fleg) {
            System.out.println("find nothing");
        }
      }

      4. 二分查找

      public static void main(String[] args) {
        //线性查找 前提：有序
        int[] myint = new int[]{1, 4, 66, 88, 90, 100, 333};
        int dest = 66;
        boolean isfleg = false;
        int start = 0;
        int end = myint.length - 1;
        while (start <= end) {
            int middle = (start + end) / 2;
            if (dest == myint[middle]) {
                System.out.println("找到啦位置是：" + middle);
                isfleg = true;
                break;
            }else if (dest > myint[middle]){
                start = middle+1;
            }else{
                end = middle-1;
            }
        }
        if (!isfleg){
            System.out.println("未找到");
        }
      }

      5. 排序 （算法的一种）

      1. 排序分类

3. 快速排序

4. 插入排序

5. 冒泡排序

    public static void main(String[] args) {
        //冒泡排序
        int[] myint = new int[]{1, 88, 4, 199, 66, 5, 90, 999, 100, 3};
        for (int i = 0; i < myint.length - 1; i++) {
            for (int j = 0; j < myint.length - 1 - i; j++) {
                if (myint[j] > myint[j+1]) {
                    int temp = myint[j];
                    myint[j] = myint[j+1];
                    myint[j+1] = temp;
                }
            }
        }
        for (int i = 0; i < myint.length; i++) {
            System.out.print(myint[i]+"  ");
        }
    }

6. 递归排序

7. 选择排序
8. 基数排序

9. 桶式排序

   2. 算法特征

10. 输入

11. 输出
12. 有穷性
13. 可行性

14. 确定性

    7. 数组工具类Arrays

    1. 常用方法

15. equals

16. toString
17. fill

18. binarySearch

     public static void main(String[] args) {
         //Arrays 工具类
         int[] myint = new int[]{1,19,40,3,24,500,26};
         int[] myint2 = new int[]{26,19,40,3,24,500,1};
         //1.Arrays.equals
         boolean equals = Arrays.equals(myint, myint2);
         System.out.println(equals);
         //2.Arrays.toString
         String s = Arrays.toString(myint);
         System.out.println(s);
         //3.Arrays.binarySearch 二分查找
         int i = Arrays.binarySearch(myint2, 24);
         System.out.println(i);
         //4.Arrays.sort 排序
         Arrays.sort(myint);
         String s2 = Arrays.toString(myint);
         System.out.println(s2);
         //4.
         int[] myint3 = new int[5];
         Arrays.fill(myint3,1);
         System.out.println(Arrays.toString(myint3));
     }

    2. 常见的异常

19. 数组角标越界

20. 空指针异常