Java入门------数组

一维数组：

数组是指一组类型相同的数据的集合，数组中的每个数据被称作元素，数组可以存放任意类型的元素，但同一个数组存放的元素类型必须一致。

数组的定义：

//方法一：
数据类型 [] 数组名=null;
//方法二：
数据类型 [] 数组名；‘
数据名=new 数据类型[长度];

举例：

int x;//声明一个int[]类型的变量，初始值均为0
x=new int[100];//为数组x分配100个元素空间
1
2

打印数组长度：

在Java中，为了方便获得数组的长度，提供了一个length属性，在程序中可以通过“数组名.length”的方式获得数组长度，即元素的个数，需要注意的是，数组索引的最小值是0，最大值是数组长度-1

举例：

public class HelloWorld {
    public static void main(String[] args) {
        int []arr;
        arr=new int [3];
        //输出数组中元素的值
        System.out.println("arr[0]="+arr[0]);
        System.out.println("arr[1]="+arr[1]);
        System.out.println("arr[2]="+arr[2]);
        System.out.println("数组的长度为："+arr.length);//打印数组长度
    }
}
1
2
3
4
5
6
7
8
9
10
11

输出：

arr[0]=0
arr[1]=0
arr[2]=0
数组的长度为：3
1
2
3
4

数组的默认值：

给数组元素赋初始值：

public class HelloWorld {
    public static void main(String[] args) {
        int []arr;
        arr=new int [3];
        //给数组部分元素赋初始值
        arr[0]=1;
        arr[1]=5;
        System.out.println("arr[0]="+arr[0]);
        System.out.println("arr[1]="+arr[1]);
        System.out.println("arr[2]="+arr[2]);
        System.out.println("数组的长度为："+arr.length);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

输出：

arr[0]=1
arr[1]=5
arr[2]=0//未赋值的元素输出默认值
数组的长度为：3
1
2
3
4

动态初始化与静态初始化：

在定义数组时，只指定数组的长度，由系统自动为元素赋初值的方式称作动态初始化，在初始化数组时还有一种方式叫做静态初始化，即为在定义数组的同时就为数组的每个元素赋初值。

具体方法如下：

类型[] 数组名=new 类型[];
类型[] 数组名={元素1，元素2…};

动态初始化即为我们上述所举的实例，这里我们重点说一下静态初始化。

举例：

public class HelloWorld {
    public static void main(String[] args) {
        int []arr={1,2,3};
        System.out.println("arr[0]="+arr[0]);
        System.out.println("arr[1]="+arr[1]);
        System.out.println("arr[2]="+arr[2]);
        System.out.println("数组的长度为："+arr.length);
    }
}
1
2
3
4
5
6
7
8
9

输出：

arr[0]=1
arr[1]=2
arr[2]=3
数组的长度为：3
1
2
3
4

注意：不要将int []arr={1,2,3};写成int []x=new int[4]{1,2,3,4}；否则编译器会报错，报错原因即为编译器会认为数组限定的元素个数[4]与实际存储的元素{1,2,3,4}个数有可能不一致，存在一定的安全隐患。

数组索引：

索引越界访问：

举例：

public class HelloWorld {
    public static void main(String[] args) {
        int []arr=new int[4];
        System.out.println("arr[4]="+arr[4]);
    }
}
1
2
3
4
5
6

报错内容为：

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4
	at HelloWorld.main(HelloWorld.java:5)
1
2

数组长度为4，最大索引值为4-1，因此当索引值为4时，就出现了越界访问的情况。

索引的对象无效：

在使用变量引用一个数组的时候，变量必须指向一个有效的数组对象，如果变量的值为null，则意味着没有指向任何数组，此时通过该变量访问数组的元素会出现指针异常。

举例；

public class HelloWorld {
    public static void main(String[] args) {
        int []arr=new int[4];
        arr[0]=5;
        System.out.println("arr[0]="+arr[0]);
        arr=null;
        System.out.println("arr[0]="+arr[0]);
    }
}
1
2
3
4
5
6
7
8
9

输出：

arr[0]=5
Exception in thread "main" java.lang.NullPointerException: Cannot load from int array because "arr" is null
	at HelloWorld.main(HelloWorld.java:8)
1
2
3

在将arr置为null之前，数组都可以进行正常的访问，但是将arr置为null之后，再次访问就出现了空指针异常。

数组遍历：

依次访问数组的每个元素称为数组的遍历。
举例：

public class HelloWorld {
    public static void main(String[] args) {
        int []arr={1,2,3,4,5,6};
        for(int i=0;i<arr.length;i++) {
            System.out.print(arr[i]);
        }
    }
}
1
2
3
4
5
6
7
8

输出：

123456
1

数组最值：

public class HelloWorld {
    public static void main(String[] args) {
        int []arr={3,4,7,19,10,2};
       int max=getMax(arr);
       System.out.println("max="+max);
    }
    public static int getMax(int[] arr)//获得数组中元素的最大值
    {
        int max=arr[0];//假设数组的第一个元素为最大值
        for (int x=1;x<arr.length;x++)
        {
            if(arr[x]>max)//依次将数组中的元素和最大值进行比较
            max=arr[x];
        }
        return max;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

输出如下：

max=19
1

最小值的查找方法相类似，这里就不过多赘述了。

数组排序-----冒泡排序：

其实在C语言中，常见的排序方法就是冒泡排序，同样，该方法在Java中依然适用。

我们先来回忆一下冒泡排序的步骤：
举例：

public class HelloWorld {
    public static void main(String[] args) {
        int []arr={3,4,17,9,10,2};
        for(int i=0;i<arr.length-1;i++)//索引最大值为数组长度减一
        {
            for(int j=0;j<arr.length-i-1;j++)//每完成一次，比较的数的个数就减一
                if(arr[j]>arr[j+1])
                {
                    //使用中间变量实现数的交换
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
        }
        for(int i=0;i<arr.length;i++)
        {
            System.out.print(arr[i]);
        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

输出：

23491017
1

二维数组：

二维的定义：

第一种定义方法：
数据类型[][]数组名=new数据类型[行的个数][列的个数]

举例：

int[][]xx=new int[3][4];
1

上述代码相当于定义了一个3*4的二维数组，即三行四列的二维数组。

如下图所示：

第二种方式：
数据类型[][] 数组名=new int[行的个数][];

和C语言不同的是，Java的行数不可以省略，但C语言是列数不能省略。

举例：

int[][] xx=new int[3][];
1

上述代码相当于定义了一个三行，但是列数不确定的二维数组。

如下图所示：

第三种方式：
数据类型[][] 数组名={{第0行初始值}，{第一行初始值}…{第n行初始值}}；

举例：

int [][] xx={{1,2},{3,4,5,6},{7,8,9}};
1

上述的二维数组arr中定义了三个元素，而这三个元素都是数组。

如下图所示：

二维数组的访问：

其方法也是通过索引的方式，例如访问二维数组第一行第二个元素arr[0][1]

public class HelloWorld {
    public static void main(String[] args) {
        int[][]arr=new int[3][];
        arr[0]=new int[]{1,2,3,5};
        arr[1]=new int[]{0,3,5};
        arr[2]=new int[]{3,9,6,5};
        for(int i=0;i<arr.length;i++)
        {
            for(int j=0;j<arr[i].length;j++)
            {
                System.out.print(arr[i][j]);
            }
            System.out.println("");
        }

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

输出：

1235
035
3965
1
2
3

二维数组的越界访问：

public class HelloWorld {
    public static void main(String[] args) {
        int[][]arr=new int[3][];
        arr[0]=new int[]{1,2,3,5};
        arr[1]=new int[]{0,3,5};
        arr[2]=new int[]{3,9,6,5};
        for(int i=0;i<=arr.length;i++)//索引最大值为数组长度减一
        {
            for(int j=0;j<arr[i].length;j++)
            {
                System.out.print(arr[i][j]);
            }
            System.out.println("");
        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

输出：

1235
035
3965
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
	at HelloWorld.main(HelloWorld.java:9)
1
2
3
4
5

索引的对象无效：

public class HelloWorld {
    public static void main(String[] args) {
        int[][]arr=new int[3][];
        arr[0]=new int[]{1,2,3,5};
        arr[1]=new int[]{0,3,5};
        arr[2]=new int[]{3,9,6,5};
        for(int i=0;i<arr.length;i++)
        {
            for(int j=0;j<arr[i].length;j++)
            {
                System.out.print(arr[i][j]);
            }
            System.out.println("");
        }
        arr=null;//将数组置空
        for(int i=0;i<arr.length;i++)
        {
            for(int j=0;j<arr[i].length;j++)
            {
                System.out.print(arr[i][j]);
            }
            System.out.println("");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

输出：

1235
035
3965
//数组置空后无法正常访问
Exception in thread "main" java.lang.NullPointerException: Cannot read the array length because "arr" is null
	at HelloWorld.main(HelloWorld.java:16)
1
2
3
4
5
6