作业代码：

  1. package com.qfedu.day03;
  3. import java.util.Scanner;
  5. /**
  6.  * @Author laoyan
  7.  * @Description TODO
  8.  * @Date 2022/3/3 9:26
  9.  * @Version 1.0
  10.  *
  11.  * 这几天的编程难点：
  12.  *   1、如何使用变量
  13.  *   2、方法如何定义  有没有参数，有几个参数，什么类型，需不需要返回值，以及返回值类型写什么比较合适
  14.  *
  15.  *
  16.  *   java基础：
  17.  *     变量
  18.  *     if-else
  19.  *     for while
  20.  *     会定义方法
  21.  *     各种常用类的方法  String  Math  Random  Scanner
  22.  *     集合（List,Set，Map）
  23.  */
  24. public class HomeWork01 {
  26.     /**
  27.      *  第二道题目：
  28.      *  编程题：
  29.      *      编写一个应用程序，当用户输入一串字符后，将大写转换为小写，
  30.      * 将小写转换为大写，并统计出该字符串中大写字母多少个，小写字母多少个？
  31.      * 比如用户依次输入： A b d D E d f c G .....
  32.      * 依次循环获取用户输入的值，然后大写变小写，并打印用户输入了多少个大写字母，多少个小写字母。
  33.      *
  34.      *    String 中的两个重要的方法：
  35.      *      charAt(下标)     从字符串中的特定位置获取一个char
  36.      *      toCharArray()   将一个字符串变为一个字符数组。
  37.      */
  38.     public static void second(){
  39.         Scanner scanner = new Scanner(System.in);
  40.         System.out.println("请输入多个字母，以空格隔开,以.结束：");
  41.         //   ZhangSan
  42.         int bigCount = 0,smallCount = 0;
  43.         String ziMu = "-1" ;
  44.         while(!ziMu.equals(".")) { // api
  45.             ziMu = scanner.next();  // "A"
  46.             System.out.println(ziMu);
  47.             char c = ziMu.charAt(0);// 'A'
  48.             if (c >= 'A' && c <= 'Z') {
  49.                 c += 32;
  50.                 bigCount++;
  51.             } else if (c >= 'a' && c <= 'z') {
  52.                 c -= 32;
  53.                 smallCount++;
  54.             }
  56.             System.out.print(c + "\t");
  57.         }
  59.         System.out.println("本地大写的字母有："+bigCount+"个，小写有"+smallCount+"个");
  62.     }
  65.     public static void second2(){
  66.         Scanner scanner = new Scanner(System.in);
  67.         System.out.println("请输入一个字符串：");
  68.         //   ZhangSan
  69.         int bigCount = 0,smallCount = 0;
  70.         String str = scanner.nextLine();  // "A"
  71.         char[] chars = str.toCharArray(); // A b C D
  72.         //  ['A',' ','b'.....]
  74.         for (int i = 0; i < chars.length; i++) {
  75.             char c = chars[i];  // 'A'
  76.             if (c >= 'A' && c <= 'Z') {
  77.                 c += 32;
  78.                 bigCount++;
  79.             } else if (c >= 'a' && c <= 'z') {
  80.                 c -= 32;
  81.                 smallCount++;
  82.             }
  84.             System.out.print(c + "\t");
  85.         }
  88.         System.out.println("本地大写的字母有："+bigCount+"个，小写有"+smallCount+"个");
  91.     }
  93.     public static void main(String[] args) {
  94.         //second();
  95.         second2();
  96.     }
  97. }
  1. package com.qfedu.day03;
  3. /**
  4.  * @Author laoyan
  5.  * @Description TODO
  6.  * @Date 2022/3/3 10:03
  7.  * @Version 1.0
  8.  *
  9.  *   打印如下：
  10.  *   ABCDE
  11.  *    BCDEF
  12.  *     CDEFG
  13.  *      DEFGH
  14.  *       EFGHI
  15.  */
  16. public class HomeWork02 {
  17.     public static void main(String[] args) {
  18.         for (int i = 0; i < 5; i++) {
  19.             // 负责打印空格
  20.             for (int j = 0; j < i; j++) {
  21.                 System.out.print(" ");
  22.             }
  23.             for (int j = 0; j < 5; j++) {
  24.                 System.out.print((char) (j+i+65));
  25.             }
  27.             System.out.println();
  29.         }
  30.     }
  32. }

一、数组

1、概念
数组就是一个容器，可以存储一串相同类型的数据。
2、定义

  1. package com.qfedu.day03_02;
  3. import java.util.Arrays;
  5. /**
  6.  * @Author laoyan
  7.  * @Description TODO
  8.  * @Date 2022/3/3 10:18
  9.  * @Version 1.0
  10.  */
  11. public class Demo01 {
  12.     public static void main(String[] args) {
  13.         // int[]  这样的数组的数据类型是引用数据类型，跟String,Student都是一样的
  14.         // 数据类型除了8大基本数据类外都是引用。
  15.         int[] arr = null; // int类型的数组只能存放int类型的数据
  16.         double[] arr2 = null;
  17.         System.out.println(arr2);
  18.         int[] arr3 = new int[5];
  19.         String[] arr4 =new String[5];
  20.         System.out.println(arr3);
  21.         System.out.println(arr3.toString());
  22.         System.out.println(Arrays.toString(arr3));
  23.         System.out.println(Arrays.toString(arr4));// ctrl + d
  24.         int[] arr5 = {1,2,3,59};
  25.         // 是上面写法的复杂写法，不建议
  26.         int[] arr6 = new int[]{1,2,3,59};
  27.         System.out.println(Arrays.toString(arr5));
  28.     }
  29. }

3、数组在jvm内存模型中的示意图
image.png
4、遍历数组

  1. package com.qfedu.day03_02;
  3. /**
  4.  * @Author laoyan
  5.  * @Description TODO
  6.  * @Date 2022/3/3 11:10
  7.  * @Version 1.0
  8.  */
  9. public class Demo02 {
  11.     public static void main(String[] args) {
  12.         int[] arr = {1,3,5,9,10};
  13.         System.out.println(arr[4]);// [下标] 下标从0开始的
  14.         System.out.println(arr.length);// 可以获取数组的长度
  15.         //System.out.println(arr[5]);
  17.         /*
  18.            最普通的循环方式
  19.          */
  20.         for (int i = 0; i < arr.length; i++) {
  21.             System.out.println(arr[i]);
  22.         }
  23.         /**
  24.          *  针对数组或者集合，for循环出了一个增强版
  25.          *  可以非常方便的遍历数组，但是如果你还需要使用到了数组中的下标，该方式不适应。
  26.          */
  27.         for (int suibian : arr) { // 从arr数组中依次拿出一个值，赋值给suibian这个变量
  28.             System.out.println(suibian);
  29.         }
  30.     }
  31. }

小心数组下标越界
image.png

5、查找数组
普通查找：

  1. package com.qfedu.day03_03;
  3. /**
  4.  * @Author laoyan
  5.  * @Description TODO
  6.  * @Date 2022/3/3 14:25
  7.  * @Version 1.0
  8.  */
  9. public class Demo01 {
  10.     // 查询    10   是否在数组 arr 中,如果有返回其 下标，如果没有 -1
  12.     public static int searchElement(int[] arr, int num){
  13.         for (int i = 0; i < arr.length; i++) {
  14.             if(arr[i] == num){
  15.                 return i;
  16.             }
  17.         }
  18.         return -1;
  19.     }
  21.     public static void main(String[] args) {
  23.         int[] arr = {10,8,5,12,19};
  24.         System.out.println(searchElement(arr, 5));
  26.     }
  27. }

二分查找：

  1. package com.qfedu.day03_03;
  3. /**
  4.  * @Author laoyan
  5.  * @Description TODO
  6.  * @Date 2022/3/3 14:34
  7.  * @Version 1.0
  8.  */
  9. public class Demo02 {
  10.     /**
  11.      * 二分查找
  12.      *   1、必须有序  不管是升序还是降序
  13.      *   2、效率比较高
  14.      *
  15.      * @param args
  16.      */
  17.     public static void main(String[] args) {
  18.         //int[] arr = {1,2,3,4,5,6,7};
  19.         int[] arr = {1,2,3,4,5,6,7,9};
  20.         System.out.println(binarySearch(arr, 10));
  22.     }
  24.     //  {1,2,3,4,5,6,7}    10
  25.     public static int binarySearch(int[] arr,int num){
  26.         int middleIndex = arr.length / 2;
  27.         int start= 0,end = arr.length -1;
  28.          while(start <= end){
  29.              if(arr[middleIndex] > num){
  30.                  end = middleIndex - 1;
  31.                  middleIndex = (start + end ) / 2 ;
  32.              }
  33.              if(arr[middleIndex] < num){
  34.                  start = middleIndex + 1;
  35.                  middleIndex = (start + end ) / 2 ;
  36.              }
  37.              if(arr[middleIndex] == num){
  38.                   return middleIndex;
  39.              }
  40.          }
  41.          return  -1;
  43.     }
  44. }

6、Arrays工具类的用法

  1. package com.qfedu.day03_03;
  3. import java.util.Arrays;
  5. /**
  6.  * @Author laoyan
  7.  * @Description TODO
  8.  * @Date 2022/3/3 14:57
  9.  * @Version 1.0
  10.  *
  11.  * Arrays 工具类，专门用来处理数组的工具类
  12.  *     里面提供了大量的关于数组的 方法
  13.  *      copyOf(int[] array, int newLength)  从原数组中拷贝指定数量的元素，到一个新的数组中，并返回这个新的数组
  14.  *
  15.  * copyOfRange(int[] array, int from, int to)   从原数组中拷贝指定范围 [from, to) 的元素，到一个新的数组中，并返回这个新的数组
  16.  *
  17.  * equals(int[] array1, int[] array2)    判断两个数组是否相同
  18.  *
  19.  * fill(int[] array, int element)   使用指定的数据，填充数组
  20.  *
  21.  * sort(int[] array)  对数组进行排序（升序）
  22.  *
  23.  * binarySearch(int[] array, int element)  使用二分查找法，到数组中查询指定的元素出现的下标
  24.  *
  25.  * toString(int[] array)  将数组中的元素拼接成字符串返回
  26.  */
  27. public class Demo03 {
  28.     public static void main(String[] args) {
  30.         int[] arr ={10,8,12,9,32};
  31.         Arrays.sort(arr);
  32.         System.out.println(Arrays.toString(arr));
  33.         int num = Arrays.binarySearch(arr, 7);
  34.         System.out.println(num!=-1 ? "查找到了":"不存在");
  36.         // 从一个老的数组中拷贝一份给新数组，如果新数组长度比老数组大，用默认值填充
  37.         int[] ints = Arrays.copyOf(arr, 10);
  38.         System.out.println(Arrays.toString(ints));
  40.         int[] arr2 ={10,8,12,9,32};
  41.         int[] arr3 ={10,8,12,9,32};
  42.         System.out.println(Arrays.equals(arr3,arr2));// 比较的是两个数组的内容
  43.         System.out.println(arr2 == arr3); // 比较的是内存地址
  44.         System.out.println(arr2.equals(arr3));// 比较的是内存地址
  45.         int[] arr4 = Arrays.copyOfRange(arr3,1,arr3.length);
  46.         System.out.println(Arrays.toString(arr4));
  47.         // 使用默认值更改里面所有的元素
  48.         Arrays.fill(arr3,100);
  49.         int[] arr5 = new int[100];
  50.         Arrays.fill(arr5,5);
  51.         System.out.println(Arrays.toString(arr3));
  54.     }
  55. }

7、可变长参数的用法

  1. package com.qfedu.day03_03;
  3. import java.util.Arrays;
  5. /**
  6.  * @Author laoyan
  7.  * @Description TODO
  8.  * @Date 2022/3/3 15:50
  9.  * @Version 1.0
  10.  */
  11. public class Demo04 {
  13.     public static void show(String name,int ... nums){
  14.         System.out.println(name);
  15.         System.out.println(nums);
  16.         System.out.println(Arrays.toString(nums));
  17.         for (int i:nums) {
  18.             System.out.println(i);
  19.         }
  20.         System.out.println(nums.length);
  21.     }
  23.     /*
  24.       可变长参数，只能放在参数列表的最后一位，操作起来跟数组一样。
  25.     public static void show(int ... nums,String name){
  26.         System.out.println(name);
  27.         System.out.println(nums);
  28.         System.out.println(Arrays.toString(nums));
  29.         for (int i:nums) {
  30.             System.out.println(i);
  31.         }
  32.         System.out.println(nums.length);
  33.     }*/
  36.     public static void main(String[] args) {
  38.         System.out.printf("你的年龄是%d,你的身高是%d",18,210);
  40.         show("zhangsan",1,3,5,10);
  42.     }
  43. }

8、排序
八大排序算法
1）选择排序
选择排序：固定值与其他值依次比较大小，互换位置。
image.png

  1. package com.qfedu.day03_03;
  3. import java.util.Arrays;
  5. /**
  6.  * @Author laoyan
  7.  * @Description TODO
  8.  * @Date 2022/3/3 16:10
  9.  * @Version 1.0
  10.  *
  11.  *   选择排序：  先固定一个位置，然后依次与后面的值比较，如果大于后者小于后者，就交换位置。 // 拿到最大值或者最小值
  12.  *              第一轮交换完成之后，固定下一个位置，以后与后年的值比较
  13.  */
  14. public class Demo05 {
  15.     public static void main(String[] args) {
  16.         int[] arr = {10,8,6,14,19};
  17.         for(int m = 0;m < arr.length;m++){
  18.             for(int n=m; n< arr.length;n++){
  19.                 if(arr[m]>arr[n]){
  20.                     arr[m]= arr[m] ^ arr[n];
  21.                     arr[n]= arr[m] ^ arr[n];
  22.                     arr[m]= arr[m] ^ arr[n];
  23.                 }
  24.             }
  26.         }
  28.         System.out.println(Arrays.toString(arr));
  29.     }
  30. }

2) 冒泡排序
冒泡排序：相邻的两个数值比较大小，互换位置
image.png

  1. package com.qfedu.day03_03;
  3. import java.util.Arrays;
  5. /**
  6.  * @Author laoyan
  7.  * @Description TODO
  8.  * @Date 2022/3/3 16:25
  9.  * @Version 1.0
  10.  */
  11. public class Demo06 {
  12.     public static void main(String[] args) {
  14.         int[] arr = {10,9,7,5};
  15.         int num = arr.length;
  16.         for(num=arr.length;num > 1;num--){
  18.             for(int m=0;m< num -1 ;m++){
  19.                 if(arr[m]>arr[m+1]){
  20.                     arr[m]= arr[m] ^ arr[m+1];
  21.                     arr[m+1]= arr[m] ^ arr[m+1];
  22.                     arr[m]= arr[m] ^ arr[m+1];
  23.                 }
  24.             }
  25.             System.out.println(Arrays.toString(arr));
  26.         }
  29.     }
  30. }
package com.qfedu.day03_03;

import java.util.Arrays;

/**
 * @Author laoyan
 * @Description TODO
 * @Date 2022/3/3 16:25
 * @Version 1.0
 */
public class Demo06 {
    public static void main(String[] args) {

        int[] arr = {10,9,7,5};
        int num = arr.length;
        while(num > 1){
            num--;
            for(int m=0;m<num;m++){
                if(arr[m]>arr[m+1]){
                    arr[m]= arr[m] ^ arr[m+1];
                    arr[m+1]= arr[m] ^ arr[m+1];
                    arr[m]= arr[m] ^ arr[m+1];
                }
            }
            System.out.println(Arrays.toString(arr));
        }


    }
}

/**
 * @Author 千锋大数据教学团队
 * @Company 千锋好程序员大数据
 * @Description 冒泡排序
 */
public class Test {
    public static void main(String[] args) {
        // 实例化一个数组
        int[] array = { 1, 2, 3, 4, 5 };
        // 冒泡排序
        sort(array);
    }
    /**
     * 使用冒泡排序进行升序排序
     * @param array 需要排序的数组
     */
    public static void sort(int[] array) {
        // 1. 确定要进行多少趟的比较
        for (int i = 0; i < array.length - 1; i++) {
            // 2. 每趟比较，从第0位开始，依次比较两个相邻的元素
            for (int j = 0; j < array.length - 1 - i; j++) {
                // 3. 比较两个相邻的元素
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
}

9、递归
所谓递归：方法自己调用自己，在某个时刻退出。
1） 使用递归计算数的阶乘。
4！= 4 3 2 1
4! = 4 3！
1! = 1

package com.qfedu.day03_04;

/**
 * @Author laoyan
 * @Description TODO
 * @Date 2022/3/3 16:35
 * @Version 1.0
 */
public class Demo01 {

    /**
     * 给定一个值，求这个值的阶乘
     *
     *   4！= 4 * （4-1）！
     *   num! = num * (num-1)!
     * @param num
     * @return
     */
    public static int getJieCheng(int num){
        if(num == 1){
            return 1;
        }
        return  num * getJieCheng(num-1);
    }


    public static void main(String[] args) {

        System.out.println(getJieCheng(4));
    }
}

2、求斐波那契数列中的某个数

package com.qfedu.day03_04;

/**
 * @Author laoyan
 * @Description TODO
 * @Date 2022/3/3 16:42
 * @Version 1.0
 */
public class Demo02 {

    public static int getFeiBo(int index){
        // 10    第9个+第8个
        if(index == 1 || index == 2){
            return 1;
        }
        return getFeiBo(index-1)+getFeiBo(index-2);
    }
    //  求斐波那契数列中的某个数
    public static void main(String[] args) {
        System.out.println(getFeiBo(10));
    }
}

10、时间复杂度（了解）