相关链接
目录
All From 传智培训课程 + 后期自己整理补充内容
P10 【常用API】数组排序和Arrays工具类、包装类、Date
1 数组排序和Arrays工具类
1.1 数组的冒泡排序
-
冒泡排序 ：相邻的两个元素两两比较,元素值较大的元素依次向后置换.
-
数组排序之冒泡排序原理图解
案例代码一 数组排序(冒泡排序)
package com.groupies.base.day10;
/**
* @author GroupiesM
* @date 2021/4/2
* @introduction 数组排序：(冒泡排序)
*
* 冒泡排序的基本原理：
* 相邻元素两两比较，大的往后放。
* 第一次比较，比较完毕后，最大值就出现在了最大索引处。
* 第二次比较，比较完毕后，次最大值就出现在了次最大索引处
* ...
* 最终我们得到了一个排序好的数组
* ==================================================
* Q:如何交换哪两个数据呢?
* int a = 10;
* int b = 20;
*
* A:采用临时变量
* int temp = a;
* a = b;
* b = temp;
* ==================================================
* 原始数组 arr
* --------------------------
* | 24 | 69 | 80 | 57 | 13 |
* --------------------------
* 0 1 2 3 4
* ==================================================
* 第一次比较
* --------------------------
* |【24】| 69 | 80 | 57 | 13 | 【不交换】
* --------------------------
* 0 -> 1 2 3 4
*
* --------------------------
* | 24 |【69】| 80 | 57 | 13 | 【不交换】
* --------------------------
* 0 1 -> 2 3 4
*
* -------------------------- temp=arr[2];
* | 24 | 69 |【80】| 57 | 13 | 【交换2和3】 arr[2]=arr[3];
* -------------------------- arr[3]=temp;
* 0 1 2 -> 3 4
*
* -------------------------- temp=arr[3];
* | 24 | 69 | 57 |【80】| 13 | 【交换3和4】 arr[3]=arr[4];
* -------------------------- arr[4]=temp;
* 0 1 2 3 -> 4
*
* --------------------------
* | 24 | 69 | 57 | 13 |【80】| 【第一次比较完毕】
* --------------------------
* 0 -> 1 -> 2 -> 3 -> 4
* ==================================================
* 第二次比较
* --------------------------
* |【24】| 69 | 57 | 13 | 80 | 【不交换】
* --------------------------
* 0 -> 1 2 3 4
*
* --------------------------
* | 24 |【69】| 57 | 13 | 80 | 【交换1和2】
* --------------------------
* 0 1 -> 2 3 4
*
* --------------------------
* | 24 | 57 |【69】| 13 | 80 | 【交换2和3】
* --------------------------
* 0 1 2 -> 3 4
*
* --------------------------
* | 24 | 57 | 13 |【69】|【80】| 【第二次比较完毕】 得到了最大值arr[4]和次最大值arr[3]
* --------------------------
* 0 -> 1 -> 2 -> 3 -> 4
* ==================================================
* .....
* ==================================================
* 第四次比较
* ...
* -------------------------------
* |【13】|【24】|【57】|【69】|【80】| 【第四次比较完毕】
* -------------------------------
* 0 -> 1 -> 2 -> 3 -> 4
* ==================================================
* 规律一：
* 第一次比较完毕后，下一次的比较就会少一个元素参加;
* 第一次比较，5个元素，比较4次(arr.length - 1);
* 第二次比较，5个元素，比较3次(arr.length - 2);
* ...
* 第n次比较，5个元素，比较5-n次(arr.length - n);
*
* 规律二：
* 总共需要比较 arr.length - 1 次。
*/
public class Demo1BubbleSort {
public static void main(String[] args) {
//初始数组（静态初始化）
int[] arr1 = {24, 69, 80, 57, 13};
int[] arr2 = {24, 69, 80, 57, 13};
//arr1
System.out.print("=======arr1=======");
//第一次比较
bubbleSortOnce(arr1, 1);
printArr(arr1, 1);//第1次比较：[24,69,57,13,80]
//第二次比较
bubbleSortOnce(arr1, 2);
printArr(arr1, 2);//第2次比较：[24,57,13,69,80]
//第三次比较
bubbleSortOnce(arr1, 3);
printArr(arr1, 3);//第3次比较：[24,13,57,69,80]
//第四次比较
bubbleSortOnce(arr1, 4);
printArr(arr1, 4);//第4次比较：[13,24,57,69,80]
//arr2
System.out.print("\r\n=======arr2=======");
/* =======arr2=======
第1次比较：[24,69,57,13,80]
第2次比较：[24,57,13,69,80]
第3次比较：[24,13,57,69,80]
第4次比较：[13,24,57,69,80]
*/
for (int i = 1; i < arr1.length; i++) {
bubbleSortOnce(arr2, i);
printArr(arr2, i);
}
}
/**
* @introduction 按照格式打印数组
* @param arr 待排序的数组
* @param count
*/
public static void printArr(int[] arr, int count) {
System.out.print("\r\n第" + count + "次比较结果：[");
StringBuilder sb = new StringBuilder();
for (int i = 0; i < arr.length; i++) {
sb.append(arr[i] + ",");
}
//去掉最后一个逗号
System.out.print(new StringBuilder(sb.toString().substring(0, sb.length() - 1)).append("]"));
}
/**
* @introduciton 冒泡排序一次
* @param arr
* @param count 第n次比较，5个元素，比较5-n次(arr.length - n);
*/
public static void bubbleSortOnce(int[] arr, int count) {
for (int i = 0; i < arr.length - count; i++) {
if (arr[i] > arr[i + 1]) {
int temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
}
}
1.2 Arrays工具类
-
Arrays ：提供了对数组操作的各种方法。
public static String toString(int[] a):把数组转成字符串 public static void sort(int[] a):对数组进行升序排序 -
Arrays类中构造方法的问题
-
Arrays类中真的没有构造方法吗?
一个类中没有构造方法，系统将提供一个无参构造方法。
而我们在帮助文档中没有看到Arrays类的构造方法，这是为什么呢?
Arrays类中有构造方法，只不过构造方法被private修饰，外界是无法使用的。因为外界无法使用，所以帮助文档中就看不到。
-
通过查看源码，我们找到了如下的内容：
private Arrays() {}
-
-
工具类的设计思想（Arrays、Math、Collections）
- 构造方法私有;
- 成员都用static修饰;
案例代码二 Arrays类的概述和使用
package com.groupies.base.day10;
import java.util.Arrays;
/**
* @author GroupiesM
* @date 2021/4/12
* @introduction Arrays类的概述和使用
*
* Arrays: 提供了对数组操作的各种方法。
*
* public static String toString(int[] a): 把数组转成字符串
*
* public static void sort(int[] a): 对数组进行升序排序
*/
public class Demo2Arrays {
public static void main(String[] args) {
//定义一个数组
int[] arr = {24, 69, 80, 57, 13};
//public static String toString(int[] a):把数组转成字符串
System.out.println("排序前：" + Arrays.toString(arr));
//public static void sort(int[] a):对数组进行升序排序
Arrays.sort(arr);
System.out.println("排序后：" + Arrays.toString(arr));
}
}
2 包装类
2.1 基本类型包装类
- 需求：我要判断一个数据是否在int范围内?
- 要想判断一个数据是否在int范围内，首先我们得知道int范围，在前面我们讲解基本数据类型的时候说过了：
- -2147483648 到 2147483647
- 为了对基本数据类型进行更多更方便的操作，Java就针对每一种基本数据类型提供了一个对应的引用类型。
- 作用
- 基本数据类型包装类最常用就是用于和字符串之间进行相互转换
- 基本类型包装类
- Byte byte
- Short short
- Integer int
- Long long
- Float float
- Double double
- Character char
- Boolean boolean
2.2 Integer类
- Integer
- Integer类 在对象中包装了一个基本类型 int 的值。
- 构造方法
- Integer(int value)
- Integer(String s)
- 注意
- 这个字符串必须由数字字符组成
案例代码三 Integer类的概述和构造方法
package com.groupies.base.day10;
/**
* @author GroupiesM
* @date 2021/4/12
* @introduciton Integer类的概述和构造方法
*
* Integer:Integer类在对象中包装了一个基本类型 int 的值。
*
* 构造方法：
* Integer(int value)
* Integer(String s)
* 注意：这个字符串必须由数字字符组成
*/
public class Demo3IntegerToString {
public static void main(String[] args) {
//Integer(int value)
int value = 100;
Integer i = new Integer(value);
System.out.println(i); //100
System.out.println("------------");
//Integer(String s)
String s = "100";
//NumberFormatException:数据格式化异常
//String s = "abc";
Integer ii = new Integer(s);
System.out.println(ii);
}
}
2.3 int <=> String 相互转换
-
int类型和String类型的相互转换
-
int --> String
-
String类中：
String.valueOf()public static String valueOf(int i)
-
-
String --> int
-
Integer类中：
Integer.parseInt()public static int parseInt(String s)
-
-
案例代码四 int类型和String类型的相互转换
package com.groupies.base.day10;
/**
* @author GroupiesM
* @date 2021/4/12
* @introduction int类型和String类型的相互转换
*
* int类型和String类型的相互转换
*
* int --> String
* 方式一： "" + int;
* 方式二： String类中 public static String valueOf(int i) {
* return Integer.toString(i);
* }
*
* String --> int
* 方式一： Integer的带参构造 new Integer(String); int = Integer.intValue();
* 方式二： Integer类中 public static int parseInt(String s) throws NumberFormatException {
* return parseInt(s,10);
* }
*/
public class Demo4IntTransString {
public static void main(String[] args) {
//TODO 【int --> String】
int number = 100;
//方式1
String s1 = "" + number;
System.out.println(s1);//100
//方式2 public static String valueOf(int i)
String s2 = String.valueOf(number);
System.out.println(s2);
System.out.println("--------------");
//TODO 【String --> int】
String s = "100";
//方式1 String --> Integer --> Integer.intValue --> int
Integer i = new Integer(s);
int x = i.intValue();
System.out.println(x);
//方式2 public static int parseInt(String s)
int y = Integer.parseInt(s);
System.out.println(y);
}
}
2.4 Integer练习之把字符串中的数据排序
-
需求
- 我有如下一个字符串:”91 27 46 38 50”
- 请写代码实现最终输出结果是：”27 38 46 50 91”
-
提示
-
这里需要参考String类中的方法
public String[] split(String regex)
-
案例代码五 Integer的练习之把字符串中的数据排序
package com.groupies.base.day10;
import java.util.Arrays;
/**
* @author GroupiesM
* @date 2021/4/12 0012
* @introduction Integer的练习之把字符串中的数据排序
*
* 需求：
* 我有如下一个字符串:”91 27 46 38 50”
* 请写代码实现最终输出结果是：”27 38 46 50 91”
* 提示：这里需要参考String类中的方法
* public String[] split(String regex)
*
* 分析：
* A:定义一个字符串对象
* B:把字符串中的数字数据存储到一个int类型的数组中
* C:对int数组进行排序
* D:把排序后的数组中的元素进行拼接得到一个字符串
* E:输出字符串
*/
public class Demo5StringSort {
public static void main(String[] args) {
//定义一个字符串对象 String
String s = "91 27 46 38 50";
//把字符串中的数字数据存储到一个int类型的数组中
//String -> String.split(String regex) -> String[] strArr
String[] strArr = s.split(" ");
//定义一个数组 String[] strArr -> int[] arr
int[] arr = new int[strArr.length];
for (int i = 0; i < arr.length; i++) {
arr[i] = Integer.parseInt(strArr[i]);
}
//对int数组进行排序 int[] arr -> Arrays.sort -> int[] arr
Arrays.sort(arr);
//int --> StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 0; i < arr.length; i++) {
if (i == 0) sb.append("【").append(arr[i]);
sb.append(arr[i]).append(" ");
if (i == arr.length - 1) sb.append(arr[i]).append("】");
}
//查看结果
System.out.println("遍历排序后的int数组：");
System.out.println(sb.toString());
}
}
2.5 JDK5 的新特性【自动装箱、拆箱】
-
JDK5新特性
-
自动装箱
- 把基本数据类型转换为对应的包装类类型
public static Integer valueOf(int i) -
自动拆箱
- 把包装类类型转换为对应的基本数据类型
public int intValue()
-
-
Java程序的运行
- 编写java文件 --> 编译生成class文件 --> 执行
-
注意
- 在使用包装类类型的新特性的时候，如果做操作，最好先判断是否为null。
-
开发原则
- 只要是对象，在使用前就必须进行不为null的判断。
案例代码六 JDK5的新特性自动装箱和拆箱
package com.groupies.base.day10;
/**
* @author GroupiesM
* @date 2021/4/12
* @introduction JDK5的新特性自动装箱和拆箱
*
* JDK5新特性：
* 自动装箱：把基本数据类型转换为对应的包装类类型
* public static Integer valueOf(int i)
* 自动拆箱：把包装类类型转换为对应的基本数据类型
* public int intValue()
*
* Java程序的运行：
* 编写java文件 -- 编译生成class文件 -- 执行
*
* 注意：在使用包装类类型的新特性的时候，如果做操作，最好先判断是否为null。
*
* 开发中的原则：
* 只要是对象，在使用前就必须进行不为null的判断。
*/
public class Demo6Packaging {
public static void main(String[] args) {
//自动装箱 创建一个包装类类型的对象 Integer i = new Integer(100);
Integer ii = 100;//Integer ii = Integer.valueOf(100);
//自动拆箱,自动装箱 ii = ii + 200; Integer.valueOf(ii)
ii = Integer.valueOf(ii.intValue() + 200);
ii += 200;
/* 静态方法 valueOf() 可以通过类名直接调用
public static Integer valueOf(String s, int radix) throws NumberFormatException {
return Integer.valueOf(parseInt(s,radix));
}
*/
System.out.println("Integer.intValue:" + ii.intValue());
System.out.println(ii);
/* 非静态方法 intValue() 不能直接调用，可以通过成员调用
public int intValue() {
return value;
}
*/
Integer iii = null;
//只要是对象，在使用前就必须进行不为null的判断 避免空指针异常 NullPointerException
if (iii != null) {
iii += 300;
System.out.println(iii);
}
}
}
3 Date、SimpleDateFormat类
3.1 Date
-
Date
- Date表示特定的瞬间，精确到毫秒。
-
构造方法
- Date()
- 根据当前时间创建的日期对象
- Date(long date)
- 根据给定的毫秒值创建对象，从1970 年 1 月 1 日 00:00:00
- Date()
案例代码七 Date类的概述和构造方法
package com.groupies.base.day10;
import java.util.Date;
/**
* @author GroupiesM
* @date 2021/4/12
* @introduction Date类的概述和构造方法
*
* import java.util.Date;
* Date:Date表示特定的瞬间，精确到毫秒。
*
* 构造方法：
* Date():根据当前时间创建的日期对象
* Date(long date):根据给定的毫秒值创建对象，从1970 年 1 月 1 日 08:00:00开始的。
*/
public class Demo7DateConstructor {
public static void main(String[] args) {
//Date()
Date d1 = new Date();
System.out.println(d1);//Mon Apr 12 16:32:10 CST 2021
//Date(long date)
long date = 1000 * 60 * 60;//1秒*60*60=1小时 ，从8点向后一小时即9点
Date d2 = new Date(date);
System.out.println(d2);//Thu Jan 01 09:00:00 CST 1970
}
}
3.2 Date.getTime()/setTime()
- Date成员方法
- public long getTime()：获取的是毫秒值。从1970年1月1日 00:00:00开始的。
- public void setTime(long time)：设置时间，给的是毫秒值。
- getTime()
- 从Date得到一个毫秒值
- setTime(long time)
- 从一个毫秒值得到一个Date对象
案例代码八 Date类的成员方法getTime()和setTime()
package com.groupies.base.day10;
import java.util.Date;
/**
* @author GroupiesM
* @date 2021/4/12
* @introduction Date类的成员方法getTime()和setTime()
*
* public long getTime():获取的是毫秒值。从1970年1月1日 00:00:00开始的。
* public void setTime(long time):设置时间，给的是毫秒值。
*
* 从Date得到一个毫秒值：
* getTime()
*
* 从一个毫秒值得到一个Date对象
* 构造方法
* setTime(long time)
*/
public class Demo8DateMethod {
public static void main(String[] args) {
//创建对象
Date d = new Date();
//Date.getTime(0
System.out.println("getTime:" + d.getTime());//getTime:1618216915269
//Date.setTime(long Time)
d.setTime(1000 * 60 * 60);
System.out.println("setTime:" + d.getTime());//setTime:3600000
}
}
3.3 SimpleDateFormat
-
SimpleDateFormat
- 是一个以与语言环境有关的方式来格式化和解析日期的具体类。
- 它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）
-
格式化（日期 -> 文本）: Date --> String
- public final String format(Date date)
-
解析（文本 -> 日期）: String --> Date
- public Date parse(String source)
案例代码九 SimpleDateFormat类的概述和使用
package com.groupies.base.day10;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* @author GroupiesM
* @date 2021/4/12
* @introduction SimpleDateFormat类的概述和使用
*
* SimpleDateFormat:是一个以与语言环境有关的方式来格式化和解析日期的具体类。
* 它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）
*
* 格式化（日期 -> 文本）: Date -- String
* public final String format(Date date)
*
* 解析（文本 -> 日期）: String -- Date
* public Date parse(String source)
*/
public class Demo9SimpleDateFormat {
public static void main(String[] args) {
//Ddate --> String
Date d1 = new Date();
System.out.println("d1指定模式前：" + d1);//Mon Apr 12 16:56:29 CST 2021
/* 现在虽然实现了把日期格式化成一个字符串，但是不是我们想要的格式
我们想要的格式是：xxxx年xx月xx日 xx:xx:xx
SimpleDateFormat(): 用默认的模式
SimpleDateFormat sdf = new SimpleDateFormat();
SimpleDateFormat(String pattern):用给定的模式
*/
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy 年 MM 月 dd 日 HH:mm:ss");
String s = sdf1.format(d1);
System.out.println("d1指定模式后：" + s); 2021 年 04 月 12 日 16:55:56
//String --> Date
String str = "2080-08-08 12:23:45";
//把一个字符串解析为日期的时候，请注意模式字符串和给定的日期字符串的格式要匹配
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//需要对解析异常进行处理 快捷键：ctrl + alt + T
try {
Date d2 = sdf2.parse(str);
System.out.println("d2:" + d2);//Thu Aug 08 12:23:45 CST 2080
} catch (ParseException e) {
e.printStackTrace();//打印异常信息
System.out.println("字符串格式异常，请重新输入，【格式：yyyy-MM-dd HH:mm:ss】");
}
}
}
3.4 Date的练习之日期工具类的定义和使用
3.4.1 制作工具类DateUtil
案例代码十 Date的练习之日期工具类的定义和使用
package com.groupies.base.day10;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* @author GroupiesM
* @date 2021/04/12
* @introduction Date的练习之日期工具类的定义和使用
*
* 工具类
*
* 构造方法私有
* 成员方法静态
*/
public class Demo10DateUtils {
/**
* @introduction 工具类 把日期转换为指定格式的字符串
* @param date 原始date格式日期
* @param format 指定date日期格式
* @return 转换后的date日期格式
*/
public static String dateToString(Date date, String format) {
SimpleDateFormat sdf = new SimpleDateFormat(format);
String s = sdf.format(date);
return s;
}
/**
* @introduction 把指定格式的字符串解析为日期
* @param s 日期字符串
* @param format 指定日期格式
* @return Date类型指定日期格式的对象
*/
public static Date stringToDate(String s, String format) {
SimpleDateFormat sdf = new SimpleDateFormat(format);
//需要对解析异常进行处理 快捷键：ctrl + alt + T
try {
Date d = sdf.parse(s);
return d;
} catch (ParseException e) {
//打印异常信息
e.printStackTrace();
System.out.println("字符串与指定格式不符，请检查");
return null;
}
}
}
3.4.2 测试工具类
案例代码十一 测试Date工具类
package com.groupies.base.day10;
import java.util.Date;
/**
* @author GroupiesM
* @date 2021/04/12
* @introduction 测试Date工具类
*/
public class Demo11UseDateUtils {
public static void main(String[] args) {
Date d = new Date();
String s1 = Demo10DateUtils.dateToString(d, "yyyy年MM月dd日 HH:mm:ss");
System.out.println("s1: " + s1);//s1: 2021年04月12日 17:35:37
String s2 = Demo10DateUtils.dateToString(d, "yyyy年MM月dd日");
System.out.println("s2: " + s2);//s2: 2021年04月12日
String s3 = Demo10DateUtils.dateToString(d, "HH:mm:ss");
System.out.println("s3: " + s3);//s3: 17:35:37
String str = "2080-08-08 12:23:34";
Date dd = Demo10DateUtils.stringToDate(str, "yyyy-MM-dd HH:mm:ss");
System.out.println("dd: " + dd);//dd: Thu Aug 08 12:23:34 CST 2080
}
}
4 课后练习
4.1 练习1 数组排序
练习1 数组排序
package com.groupies.base.day10;
import java.util.Arrays;
/**
* @author GroupiesM
* @date 2021/04/15
* @introduction 课后基础练习1 数组排序
*
* 需求说明：定义一个数组，数组中元素为：{24,69,80,57,13}，将数组中的元素按照从小到大的顺序进行排序。
*/
public class HomeWork1ArraySort {
public static void main(String[] args) {
int[] arr1 = {24, 69, 80, 57, 13};
arraysSort(arr1);
System.out.print("使用Arrays.sort排序：");
printArr(arr1);
System.out.println("----------");
int[] arr2 = {24, 69, 80, 57, 13};
bubbleSortMax(arr2);
System.out.print("使用冒泡排序：");
printArr(arr2);
}
public static void arraysSort(int[] arr) {
Arrays.sort(arr);
}
/**
* @introduciton 使用冒泡排序法，依次找出最小值
* n个元素的数组，只需要比较n-1(arr.lenth-2)轮即可完全排序
* 第m次比较，n个元素，比较n-m次(arr.length - m);
* @param arr int类型数组
*/
public static void bubbleSortMin(int[] arr) {
int temp;
for (int i = 0; i < arr.length - 1; i++) {
//第i轮找出第i个位置的最小值
for (int j = arr.length - 1; j > i; j--) {
if (arr[j - 1] > arr[j]) {
temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
}
}
}
}
/**
* @introduciton 使用冒泡排序法，依次找出最大值
* n个元素的数组，只需要比较n-1(arr.lenth-2)轮即可完全排序
* 第m次比较，n个元素，比较n-m次(arr.length - m);
* @param arr int类型数组
*/
public static void bubbleSortMax(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
/**
* @introduciton 打印数组
* @param arr int类型数组
*/
public static void printArr(int[] arr) {
for (int i = 0; i < arr.length; i++) {
if (i == 0) {
System.out.print("[" + arr[i]);
continue;
}
if (i == arr.length - 1) {
System.out.println("," + arr[i] + "]");
continue;
}
System.out.print("," + arr[i]);
}
}
}
4.2 练习2 字符串数组分割、排序
练习2 字符串数组分割、排序
package com.groupies.base.day10;
import java.util.Arrays;
/**
* @author GroupiesM
* @date 2021/04/15
* @introduction 课后基础练习2 字符串数组分割、排序
*/
public class HomeWork2StringSplit {
public static void main(String[] args) {
//定义一个字符串
String strSource = "91 27 46 38 50";
//按照空格分隔字符串，形成数组
String[] strArr = strSource.split(" ");
//定义一个int类型数组，用于转换strArr
int[] intArr = new int[strArr.length];
for (int i = 0; i < strArr.length; i++) {
intArr[i] = Integer.parseInt(strArr[i]);
}
//对intArr进行排序
Arrays.sort(intArr);
//拼接intArr内容的输出结果
StringBuilder sb = new StringBuilder("");
for (int i = 0; i < intArr.length; i++) {
if (i == intArr.length - 1) break;
sb.append(intArr[i]).append(" ");
}
//查看输出结果
System.out.println("排序后的数组：" + sb);
}
}
4.3 练习3 Date使用工具类
练习3.1 Date使用工具类 工具类
package com.groupies.base.day10;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* @author GroupiesM
* @date 2021/04/15
* @introduction 课后基础练习3 工具类
*
* 需求说明：
* 自定义一个日期工具类，工具类中提供字符串转换成指定日期对象方法，
* 再提供一个将指定格式的字符串转换成日期对象的方法，定义测试类，测试日期工具类中的方法。
*/
public class HomeWork3DateUtils {
/**
* @introduction Date转String工具类
* @param date 日期时间
* @param format 指定日期格式
* @return String类型时间
*/
public static String dateToString(Date date, String format) {
SimpleDateFormat sdf = new SimpleDateFormat(format);
return sdf.format(date);
}
/**
* @introduction String转Date工具类
* @param str 字符串时间
* @param format 指定日期格式
* @return Date类型时间
*/
public static Date stringToDate(String str, String format) {
SimpleDateFormat sdf = new SimpleDateFormat(format);
try {
return sdf.parse(str);
} catch (ParseException e) {
e.printStackTrace();
System.out.println("解析错误，请检查传入参数");
return null;
}
}
}
练习3.2 Date使用工具类 测试类
package com.groupies.base.day10;
import java.util.Date;
/**
* @author GroupiesM
* @date 2021/04/15
* @introduction 课后基础练习3 Date使用工具类
*
* 需求说明：
* 自定义一个日期工具类，工具类中提供字符串转换成指定日期对象方法，
* 再提供一个将指定格式的字符串转换成日期对象的方法，定义测试类，测试日期工具类中的方法。
*/
public class HomeWork3Date {
public static void main(String[] args) {
Date date = new Date();
String s1 = HomeWork3DateUtils.dateToString(date, "yyyy年MM月dd日 HH:mm:ss");
System.out.println(s1);//2021年04月15日 15:30:51
String s2 = HomeWork3DateUtils.dateToString(date, "yyyy年MM月dd日");
System.out.println(s2);//2021年04月15日
String s3 = HomeWork3DateUtils.dateToString(date, "HH:mm:ss");
System.out.println(s3);//15:30:51
String s4 = "2080-08-08 12:23:34";
Date d4 = HomeWork3DateUtils.stringToDate(s4, "yyyy-MM-dd HH:mm:ss");
System.out.println(d4);//Thu Aug 08 12:23:34 CST 2080
}
}
4.4 练习4 计算两日期间隔号秒
练习4 字符串数组分割、排序
package com.groupies.base.day10;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
/**
* @author GroupiesM
* @date 2021/04/15
* @introduction 课后基础练习4 计算两日期间隔号秒
*
* 分析以下需求，并用代码实现：
* 1.从键盘录入一个日期字符串,格式为 xxxx-xx-xx,代表该人的出生日期
* 2.利用人出生日期到当前日期所经过的毫秒值计算出这个人活了多少天
*/
public class HomeWork4DateCount {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
System.out.println("输入出生日期，格式yyyy-MM-dd");
Date bornDate;
//解析异常时要求重新输入出生日期
while (true) {
try {
String born = sc.next();
bornDate = sdf.parse(born);
break;
} catch (ParseException e) {
System.out.println("格式有误，请重新输入出生日期，格式yyyy-MM-dd");
continue;
}
}
long l1 = bornDate.getTime();
long l2 = new Date().getTime();
System.out.println((l2 - l1) / 1000 / 60 / 60 / 24);//输入日期2000-01-01 到今天2021-04-16 结果为7775
}
}
4.5 练习5 解析字符串并求和
练习5 字符串数组分割、排序
package com.groupies.base.day10;
import org.junit.Test;
/**
* @author GroupiesM
* @date 2021/04/15
* @introduction 课后基础练习5 解析字符串并求和
*
* 需求：
* 有一个字符串String str = "abc12abc34kkk54aa3",求出这个字符串中所有的数字之和，
* 也就是说，求 1 + 2 + 3 + 4 + 5 + 4 + 3
*/
public class HomeWork5StringParse {
/**
* @introuduction 方式一：使用Integer.parseInt 和try catch判断字符串
* @param args
*/
public static void main(String[] args) {
String str = "abc12abc34kkk54aa3";
int count = 0;
for (int i = 0; i < str.length(); i++) {
try {
int parseValue = Integer.parseInt(String.valueOf(str.charAt(i)));
System.out.println("第" + i + "位数字：" + parseValue);
count += parseValue;
} catch (NumberFormatException e) {
continue;
}
}
System.out.println(count);
}
@Test
/**
* @introduction 方式二：使用String.charAt判断数字
*/
public void Method2() {
String str = "abc12abc34kkk54aa3";
int sum = 0;
for (int i = 0; i < str.length(); i++) {
if (str.charAt(i) >= '0' && str.charAt(i) <= '9') {
String s = str.charAt(i) + "";//把字符转换成字符串
int num = Integer.parseInt(s);//把字符串转换成int
sum += num;
}
}
System.out.println(sum);
}
}
4.6 练习6 用户登录系统(进阶)
-
需求说明：实现用户注册、登陆功能；
-
1.程序中使用一个长度为3的对象数组，存储用户的登录名和密码：
-
例如如下格式：
登录名 密码 生日 爱好 zhangsan 1111 1998/3/15 旅游，唱歌 lisi 2222 2002/5/20 吃饭，睡觉，打豆豆 wangwu 3333 2001/7/28 看书，看电影，旅游 -
2.循环为用户列出菜单：
- 1.注册 2.登陆 3.退出
-
3.用户输入数字
- 用户选择1，调用：registe()方法，执行注册流程；
- 判断注册人数是否已满（3人）
- 用户选择2，调用：login()方法，执行登陆流程；
- 用户选择3，结束程序；
- 用户选择9999，进入后台，打印所有用户信息
- 用户输入其他信息，提示：请输入正确数字
- 用户选择1，调用：registe()方法，执行注册流程；
-
4.编写方法：registe()，执行注册流程：
- 要求用户输入以下信息
- 用户名：校验用户名是否已经存在，如果存在需要注册其它用户名
- 登录密码：两次输入密码，校验两次输入要一致
- 出生日期：日期校验是否合法
- 爱好：多个爱好中间用逗号(中英文都可以)隔开
- 要求用户输入以下信息
-
5.编写方法：login()，执行登陆流程：
- 请用户输入登录名、登陆密码；
- 使用登录名和密码进行验证；
- 通过：打印这个用户的所有信息；
- 未通过：打印用户名或密码错误！
-
-
练习6.1 字符串数组分割、排序 User实体类
package com.groupies.base.day10;
/**
* @author GroupiesM
* @date 2021/04/15
* @introduction 课后基础练习6
*
* 需求说明：实现用户注册、登陆功能；
* 1. 程序中使用一个长度为3的对象数组，存储用户的登录名和密码：
* 例如如下格式：
* 登录名 密码 生日 爱好
* zhangsan 1111 1998-03-15 旅游，唱歌
* lisi 2222 2002-05-20 吃饭，睡觉，打豆豆
* wangwu 3333 2001-07-28 看书，看电影，旅游
* 注册时，要判断数组是否已满，是：则禁止注册。
*
* 2. 循环为用户列出菜单：
* 1.注册 2.登陆 3.退出
*
* 3. 用户选择1，调用：registe()方法，执行注册流程；
* 用户选择2，调用：login()方法，执行登陆流程；
* 用户选择3，结束程序；
* 4. 编写方法：registe()，执行注册流程：
* 要求用户输入以下信息(信息无需校验)：
* 用户名：
* 登录密码：
* 出生日期：
* 爱好：（多个爱好中间用逗号(中英文都可以)隔开）
* 5. 编写方法：login()，执行登陆流程：
* 请用户输入登录名、登陆密码；
* 使用登录名和密码进行验证；
* 通过：打印：这个用户的所有信息；
* 未通过：打印：用户名或密码错误！
*/
public class HomeWork6POJOUsers {
private String userName;//用户名
private String pwd;//密码
private String birthday;//出生日期 yyyy-MM-dd
private String hobby;//爱好
/**
* @introduction Users实体类的带参构造
* @param userName 用户名
* @param pwd 密码
* @param birthday 出生日期(yyyy-MM-dd)
* @param hobby 爱好
*/
public HomeWork6POJOUsers(String userName, String pwd, String birthday, String hobby) {
this.userName = userName;
this.pwd = pwd;
this.birthday = birthday;
this.hobby = hobby;
}
/*
* Getter And Setter
*/
public void setUserName(String userName) {
this.userName = userName;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
public String getBirthday() {
return birthday;
}
public void setBirthday(String birthday) {
this.birthday = birthday;
}
public String getHobby() {
return hobby;
}
public void setHobby(String hobby) {
this.hobby = hobby;
}
public String getUserName() {
return userName;
}
}
练习6.2 字符串数组分割、排序 用户系统主方法
package com.groupies.base.day10;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
/**
* @author GroupiesM
* @date 2021/04/15
* @introduction 课后基础练习6 用户登录系统(进阶)
*
* 需求说明：实现用户注册、登陆功能；
* 1. 程序中使用一个长度为3的对象数组，存储用户的登录名和密码：
* 例如如下格式：
* 登录名 密码 生日 爱好
* zhangsan 1111 1998-03-15 旅游，唱歌
* lisi 2222 2002-05-20 吃饭，睡觉，打豆豆
* wangwu 3333 2001-07-28 看书，看电影，旅游
* 注册时，要判断数组是否已满，是：则禁止注册。
*
* 2. 循环为用户列出菜单：
* 1.注册 2.登陆 3.退出
*
* 3. 用户选择1，调用：registe()方法，执行注册流程；
* 用户选择2，调用：login()方法，执行登陆流程；
* 用户选择3，结束程序；
* 4. 编写方法：registe()，执行注册流程：
* 要求用户输入以下信息(信息无需校验)：
* 用户名：
* 登录密码：
* 出生日期：
* 爱好：（多个爱好中间用逗号(中英文都可以)隔开）
* 5. 编写方法：login()，执行登陆流程：
* 请用户输入登录名、登陆密码；
* 使用登录名和密码进行验证；
* 通过：打印：这个用户的所有信息；
* 未通过：打印：用户名或密码错误！
*/
public class HomeWork6UserSystem {
//统计当前注册用户数
private static int userCount = 0;
//list集合存放Users实体类,作为数据库使用
private static List<HomeWork6POJOUsers> list = new ArrayList<>();
//sc键盘录入对象,全局使用
private static Scanner sc = new Scanner(System.in);
public static <InputMismatchException extends Throwable> void main(String[] args) throws Exception {
System.out.println("》欢迎使用用户登录系统 V1.0,请根据提示输入数字进行选择《");
system:
while (true) {
System.out.println("1.注册 2.登陆 3.退出");
int next = 0;
try {
next = sc.nextInt();
} catch (Exception e) {
System.out.println("请输入正确数字");
continue system;
}
choice:
switch (next) {
case 1:
register();
continue system;
case 2:
login();
continue system;//
case 3:
System.out.println("正在退出，请稍等");
Thread.sleep(200);
System.out.print("3..");
Thread.sleep(200);
System.out.print("2..");
Thread.sleep(200);
System.out.print("1..");
Thread.sleep(200);
System.out.println("退出成功");
break system;//退出用户登录系统
case 9999:
System.out.println("》已进入用户登录系统 V1.0后台，以下是所有用户信息《：");
System.out.println("==========================================================");
for (int i = 0; i < list.size(); i++) {
System.out.println("用户名：" + list.get(i).getUserName() + " 密码：" + list.get(i).getPwd() + " 出生日期：" + list.get(i).getBirthday() + " 爱好：" + list.get(i).getHobby());
}
System.out.println("==========================================================");
continue system;//
default:
System.out.println("请输入正确数字");
}
}
}
/**
* @introduction 注册用户方法
* 功能1：判断注册人数是否已满（3人）
* 功能2：判断用户名是否存在
* 功能3：判断两次输入密码是否一致
* 功能4：判断输入的出生日期是否合法
* 功能5：注册信息存入list数据库
*/
public static void register() {
userCount++;
if (userCount > 3) {
System.out.println("注册人数已满，禁止注册");
} else {
System.out.println("您是第" + userCount + "个注册的用户");
//注册信息：用户名，需要判断用户名是否存在
String userName = registerUserName();
//注册信息：密码，需要判断两次输入密码是否一致
String pwd = registerPwd();
//注册信息：生日，需要判断日期是否合法
String birthday = registerBirthday();
//注册信息：爱好
System.out.println("请输入爱好(多个用逗号隔开)：");
String hobby = sc.next().trim();
//将用户信息存入list数据库
list.add(new HomeWork6POJOUsers(userName, pwd, birthday, hobby));
}
}
/**
* @introduciton 登录方法
* 功能1：判断当前是否有注册用户
* 功能2：判断用户名、密码是否正确
*/
public static void login() {
if (userCount == 0) {
System.out.println("当前没有任何用户注册，请先进行注册");
return;
}
System.out.println("请输入用户名");
String userName = sc.next().trim();
System.out.println("请输入密码");
String pwd = sc.next().trim();
for (int i = 0; i < list.size(); i++) {
String getName = list.get(i).getUserName();
String getPwd = list.get(i).getPwd();
if (getName.equals(userName) && pwd.equals(getPwd)) {
System.out.println("登陆成功，以下是您的个人信息：");
System.out.println("==========================================================");
System.out.println("用户名：" + list.get(i).getUserName() + " 密码：" + list.get(i).getPwd() + " 出生日期：" + list.get(i).getBirthday() + " 爱好：" + list.get(i).getHobby());
System.out.println("==========================================================");
return;
}
}
System.out.println("用户名或密码错误，登陆失败");
}
/**
* @introduction 注册方法的子方法，注册用户
* 功能：判断当前用户名是否已经存在
* @return 校验后的用户名
*/
public static String registerUserName() {
String userName;
userName:
while (true) {
System.out.println("请输入用户名：");
userName = sc.next().trim();
boolean b = registerUserNameCheck(userName);
if (b == true) {
System.out.println("当前用户名已存在，请重新输入");
continue userName;
} else {
break userName;
}
}
return userName;
}
/**
* @introduction 注册用户方法的子方法
* 功能：遍历当前list数据库，查看是否已存在当前用户名
* @param userName 传入用户名
* @return 校验后的用户名
*/
public static boolean registerUserNameCheck(String userName) {
for (int i = 0; i < list.size(); i++) {
if (list.get(i).getUserName().equals(userName)) {
//如果任一存在用户名与注册用户名相等，则返回true = 已存在用户名
return true;
}
}
//否则返回false当前不存在这个用户名
return false;
}
/**
* @introduction 注册方法的子方法，注册密码
* 功能：判断两次输入密码是否一致
* @return 校验后的密码
*/
public static String registerPwd() {
String pwd, pwd2;
pwd:
while (true) {
System.out.println("请输入登录密码：");
pwd = sc.next().trim();
System.out.println("请输入确认密码：");
pwd2 = sc.next().trim();
if (pwd.equals(pwd2)) {
break pwd;
} else {
System.out.println("error:两次密码输入不一致");
continue pwd;
}
}
return pwd;
}
/**
* @introduction 注册方法的子方法，注册生日
* 功能：判断输入的日期是否合法
* @return 校验后的日期
*/
public static String registerBirthday() {
String birthDay;
birthday:
while (true) {
System.out.println("请输入生日(yyyy-MM-dd)：");
birthDay = sc.next().trim();
//判断输入日期是否符合规则
boolean b = registerBirthdayCheck(birthDay, "yyyy-MM-dd");
if (b == true) break birthday;
if (b == false) continue birthday;
}
return birthDay;
}
/**
* @introduction 注册生日的子方法
* 功能：使用SimpleDateFormat.parse解析日期，根据是否报错判断是否符合规则
* @param date 字符串类型日期
* @param format 指定日期格式
*/
public static boolean registerBirthdayCheck(String date, String format) {
boolean convertSuccess = true;
// 指定日期格式为四位年/两位月份/两位日期，注意yyyy/MM/dd区分大小写；
SimpleDateFormat sdf = new SimpleDateFormat(format);
try {
// 设置lenient为false. 否则SimpleDateFormat会比较宽松地验证日期，比如2007/02/29会被接受，并转换成2007/03/01
sdf.setLenient(false);
sdf.parse(date);
System.out.println("日期格式合法！");
return true;
} catch (ParseException e) {
// 如果throw java.text.ParseException或者NullPointerException，就说明格式不对
System.out.println("日期格式不合法！请重新输入！");
return false;
}
}
}
- 测试用例
》欢迎使用用户登录系统 V1.0,请根据提示输入数字进行选择《
1.注册 2.登陆 3.退出
4
请输入正确数字
1.注册 2.登陆 3.退出
1
您是第1个注册的用户
请输入用户名：
zs
请输入登录密码：
11
请输入确认密码：
111
error:两次密码输入不一致
请输入登录密码：
11
请输入确认密码：
11
请输入生日(yyyy-MM-dd)：
2001-02-29
日期格式不合法！请重新输入！
请输入生日(yyyy-MM-dd)：
2000-02-29
日期格式合法！
请输入爱好(多个用逗号隔开)：
睡觉
1.注册 2.登陆 3.退出
1
您是第2个注册的用户
请输入用户名：
zs
当前用户名已存在，请重新输入
请输入用户名：
ls
请输入登录密码：
11
请输入确认密码：
11
请输入生日(yyyy-MM-dd)：
2000-01-01
日期格式合法！
请输入爱好(多个用逗号隔开)：
夏洛特
1.注册 2.登陆 3.退出
2
请输入用户名
zs
请输入密码
11
登陆成功，以下是您的个人信息：
==========================================================
用户名：zs 密码：11 出生日期：2000-02-29 爱好：睡觉
==========================================================
1.注册 2.登陆 3.退出
9999
》已进入用户登录系统 V1.0后台，以下是所有用户信息：《
==========================================================
用户名：zs 密码：11 出生日期：2000-02-29 爱好：睡觉
用户名：ls 密码：11 出生日期：2000-01-01 爱好：夏洛特
==========================================================
请输入正确数字
1.注册 2.登陆 3.退出
3
正在退出，请稍等
3..2..1..退出成功
Process finished with exit code 0
5 Date格式校验Utlis
- 校验Date日期有两种方式
- 方式一：正则表达式
- 方式二：SimpleDateFormat自带setLenient(),和parse()判断日期是否符合规则
package com.groupies.base.day10;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* @author GroupiesM
* @date 2021/04/15
* @introduction 日期校验工具
*
* 方式一：使用正则表达式校验日期是否符合规则
* 方式二：使用SimpleDateFormat自带setLenient(),和parse()判断日期是否符合规则
*
* 推荐使用方式二
* 方式二对各月份天数不一致问题校验更准确
* 包括平年和闰年的2月份天数不一样问题
* 例：平年 2001-2-29 是不合法日期
* 闰年 2000-2-29 是合法日期
*
*/
public class Utils {
public static void main(String[] args) throws Exception {
//方式一：使用正则表达式校验日期是否符合规则
String date1 = "2000-12-31";
// 指定好一个日期格式的字符串
//\d{4}表示年份 四位数字
//(0[1-9]|1[1-2])表示月份 0开头则第二位为1-9 1开头则第二位为0-2
//(0[1-9]|1[0-9]|2[0-9]|3[0-1])表示日期 01-31号
// String pattern = "\\d{4}-(0[1-9]|1[0-2])-(0[1-9]|1[0-9]|2[0-9]|3[0-1])";
// RegularExpressionIsValidDate(date1, pattern);//日期格式合法!
//方式二：使用SimpleDateFormat自带setLenient(),和parse()判断日期是否符合规则
System.out.println("--------");
String date2 = "2000-2-1";
String format = "yyyy-MM-dd";
SDFIsValidDate(date2, format);//日期格式合法
}
/**
* @introduction 使用正则表达式验证日期是否符合规则
* @param date 字符串格式的日期
* @param pattern 正则表达式
*/
public static void RegularExpressionIsValidDate(String date, String pattern) {
// 指定好正则表达式
Pattern p = Pattern.compile(pattern);
// 实例化Pattern类
Matcher m = p.matcher(date);
// 实例化Matcher类
if (m.matches()) {
// 进行验证的匹配，使用正则
System.out.println("日期格式合法！");
} else {
System.out.println("日期格式不合法！");
}
}
/**
* @introduction 使用SimpleDateFormat.parse解析日期，根据是否报错判断是否符合规则
* @param date 字符串类型日期
* @param format 指定日期格式
*/
public static void SDFIsValidDate(String date, String format) {
boolean convertSuccess = true;
// 指定日期格式为四位年/两位月份/两位日期，注意yyyy/MM/dd区分大小写；
SimpleDateFormat sdf = new SimpleDateFormat(format);
try {
// 设置lenient为false. 否则SimpleDateFormat会比较宽松地验证日期，比如2007/02/29会被接受，并转换成2007/03/01
sdf.setLenient(false);
sdf.parse(date);
System.out.println("日期格式合法！");
} catch (ParseException e) {
// 如果throw java.text.ParseException或者NullPointerException，就说明格式不对
System.out.println("日期格式不合法！");
}
}
}
21/04/19
M
4359
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
