数组概述和特点
数组的定义:数组是相同类型数据的有序集合,数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们。
数组的四个基本特点:
1.其长度是确定的。数组一旦被创建,它的大小就是不饿改变的。
2.其元素必须是相同类型,不允许出现混合类型。
3.数组中的元素是任何数据类型,包括基本类型和引用类型。
4.数组变量属引用类型,数组也恶意看成是对象,数组中的每个元素相当于该对象的成员变量。数组本身就是对象,Java中对象是在堆中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。
创建数组和初始化
声明(一维数组的声明方式有两种)
type[] arr_name; 推荐使用
type arrname[];
ps:
1.声明的时候并没有实例化任何对象,只有在实例化数组对象时,JVM才分配空间,这时才与长度有关。因此,声明数组时不能指定其长度(数组中元素的个数),例如:int a[5]//这是错误的
2.声明一个数组的时候并没有数组被真正的创建。
3.构造一个数组,必须指定长度。
构建数组:
创建基本类型一维数组示例:
pulbic class Test{
public static void main(String[] args){
int[] s=null; //1
s=new int[10]; //2
for(int i=0;i<10;i++){
s[i]=2*i+1;
System.out.println(s[i]);
} //3
}
}
创建引用类型一维数组示例:
class Man{
private int age;
private int id;
public Man(int age,int id){
super();
this.age=age;
this.id=id;
}
}
public class AppMain{
public static void main(String[] args){
Man[] mans;
mans=new Man[10]; //1
Man m1=new Man(1,11);
Man m2=new Man(2,22); //2
mans[0]=m1;
mans[1]=m2; //3
}
}
示例2:
public class Man {
private int age;
private int id;
public Man(int age,int id) {
super();
this.age=age;
this.id=id;
}
public String toString() {
return age+","+id;
}
}
public class Test {
public static void main(String[] args) {
Man[] mans=new Man[3];
mans[0]=new Man(1,11);
mans[1]=new Man(2,22);
System.out.println(mans[0]);
System.out.println(mans[1]);
}
}
初始化
静态初始化
除了用new关键字来产生数组以外,还可以直接定义数组的同时就为数组元素分配空间并赋值。
int[] a={1,2,3};
Man[] mans2={new Man(3,33),new Man(4,44)};
System.out.println(mans2[0]);
System.out.println(mans2[1]);
动态初始化
数组定义与为数组元素分配空间并赋值的操作分开进行。
int[] a=new int[2];
a[0]=1;
a[1]=2;
数组的默认初始化:
数组是引用类型,它的元素相当于类的实例变量,因此数组一经分配空间,其中的每个元素也被按照实例变量同样的方式被隐式初始化。
int[] a=new int[2];//0,0
boolean[] b=new boolean[2];//false,false
String[] s=new String[2];//null,null
数组的界限
1.下标的合法区间;【0,length-1】
* 1. 数组是相同数据类型(数据类型可以为任意类型)的有序集合
* 2. 数组也是对象。数组元素相当于对象的成员变量(详情请见内存图)
* 3. 数组长度的确定的,不可变的。如果越界,则报:ArrayIndexOutofBoundsException
数组常见操作
数组的拷贝
System类里也包含了一个static void arraycopy(Object src,int srcpos,Object dest,int destpos,int length)方法,该方法可以将src数组里的元素赋值给dests数组的元素,其中srcpos指定从src数组的第几个元素开始赋值,length参数指定将src数组的多少个元素赋给dest数组的元素。
String[] s={"Mircosoft","IBM","Sun","Oracle","Apple"};
String[] Sbak=new String[6];
System.out.println(s,0,sba,0,s.length);
java.util.Arrays
打印数组
int[] a={1,2};
System.out.println(a);//[23we45er]
System.out.println(Arrays.toString(a));
数组排序
int[] a={1,2,323,23,543,12,59};
Sysrtem.out.println(Arrays.toString(a));
Arrays.sort(a);
System.out.println(Arrays.toString(a));
结果:
[1, 2, 323, 23, 543, 12, 59]
[1, 2, 12, 23, 59, 323, 543]
如果数组元素是引用类型,那么需要怎么做呢?后面容器讲
public class Test{
public static void main(String[] args){
Man[] msMans={new Man(3,"a"),new Man(60,"b"),new Man(2,"c")};
Arrays.sort(msMans);
System.out.println(Arrays.toString(msMans));
}
}
/*****************************************************************/
public class Test{
public static void main(String[] args) {
Man[] msMans = {new Man(3,"a"),new Man(60,"b"),new Man(2,"c")};
Arrays.sort(msMans);
System.out.println(Arrays.toString(msMans));
}
}
class Man implements Comparable {
int age;
int id;
String name;
public Man(int age, String name) {
super();
this.age = age;
this.name = name;
}
public String toString(){
return this.name;
}
public int compareTo(Object o) {
Man man = (Man) o;
if(this.age<man.age){
return -1;
}
if(this.age>man.age){
return 1;
}
return 0;
}
}
二分法查找
int[] a = {1,2,323,23,543,12,59};
Arrays.sort(a); //使用二分法查找,必须先对数组进行排序
System.out.println("该元素的索引:"+Arrays.binarySearch(a, 12));
复制
一般用System.arraycopy
填充
Arrays.fill(a,2,4,100);//将2到4索引的元素替换为100
asList
int[] a={1,2,323,23,543,,12,59}
List<int[]> list=new ArrayList<int[]>();
list = Arrays.asList(a);//将数组转成list对象中的一个元素
System.out.println(list.get(0)[1]);
-------------------------------------------------------------------------------------------------------------------华丽分割线
多维数组
多位数组可以看成以数组为元素的数组。默认初始化,静态初始化,动态初始化
静态初始化:
int[] [] a={
{1,2,3},
{3,4},
{3,5,6,7}
};
System.out.println(a[2][3]);
动态初始化:
int[][] a=new int[3][];
a[0]=new int[3];
a[1]=new int[5];
a[2]=new int[8];
a[0][0]=1;
a[0][1]=2;
a[0][2]=3;
System.out.println(a[0][0]);
public static void main(String[] arge) {
int[] [] a= { //二维静态初始化
{1,2,3,4},
{3,4},
{5,6,7,8}
};
System.out.println(a[0][3]);
int[][] aa=new int[3][]; //二维动态初始化
aa[0]=new int[10];
aa[0][0]=10;
System.out.println(aa[0][0]);
int[][][] aaa=new int[3][][]; //三维动态初始化
aaa[0]=new int[3][];
aaa[0][0]=new int[2];
aaa[0][0][0]=10;
aaa[0][0][1]=110;
int[][][] aaaa= { //三维静态初始化
{{1}},
{{3},{2}},
{{3}}
};
System.out.println(aaa[0][0][1]+"---"+aaaa[1][1][0]);
}