Java：时间字符串转换时间问题
代码
public static void main(String[] args) {
test test = new test();
test.bugFour();
}
private void bugFour() {
String iso8601String = "2024-08-08T00:00:00Z";
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = null;
try {
date = formatter.parse(iso8601String);
} catch (ParseException e) {
throw new RuntimeException(e);
}
System.out.println(date);
}
结果
原因
错误是因为尝试解析的日期字符串与指定的日期格式不匹配。错误信息显示试图解析的日期字符串是”2024-08-08T00:00:00Z”，这是一个ISO 8601格式的日期时间字符串，它包含了日期和时间，并且以’Z’结尾，表示这是UTC时间。
解决
使用 ISO 8601格式解析器解析该字符串
public static void main(String[] args) {
test test = new test();
test.bugFive();
test.bugFour();
}
/**
* Java 7 时间字符串转换时间
*/
private void bugFive() {
String iso8601String = "2024-08-08T00:00:00Z";
// 创建ISO 8601的日期时间格式解析器
SimpleDateFormat isoFormatter = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
// 设置时区为UTC，因为ISO 8601字符串默认是UTC时间
isoFormatter.setTimeZone(TimeZone.getTimeZone("UTC"));
// 创建目标格式的日期时间格式解析器
SimpleDateFormat outputFormatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = null;
try {
date = isoFormatter.parse(iso8601String);
} catch (ParseException e) {
throw new RuntimeException(e);
}
// 格式化为目标格式
String formattedDateTime = outputFormatter.format(date); //如果输出为 Date 格式，则不需要这一步
System.out.println(date);
System.out.println(formattedDateTime);
}
/**
* Java 8 时间字符串转换时间
*/
private void bugFour() {
String iso8601String = "2024-08-08T00:00:00Z";
// 创建一个DateTimeFormatter对象，用于解析ISO 8601格式的字符串
DateTimeFormatter isoFormatter = DateTimeFormatter.ISO_DATE_TIME;
// 创建一个DateTimeFormatter对象，用于格式化日期时间为"yyyy-MM-dd HH:mm:ss"格式
DateTimeFormatter outputFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
// 使用isoFormatter将字符串解析为ZonedDateTime对象
ZonedDateTime zonedDateTime = ZonedDateTime.parse(iso8601String, isoFormatter);
// 将ZonedDateTime转换为LocalDateTime
LocalDateTime localDateTime = zonedDateTime.toLocalDateTime();
// 使用outputFormatter将LocalDateTime格式化为字符串
String formattedDateTime = localDateTime.format(outputFormatter);
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = null;
try {
date = formatter.parse(formattedDateTime);
} catch (ParseException e) {
throw new RuntimeException(e);
}
System.out.println(date);
System.out.println(formattedDateTime);
}
注意
暂无
Java：不能在for和增强for循环中进行元素删除，不然会引发数据错乱
代码
public static void main(String[] args) {
test test = new test();
test.bugThree();
}
private void bugThree() {
List<Map<String, Object>> list = new ArrayList<>();
HashMap<String, Object> map = new HashMap<>();
map.put("1", "1");
map.put("2", "2");
map.put("3", "3");
map.put("4", "4");
list.add(map);
System.out.println(list);
for (Map<String, Object> demo : list) {
list.remove(demo);
}
}
结果
原因
在 Java 中，如果想在循环中删除列表中的元素，需要特别小心，因为直接在循环中使用 remove() 方法可能会导致 ConcurrentModificationException 异常。这是因为列表在迭代过程中被修改了。
解决
有两种推荐的方法来安全地删除列表中的元素：
方法 1: 使用迭代器 (Iterator)
使用迭代器可以安全地删除列表中的元素，因为它不会引发 ConcurrentModificationException。
import java.util.ArrayList;
import java.util.Iterator;
public class Main {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
// 使用迭代器删除值为偶数的元素
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()) {
Integer element = iterator.next();
if (element % 2 == 0) {
iterator.remove(); // 使用迭代器的 remove() 方法
}
}
System.out.println(list); // 输出: [1, 3, 5]
}
}
方法 2: 使用倒序循环 (for 循环)
使用倒序循环可以从列表的末尾开始删除元素，这样不会影响前面元素的索引。
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
// 使用倒序循环删除值为偶数的元素
for (int i = list.size() - 1; i >= 0; i--) {
Integer element = list.get(i);
if (element % 2 == 0) {
list.remove(i); // 使用索引删除
}
}
System.out.println(list); // 输出: [1, 3, 5]
}
}
注意
- 迭代器注意事项
- 使用迭代器删除元素时，必须使用
iterator.remove()方法，而不是list.remove()。
- 使用迭代器删除元素时，必须使用
- 倒序循环
- 如果确定不会删除列表的第一个元素，可以使用倒序循环，这样可以避免索引偏移的问题。
Java：list中增加的put更新过的map的值是相同的
代码
public static void main(String[] args) {
test test = new test();
test.bugOne();
}
private void bugOne() {
List<Map<String, Object>> list = new ArrayList<>();
HashMap<String, Object> map = new HashMap<>();
map.put("1", "1");
map.put("2", "2");
map.put("3", "3");
map.put("4", "4");
list.add(map);
System.out.println(list);
for (int i = 0; i < 2; i++) {
map.put("1", "11" + i);
map.put("2", "22" + i);
map.put("3", "33" + i);
map.put("4", "44" + i);
list.add(map);
}
System.out.println(list);
}
结果
原因
在 Java 中，如果将相同的 Map 对象多次添加到 Lis t集合中，则在 List 集合中存储的 Map 对象实际上是同一个对象。
这是因为在 Java 中，通过变量和集合中保存的是对象的引用，而不是对象本身的拷贝。
当使用相同的对象作为参数多次调用方法时，实际上是多次使用了同一个对象。
因此，如果更改其中一个 Map 对象的值，所有在 List 集合中存储的 Map 对象都将反映这些更改，因为它们实际上是同一个对象。
解决
重新 New 一个新的 Map 对象用来存储数据
public static void main(String[] args) {
test test = new test();
test.bugOne();
}
private void bugOne() {
List<Map<String, Object>> list = new ArrayList<>();
HashMap<String, Object> map = new HashMap<>();
map.put("1", "1");
map.put("2", "2");
map.put("3", "3");
map.put("4", "4");
list.add(map);
System.out.println(list);
// for (int i = 0; i < 2; i++) {
// map.put("1", "11" + i);
// map.put("2", "22" + i);
// map.put("3", "33" + i);
// map.put("4", "44" + i);
// list.add(map);
// }
for (int i = 0; i < 2; i++) {
Map<String, Object> iMap = new HashMap<>();
iMap.put("1", "11" + i);
iMap.put("2", "22" + i);
iMap.put("3", "33" + i);
iMap.put("4", "44" + i);
list.add(iMap);
}
System.out.println(list);
}
注意
暂无
Java：ConcurrentModificationException异常
代码
public static void main(String[] args) {
test test = new test();
test.bugTwo();
}
private void bugTwo() {
List<Map<String, Object>> list = new ArrayList<>();
HashMap<String, Object> map = new HashMap<>();
map.put("1", "1");
map.put("2", "2");
map.put("3", "3");
map.put("4", "4");
list.add(map);
System.out.println(list);
for (Map<String, Object> demo : list) {
for (int i = 0; i < 2; i++) {
Map<String, Object> iMap = new HashMap<>();
iMap.put("1", "11" + i);
iMap.put("2", "22" + i);
iMap.put("3", "33" + i);
iMap.put("4", "44" + i);
list.add(map);
}
}
System.out.println(list);
}
结果
原因
ConcurrentModificationException 是 Java 中的一个异常类型，属于 java.util.ConcurrentModificationException 类。它是一种运行时异常（RuntimeException）。
这个异常通常发生在多线程或者非线程安全的上下文中，当一个集合（比如 ArrayList、LinkedList、HashSet 等）正在进行迭代（遍历）时，有另一个线程或操作修改了这个集合的结构（如添加、删除或替换元素）。
1、当在使用迭代器（Iterator）或增强型 for 循环遍历集合时，同时尝试修改集合（除了使用 Iterator 的 remove() 方法外），会导致 ConcurrentModificationException。
2、在多线程环境下，如果一个线程正在遍历集合，而另一个线程修改了这个集合，同样会触发 ConcurrentModificationException。
解决
创建一个新的 List 进行添加元素
public static void main(String[] args) {
test test = new test();
test.bugTwo();
}
private void bugTwo() {
List<Map<String, Object>> list = new ArrayList<>();
HashMap<String, Object> map = new HashMap<>();
map.put("1", "1");
map.put("2", "2");
map.put("3", "3");
map.put("4", "4");
list.add(map);
System.out.println(list);
// for (Map<String, Object> demo : list) {
//
// for (int i = 0; i < 2; i++) {
// Map<String, Object> iMap = new HashMap<>();
// iMap.put("1", "11" + i);
// iMap.put("2", "22" + i);
// iMap.put("3", "33" + i);
// iMap.put("4", "44" + i);
// list.add(map);
// }
//
// }
List<Map<String, Object>> listCopy = new ArrayList<>();
for (Map<String, Object> demo : list) {
listCopy.add(demo);
for (int i = 0; i < 2; i++) {
Map<String, Object> iMap = new HashMap<>();
iMap.put("1", "11" + i);
iMap.put("2", "22" + i);
iMap.put("3", "33" + i);
iMap.put("4", "44" + i);
listCopy.add(iMap);
}
}
list.clear();
list.addAll(listCopy);
System.out.println(list);
}
注意
暂无