Java 数组基础
数组
数组（Array）：相同类型数据的集合。
定义数组
方式1（推荐，更能表明数组类型）
type[] 变量名 = new type[数组中元素的个数];
比如：
int[] a = new int[10];
数组名，也即引用a，指向数组元素的首地址。
方式2（同C语言）
type变量名[] = new type[数组中元素的个数];
如：
int a[] = new int[10];
方式3 定义时直接初始化
type[] 变量名 = new type[]{逗号分隔的初始化值};
其中红色部分可省略，所以又有两种：
int[] a = {1,2,3,4};
int[] a = new int[]{1,2,3,4};
其中int[] a = new int[]{1,2,3,4};的第二个方括号中不能加上数组长度，因为元素个数是由后面花括号的内容决定的。
数组运用基础
数组长度
Java中的每个数组都有一个名为length的属性，表示数组的长度。
length属性是public final int的，即length是只读的。数组长度一旦确定，就不能改变大小。
equals()
数组内容的比较可以使用equals()方法吗？
如下程序：
public class ArrayTest { public static void main(String[] args) { int[] a = {1, 2, 3}; int[] b = {1, 2, 3}; System.out.println(a.equals(b)); } }
输出结果是false。
所以证明不能直接用equals()方法比较数组内容，因为没有override Object中的实现，所以仍采用其实现，即采用==实现equals()方法，比较是否为同一个对象。
怎么比较呢？一种解决方案是自己写代码，另一种方法是利用java.util.Arrays。
java.util.Arrays中的方法全是static的。其中包括了equals()方法的各种重载版本。
代码如下：
import java.util.Arrays; public class ArrayEqualsTest { //Compare the contents of two int arrays public static boolean isEquals(int[] a, int[] b) { if( a == null || b == null ) { return false; } if(a.length != b.length) { return false; } for(int i = 0; i < a.length; ++i ) { if(a[i] != b[i]) { return false; } } return true; } public static void main(String[] args) { int[] a = {1, 2, 3}; int[] b = {1, 2, 3}; System.out.println(isEquals(a,b)); System.out.println(Arrays.equals(a,b)); } }
数组元素不为基本数据类型时
数组元素不为基本原生数据类型时，存放的是引用类型，而不是对象本身。当生成对象之后，引用才指向对象，否则引用为null。
如下列程序：
public class ArrayTest2 { public static void main(String[] args) { Person[] p = new Person[3]; //未生成对象时，引用类型均为空 System.out.println(p[0]); //生成对象之后，引用指向对象 p[0] = new Person(10); p[1] = new Person(20); p[2] = new Person(30); for(int i = 0; i < p.length; i++) { System.out.println(p[i].age); } } } class Person { int age; public Person(int age) { this.age = age; } }
输出：
null
10
20
30
也可以在初始化列表里面直接写：
Person[] p = new Person[]{new Person(10), new Person(20), new Person(30)};
二维数组
二维数组是数组的数组。
二维数组基础
基本的定义方式有两种形式，如：
type[][] i = new type[2][3];（推荐）
type i[][] = new type[2][3];
如下程序：
public class ArrayTest3 { public static void main(String[] args) { int[][] i = new int[2][3]; System.out.println("Is i an Object? " + (i instanceof Object)); System.out.println("Is i[0] an int[]? " + (i[0] instanceof int[])); } }
输出结果是两个true。
变长的二维数组
二维数组的每个元素都是一个一维数组，这些数组不一定都是等长的。
声明二维数组的时候可以只指定第一维大小，空缺出第二维大小，之后再指定不同长度的数组。但是注意，第一维大小不能空缺（不能只指定列数不指定行数）。
如下程序：
public class ArrayTest4 { public static void main(String[] args) { //二维变长数组 int[][] a = new int[3][]; a[0] = new int[2]; a[1] = new int[3]; a[2] = new int[1]; //Error: 不能空缺第一维大小 //int[][] b = new int[][3]; } }
二维数组也可以在定义的时候初始化，使用花括号的嵌套完成，这时候不指定两个维数的大小，并且根据初始化值的个数不同，可以生成不同长度的数组元素。
如下程序：
public class ArrayTest5 { public static void main(String[] args) { int[][] c = new int[][]{{1, 2, 3},{4},{5, 6, 7, 8}}; for(int i = 0; i < c.length; ++i) { for(int j = 0; j < c[i].length; ++j) { System.out.print(c[i][j]+" "); } System.out.println(); } } }
输出：
1 2 3
4
5 6 7 8
Java中怎样使用数组
数组是java编程语言的重要语法，使用数组可以解决很多问题，我们这篇文章给大家讲解怎样使用数组，对于刚接触编程的或者不会使用数组的同学们可以学习下。
步骤/方法
-
为什么需要数组。当我们定义一个变量时可以使用一个变量名表示，但是如果出现很多的变量我们分别起变量名代替表示存储就比较麻烦了，为了解决这样的问题我们采用数组的形式表示存储，使用下标表示每个变量。
-
生活中使用数组案例。生活中使用数组可以使商品等分类清楚明了，便于我们管理，数组也一样，相同类型的一类数据。
-
什么是数组。学习怎样使用数字之前我们简单介绍下什么是数组，便于我们使用数组。增加我们对数组的认识，了解数组的使用方法、
-
如何使用数组。我们学习了java中数组的定义和意思，但是怎么使用呢？我们在实验数组的时候使用关键字NEW进行实例化数组，才能使用，从第五步开始我们详细介绍。
-
使用前先声明数组。声明数组就是告诉计算机数据类型是什么。具体实现步骤如下
-
然后分配空间。分配空间就是告诉计算机分配几个连续的空间 。
-
最后给数组赋值。给数组赋值就是向分配的格子里放数据、
-
如何给数组赋值。上面我们介绍了给数组赋值，但是具体怎样赋值呢？一般有两种情况，也是最经常使用的情况，记住不要使数组的大小超过长度。
-
使用数组常见错误一。在大家编程时使用数组很容易出现错误，下面我们把常见的容易出错的地方给大家列举出来，大家学习下。
-
使用数组常见错误二。数组越界。
-
使用数组常见错误三。语法错误。
-
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-
-
数组：是一组相关变量的集合
数组是一组相关数据的集合，一个数组实际上就是一连串的变量，数组按照使用可以分为一维数组、二维数组、多维数组
数据的有点
不使用数组定义100个整形变量：int i1;int i2;int i3
使用数组定义 int i[100];
数组定义：int i[100];只是一个伪代码，只是表示含义的
一维数组一维数组可以存放上千万个数据，并且这些数据的类型是完全相同的，
使用java数组，必须经过两个步骤，声明数组和分配内存给该数组，
声明形式一
声明一维数组：数据类型 数组名[]=null;
非配内存给数组：数组名=new 数据类型[长度];
声明形式二
声明一维数组：数据类型 [] 数组名=null;java数据类型分为两大类
基本数据类型
int、long操作的时候本身就是具体的内容
引用数据类型：数组、类、接口引用传递的就是一个内存的使用权，一块内存空间，可能有多个人同时使用
事例声明数组
package com.qn.array;
public class Test {
publicstatic void main(String[] args) {
int score[]=null;//声明数组
score=newint[3];//开辟空间，大小为3
}
}
数组的声明格式里，数据类型是数组元素的数据类型，常见的有整形、浮点型、与字符型等
数组名是用来统一这组相同数据类型元素的名称，其命名规则和变量的相同
数组声明后实际上是在栈内存中保存了此数组的名称，结下了是要在堆内存中配置数组所需要的内存，齐产固定是告诉编译器，所声明的数组要存放多少个元素，而new则是命令编译器根据括号里的长度基本数据类型偶读有其默认值：int 0;只要是引用数据类型默认值就是null
事例
package com.qn.array;
public class Test {
publicstatic void main(String[] args) {
int score[]=null;//声明数组
score=newint[3];//开辟空间，大小为3
System.out.print("score[0]="+score[0]);
System.out.print("\tscore[1]="+score[1]);
System.out.print("\tscore[2]="+score[2]);
}
}
堆栈内存的解释
数组操作中，在栈内存中保存的永远是数组的名称，只开辟了栈内的空间，数组是永远无法使用的，必须有指向的对内存才可以使用，要想开辟新对内存空间必须使用new关键字，之后就是将对内存的使用权交给对应的栈内存，而且一个堆内存空间可以同时被多个栈内存空间指向，比如一个人可以有多个名字，人就相当于对内存，名字就相当于栈内存声明数组的同时分配内存空间
声明数组的同时非配内存
数据类型 数组名[]=new 数据类型[个数]
int score[]=new int[10];
声明一个元素个数为10的整形数组score，同时开辟依靠内存空间工期使用
java中，由于整形数据类型占用的空间为4个byte，而整个数组score可保存的元素有10个。所以上例中占用的内存共有4*10=40个字节
数组的访问 数组中元素的表示方法
想要访问数组里的元素可以利用索引来完成，java的数组索引标号由10开始，以一个score[10]的整形数组为例，score[0]代表第一个元素
一直向下，最后一个为score[9]
取得数组的长度
在java中取得数组的长度（也就是数组元素的长度）可以利用数组名称.length完成，
数组名称.length--返回一个int类型的数据package com.qn.array;
public class Test {
publicstatic void main(String[] args) {
int score[]=null;//声明数组
score=newint[3];//开辟空间，大小为3
System.out.println(score.length);
}
}
结果
数组的静态初始化
之前的数组，所采用的都是动态初始化，所有的内容在数组声明的时候并不具体的指定，而是以默认值的形式出现
静态初始化是指在数组声明后直接为数组指定具体的内容
如果想要直接在声明的时候给数组赋初始值，可以采用大括号完成，只要在数组的生命格式后面加上初值的赋值即可，
数据类型 数组名 []={初始值0,初始值1,初始值3，....初始值n};package com.qn.array;
public class Test {
publicstatic void main(String[] args) {
intscore[]={1,2,3,4,5,6};//使用静态初始化声明数组
System.out.println(score.length);
}
}
结果
6
范例求出数组中的最大值和最小值
package com.qn.array;
public class Test {
publicstatic void main(String[] args) {
intscore[]={45,12,8,23,89,56};//使用静态初始化声明数组
int max=0;
int min=0;
max=min=score[0];
for (int i = 0; i< score.length; i++) {
if(score[i]>max){
max=score[i];
}
if(score[i]
min=score[i];
}
}
System.out.println("最大值:"+max);
System.out.println("最小值:"+min);
}
}
结果
范例排序，在操作中排序是比较常用的
从大到小
package com.qn.array;
public class Test {
publicstatic void main(String[] args) {
intscore[]={45,12,8,23,89,56};//使用静态初始化声明数组
int temp=0;
for (int i = 0; i< score.length; i++) {
for (int j = 0; j< score.length-1; j++) {
if(score[i]>score[j]){
temp=score[i];
score[i]=score[j];
score[j]=temp;
}
}
}
for (int i = 0; i< score.length; i++) {
System.out.print(score[i]+"\t");
}
}
}
结果
这个时候不要被i值所迷惑if(score[i]>score[j]){ 这一步主要知识为了比较，实际上完成之后输出的时候是根据j的值排序的
二维数组
如果可以把一维数组当做几何中的一条线图形，那么二维数组就相当于一个表格
A B
1姓名 年龄
2齐宁 21
3齐燕 23
4齐威 26 二维数组声明的方式和以为数组的类似，内存分配也一样是用new这个关键字
其实声明与分配内存的格式如下
动态初始化
数据类型 数组名[][];
数组名=new 数据类型[行的个数][列的个数];声明并初始化数组
数据类型 数组名[][]=new 数据类型[行的个数][列的个数];
静态初始化
二维数组的存储
声明二维数组score 同时开辟一段内存空间
int score[][]=new int[4][3];
整体数据score可保存的元素是4*3=12个，在java中，int数据类型所占用的空间为4个字节，因此该整形数组占用的内存共为4*12=48个字节
事例package com.qn.array;
public class test1 {
public static void main(String[] args) {
int score[][] = newint[4][3];
score[0][1] = 30;
score[1][0] = 31;
score[2][1] = 32;
score[2][2] = 33;
score[3][1] = 34;
score[1][1] = 35;
for (int i = 0; i< score.length; i++) {
for (int j =0; j < score[i].length; j++) {
System.out.print(score[i][j]+"\t");
}
System.out.println("");
}
}
}
结果
二维数组静态初始化用到的时候才会开辟空间，不用的（红色部分）则不开辟空间
多维数组
一般只是用到二维数组
三维数组简单了解
package com.qn.array;
public class test1 {
public static void main(String[] args) {
int score[][][]={
{
{5,1},{6,7}
},
{
{9,4},{8,3}
}
};
System.out.print(score[0][0][0]+"\t");
System.out.print(score[0][0][1]+"\t");
System.out.print(score[0][0][0]+"\t");
System.out.print(score[0][0][1]+"\t");
System.out.print(score[1][0][0]+"\t");
System.out.print(score[1][0][1]+"\t");
System.out.print(score[1][1][0]+"\t");
System.out.print(score[1][1][1]+"\t");
}
}
扫一扫
307
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
