Java 数组

1.定义数组的方式

类/基本类型 [] 数组名 = new 类/基本类型[长度];

例如：

node[] a=new node[5];
int [] b=new int[6];
double []c=new double[6];

缺点：长度固定，不够灵活

定义的时候就初始化了，类数组的初始值是null，基本类型数组的初始值是0；

        for(int i=0;i<a.length;i++)
            System.out.println( "i="+i+"  "+a[i]+"  "+b[i]+"  "+c[i] );
/*输出
i=0  null  0  0.0
i=1  null  0  0.0
i=2  null  0  0.0
i=3  null  0  0.0
i=4  null  0  0.0
*/

2.获取长度

数组名.length;

a.length;b.length;

用于遍历，越界访问则异常

3.内存

        int[] x = null;
        x = new int[3];
        x[0] = 10;
        x[1] = 20;
        x[2] = 30;
        x = null;   

 

4.引用

int[] a=new int[4];

等号右侧：创建了一个int型数组对象
等号左侧：变量a称为该对象的引用（Reference）
称作：变量a指向一个对象

int[] a=new int[4];
int[] b=a;

a指向一个对象，b指向 和 a指向 相同 的对象，a和b都是该对象的引用，a和b都可以操作目标对象

int [] a={1,2,3,4};
int [] b=a;
a=null;//空对象

此时a不指向任何对象，不能再访问，比如把数组第一个值改为12，a[0]=12会出错，但是b[0]=12不会出错。

int [] a={1,2,3,4};
System.out.println(a[0]+" "+a[1]+" "+a[2]);
a=new int[3];
a[0]=a[1]=a[2]=55;
System.out.println(a[0]+" "+a[1]+" "+a[2]);
/**输出
1 2 3
55 55 55
*/

创建一个数组对象obj1，内容为1，2，3，4
创建另一个数组对象obj2，内容为0，0，0
obj2内容变为55，55，55
此时obj1无人引用（失去引用的对象），会被java系统自动回收

如果想保留obj1，应该a=new int[3];之前加一句int [] b = a;这样可以使b引用a，a另外去引用别的也没关系。

5.匿名数组

在栈内存中没有任何引用，只在堆内存开辟空间，存放数据

System.out.println(new int[]{1,2,3}.length);

和失去引用的对象一样，用一次就废了，没办法重用，会被java系统自动回收。

6.用Arrays实现对数组的操作

导入包：import java.util.Arrays;

（1）排序

语法： Arrays.sort(数组名);
可以使用 sort() 方法实现对数组的排序，只要将数组名放在 sort( ) 方法的括号中，就可以完成对该数组的排序（按升序排列），字符串则以首字母排序

（2）将数组转换为字符串后捆绑输出

语法： Arrays.toString(数组名);

可以使用 toString() 方法将一个数组转换成字符串，该方法按顺序把多个数组元素连接在一起，多个元素之间使用逗号和空格隔开

import java.util.Arrays;
public class MyTest8 {
    public static void main(String[] args) {
        String[] hobbies = { "sports", "game", "movie" };
        int [] a= {11,33,44};
        for(int i=0;i<hobbies.length;i++)
            System.out.println(hobbies[i]);
        System.out.println(Arrays.toString(hobbies)  );
        System.out.println(Arrays.toString(a)  );
    }
}

输出：

sports
game
movie
[sports, game, movie]
[11, 33, 44]

（3）复制数组

语法： 数据类型 [] 新的数组名 = Arrays.copyOf(需要复制的数组名,需要复制的长度);

public class MyTest8 {
    public static void main(String[] args) {
        int [] a = {11,33,44,20,53,87};//初始化长度为6的数组
        int [] c1 = Arrays.copyOf(a,2);//复制前2个长度的数组
        int [] c2 = Arrays.copyOf(a,4);//复制前4个长度的数组
        int [] c3 = Arrays.copyOf(a,a.length);//完全复制
        System.out.println("a数组的长度"+a.length);
        System.out.println("c1数组的长度"+c1.length);
        System.out.println("c2数组的长度"+c2.length);
        System.out.println("c3数组的长度"+c3.length);
        for(int i=0;i<a.length;i++)
            System.out.print(a[i]+"  ");
        System.out.println();
        for(int i=0;i<c1.length;i++)
            System.out.print(c1[i]+"  ");
        System.out.println();
        for(int i=0;i<c2.length;i++)
            System.out.print(c2[i]+"  ");
        System.out.println();
        for(int i=0;i<c3.length;i++)
            System.out.print(c3[i]+"  ");
        System.out.println();
    }
}

输出：

a数组的长度6
c1数组的长度2
c2数组的长度4
c3数组的长度6
11 33 44 20 53 87
11 33
11 33 44 20
11 33 44 20 53 87

7.作为参数传入方法

public class MyTest8 {
    public static void main(String[] args) {
        int [] a= {11,33,44};
        MyTest8 test=new MyTest8();
        test.print(a);
        System.out.println("2  "+a[0]+" "+a[1]+" "+a[2]);
        test.print2(a);
        System.out.println("4  "+a[0]+" "+a[1]+" "+a[2]);
    }
    public void print(int []c )
    {
        System.out.println("1  "+c[0]+" "+c[1]+" "+c[2]);
        c[0]=10;c[1]=20;c[2]=30;
    }
    public void print2(int a[])//形参名可以相同，并且int [] a和int a[]效果一样
    {
        System.out.println("3  "+a[0]+" "+a[1]+" "+a[2]);
        a[0]=a[1]=a[2]=1;
    }
}

输出：

1 11 33 44
2 10 20 30
3 10 20 30
4 1 1 1

理解：方法里的形参，相当于创建新的引用来 共同引用a数组，可以对a数组进行操作，进行的操作直接对堆中的数据进行修改。

8.类数组

类 [] 数组名 = new 类[长度];

package my_acm;
import java.util.Arrays;
public class MyTest8 {
    public static void main(String[] args) {
        Student[] stu = new Student[3];
        for(int i=0;i<stu.length;i++)
            System.out.println(stu[i]);
        stu[0]=new Student(1);
        stu[1]=new Student(2,"守林鸟");
        stu[2]=new Student(3,"霸王别鸡",21);
        System.out.println(stu.length);
        for(int i=0;i<stu.length;i++)
            System.out.println(stu[i]);
        for(int i=0;i<stu.length;i++)
            System.out.println(stu[i].toString());
        stu[0].say();
    }
}

class Student{
    
    private int id;
    private String name;
    private int age;
    public Student(int id) {
        this.id=id;
    }
    public Student(int id,String name) {
        this(id);//调用一个参数的构造方法
        this.name=name;
    }
    public Student(int id,String name,int age) {
        this(id,name);//调用2个参数的构造方法
        this.age=age;
    }
    public int getId() {
        return this.id;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public void setName(String name) {
        this.name = name;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    public void setId(int id) {
        this.id = id;
    }
    public void say() {
        System.out.println("hello");
    }
    public String toString() {//重写toString方法
        return "id="+this.id+" name="+this.name+" age="+this.age;
    }
}

输出：

null
null
null
3
id=1 name=null age=0
id=2 name=守林鸟 age=0
id=3 name=霸王别鸡 age=21
id=1 name=null age=0
id=2 name=守林鸟 age=0
id=3 name=霸王别鸡 age=21
hello

推测：创建对象的引用数组stu，一开始引用都是null，直到new之后堆中才开辟内存空间，分别创建3个对象，再通过stu引用，对于字符串，初始值是null，基本类型初始值则是0，直接输出对象则默认调用toString()方法，这个方法默认返回该对象实现类的类名 + @ +hashCode值。一般都被重写，江湖上的不成文规定是返回属性+值。