多维数组决定数组中有多少列
package com.xiaojie.arrary;
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},{5,6},{4,5}}; //赋值二维数组
printArray(array[0]);
System.out.println(array[0][1]);
System.out.println(array[2][1]);
System.out.println(array[3][0]);
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]+" ");
}
System.out.println();
}
}
package com.xiaojie.arrary;
import java.util.Arrays;
public class ArrayDemo06 {
public static void main(String[] args) {
int[] a = {1,2,3,4,9090,1233,223,543};
System.out.println(a); //返回数组对象
//打印数组元组
System.out.println(Arrays.toString(a));
ArrayDemo06 arrayDemo06 = new ArrayDemo06();
arrayDemo06.prinArray(a);
Arrays.sort(a); //数组进行排序：升序
System.out.println(Arrays.toString(a));
}
//格式化打印数组
public void prinArray(int[] a) {
for (int i = 0; i < a.length; i++) {
if (i==0) {
System.out.print("[");
}
if (i==a.length-1) {
System.out.print(a[i]+"]
");
}else {
System.out.print(a[i]+", ");
}
}
}
}
package com.xiaojie.arrary;
import java.util.Arrays;
public class ArrayDemo07 {
public static void main(String[] args) {
int[] array = {10,1,5,23,534,231};
//输出数组
System.out.println(Arrays.toString(array));
//排序输出数组
Arrays.sort(array);
System.out.println(Arrays.toString(array));
//赋值输出数组
Arrays.fill(array,2,4,3); //从下标2开始到下标4结束（不包括结尾的下标），赋值为3
System.out.println(Arrays.toString(array)); //[1, 5, 3, 3, 231, 534]
//比较数组
int[] n = {1,2,3};
int[] i = {1,2,3,4,5,6,7,8};
int[] s = {3,2,1,33,11,643};
System.out.println(Arrays.equals(n,i));
//查找数组元素，需要先排序再查询
Arrays.sort(s);
System.out.println(Arrays.binarySearch(s , 33));
System.out.println(Arrays.binarySearch(s , 2,4,33)); //从下标2开始到下标4结束（不包括结尾的下标），是否有等于33的元素
}
}
package com.xiaojie.arrary;
//冒泡排序
//1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
//2.每一次比较，都会产生出一个最大，或者最小的数字
//3.下一轮则，可以少一次排序
//4.依次循环，直至结束
import java.util.Arrays;
public class ArrayDemo08 {
public static void main(String[] args) {
int[] a = {30,20,50,10,40,11,4,5,1};
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++) {
/*
外层循环-1是因为在此之前的前一个数值已经是内层循环的最小值（最少循环次数）
如果去掉-1，运行到内层循环时判断也是失败的，所以无需进行多余的判断
*/
boolean flag = false;
//内层循环，比值判断两个数，如何第一个数比第二个数大，则交换位置
for (int j = 0; j < array.length-1-i; j++) {
/*
内层循环-1是因为最后一个下标的前一个下标已经和最后一个下标相比较大小调整位置了
如果去掉-1循环到最后一个下标时，当前下标+1与当前下标相比较，是超出数组范围的
-i是因为内层循环运行开始直至判定失败，会从数组中选出最大的数值调整为最后的下标
由于已经选出最大数值调整到最后的下标，无需进行多余的循环，所以累计-1
*/
if (array[j+1]<array[j]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
flag = true;
}
}
if (flag == false) { //看似是优化，但在每次运行时会多出赋值与判断的操作
break;
}
}
return array;
}
}
简洁版
package com.xiaojie.arrary;
//冒泡排序
//1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
//2.每一次比较，都会产生出一个最大，或者最小的数字
//3.下一轮则，可以少一次排序
//4.依次循环，直至结束
import java.util.Arrays;
public class ArrayDemo08 {
public static void main(String[] args) {
int[] a = {4,2,1,5,3};
int[] array = (array(a));
System.out.println(Arrays.toString(array));
}
public static int[] array(int[] a) {
for (int i = 0; i < a.length-1; i++) {
int pem = 0;
for (int j = 0; j < a.length-1-i; j++) {
if (a[j]>a[j+1]) {
pem = a[j+1];
a[j+1] = a[j];
a[j] = pem;
}
}
}
return a;
}
}
package com.xiaojie.arrary;
public class ArrayDemo09 {
public static void main(String[] args) {
//1.创建一个二维数组 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+" ");
}
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];
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]+" "
+array2[i][1]+" "
+array2[i][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]; //根据稀疏数组的记录表还原值
}
//3.打印
System.out.println("输出还原的数组");
for (int[] ints : array3) {
for (int anInt : ints) {
System.out.print(anInt+" ");
}
System.out.println();
}
}
}