第五章：数组

数组元素的类型

数组元素的类型不仅可以为基本类型，也可以为引用类型。

int[] 表示int类型的数组，即数组元素为int类型

int[][] 表示int[]类型的数组，即数组元素为int[]类型

因为数组的索引是从0开始（代表第一个），所以int i = 0;

arr.length:获取数组中元素的长度

Java中的数组

在java中，数组就是一个变量，用于将相同数据类型的数据存储在内存中。数组中的每一个数据元素都属于同一数据类型。

数组的基本要素

标识符。首先，和变量一样，在计算机中，数组 也要有一个名称，称为标识符，用于区分不同的数组。

数组元素。当给出了数组名称，即数组标识符后，要向数组中存放数据，这些数据就称为数组元素

数组下标。在数组中，为了正确地得到数组的元素，需要对它们进行编号，这样计算机才能根据编号去存取，这个编号就称为数组下标。

元素类型。存储在数组中的数组元素应该是同一数据类型，如可以把赏的成绩存储在数组中，而每一个学员的成绩可以用整型变量存储，因此称它的元素类型是整型。

数组只有一个名称，即标识符。

数组元素在数组里顺序编号，该编号即为数组下标，它标明了元素在数组中的位置。第一个元素的编号 规定为0，因此数组的下标依次为0、1、2、3、4等。

数组中的每个元素都可以通过下标来访问。由于元素是按顺序来存储的，每个元素固定对应一个下标，因此可以通过下标快速地访问到每个元素。

数组的大小（长度）是数组可容纳元素的最大数量。定义一个数组的同时也定义了它的大小。如果数组已满但还继续向数组中存储数据的话，程序就会出错，这称为数组越界。

使用数组的步骤

1、声明数组

语法：

数据类型[] 数组名；

或者

数据类型 数组名[];

以上两种方式都可以声明一个数组，数组名可以是任意合法的变量名。

声明数组就是要告诉计算机该数组中数据的类型是什么？例如：

int [] scores; //存储学员的成绩，类型为int

double hight[]; //存储治学员的身高，类型为double

String[] names; //存储学员的姓名，类型为String

2、分配空间

虽然声明了数组，但并不会为数组元素分配内存空间，此时还不能使用数组。因此要为数组分配内存空间，这样数组的每一个元素才能对应一个存储单元。

简单地说，分配空间就是要告诉计算机在内存中分配 一些连续的空间来存储数据。在java中可以使用new关键字来给数组分配空间。

语法：

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

其中，数组长度就是数组中能存放的元素个数，显然应该为大于0的整数。例如：

scores = new int[30] //长度为30的int类型数组

hight = new double[30] //长度为30的double类型数组

names = new String[30] //长度为30的String类型数组

可以将上面两个步骤合并，即在声明数组的同时就给它分配空间，语法如下：

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

例如：

int scores[] = new int[30] //存储30个学员成绩

一旦声明了数组大小就不能再修改。即数组的长度是固定的。例如，上面名称为scores的这个数组 的长度是30，假如发现有31个学员成绩需要存储，想把数组长度改为31，则不可以，只能重新声明新的数组。

3、赋值

分配空间以后就可以向数组里放数据了。数组中的每一个元素都是通过下标来访问的。

语法如下：

数组名[下标值]；

例如：

scores[0] = 89;

scores[1] = 60;

scores[2] = 70;

注意：

在编写程序时，数组和循环往往结合在一起使用，可以大大简化代码，提高程序效率。通常，使用for循环遍历数组或者给数组元素赋值。

语法：

数据类型[] 数组名 = {值1 ， 值2 ， 值3 ， 。。。。值n}；

例如：

使用这种方法来创建scores数组

int[] scores = {60,70,80,90,76}; //创建一个长度为5的数组scores

同时，它也等价于下面的代码：

int[] scores = new int[] {60,70,98,90,76};

经验：

值得注意的是，直接创建并赋值的方式一般在数组元素比较少的情况下使用。它必须一并完成

4、对数据进行处理

在循环中，循环变量i从0开始递增直到数组的最大长度scores.length。因此，每次循环i加1。实现数组 的每个元素的累加。

注意：

数组一经创建，其长度（数组中包含元素的数目）是不可改变的，如果越界访问（即数组下标超过0到数组长度-1的范围），程序会报错。

数组名.length

例如，示例1的代码中，循环变量i小于数组长度，我人写成

i < scores.length;

而不是写成

i<5;

注意：

如果定义的数组是基本数据类型的数组，即int、double、char和boolean类型，在java中定义数组之后，若没有指定初始始值，则依数据类型的不同，会给数组元素赋一个默认值。如下表：

数据类型

初始值

int

0

double

0.0

char

’\u0000‘

boolean

false

常见错误：

1、数组下标从0开始

2、数组访问越界

冒泡排序

数组排序

使用Arrays类对数组进行排序，查找元素

Arrays.sort(arr);

(Arrays.toString(arr));

3.3.2、冒泡排序

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

冒泡排序格式

public void maopao() {

int arr[] = { 49, 26, 0, 10, 63, 10, 9, 1 };

for (int a = 0; a < arr.length - 1; a++) {

for (int b = 0; b < arr.length - a - 1; b++) {

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

int sum = arr[b];

arr[b] = arr[b + 1];

arr[b + 1] = sum;

}

}

}

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

}

System.out.println(arr[i])

}

}

}

选择排序

public void xuanzepaixu() {

int[] arr = { 100, 1, 30, 6, 50 };

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

for (int j = 0; j < arr.length; j++) {

if (arr[j] > arr[i]) {

int temp = arr[i];

arr[i] = arr[j];

arr[j] = temp;

}

}

}

for (int x = 0; x < arr.length; x++) {

System.out.println(arr[x]);

}

}

}

判断大小public void xiao() {

int max = a[0];

int min = a[0];

for (int j = 0; j < a.length; j++) {

if (a[j] < min) {

min = a[j];

}

if (a[j] > max) {

max = a[j];

}

}

System.out.println("\n最大的数为:" + max);

System.out.println("最小的数为:" + min);

}

copy Of的用法

int []arr={};

arr = Arrays.copyOf(arr, arr.length + 1);

arr[arr.length - 1] = b;

Arrays.copyOf功能是实现数组的复制，返回复制后的数组。参数是被复制的数组和复制的长度：

说明：复制的长度大于被复制数组的长度，则填充类型默认值，String得默认值是null,int的默认值是0

foreach语句使用

增强for(part1:part2){part3};

part2中是一个数组对象,或者是带有泛性的集合.

part1定义了一个局部变量,这个局部变量的类型与part2中的对象元素的类型是一致的.

part3当然还是循环体.

foreach语句是java5的新特征之一，在遍历数组、集合方面，foreach为开发人员提供了极大的方便。

foreach语句是for语句的特殊简化版本，但是foreach语句并不能完全取代for语句，然而，任何的foreach语句都可以改写为for语句版本。

foreach并不是一个关键字，习惯上将这种特殊的for语句格式称之为“foreach”语句。从英文字面意思理解foreach也就是“for 每一个”的意思。实际上也就是这个意思。

foreach的语句格式：

for(元素类型 int 元素变量i : 遍历对象obj){// foreach:i代表数组中的变量 obj:代表元素

引用了x的java语句;

}

下面通过两个例子简单例子看看foreach是如何简化编程的。代码如下：

/**

* foreach语句输出一维数组

*/

publicvoid test1() {

//定义并初始化一个数组

int arr[] = {2, 3, 1};

System.out.println("----1----排序前的一维数组");

for (int x : arr) {

System.out.println(x);//逐个输出数组元素的值

}

//对数组排序

Arrays.sort(arr);

//利用java新特性for each循环输出数组

System.out.println("----1----排序后的一维数组");

for (int x : arr) {

System.out.println(x);//逐个输出数组元素的值

}

}

数组查表法

数组查表法(根据键盘录入索引,查找对应星期)

意思是：String[] strArray = {"星期一","星期二",...};

*/

import java.util.Scanner;

class ArrayTest4 {

public static void main(String[] args) {

//定义一个字符串数组

String[] strArray = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"};

//创建键盘录入对象

Scanner sc = new Scanner(System.in);

System.out.println("请输入一个数据(0-6)：");

int index = sc.nextInt();

System.out.println("你要查找的日期是："+strArray[index]);

}

}

获取数组中的最大值最小值

(获取数组中的最大值最小值)

分析：

A:定义一个数组，并对数组的元素进行静态初始化。

B:从数组中任意的找一个元素作为参照物(一般取第一个),默认它就是最大值。

C:然后遍历其他的元素，依次获取和参照物进行比较，如果大就留下来，如果小，就离开。

D:最后参照物里面保存的就是最大值。

*/

class ArrayTest2 {

public static void main(String[] args) {

//定义一个数组

int[] arr = {34,98,10,25,67};

//请获取数组中的最大值

/*

//从数组中任意的找一个元素作为参照物

int max = arr[0];

//然后遍历其他的元素

for(int x=1; x<arr.length; x++) {

//依次获取和参照物进行比较，如果大就留下来，如果小，就离开。

if(arr[x] > max) {

max = arr[x];

}

}

//最后参照物里面保存的就是最大值。

System.out.println("max:"+max);

*/

//把这个代码用方法改进

//调用方法

int max = getMax(arr);

System.out.println("max:"+max);

//请获取数组中的最小值

int min = getMin(arr);

System.out.println("min:"+min);

}

/*

需求：获取数组中的最大值

两个明确：

返回值类型：int

参数列表：int[] arr

*/

public static int getMax(int[] arr) {

//从数组中任意的找一个元素作为参照物

int max = arr[0];

//然后遍历其他的元素

for(int x=1; x<arr.length; x++) {

//依次获取和参照物进行比较，如果大就留下来，如果小，就离开。

if(arr[x] > max) {

max = arr[x];

}

}

//最后参照物里面保存的就是最大值。

return max;

}

public static int getMin(int[] arr) {

//从数组中任意的找一个元素作为参照物

int min = arr[0];

//然后遍历其他的元素

for(int x=1; x<arr.length; x++) {

//依次获取和参照物进行比较，如果小就留下来，如果大，就离开。

if(arr[x] < min) {

min = arr[x];

}

}

//最后参照物里面保存的就是最小值。

return min;

}

}

数组逆序

(获取数组中的最大值最小值)

分析：

A:定义一个数组，并对数组的元素进行静态初始化。

B:从数组中任意的找一个元素作为参照物(一般取第一个),默认它就是最大值。

C:然后遍历其他的元素，依次获取和参照物进行比较，如果大就留下来，如果小，就离开。

D:最后参照物里面保存的就是最大值。

*/

class ArrayTest2 {

public static void main(String[] args) {

//定义一个数组

int[] arr = {34,98,10,25,67};

//请获取数组中的最大值

/*

//从数组中任意的找一个元素作为参照物

int max = arr[0];

//然后遍历其他的元素

for(int x=1; x<arr.length; x++) {

//依次获取和参照物进行比较，如果大就留下来，如果小，就离开。

if(arr[x] > max) {

max = arr[x];

}

}

//最后参照物里面保存的就是最大值。

System.out.println("max:"+max);

*/

//把这个代码用方法改进

//调用方法

int max = getMax(arr);

System.out.println("max:"+max);

//请获取数组中的最小值

int min = getMin(arr);

System.out.println("min:"+min);

}

/*

需求：获取数组中的最大值

两个明确：

返回值类型：int

参数列表：int[] arr

*/

public static int getMax(int[] arr) {

//从数组中任意的找一个元素作为参照物

int max = arr[0];

//然后遍历其他的元素

for(int x=1; x<arr.length; x++) {

//依次获取和参照物进行比较，如果大就留下来，如果小，就离开。

if(arr[x] > max) {

max = arr[x];

}

}

//最后参照物里面保存的就是最大值。

return max;

}

public static int getMin(int[] arr) {

//从数组中任意的找一个元素作为参照物

int min = arr[0];

//然后遍历其他的元素

for(int x=1; x<arr.length; x++) {

//依次获取和参照物进行比较，如果小就留下来，如果大，就离开。

if(arr[x] < min) {

min = arr[x];

}

}

//最后参照物里面保存的就是最小值。

return min;

}

}

数组元素逆序 (就是把元素对调)

分析：

A:定义一个数组，并进行静态初始化。

B:思路

把0索引和arr.length-1的数据交换

把1索引和arr.length-2的数据交换

...

只要做到arr.length/2的时候即可。

*/

class ArrayTest3 {

public static void main(String[] args) {

//定义一个数组，并进行静态初始化。

int[] arr = {12,98,50,34,76};

//逆序前

System.out.println("逆序前：");

printArray(arr);

//逆序后

System.out.println("逆序后：");

//reverse(arr);

reverse2(arr);

printArray(arr);

}

/*

需求：数组逆序

两个明确：

返回值类型：void (有人会想到应该返回的是逆序后的数组，但是没必要，因为这两个数组其实是同一个数组)

参数列表：int[] arr

*/

public static void reverse(int[] arr) {

/*

//第一次交换

int temp = arr[0];

arr[0] = arr[arr.length-1-0];

arr[arr.length-1-0] = temp;

//第二次交换

int temp = arr[1];

arr[1] = arr[arr.length-1-1];

arr[arr.length-1-1] = temp;

//第三次交换

int temp = arr[2];

arr[2] = arr[arr.length-1-2];

arr[arr.length-1-2] = temp;

*/

//用循环改进

for(int x=0; x<arr.length/2; x++) {

int temp = arr[x];

arr[x] = arr[arr.length-1-x];

arr[arr.length-1-x] = temp;

}

}

public static void reverse2(int[] arr) {

for(int start=0,end=arr.length-1; start<=end; start++,end--) {

int temp = arr[start];

arr[start] = arr[end];

arr[end] = temp;

}

}

//遍历数组

public static void printArray(int[] arr) {

System.out.print("[");

for(int x=0; x<arr.length; x++) {

if(x == arr.length-1) { //这是最后一个元素

System.out.println(arr[x]+"]");

}else {

System.out.print(arr[x]+", ");

}

}

}

}

数组元素的类型

数组元素的类型不仅可以为基本类型，也可以为引用类型。

int[] 表示int类型的数组，即数组元素为int类型

int[][] 表示int[]类型的数组，即数组元素为int[]类型

因为数组的索引是从0开始（代表第一个），所以int i = 0;

arr.length:获取数组中元素的长度

Java中的数组

在java中，数组就是一个变量，用于将相同数据类型的数据存储在内存中。数组中的每一个数据元素都属于同一数据类型。

数组的基本要素

标识符。首先，和变量一样，在计算机中，数组 也要有一个名称，称为标识符，用于区分不同的数组。

数组元素。当给出了数组名称，即数组标识符后，要向数组中存放数据，这些数据就称为数组元素

数组下标。在数组中，为了正确地得到数组的元素，需要对它们进行编号，这样计算机才能根据编号去存取，这个编号就称为数组下标。

元素类型。存储在数组中的数组元素应该是同一数据类型，如可以把赏的成绩存储在数组中，而每一个学员的成绩可以用整型变量存储，因此称它的元素类型是整型。

数组只有一个名称，即标识符。

数组元素在数组里顺序编号，该编号即为数组下标，它标明了元素在数组中的位置。第一个元素的编号 规定为0，因此数组的下标依次为0、1、2、3、4等。

数组中的每个元素都可以通过下标来访问。由于元素是按顺序来存储的，每个元素固定对应一个下标，因此可以通过下标快速地访问到每个元素。

数组的大小（长度）是数组可容纳元素的最大数量。定义一个数组的同时也定义了它的大小。如果数组已满但还继续向数组中存储数据的话，程序就会出错，这称为数组越界。

使用数组的步骤

1、声明数组

语法：

数据类型[] 数组名；

或者

数据类型 数组名[];

以上两种方式都可以声明一个数组，数组名可以是任意合法的变量名。

声明数组就是要告诉计算机该数组中数据的类型是什么？例如：

int [] scores; //存储学员的成绩，类型为int

double hight[]; //存储治学员的身高，类型为double

String[] names; //存储学员的姓名，类型为String

2、分配空间

虽然声明了数组，但并不会为数组元素分配内存空间，此时还不能使用数组。因此要为数组分配内存空间，这样数组的每一个元素才能对应一个存储单元。

简单地说，分配空间就是要告诉计算机在内存中分配 一些连续的空间来存储数据。在java中可以使用new关键字来给数组分配空间。

语法：

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

其中，数组长度就是数组中能存放的元素个数，显然应该为大于0的整数。例如：

scores = new int[30] //长度为30的int类型数组

hight = new double[30] //长度为30的double类型数组

names = new String[30] //长度为30的String类型数组

可以将上面两个步骤合并，即在声明数组的同时就给它分配空间，语法如下：

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

例如：

int scores[] = new int[30] //存储30个学员成绩

一旦声明了数组大小就不能再修改。即数组的长度是固定的。例如，上面名称为scores的这个数组 的长度是30，假如发现有31个学员成绩需要存储，想把数组长度改为31，则不可以，只能重新声明新的数组。

3、赋值

分配空间以后就可以向数组里放数据了。数组中的每一个元素都是通过下标来访问的。

语法如下：

数组名[下标值]；

例如：

scores[0] = 89;

scores[1] = 60;

scores[2] = 70;

注意：

在编写程序时，数组和循环往往结合在一起使用，可以大大简化代码，提高程序效率。通常，使用for循环遍历数组或者给数组元素赋值。

语法：

数据类型[] 数组名 = {值1 ， 值2 ， 值3 ， 。。。。值n}；

例如：

使用这种方法来创建scores数组

int[] scores = {60,70,80,90,76}; //创建一个长度为5的数组scores

同时，它也等价于下面的代码：

int[] scores = new int[] {60,70,98,90,76};

经验：

值得注意的是，直接创建并赋值的方式一般在数组元素比较少的情况下使用。它必须一并完成

4、对数据进行处理

在循环中，循环变量i从0开始递增直到数组的最大长度scores.length。因此，每次循环i加1。实现数组 的每个元素的累加。

注意：

数组一经创建，其长度（数组中包含元素的数目）是不可改变的，如果越界访问（即数组下标超过0到数组长度-1的范围），程序会报错。

数组名.length

例如，示例1的代码中，循环变量i小于数组长度，我人写成

i < scores.length;

而不是写成

i<5;

注意：

如果定义的数组是基本数据类型的数组，即int、double、char和boolean类型，在java中定义数组之后，若没有指定初始始值，则依数据类型的不同，会给数组元素赋一个默认值。如下表：

数据类型

初始值

int

0

double

0.0

char

’\u0000‘

boolean

false

常见错误：

1、数组下标从0开始

2、数组访问越界

(获取数组中的最大值最小值)

分析：

A:定义一个数组，并对数组的元素进行静态初始化。

B:从数组中任意的找一个元素作为参照物(一般取第一个),默认它就是最大值。

C:然后遍历其他的元素，依次获取和参照物进行比较，如果大就留下来，如果小，就离开。

D:最后参照物里面保存的就是最大值。

*/

class ArrayTest2 {

public static void main(String[] args) {

//定义一个数组

int[] arr = {34,98,10,25,67};

//请获取数组中的最大值

/*

//从数组中任意的找一个元素作为参照物

int max = arr[0];

//然后遍历其他的元素

for(int x=1; x<arr.length; x++) {

//依次获取和参照物进行比较，如果大就留下来，如果小，就离开。

if(arr[x] > max) {

max = arr[x];

}

}

//最后参照物里面保存的就是最大值。

System.out.println("max:"+max);

*/

//把这个代码用方法改进

//调用方法

int max = getMax(arr);

System.out.println("max:"+max);

//请获取数组中的最小值

int min = getMin(arr);

System.out.println("min:"+min);

}

/*

需求：获取数组中的最大值

两个明确：

返回值类型：int

参数列表：int[] arr

*/

public static int getMax(int[] arr) {

//从数组中任意的找一个元素作为参照物

int max = arr[0];

//然后遍历其他的元素

for(int x=1; x<arr.length; x++) {

//依次获取和参照物进行比较，如果大就留下来，如果小，就离开。

if(arr[x] > max) {

max = arr[x];

}

}

//最后参照物里面保存的就是最大值。

return max;

}

public static int getMin(int[] arr) {

//从数组中任意的找一个元素作为参照物

int min = arr[0];

//然后遍历其他的元素

for(int x=1; x<arr.length; x++) {

//依次获取和参照物进行比较，如果小就留下来，如果大，就离开。

if(arr[x] < min) {

min = arr[x];

}

}

//最后参照物里面保存的就是最小值。

return min;

}

}