2017.4.8（二维数组，冒泡排序）

2.1
二维数组：其实二维数组其实就是一个元素为一维数组的数组。

动态初始化方式一（指定有多少个长度相同的一维数组）：
数据类型[][] 变量名 = new 数据类型[m][n];

m表示这个二维数组有多少个一维数组
n表示每一个一维数组的元素个数

需求：请定义一个二维数组,二维数组有三个一维数组,每个一维数组有两个元素。
1.打印二维数组名称
2.打印每一个一维数组
3.不给元素赋值打印元素
4.赋值后打印元素

public class ArrayArrayDemo {
    public static void main(String[] args) {
//      需求：请定义一个二维数组,二维数组有三个一维数组,每个一维数组有两个元素。
        int[][] arr = new int[3][2];
//      1.打印二维数组名称
        System.out.println(arr);//[[I@33abb81e

//      2.打印每一个一维数组
        System.out.println(arr[0]);//[I@4ec4d412
        System.out.println(arr[1]);//[I@5c3f1224
        System.out.println(arr[2]);//[I@30c028cc

//      3.不给元素赋值打印元素
        //二维数组中的第一个一位数组的0号元素
        System.out.println(arr[0][0]);//0
        System.out.println(arr[1][1]);//0

//      4.赋值后打印元素
        arr[1][0] = 10;
        arr[2][0] = 20;
        System.out.println(arr[1][0]);//10
        System.out.println(arr[2][0]);//20
    }

}

2.2
动态初始化方式二（指定二维数组中有多少个一维数组，每一个一维数组的长度不固定）：
数据类型[][] 变量名 = new 数据类型[m][];

注意：
m这个数据必须给出，后面的数据可以不给，如arr[2][0]);

求：定义一个有3个一维数组的二维数组
1.给这个二维数组的每一个一维数组的元素赋值
仅可用此种方式：
arr[0] = new int[2];
arr[0][0] = 1;
arr[0][1] = 2;

不能用此种方式：
/*
arr[0] = {1,2};
arr[1] = {5,6,7};
arr[2] = {4};
*/

2.打印二维数组的名称
3.打印二维数组中每一个一维数组的名称
4.打印二维数组中的每一个一位数组中的元素

public class ArrayArrayDemo2 {
public static void main(String[] args) {
    //需求：定义一个有3个一维数组的二维数组,每一个一维数组的长度不固定
    int[][] arr = new int[3][];

    //3.打印二维数组中每一个一维数组的名称
    System.out.println(arr[0]);//null
    System.out.println(arr[1]);//null
    System.out.println(arr[2]);//null

    //1.给这个二维数组的每一个一维数组的元素赋值
    //arr[0] = {1,2,3};//在这里无法使用一维数组的静态初始化给二维数组中的每一个元素赋值
    //第一个一维数组有两个元素
    arr[0] = new int[2];
    arr[0][0] = 10;
    arr[0][1] = 20;

    //第二个一维数组，长度为3
    arr[1] = new int[3];
    arr[1][0] = 2;
    arr[1][1] = 3;
    arr[1][2] = 4;

    //第三个一维数组，长度为2
    arr[2] = new int[2];
    arr[2][0] = 4;
    arr[2][1] = 5;

    //2.打印二维数组的名称
    System.out.println(arr);//[[I@7f39ebdb

    //3.打印二维数组中每一个一维数组的名称
    System.out.println(arr[0]);//[I@4ec4d412
    System.out.println(arr[1]);//[I@5c3f1224
    System.out.println(arr[2]);//[I@30c028cc

    //4.打印二维数组中的每一个一位数组中的元素（手动打印几个即可）
    System.out.println(arr[0][0]);
    System.out.println(arr[2][0]);


}

}
2.3
二维数组的静态初始化：
静态初始化：
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};

简化格式：
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};

需求：定义一个里面有3个长度一样的一维数组的二维数组（使用静态初始化
public class ArrayArrayDemo3 {
public static void main(String[] args) {
//需求：定义一个里面有3个长度一样的一维数组的二维数组（使用静态初始化）
int[][] arr = new int[][]{{1,2},{3,4},{5,6}};//nw int[3][2];

//需求：定义一个里面3个长度不一样的一维数组的二维数组（用静态初始化）

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

2.4 二维数组的遍历：
需求：定义一个里面有3个长度不一样
的一维数组的二维数组，并遍历

public class ArrayArrayDemo4 {
    public static void main(String[] args) {
        //定义一个三个长度不意义样的一位数组的二维数组，并遍历
        int[][] arr = {{1,2},{3,4,5},{6,7,8,9,0}};

        //利用for循环遍历二维数组
        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();
        }

    }

2.5 二维数组的求和：
公司年销售额求和
某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99

package com.edu_01;

public class ArrayArrayDemo5 {
    public static void main(String[] args) {
    //创建对应的二维数组
        int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};

        //遍历二维数组并将每一个元素的值加起来
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            //拿到每一个一维数组之后，遍历每一个一维数组，加起来
            for (int j = 0; j < arr[i].length; j++) {
                sum+=arr[i][j];
            }
        }
        System.out.println(sum);
    }

}

三：形式参数问题
看程序写结果

package com.edu_02;

public class ArgsDemo {
    public static void main(String[] args){
        int a = 10;
        int b = 20;
        System.out.println("a:"+a+",b:"+b); //10,20
        change(a,b);
        System.out.println("a:"+a+",b:"+b); //a:10,b:20

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

    public static void change(int a,int b) { 
        System.out.println("a:"+a+",b:"+b); //10,20
        a = b; 
        b = a + b; 
        System.out.println("a:"+a+",b:"+b);//20,40
    }

    public static void change(int[] arr) { 
        for(int x=0; x<arr.length; x++) {
            //如果数组的元素值是偶数，就变为以前的2倍。
            if(arr[x]%2==0) {
                arr[x]*=2; 
            }
        }
    }

    /**
     * 基本数据类型：
     *      在传递参数的时候，基本数据类型的值不变
     * 
     * 引用数据类型：
     *      在传递参数的时候，方法会直接影响着一个引用数据类型的参数
     */

}

结论：
如果形式参数是基本类型：
    形式参数的改变，不影响实际参数。
如果形式参

1.3 画图讲解冒泡排序，int[] arr = { 24, 69, 80, 57, 13 };

1.4 文字分析比较过程
第一次比较：比较了4次，最大的值放到了最后
第二次比较：比较了3次，次大的值放到了倒数第二
。。。依次类推

1.3 画图讲解冒泡排序，int[] arr = { 24package com.edu_03;

public class ArraySortDemo {
    public static void main(String[] args) {
        //使用冒泡排序给数组int[] arr = { 24, 69, 80, 57, 13 };进行排序
        //创建一个数组
        int[] arr = { 24, 69, 80, 57, 13 };

/*      //第一次排序
        for (int i = 0; i < arr.length - 1 - 0; i++) {
            //java.lang.ArrayIndexOutOfBoundsException
            //-1是为了防止数组越界，-0是为了提高比较的效率
            if (arr[i]>arr[i+1]) {
                //找一个中间变量
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        //打印数组
        printArr(arr);


        //第二次排序
        for (int i = 0; i < arr.length - 1 - 1; i++) {
            //java.lang.ArrayIndexOutOfBoundsException
            if (arr[i]>arr[i+1]) {
                //找一个中间变量
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        //打印数组
        printArr(arr);


        //第三次排序
        for (int i = 0; i < arr.length - 1 - 2; i++) {
            //java.lang.ArrayIndexOutOfBoundsException
            if (arr[i]>arr[i+1]) {
                //找一个中间变量
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        //打印数组
        printArr(arr);


        //第四次排序
        for (int i = 0; i < arr.length - 1 - 3 ; i++) {
            //java.lang.ArrayIndexOutOfBoundsException
            if (arr[i]>arr[i+1]) {
                //找一个中间变量
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        //打印数组
        printArr(arr);*/

        System.out.println("--------------------");
        //使用for循环改进上面的代码
        for (int j = 0; j < arr.length-1; j++) {//外层循环控制比较的次数
            for (int i = 0; i < arr.length - 1 - j ; i++) {
                //-1是为了防止数组越界，-j是为了提高比较的效率
                if (arr[i]>arr[i+1]) {
                    //找一个中间变量
                    int temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }   
        }
        printArr(arr);
    }

    //写一个方法打印数组
    public static void printArr(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"  ");
        }
        System.out.println();
    }


}
, 69, 80, 57, 13 };

二：选择排序：

package com.edu_03;

public class ArraySortDemo2 {
    public static void main(String[] args) {
        //使用选择排序对数组进行排序：int[] arr = { 24, 69, 80, 57, 13 };
        int[] arr = { 24, 69, 80, 57, 13 };

/*      //第一次比较
        int x = 0;
        for (int i = x+1; i < arr.length; i++) {
            if (arr[x]>arr[i]) {
                int temp = arr[x];
                arr[x] = arr[i];
                arr[i] = temp;
            }

        }
        printArr(arr);


        //第二次比较
        x = 1;
        for (int i =  x+1; i < arr.length; i++) {
            if (arr[x]>arr[i]) {
                int temp = arr[x];
                arr[x] = arr[i];
                arr[i] = temp;
            }

        }
        printArr(arr);


        //第三次比较
        x = 2;
        for (int i =  x+1; i < arr.length; i++) {
            if (arr[x]>arr[i]) {
                int temp = arr[x];
                arr[x] = arr[i];
                arr[i] = temp;
            }

        }
        printArr(arr);


        //第四次比较
        x = 3;
        for (int i = x+1; i < arr.length; i++) {
            if (arr[x]>arr[i]) {
                int temp = arr[x];
                arr[x] = arr[i];
                arr[i] = temp;
            }

        }
        printArr(arr);*/

        System.out.println("--------------------------");
        //使用for循环改进上面的代码
        for (int j = 0; j < arr.length-1; j++) {
            for (int i = j+1; i < arr.length; i++) {
                if (arr[j]>arr[i]) {
                    int temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                }
            }
        }
        printArr(arr);

    }

    //写一个方法打印数组
        public static void printArr(int[] arr){
            for (int i = 0;     for (int j = 0; j < chs.length-1-i; j++) {
                if (chs[j]>chs[j+1]) {
                    char temp = chs[j];
                    chs[j] = chs[j+1];
                    chs[j+1] = temp;
                }
            }
        }*/

        //使用Arrays里面的sort()方法给字符数组进行排序
        Arrays.sort(chs);
        //打印数组
        System.out.println(Arrays.toString(chs));

    }

2.1 选择排序概念：从最小索引处0开始依次和后面的元素做比较，比较完第一次后，最小值出现在最小索引处，比较第二次后，次小值出现在了次小索引处，

三：Arrays数组工具类
3.1 针对数组进行操作的工具类。提供了排序，转换等功能。

3.2
* 成员方法：
* public static String toString(int[] a):把数组转成字符串
public static void sort(int[] a):对数组进行排序（有重载）

package com.edu_04;

import java.util.Arrays;

public class ArraysDemo2 {
    public static void main(String[] args) {
        //public static String toString(int[] a):把数组转成字符串
        int[] arr = {1,2,4,5,5};
        //打印上面数组的字符串表示形式
        String arrStr = Arrays.toString(arr);
        System.out.println(arrStr);//[1, 2, 4, 5, 5]

        System.out.println("----------");
        char[] chs = {'a','d','f','g'};
        String chsStr = Arrays.toString(chs);
        System.out.println(chsStr);//[a, d, f, g]

    }

}



package com.edu_04;

import java.util.Arrays;

public class AarraysDemo {
    public static void main(String[] args) {
    //创建一个int数组，应用Arrays里面的排序方法，对数组进行排序
        int[] arr = {4,3,6,5,2};
        //利用排序方法对数组进行排序
        Arrays.sort(arr);
        printArr(arr);

        System.out.println("-------------------------");
        char[] chs = {'q','s','a','c','b'};
        Arrays.sort(chs);
        printArr(chs);
    }

    public static void printArr(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"  ");
        }
        System.out.println();
    }


    public static void printArr(char[] chs){
        for (int i = 0; i < chs.length; i++) {
            System.out.print(chs[i]+"  ");
        }
        System.out.println();
    }

}

四：练习（运用冒泡排序和数组工具类两种方式实现）
* 把字符串中的字符进行排序。
* 举例：”dacgebf”
* 结果：”abcdefg”

package com.edu_05;

import java.util.Arrays;

/**
 *  四：练习（运用冒泡排序和数组工具类两种方式实现）
     * 把字符串中的字符进行排序。
     * 举例：”dacgebf”
     * 结果：”abcdefg”
 *
 */
public class StringSortDemo {
    public static void main(String[] args) {
        //使用冒泡排序
        String s = "dacgebf";
        //转换成字符数组
        char[] chs = s.toCharArray();
        /*//使用冒泡排序对字符根据ascii码表进行排序
        for (int i = 0; i < chs.length-1; i++) {
            for (int j = 0; j < chs.length-1-i; j++) {
                if (chs[j]>chs[j+1]) {
                    char temp = chs[j];
                    chs[j] = chs[j+1];
                    chs[j+1] = temp;
                }
            }
        }*/

        //使用Arrays里面的sort()方法给字符数组进行排序
        Arrays.sort(chs);
        //打印数组
        System.out.println(Arrays.toString(chs));

    }

}

2.在控制台输出九九乘法表：

package com.edu_06;

public class Test {
    public static void main(String[] args) {
        //31：在main方法中写一段代码，实现在控制台输出九九乘法表。
        for (int i = 1; i < 10; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(i+"*"+j+"="+i*j+"  ");
            }
            System.out.println();
        }
    }

}

注意：外层循环控制输出的行数，内层循环控制语句输出的逻辑