Java 数组

文章目录     一、基本概念     二、如何定义数组         1、声明         2、赋值     三、数组的遍历         1、for循环         2、foreach 循环     四、数组的内理         1、栈 (stack)         2、堆(heap)     五、数组排序         1、选择排序         2、冒泡排序     六、查找数组中的元素         1、普通查找         2、折半查找         3、折半查找的加深理解     七、二维数组         1、初始化              八、数据的常见操作         1、排序：Arrays.sort()           2、数组转字符串:Arrays.toString()         3、查找数组中的元素:binarySearch(int[] a, int key)         4、比较两数组是否相等 : equals(int[] a, int[] a2)        九、动态数组        1、ArrayList的使用     十、一些例子        1、定义一个int类型数组，并赋值，输出数组的最大值和最小值、平均值   

一、基本概念

1、概念 : 同一类型数据的集合
2、特点：有序性、可重复
3、数组属于Java数据类型中的 引用数据类型

二、如何定义数组

1、声明 格式

格式一：数据类型 [] 数组名 = new 数据类型[数组个数]

例如 : int [] arrays = new int[2];

格式二 ： 数据类型 数组名[] = new 数据类型[数据个数]

例如 : int arrays  [] = new int[2];

2、赋值

arrays[0] = 12;arrays[1] = 13;

注意 :
1 ) 数组的个数 可以通过 arrays.length 来获取
2 ) 数组的下标从0开始，取值区间在[0,arrays.length)
3 ) 声明确定数组个数多少后，赋值的时候，不允许超过角标范围。否则会数组越界(ArrayIndexOutOfBoundsException)。
4 ) 数组名 和 [] 位置可互 ，一般 [] 在数组名 前面

3、Java提供 声明、分配空间、赋值一次性完成的API

格式一 : 数据类型[] 数组名 = {};

例如: int[] arrays = [1,5,7];

格式二 ： 数据类型[] 数据名 = new 数据类型[]{};

int [] arrays  = new int[]{1,4,5};

三、数组的遍历

1、 for循环

int [] arrays  = new int[]{1,4,5};for(int i = 0;i < arrays.length;i++){    System.out.println(arrays[i]);}

2、 foreach 快速循环

int [] arrays  = new int[]{1,4,5};for(int value : arrays){   System.out.println(value);}

四、数组的内存管理

数据是一种引用数据类型，数据引用变量只是一个引用，数组元素和数组变量在内存里是分开存放的。

Java 程序在运行时，需要在内存中分配空间，为了提高运算效率，有对空间进行了不同区域的划分，因为每一块区域都有特定的处理数据方式和内存管理方式。共分为5块 : 栈内存、堆内存、方法区(共享区/数据区)、本地方法区、寄存区。

1、栈内存 ： 用于存储局部变量，当数据使用完，所占的空间会自动释放。

例如 ： 定义在方法内部的局部变量就是存放于栈内存

2、堆内存 ： 数组和对象，通过new 建立的实例都存放在堆内存中。
1) 每一个实体都有内存地址
2) 实体中的变量都有默认初始值
3) 实体不在被使用，会在不确定的时间内被垃圾回收器回收。

举个例子 : int[] arrays = new int[3]

3、方法区： 里面有静态和非静态。 存放 类的行为。

1） x 存放于栈区，int[3] 实体存放于堆区，开辟一块区间，并将该区间划分为3块子区间，其中，第一块子区间的地址作为整个实体在堆内存中的地址，x 即存放 这个实体的地址。

2 ） 我们直接方法 x[0] =0 , 即解释实体中的变量都是有默认值。如果是boolean数组，默认值为flase，float 默认值为0.0f, double 默认值为 0.0;

3) 当 我们 将 x = null; 实体在堆内存中没有任何引用所使用它的时候，我们就称它为垃圾。他不会立刻在内存中被清除掉，而是在不确定的时间启动”垃圾回收机制”将这个实体在内存中清除。

备注 ： null 是一种特殊类型，他只有一个值: null, 这个直接量 只能 赋值给 引用数据类型，用于表示这个引用类型变量中保存的地址为空，即未指向任何有效对象(实体)。

例如 :

int[] x  = new int [3];int [] y = x;y[1] = 89;  // 此时 x[1] = 89;x= null; // int[3]  肯定还未被释放 ,因为 int[] y 还在引用它

3、共享区(数据区/方法区间)
static修饰的变量放于该区，生命周期比较长

五、数组的常见排序操作(这里只介绍选择排序和冒泡排序)

1、 选择排序 : 每一趟从待排序的数据元素中选出最 ( 大/小 ) 值的一个元素，顺序放在已排好序的数列的最后或最前，直到全部待排序的数据元素排完。如下图

    //选择排序 :每循环一次 最值依次从后往前排序    public static void selectSort(int[] arr){        for(int i = 0; i < arr.length-1;i++){            for(int j = i+1;j < arr.length;j++){                // 交换顺序                if(arr[i]>arr[j]){                    int temp = arr[i];                    arr[i] = arr[j];                    arr[j] = temp;                }            }        }    }

备注 ：
1、上面的两种实现方式皆为升序，如果是降序的话，把>改成<即可。
2、比较次数构成等差数列 即 n*(n-1) /2 (其中，n为数组元素个数)

2、冒泡排序 ： 它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。如下图：

    public static void bubbleSort(int[] arr){        // 最后一次元素比较没有相邻，所以减1        for(int x= 0; x < arr.length-1;x++){            //-x : 让每一次的元素减少  -1: 避免角标越界            for(int y = 0 ;y < arr.length-x-1;y++){                if(arr[y] > arr[y+1]){                    int temp = arr[y];                    arr[y] = arr[y+1];                    arr[y+1] = temp;                }            }        }    }

六、查找数据中的元素

1、普通查找 : 顺序查找，如果找到，返回下标值，如果没找到，返回-1。

    public static int searchIndex(int[]arr,int key){        for(int i = 0;i<arr.length;i++){            //如果找到，返回下标值            if(key == arr[i])                return i;        }        return -1;    }

2.、折半查找 ： 取 中间值与之进行比较，不相等不断缩小范围。如果没找到，返回-1。折半查找的前提是: 数组有序。

public static int getIndex(int[] arr,int key){        int min = 0;        int max = arr.length-1;        int mid;        //如果存在距离，则可 进行查找      while(min <= max){          //寻找中间角标          mid = (min + max)/2;          if(key > arr[mid])              min= mid +1;          else if(key < arr[mid])              max = mid -1;          else              return mid;      }       return -1;       }

3、折半查找的加身理解 :

如果 给定一个有序数组，现在需要往有序数组插入一个元素，要求是插入后这个数组继续有序。

思路 ： 往数组中插入，那么插入的这个数必然是 介于 两值的中间。其实就是二分法查找方法中的min 。

七、二维数组

我们都知道 初始化数组的时候，我们只需要制定数组的长度即可，系统将负责为这些数据元素分配初始值。具体如下:
1) 数组元素的类型是整数类型(int、short、long、byte), 则数组元素的值为 0；
2）数组元素的类型是浮点类型(float、double),则数组元素的值是0.0;
3) 数组元素的类型是字符类型(char)，则数组元素的值为’\u0000’;
4) 数组元素的类型是布尔类型(blloean),则数组元素的值是flase
5) 数组元素的类型是引用数据类型(类、接口、数组)，则数组元素的初始值是null

1、实质： 数组里面包含数组。

2、声明格式：
数据类型 [][] 数组名 = new 数据类型[][]{};
数据类型[][] 数组名 = {{},{},…}

备注 : 数组初始化指定长度即可，也就是说第二个[] 可以不写长度，但是第一个[] 不可以。数组名可放于[][]中间，或者后面。

int[][] arrays  = new int[2][3];a[0] = {4,7,9};a[1] = {12,56,78};

.
.

* 八、数据的常见操作*

下面涉及的方法，都是Arrays.方法名(参数列表)。在使用他们的时候都需要导入 import java.util.Arrays;

1、排序：Arrays.sort()

int[] sortArrays = {78,56,12,45,94};Arrays.sort(sortArrays);System.out.println("排序后数组的值");for(int num : sortArrays){ System.out.println(num);}// 输出结果 : (默认升序)排序后数组的值1245567894

.
.

2、数组转字符串:Arrays.toString()

System.out.println("输出数组中的元素"+Arrays.toString(sortArrays))//输出结果 ：输出数组中的元素[12, 45, 56, 78, 94]// 注意 : 如果我直接指定下面语句，请问结果是什么？System.out.println(sortArrays)//输出结果如下 :[I@15db9742@ 是分割符 ，[ 代表是数组，I代表数组元素类型是整数类型。

.
.
3、查找数组中的元素:binarySearch(int[] a, int key) 。如果存在，返回所在下标值，如果不存在，返回-1

System.out.println(Arrays.binarySearch(sortArrays, 56));//输出结果 ： 2

.
.
4、比较两数组是否相等 : equals(int[] a, int[] a2) 。当且仅当，数组中每一个值都对应相等，返回true，否则，返回flase

System.out.println(Arrays.equals(sortArrays,sortArrays));//输出结果 ： true

..

九、动态数组

十、一些例子
1、定义一个int类型数组，并赋值，输出数组的最大值和最小值、平均值

System.out.println("定义一个int类型数组，并赋值，输出数组的最大值和最小值、平均值:");int[] numbers = new int[]{34,78,65,37,89,32};int max = numbers[0];int min = numbers[0];double sum = 0;  double average = 0;for(int i = 0 ; i < numbers.length;i++){int currentValue = numbers[i];if(currentValue > max){max = currentValue;}if(currentValue < min){min = currentValue;}sum += numbers[i];}average = sum/numbers.length;System.out.println("最大值是:"+max);System.out.println("最小值是:"+min);System.out.println("平均值是:"+average);

输出结果 ；

最大值是:89最小值是:32平均值是:55.833333333333336

数组练习demo