JAVA引用类型（1）——数组

数组是一种容器，可以同时存放多个相同数据类型的数据
数组是一种引用类型，其长度在程序运行期间不可以改变

1. 初始化
   动态初始化（指定长度）：
   格式： 数据类型[] 数组名称 =new 数据类型[数据长度]；
   左右俩侧数据类型必须相同。

   int[] str = new int[10];
   short[] str2 = new short[200];
   String[] str3 = new String[20];
   

   静态初始化（指定内容）
   静态初始化的长度由初始化的数据个数决定。
   基本格式：数据类型[] 数组名称 =new 数据类型[]{元素1，元素2…}；

   int[] array =new int[]{
          1,2,3,};
   String[] array2 = new String[]{
          "hello","world","linxu"};
   

   缺省格式：数据类型[] 数组名称 ={元素1，元素2…}；

   int[] array = {
          1,2,3};
   String[] array2 = {
          "hello","world","linxu"};
   

   拆分格式：数据类型[] 数组名称； 数组名称=new 数据类型[]{元素1，元素2…}；
   静态初始化的省略格式不能拆分写。

   String[] array2;
   array2= new String[]{
          "hello","world","linxu"};
   

2. 数组调用和赋值

   String[] array2 = new String[]{
          "hello","world","linxu"};//静态初始化
   //静态初始化也有默认值，但系统会自动地马上将元素值替换为大括号的值
   System.out.println(array2);//直接打印数组名，得到的是数组对应内存地址的哈希值
   System.out.println(array2[0]);//索引值一定是int类型，且索引值从0开始到‘数组长度-1’;打印出的是hello
   String str1=array2[2];//此时str1被赋值为linux；
   String[] str2=array2;//新数组指向array2数组的地址。
   System.out.println(str1);//打印结果为linux；
   
   String[] array2 = new String[20];//动态初始化,初始化为null
   int[] array3 = new int[20];//动态初始化，初始化为0
   
   array2 = "java";//为数组元素赋值
   array3 = 46;
   /*动态初始化初始值：（内存的划分见本文第10）
     整型  ————默认‘0’
   浮点类型————默认‘0.0’
   char类型————默认‘\u0000’
   布尔类型————默认‘false’
   引用类型————默认null;
   */
   

3. 数组错误现象
   数组索引越界：索引值写错，超出数组长度范围
   空指针异常：数组必须new初始化，仅赋值为null，会发生空指针异常
4. 单个数组的内存图
   
5. 俩个数组的内存图
   
6. 两个引用指向同一数组
   
7. 数组相关操作：
   获取数组长度：
   格式：数组名.length;int len=array2.length;
   数组长度在程序运行期间不可改变。如图所示，发生改变的是数组名指向的数组地址，而非new出来的数组，即数组本身没有改变。数组名只是一个引用，而非数组本身。
   
   数组作为方法参数
   数组作为方法参数，只是传递进去了数组的地址，在方法中使用数组和在平时相同
   例如：

   piublic static void demo(int[] array){
          
         for (int i = 0; i < array.length; i++) {
          
               System.out.println(array[i]);
           }
   } 
   

数组作为方法返回值
可以同时返回多个数据结果,返回值仍然是堆数组的内存地址值。

piublic static int[] demo(int a,int b,int c){
     
      int sum=a+b+c;
      int avg=sum/3;
      int[] array={
     sum,avg};
      return array;
} 

8. 实例：数组元素反转

package linxu.day01;

public class array {
     
    public static void main(String[] args) {
     
        int[] array = new int[]{
     10, 20, 30, 40, 50};
        for (int i = 0; i < array.length; i++) {
     
            System.out.println(array[i]);
        }
        System.out.println("---------");
        for (int min = 0, max = array.length - 1; min < max; min++, max--) {
     
            int temp = array[min];
            array[min] = array[max];
            array[max] = temp;
        }
        for (int i = 0; i < array.length; i++) {
     
            System.out.println(array[i]);
        }
    }
}

8. 特点：
   查询块，增删慢
   因为普通数组一旦创建，大小不可变，所以这里说的的集合的Arraylist数组，
   int[] arr=new int[]{1,2,3,4};再执行删操作时，会把除对应索引之外的其他元素复制到新数组，然后把新数组赋值给变量arr，而原数组会在内存销毁
   同理，增操作也是如此，增加一个元素也同样会把其他元素复制到新数组，然后添加一个新元素，载将新数组赋值给变量arr，而原数组会在内存销毁
   在堆内存会频繁的复制、销毁数组，效率低