本文详细介绍了Java中的数组，包括定义、声明、创建、初始化、内存分析、数组特点、越界处理、for-each循环、作为方法参数及返回值、多维数组的使用、Arrays类的功能以及冒泡排序和稀疏数组的概念。内容涵盖数组的各个方面，是学习Java数组的全面指南。
目录
1、数组概述
数组的定义
- 数组是相同类型数据的有序集合。
- 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
- 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问他们。
2、数组声明创建
数组的三种声明方法
1.类型[] 变量名=new 类型[数组长度]；
2.类型[] 变量名=new 类型[]{元素1，元素2，元素3…}；
3.类型[] 变量名={元素1，元素2…}；
4.二维数组：
类型[][] 变量名=new 类型[数组长度] [数组每行长度]；
类型[][] 变量名=new 类型[数组长度] [ ]；
如：
int[] a=new int[100];
String[] b=new String[ ]{“ss”, “cd”, “bc”,… };
Object[] c={“Tom”,3,…};
int[][] s=new int[20] [ ];
-
首先必须声明数组变量，才能在程序中使用数组，下面是声明数组变量的语法：
dataType[] arrayRefVar;//首选方法 或者 dataType arrayRefVar[];//效果相同，但不是首选 -
Java语言使用new操作符来创建数组，语法如下：
dataType[] arrayRefVar= new dataType[数组长度]; -
数组的元素是通过索引访问的，数组索引从0开始。
-
获取数组的长度
arrays.length
public class Demo01 {
public static void main(String[] args) {
int[] a;//1.声明一个数组
a=new int[6];//2.创建一个可以包含6个数据的数组
for (int i = 0; i < a.length; i++) {
a[i]=i+5;
System.out.println(a[i]);
}
}
}
内存分析
-
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;
a[1]=2;
-
数组的默认初始化
- 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
public class Demo02 {
public static void main(String[] args) {
//静态初始化：创建+赋值
int[] a={1,2,6,9,8,7,55,3};//定义好后空间不可改变
//引用类型
Man[] mans={new Man(),new Man()};
//动态初始化
int[] b=new int[10];
b[0]=1;
b[1]=2;
System.out.println(b[3]);
System.out.println(a[6]);
}
}
下标越界及小结
数组的四个特点
-
其长度是确定的。数组一旦被创建，它的大小不可以被改变。
-
其元素必须是相同类型，不允许出现混合类型。
-
数组中的元素可以是任何数据类型，包括基本类型和引用类型
-
数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身实在堆中的。
数组越界
-
下标的合法区间：[0,length-1],如果越界就会报错；
public static void main(String[] args){ int[] a=new int[2]; System.out.println(a[2]); } -
ArrayIndexOutOfBoundsException:数组下标越界异常！
-
小结：
- 数组是相同数据类型（数据类型可以为任意类型）的有序集合
- 数组也是对象。数组元素相当于对象的成员变量
- 数组长度是确定的，不可变的。如果越界，则报：ArrayIndexOutOfBounds
3、数组使用
for-Each循环
public class Demo03 {
public static void main(String[] args) {
int[] arrays={1,2,3,4,5};
//fro-Each循环,JDk1.5才有，无下标
for (int array : arrays) {
//逐一遍历arrays中的数，array从0开始
System.out.println(array);
}
}
}
数组作为方法的参数&数组作返回值
public class Demo03 {
public static void main(String[] args) {
int[] arrays={1,2,3,4,5};
//for-Each循环
// for (int array : arrays) {
// System.out.println(array);
// }
printArray(arrays);
System.out.println("\n revers后:");
int[] reverse=reverse(arrays);
printArray(reverse);
}
//数组作为方法入参,打印数组元素
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+" ");
}
}
//反转数组，数组作为返回值
public static int[] reverse(int[] arrays){
int[] result=new int[arrays.length];
//反转的操作
/*方法一：
for (int i = 0; i < result.length; i++) {
result[result.length-(i+1)]=arrays[i];
}
*/
//方法二：
for (int i = 0, j=result.length-1; i < result.length ; i++,j--) {
result[i]=arrays[j];
}
return result;
}
}
4、多维数组
- 二维数组
int a[ ] [ ] =new int[ 2 ] [ 5 ];
a.length 2
a[ ].length 5
5、Arrays类
-
数组的工具类java.util.Arrays
-
由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本操作。
-
Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（是“不用”而不是“不能”）。
-
具有以下常用功能：
- 给数组赋值：通过fill方法
- 给数组排序：通过sort方法，按升序。
- 比较数组：通过equals方法比较数组中元素值是否相等。
- 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。
import java.util.Arrays;
public class Demo04 {
public static void main(String[] args) {
//二维数组
int a[][]= {{2,1,3,0,199},{9,9,5,3,1}};
System.out.println(a.length);//2
System.out.println(a[1].length);//5
//Arrays
int[] x={445,1,9,36,555,987,79,6};
System.out.println(x);//[I@16b98e56
//打印数组元素Arrays.toString()
System.out.println(Arrays.toString(x));
//数据排序：升序
Arrays.sort(x);
//打印
System.out.println(Arrays.toString(x));
//给数组赋值
Arrays.fill(x,1,3,333);
System.out.println(Arrays.toString(x));
//比较数组中元素值是否相等
System.out.println(Arrays.equals(a[1],x));
toPrint(x);
}
//重复造轮子（自己写了一个类似于toString的方法）
public static void toPrint(int a[]) {//static 方便调用
System.out.print("[");
for(int i=0;i<a.length;i++){
if(i==a.length-1){
System.out.print(a[i]);
}else {
System.out.print(a[i] + ", ");
}
}
System.out.println("]");
}
}
6、冒泡排序
import java.util.Arrays;
public class Demo05 {
public static void main(String[] args) {
int[] a={8,4,6,15,1,91};
//排序前
System.out.println("排序前"+Arrays.toString(a));
//调用冒泡排序
sort(a);
//排序后
System.out.println("排序后"+Arrays.toString(a));
}
//冒泡排序
public static int[] sort(int[] a){
int k=0;
for (int i = 0; i < a.length-1; i++) {//0 1 2 3【a.length=5】让所有数组按顺序归位最多需要4次
boolean flag=false;//通过flag标识位减少没有意义的比较
for (int j = 0; j < a.length-1-i; j++) {//4 3 2 1 0【=a.length-1-i】
if(a[j]>a[j+1]){
k=a[j];
a[j]=a[j+1];
a[j+1]=k;
flag=true;
}
}
//优化
if(flag==false){
break;
}
}
return a;
}
}
7、稀疏数组
-
当一个数组中大部分元素为0，或者为同一值得数组时，可以使用稀疏数组来保存该数组。
-
稀疏数组的处理方式是：
- 记录数组一共有几行几列，有多少个不同值
- 把具有不同值的元素和行列及值记录在一个小规模数组中，从而缩小程序的规模
-
public class Demo06 {
public static void main(String[] args) {
int[][] a=new int[11][11];
a[1][2]=1;
a[2][3]=2;
System.out.println("输出原始数组:");
for (int[] ints:a) {
for (int intss:ints) {
System.out.print(intss+"\t");
}
System.out.println();
}
//转换为稀疏数组保存
//1.获取有效值的个数
int sum=0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if(a[i][j]!=0){
sum++;
}
}
}
System.out.println("有效个数:"+sum);
//2.创建稀疏数组
int[][] xi=new int[sum+1][3];
xi[0][0]=a.length;
xi[0][1]=a[0].length;
xi[0][2]=sum;
//3.遍历二维数组，将非零值存入稀疏数组中
int k=1;//固定稀疏数组行号
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
if(a[i][j]!=0){
xi[k][0]=i;
xi[k][1]=j;
xi[k][2]=a[i][j];
k++;
}
}
}
//4.遍历稀疏数组
System.out.println("稀疏数组:");
for (int[] ints:xi) {
for (int intss:ints) {
System.out.print(intss+"\t");
}
System.out.println();
}
//还原
System.out.println("还原:");
//1.定义二维数组长度
int b[][]=new int[xi[0][0]][xi[0][1]];
//2.给还原数组赋值
for (int i = 0; i <xi.length ; i++) {
for (int j = 0; j <xi[i].length ; j++) {
if(i>0){
b[xi[i][0]][xi[i][1]]=xi[i][2];
}
}
}
//3.遍历还原后的棋盘
for (int[] ints:b) {
for (int intss:ints) {
System.out.print(intss+"\t");
}
System.out.println();
}
}
}
//运行结果
输出原始数组:
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
有效个数:2
稀疏数组:
11 11 2
1 2 1
2 3 2
还原:
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
扫一扫
288
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
