第三章数组

一维数组的定义与使用

一维数组的声明和创建

什么是数组

数组是一种用于存储多个 相同类型 数据的存储模型。

声明数组：

数据类型 [ ] 数组名； int[ ] a

数据类型 数组名[ ]； String a[ ]

数据类型定义了数组内元素的数据类型，可以是基本数据类型或引用数据类型；
数组名是自定义变量名，需满足标识符命名规则；
声明数组时，不能在方括号中直接指定数组元素个数，如 int[3] a。

注意：声明数组后，需要创建数组，并为数组分配存储空间。

创建一维数组

使用 new 关键字创建数组并分配存储空间。

在声明数组 int a[]; 后，使用 a = new int[5]; 语句为数组分配存储空间，即给出数组长度。

1
2
3
4
5
6
7
8


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

// 数据类型  数组名[] = new 数据类型[数组长度];
int b[] = new int[10];

// 数据类型[]  数组名 = new 数据类型[数组长度];
int[] c = new int[10];

注意：java中的数组必须 初始化，然后才能使用。

所谓初始化，就是为数组中的数组元素分配内存空间，并为每个数组赋值。

一维数组的初始化

数组的初始化分为 静态初始化 以及 动态初始化。

静态初始化：

在创建数组的同时，为数组的元素赋初始值，由系统决定数组的长度。
数组元素值一开始就已经给出。

1
2


int[] arr1 = {1, 3, 5, 7, 9};
String[] arr2 = {"Lily", "Johnny", "Peter", "Lisa"};

动态初始化：

在创建数组后，初始化时只指定数组长度，由系统为数组分配初始值，再给数组元素赋值。

1
2
3
4
5
6
7


int[] arr1 = new int[5];
for (int i = 0; i< arr1.length; i++){
    arr1[i] = i+1;
}
char[] arr2 = new char[3];
arr2[0] = 'a';
arr2[2] = 'c';

练习：创建一个长度为 10 的数组，键盘录入 10 个整数为数组元素赋值。

数组内存分配

什么是内存

内存是计算机中的重要原件，是一个临时存储区域，作用是运行程序。

我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的，必须放进内存中才能运行，运行完毕后会清空内存。

Java中的内存分配

目前我们只需要记住两个内存，分别是：栈内存和堆内存。

区域名称	作用
寄存器	给CPU使用，和我们开发无关。
方法区	存储可以运行的class文件。
本地方法栈	JVM在使用操作系统功能的时候使用，和我们开发无关。
堆内存	存储对象或者数组， new来创建的，都存储在堆内存。
方法栈	方法运行时使用的内存，比如main方法运行，进入方法栈中执行。

变量存放在栈内存，对象存放在堆内存

如果是 基本数据类型 直接存放在栈内的变量里，如果是 引用数据类型 就把堆内存中 地址值 存到栈内的变量里。

1
2
3
4


String s1,s2,s3 = "abc", s4 ="abc" ;
s1 = new String("abc");
s2 = new String("abc");
System.out.println(s1 == s2);

一维数组的访问

索引

每一个存储到数组的元素，都会自动的拥有一个编号，从 0 开始。这个编号称为 数组索引（index），可以通过数组的索引访问到数组中的元素。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// 数组名[索引];
int[] arr = new int[3];

//输出数组名
System.out.println(arr); //[I@880ec60  ....

//输出数组中的元素
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);

数组遍历

所谓 遍历(Traversal) ，是指沿着某条搜索路线，依次对树、图、集合 … 中每个节点均做一次访问。

通过数组名 [index] 的方法可以直接获取数组中的某一个元素，但如果想要输出一个长数组中的所有元素，通过一个个输出的方法肯定是不合适的，那么怎么输出所有元素？

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


int[] arr1 = { 1, 2, 3, 4, 5 };
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println(arr1[2]);
System.out.println(arr1[3]);
System.out.println(arr1[4]);

int[] arr2 = {11, 22, 33, 44, 55};
for(int x=0; x<arr2.length; x++) {
    System.out.println(arr2[x]);
}

数组索引越界异常

下列代码有什么错误？

1
2


int[] arr = {10, 20, 30};
System.out.println(arr[3]);

1
2
3
4
5


String teachers[] = {"张三", "李四", "王五"};
for (int i = 0; i < 4; i++) {
    System.out.println(teachers[i]);
}
System.out.println("显示完毕！");

多维数组的定义与使用

二维数组的声明和创建

声明数组

数据类型 [ ] [ ] 数组名；

数据类型 数组名[ ] [ ]；

二维数组第二维的所有元素具有相同的数据类型。
二维数组的第一维的所有元素时数组类型。
声明二维数组时，不能在方括号中指定数组的元素个数。

创建二维数组

使用 new 关键字创建数组并分配存储空间。

数组名 = new 数据类型 [第一维长度] [第二维长度]; 如 a = new int [3] [2] 表示创建 3 行 2 列的数组。

练习

打印 0 ~ 100 的所有数字，当数字包含 7 或者是 7 的倍数的时候，改为打印 “过”。

1
2
3
4
5
6
7
8


for (int i =0;i<=100;i++){
    if ((i % 7==0) || (i%10==7)){
        System.out.println("过");
    }else {
        System.out.println(i);
    }

}

键盘录入一个大于等于 2 的整数 x，计算并返回 x 的平方根。（只保留整数部分）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


Scanner sc = new Scanner(System.in);
System.out.println("请输入一个大于等于2的整数：");
int x = sc.nextInt();

for (int i = 1; i < x; i++) {
    if(i*i > x){
        System.out.println(x+"的平方根的整数部分是"+(i-1));
        break;
    }
}

键盘录入一个正整数 x，判断该整数是否是一个质数。（质数：一个整数只能被 1 和自身整除）。
- 方法1：如果能被 2 ~ x-1 整除，则 flag = false（标记）。
- 方法2：if(x % i == 0){count++}。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


Scanner sc = new Scanner(System.in);
System.out.println("请输入一个正整数：");
int x = sc.nextInt();
boolean flag = true;

for (int i = 2; i<x;i++){
    if (x % i == 0){
        flag = false;
        break;
    }
}
if (flag == true){
    System.out.println(x+"是质数");
}else if (flag == false){
    System.out.println(x+"不是质数");
}

猜数字小游戏。程序自动生成一个 1 ~ 100 之间的随机数字，使用程序猜出这个数字是多少。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


Random r = new Random();
int num = r.nextInt(100)+1;
Scanner sc = new Scanner(System.in);
boolean a = true;

System.out.println("请输入猜的数字：");
int guess = sc.nextInt();
while (a){
    if (guess<num){
        System.out.println("猜小了");
    }else if (guess>num){
        System.out.println("猜大了");
    }else {
        System.out.println("猜对了");
        a = false;
    }
}

[min,max] 随机整数 ==> ran.nextInt(max-min+1)+min

创建一个数组存储 10 个随机数，求出最大值和最小值。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


Random r = new Random();
int[] arr = new int[10];

for (int i = 0; i < arr.length; i++) {
    arr[i] = r.nextInt(100);
}

System.out.println(Arrays.toString(arr));
int max = 0;
int min = 0;
for (int i : arr) {
    if (max < i) {
        max = i;
    }
    if (min > i) {
        min = i;
    }
}
System.out.println("数组中最大值为：" + max);
System.out.println("数组中最小值为：" + min);

生成 10 个 1 ~ 100 之间的随机数存入数组，求所有数的和，并求出平均数，最后统计数组中有多少个数比平均数小。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


Random r = new Random();
int[] arr = new int[10];
int sum = 0;
int count = 0;

for (int i = 0; i < arr.length; i++) {
    arr[i] = r.nextInt(100) + 1;
    sum += arr[i];
}

double avg = sum / 10;

for (int i : arr) {
    if (i < avg) {
        count++;
    }
}

System.out.println("数组中所有数的和为：" + sum);
System.out.println("数组中所有数的平均数为：" + avg);
System.out.println("数组中比平均数小的数有：" + count + "个");

创建一个数组存储 10 个随机数，并尝试将数组中的元素颠倒。

方法1：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


int arr[] = new int[10];
Random r = new Random();
for (int i = 0; i < arr.length; i++) {
    arr[i] = r.nextInt(100);
}

int arr2[] = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
    arr2[i] = arr[arr.length -(i+1)];
    /*
        i=0, arr2[0] = arr[9]
        i=1, arr2[1] = arr[8]
     */
}
System.out.println(Arrays.toString(arr));
System.out.println(Arrays.toString(arr2));

方法2：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


int arr[] = new int[10];
Random r = new Random();
for (int i = 0; i < arr.length; i++) {
    arr[i] = r.nextInt(100);
}
System.out.println(Arrays.toString(arr));
int num = 0;
// 0 1 2 3 4    5 6 7 8 9
// [63, 86, 15, 83, 48, 20, 45, 22, 79, 80]
// num = 63; arr[0] = arr[9] = 80; arr[9] = 63;
for (int i = 0; i < arr.length / 2; i++) {
    num = arr[i];
    arr[i] = arr[arr.length - i - 1];
    arr[arr.length - i - 1] = num;
}
System.out.println(Arrays.toString(arr));