第四章：Java数组

chap04

目标：数组

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

1.概述

数组是一组数据的集合，数组中的每个数据被称为元素。在java中,数组也是对象。数组中的元素可以是任意类型(基本类型和引用类型),但同一个数组里只能存放类型相同的元素。

数组类型的变量、类类型的变量、接口类型的变量都属于引用类型的变量,这些变量都是可以指向其相应的对象的,那么数组类型的变量指向的就是数组对象。

之前我们接触到的第一个数组类型变量,应该就是main方法的参数

public static void main(String[] args){

 // args----->数组对象(jvm 创建 并传递过来)

}

其中 String[] 就是一个数组类型,args就是这个数组类型的变量,它所指向的数组对象中只能存放String类型的数据。

注:main方法是由JVM负责调用,那么args所指向的数组对象也是由JVM负责创建并传过来.

2.声明数组类型变量

1)数组类型

8种基本数据类型和3种引用类型,使用这些都可以声明出数组类型

即:任意类型都可以声明成数组类型,只需要加"[]"即可

例如:

基本类型的数组:

byte[] short[] int[] long[] float[] double[] char[] boolean[]

引用类型的数组:

//使用类声明出的数组

Student[]

//使用接口声明出的数组

Action[]

//使用数组声明出的数组(也就是二维数组)

int[][]

注意:使用X类型声明出的数组,那么将来该数组中就只能存放X类型的数据

2)数组类型变量

有俩种形式可以声明数组变量,推荐使用第一种。

int[] a;

或者

int a[];

例如:

String[] str;

Student[] students;

long[] l;

注:数组类型变量将来是要指向对象的。

3.创建数组对象

1)数组对象的长度

数组的长度是指一个数组对象中可以存放多少个数据(元素)。

每一个数组对象在被创建的时候,就需要指明其长度是多少,并且该长度一确定的就不能再做修改。

2)数组对象的创建

创建数组对象使用new关键字即可。

例如:

int[] a = new int[4];

String[] str = new String[1];

//表示该数组对象中一个数据都存放不了

char[] c = new  char[0];

//编译报错,因为创建数组对象的时候没知道其长度

long[] v = new long[];

3)获得数组对象的长度

使用数组对象访问其length属性即可获得该数组的长度

例如:

int[] a = new int[4];

System.out.println(a.length);//4

注意:对象创建后,数组的长度是不能改变的。

例如:

//编译报错

int[] a = new int[4];

a.length = 8;

//编译通过

//但是这只是又新建了一个数组对象

//而不是改变原来数组对象的长度

int[] a = new int[4];

a = new int[8];

4.数组对象的初始化及使用

1)数组对象在内存中的位置

数组对象也是java中的一种对象,但是和之前使用类创建出的对象还是一定区别的。

数组对象也存放z在内存中的堆区,并且数组对象在堆区中是一块连续的内存空间,这其中的每一小块空间都可以存放我们要保存的一个数据(元素)。那么数组的长度指的其实也就是这个东西。

注:数据对象其实就是堆区中的一块连续的内存空间

2)数组对象中每个元素位置上的默认值

数组对象中的默认值和其要保存的数据类型有关

例如:

int[] a = new int[4];

在我们存放数据之前,这四个元素位置上就以及有了默认值了

整型数组的默认值是                0

浮点型数组的默认值是        0.0

布尔类型数组的默认值是        false

字符类型数组的默认值是        0

引用类型数组的默认值是        null

3)数组对象中的元素位置的下标

由于数组对象在堆区中是一块连续的内存空间,那么我们可以通过连续的下标,找到每一个可以存放数据的元素位置。

注:下标是从0开始的

例如:

//通过下标0 1 2 3可以访问到数组对象中四个元素位置的值

//整型的默认值是 0

int[] a = new int[4];

System.out.println(a[0]);//0

System.out.println(a[1]);//0

System.out.println(a[2]);//0

System.out.println(a[3]);//0

//布尔的默认值是 false

boolean[] a = new boolean[4];

System.out.println(a[0]);//false

System.out.println(a[1]);//false

System.out.println(a[2]);//false

System.out.println(a[3]);//false

总结:如果一个数组对象的长度是n,那么这个数组下标的值是[0,n-1],其中n必须大于0

4)使用数组的下标赋值

String[] str = new String[3];

//赋值前:使用循环输出数组中的元素

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

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

}

str[0] = "hello";

str[1] = "world";

str[2] = "test";

//赋值后:使用循环输出数组中的元素

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

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

}

5)特殊形式

//编译通过

int[] a1 = new int[]{1,3,5,7,9};

System.out.println(a1.length);//5

//编译通过

int[] a2 = {2,4,6,8};

System.out.println(a2.length);//4

//编译通过

int[] a4;

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

System.out.println(a4.length);//3

/*下面俩种情况是错误的创建方式*/

//编译报错

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

//编译报错

int[] a4;

a4 = {1,2,3};

6)数组下标越界

对于一个长度为n的数组对象,它的的下标取值范围是[0,n-1],这里的0和n-1就是这个数组对象的下标边界,使用下标的过程中不能超出这个边界。如果超出那么就会运行报错.

例如:

int[] a = new int[4];

a[4] = 10;

运行后结果:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4

at com.briup.test.ArrayTest.main(ArrayTest.java:7)

7)数组对象的拷贝

数组对象的长度确定之后便不能修改,但我们可以通过复制数组的内容变通实现改变数组长度。

在java.lang.System类中提供一个名为arraycopy的方法可以实现复制数组中元素的功能

//该方法的声明

public static void arraycopy(Object src,

 int srcPos,

 Object dest,

 int destPos,

 int length)

参数1,需要被复制的目标数组

参数2,从这个数组的那个一个位置开始复制

参数3,需要把数据复制到的另外的那一个新的数组对象

参数4,复制到新数组里面哪个位置(从这个位置开始算)

参数5,复制的目标数组的长度

例如:

写一个方法,接收一个数组对象,把这个数组对象的长度扩大到原来的2倍并返回。

public int[] test(int[] a){

int[] b = new int[a.length*2];

System.arraycopy(a, 0, b, 0, a.length);

return b;

}

 

8)数组的工具类java.util.Arrays

由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一些基本的操作.

1)Arrays类的引入

该是java.util包中的类,在我们的代码中想使用这个类的话,就必须使用import进行导入.

在当前类A中,只有java.lang包下的类,以及和当前类A在同一个包下的类,不需要import引入之外,其他所有的包下的类在被使用之前都要import引入.

例如:

package com.briup.ch04;

import java.util.Arrays;

public class Xxx{....}

2)Arrays类中方法的调用

Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对象来调用(注意:是"不用" 而不是 "不能")

例如:

main:

//返回指定元素在数组中的下标位置

//如果找不到则返回一个小于0的数

int[] a = {1,3,5,7,9};

int key = Arrays.binarySearch(a,7);

System.out.println(key);//3

3)Arrays类中常用方法

toString方法,把数组转换位字符串形式并返回

例如:

int[] a = {1,3,5,7,9};

System.out.println(Arrays.toString(a));

//输出结果: [1, 3, 5, 7, 9]

binarySearch方法,在数组中查找指定元素并返回其下标

例如:

int[] a = {1,3,5,7,9};

int key = Arrays.binarySearch(a,7);

System.out.println(key);

//输出结果: 3

注:

使用二分搜索法来搜索指定的数组，以获得指定的值。必须在进行此调用之前对数组进行排序(通过sort方法等)。如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个

copyOf方法,复制或者截取指定数组并返回

例如: 复制

int[] a = {1,3,5,7,9};

a = Arrays.copyOf(a, 8);

System.out.println(Arrays.toString(a));

//输出结果: [1, 3, 5, 7, 9, 0, 0, 0]

例如: 截取

int[] a = {1,3,5,7,9};

a = Arrays.copyOf(a, 2);

System.out.println(Arrays.toString(a));

//输出结果: [1, 3]

copyOfRange方法,将数组中指定范围复制新数组并返回

例如:

int[] a = {1,3,5,7,9};

a = Arrays.copyOfRange(a,1,3);

System.out.println(Arrays.toString(a));

//输出结果: [3, 5]

equals方法,比较俩个数组是否相等

例如:

int[] a = {1,3,5,7,9};

int[] b = {1,3,5,7,9};

System.out.println(Arrays.equals(a, b));//true

System.out.println(a==b);//false

注意:==比较的是引用所指向对象的内存地址

 Arrays.equals方法比较是俩个数组中的内容

fill方法,用指定值去填充数组对象

例如:

int[] a = {1,3,5,7,9};

Arrays.fill(a, 99);

System.out.println(Arrays.toString(a));

//输出结果:[99, 99, 99, 99, 99]

sort方法,把数据中的元素进行排序

例如:

int[] a = {3,5,1,9,7};

System.out.println("before:\t"+Arrays.toString(a));

Arrays.sort(a);

System.out.println("after:\t"+Arrays.toString(a));

//输出结果:

before:        [3, 5, 1, 9, 7]

after:        [1, 3, 5, 7, 9]

asList方法,可以把数组转换为List集合。

5.数组使用例子

1)求一组值的平均值

public double getAvg(int[] a){

double sum = 0;

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

sum+=a[i];

}

return sum/a.length;

}

2)求一组值的最大值

public int getMax(int[] a){

int max = a[0];//int max = 0

for(int i=1;i<a.length;i++){

if(a[i]>max){

max = a[i];

}

}

return max;

}

 [3,4,7,9,1,2]

3)冒泡排序

相邻的俩个元素比较,让值较大的数据逐渐向数组的底部(即朝最后一个元素)移动。

        原理：比较两个相邻的元素，将值大的元素交换到右边。

public void sort(int[] a) {

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

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

if(a[j]>a[j+1]) {

int temp = a[j];

a[j] = a[j+1];

a[j+1] = temp;

}

}

}

}

4)从众多手机号码中抽取一个获奖手机号码

public String getTel(String[] str) {

int index = (int)(Math.random()*n.length);

return str[index];

}

注意:Math.random()返回值是[0,1)之间的double类型的随机数

5)产生四位长度的验证码, 验证码内容为大小写字母或数字组成

public String getValidateCode() {

String s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

char[] c = s.toCharArray();

int i1 = (int)(Math.random()*c.length);

int i2 = (int)(Math.random()*c.length);

int i3 = (int)(Math.random()*c.length);

int i4 = (int)(Math.random()*c.length);

return ""+c[i1]+c[i2]+c[i3]+c[i4];

}

 

6.二维数组

既然任何类型都可以声明为数组,那么给数组再加一个[]就得到了二维数组,类似的二维数组再加一个[]就得到三维数组。

假定某个宾馆有三层楼，第一层有4个房间，第二层有3个房间，第三层有5个房间。某一天客户入住情况如下所示:

第三层:           |    |Tom |Jerry|    |Rose|

第二层：          |Mary|    |Kevin|  ×          ×

第一层：          |Mike|Jane|Duke |    |  ×

可以用两维数组来存储各个房间的客人信息。

String[][] room = new String[3][];

room[0] = new Stirng[]{"Mike","Jane","Duke",null};

room[1] = new String[]{"Mary",null,"kevin"};

room[2] = new String[]{null,"Tom","Jerry",null,"Rose"}

1)声明并创建二维数组

//堆区有一块连续的内存空间,里面有3个元素位置

//每个元素位置中都存放了一个一维数组

//每个一维数组中都有4个元素位置

//这个4个元素位置上的值都默认是0

int[][] a = new int[3][4];

//堆区有一块连续的内存空间,里面有3个元素位置

//每个元素位置上都只有默认值null(引用类型 )

//将来这3个位置上都是要存放一维数组的

int[][] a = new int[3][];

//编译报错

int[][] a = new int[][];

 

2)给二维数组赋值

例如:

int[][] a = new int[3][4];

a[0][0] = 10;

a[0][1] = 10;

a[0][2] = 10;

a[0][3] = 10;

 

a[1][0] = 20;

a[1][1] = 20;

a[1][2] = 20;

a[1][3] = 20;

 

a[2][0] = 30;

a[2][1] = 30;

a[2][2] = 30;

a[2][3] = 30;

 

例如:

int[][] a = new int[3][];

a[0] = new int[1];

a[1] = new int[2];

a[2] = new int[3];

 

a[0][0] = 10;

 

a[1][0] = 20;

a[1][1] = 20;

 

a[2][0] = 30;

a[2][1] = 30;

a[2][2] = 30;

 

3)特殊情况

//编译通过

int[][] a = {

{1},

{1,2},

{1,2,3}

};

//编译通过

int[][] a4 = new int[][]{

{1},{1,2},{1,2,3}

};

//编译报错

int[][] a5 = new int[3][]{

{1},{1,2},{1,2,3}

};

 

4)二维数组结合循环

String[][] str = {

{"test1"},

{"hello1","hello2"},

{"world1","world2","world3"}

};

 

//循环三次,因为str中有三个元素

//只不过这三个元素每一个都是个一维数组

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

 

//第一个一维数组中有1个元素,元素是String类型的

//第二个一维数组中有2个元素,元素是String类型的

//第三个一维数组中有3个元素,元素是String类型的

//所以内层循环每次打印的次数是不一样的

for(int j=0;j<str[i].length;j++){

System.out.println(str[i][j]);

}

}

7.可变参数

注:只有在JDK1.5或以上版本中可用

例如:

public void test(int[] a){

 

}

我们调用这个方法的时候,"只能"传入一个int[]类型的参数

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

t.test(a);

但是如果使用可变参数:

public void test(int... a){

 

}

那么调用的时候传入的参数类型及形式就会比较多样

int[] a = {1,2,3,4};

t.test2(a);

t.test2();

t.test2(1);

t.test2(1,2,3,4,5,6,7);

可变参数前面可以加其他参数,但可变参数后面再加其他参数就会报错

public void test(String msg,int... a){

 

}

调用方法:

int[] a = {1,2,3,4};

String msg = "hello";

t.test(msg,a);

t.test(msg);

t.test(msg,1);

t.test(msg,1,2,3,4,5,6,7);

注:在方法内部,这个可变参数我们使用的时候直接把它当做数组就可以了

public void test(int... a){

System.out.println(a.length);

}

8.格式化输出(作为了解的内容)

注:只有在JDK1.5或以上版本中可用

// 定义一些变量，用来格式化输出。 

double d = 345.678; 

int i = 1234; 

// "%"表示进行格式化输出，"%"之后的内容为格式的定义。

// "f"表示格式化输出浮点数。

System.out.printf("%f", d); //345.678000

System.out.println(); 

// "9.2"中的9表示输出的长度，2表示小数点后的位数。 注意输出数字前面的空格也是算在长度里的

System.out.printf("%9.2f", d);//   345.68

System.out.println(); 

// "+"表示输出的数带正负号。 

System.out.printf("%+9.2f", d);//  +345.68

System.out.println(); 

// "-"表示输出的数左对齐（默认为右对齐）。 

System.out.printf("%-9.4f", d);//345.6780

System.out.println(); 

// "+-"表示输出的数带正负号且左对齐。 

System.out.printf("%+-9.3f", d);//+345.678

System.out.println(); 

// "d"表示输出十进制整数。

System.out.printf("%d", i);//1234

System.out.println(); 

// "o"表示输出八进制整数。

System.out.printf("%o", i);//2322

System.out.println(); 

// "x"表示输出十六进制整数。 

System.out.printf("%x", i);//4d2

System.out.println(); 

// "#x"表示输出带有十六进制标志的整数。 

System.out.printf("%#x", i);//0x4d2

System.out.println();