java数组= 0_Java数组的简单概括

Java数组

定义：相同类型数据的有序集合

声明：

int[] nums;

创建：

nums = new int[10];

声明加创建：(动态初始化(包含默认初始化))

int[] nums= new int[10];

获取数组长度：

int a = nums.length;

静态初始化：

int[] nums= {1,2,3,4,5,6,7,8};

数组的基本特点

长度确定

元素类型一致

元素类型不限

数组变量为引用类型，数组可看成对象，数组中的每个元素相当于该对象的成员变量

数组本身就是对象，Java保存在堆中

数组边界：[0,length-1]

数组的使用

For-Each循环

int[] a={1,2,3,4,5,6,7};

for (int i : a) {

System.out.println(i);

}

数组做方法入参

public static void main(String[] args) {

int[] a={1,2,3,4,5,6,7};

printArray(a);

}

public static void printArray(int[] arrays){

for (int i = 0; i < arrays.length; i++) {

System.out.println(arrays[i]);

}

}

数组做返回值(反转数组)

public static void main(String[] args) {

int[] arrays={1,2,3,4,5,6,7};

printArray(reverse(arrays));

}

//数组做方法入参

public static void printArray(int[] arrays){

for (int i = 0; i < arrays.length; i++) {

System.out.println(arrays[i]);

}

}

//数组反转

public static int[] reverse(int[] arrays){

int[] result = new int[arrays.length];

for (int i = 0,j=arrays.length-1; i < arrays.length; i++,j--) {

result[j]=arrays[i];

}

return result;

}

多维数组

定义

int[][] arrays = {{1,2},{2,3},{3,4},{4,5}};//二维数组

遍历二维数组

int[][] arrays = {{1,2},{2,3},{3,4},{4,5}};

for (int i = 0; i < arrays.length; i++)

{

for (int j = 0; j < arrays[i].length; j++){

System.out.println(arrays[i][j]);

}

}

Arrays类

打印数组元素:Arrays.toString()

自动排序(升序)：Arrays.sort()

等

冒泡排序

import java.lang.reflect.Array;

import java.util.Arrays;

public class Demo {

public static void main(String[] args) {

int[] array = {7,4,3,56,5,2,9};

int[] sort = sort(array);

System.out.println(Arrays.toString(sort));

}

public static int[] sort(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]

temp = array[j];

array[j] = array[j+1];

array[j+1] = temp;

}

}

}

return array;

}

}

稀疏数组

public class Demo99 {

public static void main(String[] args) {

//创建一个棋盘 11*11 0：没有棋子 ，1：黑棋 ，2：白棋

int[][] array = new int[11][11];

array[1][2]=1;

array[2][3]=2;

System.out.println("输出原始的数组");

for (int[] ints : array) {

for (int anInt : ints) {

System.out.print(anInt+"\t");

}

System.out.println(" ");

}

System.out.println("====================================");

//生成稀疏数组

//遍历有效值，得出稀疏数组的行数

int sum = 0;

for (int[] ints : array) {

for (int anInt : ints) {

if (anInt!=0){

sum++;

}

}

}

System.out.println("有效值为："+sum);

//创建稀疏数组

int[][] array2 = new int[sum+1][3];

array2[0][0]=array.length;

array2[0][1]=array.length;

array2[0][2]=sum;

int count = 0;

for (int i = 0; i < array.length; i++) {

for (int j = 0; j < array.length; j++) {

if (array[i][j]!=0){

count++;

array2[count][0]=i;

array2[count][1]=j;

array2[count][2]=array[i][j];

}

}

}

//遍历输出稀疏数组

for (int[] ints : array2) {

for (int anInt : ints) {

System.out.print(anInt+"\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];

}

for (int[] ints : array3) {

for (int anInt : ints) {

System.out.print(anInt+"\t");

}

System.out.println(" ");

}

}

}

----------------------------输出------------------------------------

输出原始的数组

00000000000

00100000000

00020000000

00000000000

00000000000

00000000000

00000000000

00000000000

00000000000

00000000000

00000000000

====================================

有效值为：2

11112

121

232

=====================================

00000000000

00100000000

00020000000

00000000000

00000000000

00000000000

00000000000

00000000000

00000000000

00000000000

00000000000