学习大数据的第6天——复习复习

学习大数据的第6天（没上课自己复习了之前写的代码，预习后面的面向对象的知识点）

杨辉三角

（1）直角型

int[][] arr = new int[10][10];
        //第一种形式(直角型)
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j <= i; j++) {
                if (j == 0 || i == j) {//每行的头部和尾部都是1
                    arr[i][j] = 1;
                } else {
                    //例如：第5行的第3列——————>arr[4][2]    6
                    //   = 第4行第2列 arr[3][1]  3    + 第4行第3列  arr[3][2]   3
                    //   = arr[i][j] = arr[i-1][j-1] + arr[i-1][j]
                    arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
                }
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }

（2）等边三角形

int rows = 10;
        for (int i = 0; i < rows; i++) {
            int number = 1;
            // 打印空格字符串
            System.out.format("%" + (rows - i) * 2 + "s", number);
            for (int j = 0; j <= i; j++) {
                System.out.format("%4d", number);
                number = number * (i - j) / (j + 1);
            }
            System.out.println();
        }

数据加密问题的处理

难点分析：
数据加密问题
某个公司采用公用电话传递数据信息，数据是小于8位的整数，为了确保安全，
在传递过程中需要加密，加密规则如下：
首先将数据倒序，然后将每位数字都加上5，再用和除以10的余数代替该数字，
最后将第一位和最后一位数字交换。 请任意给定一个小于8位的整数，
然后，把加密后的结果在控制台打印出来。

    难点：数据长度不固定。

    题目要求：
        1、数据是小于8为的整数
            int number = 123456
        2、加密规则：
            a: 首先将数据倒序
                654321
            b: 将每位数字都加上5，再用和除以10的余数代替该数字
                109876
            c: 最后将第一位和最后一位数字交换
                609871
        3、把加密后的结果在控制台打印出来

   通过分析后，我们发现为了方便计算，我们采用数组存放这些数据，然后再进行加密
    int num = 123456;
   1、问题：数组的长度是多少呢？
        由于长度不可能是大于8的，我们就把长度定义成8
        int[] arr = new int[8];
   2、将数据每一位赋值再数组中，定义一个索引记录赋值的变化
        int index = 0;
   3、如何获取整数中的每一位数呢？
    int geWei = num%10; //6
    int shiWei = num/10%10; //5
    int baiWei = num/10/10%10; //4
    ...

    //题目要求一开始将数据倒序，我们按照反方向赋值
    arr[index] = geWei;
    index++;
    arr[index] = shiWei;
    index++
    arr[index] = baiWei;
    index++;
    ...

//定义一个不大于8位的整数
        int num = 123456;

        //定义一个数组，存储数据
        int[] arr = new int[8];

        //把数据中的每一位放到数组中，由于题目要求第一步就是逆序
        //我们干脆就直接倒着赋值。
        /*
            int index = 0;
            arr[index] = num%10;
            index++;
            arr[index] = num/10%10;
            index++;
            arr[index] = num/10/10%10;
            index++;
            arr[index] = num/10/10/10%10;
            index++;
            arr[index] = num/10/10/10/10%10;
            index++;
            arr[index] = num/10/10/10/10/10%10;
            index++;
         */

        //123456
        //由于我们今后会改进成手动输入，长度是不确定，我们用while循环赋值
        int index = 0;
        while (num > 0) {
            arr[index] = num % 10; // 6,5,4,3,2,1
            index++; //1,2,3,4,5,6
            num = num / 10; //12345 , 1234,123,12,1,0
        }

        //将每位数字都加上5，再用和除以10的余数代替该数字,for循环修改
        //注意：这里给数组元素做变化的时候需要注意的一点是，操作到index的位置停止，因为我们输入的数据的长度就到index
        for (int i = 0; i < index; i++) {
            arr[i] += 5;
            arr[i] %= 10;
        }

        //最后将第一位和最后一位数字交换
        int temp = arr[0];
        arr[0] = arr[index-1];
        arr[index-1] = temp;

        System.out.println("123456加密后的数据为：");
        for(int i=0;i<index;i++){
            System.out.print(arr[i]);
        }

以及以前编写的代码复习

//输出排序后的数组
    public static void printArr(int[] arr) {
        System.out.println(Arrays.toString(arr));
    }

    //冒泡排序
    public static int[] bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length; 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;
                }
            }
        }
        return arr;
    }

    //用非递归方法来进行二分查找
    public static int binarySearch(int[] arr, int value) {
        int start = 0;
        int end = arr.length - 1;
        while (start <= end) {//当start和end相等时      mid = start + end;
            int mid = (start + end) / 2;
            if (arr[mid] != value) {
                if (arr[mid] > value) {
                    end = mid - 1;// mid<0  跳出循环
                } else {
                    start = mid + 1;
                }
            } else {
                return mid;
            }
        }
        return -1;
    }

    //用递归方法来进行二分查找    报错原因：因为前面的排序是从小到大的顺序，但是这里是根据的从大到小的顺序排列的，所以第一个if跳不出去
    public static int recBinarysearch(int[] arr, int value, int start, int end) {
        if (value < arr[start] || value > arr[end] || start > end) {
            return -1;
        }
        int mid = (start + end) / 2;
        if (arr[mid] > value) {
            return recBinarysearch(arr, value, start, mid - 1);
        } else if (arr[mid] < value) {
            return recBinarysearch(arr, value, start + 1, end);
        } else {
            return mid;
        }
    }

    //选择排序
    public static int[] selectSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] < arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        return arr;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] arr = {2, 62, 14, 3, 7, 9, 1};

        //冒泡排序
        System.out.println("冒泡排序：");
        int[] arr1 = bubbleSort(arr);
        printArr(arr1);

        //选择排序
//        System.out.println("选择排序：");
//        int[] arr2 = selectSort(arr);
//        printArr(arr2);

        //利用非递归的方法来进行二分查找
//        System.out.println("利用非递归的方法来进行二分查找:");
//        System.out.println("请输入你想要查询的数据：");
//        int value = sc.nextInt();
//        int num = binarySearch(arr1, value);
//        if (num == -1) {
//            System.out.println("没找到！");
//        } else {
//            System.out.println("你寻找的数据在下标为：" + num + "的位置");
//        }

        //利用递归的方法来进行二分查找
        System.out.println(Arrays.toString(arr1));
        System.out.println("利用递归的方法来进行二分查找:");
        System.out.println("请输入你想要查询的数据：");
        int start = 0;
        int end = arr1.length - 1;
        int value = sc.nextInt();
        int num = recBinarysearch(arr1, value, start, end);
        if (num == -1) {
            System.out.println("没找到！");
        } else {
            System.out.println("你寻找的数据在下标为：" + num + "的位置");
        }

    }

预习面向对象的相关知识：

对象内存图

JVM(java虚拟机)
这个是自己的理解，如果想要官方的回答，可以查看这个
JVM的组成官方的回答
1、栈 存储局部变量
2、堆 存储new出来的东西
3、方法区 ：class文件区和类方法区
4、本地方法区
5、寄存器 (给CPU使用)