数组的定义与使用
目录
数组的定义与使用.jpg
1.数组的基本概念
1.1 数组的定义
所谓的数组指的就是一组存储具有相同类型的变量集合，并且这些变量可以按照统一的方式进行操作。
数组本身属于引用数据类型，那么既然是引用数据类型，这里面实际上又会牵扯到内存分配，而 数组的定义语法 有如下两类：
- 数组静态初始化:(后面介绍)
- 数组动态初始化:
- 声明并开辟数组：
数组类型 [ ] 数组名称 = new 数组类型[长度]；
数组类型 数组名称 [ ]= new 数组类型[长度]；- 分布进行数组空间开辟(实例化)：
先，声明数组：
数据类型 [ ] 数组名称 = null;
数据类型 数组名称 [ ] = null;
然后，开辟数组空间:
数组名称 = new 数据类型[长度];
1.2 数组的操作
那么数组开辟空间之后，就可以采取如下方式进行操作：
- 数组的访问通过索引完成，即: "数组名称[ 索引 ]" ，但是需要注意的是，索引从 0 开始，所以可以使用的 索引范围就是 0 ~ 数组长度-1 。如果此时数组访问的时候超过了数组的索引范围，则会产生 “ArrayIndexOutOfBoundsException” 这样的异常信息。
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4
at Test.main(Test.java:8)
- 当数组采用动态初始化开辟空间之后，数组里面的每一个元素都是该数组对应数据类型的默认值；
- 数组本身是一个有序的集合操作，所以对于数组的内容操作往往会采用循环的模式完成。(使用for循环)
- 在java中提供有一种动态取得数组长度的方式：数组名称 . length
范例 1： 定义一个int型数组
public class Test{
public static void main(String[] args){
int [] data = new int[3];
data[0]=10;
data[1]=20;
data[2]=30;
for(int x=0;x<data.length;x++){
System.out.println(data[x]);
}
}
}
数组本身除了声明并开辟空间之外还有另外一种开辟模式
范例 2:采用分布模式开辟数组空间
public class Test{
public static void main(String[] args){
int [] data = null;
data = new int[3];
data[0]=10;
data[1]=20;
data[2]=30;
for(int x=0;x<data.length;x++){
System.out.println(data[x]);
}
}
}
但是千万要记住，数组属于引用数据类型，所以在数组在使用之前一定要开辟空间(实例化)，如果使用了没有开辟空间的数组，则一定会出现 NullPointerException 异常信息：
Exception in thread "main" java.lang.NullPointerException
at Test.main(Test.java:6)
错误代码：
public class Test{
public static void main(String[] args){
int [] data = null;
data[0]=10;
data[1]=20;
data[2]=30;
for(int x=0;x<data.length;x++){
System.out.println(data[x]);
}
}
}
这一原则和之前讲解对象操作是完全相同的
2.数组引用传递
既然数组本身也属于引用数据类型，那么也一定可以发生引用传递。
在这之前首先来研究下数组的空间开辟：
范例 1： 观察一道程序
public class Test{
public static void main(String[] args){
int [] data = new data[3];;
System.out.println(data.length);
data[0]=10;
data[1]=20;
data[2]=30;
}
}
内存分析图:
06.png
那么既然说到引用数据类型了，就一定可以发生引用传递，而现在引用传递的本质也一定是:
同一块堆内存的空间可以被不同的栈内存所指向。
范例 2：定义一个程序
public class Test{
public static void main(String[] args){
int [] data = new int[3];
int temp[] = null;
System.out.println(data.length);
data[0]=10;
data[1]=20;
data[2]=30;
// 如果要发生引用传递，不要出现[]
temp = data;
temp[0]=99;
for(int x=0;x<data.length;x++){
System.out.println(data[x]);
}
}
}
内存分析图
07.png
引用传递分析都是同一个套路。(一个堆内存被不同的栈内存所指向，这样一个实现)
3.数组的静态初始化
在之前所进行的数组都有一个明显特点：数组首先先开辟内存空间，而后在使用索引进行内容的设置，实际上这种做法都叫做 动态初始化 ，而如果希望数组在定义的时候可以同时设置内容，那么就可以采用 静态初始化 。
数组静态初始化的语法一共分为以下两种类型：（建议使用第二种）
- 简化格式: 数组类型 数组名称 [ ] ={值，值，值 ...};
- 完整格式 : 数组类型 数组名称 [ ] = new 数组类型 [] {值，值，值 ...};
范例 1： 静态初始化数组。
public class Test{
public static void main(String[] args){
int [] data = {1,2,3,4,8,8,8};
for(int x=0;x<data.length;x++){
System.out.println(data[x]);
}
}
}
在开发之中，对于静态数组的初始化强烈建议使用完整语法格式，这样可以轻松的使用 匿名数组 这一概念。
数组最大的缺陷：长度固定。
4.二维数组(了解一下)
在之前所使用的数组发现只需要一个索引就可以进行访问， 那么这样的数组实际上就像一个数据行的概念。
二维数组：如果要想确定一个数据则数组使用结构就是"数组名称[行索引][列索引]";所以这样一个结构就是一个表结构。
那么对于二维数组的定义有两种声明形式:
- 数组动态初始化:
数组类型 对象数组[][] = new 数据类型[行个数][列个数]；- 数组的静态初始化：
数组类型 对象数组[][] = new 数组类型 [][]{
{值，值，.....}，{值，值，.....}，{值，值，.....}，{值，值，.....}}；
数组的数组就是二维数组。
范例：定义一个二维数组。
如果在进行输出的时候一定要使用双重循环，
外部循环控制输出的行数，内部循环控制输出的列数。
5.数组与方法调用(重点)
数组是一个引用数据类型，那么所有的引用数据类型都可以为其设置多个栈内存指向。所以在进行数组操作的时候也可以将其通过方法进行处理。
范例 1：方法接收数组
public class Test{
public static void main(String[] args){
int [] data = new int []{1,2,3,4,8,8,8};
printArray(data); // int temp[] = data;
}
//定义一个专门进行数组输出的方法
public static void printArray(int temp[]){
for(int x=0;x<temp.length;x++){
System.out.print(temp[x] + ",");
}
}
}
在方法的参数上由于需要接收一个整形数组，所以就实现了一个最为基础的引用传递操作。
范例 2：方法返回数组：
public class Test{
public static void main(String[] args){
int [] data = init(); // 接收数组
printArray(data); // int temp[] = data;
}
// 此时的方法希望可以返回一个数组类型，所以返回值类型定义为整形数组。
public static int[] init(){
return new int [] {1,2,3,4,5};
}
//定义一个专门进行数组输出的方法
public static void printArray(int temp[]){
for(int x=0;x<temp.length;x++){
System.out.print(temp[x] + ",");
}
}
}
那么现在的数组上发生了引用传递，那么也就意味着方法接收数组之后也可以对数组内容进行修改。
范例 3：定义一个方法该方法可以实现数组的内容的乘2
public class Test{
public static void main(String[] args){
int [] data = init(); // 接收数组
inc(data);
printArray(data); // int temp[] = data;
}
public static void inc(int arr[]){
for(int x=0;x<arr.length;x++){
arr[x]*=2;
}
}
// 此时的方法希望可以返回一个数组类型，所以返回值类型定义为整形数组。
public static int[] init(){
return new int [] {1,2,3,4,5};
}
//定义一个专门进行数组输出的方法
public static void printArray(int temp[]){
for(int x=0;x<temp.length;x++){
System.out.print(temp[x] + ",");
}
}
}
内存分析图
08.png
在整个分析的过程之中，引用传递不管它的结构再怎么变化，充其量给我们的也只是引用传递的包装而已，
其本质就是一个堆内存空间被多个栈内存所指向。
6.Java对数组的支持
在Java本身给出的类库之中，也提供有对于数组操作的相关支持方法。
- 数组排序 java.util.Arrays.sort(数组名称);
范例 1：实现数组排序操作
public class Test{
public static void main(String[] args){
int [] data = new int[]{1,2,3,6,4,6,8,9,8,6}; // 接收数组
char arr [] = new char[]{'a','s','c'};
java.util.Arrays.sort(data);
java.util.Arrays.sort(arr);
printArray(data); // int temp[] = data;
printArray(arr);
}
//定义一个专门进行数组输出的方法
public static void printArray(int temp[]){
for(int x=0;x<temp.length;x++){
System.out.print(temp[x] + ",");
}
System.out.println("");
}
public static void printArray(char temp[]){
for(int x=0;x<temp.length;x++){
System.out.print(temp[x] + ",");
}
}
}
只要是基本数据类型的数组，Arrays.sort() 都可以轻松地实现排序处理。
排序默认是升序。
- 数组拷贝：指的是将一个数组的部分内容替换掉另外一个数组的部分内容；
- 方法(加工)： System.arraycopy(源数组名称，源数组开始点，目标数组名称，目标数组开始点，拷贝长度)；
源数组A：1，2， 3， 4， 5， 6， 7， 8， 9
源数组B：11， 22， 33， 44， 55， 66， 77， 88， 99
替换后的 A: 1，55， 66， 77， 5， 6， 7， 8， 9
范例 2：实现数组拷贝：
public class Test{
public static void main(String[] args){
int [] dataA = new int[]{1,2,3,4,5,6,7,8,9}; // 接收数组
int dataB [] = new int[]{11,22,33,44,55,66,77,88,99};
System.arraycopy(dataB,4,dataA,1,3);
printArray(dataA); // int temp[] = data;
}
//定义一个专门进行数组输出的方法
public static void printArray(int temp[]){
for(int x=0;x<temp.length;x++){
System.out.print(temp[x] + ",");
}
System.out.println("");
}
}
这些基本的数组操作只能作为逻辑玩玩，开发用不上。
笔试里面专门考数组？？？
