Java一维数组的定义、静态初始化、动态初始化、匿名数组、排序、部分拷贝、全拷贝、数组和方法的操作

1.1 数组的定义

  在Java中，可以用如下格式定义一个数组：数据类型 [] 数组名 = new 数组类型 [数组长度] eg：int [] arr=new int [100]：就相当于在内存中定义了100个int类型的变量，第一个变量的名称为arr[0]…………第100个变量的名称为arr[99],每个变量的默认值均为0；

1.2 数组初始化

1.2.1 数组动态初始化

  数组动态初始化（声明并开辟数组）
数据类型 [] 数组名称 = new 数组类型 [长度] ; eg：int [] data=new int [5] //声明并开辟一个长度为5的整形数组

• 数组的访问通过索引完成。即“数组名称[索引]”，数组索引是从0开始，因此索引的范围就是0~索引-1；如果超出索引访问，就会产生java.long.ArrayIndexOutOfBoundsException（数组下标越界异常）（运行时异常）。
• 当数组采用动态初始化开辟后，数组之中的每个元素都是该数据类型的默认值。
• 数组名.length取得数组长度。
• 数组属于引用数据类型，因此在使用之前一定要开辟空间，否则就会产生java.long.NullPointerException(空指针异常）（运行时异常）
  范例：定义一个整形数组
  
• 数组遍历推荐使用for-each循环

public class Test{
    public static void main(String[] args)
    {
        int [] x=new int [3];
        System.out.println(x.length);
        x[0]=1;
        x[1]=2;
        x[2]=3;
        for(int i:x)
        {
            System.out.print(i+" ");
        }
    }
}

1.2.2 数组静态初始化

  静态初始化即：数组在定义的同时设置内容。语法一共分为以下两种：
   1.简化格式：数据类型 [] 数组名称 ={值，值，……}
   2.完整格式：数据类型 [] 数组名称 =new 数据类型 []{值，值，……}
  在数组定义时直接设置内容，根据值的个数确定数组长度且长度不可修改

在
范例：

public class Test{
    public static void main(String[] args)
    {
        int [] x=new int []{1,2,4,5,6,3,55};
        System.out.println(x.length);
        for(int i:x)
        {
            System.out.print(i+" ");
        }
    }
}

1.3 数组空间的开辟

代码：

public class Test{
    public static void main(String[] args)
    {
        int [] x=new int [3];
        System.out.println(x.length);
        x[0]=10;
        x[1]=20;
        x[2]=30;
        for(int i=0:x)
        {
            System.out.print(i+" ");
        }
    }
}

1.3.1 数组引用传递

  数组作为引用数据类型，也一定能发生引用传递。
  引用传递空间：同一块堆内存空间可以被不同的栈内存所指向

范例：

public class Test{
    public static void main(String[] args)
    {
        int [] x=new int [3];
        int [] tmp=null;
        System.out.println(x.length);
        x[0]=10;
        x[1]=20;
        x[2]=30;
        tmp=x;
        tmp[0]=90;
        for(int i:x)
        {
            System.out.print(i+" ");
        }
    }
}

1.3.1 匿名数组

没有任何栈内存指向的数组（相当于有电视没有遥控器）
没有任何栈内存指向的堆内存空间在使用一次后就会变成垃圾空间，被JVM回收。也就是所有匿名的空间只能用一次

public class Test{
    public static void main(String[] args)
    {
        System.out.println(new int[]{1,3,5,7,9}.length);
    }
}

1.4 数组和方法的操作

1.4.1 方法接受数组

范例：

public class Test{
    public static void main(String[] args)
    {
        int [] data=new int []{1,2,3,4,5};
        printArray(data);
    }
    public static void printArray(int [] data)
    {
        for(int i:data)
        {
            System.out.print(i+" ");
        }
    }
}

1.4.2 方法返回数组

范例：

public class Test{
    public static void main(String[] args)
    {
        int [] data=init();
        printArray(data);
    }
    public static int [] init()
    {
        return new int []{1,2,3,4};
    }
    public static void printArray(int [] data)
    {
        for(int i:data)
        {
            System.out.print(i+" ");
        }
    }
}

1.4.3 方法修改数组

范例：

public class Test{
    public static void main(String[] args)
    {
        int [] data=new int []{1,2,3,4};
        printArrayDouble(data);
    }
    public static  void  printArrayDouble(int []data)
    {
        for(int i=0;i<data.length;i++)
        {
            System.out.print((data[i]*2)+" ");    
        }
    }
    }

1.5 Java对数组的支持

1.5.1 数组排序

  java.util.Arrays.sort(数组名称) //支持所有的数据类型

import java.util.Arrays;
public class Test{
    public static void main(String[] args)
    {
        int [] data=new int[]{3,5,1,4,8,6};
        char [] data2=new char[]{'z','d','e','w','a'};
        Arrays.sort(data);
        Arrays.sort(data2);
        printArray(data);
        System.out.println("");
        printArray(data2);
    }
    public static void printArray(int [] data)
    {
        for(int i:data)
        {
            System.out.print(i+" ");
        }
    }
    public static void printArray(char [] data)
    {
        for(int i:data)
        {
            System.out.print((char)i+" ");
        }
    }
}

1.5.2 数组的部分拷贝

System.arraycopy(源数组名称，源数组开始点，目标数组名称，目标数组开始点，拷贝长度)
  我们发现这个命名不符合驼峰命名方法，其实System.arraycopy是JDK 1.0才有的，那个时候还没有驼峰命名法
  区分源数组和目标数组：
    要求的数组和哪个数组最接近谁就是目标数组

public class Test{
    public static void main(String[] args)
    {
       int [] data1 = new int []{1,2,3,4,5};
       int [] data2 = new int []{11,22,33,44,55};
       //希望最后的数组为1,2,33,44,55离data2最接近，data2为目标数组
       System.arraycopy(data1,0,data2,0,2);
       for(int x:data2)
       {
           System.out.print(x+" ");
       }
    }
}

运行结果： 1 2 33 44 55

1.5.2 数组的全拷贝

  java.util.Arrays.copyOf(源数组名称，新数组的长度) //返回值是个新数组
对于数组引用是指：同一块 堆内存空间 可以被不同的 栈内存 所指向。
对于数组而言，若是想让栈内存指向不同的堆内存但堆中数组相同就可以使用数组全拷贝，此时会返回一个新的数组

import java.util.Arrays;
public class Array{

    //数组全拷贝
    public static void main(String[] args)
    {
        int [] arr=new int[]{2,3,4,5};
        int [] tmp=Arrays.copyOf(arr,arr.length);
        printArray(tmp);
    }
      public static void printArray(int [] data)
    {
        for(int i:data)
        {
            System.out.print(i+" ");
        }
    }
    }

当新数组的长度大于源数组的长度时，后面多余位会是 0

数组全拷贝也可以部分拷贝，只是开始点为0

public class Test{
    public static void main(String[] args)
    {
       int [] data = new int[]{1,2,3,4,5};
       int [] temp = java.util.Arrays.copyOf(data,2);
       for(int x: temp)
       {
           System.out.print(x+" ");
       }
    }
}

运行结果：1 2