java数组的定义与使用_[Java 学习笔记 02] 数组的定义与使用

一、数组的定义与使用

知识点：

1、数组的基本作用与定义语法；

2、二维数组的使用；

3、数组与方法的互操作；

4、与数组有关的类库方法使用；

5、对象数组。

在所有的开发之中，数组是一个非常重要的概念，所有的项目都使用数组，但它使用的数组与本次内容是有出入的，后面会更换数组的使用形式，但是其基本概念不会改变。

1.1 数组的基本概念

数组指的就是一组相关变量的集合。

数组的定义：

声明并开辟数组

数据类型 数组名称 [] = new 数据类型 [长度]；

数据类型 [] 数组名称 = new 数据类型 [长度];

分步完成

声明数组：数据类型 数组名称 [] = null;

开辟数组: 数组名称 = new 数据类型 [长度];

1、当数组开辟空间后，可以采用 "数组名称 [下标]" 的形式进行访问。如果超出数组长度，那么会出现数组越界异常(ArrayIndexOutOfBoundsException)。

2、以上给出的数组定义结构采用的是动态初始化方式，即：数组会首先开辟内存空间，数据内容为其数据类型的默认值。

3、由于数组是一种顺序的结构，并且数组的长度都是固定的，那么可以使用循环的方式输出，很明显 for 循环，而且 java 里为了方便数组的输出提供有一个 “数组名称.length” 的属性，可以取得数组的长度。

for(int i=0; i

System.out.println( data[i]);

}

1.2 内存空间

虽然数组比较简单，但是其麻烦的问题在于，它也属于引用类型，也有内存分配，与对象保存唯一的区别在于：对象中的堆内存保存的是属性内容，数组对象中的堆内存保存的是数组里的内容。

举例：用内存关系来描述下面的关系

int data [] = new data[3];

data[0] = 10;

data[1] = 20;

data[2] = 30;

以上是第一种数组定义的语法，下面更换第二种：

int data [] = null;

data = new data[3];

data[0] = 10;

data[1] =20;

data[2] =30;

1.3 数组的引用传递

既然数组属于引用数据类型，那么数组一定可以发生引用传递。

举例：数组的引用传递

int data [] = new data[3];

data[0] = 10;

data[1] =20;

data[2] =30;

int temp [] = data;

temp[0] =99;

1.4 数组的静态初始化

以上数组的定义格式严格来讲是属于动态初始化，它的操作特点：先开辟数组空间，而后为数组中的内容进行赋值。

和对象初始化相比，对象可以在定义时通过构造函数进行初始化。类似的：

在数组定义之中还提供有静态初始化的操作，即数组定义的同时就设置好了数组内容。

格式一，简化格式： 数据类型 数组名称 [] = {值，值，值，...}

格式二， 完整格式： 数据类型 数组名称 [] = new 数据类型 [] {值，值，值，...}

int data [] = new int[]{10,20,30};

for(int i=0; i

System.out.println( data[i]);

}

在实际工作中，数组是会存在的，但是它的内容大部分情况下是通过传递的数据而动态生成的，很少使用这种先开辟数组而后去使用的情况。

虽然数组支持顺序的数据访问操作，但是数组有一个最大的缺点——长度不能被改变，所以在开发之中才不会去应用数组，但是会使用到数组的概念。

二、数组与方法参数的传递

2.1 数组的引用传递

如果方法传递的是数组，请千万要记住，观察内存分配图。

举例：一个数组传递的程序

public class ArrayDemo{

public static void main(String args[]){

int data [] = new int []{1,2,3};

change(data);

for(int i=0; i

System.out.println(data[i]);}

}

public static void change(int temp[]){

for(int i=0; i

temp[i] *=2;}

}

}

2.2 数组排序

实现一个数组排序 经典面试、笔试题。

下面给出(升序)排序的基本原理(冒泡排序)：每次取一个数与其他数比较，如果大于则交换位置。

原始数据：2、1、9、0、5、3、7、6、8；

第一次排序：1、2、0、5、3、7、6、8、9 ；

第二次排序：1、0、2、3、5、6、7、8、9；

第三次排序：0、1、2、3、5、6、7、8、9。

以上只是给出了排序的基础原理过程，但是会根据数据的不同会出现不同的排序次数，但是不管有多少个数据，总的排序次数不会超过数组的长度。所以只要排序的次数达到 长度 * 长度，那么所要排序的数组一定会排序成功。

基础的实现：

public class ArrayDemo{

public static void main(String args[]){

int data [] = new int []{2,1,9,0,5,3,7,6,8};

// 外层控制排序的次数

for (int x = 0; x

// 内层控制每次的排序

for(int i=0; i

if(data[i] > data[i+1]){

int temp = data[i];

data[i] = data[i+1];

data[i+1] =temp;

}

}

}

print(data);

}

public static void print(int temp[]){

for(int i=0; i< temp.length; i++){

System.out.print(temp[i] + ",");

}

System.out.println();

}

}

改善设计：主方法是作为程序的起点存在，那么所有程序的起点都可以称为客户端。 既然是客户端，所有的代码编写一定要简单，可以 采用方法进行封装。

public class ArrayDemo{

public static void main(String args[]){

int data [] = new int []{2,1,9,0,5,3,7,6,8};

sort(data);

print(data);

}

public static void sort(int arr []){

// 外层控制排序的次数

for (int x = 0; x

// 内层控制每次的排序

for(int i=0; i

if(arr[i] > arr[i+1]){

int temp = arr[i];

arr[i] = arr[i+1];

arr[i+1] =temp;

}

}

}

}

public static void print(int temp[]){

for(int i=0; i< temp.length; i++){

System.out.print(temp[i] + ",");

}

System.out.println();

}

}

三、数组操作方法

java 本身针对于数组是有提供类库支持的。下面有两个与数组有关的操作：

3.1 数组拷贝

可以将一个数组的部分内容拷贝到另一数组中

语法： System.arraycopy(源数组名称，源数组拷贝开始索引，目标数组名称，目标数组拷贝开始索引，长度)；

举例：实现数组拷贝

数组 A： 1、2、3、4、5、6、7、8；

数组 B： 11、22、33、44、55、66、77、88；

要求拷贝后的数组： 11、22、5、6、7、66、77、88

代码为

int data [] = new int []{1,2,3,4,5,6,7,8};

int arr [] = new int []{11,22,33,44,55,66,77,88};

print(arr);

System.arraycopy(data,4,arr,2,3);

print(arr);

3.2 数组排序

之前给出了排序的基本操作，但是在开发里面如果要进行排序，只需要使用如下代码即可。

语法: Arrays.sort();

int data [] = new int []{3,6,1,8,0};

Arrays.sort(data);

如果是笔试题写 2.2 中的代码。

四、对象数组(重点)

数组是引用类型，对象也是引用类型，所以如果是对象数组的话表示一个引用类型里面嵌套了引用类型。

在之前使用的数组都基于基本数据类型的数组，但是所有的引用数据类型也同样可以定义数组，这样的数组称为对象数组。

如果要想定义对象数组(以类为例)，可以采用如下的形式完成：

4.1 动态初始化

声明并开辟对象数组： 类名称 对象数组名称 [] = new 类名称 [长度];

分步完成：

先声明对象数组： 类名称 对象数组名称 [] = null;

开辟对象数组： 对象数组名称 = new 类名称 [长度]；

举例：对象数组的动态初始化

Employee emp[] = new Employee[3];

emp[0] = new Employee("Alice","Java 开发", 1000);

emp[1] = new Employee("Bob","JSP 开发", 1000);

emp[2] = new Employee("Candy","Android 开发", 1000);

对象数组实际上就是将多个对象交给数组管理。

4.2 静态初始化

类名称 对象数组名称 [] = new 类名称 []{实例化对象,...}；

举例：对象数组的静态初始化

Employee emp[] = new Employee[]{

new Employee("Alice","Java 开发", 1000),

new Employee("Bob","JSP 开发", 2000),

new Employee("Candy","Android 开发", 3000)

};

注意，这里不要写数组长度。

4.3 一段总结

数组用的很少，但是一定会用，而且数组的相关逻辑关系比较麻烦；

把数组的排序与转置弄明白

要明白数组的定义语法与内存关系

对象数组的定义语法，对象数组 = 多个对象。

数组有一个最大的天生短板：长度固定，这个限制了数组在开发中的出现。

数组的排序：Arrays.sort()。