No1_4.数组的基本操作_Java学习笔记

import java.util.Arrays;

public class HelloArrayOp {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        System.out.println("第131页：数组的基本操作：" 
                + "\n1.遍历数组" 
                + "\n2.填充替换数组元素" 
                + "\n3.对数组进行排序" 
                + "\n4.复制数组" 
                +    "\n5.范例一：对比一维、二维数组所占内存" 
                +    "\n6.范例二：使用直接插入排序法排序" 
                + "\n7.范例三：使用冒泡排序法排序" 
                + "\n8.范例四：输出九宫格"
                +"\n9.实战：输出二维数组中所有元素之和");
        // No1:遍历数组
        System.out.println("\n 【No1:遍历数组】");
        int day[] = new int[] { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
        for (int i = 1; i <= 12; i++) {
            System.out.print(i + " 月有 " + day[i - 1] + " 天" + "\t\t");
            if (i % 3 == 0)
                System.out.println();
        }
        /*
         * oreach的语句格式： for(元素类型t 元素变量x : 遍历对象obj){ 引用了x的java语句; }
         */
        int arr2[][] = { { 1, 2, 3 }, { 7, 8, 9 } };
        System.out.println("遍历二维数组：");
        for (int x[] : arr2) {
            for (int m : x) {
                System.out.print(m + " \t");
            }
        }

        // No2:填充替换数组元素: fill(int[] a,int value)
        // fill(int[] a,int fromIndex, int toIndex(包括), int value(不包括))
        System.out.println("\n\n 【No2:填充替换数组元素】 ");
        int arr3[] = new int[5];
        Arrays.fill(arr3, 8);
        System.out.println("填充后所有的值都相同：");
        for (int y : arr3) {
            System.out.print(y + "\t");
        }
        System.out.println("\n给指定范围填充值");
        Arrays.fill(arr3, 1, 3, 6);
        for (int y : arr3) {
            System.out.print(y + "\t");
        }

        // No3：对数组进行排序 sort()
        System.out.println("\n\n 【No3:对数组进行排序】");
        int arrS[] = new int[] { 8, 10, 4, 1, 5, 6, 3 };
        System.out.println("原数组：");
        for (int s : arrS) {
            System.out.print(s + "\t");
        }
        Arrays.sort(arrS);
        System.out.println("\n排序后数组：");
        for (int s : arrS) {
            System.out.print(s + "\t");
        }

        // No4:复制数组 copyOf() copyOfRange()
        System.out.println("\n\n 【No4:复制数组】");
        int arrC1[] = new int[] { 1, 2, 3, 4, 5, 6 };
        int arrNew[] = Arrays.copyOf(arrC1, 3);
        int arrNew2[] = Arrays.copyOfRange(arrC1, 3, 5);
        System.out.println("复制后的数组arrNew是：");
        for (int c1 : arrNew) {
            System.out.print(c1 + "\t");
        }
        System.out.println("\n复制后的数组arrNew2是：");
        for (int c1 : arrNew2) {
            System.out.print(c1 + "\t");
        }

        // No5:范例一：对比一维、二维数组所占内存

        System.out.println("\n\n 【No5:范例一：对比一维、二维数组所占内存】");
        int num1 = 1024 * 1024 * 2;
        int arrNum[] = new int[num1];
        for (int i = 0; i < arrNum.length; i++) {
            arrNum[i] = i;
        }
        // 获得占用内存总数，并将单位转换为MB
        long memory1 = Runtime.getRuntime().totalMemory() / 1024 / 1024;
        System.out.println("用一维数组占用内存总量为" + memory1 + "M");

        int num2 = 1024 * 1024;
        int arrNum2[][] = new int[num2][2];
        for (int j = 0; j < arrNum2.length; j++) {
            arrNum2[j][0] = j;
            arrNum2[j][1] = j;
        }
        // 获得占用内存总数，并将单位转换为MB
        long memory2 = Runtime.getRuntime().totalMemory() / 1024 / 1024;
        System.out.println("用二维数组占用内存总量为" + memory2 + "M");
        /* 额，显示是占用内存相同。待考证。。。 */

        // No6:范例二：使用直接插入排序法排序 逻辑：将要排序的值逐个插入到其所适合的位置，其后的元素都向后移一个位置；
        int arrSort2[] = new int[] { 2, 3, 1, 5, 6, 7, 9 };
        System.out.println("\n【No6:范例二：使用直接插入排序法排序】\n 排序前输出：");
        for (int k : arrSort2) {
            System.out.print(k + "\t");
        }
        int exchange, n;
        for (int m = 1; m < arrSort2.length; m++) {
            exchange = arrSort2[m];
            for (n = m - 1; n >= 0 && arrSort2[n] > exchange; n--) { // 把大于号改成小于号就变成了倒序哟~~
                arrSort2[n + 1] = arrSort2[n];
            }
            arrSort2[n + 1] = exchange;
        }
        System.out.println(" \n 排序后输出:");
        for (int k : arrSort2) {
            System.out.print(k + "\t");
        }

        // No7.范例三：使用冒泡排序法排序 特点：排序稳定，效率不高
        // 逻辑：对比相邻的两个值如果满足条件就交换值，较小的移到数组前面，较大的移到数组后面；
        // 首先，排序算法的稳定性：通俗地讲就是能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。
        int arrSort3[] = new int[] { 2, 3, 1, 5, 6, 7, 9 };
        System.out.println("\n\n【No7:范例三：使用冒泡排序法排序】：");
        int exchange2;
        for (int si = 1; si < arrSort3.length; si++) {
            for (int sj = 0; sj < arrSort3.length - si; sj++) {
                if (arrSort3[sj] > arrSort3[sj + 1]) {// 把大于号改成小于号就变成了倒序哟~~
                    exchange2 = arrSort3[sj];
                    arrSort3[sj] = arrSort3[sj + 1];
                    arrSort3[sj + 1] = exchange2;
                }
            }
        }
        System.out.println(" 冒泡排序后输出:");
        for (int k : arrSort3) {
            System.out.print(k + "\t");
        }
        // No8.范例四：输出九宫格

        // No9.实战：输出二维数组中所有元素之和
        int arrSort4[][] = new int[][] { { 2, 3, 1, 5, 6, 7, 9 },
                { 2, 5, 7, 8, 10 }, { 3, 4, 5 } };
        System.out.println("\n\n【No7:范例四：使用冒泡排序法排序】：");
        int arrSort4Sum = 0;
        System.out.println("二维数组arrSort4中的元素是");
        for (int sumn = 0; sumn < arrSort4.length; sumn++) {
            for (int summ = 0; summ < arrSort4[sumn].length; summ++) {
                arrSort4Sum = arrSort4Sum + arrSort4[sumn][summ];
                System.out.print(arrSort4[sumn][summ] + "\t");
            }
            System.out.println();

        }
        System.out.println("二维数组中所有元素之和：" + arrSort4Sum);
    }
}

输出结果：

第131页：数组的基本操作：
1.遍历数组
2.填充替换数组元素
3.对数组进行排序
4.复制数组
5.范例一：对比一维、二维数组所占内存
6.范例二：使用直接插入排序法排序
7.范例三：使用冒泡排序法排序
8.范例四：输出九宫格
9.实战：输出二维数组中所有元素之和

 【No1:遍历数组】
1 月有 31 天        2 月有 29 天        3 月有 31 天        
4 月有 30 天        5 月有 31 天        6 月有 30 天        
7 月有 31 天        8 月有 31 天        9 月有 30 天        
10 月有 31 天        11 月有 30 天        12 月有 31 天        
遍历二维数组：
1     2     3     7     8     9     

 【No2:填充替换数组元素】 
填充后所有的值都相同：
8    8    8    8    8    
给指定范围填充值
8    6    6    8    8    

 【No3:对数组进行排序】
原数组：
8    10    4    1    5    6    3    
排序后数组：
1    3    4    5    6    8    10    

 【No4:复制数组】
复制后的数组arrNew是：
1    2    3    
复制后的数组arrNew2是：
4    5    

 【No5:范例一：对比一维、二维数组所占内存】
用一维数组占用内存总量为117M
用二维数组占用内存总量为117M

【No6:范例二：使用直接插入排序法排序】
 排序前输出：
2    3    1    5    6    7    9     
 排序后输出:
1    2    3    5    6    7    9    

【No7:范例三：使用冒泡排序法排序】：
 冒泡排序后输出:
1    2    3    5    6    7    9    

【No7:范例四：使用冒泡排序法排序】：
二维数组arrSort4中的元素是
2    3    1    5    6    7    9    
2    5    7    8    10    
3    4    5    
二维数组中所有元素之和：77