目录
1. 数组的基本概念
1.1 数组的定义
1.2 数组的创建及初始化
1.3 数组的使用
2. 数组是引用类型
2.1 数组在JVM中的分布
2.2 基本类型变量与引用类型变量
3. 数组的应用场景
3.1 保存数据
3.2 作为函数的参数
3.3 作为函数的返回值
4. 数组的相关练习
4.1 数组转字符串
4.2 数组拷贝
4.3 求数组中元素是平均值
4.4 查找数组中指定元素（顺序查找）
4.5 查找数组中指定元素（二分查找）
4.6 数组排序（冒泡排序）
4.7 逆序数组
5. 二维数组
1. 数组的基本概念
1.1 数组的定义
数组：可以看成是相同类型元素的一个集合。在内存中是一段连续的空间
1.2 数组的创建及初始化
int[] array1 = new int[10]; // 创建一个可以容纳10个int类型元素的数组
double[] array2 = new double[5]; // 创建一个可以容纳5个double类型元素的数组
String[] array3 = new double[3]; // 创建一个可以容纳3个字符串元素的数组数组的创建第一种为最常用类型。
数组的初始化分为动态初始化和静态初始化
动态初始化：在创建数组时，直接指定数组中元素的个数
例如：
int[] array = new int[10];静态初始化：在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定
例如：
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};
String[] array3 = new String[]{"hell", "Java", "!!!"};1.3 数组的使用
数组中元素的访问：数组在内存中是一段连续的空间，空间的编号都是从0开始的，依次递增，该编号称为数组的下标，数组可以通过 下标访问其任意位置的元素
int[]array = new int[]{10, 20, 30, 40, 50};
System.out.println(array[0]);//输出结果为10遍历数组
int[] array = new int[]{10, 20, 30, 40, 50};
for(int i = 0; i < 5; i++){
System.out.println(array[i])；
}获取数组长度：在数组中可以通过 数组对象.length 来获取数组的长度，也可以使用 for-each 遍历数组
int[] array = {1, 2, 3};//for each遍历数组
for (int x : array) {
System.out.println(x);
}2. 数组是引用类型
2.1 数组在JVM中的分布
JVM主要有本地方法栈，方法区，堆，虚拟机栈，程序计数器等。数组名称存储在栈中，变量存储在堆中
2.2 基本类型变量与引用类型变量
基本数据类型创建的变量，称为基本变量，该变量空间中直接存放的是其所对应的值；
引用数据类型创建的变量，一般称为对象的引用，其空间中存储的是对象所在空间的地址。
public static void func() {
int a = 10;
int b = 20;
int[] arr = new int[]{1,2,3};
}在上述代码中，a、b、arr，都是函数内部的变量，因此其空间都在main方法对应的栈帧中分配。
a、b是内置类型的变量，因此其空间中保存的就是给该变量初始化的值。
array是数组类型的引用变量，其内部保存的内容可以简单理解成是数组在堆空间中的首地址。
3. 数组的应用场景
3.1 保存数据
public static void main(String[] args) {
int[] array = {1, 2, 3};
for(int i = 0; i < array.length; ++i){
System.out.println(array[i] + " ");
}
}3.2 作为函数的参数
传基本数据类型
public static void main(String[] args) {
int num = 0;
func(num);
System.out.println("num = " + num);
}
public static void func(int x) {
x = 10;
System.out.println("x = " + x);
}
// 执行结果
x = 10
num = 0；
}传引用数据类型：发现在func方法内部修改数组的内容, 方法外部的数组内容也发生改变. 因为数组是引用类型，按照引用类型来进行传递，是可以修改其中存放的内容的。
public static void main(String[] args) {
int[] arr = {1, 2, 3};
func(arr);
System.out.println("arr[0] = " + arr[0]);
}
public static void func(int[] a) {
a[0] = 10;
System.out.println("a[0] = " + a[0]);
}
// 执行结果
a[0] = 10；
arr[0] = 10；
}总结: 所谓的 "引用" 本质上只是存了一个地址. Java 将数组设定成引用类型, 这样的话后续进行数组参数传参, 其实 只是将数组的地址传入到函数形参中。这样可以避免对整个数组的拷贝(数组可能比较长, 那么拷贝开销就会很大).
3.3 作为函数的返回值
//斐波那契数列
public class TestArray {
public static int[] fib(int n){
if(n <= 0){
return null;
}
int[] array = new int[n];
array[0] = array[1] = 1;
for(int i = 2; i < n; ++i){
array[i] = array[i-1] + array[i-2];
}
return array;
}
public static void main(String[] args) {
int[] array = fib(10);
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}4. 数组的相关练习
4.1 数组转字符串
import java.util.Arrays
int[] arr = {1,2,3,4,5,6};
String newArr = Arrays.toString(arr);
System.out.println(newArr)；
// 执行结果
[1, 2, 3, 4, 5, 6]4.2 数组拷贝
public static void main(String[] args) {
int[] array={1,2,3};
//接收拷贝的数组
int[] ret=copy(array);
//打印被接收的数组
System.out.println(Arrays.toString(ret));
System.out.println("=====分割线========");
//数组拷贝的第一个方法
//对数组进行扩容，直接*2
int[] ret1=Arrays.copyOf(array,array.length*2);
System.out.println(Arrays.toString(ret1));
//数组拷贝的第二个方法
//直接拷贝数组的下标，从1下标到3下标，[1,3)左闭右开的区间
int[] ret2=Arrays.copyOfRange(array,1,3);
System.out.println(Arrays.toString(array));
}
//数组的拷贝
//返回int型数组
public static int[] copy(int[] array){
//为数组提前申请空间
int[] copyArray=new int[array.length];
for(int i=0;i<array.length;i++){
copyArray[i]=array[i];
}
return copyArray;
}4.3 求数组中元素是平均值
public static void main(String[] args) {
int[] array = {1,2,3,4,5,6};
System.out.println(avg(array));
}
public static double avg(int[] array) {
int sum = 0;
//for each语句
for (int x : array) {
sum += x;
}
return (double)sum / (double)array.length;
}
// 结果
3.54.4 查找数组中指定元素（顺序查找）
public static void main(String[] args) {
int[] array = {1,3,5,7,9};
//在上面数组中找到5
System.out.println(find(array, 5));
}
public static int find(int[] array, int data) {
for (int i = 0; i < array.length; i++) {
if (array[i] == data) {
return i;
}
}
return -1; // 表示没有找到
}4.5 查找数组中指定元素（二分查找）
二分查找仅适用于有序数组
public static void main(String[] args) {
//给定一个数组
int[] array = {1,2,3,4,5,6};
System.out.println(find(array, 6));
}
public static int find(int[] array, int toFind) {
int left = 0;
int right = array.length - 1;
while (left <= right) {
int mid = (left + right) / 2;
if (toFind < arr[mid]) {
// 去左侧区间找
right = mid - 1;
} else if (toFind > arr[mid]) {
// 去右侧区间找
left = mid + 1;
} else {
// 相等, 说明找到了
return mid;
}
}
// 循环结束, 说明没找到
return -1;
}4.6 数组排序（冒泡排序）
冒泡排序就是两个相邻的元素依次比较，将大的替换到数组后面，直到所有的元素都排列好
public static void main(String[] args) {
int[] array = {1, 3, 2, 4};
compare(array);
System.out.println(Arrays.toString(arr));
}
public static void compare(int[] arr) {
for (int i = 0; i < arr.length; i++) {
for (int j = 1; j < arr.length-i; j++) {
if (arr[j-1] > arr[j]) {
int tmp = arr[j - 1];
arr[j - 1] = arr[j];
arr[j] = tmp;
}
}
} // end for
} // end compare
// 执行结果
[1,2,3,4]相比于冒泡排序java 中内置了更高效的排序算法
public static void main(String[] args) {
int[] array = {1，3，2，4};
Arrays.sort(array);
System.out.println(Arrays.toString(array));
}4.7 逆序数组
方法：设定两个下标, 分别指向第一个元素和最后一个元素. 交换两个位置的元素，然后让前一个下标自增, 后一个下标自减, 循环继续即可
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4};
reverse(arr);
System.out.println(Arrays.toString(arr));
}
public static void reverse(int[] arr) {
int left = 0;
int right = arr.length - 1;
while (left < right) {
int tmp = arr[left];
arr[left] = arr[right];
arr[right] = tmp;
left++;
right--;
}
}5. 二维数组
格式：数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };
例如：
int[][] arr = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
