Day 6 数组
定义
相同类型数据的有序集合
按照一定的饭次序先后排序而成，每个数据：数据元素。通过下标来访问他们
创建和声明
data type []
数组索引从0开始
创建数组 使用new操作符
int[] =new int [10]
具体详看以下代码
package Array;
public class ArrayDemo1 {
//变量类型 变量名 = 变量值
//数组类型：类型[] //参数名
public static void main(String[] args) {
//代表数组类型
int[] nums; //定义: 首选方法
//创建数组
nums = new int[10]; //这里面可以存放10个int类型的数字
//数组元素中赋值
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;
内存分析
java内存构成： 堆，栈，方法去（可以被所有的线程共享，包含了所有的class和static变量）
声明数组—— 放入栈中
创建数组—— 放入堆中 声明和创建可以一起做
数组赋值—— 堆中也有值 没赋值的话默认值就是0
三种初始化
默认初始化
静态初始化：创建+赋值
动态初始化： 包含默认初始化
数组的长度是确定的，一旦被创建就无法更改
一个数组里是相同类型
下标是从0开始的
example:
package Array;
import java.util.Arrays;
public class ArrayDemo2 {
public static void main(String[] args) {
//静态初始化: 创建 + 赋值
int[] a = {1, 2, 3, 4, 5, 6, 7, 8}; // 花括号里就是代表数组
System.out.println(a[0]);
for(int i=0;i<a.length;i++){ //不能等于 ，因为会越界
System.out.println(a[i]);
}
//动态初始化 : 包含默认初始化
int[] b = new int[10];
b[0] = 10;
System.out.println(b[1]); //输出为0
}
}
下标越界
数组的合法区间： [0, 数组length -1]，如果超出就会报错：
ArrayIndexOutOfBoundsException: 数组下标越界异常
数组的运用——重要，看example
example:
package Array;
public class ArrayDemo3 {
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]);
}
System.out.println("___________________");
//算和
int sum = 0;
for (int i =0; i < arrays.length; i++){
sum = sum + arrays[i];
}
System.out.println("sum=" + sum);
//查找最大元素
int max = arrays[0];
for (int i =1; i < arrays.length; i++){
if(arrays[i]> max) {
max = arrays[i];
}
}
System.out.println("Max= "+max);
}
}
多维数组
数组嵌套数组，如：
二维数组
数组中的每个元素都是一堆数组
表示：
int a [] [] = new int [2] [5] ： 一个两行五列的数组
点击查看代码
package Array;
//多维数组： 类似于数组的嵌套
public class ArrayDemo5 {
public static void main(String[] args) {
// 三行两列
// array[0] array[1] array[2]
int[][] array = {{1, 2}, {2, 3}, {4,5}};
// printArray(array[0]); //输出 1，2
// System.out.println(array[2][1]); //输出 4
// System.out.println(array.length); //输出3
// System.out.println(array[0].length); //输出 2
for (int i =0; i< array.length; i++){
for(int j=0;j<array[i].length;j++){
System.out.println(array[i][j]);
}
}
}
}
Arrays 类
数组的工具类： java.util.Arrays
这是API中提供的一个工具类供我们使用，从而可以对数据对象进行一些基本的操作。
相当于是被人写好的方法，可以直接拿来用
功能
赋值： fill
排序： sort
比较： equals 数组内的元素值是否相等
查找： binarySearch 对排序好的数组进行二分查找法操作
具体看代码！！
点击查看代码
package Array;
import java.util.Arrays;
public class ArrayDemo6 {
//arrays 类// 三行两列
// // array[0] array[1] array[2]
// int[][] array = {{1, 2}, {2, 3}, {4,5}};
/// / printArray(array[0]); //输出 1，2
/// / System.out.println(array[2][1]); //输出 4
/// / System.out.println(array.length); //输出3
/// / System.out.println(array[0].length); //输出 2
// for (int i =0; i< array.length; o++){
//
// }
public static void main(String[] args) {
int[] a ={1, 2, 3, 7489, 8978, 37289,890};
System.out.println(a); //输出 [I@27716f4
//打印数组元素：Arrays.toString
System.out.println(Arrays.toString(a));
//自己做的查询：
printArray(a);
// 数组进行排序
Arrays.sort(a);
System.out.println(Arrays.toString(a));
//填充元素： 2,3,元素会被填充成0
Arrays.fill(a,2,4,0);
System.out.println(Arrays.toString(a));
}
public static void printArray(int[] a){}
}
冒泡排序
- 比较数组中两个相邻的元素，如第一个大于第二个，就交换位置
- 每次比较都会产生出一个最大或者最小的数字
- 下一轮则可以少一次排序
- 依次循环直至结束
具体详看代码！！
点击查看代码
package Array;
import java.util.Arrays;
public class ArrayDemo7 {
public static void main(String[] args) {
int[] a = {1,23456,89,976,987654,870965};
int[] sort = sort(a); //调用我们自己写的排序方法后，返回一个排序后的数组
System.out.println(Arrays.toString(sort));
}
// 冒泡排序：比较数组中两个相邻的元素，如第一个大于第二个，就交换位置
// 每次比较都会产生出一个最大或者最小的数字
// 下一轮则可以少一次排序
// 依次循环直至结束
public static int[] sort(int[] array){
//临时变量 用来进行存储
int temp = 0;
//外层循环：要走多少次
for(int i=0; i<array.length-1; i++){
//内层循环，如果第一个数大于第二个数，则交换位置
boolean flag = false; //减少没有意义的排序
for(int j=0; j < array.length-1-i; j++ ){
if(array[j]>array[j+1]){
//交换位置：
temp =array[j]; //把当前变量給临时变量
array [j]= array[j+1];
array[j+1]= temp;
flag = true;
}
}
if (flag == false){
break;
}
}
return array;
}
}
稀疏数组
当一个数组中大部分元素为0, 或者为同一值的数组的时候，可以用稀疏数组来保存该数组
处理方式
记录数组一共有几行几列，有多少不同的值
把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
我们表现出来的稀疏数组就是这个格式：第一排代表：行，列，值，下面就按照这个排序
//输出的稀疏数组如下：
11 11 2 代表：这个数列是11行 11列 2个值
1 2 1 代表：第1行第二列 值为1
2 3 2 代表： 第2行第3列，值为2
具体看代码！
点击查看代码
package Array;
public class ArrayDemo8 {
public static void main(String[] args) {
//创建一个二维数组 11* 11 0: 没有棋子 1.黑棋 2. 白棋
int[][] array1 = new int[11][11];
array1[1][2] =1;
array1[2][3] =2;
//输出原始的数组
System.out.println("输出原始的数组：");
for (int[] ints: array1){
for (int anInt: ints){
System.out.print(anInt + " \t");
}
System.out.println();
}
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);
//创建稀疏数组的数组
int[][] array2 = new int[sum+1][3];//行，列，值——总共三列，所以列是固定的
array2[0][0] = 11; //多少行
array2[0][1] = 11; //多少列
array2[0][2] = sum; //有几个有效的值 就是图片的第一行的东西
//遍历二维数组，将非零的值，存放到稀疏数组中
int count = 0;
for (int i =0; i <array1.length; i++){
for (int j =0; j <array1[i].length; j++){
if (array1[i][j] != 0){
count++;
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] = array1[i][j];
}
}
}
//输出稀疏数组
System.out.println("稀疏数组");
for (int i =0; i <array2.length; i++){
System.out.println(array2[i][0] + " \t"
+array2[i][1]+"\t"
+array2[i][2]+"\t");
}
System.out.println("________________");
System.out.println("还原");
//读取稀疏数组
// 行 列
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//给其中的元素还原它的值
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 anInt: ints){
System.out.print(anInt + " \t");
}
System.out.println();
}
}
}
posted on 2025-09-15 13:00 escapedlili 阅读(11) 评论(0) 收藏 举报
浙公网安备 33010602011771号