夹哇基础知识总结part5（数组）_夹哇系统

Java当中的数组

1、数组是存放相同数据类型的集合，内存是连续的
2、Java中数组存在堆上，
new ： 实例化一个对象，定义一个数组，其实就是定义一个对象，

(一)、一维数组

1、数组的定义

    public static void main(String[] args) {
        int[] array = {1,2,3,4};                    //该写法与下面那条写法本质上是一样的，
        int[] array2 = new int[]{11,22,33,44};
        int[] array3 = new int[4];                  //此时array数组里存放着4个0；
        System.out.println(array);                  //栈上的地址是拿不到的，堆上的地址可以打印，但不是真是的，但是可以当做是真是的，因为他是唯一的（经过了哈希处理）    
    }

1
2
3
4
5
6
7

2、数组的初始化

    public static void main(String[] args) {
        int a = 0;                          //其他变量在定义的时候要附一个初始值，不知道赋值什么就赋值0
        System.out.println(a);
        int[] array = null;                 //数组中的初值可以赋值null，表示array引用的是一个空对象。/null与地址无关，仅代表一个空对象
        System.out.println(array[0]);       //运行后抛出空指针异常，因为根本就没有对象，没有0下标让你访问
    }
    //运行时常量池，在jdk1.7开始都被放到堆中了，
1
2
3
4
5
6
7

3、一维数组的遍历

 		//遍历一个数组
        for (int  i = 0; i<array.length;i++){       //i不能等于array.length,否则会下标越界
            System.out.print(array[i]);
        }
        System.out.println("*****************************");
        //for...each... 打印数组.(与for的区别是不需要索引值i，适用于单纯遍历整个数组)
        for (int val : array) {
            System.out.print( val + " ");
        }
1
2
3
4
5
6
7
8
9

4、下标越界

    public static void main(String[] args) {
        //数组下标越界，由于数组长度总共只有3，想访问第100个元素的时候系统找不到，就会抛出下标越界异常
        int [] arr = {1,2,3};
        System.out.println(arr[100]);
    }
1
2
3
4
5

数组作为参数传递时的注意事项：

    数组作为参数进行传递时，传过去的是数组的地址，

    //方法：打印一个数组
    public static void printArray(int[] arr) {
        for (int x : arr) {
            System.out.print(x + " ");
        }
    }
    //方法：通过数组实现两个数字的交换，前面的方法直接调用方法因为修改的是形参的值，实参并不发生改变，所以可以用数组实现
    public static void swap(int[] arr) {
        int tmp = arr[0];
        arr[0] = arr[1];
        arr[1] = tmp;
    }

    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4};
        printArray(array);
        System.out.println();

        int[] arr2 = {10, 20};
        System.out.println(arr2[0] + " " + arr2[1]);
        swap(arr2);                                     //调用方法
        System.out.println(arr2[0] + " " + arr2[1]);
        //调用内部方法直接打印数组
        String ret = Arrays.toString(array);            //Arrays操作数组的工具类，需要导包，util包,toString是将数组以字符串形式输出
        System.out.println(ret);                        //定义一个ret来接收返回的String类型结果。
    }
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
26

(二)、二维数组

Java当中：二维数组可以看做是一个一维数组中的每一个元素都是一个一维数组。
数组是引用类型。默认值为mull，

1、二维数组的定义

	 public static void main(String[] args) {
        //定义一个二维数组， (中括号中不允许出现数字)
        int[][] array = {{1,2,3},{4,5,6}};
        int[][] array2 = new int[][]{{1,2,3},{4,5,6}};
        //这样定义时，中括号里可以有数字，表示他是一个2行3列的数组
        int[][] array3 = new int[2][3];
    }
1
2
3
4
5
6
7

2、二维数组的遍历

    public static void main(String[] args) {
        int[][] array = {{1,2,3},{4,5,6}};
        //对于上面两行三列的二维数组，遍历数组打印所有的元素，（其中2和3分别表示数组的行数和列数）
        for (int i = 0; i < 2 ; i++) {              //外层的for循环表示打印某一行元素
            for (int j = 0; j < 3; j++) {           //内层的for循环表示打印某一行的某一个一个元素
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }

        //对于任意一个二维数组，遍历他                           //因为二维数组相当于一维数组存了n个一维数组，
        for (int i = 0; i < array.length; i++) {            //这里的array.length表示的是二维数组的行数
            for (int j = 0; j < array[i].length; j++) {     //这里的array[i].length表示的是二维数组的列数
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }

        //想要打印一个数组
        System.out.println(Arrays.toString(array));         //此时，用toString方法只能打印第一层数组的地址
        System.out.println(Arrays.deepToString(array));     //想要打印二维数组应该用deepToString

        //通过for...each..打印二维数组
        for (int[] tmp: array) {
            for ( int x : tmp ) {
                System.out.print(x + " ");
            }
            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
26
27
28
29
30

3、不规则数组

    public static void main(String[] args) {
        //Java当中，定义不规则的数组的时候，数组的行必须指定，列，不可以自动推导的
        int[][] array = new int[2][];
        array[0] = new int[3];              //对于两行的数组，可以分别指定第几行有几个元素，这里表示下标为0的行有3个元素
        array[1] = new int[2];              //这里表示，下标为1的行有2个元素，由于没有给初始值，他们默认都为0；（简单类型默认值为0）

    }
1
2
3
4
5
6
7

Arrays数组工具类中常用的方法：

           1、Arrays.toString();               //将数组中的数据以字符串的形式进行输出，
           2、Arrays.copyOf();                //将数组拷贝的拷贝返回，
              Arrays.copyOfRange(array, 1,5); 	//拷贝数组中某一个范围：比如：拷贝下标1到下标5之间所有的元素，
           3、Arrays.binarySearch();           //二分查找，找数组中的某个元素，返回下标
           4、Arrays.equals();                 //判断两个数组内容是否相同
           5、Arrays.fill();                   //填充数组，用第二个参数值填充数组。也可以局部填充，用fromindex和toindex
           6、Arrays.sort();                   //将数组中的元素按升序排列
1
2
3
4
5
6
7

注意：在Java当中数组的范围一般是半开区间的形式：[ 1 , 5 )
比如：
Arrays.copyOfRange(array, 1,5); // 拷贝下标1到下标5之间所有的元素，包括下标1的元素但不包括下标5的元素。
更多其他的方法可以参考Java帮助手册：链接: link.