Java_60_数组_多维数组_基本语法

数组概述和特点

数组的定义：数组是相同类型数据的有序集合，数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。

数组的四个基本特点：

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]);
    }