java 数组 控件 名称_Java数组

Java数组

1. 数组概述

相同类型的若干数据，按一定先后次序排列的有序集合

每个数据被称作一个数组元素，可通过他的下标来访问

2. 数组声明创建

声明与创建

首先声明数组变量

int[] aname;//首选方法

int aname[];

Java使用new操作符来创建数组

int[] aname = new int[size];

数组元素通过索引访问，数组索引从0开始

获取数组长度：arrays.length

内存分析

Java：

堆

存放new对象和数组

可以被线程共享，不会存放在别的对象引用

栈

存放基本数据类型

引用对象的变量，存放引用在堆地址

方法区

可以被线程共享

包含所有class和static变量

三种初始化

静态初始化

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

Man[] mans = {new Man(1,1),new Man(2,2)};

动态初始化

int[] a = new int[2];

a[0] = 1;

数组默认初始化

数组是引用类型，相当于类的实例变量，按同样方式隐式初始化。

数组四个基本特点

长度确定，大小不变

元素必须是相同类型

可任意类型

数组变量是引用类型，数组对象存放在堆中

数组下标越界

下标合法区间：[0,length-1],越界报错.

ArrayIndexOutOfBoundsException:数组下标越界异常

小结:

数组是相同类型有序集合

数组是对象

数组长度不可变，超出报越界异常

3. 数组使用

for each

数组作方法入参

数组作返回值入参

public static void main(String[] args) {

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

//1.for循环

// for (int i = 0; i

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

// }

//2.for each

// for (int array:arrays) {

// System.out.println(array);

// }

//3.调用入参方法

// printArray(arrays);

//4.数组作返回值

int[] reverse = reverse(arrays);

printArray(reverse);

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

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

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

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

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

}

}

}

//3.方法入参

public static void printArray(int[] arrays){

for (int array:arrays) {

System.out.println(array);

}

}

//4.数组作返回值

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

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

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

result[i] = arrays[arrays.length-i-1];

}

return result;

}

4. 多维数组

多维数组定义：可看成是数组的数组，二维数组是特殊的一维数组，其中每个元素都是一维数组。

int[][] a = new int[2][3];

5. Arrays类

数组工具类Arrays:java.util.Arrays

数组对象本身没什么方法，可调用Arrays类中的

查看java API手册

Arrays类中方法有static修饰，可直接调用

功能:

给数组赋值:fill

排序：sort,升序

比较数组：equals,比较数组中元素是否相等

查找数组元素：binarySearch,对已排序数组二分查找

public static void main(String[] args) {

int[] a = {1,2,3,87,2678,431,17,77899};

//System.out.println(a); //[I@531be3c5

//1.输出数组

//System.out.println(Arrays.toString(a)); //依次输出数组元素

//自写toString

//printArrays(a);

//2.升序排序

//Arrays.sort(a);

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

//3.填充

//Arrays.fill(a,0);

Arrays.fill(a,2,4,0);

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

//4.比较 ==与equals

int[] b = a;

System.out.println(a==b);

System.out.println(Arrays.equals(a,b));

Integer i1 = 128;

Integer i2 = 128;

System.out.println(i1==i2);

System.out.println(i1.equals(i2));

//5.二分查找

System.out.println(Arrays.binarySearch(a,17));

System.out.println(Arrays.binarySearch(a,77899));

}

public static void printArrays(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]+", ");

}

}

}

6. 稀疏数组

介绍：

一个数组大部分元素为0，或同一值可用稀疏算法

处理方式：

记录数组中一共几行几列，有多少个不同值

把巨头不通知的元素和行列及值记录在小规模数组中，从而缩小规模

//稀疏数组

//1.创建一个二维数组 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+"\t");

}

System.out.println();

}

//2.稀疏数组

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("======================================");

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

//打印稀疏数组

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]+"\t"+

array2[i][1]+"\t"+

array2[i][2]+"\t"

);

}

//3.还原

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();

}