java数组价值_JAVA的数组

1. 数组的定义：

1.1 存放一组数据类型相同的变量；

1.2 声明/定义/初始化：元素数据类型[] 数组名 = new 元素数据类型[数组长度]；

1.3 数组名存放在栈中，数组本身是一个对象，数组对象本身存放在堆上。

1.3.1 如果只声明数组名时(int[] nums;)，栈中存放了数组名，但是堆中没有数组对象；

1.3.2 只有实例化数组对象时(nums = {1, 2, 3}; nums = new int[5];)，堆上开辟空间存放数组对象，数组名指向数组对象。

package com.langtao.array;

public class Demo2 {

public static void main(String[] args) {

int[] numbers = new int[10];

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

numbers[i] = i + 1;

}

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

System.out.println("numbers[" + i +"]=" +numbers[i]);

}

int[] array1 = {1, 2, 3};

Demo1[] d1 = {new Demo1(), new Demo1()};

}

}

2. 数组的使用

package com.langtao.array;

public class Demo3 {

public static void main(String[] args) {

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

printArray(arrayOriginal);

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

int[] reverseOriginal = reverseArray(arrayOriginal);

printArray(reverseOriginal);

System.out.println("====In the main method call the reverse method====");

reverseArray1(arrayOriginal);

for (int i : arrayOriginal) {

System.out.println(i);

}

System.out.println("====In the main method call the reverse method====");

}

public static void printArray(int[] array){

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

System.out.print(array[i] + " ");

}

}

public static int[] reverseArray(int[] array){

int[] reverseArray = new int[array.length];

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

reverseArray[i] = array[reverseArray.length - i - 1];

}

return reverseArray;

}

public static void reverseArray1(int[] array){

int tmp = 0;

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

tmp = array[i];

array[i] = array[array.length - i - 1];

array[array.length - i - 1] = tmp;

}

System.out.println("====In the method====");

for (int i : array) {

System.out.println(i);

}

System.out.println("====In the method====");

}

}

3.二维数组

package com.langtao.array;

public class Demo4 {

public static void main(String[] args) {

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

printArray(array2[0]);

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

printArray(array2);

}

public static void printArray(int[] array){

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

System.out.print(array[i] + " ");

}

}

public static void printArray(int[][] array){

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

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

System.out.print(array[i][j] + " ");

}

System.out.println();

}

}

}

4. 冒泡排序

package com.langtao.array;

import java.util.Arrays;

public class Demo5 {

public static void main(String[] args) {

int[] a = {1, 3, 2, 5, -1, 23, 6};

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

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

// Arrays.sort(a);

// System.out.println(Arrays.toString(a));

sort1(a);

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

sort1(b);

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

}

public static void sort1(int[] array){

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

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

if (array[j] > array[j + 1]){

int tmp = array[j];

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

array[j + 1] = tmp;

}

}

}

}

}

5.稀疏数组

package com.langtao.array;

import java.util.Arrays;

/*

* The sparse array is used to compress the array which has only limited unequal values comparing to the majority ones.

* For example, the original array can be like this:

* 0 0 0 0 0

* 0 1 0 0 0

* 0 0 2 0 0

* 0 0 0 0 0

* 0 0 0 0 0

* 0 0 0 0 0

* We can compress this array into a sparse array as:

* 6 5 2

* 1 1 1

* 2 2 2

* In the first line of the array, we record the size and non-zero elements. Then in the second row, we record the first

* non-zero element's coordinates and value and in the next lines we record the same information.

* Then you can transform the sparse array back to the original array.

* */

public class Demo6 {

public static void main(String[] args) {

int[][] array = new int[6][5];

array[1][2] = 1;

array[2][3] = 2;

array[1][1] = 99;

printArray(array);

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

int[][] sparseArray = sparseArray(array);

printArray(sparseArray);

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

int[][] originalArray = reverseSparseArray(sparseArray);

printArray(originalArray);

}

public static void printArray(int[][] array){

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

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

System.out.print(array[i][j] + " ");

}

System.out.println();

}

}

public static int[][] sparseArray(int[][] array){

//get the numbers of non-zero values in the original array.

int count = 0;

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

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

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

count++;

}

}

}

/*

In the first row of the sparse array, it records the size of the original array and the

total number of the non-zero elements.

*/

int[][] sparseArray = new int[count + 1][3];

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

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

sparseArray[0][2] = count;

int index = 1;

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

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

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

sparseArray[index][0] = i;

sparseArray[index][1] = j;

sparseArray[index][2] = array[i][j];

index++;

}

}

}

return sparseArray;

}

public static int[][] reverseSparseArray(int[][] array){

int row = array[0][0];

int colume = array[0][1];

int[][] reverseSparseArray = new int[row][colume];

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

int realRow = array[i][0];

int realColume = array[i][1];

reverseSparseArray[realRow][realColume] = array[i][2];

}

return reverseSparseArray;

}

}