From 22b7675f7cfcdbd73e4452986cfcc387dbd058c5 Mon Sep 17 00:00:00 2001 From: "hollis.zhl" Date: Sun, 14 Jun 2020 16:25:06 +0800 Subject: [PATCH] =?UTF-8?q?=E5=9F=BA=E7=A1=80=E7=AF=87=E9=83=A8=E5=88=86?= =?UTF-8?q?=E7=9F=A5=E8=AF=86=E5=AE=8C=E5=96=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/_sidebar.md | 12 +- docs/basics/java-basic/apache-collections.md | 388 ++++++++++++++++++ .../convert-bytestream-characterstream.md | 43 ++ docs/basics/java-basic/enum-switch.md | 14 +- docs/basics/java-basic/h2-db.md | 152 +++++++ .../java-basic/iteration-of-collection.md | 35 ++ docs/basics/java-basic/replace-in-string.md | 83 ++++ docs/menu.md | 10 +- 8 files changed, 726 insertions(+), 11 deletions(-) create mode 100644 docs/basics/java-basic/apache-collections.md create mode 100644 docs/basics/java-basic/convert-bytestream-characterstream.md create mode 100644 docs/basics/java-basic/h2-db.md create mode 100644 docs/basics/java-basic/iteration-of-collection.md create mode 100644 docs/basics/java-basic/replace-in-string.md diff --git a/docs/_sidebar.md b/docs/_sidebar.md index 630513d..ed886d4 100644 --- a/docs/_sidebar.md +++ b/docs/_sidebar.md @@ -1,3 +1,5 @@ + + * 基础篇 * 面向对象 @@ -65,7 +67,7 @@ * [JDK 6和JDK 7中substring的原理及区别](/basics/java-basic/substring.md) - * replaceFirst、replaceAll、replace区别 + * [replaceFirst、replaceAll、replace区别](/basics/java-basic/replace-in-string.md) * [String对“+”的重载](/basics/java-basic/string-append.md) @@ -127,13 +129,13 @@ * [Java 8中stream相关用法](/basics/java-basic/stream.md) - * Apache集合处理工具类的使用 + * [Apache集合处理工具类的使用](/basics/java-basic/apache-collections.md) * 不同版本的JDK中HashMap的实现的区别以及原因 * [Arrays.asList获得的List使用时需要注意什么](/basics/java-basic/Arrays-asList.md) - * Collection如何迭代 + * [Collection如何迭代](/basics/java-basic/iteration-of-collection.md) * [Enumeration和Iterator区别](/basics/java-basic/Enumeration-vs-Iterator.md) @@ -169,7 +171,7 @@ * [输入流、输出流](/basics/java-basic/input-stream-vs-output-stream.md) - * 字节流和字符流之间的相互转换 + * [字节流和字符流之间的相互转换](/basics/java-basic/convert-bytestream-characterstream.md) * [同步、异步](/basics/java-basic/synchronized-vs-asynchronization.md) @@ -271,7 +273,7 @@ * [mockito](/basics/java-basic/ut-with-mockito.md) - * 内存数据库（h2） + * [内存数据库（h2）](/basics/java-basic/h2-db.md) * 正则表达式 diff --git a/docs/basics/java-basic/apache-collections.md b/docs/basics/java-basic/apache-collections.md new file mode 100644 index 0000000..90f9220 --- /dev/null +++ b/docs/basics/java-basic/apache-collections.md @@ -0,0 +1,388 @@ +Commons Collections增强了Java Collections Framework。 它提供了几个功能，使收集处理变得容易。 它提供了许多新的接口，实现和实用程序。 Commons Collections的主要功能如下 + +* Bag - Bag界面简化了每个对象具有多个副本的集合。 + +* BidiMap - BidiMap接口提供双向映射，可用于使用值使用键或键查找值。 + +* MapIterator - MapIterator接口提供简单而容易的迭代迭代。 + +* Transforming Decorators - 转换装饰器可以在将集合添加到集合时更改集合的每个对象。 + +* Composite Collections - 在需要统一处理多个集合的情况下使用复合集合。 + +* Ordered Map - 有序地图保留添加元素的顺序。 + +* Ordered Set - 有序集保留了添加元素的顺序。 + +* Reference map - 参考图允许在密切控制下对键/值进行垃圾收集。 + +* Comparator implementations - 可以使用许多Comparator实现。 + +* Iterator implementations - 许多Iterator实现都可用。 + +* Adapter Classes - 适配器类可用于将数组和枚举转换为集合。 + +* Utilities - 实用程序可用于测试测试或创建集合的典型集合论属性，例如union，intersection。 支持关闭。 + +### Commons Collections - Bag + +Bag定义了一个集合，用于计算对象在集合中出现的次数。 例如，如果Bag包含{a，a，b，c}，则getCount（“a”）将返回2，而uniqueSet（）将返回唯一值。 + + +```java + +import org.apache.commons.collections4.Bag; +import org.apache.commons.collections4.bag.HashBag; +public class BagTester { + public static void main(String[] args) { + Bag bag = new HashBag<>(); + //add "a" two times to the bag. + bag.add("a" , 2); + //add "b" one time to the bag. + bag.add("b"); + //add "c" one time to the bag. + bag.add("c"); + //add "d" three times to the bag. + bag.add("d",3); + //get the count of "d" present in bag. + System.out.println("d is present " + bag.getCount("d") + " times."); + System.out.println("bag: " +bag); + //get the set of unique values from the bag + System.out.println("Unique Set: " +bag.uniqueSet()); + //remove 2 occurrences of "d" from the bag + bag.remove("d",2); + System.out.println("2 occurences of d removed from bag: " +bag); + System.out.println("d is present " + bag.getCount("d") + " times."); + System.out.println("bag: " +bag); + System.out.println("Unique Set: " +bag.uniqueSet()); + } +} + +``` + +它将打印以下结果: + +``` + +d is present 3 times. +bag: [2:a,1:b,1:c,3:d] +Unique Set: [a, b, c, d] +2 occurences of d removed from bag: [2:a,1:b,1:c,1:d] +d is present 1 times. +bag: [2:a,1:b,1:c,1:d] +Unique Set: [a, b, c, d] + +``` + +### Commons Collections - BidiMap + +使用双向映射，可以使用值查找键，并且可以使用键轻松查找值。 + +```java + +import org.apache.commons.collections4.BidiMap; +import org.apache.commons.collections4.bidimap.TreeBidiMap; +public class BidiMapTester { + public static void main(String[] args) { + BidiMap bidi = new TreeBidiMap<>(); + bidi.put("One", "1"); + bidi.put("Two", "2"); + bidi.put("Three", "3"); + System.out.println(bidi.get("One")); + System.out.println(bidi.getKey("1")); + System.out.println("Original Map: " + bidi); + bidi.removeValue("1"); + System.out.println("Modified Map: " + bidi); + BidiMap inversedMap = bidi.inverseBidiMap(); + System.out.println("Inversed Map: " + inversedMap); + } +} +``` + +它将打印以下结果。 +``` +1 +One +Original Map: {One=1, Three=3, Two=2} +Modified Map: {Three=3, Two=2} +Inversed Map: {2=Two, 3=Three} +``` + +### Commons Collections - MapIterator + +JDK Map接口很难迭代，因为迭代要在EntrySet或KeySet对象上完成。 MapIterator提供了对Map的简单迭代。 + +```java + +import org.apache.commons.collections4.IterableMap; +import org.apache.commons.collections4.MapIterator; +import org.apache.commons.collections4.map.HashedMap; +public class MapIteratorTester { + public static void main(String[] args) { + IterableMap map = new HashedMap<>(); + map.put("1", "One"); + map.put("2", "Two"); + map.put("3", "Three"); + map.put("4", "Four"); + map.put("5", "Five"); + MapIterator iterator = map.mapIterator(); + while (iterator.hasNext()) { + Object key = iterator.next(); + Object value = iterator.getValue(); + System.out.println("key: " + key); + System.out.println("Value: " + value); + iterator.setValue(value + "_"); + } + System.out.println(map); + } +} +``` + +它将打印以下结果。 +``` +key: 3 +Value: Three +key: 5 +Value: Five +key: 2 +Value: Two +key: 4 +Value: Four +key: 1 +Value: One +{3=Three_, 5=Five_, 2=Two_, 4=Four_, 1=One_} +``` + +### Commons Collections - OrderedMap + +OrderedMap是地图的新接口，用于保留添加元素的顺序。 LinkedMap和ListOrderedMap是两个可用的实现。 此接口支持Map的迭代器，并允许在Map中向前或向后迭代两个方向。 + +```java +import org.apache.commons.collections4.OrderedMap; +import org.apache.commons.collections4.map.LinkedMap; +public class OrderedMapTester { + public static void main(String[] args) { + OrderedMap map = new LinkedMap(); + map.put("One", "1"); + map.put("Two", "2"); + map.put("Three", "3"); + System.out.println(map.firstKey()); + System.out.println(map.nextKey("One")); + System.out.println(map.nextKey("Two")); + } +} +``` + +它将打印以下结果。 + +``` +One +Two +Three + +``` + +### Commons Collections - Ignore NULL + +Apache Commons Collections库的CollectionUtils类为常见操作提供了各种实用方法，涵盖了广泛的用例。 它有助于避免编写样板代码。 这个库在jdk 8之前非常有用，因为Java 8的Stream API现在提供了类似的功能。 + + +```java +import java.util.LinkedList; +import java.util.List; +import org.apache.commons.collections4.CollectionUtils; +public class CollectionUtilsTester { + public static void main(String[] args) { + List list = new LinkedList(); + CollectionUtils.addIgnoreNull(list, null); + CollectionUtils.addIgnoreNull(list, "a"); + System.out.println(list); + if(list.contains(null)) { + System.out.println("Null value is present"); + } else { + System.out.println("Null value is not present"); + } + } +} +``` + +它将打印以下结果。 +``` +[a] +Null value is not present +``` + +### Merge & Sort + +Apache Commons Collections库的CollectionUtils类为常见操作提供了各种实用方法，涵盖了广泛的用例。 它有助于避免编写样板代码。 这个库在jdk 8之前非常有用，因为Java 8的Stream API现在提供了类似的功能。 + +```java + +import java.util.Arrays; +import java.util.List; +import org.apache.commons.collections4.CollectionUtils; +public class CollectionUtilsTester { + public static void main(String[] args) { + List sortedList1 = Arrays.asList("A","C","E"); + List sortedList2 = Arrays.asList("B","D","F"); + List mergedList = CollectionUtils.collate(sortedList1, sortedList2); + System.out.println(mergedList); + } +} +``` + + +它将打印以下结果。 +``` +[A, B, C, D, E, F] +``` + +### 安全空检查(Safe Empty Checks) + +Apache Commons Collections库的CollectionUtils类为常见操作提供了各种实用方法，涵盖了广泛的用例。 它有助于避免编写样板代码。 这个库在jdk 8之前非常有用，因为Java 8的Stream API现在提供了类似的功能。 + + +```java +import java.util.List; +import org.apache.commons.collections4.CollectionUtils; +public class CollectionUtilsTester { + public static void main(String[] args) { + List list = getList(); + System.out.println("Non-Empty List Check: " + checkNotEmpty1(list)); + System.out.println("Non-Empty List Check: " + checkNotEmpty1(list)); + } + static List getList() { + return null; + } + static boolean checkNotEmpty1(List list) { + return !(list == null || list.isEmpty()); + } + static boolean checkNotEmpty2(List list) { + return CollectionUtils.isNotEmpty(list); + } +} +``` + +它将打印以下结果。 +``` +Non-Empty List Check: false +Non-Empty List Check: false +``` + +### Commons Collections - Inclusion + +检查列表是否是另一个列表的一部分 + +```java +import java.util.Arrays; +import java.util.List; +import org.apache.commons.collections4.CollectionUtils; +public class CollectionUtilsTester { + public static void main(String[] args) { + //checking inclusion + List list1 = Arrays.asList("A","A","A","C","B","B"); + List list2 = Arrays.asList("A","A","B","B"); + System.out.println("List 1: " + list1); + System.out.println("List 2: " + list2); + System.out.println("Is List 2 contained in List 1: " + + CollectionUtils.isSubCollection(list2, list1)); + } +} +``` + +它将打印以下结果。 + +``` +List 1: [A, A, A, C, B, B] +List 2: [A, A, B, B] +Is List 2 contained in List 1: true +``` + +### Commons Collections - Intersection + +用于获取两个集合（交集）之间的公共对象 + +```java +import java.util.Arrays; +import java.util.List; +import org.apache.commons.collections4.CollectionUtils; +public class CollectionUtilsTester { + public static void main(String[] args) { + //checking inclusion + List list1 = Arrays.asList("A","A","A","C","B","B"); + List list2 = Arrays.asList("A","A","B","B"); + System.out.println("List 1: " + list1); + System.out.println("List 2: " + list2); + System.out.println("Commons Objects of List 1 and List 2: " + + CollectionUtils.intersection(list1, list2)); + } +} +``` + +它将打印以下结果。 + + +``` +List 1: [A, A, A, C, B, B] +List 2: [A, A, B, B] +Commons Objects of List 1 and List 2: [A, A, B, B] + +``` + +### Commons Collections - Subtraction +通过从其他集合中减去一个集合的对象来获取新集合 + +```java +import java.util.Arrays; +import java.util.List; +import org.apache.commons.collections4.CollectionUtils; +public class CollectionUtilsTester { + public static void main(String[] args) { + //checking inclusion + List list1 = Arrays.asList("A","A","A","C","B","B"); + List list2 = Arrays.asList("A","A","B","B"); + System.out.println("List 1: " + list1); + System.out.println("List 2: " + list2); + System.out.println("List 1 - List 2: " + + CollectionUtils.subtract(list1, list2)); + } +} +``` + +它将打印以下结果。 +``` +List 1: [A, A, A, C, B, B] +List 2: [A, A, B, B] +List 1 - List 2: [A, C] +``` + +### Commons Collections - Union + +用于获取两个集合的并集 + +```java +import java.util.Arrays; +import java.util.List; +import org.apache.commons.collections4.CollectionUtils; +public class CollectionUtilsTester { + public static void main(String[] args) { + //checking inclusion + List list1 = Arrays.asList("A","A","A","C","B","B"); + List list2 = Arrays.asList("A","A","B","B"); + System.out.println("List 1: " + list1); + System.out.println("List 2: " + list2); + System.out.println("Union of List 1 and List 2: " + + CollectionUtils.union(list1, list2)); + } +} +``` + +它将打印以下结果。 +``` +List 1: [A, A, A, C, B, B] +List 2: [A, A, B, B] +Union of List 1 and List 2: [A, A, A, B, B, C] + +``` + +原文地址：https://iowiki.com/commons_collections/commons_collections_index.html \ No newline at end of file diff --git a/docs/basics/java-basic/convert-bytestream-characterstream.md b/docs/basics/java-basic/convert-bytestream-characterstream.md new file mode 100644 index 0000000..c66a56d --- /dev/null +++ b/docs/basics/java-basic/convert-bytestream-characterstream.md @@ -0,0 +1,43 @@ + +想要实现字符流和字节流之间的相互转换需要用到两个类： + +OutputStreamWriter 是字符流通向字节流的桥梁 + +InputStreamReader 是字节流通向字符流的桥梁 + +### 字符流转成字节流 + +``` + +public static void main(String[] args) throws IOException { + File f = new File("test.txt"); + + // OutputStreamWriter 是字符流通向字节流的桥梁,创建了一个字符流通向字节流的对象 + OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(f),"UTF-8"); + + osw.write("我是字符流转换成字节流输出的"); + osw.close(); + +} + +``` + +### 字节流转成字符流 + +``` + public static void main(String[] args) throws IOException { + + File f = new File("test.txt"); + + InputStreamReader inr = new InputStreamReader(new FileInputStream(f),"UTF-8"); + + char[] buf = new char[1024]; + + int len = inr.read(buf); + System.out.println(new String(buf,0,len)); + + inr.close(); + + } + +``` \ No newline at end of file diff --git a/docs/basics/java-basic/enum-switch.md b/docs/basics/java-basic/enum-switch.md index 245d9e4..4d03b24 100644 --- a/docs/basics/java-basic/enum-switch.md +++ b/docs/basics/java-basic/enum-switch.md @@ -1 +1,13 @@ -Java 1.7 之前 switch 参数可用类型为 short、byte、int、char，枚举类型之所以能使用其实是编译器层面实现的，编译器会将枚举 switch 转换为类似 switch(s.ordinal()) { case Status.START.ordinal() } 形式，所以实质还是 int 参数类型，感兴趣的可以自己写个使用枚举的 switch 代码然后通过 javap -v 去看下字节码就明白了。 \ No newline at end of file +Java 1.7 之前 switch 参数可用类型为 short、byte、int、char，枚举类型之所以能使用其实是编译器层面实现的 + +编译器会将枚举 switch 转换为类似 + +``` +switch(s.ordinal()) { + case Status.START.ordinal() +} + +``` + + +形式，所以实质还是 int 参数类型，感兴趣的可以自己写个使用枚举的 switch 代码然后通过 javap -v 去看下字节码就明白了。 \ No newline at end of file diff --git a/docs/basics/java-basic/h2-db.md b/docs/basics/java-basic/h2-db.md new file mode 100644 index 0000000..22dfd41 --- /dev/null +++ b/docs/basics/java-basic/h2-db.md @@ -0,0 +1,152 @@ +H2是一个开源的嵌入式（非嵌入式设备）数据库引擎，它是一个用Java开发的类库，可直接嵌入到应用程序中，与应用程序一起打包发布，不受平台限制。 + +H2与Derby、HSQLDB、MySQL、PostgreSQL等开源数据库相比，H2的优势为： +* Java开发，不受平台限制； +* H2只有一个jar包，占用空间小，适合嵌入式数据库； +* 有web控制台，用于管管理数据库。 + +接下来介绍Spring+Mybatis+H2的数据库访问实践，参考：https://blog.csdn.net/xktxoo/article/details/78014739 + +添加H2数据库依赖： + +``` + + com.h2database + h2 + 1.4.190 + +``` + + + +H2数据库属性文件配置如下，本文采用内存模式访问H2数据库： +``` +driver=org.h2.Driver +# 内存模式 +url=jdbc:h2:mem:testdb;MODE=MYSQL;DB_CLOSE_DELAY=-1 +# 持久化模式 +#url= jdbc:h2:tcp://localhost/~/test1;MODE=MYSQL;DB_CLOSE_DELAY=-1 +``` + +H2数据库访问的Spring配置文件为： + +``` + + + + + + + + classpath:config.properties + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +``` + +初始化数据库的DDL语句文件为： +``` +CREATE TABLE `user` ( + `id` int(11) unsigned NOT NULL AUTO_INCREMENT, + `name` varchar(100) NOT NULL, + `age` int(11) NOT NULL, + PRIMARY KEY (`id`) +); +``` + +初始化数据库的DML语句文件为： +``` +insert into `user` (`id`,`name`,`age`) values (1, 'Jerry', 27); +insert into `user` (`id`,`name`,`age`) values (2, 'Angel', 25); +``` + +编写测试文件，如下： + +```java +/** + * Created by Jerry on 17/7/30. + */ +@ContextConfiguration(locations = {"classpath:config.xml"}) +@RunWith(SpringJUnit4ClassRunner.class) +public class Test extends AbstractJUnit4SpringContextTests{ + + @Resource + UserDAO userDAO; + + @org.junit.Test + public void testInsert() { + + int result = userDAO.insert(new User(null, "LiLei", 27)); + + Assert.assertTrue(result > 0); + } + + @org.junit.Test + public void testUpdate() { + int result = userDAO.update(new User(2L, "Jerry update", 28)); + + Assert.assertTrue(result > 0); + } + + @org.junit.Test + public void testSelect() { + User result = userDAO.findByName(new User(null, "Jerry", null)); + + Assert.assertTrue(result.getAge() != null); + } + + @org.junit.Test + public void testDelete() { + int result = userDAO.delete("Jerry"); + + Assert.assertTrue(result > 0); + } + +} +``` \ No newline at end of file diff --git a/docs/basics/java-basic/iteration-of-collection.md b/docs/basics/java-basic/iteration-of-collection.md new file mode 100644 index 0000000..4d4df9b --- /dev/null +++ b/docs/basics/java-basic/iteration-of-collection.md @@ -0,0 +1,35 @@ +Collection的迭代有很多种方式： + +1、通过普通for循环迭代 + +2、通过增强for循环迭代 + +3、使用Iterator迭代 + +4、使用Stream迭代 + + +``` +List list = ImmutableList.of("Hollis", "hollischuang"); + +// 普通for循环遍历 +for (int i = 0; i < list.size(); i++) { + System.out.println(list.get(i)); +} + +//增强for循环遍历 +for (String s : list) { + System.out.println(s); +} + +//Iterator遍历 +Iterator it = list.iterator(); +while (it.hasNext()) { + System.out.println(it.next()); +} + +//Stream 遍历 +list.forEach(System.out::println); + +list.stream().forEach(System.out::println); +``` diff --git a/docs/basics/java-basic/replace-in-string.md b/docs/basics/java-basic/replace-in-string.md new file mode 100644 index 0000000..d89f565 --- /dev/null +++ b/docs/basics/java-basic/replace-in-string.md @@ -0,0 +1,83 @@ +replace、replaceAll和replaceFirst是Java中常用的替换字符的方法,它们的方法定义是： + +replace(CharSequence target, CharSequence replacement) ，用replacement替换所有的target，两个参数都是字符串。 + +replaceAll(String regex, String replacement) ，用replacement替换所有的regex匹配项，regex很明显是个正则表达式，replacement是字符串。 + +replaceFirst(String regex, String replacement) ，基本和replaceAll相同，区别是只替换第一个匹配项。 + +可以看到，其中replaceAll以及replaceFirst是和正则表达式有关的，而replace和正则表达式无关。 + +replaceAll和replaceFirst的区别主要是替换的内容不同，replaceAll是替换所有匹配的字符，而replaceFirst()仅替换第一次出现的字符 + +### 用法例子 + +一以下例子参考：http://www.51gjie.com/java/771.html + +1. replaceAll() 替换符合正则的所有文字 + +``` +//文字替换（全部） +Pattern pattern = Pattern.compile("正则表达式"); +Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World"); +//替换第一个符合正则的数据 +System.out.println(matcher.replaceAll("Java")); + +``` + + +2. replaceFirst() 替换第一个符合正则的数据 + +``` +//文字替换（首次出现字符） +Pattern pattern = Pattern.compile("正则表达式"); +Matcher matcher = pattern.matcher("正则表达式 Hello World,正则表达式 Hello World"); +//替换第一个符合正则的数据 +System.out.println(matcher.replaceFirst("Java")); + +``` + +3. replaceAll()替换所有html标签 + +``` +//去除html标记 +Pattern pattern = Pattern.compile("<.+?>", Pattern.DOTALL); +Matcher matcher = pattern.matcher("主页"); +String string = matcher.replaceAll(""); +System.out.println(string); + +``` + +4. replaceAll() 替换指定文字 +``` +//替换指定{}中文字 +String str = "Java目前的发展史是由{0}年-{1}年"; +String[][] object = { + new String[] { + "\\{0\\}", + "1995" + }, + new String[] { + "\\{1\\}", + "2007" + } +}; +System.out.println(replace(str, object)); +public static String replace(final String sourceString, Object[] object) { + String temp = sourceString; + for (int i = 0; i < object.length; i++) { + String[] result = (String[]) object[i]; + Pattern pattern = Pattern.compile(result[0]); + Matcher matcher = pattern.matcher(temp); + temp = matcher.replaceAll(result[1]); + } + return temp; +} + +``` + +5. replace()替换字符串 + +``` +System.out.println("abac".replace("a", "\\a")); //\ab\ac +``` diff --git a/docs/menu.md b/docs/menu.md index 139b371..1ed8810 100644 --- a/docs/menu.md +++ b/docs/menu.md @@ -122,7 +122,7 @@ Gitee Pages 完整阅读：[进入](http://hollischuang.gitee.io/tobetopjavaer) * [JDK 6和JDK 7中substring的原理及区别](/basics/java-basic/substring.md) - * replaceFirst、replaceAll、replace区别 + * [replaceFirst、replaceAll、replace区别](/basics/java-basic/replace-in-string.md) * [String对“+”的重载](/basics/java-basic/string-append.md) @@ -184,13 +184,13 @@ Gitee Pages 完整阅读：[进入](http://hollischuang.gitee.io/tobetopjavaer) * [Java 8中stream相关用法](/basics/java-basic/stream.md) - * Apache集合处理工具类的使用 + * [Apache集合处理工具类的使用](/basics/java-basic/apache-collections.md) * 不同版本的JDK中HashMap的实现的区别以及原因 * [Arrays.asList获得的List使用时需要注意什么](/basics/java-basic/Arrays-asList.md) - * Collection如何迭代 + * [Collection如何迭代](/basics/java-basic/iteration-of-collection.md) * [Enumeration和Iterator区别](/basics/java-basic/Enumeration-vs-Iterator.md) @@ -226,7 +226,7 @@ Gitee Pages 完整阅读：[进入](http://hollischuang.gitee.io/tobetopjavaer) * [输入流、输出流](/basics/java-basic/input-stream-vs-output-stream.md) - * 字节流和字符流之间的相互转换 + * [字节流和字符流之间的相互转换](/basics/java-basic/convert-bytestream-characterstream.md) * [同步、异步](/basics/java-basic/synchronized-vs-asynchronization.md) @@ -328,7 +328,7 @@ Gitee Pages 完整阅读：[进入](http://hollischuang.gitee.io/tobetopjavaer) * [mockito](/basics/java-basic/ut-with-mockito.md) - * 内存数据库（h2） + * [内存数据库（h2）](/basics/java-basic/h2-db.md) * 正则表达式 -- GitLab