Java中数组的定义和使用

一、数组的基本概念

1.什么是数组

数组：可以看成是相同类型元素的一个集合。
如图：

1. 数组中存放的元素其类型相同
2. 数组的空间是连在一起的
3. 每个空间有自己的编号，其实际位置的编号为0，即数组的下标。

2.数组的创建及初始化

(1)数组的创建

type [ ] 数组名 = new type [N]

type：表示数组名。
type [ ]: 表示数组的类型。
N ：表示数组的长度。

int [] arry1 = new int [10];	//创建一个可以容纳10个int元素的数组
double [] arry2 = new int [5];	//创建一个可以容纳5个double元素的数组
String [] arry3 = new int [3];	//创建一个可以容纳3个字符串类型的数组

(2)数组的初始化

数组的初始化：分为动态初始化和静态初始化。

1.动态初始化：在创建数组时直接指定元素个数。

int arry [] = new int [10];

        int[] array1 = new int[3];
        array1[0] = 10;
        array1[1] = 20;

2.静态初始化：在创建数组时不直接指定元素个数，根据需要进行指定。
语法格式：

type [] 数组名称 = {data1, data2, data3, …, datan};

int[] array1 = new int[]{0,1,2,3,4,5,6,7,8,9};
double[] array2 = new double[]{1.0, 2.0, 3.0, 4.0, 5.0};

注：
1.静态初始化时可以简写，省略后面的 new type [ ];
2.若未对数组中元素初始化，元素数组中元素会有其默认值，如下表。

(3)数组的使用

1.数组元素的访问：
数组在内存中是一段连续的空间，空间的编号都是从0开始的，依次递增，该编号称为数组的下标，数组可以通过下标访问其任意位置的元素。

   public static void main(String[] args) {
        int arr[] = new int[]{1, 2, 3, 4};
        System.out.println(arr[0]);
        System.out.println(arr[3]);
    }

注：访问时不可超出数组范围，即数组越界。

    public static void main(String[] args) {
        int arr[] = new int[]{1, 2, 3, 4};
        System.out.println(arr[4]);

2. 数组的遍历：
遍历：即将所有数组中的数进行依次打印访问一遍，进行相关操作。
此操作很简单，代码如下：

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

注：对于元素数量较大的数组可以使用 数组对象.length 来获取数组的长度。如上述代码中可有
arr.length 来替换数字 3。

二、数组是引用类型

1.基本类型变量和引用类型变量的区别

基本类型变量：该变量在空间中直接存放 数据 / 数值。
引用类型变量：一般称为对象的引用，存放的是对象所在的空间地址。

public static void func() { 
int a = 10; 
int b = 20; 
int[] arr = new int[]{1,2,3}; 
}

不难由上图看出，引用变量并不存储数据本身，存储的是对象在堆中元素的起始地址。通过该地址，引用变量可以去操作对象

对数组的运用，代码如下：

    public static void main(String[] args) {
        int[] array2 = new int[]{1,2,3,4,5};
        array2[0] = 100;
        array2[1] = 200;
        
        int[] array1 = new int[3];
        array1[0] = 10;
        array1[1] = 20;
        array1[2] = 30; 
        
        array1 = array2;
        array1[2] = 300;
        array1[3] = 400; 
        array2[4] = 500; 
        for (int i = 0; i < array2.length; i++) { 
            System.out.println(array2[i]); 
        }
    }

如图所示，在代码进行到 array1 = array2 前两个数组在内存中的情况如图。

同样，在 array1 = array2 时，将 array2 的地址赋值给 array1，由此之后所修改的时 array2 所指向的堆中的内容。答案如下：

三、数组的简单运用

1.数组传递字符串

Java 中提供了 java.util.Arrays 包, 其中包含了一些操作数组的常用方法.

String 新数组名 = Arrays.toString(旧数组名)；

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        int arr [] = {1,2,3,4,5,6};
        String newarr = Arrays.toString(arr);
        System.out.println(newarr);
    }
}

这种方法主要是方便之后的打印。

2.数组拷贝

新数组名 = Array.copyOf (旧数组名 ，旧数组长度)

    public static void main(String[] args) {
        int arr1[] = {1,2,3,4};
        int arr2[] = {0};
        arr2 = Arrays.copyOf(arr1,arr1.length);
        arr1[0] = 10;
        System.out.println("arr1 "+ Arrays.toString(arr1));
        System.out.println("arr2 "+ Arrays.toString(arr2));
    }

注：这里对 arr1[0] 中的元素进行修改但发现 arr2[0] 未改变，说明这里为arr2申请开辟了新的空间，并不是将 arr1 的地址传递给 arr2.

同样这也可以拷贝需要的一段长度
新数组名 = Arrays.copyOfRange(旧数组名, 2, 4（范围）);
注：[ min,max) 这样的区间。

    public static void main(String[] args) {
        int arr1[] = {1,2,3,4};
        int arr2[] = {0};
        arr2 = Arrays.copyOfRange(arr1, 0, 3);
        System.out.println("arr2 "+ Arrays.toString(arr2));
    }

3.求数组中元素的平均值

   public static void main(String[] args) {
        int arr1[] = {1,2,3,4,5,6};
        System.out.println(avg(arr1));
    }
    public static double avg(int arr[]){
        int i = 0;
        int sum = 0;
        for(i = 0;i < arr.length;i++){
            sum+=arr[i];
        }
        return (double)sum/(double)arr.length;
    }

4.数组的查找

(1)顺序查找

    public static void main(String[] args) {
        //顺序查找
        int arr[] = {1,2,3,15,2};
        System.out.println(find(arr,15));
    }
    public static int find(int arr[],int a){
        int i = 0;
        for(i = 0;i < arr.length;i++){
            if(arr[i] == a){
                return arr[i];
            }
        }
        return -1;  //没有找到
    }

(2)二分查找

二分查找只能对有序的数组进行相应查找，即，从大到小或从小到大排列好的数字。
二分查找基本思路（以升序为例）：
1.先取中间元素与要查找数据对比。
2.若是相等，返回该数字在数组中的下标。
3.若是小于，以1，2方法在左侧区域寻找。
4.若是大于，以1，2方法在右侧区域寻找。
代码实现如下：

    public static void main(String[] args) {
        int arr[] = {1,2,3,4,5,6};
        System.out.println(binarySearch(arr,6));
    }
    public static int binarySearch(int arry[],int need){
        //先定义一个左右变量控制查找区域
        int left = 0;
        int right = arry.length-1;  //对应数组下标
        while(left <= right){
            int mid = (left + right)/2;
            if(need < arry[mid]){
                right = mid-1;
            }
            if(need > arry[mid]){
                left = mid + 1;
            }
            else{
                return mid;     //找到了
            }
        }
        return -1;  //表示没找到
    }

5.冒泡排序

给定一个数组要进行升序（降序）排列。
基本思路（假设为升序）：
1.将数组中的元素前后依次比较，若前一个比后一个大，则交换。
2.多次进行上述操作，直到顺序排好。
代码如下：

   public static void main(String[] args) {
        //冒泡排序
        int arr[] = {1,4,12,2,33,23};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void bubbleSort(int arry[]){
        int i = 0;
        int j = 0;
        int tmp = 0;
        for(j = 0;j <arry.length;j++) {
            //控制循环次数
            for (i = 1; i < arry.length - j; i++) {
                //随着循环次数的增加，每次需要排序的数字也在减少
                if (arry[i - 1] > arry[i]) {
                    tmp = arry[i];
                    arry[i] = arry[i - 1];
                    arry[i - 1] = tmp;
                }
            }
        }
    }

6.数组逆序

基本思路：
1.设定两个下标分别指向第一和最后两个元素。
2.两个数子交换后，第一个++，最后一个- -。
代码如下：

    public static void main(String[] args) {
        //逆序输出
        int arr[] = {1,2,3,4,5};
        reverse(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void reverse(int arry[]){
        int left = 0;
        int right = arry.length-1;
        int tmp = 0;
        while(left <= right){
            tmp = arry[left];
            arry[left] = arry[right];
            arry[right] = tmp;
            left++;
            right--;
        }
    }