diff --git a/inc/hgl/CodePage.h b/inc/hgl/CodePage.h
index 10ee69b..7085d4f 100644
--- a/inc/hgl/CodePage.h
+++ b/inc/hgl/CodePage.h
@@ -252,44 +252,44 @@ namespace hgl
         return u8_to_u16(str,hgl::strlen<u8char>(str)+1,len);
     }
 
-    inline UTF16String to_u16(const u8char *u8_str,int length)
+    inline U16String to_u16(const u8char *u8_str,int length)
     {
         int wlen;
         u16char *ws=u8_to_u16(u8_str,length,wlen);
 
-        return UTF16String::newOf(ws,wlen);
+        return U16String::newOf(ws,wlen);
     }
 
-    inline UTF16String to_u16(const UTF8String &u8str)
+    inline U16String to_u16(const U8String &u8str)
     {
         return to_u16(u8str.c_str(),u8str.Length());
     }
 
-    inline UTF16String to_u16(const u8char *str)
+    inline U16String to_u16(const u8char *str)
     {
         int wlen;
 
         u16char *ws=u8_to_u16(str,hgl::strlen(str),wlen);
         
-        return UTF16String::newOf(ws,wlen);
+        return U16String::newOf(ws,wlen);
     }
 
-    inline UTF8String to_u8(const u16char *wide_str,int length)
+    inline U8String to_u8(const u16char *wide_str,int length)
     {
         int ulen;
 
         u8char *us=u16_to_u8(wide_str,length,ulen);
 
-        return UTF8String::newOf(us,ulen);
+        return U8String::newOf(us,ulen);
     }
 
-    inline UTF8String to_u8(const UTF16String &ws)
+    inline U8String to_u8(const U16String &ws)
     {
         return to_u8(ws.c_str(),ws.Length());
     }
 #if HGL_OS == HGL_OS_Windows
-           AnsiString ToAnsiString(const CharSet &cs,const UTF16String &str);
-    inline AnsiString ToAnsiString(const UTF16String &str)
+           AnsiString ToAnsiString(const CharSet &cs,const U16String &str);
+    inline AnsiString ToAnsiString(const U16String &str)
     {
         const CharSet cs((uint16)0);
         
@@ -298,16 +298,16 @@ namespace hgl
     
     inline OSString ToOSString(const char *str){return to_u16((u8char *)str);}
     inline OSString ToOSString(const u8char *str){return to_u16(str);}
-    inline OSString ToOSString(const UTF8String &str){return to_u16(str.c_str(), (int)(str.Length()));}
+    inline OSString ToOSString(const U8String &str){return to_u16(str.c_str(), (int)(str.Length()));}
 
-    inline UTF8String ToUTF8String(const os_char *str){return to_u8(str,strlen(str));}
-    inline UTF8String ToUTF8String(const OSString &str){return to_u8(str);}
+    inline U8String ToU8String(const os_char *str){return to_u8(str,strlen(str));}
+    inline U8String ToU8String(const OSString &str){return to_u8(str);}
 #else
     inline OSString ToOSString(const char *str){return OSString(str);}
-    inline OSString ToOSString(const UTF8String &str){return str;}
+    inline OSString ToOSString(const U8String &str){return str;}
 
-    inline UTF8String ToUTF8String(const os_char *str){return UTF8String(str);}
-    inline UTF8String ToUTF8String(const OSString &str){return str;}
+    inline U8String ToU8String(const os_char *str){return U8String(str);}
+    inline U8String ToU8String(const OSString &str){return str;}
 #endif//
 
     const BOMFileHeader *ParseBOM(const void *input);
diff --git a/inc/hgl/filesystem/Filename.h b/inc/hgl/filesystem/Filename.h
index 0b02f94..f385a49 100644
--- a/inc/hgl/filesystem/Filename.h
+++ b/inc/hgl/filesystem/Filename.h
@@ -360,11 +360,11 @@ namespace hgl
         {return MergeFilename<char>(pathname,filename,HGL_DIRECTORY_SEPARATOR,HGL_DIRECTORY_SEPARATOR_RAWSTR);}
     #endif//HGL_SUPPORT_CHAR8_T
 
-        inline UTF8String MergeFilename(const UTF8String &pathname,const UTF8String &filename)          ///<组合路径名与文件名
+        inline U8String MergeFilename(const U8String &pathname,const U8String &filename)          ///<组合路径名与文件名
         {return MergeFilename<u8char>(pathname,filename,HGL_DIRECTORY_SEPARATOR,HGL_DIRECTORY_SEPARATOR_U8STR);}
 
     #if HGL_OS == HGL_OS_Windows
-        inline WideString MergeFilename(const WideString &pathname,const WideString &filename)          ///<组合路径名与文件名
+        inline WString MergeFilename(const WString &pathname,const WString &filename)          ///<组合路径名与文件名
         {return MergeFilename<wchar_t>(pathname,filename,L'\\',L"\\");}
     #endif//HGL_OS == HGL_OS_Windows
 
diff --git a/inc/hgl/io/DataInputStream.h b/inc/hgl/io/DataInputStream.h
index b9bc4c5..89bea40 100644
--- a/inc/hgl/io/DataInputStream.h
+++ b/inc/hgl/io/DataInputStream.h
@@ -172,37 +172,37 @@ namespace hgl
             virtual bool ReadUTF16BEChars(u16char *,uint);                                          ///<读取utf16-be格式字符阵列到u16char *
 
             //32bit str-length
-            virtual bool ReadUTF8String         (char *,        uint max_len=0);                    ///<读取utf8格式字符串(前缀四字节的字符串字节长度)
-            virtual bool ReadUTF8String         (UTF8String &,  uint max_len=0);                    ///<读取utf8格式字符串(前缀四字节的字符串字节长度)
-            virtual bool ReadUTF8String         (UTF16String &, uint max_len=0);                    ///<读取utf8格式字符串(前缀四字节的字符串字节长度)
+            virtual bool ReadU8String         (char *,        uint max_len=0);                    ///<读取utf8格式字符串(前缀四字节的字符串字节长度)
+            virtual bool ReadU8String         (U8String &,  uint max_len=0);                    ///<读取utf8格式字符串(前缀四字节的字符串字节长度)
+            virtual bool ReadU8String         (U16String &, uint max_len=0);                    ///<读取utf8格式字符串(前缀四字节的字符串字节长度)
 
             virtual bool ReadUTF16LEString      (u16char *,     uint max_len=0);
             virtual bool ReadUTF16BEString      (u16char *,     uint max_len=0);
 
-            virtual bool ReadUTF16LEString      (UTF16String &, uint max_len=0);                    ///<读取utf16-le格式字符串(前缀四字节的字符串字节长度)
-            virtual bool ReadUTF16BEString      (UTF16String &, uint max_len=0);                    ///<读取utf16-be格式字符串(前缀四字节的字符串字节长度)
+            virtual bool ReadUTF16LEString      (U16String &, uint max_len=0);                    ///<读取utf16-le格式字符串(前缀四字节的字符串字节长度)
+            virtual bool ReadUTF16BEString      (U16String &, uint max_len=0);                    ///<读取utf16-be格式字符串(前缀四字节的字符串字节长度)
 
             //16bit str-length
             virtual bool ReadUTF8ShortString    (char *,        uint max_len=0);
-            virtual bool ReadUTF8ShortString    (UTF8String &,  uint max_len=0);                    ///<读取utf8格式字符串(前缀2字节的字符串字节长度)
-            virtual bool ReadUTF8ShortString    (UTF16String &, uint max_len=0);                    ///<读取utf8格式字符串(前缀2字节的字符串字节长度)
+            virtual bool ReadUTF8ShortString    (U8String &,  uint max_len=0);                    ///<读取utf8格式字符串(前缀2字节的字符串字节长度)
+            virtual bool ReadUTF8ShortString    (U16String &, uint max_len=0);                    ///<读取utf8格式字符串(前缀2字节的字符串字节长度)
 
             virtual bool ReadUTF16LEShortString (u16char *,     uint max_len=0);
             virtual bool ReadUTF16BEShortString (u16char *,     uint max_len=0);
 
-            virtual bool ReadUTF16LEShortString (UTF16String &, uint max_len=0);                    ///<读取utf16-le格式字符串(前缀2字节的字符串字节长度)
-            virtual bool ReadUTF16BEShortString (UTF16String &, uint max_len=0);                    ///<读取utf16-be格式字符串(前缀2字节的字符串字节长度)
+            virtual bool ReadUTF16LEShortString (U16String &, uint max_len=0);                    ///<读取utf16-le格式字符串(前缀2字节的字符串字节长度)
+            virtual bool ReadUTF16BEShortString (U16String &, uint max_len=0);                    ///<读取utf16-be格式字符串(前缀2字节的字符串字节长度)
 
             //8bit str-length
             virtual bool ReadUTF8TinyString     (char *,        uint max_len=0);
-            virtual bool ReadUTF8TinyString     (UTF8String &,  uint max_len=0);                    ///<读取utf8格式字符串(前缀1字节的字符串字节长度)
-            virtual bool ReadUTF8TinyString     (UTF16String &, uint max_len=0);                    ///<读取utf8格式字符串(前缀1字节的字符串字节长度)
+            virtual bool ReadUTF8TinyString     (U8String &,  uint max_len=0);                    ///<读取utf8格式字符串(前缀1字节的字符串字节长度)
+            virtual bool ReadUTF8TinyString     (U16String &, uint max_len=0);                    ///<读取utf8格式字符串(前缀1字节的字符串字节长度)
 
             virtual bool ReadUTF16LETinyString  (u16char *,     uint max_len=0);
             virtual bool ReadUTF16BETinyString  (u16char *,     uint max_len=0);
 
-            virtual bool ReadUTF16LETinyString  (UTF16String &, uint max_len=0);                    ///<读取utf16-le格式字符串(前缀1字节的字符串字节长度)
-            virtual bool ReadUTF16BETinyString  (UTF16String &, uint max_len=0);                    ///<读取utf16-be格式字符串(前缀1字节的字符串字节长度)
+            virtual bool ReadUTF16LETinyString  (U16String &, uint max_len=0);                    ///<读取utf16-le格式字符串(前缀1字节的字符串字节长度)
+            virtual bool ReadUTF16BETinyString  (U16String &, uint max_len=0);                    ///<读取utf16-be格式字符串(前缀1字节的字符串字节长度)
         };//class DataInputStream
 
         template<> bool inline DataInputStream::ReadNumber<int8>(int8 &value){return ReadInt8(value);}
diff --git a/inc/hgl/io/DataOutputStream.h b/inc/hgl/io/DataOutputStream.h
index 9667725..cf38722 100644
--- a/inc/hgl/io/DataOutputStream.h
+++ b/inc/hgl/io/DataOutputStream.h
@@ -138,52 +138,52 @@ namespace hgl
             template<typename T> bool WriteUTF16LEChars     (const String<T> &str){return WriteUTF16LEChars (str.c_str(),str.Length());}
             template<typename T> bool WriteUTF16BEChars     (const String<T> &str){return WriteUTF16BEChars (str.c_str(),str.Length());}
 
-            template<typename T> bool WriteUTF8StringWithLength (const u8char *str,const uint length);
-            template<typename T> bool WriteUTF8StringWithLength (const UTF16String &str);
+            template<typename T> bool WriteU8StringWithLength (const u8char *str,const uint length);
+            template<typename T> bool WriteU8StringWithLength (const U16String &str);
 
-            template<uchar C,typename T> bool WriteUTF16StringWithLength(const u16char *str,const uint len);
+            template<uchar C,typename T> bool WriteU16StringWithLength(const u16char *str,const uint len);
 
         public:
 
             //32 bit length
-            bool WriteUTF8String        (const u8char *str,uint length);                                            ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
-            bool WriteUTF8String        (const u8char *str            );                                            ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
-            bool WriteUTF8String        (const UTF8String &str      );                                              ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
-            bool WriteUTF8String        (const UTF16String &str     );                                              ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
+            bool WriteU8String        (const u8char *str,uint length);                                            ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
+            bool WriteU8String        (const u8char *str            );                                            ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
+            bool WriteU8String        (const U8String &str      );                                              ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
+            bool WriteU8String        (const U16String &str     );                                              ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
 
             bool WriteUTF16LEString     (const u16char *str,uint len);                                              ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
             bool WriteUTF16BEString     (const u16char *str,uint len);                                              ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
 
-            bool WriteUTF16LEString     (const UTF16String &str     );                                              ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
-            bool WriteUTF16BEString     (const UTF16String &str     );                                              ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
+            bool WriteUTF16LEString     (const U16String &str     );                                              ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
+            bool WriteUTF16BEString     (const U16String &str     );                                              ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
 
             bool WriteUTF16LEString     (const u16char *str         );                                              ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
             bool WriteUTF16BEString     (const u16char *str         );                                              ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
 
-            bool WriteUTF16LEString     (const UTF8String &str      ){return WriteUTF16LEString(to_u16(str));}      ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
-            bool WriteUTF16BEString     (const UTF8String &str      ){return WriteUTF16BEString(to_u16(str));}      ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
+            bool WriteUTF16LEString     (const U8String &str      ){return WriteUTF16LEString(to_u16(str));}      ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
+            bool WriteUTF16BEString     (const U8String &str      ){return WriteUTF16BEString(to_u16(str));}      ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
 
-            bool WriteAnsiString        (const char *str,uint length){return WriteUTF8String((u8char *)str,length);}
-            bool WriteAnsiString        (const char *str            ){return WriteUTF8String((u8char *)str);}
-            bool WriteAnsiString        (const AnsiString &str      ){return WriteUTF8String((u8char *)str.c_str(),str.Length());}
+            bool WriteAnsiString        (const char *str,uint length){return WriteU8String((u8char *)str,length);}
+            bool WriteAnsiString        (const char *str            ){return WriteU8String((u8char *)str);}
+            bool WriteAnsiString        (const AnsiString &str      ){return WriteU8String((u8char *)str.c_str(),str.Length());}
 
             //16 bit length
             bool WriteUTF8ShortString   (const u8char *str,uint length);                                            ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
             bool WriteUTF8ShortString   (const u8char *str            );                                            ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
-            bool WriteUTF8ShortString   (const UTF8String &str      );                                              ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
-            bool WriteUTF8ShortString   (const UTF16String &str     );                                              ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
+            bool WriteUTF8ShortString   (const U8String &str      );                                              ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
+            bool WriteUTF8ShortString   (const U16String &str     );                                              ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
 
             bool WriteUTF16LEShortString(const u16char *str,uint len);                                              ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
             bool WriteUTF16BEShortString(const u16char *str,uint len);                                              ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
 
-            bool WriteUTF16LEShortString(const UTF16String &str     );                                              ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
-            bool WriteUTF16BEShortString(const UTF16String &str     );                                              ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
+            bool WriteUTF16LEShortString(const U16String &str     );                                              ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
+            bool WriteUTF16BEShortString(const U16String &str     );                                              ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
 
             bool WriteUTF16LEShortString(const u16char *str         );                                              ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
             bool WriteUTF16BEShortString(const u16char *str         );                                              ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
 
-            bool WriteUTF16LEShortString(const UTF8String &str      ){return WriteUTF16LEShortString(to_u16(str));} ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
-            bool WriteUTF16BEShortString(const UTF8String &str      ){return WriteUTF16BEShortString(to_u16(str));} ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
+            bool WriteUTF16LEShortString(const U8String &str      ){return WriteUTF16LEShortString(to_u16(str));} ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
+            bool WriteUTF16BEShortString(const U8String &str      ){return WriteUTF16BEShortString(to_u16(str));} ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
             
             bool WriteAnsiShortString   (const char *str,uint length){return WriteUTF8ShortString((u8char *)str,length);}
             bool WriteAnsiShortString   (const char *str            ){return WriteUTF8ShortString((u8char *)str);}
@@ -192,20 +192,20 @@ namespace hgl
             //8 bit length
             bool WriteUTF8TinyString    (const u8char *str,uint length);                                            ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
             bool WriteUTF8TinyString    (const u8char *str            );                                            ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
-            bool WriteUTF8TinyString    (const UTF8String &str      );                                              ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
-            bool WriteUTF8TinyString    (const UTF16String &str     );                                              ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
+            bool WriteUTF8TinyString    (const U8String &str      );                                              ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
+            bool WriteUTF8TinyString    (const U16String &str     );                                              ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
 
             bool WriteUTF16LETinyString (const u16char *str,uint len);                                              ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
             bool WriteUTF16BETinyString (const u16char *str,uint len);                                              ///<按utf16-be格式写入字符串(前置1字节字符串长度,再写入字符阵列)
 
-            bool WriteUTF16LETinyString (const UTF16String &str     );                                              ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
-            bool WriteUTF16BETinyString (const UTF16String &str     );                                              ///<按utf16-be格式写入字符串(前置1字节字符串长度,再写入字符阵列)
+            bool WriteUTF16LETinyString (const U16String &str     );                                              ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
+            bool WriteUTF16BETinyString (const U16String &str     );                                              ///<按utf16-be格式写入字符串(前置1字节字符串长度,再写入字符阵列)
 
             bool WriteUTF16LETinyString (const u16char *str         );                                              ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
             bool WriteUTF16BETinyString (const u16char *str         );                                              ///<按utf16-be格式写入字符串(前置1字节字符串长度,再写入字符阵列)
 
-            bool WriteUTF16LETinyString (const UTF8String &str      ){return WriteUTF16LETinyString(to_u16(str));}  ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
-            bool WriteUTF16BETinyString (const UTF8String &str      ){return WriteUTF16BETinyString(to_u16(str));}  ///<按utf16-be格式写入字符串(前置1字节字符串长度,再写入字符阵列)
+            bool WriteUTF16LETinyString (const U8String &str      ){return WriteUTF16LETinyString(to_u16(str));}  ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
+            bool WriteUTF16BETinyString (const U8String &str      ){return WriteUTF16BETinyString(to_u16(str));}  ///<按utf16-be格式写入字符串(前置1字节字符串长度,再写入字符阵列)
 
             bool WriteAnsiTinyString    (const char *str,uint length){return WriteUTF8TinyString((u8char *)str,length);}
             bool WriteAnsiTinyString    (const char *str            ){return WriteUTF8TinyString((u8char *)str);}
diff --git a/inc/hgl/io/JavaInputStream.h b/inc/hgl/io/JavaInputStream.h
index 619f37b..20011ce 100644
--- a/inc/hgl/io/JavaInputStream.h
+++ b/inc/hgl/io/JavaInputStream.h
@@ -61,7 +61,7 @@ namespace hgl
                 return in?in->ReadUTF16BEChars(wstr,count):false;
             }
 
-            bool    readUTF             (UTF16String &str)
+            bool    readUTF             (U16String &str)
             {
                 return in?in->ReadUTF8ShortString(str):false;
             }
diff --git a/inc/hgl/io/JavaOutputStream.h b/inc/hgl/io/JavaOutputStream.h
index c93ff68..70327fb 100644
--- a/inc/hgl/io/JavaOutputStream.h
+++ b/inc/hgl/io/JavaOutputStream.h
@@ -54,8 +54,8 @@ namespace hgl
                 return out?out->WriteUTF16BEChars(wstr,count):false;
             }
 
-            bool    writeUTF            (const UTF8String   &str){return out?out->WriteUTF8ShortString(str):false;}
-            bool    writeUTF            (const UTF16String  &str){return out?out->WriteUTF8ShortString(str):false;}
+            bool    writeUTF            (const U8String   &str){return out?out->WriteUTF8ShortString(str):false;}
+            bool    writeUTF            (const U16String  &str){return out?out->WriteUTF8ShortString(str):false;}
         };//class JavaOutputStream
     }//namespace io
 }//namespace hgl
diff --git a/inc/hgl/io/LoadString.h b/inc/hgl/io/LoadString.h
index 61b2836..9f09b80 100644
--- a/inc/hgl/io/LoadString.h
+++ b/inc/hgl/io/LoadString.h
@@ -6,9 +6,9 @@
 
 namespace hgl
 {
-    int LoadStringFromText(UTF8String &full_text,const void *source_data,const int size,const CharSet &cs=UTF8CharSet);             ///<加载一个原始文本块到UTF8String
-    int LoadStringFromText(UTF16String &full_text,const void *source_data,const int size,const CharSet &cs=UTF8CharSet);            ///<加载一个原始文本块到UTF16String
-    int LoadStringFromTextFile(UTF8String &str,const OSString &filename,const CharSet &cs=UTF8CharSet);                             ///<加载一个原始文本文件到UTF8String
-    int LoadStringFromTextFile(UTF16String &str,const OSString &filename,const CharSet &cs=UTF8CharSet);                            ///<加载一个原始文本文件到UTF16String
+    int LoadStringFromText(U8String &full_text,const void *source_data,const int size,const CharSet &cs=UTF8CharSet);             ///<加载一个原始文本块到U8String
+    int LoadStringFromText(U16String &full_text,const void *source_data,const int size,const CharSet &cs=UTF8CharSet);            ///<加载一个原始文本块到U16String
+    int LoadStringFromTextFile(U8String &str,const OSString &filename,const CharSet &cs=UTF8CharSet);                             ///<加载一个原始文本文件到U8String
+    int LoadStringFromTextFile(U16String &str,const OSString &filename,const CharSet &cs=UTF8CharSet);                            ///<加载一个原始文本文件到U16String
 }//namespace hgl
 #endif//HGL_LOAD_STRING_INCLUDE
diff --git a/inc/hgl/io/LoadStringList.h b/inc/hgl/io/LoadStringList.h
index 28d40ba..52260c3 100644
--- a/inc/hgl/io/LoadStringList.h
+++ b/inc/hgl/io/LoadStringList.h
@@ -14,7 +14,7 @@ namespace hgl
     {
         bool ReadString(io::DataInputStream *dis,T &str)
         {
-            return dis->ReadUTF8String(str);
+            return dis->ReadU8String(str);
         }
     };
 
@@ -66,13 +66,13 @@ namespace hgl
         return(result);
     }//int LoadStringList
 
-    inline int LoadUTF8StringList      (UTF8StringList &   sl,io::DataInputStream *dis){return LoadStringList<u8char,  ByteOrderMask::UTF8     >(sl,dis);}
-    inline int LoadUTF16LEStringList   (UTF16StringList &  sl,io::DataInputStream *dis){return LoadStringList<u16char, ByteOrderMask::UTF16LE  >(sl,dis);}
-    inline int LoadUTF16BEStringList   (UTF16StringList &  sl,io::DataInputStream *dis){return LoadStringList<u16char, ByteOrderMask::UTF16BE  >(sl,dis);}
+    inline int LoadU8StringList      (U8StringList &   sl,io::DataInputStream *dis){return LoadStringList<u8char,  ByteOrderMask::UTF8     >(sl,dis);}
+    inline int LoadUTF16LEStringList   (U16StringList &  sl,io::DataInputStream *dis){return LoadStringList<u16char, ByteOrderMask::UTF16LE  >(sl,dis);}
+    inline int LoadUTF16BEStringList   (U16StringList &  sl,io::DataInputStream *dis){return LoadStringList<u16char, ByteOrderMask::UTF16BE  >(sl,dis);}
 
-    int LoadStringListFromText(     UTF8StringList  &sl,const void *data,const int size,const CharSet &cs=UTF8CharSet);                ///<加载一个原始文本块到UTF8StringList
-    int LoadStringListFromText(     UTF16StringList &sl,const void *data,const int size,const CharSet &cs=UTF8CharSet);                ///<加载一个原始文本块到UTF16StringList
-    int LoadStringListFromTextFile( UTF8StringList  &sl,const OSString &filename,       const CharSet &cs=UTF8CharSet);                ///<加载一个原始文本文件到UTF8StringList
-    int LoadStringListFromTextFile( UTF16StringList &sl,const OSString &filename,       const CharSet &cs=UTF8CharSet);                ///<加载一个原始文本文件到UTF16StringList
+    int LoadStringListFromText(     U8StringList  &sl,const void *data,const int size,const CharSet &cs=UTF8CharSet);                ///<加载一个原始文本块到U8StringList
+    int LoadStringListFromText(     U16StringList &sl,const void *data,const int size,const CharSet &cs=UTF8CharSet);                ///<加载一个原始文本块到U16StringList
+    int LoadStringListFromTextFile( U8StringList  &sl,const OSString &filename,       const CharSet &cs=UTF8CharSet);                ///<加载一个原始文本文件到U8StringList
+    int LoadStringListFromTextFile( U16StringList &sl,const OSString &filename,       const CharSet &cs=UTF8CharSet);                ///<加载一个原始文本文件到U16StringList
 }//namespace hgl
 #endif//HGL_LOAD_STRING_LIST_INCLUDE
\ No newline at end of file
diff --git a/inc/hgl/io/SaveStringList.h b/inc/hgl/io/SaveStringList.h
index 8c82141..068d164 100644
--- a/inc/hgl/io/SaveStringList.h
+++ b/inc/hgl/io/SaveStringList.h
@@ -14,7 +14,7 @@ namespace hgl
     {
         bool WriteString(io::DataOutputStream *dos,const T &str)
         {
-            return dos->WriteUTF8String(str);
+            return dos->WriteU8String(str);
         }
     };
 
@@ -55,7 +55,7 @@ namespace hgl
         return(result);
     };
 
-    template<typename T> int SaveUTF8StringList(io::DataOutputStream *dos,const StringList<T> &sl)
+    template<typename T> int SaveU8StringList(io::DataOutputStream *dos,const StringList<T> &sl)
     {
         return WriteStringList<T,ByteOrderMask::UTF8>(dos,sl);
     }
diff --git a/inc/hgl/log/LogInfo.h b/inc/hgl/log/LogInfo.h
index 88abba8..de00e7c 100644
--- a/inc/hgl/log/LogInfo.h
+++ b/inc/hgl/log/LogInfo.h
@@ -21,12 +21,12 @@ namespace hgl
         void Log(LogLevel level,const u16char *str,int size);
         void Log(LogLevel level,const u8char *str,int size);
 
-        inline  void Log(LogLevel ll,const UTF16String &str)
+        inline  void Log(LogLevel ll,const U16String &str)
         {
             Log(ll,str.c_str(),str.Length());
         }
 
-        inline  void Log(LogLevel ll,const UTF8String &str)
+        inline  void Log(LogLevel ll,const U8String &str)
         {
             Log(ll,str.c_str(),str.Length());
         }
@@ -38,14 +38,14 @@ namespace hgl
         }
         #endif//HGL_SUPPORT_CHAR8_T
 
-        inline  void DebugLog(LogLevel ll,const UTF16String &str,const char *filename,int line,const char *funcname)
+        inline  void DebugLog(LogLevel ll,const U16String &str,const char *filename,int line,const char *funcname)
         {
-            Log(ll,str+U16_TEXT(">>LogFrom(\"")+to_u16((u8char *)filename)+U16_TEXT("\", ")+UTF16String::numberOf(line)+U16_TEXT(" line,func:\"")+to_u16((u8char *)funcname)+U16_TEXT("\")"));
+            Log(ll,str+U16_TEXT(">>LogFrom(\"")+to_u16((u8char *)filename)+U16_TEXT("\", ")+U16String::numberOf(line)+U16_TEXT(" line,func:\"")+to_u16((u8char *)funcname)+U16_TEXT("\")"));
         }
 
-        inline  void DebugLog(LogLevel ll,const UTF8String &str,const char *filename,int line,const char *funcname)
+        inline  void DebugLog(LogLevel ll,const U8String &str,const char *filename,int line,const char *funcname)
         {
-            Log(ll,str+U8_TEXT(">>LogFrom(\"")+UTF8String((u8char *)filename)+U8_TEXT("\", ")+UTF8String::numberOf(line)+U8_TEXT(" line,func:\"")+UTF8String((u8char *)funcname)+U8_TEXT("\")"));
+            Log(ll,str+U8_TEXT(">>LogFrom(\"")+U8String((u8char *)filename)+U8_TEXT("\", ")+U8String::numberOf(line)+U8_TEXT(" line,func:\"")+U8String((u8char *)funcname)+U8_TEXT("\")"));
         }
 
         #define LOG_INFO(str)       {Log(LogLevel::Log,     str);}
diff --git a/inc/hgl/plugin/PlugIn.h b/inc/hgl/plugin/PlugIn.h
index 0fbe1a2..bd9f5e0 100644
--- a/inc/hgl/plugin/PlugIn.h
+++ b/inc/hgl/plugin/PlugIn.h
@@ -15,7 +15,7 @@ namespace hgl
 
         uint ver;
         OSString name;
-        UTF16String intro;
+        U16String intro;
 
         OSString filename;                                                                          ///<插件文件名
 
@@ -23,7 +23,7 @@ namespace hgl
 
         const uint          GetVersion  ()const{return ver;}                                        ///<取得插件版本
         const OSString &    GetName     ()const{return name;}                                       ///<取得插件名称
-        const UTF16String & GetIntro    ()const{return intro;}                                      ///<取得插件介绍
+        const U16String & GetIntro    ()const{return intro;}                                      ///<取得插件介绍
 
     public:
 
diff --git a/inc/hgl/plugin/PlugInManage.h b/inc/hgl/plugin/PlugInManage.h
index 3a60c5e..b9ef7b5 100644
--- a/inc/hgl/plugin/PlugInManage.h
+++ b/inc/hgl/plugin/PlugInManage.h
@@ -28,7 +28,7 @@ namespace hgl
         PlugIn *LoadPlugin  (const OSString &,const OSString &);                ///<加载一个外部插件，明确指定全路径文件名
         PlugIn *LoadPlugin  (const OSString &);                                 ///<加载一个外部插件，自行查找
         bool    UnloadPlugin(const OSString &);                                 ///<释放一个外部插件
-    };//class PlugInManage:public ObjectManage<UTF16String,PlugIn>
+    };//class PlugInManage:public ObjectManage<U16String,PlugIn>
 
     /**
      * 插件注册模板
diff --git a/inc/hgl/thread/Loader.h b/inc/hgl/thread/Loader.h
index ba71a95..7a88746 100644
--- a/inc/hgl/thread/Loader.h
+++ b/inc/hgl/thread/Loader.h
@@ -38,7 +38,7 @@ namespace hgl
         void SetStatus(LoaderStatus);
 
         HAC *loader_hac;
-        UTF16String loader_filename;
+        U16String loader_filename;
         void *loader_pointer;
         void *loader_data;
         int loader_size;
diff --git a/inc/hgl/thread/Thread.h b/inc/hgl/thread/Thread.h
index 247d8cd..fc7c2db 100644
--- a/inc/hgl/thread/Thread.h
+++ b/inc/hgl/thread/Thread.h
@@ -37,7 +37,7 @@ namespace hgl
         friend THREAD_FUNC ThreadFunc(Thread *tc);
 
 #ifdef _DEBUG
-        UTF8String thread_addr_string;                                                              ///<线程地址用字符串，调试使用
+        U8String thread_addr_string;                                                              ///<线程地址用字符串，调试使用
 #endif//_DEBUG
 
     public:
@@ -45,7 +45,7 @@ namespace hgl
         virtual ~Thread()=default;
 
 #ifdef _DEBUG
-        const UTF8String &GetThreadAddressString()const{return thread_addr_string;}               ///<取得线程地址字符串
+        const U8String &GetThreadAddressString()const{return thread_addr_string;}               ///<取得线程地址字符串
 #endif//_DEBUG
 
         /**
diff --git a/inc/hgl/type/ConstStringSet.h b/inc/hgl/type/ConstStringSet.h
index e85c0ec..4e91826 100644
--- a/inc/hgl/type/ConstStringSet.h
+++ b/inc/hgl/type/ConstStringSet.h
@@ -180,9 +180,9 @@ namespace hgl
         }
     };//class ConstStringSet
 
-    using ConstWideStringSet    =ConstStringSet<wchar_t>;
-    using ConstUTF8StringSet    =ConstStringSet<u8char>;
-    using ConstUTF16StringSet   =ConstStringSet<u16char>;
+    using ConstWStringSet    =ConstStringSet<wchar_t>;
+    using ConstU8StringSet    =ConstStringSet<u8char>;
+    using ConstU16StringSet   =ConstStringSet<u16char>;
 //    using ConstUTF32StringSet   =ConstStringSet<u32char>;
     using ConstOSStringSet      =ConstStringSet<os_char>;
 
diff --git a/inc/hgl/type/StdString.h b/inc/hgl/type/StdString.h
index 1a155e4..9a0424b 100644
--- a/inc/hgl/type/StdString.h
+++ b/inc/hgl/type/StdString.h
@@ -17,14 +17,14 @@ namespace hgl
         return hgl::OSString(str.c_str(),(int)str.length());
     }
 
-    inline hgl::UTF8String ToUTF8String(const std::wstring &str)
+    inline hgl::U8String ToU8String(const std::wstring &str)
     {
         return hgl::to_u8(str.c_str(),(int)str.length());
     }
 
     inline std::string ToStdString(const hgl::OSString &str)
     {
-        hgl::UTF8String u8_str=hgl::to_u8(str);
+        hgl::U8String u8_str=hgl::to_u8(str);
 
         return std::string((char *)u8_str.c_str(),str.Length());
     }
@@ -51,14 +51,14 @@ namespace hgl
 
     inline std::wstring ToStdWString(const OSString &str)
     {
-        hgl::WideString w_str=hgl::to_wide<sizeof(wchar_t)>(str);
+        hgl::WString w_str=hgl::to_wide<sizeof(wchar_t)>(str);
 
         return std::wstring(w_str.c_str(),w_str.Length());
     }
     #endif//
 
-    inline hgl::UTF8String ToUTF8String(const std::string &str)
+    inline hgl::U8String ToU8String(const std::string &str)
     {
-        return hgl::UTF8String((hgl::u8char *)str.c_str(),int(str.size()));
+        return hgl::U8String((hgl::u8char *)str.c_str(),int(str.size()));
     }
 }
\ No newline at end of file
diff --git a/inc/hgl/type/String.h b/inc/hgl/type/String.h
index 1e58e29..0520b7a 100644
--- a/inc/hgl/type/String.h
+++ b/inc/hgl/type/String.h
@@ -1325,14 +1325,14 @@ namespace hgl
         return String<T>(value)+str;
     }
     
-    using AnsiString    =String<char>;
-    using UTF8String    =String<u8char>;
-    using UTF16String   =String<u16char>;
-    using UTF32String   =String<char32_t>;
-    using OSString      =String<os_char>;
-    using WideString    =String<wchar_t>;
+    using AnsiString=String<char>;
+    using U8String  =String<u8char>;
+    using U16String =String<u16char>;
+    using U32String =String<char32_t>;
+    using OSString  =String<os_char>;
+    using WString   =String<wchar_t>;
 
-    using ShaderString  =UTF8String;
+    using ShaderString  =U8String;
 
     template<typename C> bool ToNumber(const String<C> &str,int &value){return str.ToInt(value);}
     template<typename C> bool ToNumber(const String<C> &str,uint &value){return str.ToUint(value);}
@@ -1398,12 +1398,12 @@ namespace hgl
         return PointerToHexString<os_char>(value);
     }
 
-    inline String<char> PointerToHexUTF8String(const void *value)
+    inline String<char> PointerToHexU8String(const void *value)
     {
         return PointerToHexString<char>(value);
     }
 
-    inline String<u16char> PointerToHexUTF16String(const void *value)
+    inline String<u16char> PointerToHexU16String(const void *value)
     {
         return PointerToHexString<u16char>(value);
     }
diff --git a/inc/hgl/type/StringList.h b/inc/hgl/type/StringList.h
index 7ff3478..748b521 100644
--- a/inc/hgl/type/StringList.h
+++ b/inc/hgl/type/StringList.h
@@ -296,11 +296,11 @@ namespace hgl
 
 #define DEFINE_STRING_LIST(name)    using name##StringList=StringList<name##String::CharType>;
 
-    DEFINE_STRING_LIST(UTF8)
-    DEFINE_STRING_LIST(UTF16)
-    DEFINE_STRING_LIST(UTF32)
+    DEFINE_STRING_LIST(U8)
+    DEFINE_STRING_LIST(U16)
+    DEFINE_STRING_LIST(U32)
     DEFINE_STRING_LIST(Ansi)
-    DEFINE_STRING_LIST(Wide)
+    DEFINE_STRING_LIST(W)
     DEFINE_STRING_LIST(OS)
 
 #undef DEFINE_STRING_LIST
diff --git a/inc/hgl/type/StringView.h b/inc/hgl/type/StringView.h
index 8e00efe..2fb7db4 100644
--- a/inc/hgl/type/StringView.h
+++ b/inc/hgl/type/StringView.h
@@ -58,11 +58,11 @@ namespace hgl
         }
     };//class StringView
 
-    using UTF8StringView=StringView<u8char>;
-    using UTF16StringView=StringView<u16char>;
-    using UTF32StringView=StringView<u32char>;
+    using U8StringView=StringView<u8char>;
+    using U16StringView=StringView<u16char>;
+    using U32StringView=StringView<u32char>;
     
     using OSStringView  =StringView<os_char>;
     using AnsiStringView=StringView<char>;
-    using WideStringView=StringView<wchar_t>;
+    using WStringView=StringView<wchar_t>;
 }//namespace hgl
diff --git a/src/IO/DataInputStream.cpp b/src/IO/DataInputStream.cpp
index 12cd61b..1fe203e 100644
--- a/src/IO/DataInputStream.cpp
+++ b/src/IO/DataInputStream.cpp
@@ -38,7 +38,7 @@ namespace hgl
         }
 
         template<typename T>
-        bool ReadUTF8String(char *buf,uint max_len,DataInputStream *dis)
+        bool ReadU8String(char *buf,uint max_len,DataInputStream *dis)
         {
             if(!buf||!max_len||!dis)
                 return(false);
@@ -73,12 +73,12 @@ namespace hgl
             return(true);
         }
 
-        bool DataInputStream::ReadUTF8String        (char *u8str,uint max_len){return hgl::io::ReadUTF8String<uint32>(u8str,max_len,this);}
-        bool DataInputStream::ReadUTF8ShortString   (char *u8str,uint max_len){return hgl::io::ReadUTF8String<uint16>(u8str,max_len,this);}
-        bool DataInputStream::ReadUTF8TinyString    (char *u8str,uint max_len){return hgl::io::ReadUTF8String<uint8 >(u8str,max_len,this);}
+        bool DataInputStream::ReadU8String        (char *u8str,uint max_len){return hgl::io::ReadU8String<uint32>(u8str,max_len,this);}
+        bool DataInputStream::ReadUTF8ShortString   (char *u8str,uint max_len){return hgl::io::ReadU8String<uint16>(u8str,max_len,this);}
+        bool DataInputStream::ReadUTF8TinyString    (char *u8str,uint max_len){return hgl::io::ReadU8String<uint8 >(u8str,max_len,this);}
 
         template<typename T>
-        bool ReadUTF8String(UTF8String &u8str,uint max_len,DataInputStream *dis)
+        bool ReadU8String(U8String &u8str,uint max_len,DataInputStream *dis)
         {
             if(!max_len||!dis)
                 return(false);
@@ -108,12 +108,12 @@ namespace hgl
             return(true);
         }
 
-        bool DataInputStream::ReadUTF8String        (UTF8String &u8str,uint max_len){return hgl::io::ReadUTF8String<uint32>(u8str,max_len,this);}
-        bool DataInputStream::ReadUTF8ShortString   (UTF8String &u8str,uint max_len){return hgl::io::ReadUTF8String<uint16>(u8str,max_len,this);}
-        bool DataInputStream::ReadUTF8TinyString    (UTF8String &u8str,uint max_len){return hgl::io::ReadUTF8String<uint8 >(u8str,max_len,this);}
+        bool DataInputStream::ReadU8String        (U8String &u8str,uint max_len){return hgl::io::ReadU8String<uint32>(u8str,max_len,this);}
+        bool DataInputStream::ReadUTF8ShortString   (U8String &u8str,uint max_len){return hgl::io::ReadU8String<uint16>(u8str,max_len,this);}
+        bool DataInputStream::ReadUTF8TinyString    (U8String &u8str,uint max_len){return hgl::io::ReadU8String<uint8 >(u8str,max_len,this);}
 
         template<typename T>
-        bool ReadUTF8String(UTF16String &u16str,uint max_len,DataInputStream *dis)
+        bool ReadU8String(U16String &u16str,uint max_len,DataInputStream *dis)
         {
             if(!max_len||!dis)
                 return(false);
@@ -149,12 +149,12 @@ namespace hgl
             return(true);
         }
 
-        bool DataInputStream::ReadUTF8String        (UTF16String &u16str,uint max_len){return hgl::io::ReadUTF8String<uint32>(u16str,max_len,this);}
-        bool DataInputStream::ReadUTF8ShortString   (UTF16String &u16str,uint max_len){return hgl::io::ReadUTF8String<uint16>(u16str,max_len,this);}
-        bool DataInputStream::ReadUTF8TinyString    (UTF16String &u16str,uint max_len){return hgl::io::ReadUTF8String<uint8 >(u16str,max_len,this);}
+        bool DataInputStream::ReadU8String        (U16String &u16str,uint max_len){return hgl::io::ReadU8String<uint32>(u16str,max_len,this);}
+        bool DataInputStream::ReadUTF8ShortString   (U16String &u16str,uint max_len){return hgl::io::ReadU8String<uint16>(u16str,max_len,this);}
+        bool DataInputStream::ReadUTF8TinyString    (U16String &u16str,uint max_len){return hgl::io::ReadU8String<uint8 >(u16str,max_len,this);}
 
         template<char E,typename T>
-        bool ReadUTF16String(u16char *str,uint max_len,DataInputStream *dis)
+        bool ReadU16String(u16char *str,uint max_len,DataInputStream *dis)
         {
             if(!dis)return(false);
             if(!str||!max_len)return(false);
@@ -192,16 +192,16 @@ namespace hgl
             return(true);
         }
 
-        bool DataInputStream::ReadUTF16LEString     (u16char *u16str,uint max_len){return ReadUTF16String<HGL_LITTLE_ENDIAN,uint32>(u16str,max_len,this);}
-        bool DataInputStream::ReadUTF16LEShortString(u16char *u16str,uint max_len){return ReadUTF16String<HGL_LITTLE_ENDIAN,uint16>(u16str,max_len,this);}
-        bool DataInputStream::ReadUTF16LETinyString (u16char *u16str,uint max_len){return ReadUTF16String<HGL_LITTLE_ENDIAN,uint8 >(u16str,max_len,this);}
+        bool DataInputStream::ReadUTF16LEString     (u16char *u16str,uint max_len){return ReadU16String<HGL_LITTLE_ENDIAN,uint32>(u16str,max_len,this);}
+        bool DataInputStream::ReadUTF16LEShortString(u16char *u16str,uint max_len){return ReadU16String<HGL_LITTLE_ENDIAN,uint16>(u16str,max_len,this);}
+        bool DataInputStream::ReadUTF16LETinyString (u16char *u16str,uint max_len){return ReadU16String<HGL_LITTLE_ENDIAN,uint8 >(u16str,max_len,this);}
 
-        bool DataInputStream::ReadUTF16BEString     (u16char *u16str,uint max_len){return ReadUTF16String<HGL_BIG_ENDIAN,uint32>(u16str,max_len,this);}
-        bool DataInputStream::ReadUTF16BEShortString(u16char *u16str,uint max_len){return ReadUTF16String<HGL_BIG_ENDIAN,uint16>(u16str,max_len,this);}
-        bool DataInputStream::ReadUTF16BETinyString (u16char *u16str,uint max_len){return ReadUTF16String<HGL_BIG_ENDIAN,uint8 >(u16str,max_len,this);}
+        bool DataInputStream::ReadUTF16BEString     (u16char *u16str,uint max_len){return ReadU16String<HGL_BIG_ENDIAN,uint32>(u16str,max_len,this);}
+        bool DataInputStream::ReadUTF16BEShortString(u16char *u16str,uint max_len){return ReadU16String<HGL_BIG_ENDIAN,uint16>(u16str,max_len,this);}
+        bool DataInputStream::ReadUTF16BETinyString (u16char *u16str,uint max_len){return ReadU16String<HGL_BIG_ENDIAN,uint8 >(u16str,max_len,this);}
 
         template<char E,typename T>
-        bool ReadUTF16String(UTF16String &str,DataInputStream *dis,uint max_len)
+        bool ReadU16String(U16String &str,DataInputStream *dis,uint max_len)
         {
             if(!dis||!max_len)return(false);
 
@@ -237,12 +237,12 @@ namespace hgl
             return(true);
         }
 
-        bool DataInputStream::ReadUTF16LEString     (UTF16String &u16str,uint max_len){return ReadUTF16String<HGL_LITTLE_ENDIAN,uint32>(u16str,this,max_len);}
-        bool DataInputStream::ReadUTF16LEShortString(UTF16String &u16str,uint max_len){return ReadUTF16String<HGL_LITTLE_ENDIAN,uint16>(u16str,this,max_len);}
-        bool DataInputStream::ReadUTF16LETinyString (UTF16String &u16str,uint max_len){return ReadUTF16String<HGL_LITTLE_ENDIAN,uint8 >(u16str,this,max_len);}
+        bool DataInputStream::ReadUTF16LEString     (U16String &u16str,uint max_len){return ReadU16String<HGL_LITTLE_ENDIAN,uint32>(u16str,this,max_len);}
+        bool DataInputStream::ReadUTF16LEShortString(U16String &u16str,uint max_len){return ReadU16String<HGL_LITTLE_ENDIAN,uint16>(u16str,this,max_len);}
+        bool DataInputStream::ReadUTF16LETinyString (U16String &u16str,uint max_len){return ReadU16String<HGL_LITTLE_ENDIAN,uint8 >(u16str,this,max_len);}
 
-        bool DataInputStream::ReadUTF16BEString     (UTF16String &u16str,uint max_len){return ReadUTF16String<HGL_BIG_ENDIAN,uint32>(u16str,this,max_len);}
-        bool DataInputStream::ReadUTF16BEShortString(UTF16String &u16str,uint max_len){return ReadUTF16String<HGL_BIG_ENDIAN,uint16>(u16str,this,max_len);}
-        bool DataInputStream::ReadUTF16BETinyString (UTF16String &u16str,uint max_len){return ReadUTF16String<HGL_BIG_ENDIAN,uint8 >(u16str,this,max_len);}
+        bool DataInputStream::ReadUTF16BEString     (U16String &u16str,uint max_len){return ReadU16String<HGL_BIG_ENDIAN,uint32>(u16str,this,max_len);}
+        bool DataInputStream::ReadUTF16BEShortString(U16String &u16str,uint max_len){return ReadU16String<HGL_BIG_ENDIAN,uint16>(u16str,this,max_len);}
+        bool DataInputStream::ReadUTF16BETinyString (U16String &u16str,uint max_len){return ReadU16String<HGL_BIG_ENDIAN,uint8 >(u16str,this,max_len);}
     }//namespace io
 }//namespace hgl
diff --git a/src/IO/DataOutputStream.cpp b/src/IO/DataOutputStream.cpp
index 60a3949..3d7b6cc 100644
--- a/src/IO/DataOutputStream.cpp
+++ b/src/IO/DataOutputStream.cpp
@@ -27,7 +27,7 @@ namespace hgl
 
     namespace io    //write utf8 string
     {
-        template<typename T> bool DataOutputStream::WriteUTF8StringWithLength(const u8char *str,const uint length)
+        template<typename T> bool DataOutputStream::WriteU8StringWithLength(const u8char *str,const uint length)
         {
             if(!out)return(false);
 
@@ -42,14 +42,14 @@ namespace hgl
             return WriteUTF8Chars(str,length);
         }
 
-        template<typename T> bool DataOutputStream::WriteUTF8StringWithLength(const UTF16String &str)
+        template<typename T> bool DataOutputStream::WriteU8StringWithLength(const U16String &str)
         {
             if(!out)return(false);
 
             int utf8_count;
             u8char *utf8_str=u16_to_u8(str.c_str(),str.Length(),utf8_count);
 
-            const bool result=WriteUTF8StringWithLength<T>(utf8_str,utf8_count);
+            const bool result=WriteU8StringWithLength<T>(utf8_str,utf8_count);
 
             delete[] utf8_str;
 
@@ -83,7 +83,7 @@ namespace hgl
             if(length==0)return(true);
             if(!out||!str||!*str)return(false);
 
-            UTF16String u16_str=to_u16(str);
+            U16String u16_str=to_u16(str);
 
             return WriteUTF16Chars<HGL_LITTLE_ENDIAN>(this,u16_str.c_str(),u16_str.Length());
         }
@@ -104,7 +104,7 @@ namespace hgl
             if(length==0)return(true);
             if(!out||!str||!*str)return(false);
 
-            UTF16String u16_str=to_u16(str,length);
+            U16String u16_str=to_u16(str,length);
 
             return WriteUTF16Chars<HGL_BIG_ENDIAN>(this,u16_str.c_str(),u16_str.Length());
         }
@@ -120,7 +120,7 @@ namespace hgl
 
     namespace io    //write utf16 string
     {
-        template<uchar C,typename T> bool DataOutputStream::WriteUTF16StringWithLength(const u16char *str,const uint len)
+        template<uchar C,typename T> bool DataOutputStream::WriteU16StringWithLength(const u16char *str,const uint len)
         {
             if(!out)return(false);
             if(len&&!str)return(false);
@@ -136,50 +136,50 @@ namespace hgl
 
     namespace io
     {
-        bool DataOutputStream::WriteUTF8String        (const u8char *str,uint length){return WriteUTF8StringWithLength<uint32>(str,         length);}                               ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
-        bool DataOutputStream::WriteUTF8String        (const u8char *str            ){return WriteUTF8StringWithLength<uint32>(str,         hgl::strlen(str));}                     ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
-        bool DataOutputStream::WriteUTF8String        (const UTF8String &str      ){return WriteUTF8StringWithLength<uint32>(str.c_str(), str.Length());}                         ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
-        bool DataOutputStream::WriteUTF8String        (const UTF16String &str     ){return WriteUTF8StringWithLength<uint32>(str);}                                               ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteU8String        (const u8char *str,uint length){return WriteU8StringWithLength<uint32>(str,         length);}                               ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteU8String        (const u8char *str            ){return WriteU8StringWithLength<uint32>(str,         hgl::strlen(str));}                     ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteU8String        (const U8String &str      ){return WriteU8StringWithLength<uint32>(str.c_str(), str.Length());}                         ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteU8String        (const U16String &str     ){return WriteU8StringWithLength<uint32>(str);}                                               ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
 
-        bool DataOutputStream::WriteUTF16LEString     (const u16char *str,uint len){return WriteUTF16StringWithLength<HGL_LITTLE_ENDIAN,  uint32>(str,        len);}              ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
-        bool DataOutputStream::WriteUTF16BEString     (const u16char *str,uint len){return WriteUTF16StringWithLength<HGL_BIG_ENDIAN,     uint32>(str,        len);}              ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF16LEString     (const u16char *str,uint len){return WriteU16StringWithLength<HGL_LITTLE_ENDIAN,  uint32>(str,        len);}              ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF16BEString     (const u16char *str,uint len){return WriteU16StringWithLength<HGL_BIG_ENDIAN,     uint32>(str,        len);}              ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
 
-        bool DataOutputStream::WriteUTF16LEString     (const UTF16String &str     ){return WriteUTF16StringWithLength<HGL_LITTLE_ENDIAN,  uint32>(str.c_str(),str.Length());}     ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
-        bool DataOutputStream::WriteUTF16BEString     (const UTF16String &str     ){return WriteUTF16StringWithLength<HGL_BIG_ENDIAN,     uint32>(str.c_str(),str.Length());}     ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF16LEString     (const U16String &str     ){return WriteU16StringWithLength<HGL_LITTLE_ENDIAN,  uint32>(str.c_str(),str.Length());}     ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF16BEString     (const U16String &str     ){return WriteU16StringWithLength<HGL_BIG_ENDIAN,     uint32>(str.c_str(),str.Length());}     ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
 
-        bool DataOutputStream::WriteUTF16LEString     (const u16char *str         ){return WriteUTF16StringWithLength<HGL_LITTLE_ENDIAN,  uint32>(str,        hgl::strlen(str));} ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
-        bool DataOutputStream::WriteUTF16BEString     (const u16char *str         ){return WriteUTF16StringWithLength<HGL_BIG_ENDIAN,     uint32>(str,        hgl::strlen(str));} ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF16LEString     (const u16char *str         ){return WriteU16StringWithLength<HGL_LITTLE_ENDIAN,  uint32>(str,        hgl::strlen(str));} ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF16BEString     (const u16char *str         ){return WriteU16StringWithLength<HGL_BIG_ENDIAN,     uint32>(str,        hgl::strlen(str));} ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
 
 
 
-        bool DataOutputStream::WriteUTF8ShortString   (const u8char *str,uint length){return WriteUTF8StringWithLength<uint16>(str,         length);}                               ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
-        bool DataOutputStream::WriteUTF8ShortString   (const u8char *str            ){return WriteUTF8StringWithLength<uint16>(str,         hgl::strlen(str));}                     ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
-        bool DataOutputStream::WriteUTF8ShortString   (const UTF8String &str      ){return WriteUTF8StringWithLength<uint16>(str.c_str(), str.Length());}                         ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
-        bool DataOutputStream::WriteUTF8ShortString   (const UTF16String &str     ){return WriteUTF8StringWithLength<uint16>(str);}                                               ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF8ShortString   (const u8char *str,uint length){return WriteU8StringWithLength<uint16>(str,         length);}                               ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF8ShortString   (const u8char *str            ){return WriteU8StringWithLength<uint16>(str,         hgl::strlen(str));}                     ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF8ShortString   (const U8String &str      ){return WriteU8StringWithLength<uint16>(str.c_str(), str.Length());}                         ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF8ShortString   (const U16String &str     ){return WriteU8StringWithLength<uint16>(str);}                                               ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
 
-        bool DataOutputStream::WriteUTF16LEShortString(const u16char *str,uint len){return WriteUTF16StringWithLength<HGL_LITTLE_ENDIAN,  uint16>(str,        len);}              ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
-        bool DataOutputStream::WriteUTF16BEShortString(const u16char *str,uint len){return WriteUTF16StringWithLength<HGL_BIG_ENDIAN,     uint16>(str,        len);}              ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF16LEShortString(const u16char *str,uint len){return WriteU16StringWithLength<HGL_LITTLE_ENDIAN,  uint16>(str,        len);}              ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF16BEShortString(const u16char *str,uint len){return WriteU16StringWithLength<HGL_BIG_ENDIAN,     uint16>(str,        len);}              ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
 
-        bool DataOutputStream::WriteUTF16LEShortString(const UTF16String &str     ){return WriteUTF16StringWithLength<HGL_LITTLE_ENDIAN,  uint16>(str.c_str(),str.Length());}     ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
-        bool DataOutputStream::WriteUTF16BEShortString(const UTF16String &str     ){return WriteUTF16StringWithLength<HGL_BIG_ENDIAN,     uint16>(str.c_str(),str.Length());}     ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF16LEShortString(const U16String &str     ){return WriteU16StringWithLength<HGL_LITTLE_ENDIAN,  uint16>(str.c_str(),str.Length());}     ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF16BEShortString(const U16String &str     ){return WriteU16StringWithLength<HGL_BIG_ENDIAN,     uint16>(str.c_str(),str.Length());}     ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
 
-        bool DataOutputStream::WriteUTF16LEShortString(const u16char *str         ){return WriteUTF16StringWithLength<HGL_LITTLE_ENDIAN,  uint16>(str,        hgl::strlen(str));} ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
-        bool DataOutputStream::WriteUTF16BEShortString(const u16char *str         ){return WriteUTF16StringWithLength<HGL_BIG_ENDIAN,     uint16>(str,        hgl::strlen(str));} ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF16LEShortString(const u16char *str         ){return WriteU16StringWithLength<HGL_LITTLE_ENDIAN,  uint16>(str,        hgl::strlen(str));} ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF16BEShortString(const u16char *str         ){return WriteU16StringWithLength<HGL_BIG_ENDIAN,     uint16>(str,        hgl::strlen(str));} ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
 
 
 
-        bool DataOutputStream::WriteUTF8TinyString    (const u8char *str,uint length){return WriteUTF8StringWithLength<uint8>(str,          length);}                             ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
-        bool DataOutputStream::WriteUTF8TinyString    (const u8char *str            ){return WriteUTF8StringWithLength<uint8>(str,          hgl::strlen(str));}                   ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
-        bool DataOutputStream::WriteUTF8TinyString    (const UTF8String &str        ){return WriteUTF8StringWithLength<uint8>(str.c_str(),  str.Length());}                       ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
-        bool DataOutputStream::WriteUTF8TinyString    (const UTF16String &str       ){return WriteUTF8StringWithLength<uint8>(str);}                                              ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF8TinyString    (const u8char *str,uint length){return WriteU8StringWithLength<uint8>(str,          length);}                             ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF8TinyString    (const u8char *str            ){return WriteU8StringWithLength<uint8>(str,          hgl::strlen(str));}                   ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF8TinyString    (const U8String &str        ){return WriteU8StringWithLength<uint8>(str.c_str(),  str.Length());}                       ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF8TinyString    (const U16String &str       ){return WriteU8StringWithLength<uint8>(str);}                                              ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
 
-        bool DataOutputStream::WriteUTF16LETinyString (const u16char *str,uint len){return WriteUTF16StringWithLength<HGL_LITTLE_ENDIAN,  uint8>(str,         len);}              ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
-        bool DataOutputStream::WriteUTF16BETinyString (const u16char *str,uint len){return WriteUTF16StringWithLength<HGL_BIG_ENDIAN,     uint8>(str,         len);}              ///<按utf16-be格式写入字符串(前置1字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF16LETinyString (const u16char *str,uint len){return WriteU16StringWithLength<HGL_LITTLE_ENDIAN,  uint8>(str,         len);}              ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF16BETinyString (const u16char *str,uint len){return WriteU16StringWithLength<HGL_BIG_ENDIAN,     uint8>(str,         len);}              ///<按utf16-be格式写入字符串(前置1字节字符串长度,再写入字符阵列)
 
-        bool DataOutputStream::WriteUTF16LETinyString (const UTF16String &str     ){return WriteUTF16StringWithLength<HGL_LITTLE_ENDIAN,  uint8>(str.c_str(), str.Length());}     ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
-        bool DataOutputStream::WriteUTF16BETinyString (const UTF16String &str     ){return WriteUTF16StringWithLength<HGL_BIG_ENDIAN,     uint8>(str.c_str(), str.Length());}     ///<按utf16-be格式写入字符串(前置1字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF16LETinyString (const U16String &str     ){return WriteU16StringWithLength<HGL_LITTLE_ENDIAN,  uint8>(str.c_str(), str.Length());}     ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF16BETinyString (const U16String &str     ){return WriteU16StringWithLength<HGL_BIG_ENDIAN,     uint8>(str.c_str(), str.Length());}     ///<按utf16-be格式写入字符串(前置1字节字符串长度,再写入字符阵列)
 
-        bool DataOutputStream::WriteUTF16LETinyString (const u16char *str         ){return WriteUTF16StringWithLength<HGL_LITTLE_ENDIAN,  uint8>(str,         hgl::strlen(str));} ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
-        bool DataOutputStream::WriteUTF16BETinyString (const u16char *str         ){return WriteUTF16StringWithLength<HGL_BIG_ENDIAN,     uint8>(str,         hgl::strlen(str));} ///<按utf16-be格式写入字符串(前置1字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF16LETinyString (const u16char *str         ){return WriteU16StringWithLength<HGL_LITTLE_ENDIAN,  uint8>(str,         hgl::strlen(str));} ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF16BETinyString (const u16char *str         ){return WriteU16StringWithLength<HGL_BIG_ENDIAN,     uint8>(str,         hgl::strlen(str));} ///<按utf16-be格式写入字符串(前置1字节字符串长度,再写入字符阵列)
     }//namespace io
 }//namespace hgl
diff --git a/src/Text/ConstStringSetSaveToTextStream.cpp b/src/Text/ConstStringSetSaveToTextStream.cpp
index 44d706f..9a73253 100644
--- a/src/Text/ConstStringSetSaveToTextStream.cpp
+++ b/src/Text/ConstStringSetSaveToTextStream.cpp
@@ -79,12 +79,12 @@ namespace hgl
     //下面这些定义是为了实例化上面的函数，所以不要删掉
 
     //bool SaveToAnsiTextStream(hgl::io::TextOutputStream *tos,const ConstAnsiStringSet *css,bool output_id){return SaveToTextStream(tos,css,output_id);}
-    bool SaveToWideTextStream(hgl::io::TextOutputStream *tos,const ConstWideStringSet *css,bool output_id){return SaveToTextStream(tos,css,output_id);}
-    bool SaveToUTF8TextStream(hgl::io::TextOutputStream *tos,const ConstUTF8StringSet *css,bool output_id){return SaveToTextStream(tos,css,output_id);}
-    bool SaveToUTF16TextStream(hgl::io::TextOutputStream *tos,const ConstUTF16StringSet *css,bool output_id){return SaveToTextStream(tos,css,output_id);}
+    bool SaveToWideTextStream(hgl::io::TextOutputStream *tos,const ConstWStringSet *css,bool output_id){return SaveToTextStream(tos,css,output_id);}
+    bool SaveToUTF8TextStream(hgl::io::TextOutputStream *tos,const ConstU8StringSet *css,bool output_id){return SaveToTextStream(tos,css,output_id);}
+    bool SaveToUTF16TextStream(hgl::io::TextOutputStream *tos,const ConstU16StringSet *css,bool output_id){return SaveToTextStream(tos,css,output_id);}
 
     //bool SaveToAnsiTextFile(const OSString &filename,const ConstAnsiStringSet *css,bool output_id,bool output_bom){return SaveToTextFile(filename,css,output_id,output_bom);}
-    bool SaveToWideTextFile(const OSString &filename,const ConstWideStringSet *css,bool output_id,bool output_bom){return SaveToTextFile(filename,css,output_id,output_bom);}
-    bool SaveToUTF8TextFile(const OSString &filename,const ConstUTF8StringSet *css,bool output_id,bool output_bom){return SaveToTextFile(filename,css,output_id,output_bom);}
-    bool SaveToUTF16TextFile(const OSString &filename,const ConstUTF16StringSet *css,bool output_id,bool output_bom){return SaveToTextFile(filename,css,output_id,output_bom);}
+    bool SaveToWideTextFile(const OSString &filename,const ConstWStringSet *css,bool output_id,bool output_bom){return SaveToTextFile(filename,css,output_id,output_bom);}
+    bool SaveToUTF8TextFile(const OSString &filename,const ConstU8StringSet *css,bool output_id,bool output_bom){return SaveToTextFile(filename,css,output_id,output_bom);}
+    bool SaveToUTF16TextFile(const OSString &filename,const ConstU16StringSet *css,bool output_id,bool output_bom){return SaveToTextFile(filename,css,output_id,output_bom);}
 }//namespace hgl
diff --git a/src/Text/LoadString.cpp b/src/Text/LoadString.cpp
index 71220b3..27c1ace 100644
--- a/src/Text/LoadString.cpp
+++ b/src/Text/LoadString.cpp
@@ -3,9 +3,9 @@
 namespace hgl
 {
     /**
-     * 加载一个原始文本块到UTF8String
+     * 加载一个原始文本块到U8String
      */
-    int LoadStringFromText(UTF8String &full_text,const void *source_data,const int size,const CharSet &cs)
+    int LoadStringFromText(U8String &full_text,const void *source_data,const int size,const CharSet &cs)
     {
         if(!source_data||size<=0)
             return 0;
@@ -83,9 +83,9 @@ namespace hgl
     }
 
     /**
-     * 加载一个原始文本块到UTF16String
+     * 加载一个原始文本块到U16String
      */
-    int LoadStringFromText(UTF16String &full_text,const void *source_data,const int size,const CharSet &cs)
+    int LoadStringFromText(U16String &full_text,const void *source_data,const int size,const CharSet &cs)
     {
         if(!source_data||size<=0)
             return(0);
@@ -165,9 +165,9 @@ namespace hgl
     }
     
     /**
-     * 加载一个原始文本文件到UTF8String
+     * 加载一个原始文本文件到U8String
      */
-    int LoadStringFromTextFile(UTF8String &str,const OSString &filename,const CharSet &cs)
+    int LoadStringFromTextFile(U8String &str,const OSString &filename,const CharSet &cs)
     {
         uchar *data;
 
@@ -180,9 +180,9 @@ namespace hgl
     }
 
     /**
-     * 加载一个原始文本文件到UTF16String
+     * 加载一个原始文本文件到U16String
      */
-    int LoadStringFromTextFile(UTF16String &str,const OSString &filename,const CharSet &cs)
+    int LoadStringFromTextFile(U16String &str,const OSString &filename,const CharSet &cs)
     {
         uchar *data;
 
diff --git a/src/Text/LoadStringList.cpp b/src/Text/LoadStringList.cpp
index b90fdcf..0d32bae 100644
--- a/src/Text/LoadStringList.cpp
+++ b/src/Text/LoadStringList.cpp
@@ -6,11 +6,11 @@
 namespace hgl
 {
     /**
-     * 加载一个原始文本块到UTF8StringList
+     * 加载一个原始文本块到U8StringList
      */
-    int LoadStringListFromText(UTF8StringList &sl,const void *data,const int size,const CharSet &cs)
+    int LoadStringListFromText(U8StringList &sl,const void *data,const int size,const CharSet &cs)
     {
-        UTF8String str;
+        U8String str;
 
         LoadStringFromText(str,data,size,cs);
 
@@ -18,11 +18,11 @@ namespace hgl
     }
 
     /**
-     * 加载一个原始文本块到UTF16StringList
+     * 加载一个原始文本块到U16StringList
      */
-    int LoadStringListFromText(UTF16StringList &sl,const void *data,const int size,const CharSet &cs)
+    int LoadStringListFromText(U16StringList &sl,const void *data,const int size,const CharSet &cs)
     {
-        UTF16String str;
+        U16String str;
 
         LoadStringFromText(str,data,size,cs);
 
@@ -30,9 +30,9 @@ namespace hgl
     }
 
     /**
-     * 加载一个原始文本文件到UTF8StringList
+     * 加载一个原始文本文件到U8StringList
      */
-    int LoadStringListFromTextFile(UTF8StringList &sl,const OSString &filename,const CharSet &cs)
+    int LoadStringListFromTextFile(U8StringList &sl,const OSString &filename,const CharSet &cs)
     {
         uchar *data;
 
@@ -45,9 +45,9 @@ namespace hgl
     }
 
     /**
-     * 加载一个原始文本文件到UTF16StringList
+     * 加载一个原始文本文件到U16StringList
      */
-    int LoadStringListFromTextFile(UTF16StringList &sl,const OSString &filename,const CharSet &cs)
+    int LoadStringListFromTextFile(U16StringList &sl,const OSString &filename,const CharSet &cs)
     {
         uchar *data;