javabasic-day05

method_01MethDemo

package com.basic.day05.method;

/**
 * 方法的调用(续)
 * 1. 没有参数的方法调用(自行回顾)
 * 2. 有参数的方法调用:
 * 实际参数，简称实参。在调用时，传入到方法小括号里的变量，或者是具体值。
 * 实参的作用:就是用于给形参赋值(传值)，这个过程,称之为传参。
 * 3. void形式的方法调用：
 * 方法名(有形参传入实参)
 * 4. 有具体返回值的方法调用
 * 返回值类型
 */

public class _01MethDemo {
    public static void main(String[] args) {
        //需求1： 计算两个int类型的数据之和
        int m = 5;
        int n = 6;
      /* 调用 sum(int,int)方法:
         调用的时候，m和n是实际参数，要传入方法的括号里
         m给形参a赋值，n给形参b赋值sum(m,n)
       */
        sum(m, n);

        //需求2: 获取三个int类型的随机整数中的最大值。
        int x = (int) (Math.random() * 100);
        int y = (int) (Math.random() * 100);
        int z = (int) (Math.random() * 100);
        System.out.println("x=" + x + "y=" + y + "z=" + z);
        //调用getMax(int,int,int)方法:将实参 x，y，z传给方法形参
        int max = getMax(x, y, z);
        System.out.println("max=" + max);
    }

    /**
     * 用于计算两个int类型数据的和
     *
     * @param a int a
     * @param b int b
     */

    public static void sum(int a, int b) {
        a = 2 * a;
        b = 5 + b;
        int c = a + b;
        System.out.println("c=" + c);
    }

    public static int getMax(int a, int b, int c) {
        int max = Integer.MIN_VALUE;
        if (a > b && a > c) {
            max = a;
        } else if (b > a && b > c) {
            max = b;
        } else {
            max = c;
        }
        return max;
    }
}

method_02RecursionDemo

package com.basic.day05.method;

/**
 * 方法的递归：
 * 方法里调用自己
 * <p>
 * 设定 x=f(n)  计算20的阶乘 f(20)
 * f(20)= f(19)*20
 * f(19)= f(18)*19
 * ******
 * f(2)= f(1)*2
 * f(1)= 1
 * <p>
 * 总结 f(n)= f(n-1)*n
 */


public class _02RecursionDemo {
    public static void main(String[] args) {
        //计算20的阶乘
        long sum = 1;
        for (int i = 1; i <= 20; i++) {
            sum *= i;
        }
        System.out.println("sum=" + sum);
        //1-20的阶乘
        long result = f(20);
        System.out.println("result=" + result);
        //1-100的累加
        long result2 = mySum(100);
        System.out.println("result2=" + result2);
    }

    /**
     * 计算n的阶乘
     *
     * @param n 要计算的数字
     * @return 数字n的阶乘
     */
    public static long f(int n) {
        //需要设置递归的终止操作，n为1时 不需要调用递归方法了
        if (n == 1) {
            return 1;
        } else {
            return f(n - 1) * n;
        }
    }

    /**
     * 定义一个递归方法，计算1~n的和
     */
    public static long mySum(int n) {
        if (n == 1) {
            return 1;
        } else {
            return mySum(n - 1) + n;
        }
    }

}

array_01ArrayDemo

package com.basic.day05.array;

import org.omg.PortableInterceptor.ServerRequestInfo;

import java.util.Arrays;

/**
 * 数组的实例化：
 *   1. 使用new的两种方式  动态初始化
 *      第一种方式： new + 直接初始化具体元素
 *      第二种方式： new + 长度
 *   2. 静态初始化
 *       数据类型[] 变量 = { 元素1, 元素2,,······元素n}
 *
 */

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

        //new + 直接初始化具体元素
        String[] name =new String[]{"小红","小明","小强","张三","李四" };

        //new + 长度  注意：其实有长度个默认元素
        int[] nums =new int[5];//byte，short,int,long对应的默认元素是0
        System.out.println(Arrays.toString(nums));
        double [] prices =new double[5];//float 对应的默认元素是0.0
        System.out.println(Arrays.toString(prices));
        char [] chars =new char[5];//char对应的默认元素是\u0000
        System.out.println(Arrays.toString(chars));
        boolean [] booleans =new boolean[5];//boolean对应的默认元素是false
        System.out.println(Arrays.toString(booleans));
        String [] adds =new String[5];//String对应的默认元素是null
        System.out.println(Arrays.toString(adds));

        //使用静态初始化的方式，实例化一个数组
        //注意 该方式不能先声明 再初始化
        int[] numbers = {1,2,3,4,5};


    }
}

array_02ArrayDemo

package com.basic.day05.array;

import java.util.Arrays;

/**
 * 数组的访问：
 *   1. 通过下标访问 ： 下标就是元素对应的索引值 下标从0开始
 *   2. 数组的长度： 变量名.length
 *   3. 如何通过下标访问： 变量名[index]
 */

public class _02ArrayDemo {
    public static void main(String[] args) {
        int [] ages = new int[] { 20,18,19,20,19,30};
        //获取ages种的的第一个元素
         int first = ages[0];
         System.out.println(first);
         //获取ages中的第四个元素
         int fourth = ages[3];
         System.out.println(fourth);

         //打印ages数组的长度
         System.out.println(ages.length);
         //直接打印ages中的最后一个元素
         System.out.println(ages[ages.length-1]);


         //将年龄39存入到第二个位置
          ages[1]=39;
          //将年龄50存入最后一位
          ages[ages.length-1]=50;
        System.out.println(Arrays.toString(ages));

        //创建一个具有5个长度的long类型数组
        long [] ns = new long[5];
        //将数字10,,20,30,40,50存入到数组中
        ns[0]=10;
        ns[1]=20;
        ns[2]=30;
        ns[3]=40;
        ns[4]=50;
        System.out.println(Arrays.toString(ns));

        //1~10存入int类型数组 scores
        int [] scores = new int[10];
        for (int i = 0; i < scores.length; i++) {
            scores[i]=i+1;
        }
        System.out.println(Arrays.toString(scores));

    }
}

array_03ArrayDemo

package com.basic.day05.array;

/**
 * 数组下标越界异常；   .ArrayIndexOutOfBoundsException(数组下标异常)
 * 1. 运行期间的异常
 * 2. 当输入的下标大于等于数组的长度或者小于0发生
 * 3. 运行时异常，不做处理，jvm会暴力程序终止
 * <p>
 * 空指针异常:NullPointerException
 * 1. 运行期间的异常
 * 2. 当数组元素为null，或者数组为null
 */

public class _03ArrayDemo {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5};
//        int e1 = nums[5];
//        System.out.println(e1);

//        int e2 = nums[nums.length+10];
//        System.out.println(e2);

        String[] names = {"小明", " micheal", null, "" };
        //打印每个元素字符长度
        for (int i = 0; i < names.length; i++) {
            //处理 null的情况
            if (names[i] == null) {
                continue;
            }
            System.out.println(names[i].length());
        }


    }
}

array_04ArrayDemo

package com.basic.day05.array;

import java.util.Arrays;

/**
 * 数组的遍历
 *  1. 使用经典for循环，完成下标里面遍历
 *  2. 使用foreach循环：也叫增强for循环，底层使用的是迭代器
 *        for(元素类型 变量名 :目标数组，集合，枚举){
 *
 *        }
 *  3. 两者的对比
 *       增强for循环中，没有下标的概念
 *       增强for循环中，不能对数组中的元素进行改动
 *       增强for循环比遍历下标的执行效率要高
 *
 */

public class _04ArrayDemo {
    public static void main(String[] args) {
        int[] nums = new int[5];
        nums[0] = 10;
        nums[1] = 20;
        nums[2] = 30;
        nums[3] = 40;
        nums[4] = 50;
        //直接打印数组的变量
        System.out.println( "数组变量"+nums);//直接打印数组名得到的是类全名+@+内存地址16进制数字
        //调用Array.toString();
        System.out.println( "数组字符串"+ Arrays.toString(nums));

        //使用经典for循环，通过下标进行遍历
        for (int i = 0; i < nums.length; i++) {
            //i充当下标
            System.out.print(nums[i] + " ");
        }

        System.out.println();
        System.out.println("---------------------");

        //使用foreach循环遍历上述数组
        for (int n : nums) {
            System.out.print(n+" ");
        }

    }
}

array_05ArrayDemo

package com.basic.day05.array;

import java.awt.font.NumericShaper;
import java.util.Arrays;

/**
 * 数组的排序之：选择排序
 * 原理：
 * 第一轮：拿0索引处的元素与后面的元素一一做比较，满足条件就交换，每次交换都保证0索引处是最小值
 * 一轮结束，0索引处是最小值
 * 第一轮：拿1索引处的元素与后面的元素一一做比较，满足条件就交换，每次交换都保证1索引处是次小值
 * *            一轮结束，1索引处是次小值
 * 一次比较下去。
 * 比较的轮次： 元素个数-1 *
 * <p>
 * 通过分析，轮数是由外层循环控制，
 * 每一轮的比较由内层循环控制
 */

public class _05ArrayDemo {
    public static void main(String[] args) {
        int[] nums = {6, 5, 3, 2, 4, 1};
        //外层循环控制轮数
        for (int i = 0; i < nums.length - 1; i++) {
            //内层循环控制比较
            for (int j = i + 1; j < nums.length; j++) {
                //sum[i] 需要判断的索引位置上的元素
                //sum[j] 比较判断索引位置上的元素

                //定义一个临时变量
                int temp = 0;
                if (nums[i] > nums[j]) {
                    temp = nums[i];
                    nums[i] = nums[j];
                    nums[j] = temp;
                }

            }

        }
        System.out.println(Arrays.toString(nums));
    }
}

array_06ArrayDemo

package com.basic.day05.array;

import java.util.Arrays;

/**
 * 将一个数组的第一个元素，看成是有序的。然后拿第二个元素与前面的元素从左到右依次做比较。如果小于等于某一个元素
 * 则进行插入。该位置处及其以后的有序元素都要向后移动一位。
 *
 *  原数组：   4  6  3  1  2  7
 *  第一次：   4 | 6  3  1  2  7
 *            比较一次
 *  第二次：   4 6 | 3  1  2  7
 *            3和4比较。 需要插入
 *            3存起来，每个元素向后移动
 *           结果：
 *           3 4 6 | 1 2 7
 *  第三次：  需要插入，   1存起来， 移动元素
 *           结果：
 *           1 3 4 6 | 2 7
 *  第四次：  需要插入   2存起来  移动元素
 *           结果：1 2 3 4 6| 7
 *  第五次：  不需要插入
 *
 *      分析：
 */
public class _06ArrayDemo {
    public static void main(String[] args) {
        int[] nums = {4,6,1,3,2,7};
        // 分别拿nums[1] 到 nums[length-1]
        for (int i = 1; i < nums.length; i++) {
            for (int j = 0; j < i; j++) {
                if(nums[i]<nums[j]){
                    int temp = nums[i];
                    //向后移动，然后插入。
                    move(nums,j,i);
                    nums[j] = temp;
                    break;
                }
            }
        }
        System.out.println(Arrays.toString(nums));
    }

    /**
     * arr，是要移动的数组
     * @param arr    [ .... 1,4,6     3 ]
     * @param max             min     max
     * @param min
     */
    public static void move(int[] arr,int min,int max){
        for(int i=max;i>min;i--){
            arr[i] = arr[i-1];
        }
    }

//    public static void main(String[] args) {
//        int[] arr = {1,2,3,4,5};
//        move(arr,0,4);
//        System.out.println(Arrays.toString(arr));
//    }
}

array_07ArrayDemo

package com.basic.day05.array;

import java.util.Arrays;

/**
 * 插入排序的第二种方法
 */

public class _07ArrayDemo {
    public static void main(String[] args) {
        int[] nums = {6, 2, 3, 4, 1, 7};
        //从下标1开始拿到排序，默认0位置是排好序的
        for (int i = 1; i < nums.length; i++) {
            // 用拿到的i元素与前一位元素进行比较，如果小于前一位元素，则进行插入排序
            if (nums[i] < nums[i - 1]) {
                int j;
                int temp = nums[i];//存储需要插入的元素 ，放在覆盖
                //从后往前比较，如果小于前一位元素，则进行插入排序
                for (j = i - 1; j >= 0 && temp < nums[j]; j--) {
                    //如果j大于temp，将前一位的元素后移
                    nums[j + 1] = nums[j];
                }
                //将temp插入到j+1的位置
                nums[j + 1] = temp;
            }
        }
        System.out.println(Arrays.toString(nums));
    }

}

array_08ArrayDemo

package com.basic.day05.array;

import java.util.Arrays;

/**
 * 冒号排序：
 *       从左到右，紧挨着的两个元素进行比较
 *
 *       例如六元素
 *       第一轮找到最大值，冒号到最右侧
 *       第二轮找到次大值
 *       依次找到剩余值
 *       第五轮找到次小值和最小值
 *
 *    注意 每一轮比较时都是从最左边的元素开始
 *
 *    六个元素：
 *    i=0 j=5
 *    i=1 j=4
 *    i=2 j=3
 *    i=3 j=2
 *    i=4 j=1  j<length-1-i
 */

public class _08ArrayDemo {
    public static void main(String[] args) {
        int[] nums = {6,2,4,7,1,5};

        //外层循环控制比较轮数，论述等于leng-1
        for (int i = 0; i < nums.length - 1; i++){
            //内层控制每轮如何比较,从左边开始比较，j从0开始
            for (int j = 0; j < nums.length - 1-i; j++) {
                //如果前大于后，则交换
                if (nums[j] > nums[j+1]){
                    int temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                }

            }
            System.out.println(Arrays.toString(nums));
        }
    }
}

array_09ArrayDemo

package com.basic.day05.array;

/**
 * 从数组中查找元素：
 *   1. 可与使用顺序查找法
 */

public class _09ArrayDemo {
    public static void main(String[] args) {
        int[] nums = {100,23,48,56,10,78};
        //需求 ：查找数组中是否存在元素为56的元素，如果有返回左边，没有返回 -1
//        int index = -1;
//        for (int i = 0; i < nums.length; i++) {
//            if(nums[i] == 56){
//                index = i;
//                break;
//            }
//        }
//        System.out.println(index);
        int index = find(nums,56);
        System.out.println(index);
    }
    /**
     * 需求： 查找int数组arr中是否有n，如果有返回坐标，如果没有返回-1
     */
    public static int find(int[] arr,int n){
        int index = -1;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == n){
                index = i;
                break;
            }
        }
        return index;
    }

}

array_10ArrayDemo

package com.basic.day05.array;

/**
 * 数组元素的二分查找法：
 */

public class _10ArrayDemo {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int index = binarySearch(nums, 7);
        System.out.println(index);

    }
    /**
     * 写一个使用二分查找算法，从int类型的数组arr中找元素element的方法
     * 发到，返回其坐标，没找到，返回-1
     */
    public static int binarySearch(int[]arr,int element){
        int min = 0,max = arr.length-1;
        // min <= max时，表示还未找到该元素， min=max，是最后一次查找
        while(min<=max){
            //找到中间元素下标
            int mid = (min+max)/2;
            if(arr[mid]==element){
                // 如果min位置是目标元素，则返回下标
                return mid;
            }else if(arr[mid]<element){// 如果中间元素小于目标元素，表明在中间值右侧
                min = mid+1; // 将min设置为中间下标+1，重新循环
            }else{// 如果中间元素大于目标元素，表明在中间值左侧
                max = mid-1; // 将max设置为中间下标-1，重新循环
            }
        }
        return -1;
    }
}

array_11ArrayDemo

package com.basic.day05.array;

import java.util.Arrays;

/**
 * 学习一下Arrays工具类的用法
 * 1. toString():将数组转换为字符串形式。
 * 2. binarySearch():在已排序的数组中査找指定元素的索引。(必须升序)
 * 3. fill():将数组的所有元素都设置为指定值。了，
 * 4. sort(数组):对数组进行排序。4
 * 5. copyOf():将一个数组的部分或全部元素复制到一个新数组中。
 */

public class _11ArrayDemo {
    public static void main(String[] args) {
        int[] nums = {1,2,3,4,5,6,7,8,9,10};

        //转换为字符串
        String info = Arrays.toString(nums);
        System.out.println(info);
        System.out.println(Arrays.binarySearch(nums,5));

        //二分查找 (升序)
        int index = Arrays.binarySearch(nums,5);
        System.out.println(index);

        //指定填充
        Arrays.fill(nums,100);
        System.out.println(Arrays.toString(nums));

        //Arrays.sort(数组名); 只能对已经设置好排序规则的类的数组进行排序。
        int[] nums2 ={2,3,1,4,5,};
        Arrays.sort(nums2);
        System.out.println(Arrays.toString(nums2));

        // 复制数组(扩容)
        int[] nums3 = Arrays.copyOf(nums2,10);
        System.out.println(Arrays.toString(nums3));


        //指定长度一样，完全copy，与原数组相同
        int[] nums4= Arrays.copyOf(nums2,nums.length);

        // 小于原长度 ，截取
        int[] nums5 = Arrays.copyOf(nums2,3);
        System.out.println(Arrays.toString(nums5));


    }
}