2.4 数组
目录
1. 数组的概述
- 数组是相同类型数据的有序集合
- 数组描述的是相同类型的若干个数据，按照一定的先后次序组合而成
- 每一个数据称为 一个数据元素，每个数组元素可以通过一个下标来访问它
2. 数组de创建声明
-
必须声明数组变量，才能在程序中使用数组
-
使用new操作来创建数组
-
数组的元素是通过索引来访问的，从0开始
-
获取数组的长度：
array.length
package com.kuang.array;
public class DefineArray {
public static void main(String[] args) {
// 变量的类型 变量的名字 = 变量的值
//1.声明一个数组 定义方法1
int[] nums;
//int num[]; 定义方法2 c/c++写法
//2. 创建一个数组
nums = new int[10];//开辟10个空间
//int[] nums = new int[10] 1.2.步合并写法
//给数组元素赋值
nums[0] = 1;
nums[1] = 2;
nums[2] = 3;
nums[3] = 4;
nums[4] = 5;
nums[5] = 6;
nums[6] = 7;
nums[7] = 8;
nums[8] = 9;
nums[9] = 10;
// System.out.println(nums[9]);
// 求和
int sum = 0 ;
for (int i = 0; i<nums.length; i++){
sum += nums[i];
}
System.out.println("总和为："+sum);
}
}
Java内存
数组的三种初始化方式：
-
静态初始化
-
动态初始化
-
默认初始化
数组是引用类型，他的元素相当于实例变量（类变量，实例变量，局部类变量），因此数组已经分配空间，其中每个元素也被按照实例变量同样的方式被隐式初始化（未被初始化的int为0，String为null）
package com.kuang.array; public class Initialize { public static void main(String[] args) { //1. 静态初始化： 创建+赋值 int[] a = {1,2,3,4,5}; System.out.println(a[4]); //2. 动态初始化 包括默认初始化 int[] b = new int[10]; b[0] = 3; b[5] = 4; System.out.println(b[0]); System.out.println(b[4]); // String 类型的初始值呢？ String[] c = new String[10]; System.out.println(c[4]); } }
数组的4个特点
- 其长度是确定的，一旦创建，大小不变
- 元素必须是相同类型，不许出现混合类型
- 数组中的元素类型任意，包括八大基本类型和引用类型
- 数组本身就是引用类型，也可以看成对象，数组中的每个元素就相当于该对象的成员变量。Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组本身是在堆中的
合法的数组下标区间 [0, array.length-1]
3. 数组使用
package com.kuang.array;
public class Apply {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
//逐个输出
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]);
}
//求和
int sum = 0;
for (int i = 0; i < arrays.length; i++) {
sum += arrays[i];
}
System.out.println(sum);
//找最大元素
int max = arrays[0];
for (int i = 0; i < arrays.length; i++) {
if (max < arrays[i])
max = arrays[i];
}
System.out.println("max:"+max);
}
}
package com.kuang.array;
public class PlusApply {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5,6,7};
//增强for,前部代表每一个元素，后部整个数组,最后输出里面填array，不用控制变量i
for (int array : arrays) {
System.out.println(array);
}
//调用下面方法是不用加中括号
//printLn(arrays);
reverse(arrays);
}
public static void printLn(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]);
}
}
//反转数组输出
public static void reverse(int[] arrays){
int result[] = new int[arrays.length];
for (int i = 0, j = result.length-1 ; i < arrays.length; i++) {
result[i] = arrays[j - i];
System.out.print(result[i]+" ");
}
}
}
4. 多维数组
多维数组可以看成数组的数组(线到面的变化)，比如二维数组就是一个特殊的一维数组，每一个元素都是一维数组。
int a[][] = new int[2][5];
Dimensional 维度
package com.kuang.array;
public class TwoDimensionalArray {
public static void main(String[] args) {
int[][] arrays = {{1,2},{3,4},{5,6}};
System.out.println(arrays[0]);
// 输出一个地址
// System.out.println(arrays.length);//输出二维数组长度
// System.out.println(arrays[0][0]);
// System.out.println(arrays[2][1]);
for (int i = 0; i <arrays.length;i++){
for (int j = 0; j < arrays[i].length; j++) { //用arrays[i].length表示内部长度
System.out.println(arrays[i][j]);
}
}
}
}
5. Arrays类
-
数组的工具类是java.util.Arrays
-
由于数组本身并没有什么方法可以供我们调用，但是在API中提供了一个工具类Arrays供我们使用
-
查看帮助jdk文档
-
Arrays 中的方法都是static修饰静态方法，可以直接用类名进行调用（而不用使用对象来调用。是不用而不是不能）
-
具有以下常用功能(时间不够不用重复造轮子)
- 给数组赋值：通过fill方法
- 对数组啊排序：sort
- 比较数组：equals
- 查找数组元素：binarySearch对排序好的用二分法查找
STL (Standard Template Lirary) 标准模板库
6. 冒泡排序
还可以不设中间变量实现交换
package com.kuang.arrays;
import java.util.Arrays;
public class MaoPaoPaiXu {
public static void main(String[] args) {
int[] a = {1,2,3,45,65,4355,34452,34};
Pao(a);
}
public static void Pao(int[] a){
for (int i = 0; i < a.length-1; i++) {//外层循环计数，将最大的数字扔到最后面
for (int j = 0; j < a.length-1-i; j++) {
//使用中间变量交换
// int temp = a[j];
// if(a[j] < a[j+1]){
// temp = a[j];
// a[j] = a[j+1];
// a[j+1] = temp;
// }
//不使用中间变量交换
if(a[j] < a[j+1]){
a[j] = a[j] + a[j+1];
a[j+1] = a[j] - a[j+1];
a[j] = a[j] - a[j+1];
}
}
}
System.out.println(Arrays.toString(a));
}
}
改良冒泡思路1：如果在任一次遍历中没有交换过顺序，那么以后也不需要交换顺序，冒泡终止。
bubble 气泡
package com.kuang.arrays;
public class BubbleSoerOpt1 {
public static void main(String[] args) {
int[] list = {5,4,3,1,2};
int temp = 0; // 开辟一个临时空间, 存放交换的中间值
// 要遍历的次数
for (int i = 0; i < list.length-1; i++) {
int flag = 1; //设置一个标志位
//依次的比较相邻两个数的大小，遍历一次后，把数组中第i小的数放在第i个位置上
for (int j = 0; j < list.length-1-i; j++) {
// 比较相邻的元素，如果前面的数小于后面的数，交换
if (list[j] < list[j+1]) {
temp = list[j+1];
list[j+1] = list[j];
list[j] = temp;
flag = 0; //发生交换，标志位置0
}
}
System.out.format("第 %d 遍最终结果：", i+1);
//遍历输出数组的 count：list
for(int count:list) {
System.out.print(count);
}
System.out.println("");
if (flag == 1) {//如果没有交换过元素，则已经有序
return;
}
}
}
}
7. 稀疏数组
需求引入：五子棋游戏，有存档和读档的功能
很多默认值都是0，倘若每个落子点都记录的话，会有很多无意义
解决：稀疏数组
介绍
-
当一个数组大部分为一个值或者0时，可以使用稀疏数组来保存该数组
-
稀疏数组的处理方式
- 记录数组有几行几列，有多少个不同值
- 把具有不同值的元素，行列和值记录在一个小规模数组中，从而缩小规模
-
如下图，左边为原始数组，右边为压缩后的稀疏数组：
介绍了存档，读档，复习了增强for循环
package com.kuang.arrays;
import javax.swing.plaf.IconUIResource;
public class UziChess {
public static void main(String[] args) {
//创建一个二维数组，11*11， 0：没有棋子 1：黑棋 2：白棋
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[1][3] = 2;
System.out.println("输出原始的数组:");
//IDEA 查找CTRL + F ；替换CTRL + R
for(int[] s:array1){
//上一段改良冒泡中有类似的增强for循环
// for(int count:list) {
// System.out.print(count);
// }
//为什么二维数组就是int[] s:array1呢？
for (int ss:s){
System.out.print(ss+"\t");
}
System.out.println();
}
//转换为稀疏数组
int sum = 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (array1[i][j] != 0) {
sum++;
}
}
}
System.out.println("稀疏数组的有效值个数为："+sum);
System.out.println("存档：");
//创建一个稀疏数组：
int[][] array2 = new int[sum+1][3];//因为数组下标是从0开始的，所以要sum+1
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//开始遍历
for (int count =0,i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[i].length; j++) {
if (array1[i][j] != 0){
count++;//倘若没有此，初始cocunt需要设为1
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] = array1[i][j];
}
}
}
//试着用增强for循环输出
//输出压缩后的稀疏数组
for (int[] ints:array2) {
for (int intss:ints){
System.out.print(intss+"\t");
}
System.out.println();
}
//1.读取稀疏数组
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//2.还原初始数组
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
//3.读档
System.out.println("读档：");
for (int[] ints:array3) {
for (int intss:ints){
System.out.print(intss+"\t");
}
System.out.println();
}
}
}
// 使用了center标签使得文本居中，然而页内跳转不能实现了 < center>markdown居中文本< /center>
浙公网安备 33010602011771号