Java数组
数组概述
数组：相同类型数据的有序集合
其中每个数据是一个数组元素，每个数组元素可以通过一个下标来访问，{1，2，3，4，。。。}，{*,&,%,#,…}
数组一旦创建，其长度不可以再改变
数组中的元素可以为任何数据类型，包括基本类型和引用类型
数组变量属于引用类型，数组也可以看成是对象，数组中每个元素相当于该对象的成员变量
数组本身就是对象，Java中对象是在堆中的。
数组也可以看成是对象（也是通过new创建的），数组中每个元素相当于该对象的成员变量：用length或.xxx可以取出其中成员。
数组声明与创建
先声明数组变量，才能使用
dataType[] arrayRefvar; //首选方法
//或
dataType arrayRefVar[];//效果相同
使用new来创建数组：
dataType[] arrayRefVar = new dataType[ size ];
变量类型（数组） 数组名称 = new 数组类型[长度]
数组一旦创建，长度不可改变。
package Array;
public class Demo1 {
public static void main(String[] args) {
int[] nums;//声明了数组为int类的数组
nums = new int[6];//创建了nums数组
//等价于
int[] num = new int[3];//直接定义了num数组
}
}
以上为动态初始化
静态初始化：
package Array;
public class Demo2 {
public static void main(String[] args) {
//静态初始化
int a[] = {1,2,3,5};//创建+赋值，一旦创建后空间大小不可再改变
//引用数组：
Man[] man = {new Man(),new Man()};
//动态初始化：包含默认初始化
int b[] = new int[10];//空间大小已定，且此时未赋值，都是默认值0
}
}
数组使用
数组的长度：数组名.length
普通for循环
package Array;
public class Demo1 {
public static void main(String[] args) {
int[] nums;//1.声明数组
nums = new int[6];//2.创建数组
nums[0] = 10;
nums[1] = 33;//3.给数组赋值
int[] num = new int[3];
}
}
例：数组的数求和：
public class Demo1 {
public static void main(String[] args) {
int[] nums;//1.声明数组
nums = new int[3];//2.创建数组，3为长度，共3个数，下标截止到2
nums[0] = 10;
nums[1] = 33;//3.给数组赋值
nums[2] = 1;
int a = 0;
for (int i = 0; i < nums.length; i++) {
a = nums[i]+a;//数组长度为循环次数，每次依次按循环的次数——即数组下标，来循环遍历数组
}
System.out.println(a);
//输出为44
package Array;
public class Demo3 {
public static void main(String[] args) {
int arrays[] = {5,4,3,2,1};
//打印数组
for (int i = 0; i <arrays.length; i++) {
System.out.println(arrays[i]);
}
//计算所有数组和
int sum= 0;
for (int i = 0; i <arrays.length ; i++) {
sum+=arrays[i];
}
System.out.println(sum);
//查找最大元素
int max = arrays[0];
for (int i = 0; i < arrays.length; i++) {
if (max<arrays[i]){
max = arrays[i];
}
}
System.out.println(max);
}
}
for-each循环
增强型循环：（与python一致）
for(数据类型 a : 数组){
}
直接用a遍历数组里的每个元素，而不是遍历下标
package Array;
public class Demo4 {
public static void main(String[] args) {
int a[] = {3,4,6,7,8};
for (int x : a){
System.out.println(x);
}//此处x遍历的为a内的每个元素值（3，4，5，6，7），而非下标（0，1，2，3，4）
}
}
输出为：
3
4
6
7
8
数组作方法入参
package Array;
public class Demo4 {
public static void main(String[] args) {
int a[] = {3,4,6,7,8};
print(a);
}
public static void print(int array[]){
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]+" ");
}//将数组作为自定义方法的参数
}
}//输出：3 4 5 6 7
数组作返回值
package Array;
public class Demo4 {
public static void main(String[] args) {
int a[] = {3,4,6,7,8};
int b[] = reverse(a);//将reverse方法的返回的数组赋值给b
print(b);//用print方法打印反转后的数组
}
public static void print(int array[]){
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]+" ");
}
}
//反转数组：将原数组反转并返回
public static int[] reverse(int array[]){
int m[] = new int[array.length];//创建一个一样长的数组
for (int i = 0; i < array.length; i++) {
m[i] = array[array.length-1- i];
}
return m;//数组作为返回值
}
}
public static int[] fangfa(int array[]){
int m[];
return m; //返回数组
}
多维数组
可以视作由数组构成的数组
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hxgs3JEU-1608347608815)(F:\MarkDown\二维数组.png)]
二维数组
package Array;
public class Demo5 {
public static void main(String[] args) {
int[][] array = {{3,4,5},{6,7,8},{2,3}};
System.out.println(array[0]);//输出为[I@1b6d3586，为内存中的地址
}
}
package Array;
public class Demo5 {
public static void main(String[] args) {
int[][] array = {{3,4,5},{6,7,8},{2,3}};
System.out.println(array[0]);
for (int i = 0; i <array[0].length ; i++) {
System.out.print(array[0][i]);
}
}//输出为3 4 5
}
package Array;
public class Demo5 {
public static void main(String[] args) {
int[][] array = {{3,4,5},{6,7,8},{2,3}};
System.out.println(array[0]);
for (int i = 0; i <array.length ; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.println(array[i][j]);
}
}
}//依次输出
}
Arrays类
数据的工具类：java.util.Arrays
看源码：import java.util.Arrays; 选中Array，然后按住CTRL点击
package Array;
import java.util.Arrays;
public class Demo6 {
public static void main(String[] args) {
int a[] = {23,3554545,4523452,23,3466767,988923};
System.out.println(a);
//输出为[I@1b6d3586，为HashCode
//用Arrays的方法直接打印数组元素:
System.out.println(Arrays.toString(a));
//输出：[23, 3554545, 4523452, 23, 3466767, 988923]
Arrays.sort(a);//用Arrays的方法对a排序并更新，且升序
System.out.println(Arrays.toString(a));
//重新打印排序后的a
}
}
//填充数组
Arrays.fill(a,88);//将所有位置都赋值88
System.out.println(Arrays.toString(a));
//输出为[88, 88, 88, 88, 88, 88]
Arrays.fill(a,0,2,4);//第0-2个位置被4填充
System.out.println(Arrays.toString(a));
Arrays用法要根据帮助文档来查看，自行使用。
稀疏数组
是一种数据结构
二维数组很多值是默认值0，因此记录了很多无用的信息。
稀疏数组：首先记录行列数据，几行几列，有多少个不同值
把具有不同值的元素和行列及值记录在小规模数组中
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5Mk7sXyp-1608347608818)(F:\MarkDown\稀疏数组.jpg)]
不同值的元素单独用坐标（行列）确定其位置
package Array;
public class Demo8 {
public static void main(String[] args) {
//创建一个11*11的二维空数组，0：没有棋子，1：黑棋，2：白棋
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
System.out.println("输出原始数组：");
for (int[] a : array1){//遍历第一维
for (int b :a){//遍历第二维
System.out.print(b+"\t");
}
System.out.println();
}
//转换为稀疏数组
//1.获取有效值的个数
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++;
}
}
}
//2.创建稀疏数组
int[][] array2 = new int[count+1][3];
array2[0][0] = array1.length;
array2[0][1] = array1[0].length;
array2[0][2] = count;
int num = 0;
for (int i = 0; i <array1.length ; i++) {
for (int j = 0; j <array1[0].length ; j++) {
if (array1[i][j]!=0){
num++;
array2[num][0] = i;
array2[num][1] = j;
array2[num][2] = array1[i][j];
}
}
}
//3.输出稀疏数组
for (int i = 0; i < array2.length; i++) {
for (int j = 0; j <array2[0].length ; j++) {
System.out.print(array2[i][j]+"\t");
}
System.out.println();
}
}
}
//输出：
11 11 2 //第一行为原数组行数列数及非零值个数
1 2 1 //第二行第三列，值为1
2 3 2
11 11 2 //第一行为原数组行数列数及非零值个数
1 2 1 //第二行第三列，值为1
2 3 2
//将稀疏数组还原：
//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.打印稀疏数组
for (int[] a :array3){
for (int b:a){
System.out.print(b+"\t");
}
System.out.println();
}
创建不定长度的数组：
自行拓展：
扫一扫
5925
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
