04.数组

第一章.数组的介绍以及定义

1.概述:容器
2.作用:一次存多个数据
3.特点:
  a.定长(定义数组的时候长度为多少,最多就能存多少个数据,后续操作的时候不能对长度进行修改)
  b.既可以存基本类型数据,还能存引用类型数据  
4.定义:
  a.动态初始化(定义的时候只规定元素类型以及数组长度,没有存具体的元素,需要后续动态存入)
    数据类型[] 数组名 = new 数据类型[长度]
    数据类型 数组名[] = new 数据类型[长度]
      
    等号左边的数据类型:规定了数组中元素的类型
    []:代表的数组
    数组名:见名知意,自己为数组取名字
    new:创建数组
    等号右边的数据类型:和等号左边的数据类型一致
    [长度]:规定数组的长度,代表最多能存多少个数据(元素)
        
  b.静态初始化(定义的时候直接往数组存储元素,存多少个数据,长度就是多少)
    数据类型[] 数组名 = new 数据类型[]{元素1,元素2...}
    数据类型 数组名[] = new 数据类型[]{元素1,元素2...}

  c.简化的静态初始化
    数据类型[] 数组名 = {元素1,元素2...}

public class Demo01Array {
    public static void main(String[] args) {
        //动态初始化创建数组
        int[] arr1 = new int[3];
        String[] arr2 = new String[3];
        
        //静态初始化创建数组
        int[] arr3 = {1,2,3,4,5};
        String[] arr4 = {"努尔哈赤","皇太极","顺治","康熙","雍正","乾隆","嘉庆","道光","咸丰","同治","光绪","宣统"};
        
    }
}

分别用动态初始化,和静态初始化将8种基本类型都定义一遍,外加上一个字符串的数组

第二章.操作数组

1.获取数组的长度

1.格式:
  数组名.length
2.注意:
  length是数组的一个属性,所以在调用的时候不要带()

public class Demo02Array {
    public static void main(String[] args) {
        String[] arr1 = {"努尔哈赤","皇太极","顺治","康熙","雍正","乾隆","嘉庆","道光","咸丰","同治","光绪","宣统"};
        System.out.println(arr1.length);
    }
}

2.索引

1.概述:指的是元素在数组中的存储位置(下标)
2.特点:
  a.从0开始,最大索引为(数组长度-1)
  b.唯一,不能重复    
3.注意:
  操作数组中的元素,都是根据索引来操作的

3.存储元素

1.格式:
  数组名[索引值] = 值
      
2.含义:
  将等号右边的值放到数组指定的索引位置上

public class Demo03Array {
    public static void main(String[] args) {
        String[] arr = new String[3];
        //存元素
        arr[0] = "涛哥";
        arr[1] = "金莲";
        arr[2] = "大郎";

        //获取元素
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

4.获取元素

1.注意:
  a.直接输出数组名,会输出数组的地址值(数据在内存中的唯一标识)
  b.数组创建完之后,没有存具体的值,直接输出会输出元素的默认值
    整数 0
    小数 0.0
    字符 '\u0000'  空白字符,转成int型就是0
    布尔 false
    引用 null
      
2.格式:
  数组名[索引值]

public class Demo04Array {
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr);//地址值
        System.out.println(arr[0]);//0 默认值
        System.out.println(arr[1]);//0 默认值
        System.out.println(arr[2]);//0 默认值

        arr[0] = 10;
        arr[1] = 20;
        arr[2] = 30;
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

arr1[0] = arr2[1] -> 将arr2这个数组的1索引上的元素取出来放到arr1这个数组的0索引上

public class Demo05Array {
    public static void main(String[] args) {
        int[] arr1 = {1,2,3};

        int[] arr2 = new int[3];

        //将arr1这个数组的0索引上的元素赋给arr2的0索引
        arr2[0] = arr1[0];
        //将arr1这个数组的1索引上的元素赋给arr2的1索引
        arr2[1] = arr1[1];

        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        //arr2的2索引上的元素没有被赋值,所以是默认值
        System.out.println(arr2[2]);

    }
}

5.遍历数组

1.概述:循环获取元素
2.快捷键:数组名.fori    

public class Demo06Array {
    public static void main(String[] args) {
        int[] arr = {1,2,3,34,4,54,4,4,5,6,6,7,7,7,7};
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

6.操作数组时容易出现的问题

6.1.数组索引越界异常_ArrayIndexOutOfBoundsException

1.出现的原因: 操作的索引,超出了数组的索引范围

public class Demo07Array {
    public static void main(String[] args) {
        int[] arr = new int[3];
        arr[0] = 10;
        arr[1] = 20;
        arr[2] = 30;
        //arr[3] = 40; 数组中没有3索引,会抛出ArrayIndexOutOfBoundsException异常
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

6.2.空指针异常_NullPointerException

1.出现的原因:
  一个引用类型数据为null之后还要使用

public class Demo07Array {
    public static void main(String[] args) {
        int[] arr = new int[3];
        arr[0] = 10;
        arr[1] = 20;
        arr[2] = 30;
        //arr[3] = 40; 数组中没有3索引,会抛出ArrayIndexOutOfBoundsException异常
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        arr = null;
        System.out.println(arr.length);
    }
}

第四章.内存的说明

1.内存的概念:说白了就是运行内存,在java的世界中分为5块:
2.分哪5块:
  栈(了解)(Stack):方法的运行都会在栈内存中运行
      
  堆(了解)(Heap):存储的是引用类型的数据,而且每new一次都会在堆内存中开辟一个空间,堆内存会为这个空间自动分配一个地址值
                而且堆内存中的数据都有默认值
                整数  0
                小数  0.0
                字符  '\u0000'
                布尔 false
                引用  null
      
  方法区(了解)(Method Area):所有代码执行前的"预备区",方法运行前代码会先加载到内存中,先保存在方法区中
                          在方法区中记录了类的信息以及方法的信息
      
  本地方法栈(不用管)(Native Method Stack):运行本地方法 -> 带native关键字的
                本地方法:是对java无法实现的功能进行功能上的扩充,这些本地方法都是C语言编写
                        这些本地方法如何实现的,我们看不到,因为c语言没有对我们开源
      
  寄存器(不用管)(PC register):和CPU有关

1.一个数组内存图

2.两个数组内存图

new了两次,开辟了两个不同的空间,修改一个空间中的数据不会影响另外一个空间的数据

3.两个数组指向同一片内存空间

arr2不是new出来的,而是arr1给的,所以arr2和arr1的地址值是一样的,所以就指向了同一片空间,修改一个数组的数据会影响到另外一个数组

第五章.数组复杂操作_数组扩容

1.定义一个数组,存储1,2,3,将其扩容到长度为5

public class Demo04Array {
    public static void main(String[] args) {
        int[] arr1 = {1,2,3};
        /*
           由于数组定长,定义之后不能修改长度
           所以我们只能创建一个新数组,指定新长度
         */
        int[] arr2 = new int[5];

        //将arr1的数据复制到arr2中
        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }

        /*
          将arr2的地址值赋值给arr1
         */
        arr1 = arr2;

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

第六章.数组常见算法

1.数组翻转

1.将数组中对称索引位置上的元素互换

public class Demo01Reverse {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        for (int min = 0,max = arr.length - 1; min < max; min++,max--){
            int temp = arr[min];
            arr[min] = arr[max];
            arr[max] = temp;
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

2.冒泡排序

1.数组的排序有很多种:我们今天只将冒泡排序
2.规则:
  相邻两个元素比较,大的往后走,小的往前走
  默认都是升序  

public class Demo02MaoPao {
    public static void main(String[] args) {
        int[] arr = {5,4,3,2,1};
        /*
           数组长度为5,最多索引为4,但是我们需要将i<arr.length改成
           i<arr.length-1
           此时i最大能变化到3,当i为3的时候,正好是arr[3]和arr[4]比较,所以就不越界了

           第一轮比较,比较了4次
         */
/*        for (int i = 0; i < arr.length-1-0; i++) {
            if (arr[i]>arr[i+1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }*/

        /*
          第二轮比较,比较了3次
         */
/*        for (int i = 0; i < arr.length-1-1; i++) {
            if (arr[i]>arr[i+1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }*/

        /*
          第三轮比较,比较了2次
         */
/*        for (int i = 0; i < arr.length-1-2; i++) {
            if (arr[i]>arr[i+1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }*/

        /*
          第四轮比较,比较了1次
         */
    /*    for (int i = 0; i < arr.length-1-3; i++) {
            if (arr[i]>arr[i+1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }*/

        /*
           外圈代表比较了几轮
           内圈代表比较换位
         */
        for (int j = 0; j < arr.length-1; j++) {
            for (int i = 0; i < arr.length-1-j; i++) {
                if (arr[i]>arr[i+1]){
                    int temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"  ");
        }
    }
}

3.二分查找

1.前提:数组中的数据必须是升序的

2.查询思想:

  a.老式查询:遍历数组,一个一个比较

  b.二分查询:每次找中间索引对应的元素进行比较查询,每次查找,干掉数组的一半

public class Demo03BinarySearch {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        //定义最大索引和最小索引以及要查找的元素
        int min = 0;
        int max = arr.length - 1;
        int key = 5;
        //如果min<=max就找
        while(min <= max){
            //算中间索引
            int mid = (min + max) / 2;
            if(key > arr[mid]){
                min = mid + 1;
            }else if (key < arr[mid]){
                max = mid - 1;
            }else{
                System.out.println("找到了，索引是：" + mid);
                break;
            }
        }
    }
}