Java基础（五）★数组

数组

存储一组同一个类型数据的容器---数组
数组对每一个存入的数字都会自动编号，编号是从0开始的---下标

定义格式：

数据类型[] 数组名 = new 数据类型[表示数组能存放的元素个数];---适用于一些知道元素个数而不知道具体元素的场景
int[] arr = new int[5]; --- 表示定义了一个能存储5个int类型的数据的数组
Java中对数组中的元素进行了自动的编号。---编号是从0开始的。---下标
注意：数组一旦定义好，大小不可变arr[1] =  5;
int i = arr[1];

int i = 5;

int i; //声明
i = 5; //初始化---在程序中第一次给变量赋值

int[] arr;
arr = new int[5];---可以先声明再初始化

arr[2] = 15;
System.out.println(arr[2]);

数据类型[] 数组名 = new 数据类型[]{元素1， 元素2，……，元素n};---同时也就规定了数组的大小就是元素的个数
int[] arr = new int[]{3,5,1,2,5};arr[3] = 10;---在定义好之后，数组的初始元素已经一一赋值，数组的大小已经固定。可以先声明再初始化吗？---可以
数据类型[] 数组名 = {元素1， 元素2，……，元素n};
int[] arr = {2,6,4,7,9};//在创建的时候动态的获取数组大小，然后才能分配内存空间

int[] arr;
arr = {1,5,3,7,4};---不可以---现在不知道数组的大小

内存

Java将内存分为了五块：栈内存，堆内存，方法区，本地方法栈，寄存器

栈内存

变量是存储在栈内存中的。
存储变量，执行代码块的。变量存储在栈内存中不会自动赋予初始值，变量使用完成之后立即移除出栈内存，释放空间

堆内存

存储的是对象。对象在堆内存中会自动的赋予一个默认值。
---初始值：byte/short/int---0, long---0L
float---0.0f, double---0.0, char---‘\u0000’, boolean---false, 所有的引用类型的默认值全部都是null

对象在使用完成之后，不会立即移除，而是在不定的某个时刻被回收。

 


----------------------------------------------------------------------------



----------------------------------------------------------------------------



----------------------------------------------------------------------------



----------------------------------------------------------------------------


 
----------------------------------------------------------------------------
ArrayIndexOutOfBoundsException---数组下标越界异常---编译没有问题---说明明语法没有问题---逻辑上或者事实上不符合--运行出错
NullPointorException---空指针异常---编译没有问题---对于null而言，不能做任何操作int i = 5;
int j = i;注意：对于基本类型而言，传值传的实际的数据；对于引用类型而言，传值传的是地址。
-----------------------------------------------
ecc3
-----------------------------

数组的应用

1. 获取指定位置上的元素---数组名[下标]
2. 获取数组的长度---数组名.length
3. 遍历数组

A. 普通for循环

for(int i = 0; i < arr.lenth; i++){}

B. 增强for循环

for(int i : arr){  // 表示把数组中的元素依次取出赋值给i
// 无法改变原来的元素了
System.out.println(i);
}

C. String str = Arrays.toString(数组);

4. 获取数组元素的最值。---获取最大值---遍历数组
5. 数组元素排序

冒泡排序:

for(int i = 1 ; i < arr.length ; i++){  //控制轮数
for(int j = 1; j <= arr.length - i; j++){ //控制每轮的次数，以及下标
if(arr[j - 1] > arr[j] ){
int temp = arr[j - 1];
arr[j - 1] = arr[j];
arr[j] = temp;
}
}
}

选择排序:

 


for(int i = 1; i < arr.length ; i++){  //控制轮数和起始下标
for(int j = i - 1; j < arr.length; j++){ //控制次数，后边那一位的下标的变化
if(arr[i - 1] >  arr[j]){
int temp =  arr[i - 1];
arr[i  - 1] = arr[j];
arr[j] = temp;
}
}
}快速排序、希尔排序、堆排序
import java.util.Arrays;
Arrays.sort(数组); //只能升序排列---从小到大

String s = Arrays.toString(arr);---将数组中的元素依次取出拼接成了一个字符串

6. 查找元素的位置
A. 遍历
B. 折半查找---要求数组有序---时间复杂度：O(log2n)
无序数组---for循环
有序数组---折半查找
7. 反转数组---头尾交换

利用新的数组，也可以利用两个变量来同时操作数组的两端
注意：如果访问的下标不存在，会出现ArrayIndexOutOfBoundsException---数组下标越界异常---编译的时候没有报错---因为语法无错。---所以编译检查的是语法问题
8. 数组的扩容---数组的复制
System.arraycopy(要复制的数组，要复制的数组的起始位置，被复制到的数组，新数组中放置的起始位置，要复制的元素的个数);
System.arraycopy(arr,3,arr2,2,5);---从arr下标为3的位置开始复制，复制5个元素到arr2中，从arr2的下标为2的位置开始依次存放
数组 = Arrays.copyOf(要扩容的数组, 扩容之后的大小);---表面上看起来对数组的长度做了改变，实际上数组已经发生了变化，已经是一个新的数组---数组在扩容完成之后，堆内存的地址已经发生了改变Arrays.copyOf(arr,len);
int[] arr2 = new int[len];
if(len < arr.length){
System.arraycopy(arr,0,arr2,0,len);
} else {
System.arraycopy(arr,0,arr2,0,arr.length);
}T[] arr2; //数据类型在Java底层动态获取的
arr2 = new T[长度]; //T---表示泛型
if(长度 >= 数组.length){
System.arraycopy(arr,0,arr2,0,arr.length);
} else {
Sysetem.arraycopy(arr,0,arr2,0,长度);
}
arr = arr2;补充扩展：
1. int i = 1 / 0;---编译没有问题---运行---ArithmeticException---算术异常
在Java中小数允许除以0，结果是Infinity/NaN---Not a Number---NaN和任何值都不相等，即使是本身，也不相等。
2. 尽量减少使用小数作为控制条件----因为小数在计算机中不能够精确存储
3. strictfp---在函数执行过程中，小数是以80位二进制进行存储的，但是函数完成之后，依然使用double类型存储最终的结果---最终的结果依然是64位二进制小数

二维数组

二维数组的每一个元素就是一个一维数组---是一个存放数组的容器---数组的数组

定义格式

数据类型[][] 数组名 = new 数据类型[二维数组的大小/二维数组中包含的一位数组的个数][所包含的一维数组的大小];
int[][] arr = new int[3][5];---表示这是一个包含3个一维数组的二维数组，每个一维数组由5个整数组成
int[] arr2 = arr[0];----获取的是一个一维数组
arr[0][3];---如果获取具体的元素，需要两个下标
数据类型[][] 数组名 = new 数据类型[二维数组的大小/包含的一维数组的个数][];
int[][] arr = new int[3][];---表示这个二维数组由3个整型的一维数组组成
arr[0][0] = 3; ---不可以---因为所包含的一维数组没有初始化
arr[3][0] = 8;---NullPointerException---空指针异常
数据类型[][] 数组名 = {{元素1}，{元素1，元素2} ……};
int[][] arr = {{1},{1,3},{2,4,3}};
arr[0][1] = 5;--不可以





注意：针对null的任何操作都会出现空指针异常
面试题总结：对于数组int[] x,y[]均已初始化，下列选项正确的是：
对于数组int[] x, y[]均已初始化，下面各项正确的是：---BC---int[] y[];
A. y[0] = x[0];
B. y[0] = x;
C. y[0][0] = x[0];
D. y[0][0] = x;
E. y[0] = x[0][0];
注意：[]在变量名之前紧跟的是数据类型，以后定义的每一个变量都会拥有这个[]；如果[]在变量名之后，那么[]只属于当前的变量。

应用：

遍历一个二维数组---需要两个循环
for(int i = 0; i < arr.length; i++){for(int j = 0; j < arr[i].length ; j++){    arr[i][j];}}

杨辉三角

1
1	1
1	2	1
1	3	3	1
1	4	6	4	1
1	5	10	10	5	1
arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];

输入一个数n，输出前n行
//从控制台获取行数
Scanner s = new Scanner(System.in);
int row = s.nextInt();
//根据行数定义好二维数组，由于每一行的元素个数不同，所以不定义每一行的个数
int[][] arr = new int[row][];
//遍历二维数组
for(int i = 0; i < row; i++){
//初始化每一行的这个一维数组
arr[i] = new int[i + 1];
//遍历这个一维数组，添加元素
for(int j = 0; j <= i; j++){
//每一列的开头和结尾元素为1，开头的时候，j=0，结尾的时候，j=i
if(j == 0 || j == i){
arr[i][j] = 1;
} else {//每一个元素是它上一行的元素和斜对角元素之和
arr[i][j] = arr[i -1][j] + arr[i - 1][j - 1];
}
System.out.print(arr[i][j] + "\t");
}
System.out.println();
}