一、知识点（必做）:

CalendarDemo.java

需求：创建Calendar对象，并分别设置和获取日期的年、月、日、时、分、秒。

作业目的：掌握Calendar对象的创建，简单的设置和获取日期信息。

  1. package hk.calendar;
  3. import java.text.SimpleDateFormat;
  4. import java.util.Calendar;
  6. public class CalendarDemo {
  7.    public static void main(String[] args) {
  8. /**
  9. * 需求：创建Calendar对象，并分别设置和获取日期的年、月、日、时、分、秒。
  10. * 作业目的：掌握Calendar对象的创建，简单的设置和获取日期信息。
  11. */
  13.        Calendar calendar = Calendar.getInstance();
  14.        int year = calendar.get(Calendar.YEAR);
  15.        int month = calendar.get(Calendar.MONTH);
  16.        int day = calendar.get(Calendar.DATE);
  17.        int hour = calendar.get(Calendar.HOUR_OF_DAY);
  18.        int minute = calendar.get(Calendar.MINUTE);
  19.        int second = calendar.get(Calendar.SECOND);
  20.        int week = calendar.get(Calendar.WEEK_OF_MONTH);
  21.        System.out.println(calendar.getTime());
  22.    }
  23. }

RegexDemo.java

需求：

  • 判断一个字符串是否全部有数字组成
  • 判断一个字符串是否是手机号码
  • 判断一个字符串是否是18位身份证号码
  • 判断一个字符串是否6到16位，且第一个字必须为字母

作业目的：了解正则表达式是什么东西，以后会查正则表达式即可。

  1. package hk.regex;
  3. public class RegexDemo {
  4. public static void main(String[] args) {
  5.        /**
  6.         * 需求：
  7.         *- 判断一个字符串是否全部有数字组成
  8.         *- 判断一个字符串是否是手机号码
  9.         * - 判断一个字符串是否是18位身份证号码
  10.         *- 判断一个字符串是否6到16位，且第一个字必须为字母
  11.         * 作业目的：了解正则表达式是什么东西，以后会查正则表达式即可。
  12.         */
  14. // 判断一个字符串是否全部有数字组成
  15. System.out.println("12345678S".matches("\\d"));// false
  16. System.out.println("12345678".matches("\\d"));// false
  17. System.out.println("12345678".matches("\\d*"));// true
  18. System.out.println("1234".matches("\\d{5,10}"));// false
  19. System.out.println("12345678".matches("\\d{5,10}"));// true
  20. // 判断一个字符串是否是手机号码
  21. String regex1 = "^1[3|4|5|7|8][0-9]{9}$";
  22. System.out.println("12712345678".matches(regex1));// false
  23. System.out.println("13712345678".matches(regex1));// true
  24. // 判断一个字符串是否是18位身份证号码
  25. String regex2 = "\\d{17}[[0-9]X]";
  26. System.out.println("511123200110101234".matches(regex2));// true
  27. System.out.println("51112320011010123X".matches(regex2));// true
  28. System.out.println("51112320011010123S".matches(regex2));// false
  29. // 判断一个字符串是否6到16位，且第一个字必须为字母
  30.   String regex3 = "^[a-zA-Z]\\w{5,15}$";
  31.   System.out.println("will".matches(regex3));// false
  32.   System.out.println("17will".matches(regex3));//false
  33.   System.out.println("will17willwillwill".matches(regex3));//false
  34.   System.out.println("will17".matches(regex3));// true
  35.    }
  36. }

DEBUG调试功能（重点）

需求：Debug调试

步骤：

（1）打断点

（2）以Debug As模式运行程序

ArrayCopyDemo.java（重点）

需求：定义一个方法，进行数组拷贝，并调用System中的数组拷贝方法

思路：

数组高级 - 图1

  1. package hk.arraycopy;
  3. import wolfcode._03_arracopy.ArrayUtils;
  5. public class ArrayCopyDemo {
  6.     public static void main(String[] args) {
  7.         /**
  8.          * 需求：定义一个方法，进行数组拷贝，并调用System中的数组拷贝方法
  9.          *思路：
  10.          *
  11.          */
  12.         int[] srcArr = {10, 20, 30, 40, 50, 60, 70, 80, 90};
  13.         int[] destArr = new int[10];
  14.         wolfcode._03_arracopy.ArrayUtils.arrayCopy(srcArr, 0, destArr, 2, 5);
  15.         for (int item : srcArr) {
  16.             System.out.println(item + "");
  18.         }
  19.         System.out.println();
  20.         for (int item : destArr) {
  21.             System.out.println(item + "");
  22.         }
  23.     }
  24.     public static class ArrayUtils {
  25.         public static void arrayCopy(int[] srcArr, int srcIndex, int[] destArr, int dextIndex, int length) {
  26.             for (int i = 0; i < length; i++) {
  27.                 destArr[dextIndex + i] = srcArr[srcIndex + i];
  28.             }
  29.         }
  30.     }
  31. }

ArraySortDemo.java

需求：定义一个方法，进行数组排序，并调用Arrays中的排序方法

思路：

（1）第一趟比较

  1.         遍历所有元素，比较元素之间的大小，上一个元素>下一个元素，两个元素进行交换

（2）比较多趟之后，总结规律

  1. package hk.arraysort;
  3. import wolfcode._04_sort.ArraysUtils;
  5. public class ArraySortDemo {
  6.    public static void main(String[] args) {
  7.        /**
  8.         * 需求：定义一个方法，进行数组排序，并调用Arrays中的排序方法
  9.         * 思路：
  10.         * （1）第一趟比较
  11.         *遍历所有元素，比较元素之间的大小，上一个元素>下一个元素，两个元素进行交换
  12.         * （2）比较多趟之后，总结规律
  13.         */
  15.        int[] arr = new int[]{2, 9, 6, 7, 4, 1};
  16.        ArraysUtils.bubbleSort(arr);
  19.    }
  21.    public abstract static class ArraysUtils {
  22.        public static void bubbleSort(int[] arr) {
  23.            int temp;
  24.            //控制轮数6个数，需要5轮完全有序
  25.            for (int i = 0; i < arr.length - 1; i++) {
  26.                //每一轮两两比较
  27.                for (int j = 0; j < arr.length - 1 - i; j++) {
  28.                    if (arr[j] > arr[j + 1]) {
  29.                        temp = arr[j];
  30.                        arr[j] = arr[j + 1];
  31.                        arr[j + 1] = temp;
  33.                    }
  34.                }
  36.            }
  37.            for (int item : arr) {
  38.                System.out.print(item + " ");
  40.            }
  41.        }
  42.    }
  43. }

ArraySreachDemo2.java

需求：定义一个方法，进行数组二分查找，并调用Arrays中的二分查找方法

思路：

数组高级 - 图2

  1. package hk.arraysearch;
  3. import wolfcode._05_search.ArrayUtils;
  5. public class ArraySearchDemo {
  6.     public static void main(String[] args) {
  7.         /**
  8.          * 需求：定义一个方法，进行数组二分查找，并调用Arrays中的二分查找方法
  9.          * 思路：
  10.          */
  11.         int[] arr = {1, 2, 3, 5, 6};
  12.         int index = binarySeach(arr, 3);
  13.         System.out.println(index);
  15.     }
  18.         public static int binarySeach(int[] arr, int key) {
  19.             int low = 0;
  20.             int high = arr.length - 1;
  21.             int mid = (low + high) / 2;
  22.             int midvalue = arr[mid];
  23.             if (key == midvalue) {
  24.                 return mid;
  25.             } else if (key > midvalue) {
  26.                 low = mid + 1;
  27.             } else {
  28.                 high = mid - 1;
  29.             }
  30.             return -1;
  31.         }
  32. }

ArraysDemo.java

需求：Arrays常用方法

步骤：

（1）调用Arrays中的toString来打印数组的元素

（2）调用Arrays中的sort来排序数组的元素

（3）调用Arrays中的binarySearch来查找数组元素，并观察返回值

（4）调用Arrays中的copyOf来复制数组，并打印复制的数组中的元素，并对比System.arraycopy

  1. package hk.arrays;
  2. import java.util.Arrays;
  4. public class ArraysDemo {
  5.     public static void main(String[] args) {
  6.         /**
  7.          * 需求：Arrays常用方法
  8.          * 步骤：
  9.          *（1）调用Arrays中的toString来打印数组的元素
  10.          *（2）调用Arrays中的sort来排序数组的元素
  11.          * （3）调用Arrays中的binarySearch来查找数组元素，并观察返回值
  12.          * （4）调用Arrays中的copyOf来复制数组，并打印复制的数组中的元素，并对比System.arraycopy
  13.          */
  15.         int[] arr = {1, 32, 325, 11, 367};
  16.         System.out.println(Arrays.toString(arr));//打印数组元素
  17.         Arrays.sort(arr);//排序
  18.         System.out.println(Arrays.toString(arr));//排序后打印
  19.         System.out.println(Arrays.binarySearch(arr,32));//binarySearch查找元素
  20.         int[] str1 = Arrays.copyOf(arr, 6);//copyof复制数组
  21.         System.out.println(Arrays.toString(str1));//复制后打印数组
  22.     }
  23. }

二、综合练习（必做）:

SreachDemo.java

需求：字符数组char[] arr={‘A’,‘1’,‘R’,‘!’,‘e’,‘&’,‘A’,‘5’,‘A’,‘g’,‘#’,‘D’}，请使用循环，统计出其中英文字母‘A’的个数。

  1. public class SearchDemo {
  2.     public static void main(String[] args) {
  3.         /**
  4.          * 需求：字符数组char[] arr={‘A’,‘1’,‘R’,‘!’,‘e’,‘&’,‘A’,‘5’,‘A’,‘g’,‘#’,‘D’}，
  5.          * 请使用循环，统计出其中英文字母‘A’的个数。
  6.          */
  7.         char[] arr={'A','1','R','!','e','&','A','5','A','g','#','D'};
  8.         int sum=0;
  9.         for (char item:arr) {
  10.             if(item=='A'){
  11.                sum++;
  12.             }
  13.         }
  14.         System.out.println(sum);
  15.     }
  16. }

ChangeDemo.java

需求：定义一个方法transfer(int[] arr, int index1, int index2)实现交换数组arr中索引为index1和index2对应元素的值。

  1. package hk.change;
  2. import java.util.Arrays;
  4. public class ChangeDemo {
  5.     public static void main(String[] args) {
  6.         /**
  7.          * 需求：定义一个方法transfer(int[] arr, int index1, int index2)
  8.          * 实现交换数组arr中索引为index1和index2对应元素的值。
  9.          */
  10.         int[] arr = {12, 121, 42, 65, 99, 88};
  11.         transfer(arr, 0, 4);
  12.         System.out.println(Arrays.toString(arr));
  13.     }
  15.     public static void transfer(int[] arr, int index1, int index2) {
  16.         int t = arr[index1];
  17.         arr[index1] = arr[index2];
  18.         arr[index2] = t;
  19.     }
  20. }

CalendarDemo2.java

需求：查询某个时间最近一周的信息，如何表示最近这一周的开始时间和结束时间

作业目的：熟悉Calendar类中的方法。

  1. package hk.calendar2;
  3. import java.text.SimpleDateFormat;
  4. import java.util.Calendar;
  5. import java.util.Date;
  7. public class CalendarDemo2 {
  8.    public static void main(String[] args) {
  9.        /**
  10.         * 需求：查询某个时间最近一周的信息，如何表示最近这一周的开始时间和结束时间
  11.         * 作业目的：熟悉Calendar类中的方法。
  12.         */
  13.        SimpleDateFormat df = new SimpleDateFormat();
  14.        df.applyPattern("yyyy-MM-dd HH:mm:ss");
  15.        String dateStr="2022-03-07 19:18:26";
  16.        Calendar cal = Calendar.getInstance();
  17.        cal.set(Calendar.HOUR_OF_DAY,23);
  18.        cal.set(Calendar.MINUTE,59);
  19.        cal.set(Calendar.SECOND,59);
  20.        Date endDate =cal.getTime();
  21.        System.out.println("endDate="+endDate);
  22.        cal.add(Calendar.SECOND,1);
  23.        cal.add(Calendar.DAY_OF_MONTH,-7);
  24.        Date beginDate =cal.getTime();
  25.        System.out.println("beginDate="+beginDate);
  26.    }
  27. }

三、 拓展练习（选做）

PrimeNumberDemo.java

需求：请输出1-100以内最大的五个质数(质数又称素数。一个大于1的自然数，如果除了1和它自身外，不能被其他自然数整除的数)。

思路：

（1）一个数num和[2，num)这个范围的数进行对比，如果能被整除就不需要进行对比

（2）5个数，那么需要我们定义一个计数器，来记录符合要求的个数

（3）最大的需要我们倒着循环

FallDemo.java

需求：在main方法中实现如下功能并打印结果：一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？

数组高级 - 图3