-
String课后算法题1
-
String课后算法题2
-
String课后算法题3
-
IDEA中的Debug调试
-
SimpleDateFormat
-
Calendar日历类的使用
-
JDK8中日期时间API的介绍
-
LocalDate、LocalTime、LocalDateTime的使用
-
Instant类的使用
-
DateTimeFormat的使用
-
其他日期相关的API
-
IDEA：导入module
-
Java比较器的概述
-
Comparable自然排序举例
-
自定义类实现Comparable自然排序
-
使用Comparable实现定制排序
-
System、Math、BigInteger、BigDecimal类的使用
1，String课后算法题1
package com.atguigu.exer;
import org.junit.Test;
/**
* 将字符串中指定的部分进行反转，比如“abcdefg”反转为“abfedcg”
*/
public class StringDemo {
// 方式一：转换为char[]数组
public String reverse(String str, int startIndex, int endIndex) {
if(str != null) {
char[] arr = str.toCharArray();
for(int x = startIndex, y = endIndex ; x < y ; x++, y--) {
char temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
return new String(arr);
}
return null;
}
// 方式二：使用String的拼接
public String reverse1(String str, int startIndex, int endIndex) {
if(str != null) {
String reverseStr = str.substring(0, startIndex);
for(int i = endIndex ; i >= startIndex ; i--) {
reverseStr += str.charAt(i); // 每次都会创建新的对象
}
reverseStr += str.substring(endIndex + 1);
return reverseStr;
}
return null;
}
// 优化：使用StringBuffer或StringBuilder替换String
public String reverse2(String str, int startIndex, int endIndex) {
if(str != null) {
StringBuilder builder = new StringBuilder(str.length());
builder.append(str.substring(0, startIndex));
for(int i = endIndex ; i >= startIndex ; i--) {
builder.append(str.charAt(i)); // 在同一个char类型数组中添加，并没创建新的对象
}
builder.append(str.substring(endIndex + 1));
return builder.toString(); // 转换为String类型
}
return null;
}
@Test
public void testReverse() {
String str = "abcdefg";
String reverse = reverse(str, 2, 5);
String reverse1 = reverse1(str, 2, 5);
System.out.println(reverse);
System.out.println(reverse1);
}
}
2，String课后算法题2
package com.atguigu.exer;
import org.junit.Test;
/**
* 获取一个字符串在另一个字符串中出现的次数
*/
public class StringDemo1 {
public int getCount(String mainStr, String subStr) {
int mainLength = mainStr.length();
int subLength = subStr.length();
int count = 0;
int index = 0;
if(mainLength >= subLength) {
// 方式一：
// while((index = mainStr.indexOf(subStr)) != -1) {
// count++;
// mainStr = mainStr.substring(index + subStr.length());
// }
// 方式二：使用可以从指定位置开始查找的indexOf()
while((index = mainStr.indexOf(subStr, index)) != -1) {
count++;
index += subLength;
}
return count;
}else {
return 0;
}
}
@Test
public void testGetCount() {
String mainStr = "abkkcadkabkebfkaabkskab";
String subStr = "ab";
int count = getCount(mainStr, subStr);
System.out.println(count);
}
}
3，String课后算法题3
package com.atguigu.exer;
import org.junit.Test;
import java.util.Arrays;
/**
* 获取两个字符串的最大相同子串
* 比如：str1="abcwerthelloyuiodefabcdef" str2="cvhellobnm"
* 思路：先找到较短的字符串，最大的相同子串可能是较短字符串、较短字符串长度-1的子串、较短字符串长度-2的子串...
*/
public class StringDemo2 {
// 前提是两个字符串中只有一个最大相同子串
public String getMaxSameString(String str1, String str2) {
if(str1 != null && str2 != null) {
String maxStr = (str1.length() >= str2.length()) ? str1 : str2;
String minStr = (str1.length() < str2.length()) ? str1 : str2;
int length = minStr.length();
for(int i = 0 ; i < length ; i++) {
for(int x = 0, y = length - i ; y <= length ; x++, y++) {
String subStr = minStr.substring(x, y);
if(maxStr.contains(subStr)) {
return subStr;
}
}
}
}
return null;
}
// 如果有多个相同长度的最大相同子串，用String[]返回
public String[] getMaxSameString1(String str1, String str2) {
if(str1 != null && str2 != null) {
StringBuffer sBuffer = new StringBuffer();
String maxString = (str1.length() > str2.length()) ? str1 : str2;
String minString = (str1.length() > str2.length()) ? str2 : str1;
int len = minString.length();
for(int i = 0 ; i < len ; i++) {
for(int x = 0, y = len - i ; y <= len ; x++, y++) {
String subString = minString.substring(x, y);
if(maxString.contains(subString)) {
sBuffer.append(subString + ",");
}
}
if(sBuffer.length() != 0) {
break;
}
}
String[] split = sBuffer.toString().replaceAll(",$", "").split("\\,");
return split;
}
return null;
}
@Test
public void testGetMaxSameString() {
String str1 = "abcwerthelloyuiodefabcdefabcde";
String str2 = "cvhellobnmabcde";
String maxSameString = getMaxSameString(str1, str2);
System.out.println(maxSameString); // hello
String[] maxSameStrings = getMaxSameString1(str1, str2);
System.out.println(Arrays.toString(maxSameStrings)); // [hello, abcde]
}
}
4，IDEA中的Debug调试
@Test
public void testStringBuffer() {
String str = null;
StringBuffer sb = new StringBuffer();
sb.append(str); // 查看源码得知，当添加的是null时，会调用父类的append()，
// 父类会执行appendNull()将字符串“null”存储到char类型数组中
System.out.println(sb.length()); // 4
System.out.println(sb); // "null"
StringBuffer sb1 = new StringBuffer(str); // 构造器会先创建str.length()+16长度的char类型数组，所以会报空指针异常
System.out.println(sb1); // 因为异常不会输出
}
5，SimpleDateFormat
package com.atguigu.java;
import org.junit.Test;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* JDk8之前的日期时间API
* 1，System类的currentTimeMillis()
* 2，java.util.Date和子类java.sql.Date
* 3，SimpleDateFormat：对日期类Date进行格式化和解析
* 4，Calendar
*/
public class DateTimeTest {
@Test
public void testSimpleDateFormat() throws ParseException {
SimpleDateFormat sdf = new SimpleDateFormat(); // 需要实例化对象，使用默认构造器
Date date = new Date();
System.out.println(date); // Fri Jul 09 22:30:06 CST 2021
String format = sdf.format(date); // 格式化：日期——>字符串
System.out.println(format); // 21-7-9 下午10:30
// String str = "2021-09-08"; // 传入的字符串不符合格式
String str = "21-9-8 上午11:34";
Date date1 = sdf.parse(str); // 解析：字符串——>日期。会抛异常，因为传入的字符串可能不符合格式
System.out.println(date1); // Wed Sep 08 11:34:00 CST 2021
// **********************************
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyyy.MMMMM.dd GGG hh:mm aaa"); // 带参构造器
String format1 = sdf1.format(date); // 格式化
System.out.println(format1); // 02021.七月.09 公元 10:48 下午
// 开发中都会使用指定格式的构造器
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"); // 年月日时分秒
String format2 = sdf2.format(date);
System.out.println(format2); // 2021-07-09 10:51:42，有个小问题，现在是晚上10点
Date date2 = sdf2.parse("2022-06-20 12:51:42"); // 解析。只认yyyy-MM-dd hh:mm:ss格式
System.out.println(date2); // Mon Jun 20 00:51:42 CST 2022，被当做晚上12点
}
} 练习1
// 将字符串"2020-07-08"转换为java.sql.Date，这是种很常见的需求，用户提交的生日信息会存到数据库中，对应
// 数据库中的日期类型就是java.sql.Date
@Test
public void testExer() throws ParseException {
String birth = "2020-07-08";
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
Date date = sdf1.parse(birth); // java.util.Date
System.out.println(date); // Wed Jul 08 00:00:00 CST 2020
java.sql.Date birthDate = new java.sql.Date(date.getTime()); // 传入毫秒数
System.out.println(birthDate); // 调用toString()，2020-07-08
} 练习2
“三天打渔两天晒网” 从1990-01-01开始，在2020-09-08这天是在打渔还是在晒网
1，计算总天数：方式一，将1990-01-01和2020-09-08转换为Date，(date2.getTime() - date1.getTime()) / (1000 * 60 * 60 * 24) + 1，不管是否除尽都需要加1就是总天数。方式二，1990-01-01——2019-12-31的总天数是29*365 + 闰年的次数，再计算2019-12-31——2020-09-08的总天数
2，总天数 % 5 == 1,2,3：打渔
总天数 % 5 == 4,0：晒网
6，Calendar日历类的使用
@Test
public void testCalendar() {
// Calendar是一个抽象基类，获取Calendar实例的方式有两种
// 方式一：通过其子类GregorianCalendar创建对象
// 方式二：调用其静态方法getInstance()返回一个Calendar对象，实际还是一个子类GregorianCalendar对象
Calendar calendar = Calendar.getInstance(); // 代表当前时间
// System.out.println(calendar.getClass()); // class java.util.GregorianCalendar
// get操作
int days = calendar.get(Calendar.DAY_OF_MONTH); // 现在是这个月的第几天
System.out.println(days); // 10
System.out.println(calendar.get(Calendar.DAY_OF_YEAR)); // 191，现在是这一年的第几天
// set操作
calendar.set(Calendar.DAY_OF_MONTH, 22); // 修改的是对象calendar本身，将它由当前时间改为是这个月的第22天
days = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(days); // 22
System.out.println(calendar.get(Calendar.DAY_OF_YEAR)); // 203，也会跟着改变
// add操作
calendar.add(Calendar.DAY_OF_MONTH, 3); // 在对象calendar的基础上加上3天
days = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(days); // 25
calendar.add(Calendar.DAY_OF_MONTH, -3); // 在对象calendar的基础上减去3天
System.out.println(calendar.get(Calendar.DAY_OF_MONTH)); // 22
// getTime()：日历类——>Date
Date date = calendar.getTime(); // 返回一个Date对象
System.out.println(date); // Thu Jul 22 10:31:46 CST 2021
// setTime()：Date——>日历类
Date date1 = new Date(); // 当前时间
calendar.setTime(date1); // 设置为Date类代表的时间
System.out.println(calendar.get(Calendar.DAY_OF_MONTH)); // 10
} 注意：获取月份时：一月是0，二月是1，以此类推，12月是11；获取星期时：周日是1，周二是2 ， 。。。。周六是7
7，JDK8中日期时间API的介绍
Date类和Calendar类都有缺点，导致对日期和时间的操作不便
@Test
public void testDate() {
Date date1 = new Date(2020, 9, 8);
System.out.println(date1); // Fri Oct 08 00:00:00 CST 3920，有偏移量
Date date2 = new Date(2020 - 1900, 9 - 1, 8);
System.out.println(date2); // Tue Sep 08 00:00:00 CST 2020
}
8，LocalDate、LocalTime、LocalDateTime的使用
package com.atguigu.java;
import org.junit.Test;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
/**
* 使用前提是JDK8之后的版本
*/
public class JDK8DaetTimeTest {
@Test
public void test1() {
// 实例化方式一：now()，获取当前日期、时间、日期+时间
LocalDate localDate = LocalDate.now();
LocalTime localTime = LocalTime.now();
LocalDateTime localDateTime = LocalDateTime.now();
System.out.println(localDate); // 2021-07-10
System.out.println(localTime); // 12:11:21.567
System.out.println(localDateTime); // 2021-07-10T12:11:21.567
// 实例化方式二：of()，设置指定的年月日时分秒
LocalDateTime localDateTime1 = LocalDateTime.of(2020, 10, 6, 13, 23, 43);
System.out.println(localDateTime1); // 2020-10-06T13:23:43，没有偏移量的问题
// get操作
System.out.println(localDateTime.getDayOfMonth()); // 10
System.out.println(localDateTime.getDayOfWeek()); // SATURDAY
System.out.println(localDateTime.getMonth()); // JULY
System.out.println(localDateTime.getMonthValue()); // 7，7月份，不再是6代表7月
System.out.println(localDateTime.getMinute()); // 19
// with操作设置日期时间
LocalDate localDate1 = localDate.withDayOfMonth(22);
System.out.println(localDate); // 2021-07-10，没有改变对象本身，与Calendar相比JDK8中的日期时间类具有不可变性
System.out.println(localDate1); // 2021-07-22
// 加上或减去指定时间
LocalDateTime localDateTime2 = localDateTime.plusMonths(3);
System.out.println(localDateTime); // 2021-07-10T12:27:45.470，不可变
System.out.println(localDateTime2); // 2021-10-10T12:27:45.470
LocalDateTime localDateTime3 = localDateTime.minusDays(6);
System.out.println(localDateTime); // 2021-07-10T12:29:52.102
System.out.println(localDateTime3); // 2021-07-04T12:29:52.102
}
}
9，Instant类的使用
Instant：时间线上的一个瞬时点，可以被用来记录程序中的事件时间戳
@Test
public void test2() {
Instant instant = Instant.now(); // 返回一个对象，它代表本初子午线对应的标准的时间
System.out.println(instant); // 2021-07-10T10:01:31.032Z
OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8)); // 添加偏移量
System.out.println(offsetDateTime); // 2021-07-10T18:01:31.032+08:00
long milli = instant.toEpochMilli();
System.out.println(milli); // 1625911427317，自1970...开始的毫秒数
Instant instant1 = Instant.ofEpochMilli(1625911427317L);
System.out.println(instant1); // 2021-07-10T10:03:47.317Z，通过给定的毫秒数获取Instant实例
}
10，DateTimeFormat的使用
@Test
// DateTimeFormatter：格式化或解析日期、时间，类似SimpleDateFormat
public void test3() {
// 方式一：使用预定义的标准格式。如：ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
LocalDateTime localDateTime = LocalDateTime.now();
// 格式化：日期——>字符串
String str1 = formatter.format(localDateTime);
System.out.println(localDateTime); // 2021-07-11T08:26:58.655
System.out.println(str1); // 2021-07-11T08:26:58.655，使用标准格式，所以没什么差别
// 解析：字符串——>日期
TemporalAccessor parse = formatter.parse("2021-07-10T18:16:39.26"); // 用一个接口类型接收
System.out.println(parse); // {},ISO resolved to 2021-07-10T18:16:39.260
// 方式二：本地化相关的格式。如ofLocalizedDateTime()
// FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT :适用于LocalDateTime
DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
// 格式化：
String str2 = formatter1.format(localDateTime);
System.out.println(str2); // 2021年7月11日 上午08时26分58秒
// ofLocalizedDate()
// FormatStyle.FULL / FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT : 适用于LocalDate
DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM);
// 格式化：
String str3 = formatter2.format(LocalDate.now());
System.out.println(str3); // 2021-7-11
// 方式三(重点)：自定义的格式。如ofPattern(“yyyy-MM-dd hh:mm:ss”)
DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
// 格式化：
String str4 = formatter3.format(LocalDateTime.now());
System.out.println(str4); // 2021-07-11 08:26:58
// 解析：
TemporalAccessor accessor = formatter3.parse("2019-02-18 03:52:09");
System.out.println(accessor); // {SecondOfMinute=9, HourOfAmPm=3, MicroOfSecond=0, NanoOfSecond=0, MinuteOfHour=52, MilliOfSecond=0},ISO resolved to 2019-02-18
}
11，其他日期相关的API
12，IDEA：导入module
将一个module在Windows中对应目录放在工程下，day13这个module其中的代码是不能运行的
选择该工程下的module：day13，Create module，Overwrite
点“-”号移除day13后，就可以delete该module了
13，Java比较器的概述
一般情况下，Java中的对象只能进行==或!=的操作，即判断两个引用是否指向同一对象，比较的是地址值。不能使用>或<，而在实际开发中，需要对多个对象进行排序，也就需要比较对象之间的大小。这是就需要使用两个接口之一：Comparable或Comparator
14，Comparable自然排序举例
package com.atguigu.java;
import org.junit.Test;
import java.util.Arrays;
/**
* Comparable接口：
* 像String、包装类等，实现了Comparable接口，重写了compareTo()方法，给出了比较两个对象大小的方式
* 重写compareTo(obj)的规则：
* 如果当前对象this大于形参对象obj，则返回正整数
* 如果当前对象this小于形参对象obj，则返回负整数
* 如果当前对象this等于形参对象obj，则返回零
*/
public class CompareTest {
@Test
public void test1() {
String[] arr = new String[]{"AA", "CC", "KK", "MM", "GG", "JJ", "DD"};
Arrays.sort(arr); // 使用工具类。String重写compareTo方法，所以能排序。String的compareTo()是依次比较两个字符串的每个字符，
// 当第一个字符串的第n个字符大于第二个字符串的第n个字符就返回正整数
System.out.println(Arrays.toString(arr)); // [AA, CC, DD, GG, JJ, KK, MM]，按照从小到大排序
}
}
15，自定义类实现Comparable自然排序
实现Comparable接口的自定义类
package com.atguigu.java;
/**
* 对于自定义类，如果需要排序，就需要让类实现Comparable接口，重写compareTo()，
* 在该方法中定义如何比较此类对象的大小。实现Comparable称为自然排序
*/
public class Goods implements Comparable {
private String name;
private double price;
public Goods() {
}
public Goods(String name, double price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "Goods{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
// 定义比较此类对象大小的方式：比较价格高低，当两个对象价格一样时，按照商品名排序
@Override
public int compareTo(Object o) {
if(o instanceof Goods) { // 显然只有相同类型的对象才有比较大小的意义
Goods goods = (Goods)o;
// 方式一：
if(this.price > goods.price) {
return 1;
}else if(this.price < goods.price) {
return -1;
}else {
// return 0; // 如果没有对相同价格的对象排序的要求，返回0即可
return this.name.compareTo(goods.name); // 直接调用String重写过的compareTo()
}
// 方式二：
// return Double.compare(this.price, goods.price);
}
throw new RuntimeException("传入的数据有误");
}
} 测试
@Test
public void test2() {
Goods[] arr = new Goods[5];
arr[0] = new Goods("lenovoMouse", 34);
arr[1] = new Goods("dellMouse", 43);
arr[2] = new Goods("xiaomiMouse", 12);
arr[3] = new Goods("huaweiMouse", 65);
arr[4] = new Goods("microsoftMouse", 43);
Arrays.sort(arr); // Goods类重写了compareTo()，所以sort()可以根据重写的方法比较Goods对象的大小并从小到大排序
System.out.println(Arrays.toString(arr)); // [Goods{name='xiaomiMouse', price=12.0}, Goods{name='lenovoMouse', price=34.0},
// Goods{name='dellMouse', price=43.0}, Goods{name='microsoftMouse', price=43.0}, Goods{name='huaweiMouse', price=65.0}]
16，使用Comparator实现定制排序
重新定义String比较大小的方法使其变为从大到小排序，并没有影响到String的compareTo()
/**
* Comparator接口的使用：定制排序
* 当元素的类型没有实现comparable接口而又不方便修改代码，或者实现了Comparable接口的排序规则不适合当前的操作，
* 考虑使用Comparator的对象来排序
* 重写compare(Object o1,Object o2)方法，比较o1和o2的大小：
* 如果方法返回正整数，表示o1大于o2
* 如果返回0，表示相等
* 返回负整数，表示o1小于o2
*/
@Test
public void test3() {
String[] arr = new String[]{"AA", "CC", "KK", "MM", "GG", "JJ", "DD"};
Arrays.sort(arr, new Comparator(){ // 需要传入一个Comparator接口类型的对象
@Override
public int compare(Object o1, Object o2) { // 重写接口中的compare方法
if(o1 instanceof String && o2 instanceof String) {
String s1 = (String)o1;
String s2 = (String)o2;
return -s1.compareTo(s2); // 加了-号，表示s1大于s2时返回负数，在排序时s1会排在s2的前面
}
throw new RuntimeException("输入的数据类型有误");
}
});
System.out.println(Arrays.toString(arr)); // [MM, KK, JJ, GG, DD, CC, AA]
} 重新定义自定义类比较大小的方式，并没有影响到Goods类的compareTo()
@Test
public void test4() {
Goods[] arr = new Goods[6];
arr[0] = new Goods("lenovoMouse", 34);
arr[1] = new Goods("dellMouse", 43);
arr[2] = new Goods("xiaomiMouse", 12);
arr[3] = new Goods("huaweiMouse", 65);
arr[4] = new Goods("microsoftMouse", 43);
arr[5] = new Goods("huaweiMouse", 79);
Arrays.sort(arr, new Comparator() {
@Override
// Goods类中compareTo()并未修改，而在这里相当于屏蔽了compareTo()，使用另一种定义的比较大小的方式
// 先按照商品名称从低到高排序，再按照价格从高到低排序
public int compare(Object o1, Object o2) {
if(o1 instanceof Goods && o2 instanceof Goods) {
Goods g1 = (Goods)o1;
Goods g2 = (Goods)o2;
if(g1.getName().equals(g2.getName())) {
return -Double.compare(g1.getPrice(), g2.getPrice()); // 当商品名一样时，g1的价格如果大于g2则返回负数，原本g1排在后面现在g1排在前面
}else {
return g1.getName().compareTo(g2.getName());
}
}
throw new RuntimeException("输入的数据类型有误");
}
});
System.out.println(Arrays.toString(arr)); // [Goods{name='dellMouse', price=43.0}, Goods{name='huaweiMouse', price=79.0},
// Goods{name='huaweiMouse', price=65.0}, Goods{name='lenovoMouse', price=34.0}, Goods{name='microsoftMouse', price=43.0}, Goods{name='xiaomiMouse', price=12.0}]
} Comparable与Comparator的对比：依上面的执行情况看，实现了Comparable接口的实现类保留了重写后CompareTo()比较大小的方式，以后它的对象都可以用这种方式来比较大小；而Comparator接口的方式相当于临时定义比较对象大小的方式，这次会代替该类的CompareTo()，下次使用则需要再次定义
17，System、Math、BigInteger、BigDecimal类的使用
System类测试
@Test
public void test1() {
String javaVersion = System.getProperty("java.version");
System.out.println("java的version:" + javaVersion); // java的version:1.8.0_281
String javaHome = System.getProperty("java.home");
System.out.println("java的home:" + javaHome); // java的home:D:\java\jdk1.8.0_281\jre
String osName = System.getProperty("os.name");
System.out.println("os的name:" + osName); // os的name:Windows 10
String osVersion = System.getProperty("os.version");
System.out.println("os的version:" + osVersion); // os的version:10.0
String userName = System.getProperty("user.name");
System.out.println("user的name:" + userName); // user的name:xurui
String userHome = System.getProperty("user.home");
System.out.println("user的home:" + userHome); // user的home:C:\Users\xurui
String userDir = System.getProperty("user.dir");
System.out.println("user的dir:" + userDir); // user的dir:D:\java\workspace_idea\JavaSenior\day21
}
