Day13-01
P56 Java数组06：二维数组
二维数组：表示原来的一维数组中的每一个数变成一个数组就成了二维数组
package com.kuang.array;
public class ArrayDemo05 {
public static void main(String[] args) {
//[4][2] 四行两列
/*
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}};
System.out.println(array[0][0]);//输出1 （第0行第0列的数）
System.out.println(array[0][1]);//输出2 （第0行第1列的数）
System.out.println(array.length);//输出4 表示这个二维数组长度为4 也表示这个二位数组中有4个一维数组
System.out.println(array[0].length);//输出2 表示这个二维数组第0行长度为2 也表示这个二维数组第0行有2个数
System.out.println("========================");
//打印二维数组中的每个元素
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.println(array[i][j]);
}
}
System.out.println("==========================");
}
//打印数组元素的方法
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]+" ");
}
}
}
P57 Java数组07：Arrays类讲解
package com.kuang.array;
import java.util.Arrays;
public class ArrayDemo06 {
public static void main(String[] args) {
int[] a = {1,9,8,9,1,52,6,422};
System.out.println(a);//直接输出数组名称a: 输出[I@1b6d3586 所以不能这样直接输入数组名称来打印数组
//打印数组元素Arrays.toString() Arrays类中的 toString方法
System.out.println(Arrays.toString(a));//输出[1, 9, 8, 9, 1, 52, 6, 422]
System.out.println("=======================");
//使用自己做的方法打印数组，和Arrays类中的 toString方法效果一样，所以IDEA中的方法也是人写的
printArray(a);//输出[1, 9, 8, 9, 1, 52, 6, 422]
System.out.println("============================");
//Arrays类中的sort()方法 给数组内元素进行升序排序
Arrays.sort(a);
System.out.println(Arrays.toString(a));//输出[1, 1, 6, 8, 9, 9, 52, 422]
//Arrays类中的fill()方法 数组填充 把数组中元素变成指定值
Arrays.fill(a,0);//把数组中元素全变为0 或者叫做填充为0
System.out.println(Arrays.toString(a));//输出[0, 0, 0, 0, 0, 0, 0, 0]
int[] b = {1,9,8,9,1,52,6,422};
Arrays.fill(b,2,4,0);//表示把数组下标2到4之间的元素填充为0，注意是下标 下标是0，1，2....
System.out.println(Arrays.toString(b));//输出[1, 9, 0, 0, 1, 52, 6, 422]
}
//我们也可以写一个方法打印数组 像上面的Arrays类中的 toString方法一样
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]+", ");
}
}
}
}
//以下有的没有试，课下自己试试
//给数组赋值：通过fill方法
//对数组排序：通过sort方法，按升序
//比较数组：通过equals方法比较数组中元素值是否相等
//查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作
P58 Java数组08：冒泡排序
//狂神课上教的：
//冒泡排序
//1、比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
//2、每一次比较，都会产生出一个最大，或者最小的数字
//3、下一轮则可以少一次排序！
//4、依次循环，直到结束！
package com.kuang.array;
import java.util.Arrays;
public class ArrayDemo07 {
public static void main(String[] args) {
int[] a = {8,6,23,99,466,2,1,3,11};
int[] sor = sorts(a);//调用完自己写的排序方法后，返回一个排序后的数组
System.out.println(Arrays.toString(sor));//输出[466, 99, 23, 11, 8, 6, 3, 2, 1]
}
public static int[] sorts(int[] array){
//临时变量
int temp = 0;
//外层循环，判断我们这个要走多少次
for (int i = 0; i < array.length-1; i++) {
//内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置
for (int j = 0; j < array.length-1-i; j++) {
if (array[j+1]>array[j]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
return array;
}
}
//自己写的冒泡排序总结：
//冒泡排序：比如四个数组元素，
// 1、首先第一个数跟第二个数比大小，谁大谁往后排，
// *第一个数大与第二个数那么互换位置（不大于的话就不换位置），
// *此时排第二的数再跟排第三的数比大小，第二个数大于第三个数那么两个数换位置（否则就不换位置），
// *此时排第三的数在跟排第四的数比大小，第三个数大于第四个数那么两个数换位置（否则就不换位置），此时第一轮比大小结束，
// *此时排在最后的第四位必定是 最大的数（四个数里面）
// 2、此时等于说只需要把前三个数比大小排序就行了
// *第一个数和第二个数比大小，第一个数大与第二个数那么互换位置（不大于的话就不换位置），
// *此时排第二的数再跟排第三的数比大小，第二个数大于第三个数那么两个数换位置（否则就不换位置），此时第二轮比大小结束，
// *此时排在最后的第三位必定是 最大的数（前三个数里面)
// 3、此时等于说只需要把前二个数比大小排序就行了
// *第一个数和第二个数比大小，第一个数大与第二个数那么互换位置（不大于的话就不换位置），
// *此时排在最后的第二位必定是 最大的数（前二个数里面)
// 结束
// 总结：n个数排列，需要 “从头开始” 比较的次数为（n-1）次，第一次 “从头开始”过程中 内部两个数之间的比较次数为（n-1）次，以后每一次
// 的 “从头开始” 中两个数之间的比较次数减一次（比如第二次 “从头开始” 的过程中 两个数之间比较的次数为（n-2）次）
//就比较n-1次，或者说length-1次，
package com.kuang.array;
import java.util.Arrays;
public class MaoPaoPaiXu {
public static void main(String[] args) {
int[] arr = {9,5,31,56,885,31,35,89,633};
int[] so = sort(arr);//输入sort（arr）;表示使用sort方法 然后按alt + 回车 就返回一个数组
//调用完自己写的排序方法后，返回一个排序后的数组
System.out.println(Arrays.toString(so));//输出[5, 9, 31, 31, 35, 56, 89, 633, 885]
}
public static int[] sort(int[] array){
int a = 0;
for (int i = 0; i < array.length-1; i++) {
for (int j = 0; j < array.length-1-a; j++) {
if (array[j]>array[j+1]){
int t = 0;
t = array[j];
array[j] = array[j+1];
array[j+1] = t;
}
}
a = a + 1;
}
return array;
}
}
建议：如果忘了冒泡排序，可以搜搜冒泡排序动画看一下就清楚多了
P59 Java数组09：稀疏数组
右边蓝色的部分 【0】 6 7 8 表示存了一个6行7列的数组，里面有8个有效数字（不为0的数字，如22 15 17 -6 39 91 28 11 ；【1】0 3 22 表示第 1 个有效数字在第 0 行（因为数组从0开始） 第 3 列，值是22，同理以下几行以此类推
//根据上一张图片上的棋盘写一个稀疏数组：
package com.kuang.array;
public class ArrayDemo08 {
public static void main(String[] args) {
//1、创建一个二维数组 11*11 即11行11列的 0表示没有棋子 1表示黑棋 2表示白棋
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
//输出原始的数组
System.out.println("输出原始的数组");
//遍历一个二维数组，把二维数组输出出来 因为是二维数组所以两层for-each循环
//for-each遍历： for(数组内元素类型 元素变量 ：数组名字）
for (int[] ints : array1) { //二维数组内元素为一维数组int[] ints元素变量 arrays1是二维数组名字
for (int anInt : ints) { //一维数组ints内数组元素类型是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);
//2.创建一个稀疏数组的数组
int[][] array2 = new int[sum+1][3];//sum+1行 因为第0行表示二维数
// 组有几行几列所以要把这一行加上去 有几个有效个数就有几行所以一共是sum+1行，3列表示 行
// 列 值 这三行，看上一张图片上的蓝色表格参考
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//稀疏数组的第0行的三个值，分别是行数11 列数11 有效值个数sum
//遍历二维数组array1,将非零的值，存放稀疏数组中（把它的信息传到稀疏数组）参考图片上蓝色稀疏数组
int count = 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1.length; j++) {
if (array1[i][j]!=0){
count++;//count=count+1 稀疏数组第0行已经被占用了，所以非零值的信息从第一行开始存
array2[count][0] = i;//把非零值在array1的第几行i的值储存到这个位置
array2[count][1] = j;//把非零值在array1的第几列j的值储存到这个位置
array2[count][2] = array1[i][j];//把array1里第count个非零值赋值给稀疏数组第count行第2列
}
}
}
//输出稀疏数组
System.out.println("稀疏数组");
for (int i = 0; i < array2.length; i++) {//表示一行一行的输出，array2.length表示行数
System.out.println(array2[i][0]+"\t"+
array2[i][1]+"\t"+
array2[i][2]+"\t");
//因为稀疏数组只有三列，所以这里列数上是0 1 2 这三个数
}
System.out.println("=========================");
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];
}//可参考上面PPT图片上的蓝色稀疏数组样式和其左边的原二维数组样式
// 稀疏数组从第1行开始，（包括第一行）后边的几行存储的都是原二维数组的 行和列和值 的信息
//第0行储存的是原二维数组的行列数和有效值的个数，所以从第一行开始
//3.打印原二维数组
System.out.println("输出还原的二维数组");
//下面是打印二维数组的固定格式 记住即可 （是一个两层for-each循环的嵌套）（for-each循环常常遍历一维数组）
for (int[] ints : array3) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
