释放双眼，带上耳机，听听看~！
JAVA之旅（三）——数组，堆栈内存结构，静态初始化，遍历，最值，选择/冒泡排序，二维数组，面向对象思想
我们继续JAVA之旅
一.数组
1.概念
数组就是同一种类型数据的集合，就是一个容器
- 数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素
数组的格式
2
3
4
5
6
7
8
9
10
11
12
13
2public class HelloJJAVA {
3 // 公共的 静态 无返回值 main方法 数组
4 public static void main(String[] str) {
5 /**
6 * 格式：元素类型 [] 数组名 = new 元素类型[元素个数]
7 * 定义一个可以存储3个整数的容器
8 */
9 int[] x = new int[3];
10 }
11
12}
13
2.内存结构
JAVA程序在运行时，需要在内存中分配空间，为了提高效率，有对空间进行不同区域的划分，因为每一片区域都有特定的处理数据方式和内存内存管理方式
-
堆内存：用于存储局部变量，当数据使用完，所占空间会自动释放
-
栈内存
-
数组和对象，通过new建立的实例都放在堆内存中
- 每一个实体都有内存地址值
- 实体中的变量都有默认的初始值
- 实体不再被使用，会在不确定的时间被垃圾回收器回收
-
方法区
-
本地方法，寄存器
数组还有另外一种格式
2
3
2int [] arr1 = {3,6,8,74,99,12};
3
我们把他叫做静态初始化
3.遍历
数组的操作，我们先看一个最简单的，直接循环
2
3
4
5
6
7
8
9
10
11
12
13
14
15
2public class HelloJJAVA {
3 // 公共的 静态 无返回值 main方法 数组
4 public static void main(String[] str) {
5 /**
6 * 数组操作
7 */
8 int [] arr = {3,6,8,74,99,12};
9 for (int i = 0; i < arr.length; i++) {
10 System.out.println("遍历"+arr[i]);
11 }
12 }
13
14}
15
得到的结果
我们再来写个小例子
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
2public class HelloJJAVA {
3 // 公共的 静态 无返回值 main方法 数组
4 public static void main(String[] str) {
5 /**
6 * 数组操作
7 */
8 int[] arr = { 3, 6, 8, 74, 99, 12 };
9 printArray(arr);
10
11 }
12
13 /**
14 * 定义一个方法打印数组中的元素用逗号隔开
15 */
16
17 public static void printArray(int[] array) {
18 for (int i = 0; i < array.length; i++) {
19 System.out.print(array[i] + ",");
20 }
21 }
22
23}
24
我们的运行结果
现在我们有一个需求就是不要最后面的逗号，我们该怎么去做？其实就是判断
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
2public class HelloJJAVA {
3 // 公共的 静态 无返回值 main方法 数组
4 public static void main(String[] str) {
5 /**
6 * 数组操作
7 */
8 int[] arr = { 3, 6, 8, 74, 99, 12 };
9 printArray(arr);
10
11 }
12
13 /**
14 * 定义一个方法打印数组中的元素用逗号隔开
15 */
16
17 public static void printArray(int[] array) {
18 for (int i = 0; i < array.length; i++) {
19 // 最后一个
20 if ((array.length - 1) - i == 0) {
21 System.out.print(array[i]);
22 } else {
23 System.out.print(array[i] + ",");
24 }
25
26 }
27 }
28
29}
30
只要我的长度-1 再减去你的循环数是0，说明是最后一个，那就不加逗号，输出的结果
4.获取最值
获取最值就是最大值，最小值之类的，我们一个个来获取
-1.最大/最小值
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
2public class HelloJJAVA {
3 // 公共的 静态 无返回值 main方法 数组
4 public static void main(String[] str) {
5 /**
6 * 获取数组中的最大值和最小值
7 */
8
9 int[] arr = { 3, 6, 8, 74, 99, 12 };
10
11 // 最大值
12 int max = arr[0];
13 // 最小值
14 int min = arr[0];
15
16 /**
17 * 思路，定义一个变量对数组的元素进行比较，大于/小于 就记录
18 */
19 for (int i = 1; i < arr.length; i++) {
20 if (arr[i] > max) {
21 max = arr[i];
22 }
23 }
24 System.out.println("最大值：" + max);
25
26 for (int i = 0; i < arr.length; i++) {
27 if (arr[i] < min) {
28 min = arr[i];
29 }
30 }
31 System.out.println("最小值：" + min);
32 }
33}
34
输出的结果‘
五.排序
这个就比较有意思了
-1.选择排序
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
2public class HelloJJAVA {
3 // 公共的 静态 无返回值 main方法 数组
4 public static void main(String[] str) {
5
6 /**
7 * 选择排序
8 */
9 int[] arr = { 3, 6, 8, 74, 99, 12 };
10
11 for (int i = 0; i < arr.length; i++) {
12 for (int j = 0; j < arr.length; j++) {
13 if (arr[i] > arr[j]) {
14 int temp = arr[i];
15 arr[i] = arr[j];
16 arr[j] = temp;
17 }
18 }
19 }
20
21 // 打印
22 for (int i = 0; i < arr.length; i++) {
23 System.out.print(arr[i] + " ");
24 }
25 }
26}
27
拿着每一个元素都比较一遍，然后从大到小排列
我们再来一个更好用的
-2.冒泡排序
这个比较逻辑就更加效率了，相邻的两个元素进行比较，换位置
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
2public class HelloJJAVA {
3 // 公共的 静态 无返回值 main方法 数组
4 public static void main(String[] str) {
5
6 /**
7 * 冒泡排序
8 */
9 int[] arr = { 3, 6, 8, 74, 99, 12 };
10
11 for (int i = 0; i < arr.length - 1; i++) {
12 // 每一次比较的元素-1，避免角标越界
13 for (int j = 0; j < arr.length - i - 1; j++) {
14 if (arr[j] < arr[j + 1]) {
15 int temp = arr[j];
16 arr[j] = arr[j + 1];
17 arr[j + 1] = temp;
18 }
19 }
20 }
21 // 输出
22 for (int i = 0; i < arr.length; i++) {
23 System.out.print(arr[i] + " ");
24 }
25
26 }
27}
28
这样我们也可以输出
二.二维数组
说完了数组，我们又来了一个二维数组，数组中的数组，其实就是一个装数组类型的数组，这样说就比较清晰了
格式
- int [] [] arr = new int [3] [2] ;
- int [] [] arr = new int [ ] [2] ;
这是个小知识点，我们简单说一下
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
2public class HelloJJAVA {
3 // 公共的 静态 无返回值 main方法 数组
4 public static void main(String[] str) {
5
6 /**
7 * 二维数组的和
8 */
9
10 int[][] arr = { { 4, 6, 8 }, { 99, 22, 88 }, { 74, 36, 1 } };
11
12 int num = 0;
13
14 for (int i = 0; i < arr.length; i++) {
15 for (int j = 0; j < arr[i].length; j++) {
16 num = num + arr[i][j];
17 }
18 }
19 System.out.println("num:" + num);
20 }
21}
22
输出的结果
我们来个小练习
(选择题)int [] x,y [] ; //x是一维 y是二维
- a.x[0] = y; //error
- b.y[0]= x; //yes
- c.y[0][0] = x; //error
- d.x[0][0] = y; // error
- e.y[0][0] = x[0]; //yes
- f.x=y //error
三.面向对象
这篇博文其实到这里本该结束的，为了埋个伏笔，我再加点面向对象的思想，我们先理解一下面向对象的思想
-
面向对象是相对于面向过程而已
-
面向对象和面向过程都是一种思想
-
面向过程
-
强调的是功能行为
-
面向对象
-
讲功能封装进对象，强调具备了功能的对象
-
面向对象是基于面向过程的
这么说可能有点笼统，我们举个例子来说明
还记得那个故事吗，把大象放进冰箱里，这里分几步？
- 第一步：打开冰箱门
- 第二步：把大象放进去
- 第三步：关闭冰箱门
这个行为艺术，叫做过程，这个行为过程，我很强调过程，不管是大象还是小象，无所谓，打开，放进去，关上，这就是面向过程
而面向对象
只需要我们封装这个冰箱，那么那就有打开，存储，和关闭的功能，那么我们作用的就是冰箱这个对象了，我们直接面向他这样说，是不是有点空洞？我下篇博客会继续深入，生动的把这个思想给描绘出来，尽情期待！
