Java–数组
1 容器概述
案例分析
现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有50名员工，用前面所学的知识，程序首先需要声明50个变量来分别记住每位员工的工资，然后在进行操作，这样做会显得很麻烦，而且错误率也会很高。因此我们可以使用容器进行操作。将所有的数据全部存储到一个容器中，统一操作。
容器概念
- **容器：**是将多个数据存储到一起，每个数据称为该容器的元素。
- **生活中的容器：**水杯，衣柜，教室
2 数组的概念
- 数组概念： 数组就是用于存储数据的长度固定的容器，保证多个数据的数据类型要一致。
百度百科中对数组的定义：
所谓数组(array)，就是相同数据类型的元素按一定顺序排列的集合，就是把有限个类型相同的变量用一个名字命名，以便统一管理他们，然后用编号区分他们，这个名字称为数组名，编号称为下标或索引(index)。组成数组的各个变量称为数组的元素(element)。数组中元素的个数称为数组的长度(length)。
数组的特点：
1、数组的长度一旦确定就不能修改
2、创建数组时会在内存中开辟一整块连续的空间。
3、存取元素的速度快，因为可以通过[下标]，直接定位到任意一个元素。
3 数组的声明与初始化
方式一：静态初始化
- 格式：
数据类型[] 数组名 = {元素1,元素2,元素3...};//必须在一个语句中完成，不能分开两个语句写
- 举例：
定义存储1，2，3，4，5整数的数组容器
int[] arr = {1,2,3,4,5};//正确
int[] arr;
arr = {1,2,3,4,5};//错误
方式二：静态初始化
- 格式：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
或
数据类型[] 数组名;
数组名 = new 数据类型[]{元素1,元素2,元素3...};
- 举例：
定义存储1，2，3，4，5整数的数组容器。
int[] arr = new int[]{1,2,3,4,5};//正确
int[] arr;
arr = new int[]{1,2,3,4,5};//正确
int[] arr = new int[5]{1,2,3,4,5};//错误的，后面有{}指定元素列表，就不需要在[长度]指定长度。
方式三：动态初始化
- 格式：
数组存储的元素的数据类型[] 数组名字 = new 数组存储的元素的数据类型[长度];
或
数组存储的数据类型[] 数组名字;
数组名字 = new 数组存储的数据类型[长度];
- 数组定义格式详解：
- 数组存储的元素的数据类型： 创建的数组容器可以存储什么数据类型的数据。
- 元素的类型可以是任意的Java的数据类型。例如：int, String, Student等
- [] : 表示数组。
- 数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。
- new：关键字，创建数组使用的关键字。因为数组本身是引用数据类型，所以要用new创建数组对象。
- [长度]：数组的长度，表示数组容器中可以存储多少个元素。
- 注意：数组有定长特性，长度一旦指定，不可更改。
- 和水杯道理相同，买了一个2升的水杯，总容量就是2升，不能多也不能少。
4 数组元素的访问
- 索引： 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。
- 索引范围：[0, 数组的长度-1]
- 格式：
数组名[索引]
- 索引访问数组中的元素：
- 数组名[索引]=数值，为数组中的元素赋值
- 变量=数组名[索引]，获取出数组中的元素
public static void main(String[] args) {
//定义存储int类型数组，赋值元素1，2，3，4，5
int[] arr = {1,2,3,4,5};
//为0索引元素赋值为6
arr[0] = 6;
//获取数组0索引上的元素
int i = arr[0];
System.out.println(i); //6
//直接输出数组0索引元素
System.out.println(arr[0]); //6
}
5 数组的遍历
- 数组的长度属性： 每个数组都具有长度，而且是固定的，Java中赋予了数组的一个属性，可以获取到数组的长度，语句为：
数组名.length，属性length的执行结果是数组的长度，int类型结果。由次可以推断出，数组的最大索引值为数组名.length-1。 - 数组遍历： 就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。
6 数组元素的默认值
当我们使用动态初始化创建数组时：
数组存储的元素的数据类型[] 数组名字 = new 数组存储的元素的数据类型[长度];
此时只确定了数组的长度，那么数组的元素是什么值呢？
数组的元素有默认值：
7 数组内存图
1 内存概述
内存是计算机中重要的部件之一，它是与CPU进行沟通的桥梁。其作用是用于暂时存放CPU中的运算数据，以及与硬盘等外部存储器交换的数据。只要计算机在运行中，CPU就会把需要运算的数据调到内存中进行运算，当运算完成后CPU再将结果传送出来。我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的，必须放进内存中才能运行，运行完毕后会清空内存。
Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。
2 Java虚拟机的内存划分
为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
| 区域名称 | 作用 |
|---|---|
| 程序计数器 | 程序计数器是CPU中的寄存器，它包含每一个线程下一条要执行的指令的地址 |
| 本地方法栈 | 当程序中调用了native的本地方法时，本地方法执行期间的内存区域 |
| 方法区 | 存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。 |
| 堆内存 | 存储对象（包括数组对象），new来创建的，都存储在堆内存。 |
| 虚拟机栈 | 用于存储正在执行的每个Java方法的局部变量表等。局部变量表存放了编译期可知长度的各种基本数据类型、对象引用，方法执行完，自动释放。 |
3 数组在内存中的存储
1、一个数组内存图
2、数组下标为什么是0开始
因为第一个元素距离数组首地址间隔0个单元。
3、两个数组内存图
4、两个变量指向一个数组
8 数组的常见算法
找最值及其所有最值的下标（即可能最大值重复）
思路：
（1）先找最大值
①假设第一个元素最大
②用max与后面的元素一一比较
（2）遍历数组，看哪些元素和最大值是一样的
示例代码：
int[] arr = {4,5,6,1,9};
//找最大值
int max = arr[0];
for(int i=1; i<arr.length; i++){
if(arr[i] > max){
max = arr[i];
}
}
//遍历数组，看哪些元素和最大值是一样的
for(int i=0; i<arr.length; i++){
if(max == arr[i]){
System.out.print(i+"\t");
}
}
9 冒泡排序
Java中的经典算法之冒泡排序（Bubble Sort）
原理：比较两个相邻的元素，将值大的元素交换至右端。
思路：依次比较相邻的两个数，将小数放到前面，大数放到后面。
即第一趟，首先比较第1个和第2个元素，将小数放到前面，大数放到后面。
然后比较第2个和第3个元素，将小数放到前面，大数放到后面。
如此继续，直到比较最后两个数，将小数放到前面，大数放到后面。
重复第一趟步骤，直至全部排序完成。
例如：冒泡：从小到大，从左到右两两比较
/*
{6,3,8,2,9,1}
第一轮：
第1次：arr[0]与arr[1]比较，6>3成立，就交换，{3,6,8,2,9,1}
第2次：arr[1]与arr[2]比较，6>8不成立，不交换{3,6,8,2,9,1}
第3次：arr[2]与arr[3]比较，8>2成立，就交换，{3,6,2,8,9,1}
第4次：arr[3]与arr[4]比较，8>9不成立，不交换{3,6,2,8,9,1}
第5次：arr[4]与arr[5]比较，9>1成立，就交换，{3,6,2,8,1,9}
第一轮结果：{3,6,2,8,1,9} 9已经到达正确位置，下一轮不用在参与
第二轮：
第1次：arr[0]与arr[1]比较，3>6不成立，不交换{3,6,2,8,1,9}
第2次：arr[1]与arr[2]比较，6>2成立，就交换，{3,2,6,8,1,9}
第3次：arr[2]与arr[3]比较，6>8不成立，不交换{3,2,6,8,1,9}
第4次：arr[3]与arr[4]比较，8>1成立，就交换，{3,2,6,1,8,9}
第二轮结果：{3,2,6,1,8,9} 8已经到达正确位置，下一轮不用在参与
第三轮：
第1次：arr[0]与arr[1]比较，3>2成立，就交换，{2,3,6,1,8,9}
第2次：arr[1]与arr[2]比较，3>6不成立，不交换{2,3,6,1,8,9}
第3次：arr[2]与arr[3]比较，6>1成立，就交换，{2,3,1,6,8,9}
第三轮结果：{2,3,1,6,8,9} 6已经到达正确位置，下一轮不用在参与
第四轮：
第1次：arr[0]与arr[1]比较，2>3不成立，不交换{2,3,1,6,8,9}
第2次：arr[1]与arr[2]比较，3>1成立，就交换，{2,1,3,6,8,9}
第四轮结果：{2,1,3,6,8,9} 3已经到达正确位置，下一轮不用在参与
第五轮
第1次：arr[0]与arr[1]比较，2>1成立，就交换，{1,2,3,6,8,9}
第五轮结果：{1,2,3,6,8,9} 2已经到达正确位置，下一轮不用在参与
剩下1，肯定是最小的了，不用比较了
6个元素，比较了5轮， n个元素需要n-1轮
每一轮比较很多次
*/
示例代码：
public static void main(String[] args){
int[] arr = {6,3,8,2,9,1}; //arr.length = 6
//i=1,2,3,4,5 一共5轮
for(int i=1; i<arr.length; i++){//轮数
/*
i=1，第1轮，j=0,1,2,3,4 arr[j]与arr[j+1]
i=2，第2轮，j=0,1,2,3 arr[j]与arr[j+1]
i=3，第3轮，j=0,1,2 arr[j]与arr[j+1]
i=4，第4轮，j=0,1 arr[j]与arr[j+1]
i=5，第5轮，j=0 arr[j]与arr[j+1]
j=0, j<=arr.length-1-i
*/
for(int j=0; j<=arr.length-1-i; j++){
if(arr[j] > arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
//结果
for(int i=0; i<arr.length; i++){
System.out.print(arr[i] + " ");
}
}
示例代码：从大到小，从右到左
char[] arr = {'h','e','l','l','o','j','a','v','a'};
for(int i=1; i<arr.length; i++){//外循环的次数 = 轮数 = 数组的长度-1
/*
第1轮，i=1，从右到左两两比较，arr[8]与arr[7]，arr[7]与arr[6]....arr[1]与arr[0]
第2轮，i=2，从右到左两两比较，arr[8]与arr[7]，arr[7]与arr[6]....arr[2]与arr[1]
...
第8轮，i=8，从右到左两两比较，arr[8]与arr[7]
arr[j]与arr[j-1]
找两个关键点：（1）j的起始值：8（2）找j的终止值，依次是1,2,3,。。。8，得出j>=i
*/
for(int j=8; j>=i; j--){
//从大到小，后面的元素 > 前面的元素，就交换
if(arr[j]>arr[j-1]){
int temp = arr[j];
arr[j] = arr[j-1];
arr[j-1] = temp;
}
}
}
冒泡排序优化
// 冒泡排序
public static void main(String [] args){
int [] arr = {70,60,50,40,30,20,10};//7
System.out.println("排序前："+java.util.Arrays.toString(arr)+"\n");
//排序的次数
for(int i = 0;i<arr.length-1;i++){
//进行每一次排序
for(int j = 0;j<arr.length-1-i;j++){//6
//当前一个数大于后一个数时 俩数交换位置
if(arr[j]>arr[j+1]){
//俩数交换位置
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
System.out.println("排序中："+java.util.Arrays.toString(arr));
}
System.out.println("\n排序后："+java.util.Arrays.toString(arr));
}
// 冒泡排序优化
public static void main(String [] args){
int [] arr = {40,30,20,10,50,60,70};//7
System.out.println("排序前："+java.util.Arrays.toString(arr)+"\n");
//排序的次数
for(int i = 0;i<arr.length-1;i++){
//假设此次排序数组已经有序
boolean flag = true;
//进行每一次排序
for(int j = 0;j<arr.length-1-i;j++){//6
//当前一个数大于后一个数时 俩数交换位置
if(arr[j]>arr[j+1]){
//俩数交换位置
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
//产生了前一个数大于后一个数的情况 此次排序 无序
flag = false;
}
}
if(flag){
break;
}
System.out.println("排序中："+java.util.Arrays.toString(arr));
}
System.out.println("\n排序后："+java.util.Arrays.toString(arr));
}
优化前：
优化后：
557
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
