Java数组

数组的实例化

使用new的两种方式：
1.动态初始化
第一种方式： new+直接初始化具体元素
第二种方式： new+长度
2. 静态初始化
数据类型[] 变量 = {元素1,元素

public class _01ArrayDemo {
    public static void main(String[] args) {
        //new+直接初始化具体元素
        String[] names = new String[]{"小红","小明","小强","张三","李四"};
        //new+长度:   注意，其实是有长度个默认元素
        int[] nums = new int[5]; // byte，short,int,long对应的默认元素是0
        System.out.println(Arrays.toString(nums));
        double[] prices = new double[5]; // float double 对应的默认元素0.0
        System.out.println(Arrays.toString(prices));
        char[] chars = new char[5];      //char 对应的默认元素 \u0000
        System.out.println(Arrays.toString(chars));
        boolean[] bools = new boolean[5];  //boolean 对应的默认元素  false
        System.out.println(Arrays.toString(bools));
        String[] adds = new String[5];      //引用类型 对应的默认元素 null
        System.out.println(Arrays.toString(adds));

        //使用静态初始化的方式，实例化一个数组, 注意：该方式不能先声明，再初始化
        int[] numbers = {1,2,3,4,5};
    }
}

数组的访问

1. 通过下标访问：  下标就是元素对应的索引值。 下标从0开始，最后一个元素下标length-1
2. 数组的长度：  变量名.length
3. 如何通过下标访问：  变量名[index]

public class _02ArrayDemo {
    public static void main(String[] args) {
        int[] ages = new int[]{20,18,19,20,19,30};
        //获取ages中的第一个元素
        int first = ages[0];
        System.out.println("first: " + first);
        //获取ages中的第4个元素
        int four = ages[3];
        System.out.println("four: " + four);
        //打印ages的长度
        System.out.println("长度："+ages.length);
        //直接打印ages中的最后一个元素
        System.out.println("最后一个元素："+ages[ages.length-1]);

        //将年龄39，存入到第二个位置
        ages[1] = 39;
        //将年龄50，存入到最后一个位置
        ages[ages.length-1] = 50;
        System.out.println(Arrays.toString(ages));

        //创建一个具有5个长度的long类型数组
        long[] ns = new long[5];
        //将数字10,20,30,40,50分别存入。
        ns[0] = 10;
        ns[1] = 20;
        ns[2] = 30;
        ns[3] = 40;
        ns[4] = 50;
        System.out.println(Arrays.toString(ns));

        //将数字1~10存入到int类型的数组scores里
        int[] scores = new int[10];
        for (int i = 0; i < scores.length  ; i++) {
            scores[i]=i+1;
        }
        System.out.println(Arrays.toString(scores));
    }
}

数组下标越界

数组下标越界异常：ArrayIndexOutOfBoundsException
1. 什么时候发生的？在运行期间发生的。
2. 怎么发生的？当输入的下标大于等于数组的长度或者是小于0发生的。
3. 运行时异常，如果不做任何处理操作，那么jvm会暴力终止该程序。
空指针异常：NullPointerException
1. 运行时异常，运行期间发生的
2. 如何发生的， 即使用null去访问各种方法或者属性
比如：  null.length()   null.name等等操作

public class _03ArrayDemo {
    public static void main(String[] args) {
        int[] nums = {1,3,2,4,5};
//        int e1 = nums[5];
//        System.out.println(e1);
//        int e2 = nums[nums.length+10];
//        System.out.println(e2);

        String[] names = {"小明","michael",null,""};
        //打印每个元素的字符长度
        for (int i = 0; i < names.length; i++) {
            //处理null的情况
            if(names[i]==null){
                continue;
            }
            System.out.println(names[i].length());
        }
    }
}

数组的遍历

1. 使用经典for循环，通过下标进行遍历
2. 使用foreach循环：也叫增强for循环。底层使用的是迭代器。
for(元素类型 变量名:数组|集合|枚举){

 }
 3. 两者的对比
- 增强for循环中，没有下标的概念
- 增强for循环中，不能对数组中的元素进行改动
- 增强for循环比遍历下标的执行效率要高

public class _04ArrayDemo {
    public static void main(String[] args) {
        int[] nums = new int[5];
        nums[0] = 10;
        nums[1] = 20;
        nums[2] = 30;
        nums[3] = 40;
        nums[4] = 50;
        //直接打印数组的变量
        System.out.println("数组变量："+nums); //直接打印数组名，得到的是类全名+@+内存地址的16进制数字
        //调用Arrays.toString();
        System.out.println("数组字符串："+ Arrays.toString(nums));

        //使用经典for循环，通过下标进行遍历
        for (int i = 0; i < nums.length; i++) {
            //i充当下标
            System.out.print(nums[i]+" ");
            //System.out.println(nums[i]);
        }
        System.out.println();
        System.out.println("---------增强for循环-----------");

        //使用foreach循环遍历上面的数组nums
        for(int n:nums){
            System.out.print(n+" ");
        }
    }
}

数组的排序之: 选择排序

原理：
 第一轮：拿0索引处的元素与后面的元素一一做比较，满足条件就交换。每次交换都保证0索引处是较小值。
一轮结束，0索引处，就是最小值
第二轮：拿1索引处的元素与后面的元素一一做比较，满足条件就交换。每次交换都保证1索引处是较小值。
一轮结束，1索引处，就是第二最小值
每轮依次比较下去。
比较的轮数： 元素个数-1

通过分析：  轮数是有外层循环控制，
 每一轮的比较由内层循环控制

 0-1,2,3,4,5
   1-2,3,4,5
     2-3,4,5
       3-4,5
         4-5

public class _05ArrayDemo {
    public static void main(String[] args) {
        int[] nums = {6,5,3,2,4,1};
        //控制着轮数
        for (int i = 0; i < nums.length -1 ; i++) {
            //控制着每轮的比较
            for (int j = i+1; j < nums.length ; j++) {
                //  nums[i]:  就是每轮要判断是否是最小的元素的位置。
                //  nums[j]:  就是依次要比较的后续元素
                if(nums[i] > nums[j]){ //条件成立，做交换操作
                    //定义一个临时变量,保存i处的元素
                    int temp = nums[i];
                    // 将j处的元素存储i处
                    nums[i] = nums[j];
                    // 将临时变量里的原i处的元素，放入j处。
                    nums[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(nums));
    }
}

冒泡排序

   从左到右，紧挨着的两个元素进行比较，满足条件就交换。
 数组里有6元素。
第一轮：  能找到最大值，冒泡到最右边。
  比较五次
 第二轮：   第二大元素冒泡到倒数第二个为止
比较4次
第五轮:  第五大元素冒泡的正数的第二个为止。  最后一个数不再需要比较了
注意： 每一轮比较时，都是从最左边的两个元素开始的。
6个元素：
 i=0    j=5
 i=1    j=4
 i=2    j=3
 i=3    j=2
 i=4    j=1     j < length-1-i

public class _08ArrayDemo {
    public static void main(String[] args) {
        int[]  nums = {6,2,4,7,1,5};
        //外层循环控制着轮数，轮数是leng-1轮
        for (int i = 0; i < nums.length-1; i++) {
            //内层是控制着每轮如何比较. 每次都要从左边开始比较，因此j从0开始
            for (int j = 0; j < nums.length-1-i ; j++) {
                // 如果前面的大于后面的，就做交换操作
                if (nums[j] > nums[j+1]) {
                    int temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(nums));
    }
}

从数组中查找元素--顺序查找法

public class _09ArrayDemo {
    public static void main(String[] args) {
        int[] nums = {100,23,48,56,10,78};
        //需求：查找数组中是否有56，如果有，返回其坐标，如果没有返回-1
        int index = searchElement(nums,23);
        System.out.println("index:"+index);
    }
    /**
     * 需求：查找int类型的数组arr中是否有元素element，如果有，返回其坐标，如果没有返回-1
     */
    public static int searchElement(int[] arr, int element) {
        int index = -1;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == element){
                index = i;
                break;
            }
        }
        return index;
    }
}

数组元素的二分查找法

public class _10ArrayDemo {
    public static void main(String[] args) {
        int[] nums = {1,4,6,7,9,10};
        int index = binarySearch(nums,7);
        System.out.println(index);
    }
    /**
     * 写一个使用二分查找算法，从int类型的数组arr中找元素element的方法
     * 找到，返回其坐标，没找到，返回-1
     */
    public static int binarySearch(int[] arr, int element) {
        int min = 0, max = arr.length - 1;
        //  min<=max时，表示还没有找到该元素， min=max时，是最后一次查找
        while (min <= max) {
            // 找到中间的元素下标
            int mid = (min + max) / 2;
            if (arr[mid] == element) {
                //如果mid位置上的元素就是我们要找的，就返回下标
                return mid;
            }else if (arr[mid] < element) { // 表示要找的元素，在中间值的右侧
                min = mid + 1;  //将min设置为中间下标+1.  然后重新循环
            }else {  //表示要找的元素，在中间值的左侧
                max = mid - 1;  //将max设置为中间下标-1.  然后重新循环
            }
        }
        //循环结束都没有遇到return,说明没有找到，就返回-1
        return -1;
    }
}

Arrays工具类的用法

1. toString()：将数组转换为字符串形式。   "["+元素1+","+元素2+","+.....+"]"
2. binarySearch()：在已排序的数组中查找指定元素的索引。
3. fill()：将数组的所有元素都设置为指定值。
4. sort(数组)：对数组进行排序。
5. copyOf()：将一个数组的部分或全部元素复制到一个新数组中。

public class _11ArrayDemo {
    public static void main(String[] args) {
        int[] nums = {1,2,3,4,5};
        String info = Arrays.toString(nums);
        System.out.println(info);//[5, 4, 3, 2, 1]
        System.out.println(Arrays.toString(nums)); //[5, 4, 3, 2, 1]

        //注意：工具类里的二分查找法，必须要数组升序排序
        int index = Arrays.binarySearch(nums,4);
        System.out.println(index);

        //使用指定元素，填满整个数组
        Arrays.fill(nums,100);
        System.out.println(Arrays.toString(nums));

        //Arrays.sort(数组名)： 只能对已经提前设置好排序规则的类的数组进行排序。
        int[] nums2 = {2,3,4,1,5};
        Arrays.sort(nums2);
        System.out.println(Arrays.toString(nums2));

        // 扩容: 将源数组的所有元素都拷贝到新数组的最前面，然后多余的位置是默认值， 注意：返回的是一个新的数组
        int[] nums3 = Arrays.copyOf(nums2,10); // [1,2,3,4,5,0,0,0,0,0]
        // 指定的长度一样，因此可以理解为，完全拷贝。新数组和源数组一模一样
        int[] nums4 = Arrays.copyOf(nums2,nums.length);  // [1,2,3,4,5]

        // 指定的长度小于源数组的长度，可以理解为部分拷贝。注意是从头开始拷贝
        int[] nums5 = Arrays.copyOf(nums2,3);
        System.out.println(Arrays.toString(nums5));

    }
}