diff --git a/pom.xml b/pom.xml
index aa11784..2349b14 100644
--- a/pom.xml
+++ b/pom.xml
@@ -6,7 +6,7 @@
 
     <groupId>com.baidu.hugegraph</groupId>
     <artifactId>hugegraph-common</artifactId>
-    <version>1.6.8</version>
+    <version>1.6.9</version>
 
     <name>hugegraph-common</name>
     <url>https://github.com/hugegraph/hugegraph-common</url>
@@ -212,7 +212,7 @@
                         <manifestEntries>
                             <!-- Must be on one line, otherwise the automatic
                                  upgrade script cannot replace the version number -->
-                            <Implementation-Version>1.6.8.0</Implementation-Version>
+                            <Implementation-Version>1.6.9.0</Implementation-Version>
                         </manifestEntries>
                     </archive>
                 </configuration>
diff --git a/src/main/java/com/baidu/hugegraph/util/StringUtil.java b/src/main/java/com/baidu/hugegraph/util/StringUtil.java
index 8a2a723..f7dcbb9 100644
--- a/src/main/java/com/baidu/hugegraph/util/StringUtil.java
+++ b/src/main/java/com/baidu/hugegraph/util/StringUtil.java
@@ -19,22 +19,107 @@
 
 package com.baidu.hugegraph.util;
 
-import java.nio.CharBuffer;
-import java.util.ArrayList;
-import java.util.List;
-
 public final class StringUtil {
 
-    public static List<CharSequence> split(String line, String delimiter) {
+    public static Chars[] splitToCharsArray(String text, String delimiter) {
         E.checkArgument(delimiter.length() > 0,
                         "The delimiter can't be empty");
-        List<CharSequence> results = new ArrayList<>();
-        int from = 0;
-        for (int to; (to = line.indexOf(delimiter, from)) >= 0;
-             from = to + delimiter.length()) {
-            results.add(CharBuffer.wrap(line, from, to));
+        Chars[] buffer = new Chars[text.length()];
+        int count = Chars.split(text, delimiter, buffer);
+        if (count == buffer.length) {
+            return buffer;
         }
-        results.add(CharBuffer.wrap(line, from, line.length()));
-        return results;
+        Chars[] result = new Chars[count];
+        System.arraycopy(buffer, 0, result, 0, count);
+        return result;
+    }
+
+    public static String[] split(String text, String delimiter) {
+        E.checkArgument(delimiter.length() > 0,
+                        "The delimiter can't be empty");
+        Chars[] buffer = new Chars[text.length()];
+        int count = Chars.split(text, delimiter, buffer);
+        String[] result = new String[count];
+        for (int i = 0; i < count; i++) {
+            result[i] = buffer[i].toString();
+        }
+        return result;
+    }
+
+    public static class Chars implements CharSequence {
+
+        private final char[] chars;
+        private final int start;
+        private final int end;
+
+        public Chars(char[] chars, int start, int end) {
+            E.checkArgument(0 < start && start < chars.length || start == 0,
+                            "Invalid start parameter %s", start);
+            E.checkArgument(start <= end && end <= chars.length,
+                            "Invalid end parameter %s", end);
+            this.chars = chars;
+            this.start = start;
+            this.end = end;
+        }
+
+        @Override
+        public int length() {
+            return this.end - this.start;
+        }
+
+        @Override
+        public char charAt(int index) {
+            return this.chars[this.start + index];
+        }
+
+        @Override
+        public CharSequence subSequence(int start, int end) {
+            return new Chars(this.chars, this.start + start, this.start + end);
+        }
+
+        @Override
+        public boolean equals(Object object) {
+            if (!(object instanceof Chars)) {
+                return false;
+            }
+            Chars other = (Chars) object;
+            return this.toString().equals(other.toString());
+        }
+
+        @Override
+        public int hashCode() {
+            return this.toString().hashCode();
+        }
+
+        @Override
+        public String toString() {
+            return new String(this.chars, this.start, this.length());
+        }
+
+        public static Chars of(String string) {
+            return new Chars(string.toCharArray(), 0, string.length());
+        }
+
+        public static Chars[] of(String... strings) {
+            Chars[] results = new Chars[strings.length];
+            for (int i = 0; i < strings.length; i++) {
+                results[i] = Chars.of(strings[i]);
+            }
+            return results;
+        }
+
+        public static int split(String text, String delimiter, Chars[] buffer) {
+            int count = 0;
+            int from = 0;
+            char[] chars = text.toCharArray();
+            for (int to; (to = text.indexOf(delimiter, from)) >= 0;
+                 from = to + delimiter.length()) {
+                buffer[count++] = new Chars(chars, from, to);
+            }
+            if (from < text.length()) {
+                buffer[count++] = new Chars(chars, from, text.length());
+            }
+            return count;
+        }
     }
 }
diff --git a/src/main/java/com/baidu/hugegraph/version/CommonVersion.java b/src/main/java/com/baidu/hugegraph/version/CommonVersion.java
index 81c9333..5d16637 100644
--- a/src/main/java/com/baidu/hugegraph/version/CommonVersion.java
+++ b/src/main/java/com/baidu/hugegraph/version/CommonVersion.java
@@ -27,5 +27,5 @@
 
     // The second parameter of Version.of() is for all-in-one JAR
     public static final Version VERSION = Version.of(CommonVersion.class,
-                                                     "1.6.8");
+                                                     "1.6.9");
 }
diff --git a/src/test/java/com/baidu/hugegraph/unit/UnitTestSuite.java b/src/test/java/com/baidu/hugegraph/unit/UnitTestSuite.java
index 629e986..e5f65d7 100644
--- a/src/test/java/com/baidu/hugegraph/unit/UnitTestSuite.java
+++ b/src/test/java/com/baidu/hugegraph/unit/UnitTestSuite.java
@@ -43,6 +43,7 @@
 import com.baidu.hugegraph.unit.util.NumericUtilTest;
 import com.baidu.hugegraph.unit.util.OrderLimitMapTest;
 import com.baidu.hugegraph.unit.util.ReflectionUtilTest;
+import com.baidu.hugegraph.unit.util.StringUtilTest;
 import com.baidu.hugegraph.unit.util.TimeUtilTest;
 import com.baidu.hugegraph.unit.util.VersionUtilTest;
 import com.baidu.hugegraph.unit.version.VersionTest;
@@ -69,6 +70,7 @@
     InsertionOrderUtilTest.class,
     NumericUtilTest.class,
     ReflectionUtilTest.class,
+    StringUtilTest.class,
     TimeUtilTest.class,
     VersionUtilTest.class,
     LongEncodingTest.class,
diff --git a/src/test/java/com/baidu/hugegraph/unit/util/StringUtilTest.java b/src/test/java/com/baidu/hugegraph/unit/util/StringUtilTest.java
index 2c9fd4f..f37ba41 100644
--- a/src/test/java/com/baidu/hugegraph/unit/util/StringUtilTest.java
+++ b/src/test/java/com/baidu/hugegraph/unit/util/StringUtilTest.java
@@ -26,12 +26,20 @@
 
 import com.baidu.hugegraph.testutil.Assert;
 import com.baidu.hugegraph.util.StringUtil;
+import com.baidu.hugegraph.util.StringUtil.Chars;
 import com.google.common.base.Splitter;
 
 public class StringUtilTest {
 
     @Test
     public void testSplit() {
+        Assert.assertArrayEquals(new String[]{"1", "2", "3"},
+                                 StringUtil.split("1, 2, 3", ", "));
+        Assert.assertArrayEquals(new String[]{"1", "1", "1"},
+                                 StringUtil.split("1 1 1", " "));
+        Assert.assertArrayEquals(new String[]{"", "", ""},
+                                 StringUtil.split("111", "1"));
+
         Assert.assertEquals(guavaSplit("123", " "),
                             toStringList(StringUtil.split("123", " ")));
         Assert.assertEquals(guavaSplit("1 2 3", " "),
@@ -48,22 +56,41 @@
                             toStringList(StringUtil.split("1:|2|:3", "|")));
         Assert.assertEquals(guavaSplit("1\t2\t3", "\t"),
                             toStringList(StringUtil.split("1\t2\t3", "\t")));
-        Assert.assertEquals(guavaSplit("111", "1"),
-                            toStringList(StringUtil.split("111", "1")));
 
         Assert.assertThrows(IllegalArgumentException.class, () -> {
             StringUtil.split("123", "");
         });
     }
 
+    @Test
+    public void testSplitToCharsArray() {
+        Assert.assertArrayEquals(Chars.of("1", "2", "3"),
+                                 StringUtil.splitToCharsArray("1, 2, 3", ", "));
+        Assert.assertArrayEquals(Chars.of("1", "1", "1"),
+                                 StringUtil.splitToCharsArray("1 1 1", " "));
+        Assert.assertArrayEquals(Chars.of("", "", ""),
+                                 StringUtil.splitToCharsArray("111", "1"));
+
+        Assert.assertArrayEquals(new Chars[]{Chars.of("123")},
+                                 StringUtil.splitToCharsArray("123", " "));
+        Assert.assertArrayEquals(Chars.of("1", "", "2", "3"),
+                                 StringUtil.splitToCharsArray("1::2:3", ":"));
+        Assert.assertArrayEquals(Chars.of("1", "", "2", "", "3"),
+                                 StringUtil.splitToCharsArray("1::2::3", ":"));
+
+        Assert.assertThrows(IllegalArgumentException.class, () -> {
+            StringUtil.splitToCharsArray("123", "");
+        });
+    }
+
     private static List<String> guavaSplit(String line, String delimiter) {
         return Splitter.on(delimiter).splitToList(line);
     }
 
-    private static List<String> toStringList(List<CharSequence> chars) {
-        List<String> results = new ArrayList<>(chars.size());
-        for (CharSequence seq : chars) {
-            results.add(seq.toString());
+    private static List<String> toStringList(String[] stringArray) {
+        List<String> results = new ArrayList<>(stringArray.length);
+        for (String str : stringArray) {
+            results.add(str);
         }
         return results;
     }