Java数组之Arrays类
学习Demo
-
数组的工具类 java.util.Arrays
Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对象来调用(注意:是"不用"而不是"不能")
-
具有以下常用功能
- 给数组赋值：通过 fill 方法
- 对数组排序：通过 sort 方法【升序】
- 比较数组：通过 equals 方法比较数组中元素值是否相等
- 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作
码上行动
package array;
import java.util.Arrays;
/**
* 数组的工具类 java.util.Arrays
* Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对象来调用(注意:是"不用"而不是"不能")
* 具有以下常用功能：
* 1. 给数组赋值：通过 fill 方法
* 2. 对数组排序：通过 sort 方法【升序】
* 3. 比较数组：通过 equals 方法比较数组中元素值是否相等
* 4. 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作
*/
public class ArrayDemo4 {
public static void main(String[] args) {
int[] a = {
1,2,3,4,9090,31231,543,21,3,23};
//打印数组
System.out.println(a); //哈希code
//工具类 打印数组 Arrays.toString方法返回指定数组内容的字符串表示形式。
System.out.println(Arrays.toString(a));
System.out.println("----------- 分隔符 ------------");
//手撸 打印数组
printArray(a);
System.out.println("----------- 分隔符 ------------");
//工具类 数组进行排序
Arrays.sort(a);
//打印排序后的数组
System.out.println("排序后的数组为：" + Arrays.toString(a));
System.out.println("----------- 分隔符 ------------");
//工具类 数组进行赋值
Arrays.fill(a, 0); //给a这个数组赋值为0
//打印赋值后的数组
System.out.println("赋值后的数组为：" + Arrays.toString(a));
}
//输出数组 重复造轮子
public static void printArray(int[] a){
for (int i = 0; i < a.length; i++) {
if (i == 0) {
System.out.print("[");
}
if (i == a.length - 1) {
System.out.println(a[i] + "]");
}else {
System.out.print(a[i] + ", ");
}
}
}
}
Java数组之多维数组
学习Demo
码上行动
package array;
/**
* 多维数组：数组中嵌入数组
*/
public class ArrayDemo3 {
public static void main(String[] args) {
/*
1,2 array[0]
2,3 array[1]
3,4 array[2]
4,5 array[3]
*/
int[][] array = {
{
1,2},{
2,3},{
3,4},{
4,5}};
//打印数组元素
printArray(array[0]);
System.out.println("----------- 分隔符 ------------");
System.out.println(array[0][0]);
System.out.println("----------- 分隔符 ------------");
System.out.println(array[0][1]);
System.out.println("----------- 分隔符 ------------");
//嵌套for循环遍历元素
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.println(array[i][j]);
}
}
}
//打印数组元素
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i] + "\n");
}
}
}
Java数组之基础篇
学习Demo
码上行动
package array;
/**
* 数组基础篇
*/
public class ArrayDemo1 {
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 += arrays[i]; //sum = sum + arrays[i];
}
System.out.println("所有元素的和为：" + sum);
System.out.println("------------- 分割符 --------------");
//查找数组中的最大元素
int max = arrays[0];
for (int i = 1; i < arrays.length; i++) {
if (arrays[i] > max) {
max = arrays[i];
}
}
System.out.println("最大元素为：" + max);
}
}
Java数组之稀疏数组
学习Demo
稀疏数组
实例：五子棋游戏。数字1表示黑棋，数字2表示白棋，数字0表示空闲点位，棋盘为 11行 * 11列
- 需求：编写五子棋游戏中，有存盘退出和续上盘的功能。
- 分析问题：因为该二维数组的很多值是默认值0，因此记录了很多没有意义的数据【有效数据只有黑白棋】
- 解决：稀疏数组
码上行动
package array;
/**
* 稀疏数组
* 实例：五子棋游戏。数字1表示黑棋，数字2表示白棋，数字0表示空闲点位，棋盘为 11行 * 11列
* 1. 需求：编写五子棋游戏中，有存盘退出和续上盘的功能。
* 2. 分析问题：因为该二维数组的很多值是默认值0，因此记录了很多没有意义的数据【有效数据只有黑白棋】
* 3. 解决：稀疏数组
*/
public class ArrayDemo6 {
public static void main(String[] args) {
/*
创建一个二维数组
11 * 11(11行乘11列的棋盘)
0：没有棋子
1：黑棋
2：白棋
*/
int[][] array1 = new int[11][11];
array1[1][2] = 1; //在第二行第三列落一个黑棋
array1[2][3] = 2; //在第三行第四列落一个白棋
//输出原始数组
System.out.println("-------------- 原始数组如下 ---------------");
//foreach遍历输出原始数组
for (int[] ints : array1) {
for (int anInt : ints) {
System.out.print(anInt + "\t");
}
System.out.println(); //换行
}
/*
转换为稀疏数组保存
1. 获取有效值的个数
2. 创建一个稀疏数组
3. 给稀疏数组赋值
4. 输出稀疏数组
*/
//计算有效值个数
System.out.println("-------------- 有效值个数如下 ---------------");
//1. 获取有效值的个数
int sum = 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (array1[i][j] != 0) {
//不为0则为有效值
sum++;
}
}
}
System.out.println("有效值的个数为：" + sum);
//2. 创建一个稀疏数组
int[][] array2 = new int[sum + 1][3]; //行：有效值的个数加1 列：固定3列
//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) {
//不为0则为有效值
count++; //计数
array2[count][0] = i; //横坐标
array2[count][1] = j; //纵坐标
array2[count][2] = array1[i][j]; //有效值
}
}
}
//4. 输出稀疏数组
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("-------------- 还原数组如下 ---------------");
/*
还原数组
1. 读取稀疏数组
2. 给其中的元素还原它的值
3. 打印
*/
//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. 打印
for (int[] ints : array1) {
for (int anInt : ints) {
System.out.print(anInt + "\t");
}
System.out.println();
}
}
}