Java暑期学习Day08（数组）

马太效应

今天是第八天了，希望能坚持下去(*Φ皿Φ*)
ps.崩溃了，又一次在写了一个多小时后出错，这告诉我随时随地保存草稿箱的重要性...

数组对象<plus>

import java.util.Arrays;

public class ArrayDemo {
        public static void main(String[] args) {

                int[] scores = new int[10];

                for (int score : scores) {
                        System.out.printf("%2d", score);// 0 0 0 0 0 0 0 0 0 0
                }
                Arrays.fill(scores, 60);
                for (int score : scores) {
                        System.out.printf("%3d", score);//60 60 60 60 60 60 60 60 60 60
                }

        }

}

A. 增强性for循环（for-each循环）<JDK5之后>
     语法：for(type element: array)
　　{
      　　System.out.println(element);
　　}
   说明：先取得array数组第一个元素，指定给type element变量之后执行循环体，接着取得array数组第二个元素，指定给type element变量之后执行循环体。以此类推，直到数组中所有元素访问完为止。
   element——要素; [化] 元素; 原理; [电] 电阻丝;
如果需要取出数组元素，使用for-each简单
如果需要取出数组元素的索引，只能使用for循环
  

B. 若默认值不符合自己的需求，可以使用java.util.Arrays的fill()方法来设定新建数组元素值。（Arrays类）

public class ArrayDemo2 {
        public static void main(String[] args) {

                int[] arr = new int[] { 1, 2, 3, 4, 20 };
                int arr2[] = new int[] { 1, 3 };
                int[] arr3 = { 4, 5, 6, 7 };
                System.out.println(arr);// [I@15db9742 arr引用于堆空间内存地址区域
                System.out.println(arr.length);// 5
                System.out.println(arr[0]);// 1 （即其索引从0开始）

                int[] arr4 = new int[] { 1, 2, 3, 5, 6 };
                // 取出数组中索引为3的元素

                int ele = arr[3];// 4
                System.out.println(ele);
                // 重新赋值
                arr[3] = 77;

                for (int i = 0; i < arr.length; i++) {
                        System.out.println(arr[i]);
                }
                System.out.println("end");

                arr = new int[] { 1, 2, 3, 4, 5 };
                // System.out.println(arr[5]);
// ArrayIndexOutOfBoundsException

boolean[] ages = new boolean[100];
                System.out.println(ages[99]);// false

                // 获取数组元素中最大元素
                int[] number7 = { 1, 2, 3, 4, 5, 6 };
                int max = number7[1];// 2
                System.out.println(max);
                for (int i = 0; i < number7.length; i++) {
                        if (number7[i] > max) {
                                max = number7[i];
                        }
                }
                System.out.println(max);// 6
                String[] arr5 = new String[3];
                for (int i = 0; i < arr5.length; i++) {
                        System.out.println(arr5[i]);
                }//都为null
                arr5 = null;
                 //System.out.println(arr5.length);
                // NullPointerException 空指针异常
        }
}

C. ArrayIndexOutOfBoundsException，超出索引范围
         NullPointerException 空指针异常

public class MoreArrayDemo {

        public static void main(String[] args) {

                int[][] arr1 = new int[6][];// 第二维数组长度未定
                int[][] arr2 = new int[6][6];// 第二维长度确定

                // （！！！）系统为这两个数组分配的堆内存空间是一样的

                int[][] arr3 = new int[5][3];
                // arr2数组中有5个元素，每一个元素其实是一个数组 其中有三个元素

                int[][] arr = { { 1, 2 }, { 3, 4, 5 }, { 6, 7, 8, 9 } };// 静态初始化二维数组

                // 接下来是动态初始化二维数组
                String[][] arrStr;// 声明
                arrStr = new String[3][];// 创建、分配内存
                arrStr[0] = new String[2];// 为高维初始化
                arrStr[1] = new String[3];
                arrStr[2] = new String[4];
                arrStr[0][0] = new String("abc00");// 为低维初始化
                // ...
                int[][] arr4 = new int[][] { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 12, 6 } };

                for (int[] xx : arr4) {
                        for (int x : xx) {
                                System.out.print(x);//12345678126
                        }
                }

        }

}

D.   一维数组：数组中的每一个元素都是一个值
      二维数组：数组中的数组，每一个元素都是数组
      三维数组：每一个元素都是二维数组
对于任何类型的二维数组而言，第一维的大小决定了二维数组对象的大小。
因为二维数组的成员是数组引用，数组引用本身大小是固定的。

<font size="5">
//冒泡排序

public class maopaopaixu {

        public static void main(String[] args) {
                
                int score[] = { 67, 6, 23, 87, 2 };
                for (int i = 0; i < score.length - 1; i++) {
                        for (int j = 0; j < score.length - 1; j++) {
                                if (score[j] > score[j + 1]) {
                                        int temp = score[j];
                                        score[j] = score[j + 1];
                                        score[j + 1] = temp;
                                }
                        }
                }

                for (int s = 0; s < score.length; s++) {
                        System.out.print(score[s] + " ");
                }

        }

}</font>

E.冒泡排序算法的运作如下：（从后往前）
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

412046761

加油！坚持学习！

马太效应

412046761 发表于 2017-7-16 10:34
加油！坚持学习！

嗯嗯，你也是！