IO流（字节流主要用于读写二进制文件；字符流主要用于读写文本性文件）

1.  File类

File类在java中表示(带路径的)文件或者目录

1).File常用属性和方法

public static void main(String[] args) {

        

         // 给定路径创建File对象

         // File file = new File("D:"+File.separator+"javatest"+File.separator+"a.txt");

         File file = new File("d:\javatest\b.mp3");

         System.out.println(file);

        

         // 文件基本属性

         System.out.println(file.canExecute());

         System.out.println(file.canRead());

         System.out.println(file.canWrite());

        

         // 文件的创建、删除

         if(!file.exists()) {

             

              booleanr;

              try {

                   r = file.createNewFile();

                   if(r) {

                       System.out.println("文件创建成功");

                   }

              } catch (IOExceptione) {

                   e.printStackTrace();

              }

         }

        

         // 删除文件

         file.delete();

     }

创建文件时会抛出检查时异常IOException

2）.File的路径相关

public static void main(String[] args) {

        

          File file = new File("d:\javatest\a");

//       File file = new File("a.txt");

        

         // 获取file的绝对路径

         System.out.println(file.getAbsolutePath());

         // 获取file的创建时的路径字符串

         System.out.println(file.getPath());

         // 获取文件或者目录的名字

         System.out.println(file.getName());

         // 获取文件或者目录的父目录

         System.out.println(file.getParent());

        

     }

注意：如果file是相对路径，相对路径的当前路径是工程目录(java17)

3). 目录的创建

public static void main(String[] args) {

       

         File file = new File("d:\javatest\c\d\e");

       

        if(!file.exists()) {

            booleanr;

           

            try {

                // 一次只能创建一个目录

                // r = file.mkdir();

                r = file.mkdirs();

                if(r) {

                    System.out.println("目录创建成功");

                }

            } catch (Exception e) {

                e.printStackTrace();

            }

           

         }

    }

4).目录的遍历

list():返回一个file表示的目录中的子目录或者文件，字符串数组类型

listFiles():返回一个file表示的目录中的子目录或者文件，File数组类型

public static void main(String[] args) {

        

         // 需求:遍历d:javatest目录

         // list()

         Filefile=  newFile("d:\javatest");

        

        

         /*

         String[] list = file.list();

        

         for (String str : list) {

              System.out.print(str);

              File f = new File(file.getPath()+"\"+str);

              if(f.isDirectory()) {

                   System.out.println(" 目录");

              }else {

                   System.out.println(" 文件");

              }

         }*/

        

        

         // listFiles();

         File[] listFiles = file.listFiles();

         for (Filef :listFiles) {

              System.out.print(f.getName());

              if(f.isDirectory()) {

                   System.out.println(" 目录");

              }else {

                   System.out.println(" 文件");

              }

         }

     }

2. IO流

1).  流

流(stream):流是一连串流动的数据(字节、字符),以先进先出的方式发送的信息的通道中。

2).  输入流和输出流

输入流

数据从源数据源流入程序的过程称为输入流。可以理解为从源数据源读取数据到程序的过程

 

输出流

数据从程序流出到目的地的过程称为输出流。可以理解为把数据从程序写入目的地的过程

 

注：数据源一般指提供数据的原始媒介,一般常见有文件、数据库、云端、其他硬件等能提供数据的媒介。

3).  流的分类

按照流向分为输入流和输出流

按照处理单元分为字节流和字符流

按照功能分为节点流和转换流。

 

3 .  InputStream/OutputStream

InputStream  是所有字节输入流的抽象父类，提供了

read   读取一个字节

read(byte[] buf) 读取一定量的字节到缓冲区数组buf中。

OutputStream  是所有字节输出流的抽象父类，提供了

write() 写入一个字节

write(byte[] buf) 写入一定量的字节到输出流

FileInputStream文件字节输入流，专门用于从文件中读取字节到程序内存中。

FileOutputStream文件字节输出流，专门用于从内存中写入字节到文件中。

需求:从文件读取一个字节

public static void main(String[] args) {

        

         // 需求:读取一个文件中的一个字节

         File file = new File("d:\javatest\a.txt");

        

         // 【1】创建管道

         FileInputStreamin = null;

        

         try {

              in = newFileInputStream(file);

             

              // 【2】从管道读取一个字节

              /*

              int t;

              t = in.read();

              t = in.read();

              t = in.read();

              t = in.read();

              */

              // System.out.println(t);

             

              // 循环读取一个字节

              intt;

              StringBuildersb = newStringBuilder();

              while( (t=in.read()) != -1 ) {

                   sb.append((char)t);

              }

             

              System.out.println(sb.toString());

             

             

             

         } catch (FileNotFoundExceptione) {

              e.printStackTrace();

         } catch(IOExceptione) {

              e.printStackTrace();

         }

        

         // 【3】关闭流管道

         try {

              in.close();

         } catch (IOExceptione) {

              e.printStackTrace();

         }

     }

一次读取多个字节

public static void main(String[] args) {

        

         // 需求:一次读取多个字节

         File file = new File("d:\javatest\a.txt");

        

         // 【1】创建管道

          FileInputStreamin = null;

        

         try {

              in = newFileInputStream(file);

             

              // 【2】从管道读取多个字节到缓冲区

              /*

              byte[] buf = new byte[5];

              intlen;

              len = in.read(buf);

              len = in.read(buf);

              len = in.read(buf);

              len = in.read(buf);

             

              for(byte b:buf) {

                   System.out.print((char)b+"	");

              }

              System.out.println(len);

              */

             

              // 通过循环读取文件

              byte[] buf = newbyte[5];

              intlen;

              StringBuildersb = newStringBuilder();

              while( (len=in.read(buf)) != -1 ) {

                   // 读取的内容是原始二进制流，需要根据编码的字符集解码成对于字符

                   String str = new String(buf,0,len);

                   sb.append(str);

              }

              System.out.println(sb.toString());

             

             

             

             

         } catch (FileNotFoundExceptione) {

              e.printStackTrace();

         } catch(IOExceptione) {

              e.printStackTrace();

         }

        

         // 【3】关闭流管道

         try {

              in.close();

         } catch (IOExceptione) {

              e.printStackTrace();

         }

     }

需求:按照指定编码写入文件

public static void main(String[] args) {

        

        

         File file = new File("d:\javatest\c.txt");

        

         FileOutputStreamout = null;

        

         try {

              // 【1】创建输出流管道

              out = newFileOutputStream(file);

             

              // 【2】写入数据到管道中

              // 一次写入一个字节

              /*

              out.write(97);

              out.write(98);

              out.write(99);

              */

             

              // 一次写入多个字节

              String str = "hello world";

              // gbk

              /*

              byte[] buf = str.getBytes();

              out.write(buf);

              */

             

              byte[] buf = str.getBytes("UTF-8");

              out.write(buf);

             

              System.out.println("写入完成!");

             

         } catch (FileNotFoundExceptione) {

              e.printStackTrace();

         } catch (IOExceptione) {

              e.printStackTrace();

         }

        

         // 【3】关闭流

         try {

              out.close();

         } catch (IOExceptione) {

              e.printStackTrace();

         }

     }

注意：

[1]字符串写入文件时一定会存在编码问题

[2]使用utf8编码写入文件时，如果不含中文时,win系统会对文件的编码造成误判。

[3]通过字节流写入文件时，向管道写入一个字节，该字节立即写入文件中。

总结

InputStream/OutputStream用于字节的读写。主要用于读取二进制文件(图片、音频、视频),也可以读取文件性文件。

需求:请把d:\javatest\logo.png 复制到工程目录中，并显示复制进度。

public static void main(String[] args) throwsFileNotFoundException,IOException {

        File oriFile = new File("d:\javatest\logo.jpg");

        File toFile = new File("logo.jpg");

 
        longtotalLen = oriFile.length();    // 文件大小

        longcpyedLen = 0;   // 已复制完成的大小

        floatprogress = 0.0f;

       

        FileInputStreamin = newFileInputStream(oriFile);

        FileOutputStreamout = newFileOutputStream(toFile);

       
        // 一次读取1kb

        byte[] buf = newbyte[512];

        intlen;

        while( (len=in.read(buf)) != -1) {

            out.write(buf, 0, len);

            cpyedLen += len;

            progress = cpyedLen*1.0f/totalLen;

            System.out.println(progress);
         

        }

       

        in.close();

        out.close();

       

        System.out.println("复制完成！");

       

    }

4.Reader/Writer

Reader 是字符输入流的抽象父类，提供了

read一次读取一个字符

read(char[] cbuf)一次读取多个字符到字符缓冲区cbuf，返回长度表示读取的字符个数。

Writer是字符输出流的抽象父类，提供了

write

write(char[] cbuf)

write(string)

FileReader文件字符输入流，专门用于读取默认字符编码文本性文件。

FileWriter文件字符输出流，专门用于写入默认字符编码的文本性文件。为了提高效率，FileWriter内部存在一个字节缓冲区，用于对待写入的字符进行统一编码到字节缓冲区，一定要在关闭流之前，调用flush方法刷新缓冲区。

需求:一次读取一个字符/多个字符到cbuf

public static void main(String[] args) throwsIOException {

       

        File file = new File("d:\javatest\d.txt");

       

        FileReaderreader = newFileReader(file);

       

        // 【1】一次读取一个字符

        /*

        int c;

        c = reader.read();

        c = reader.read();

        c = reader.read();

        c = reader.read();

        c = reader.read();

        System.out.println((char)c);

        */

       

        // 【2】一次读取多个字符到cbuf中

        /*

        char[] cbuf = new char[2];

        intlen;

        len = reader.read(cbuf);

        len = reader.read(cbuf);

        len = reader.read(cbuf);

        len = reader.read(cbuf);

        System.out.println(Arrays.toString(cbuf));

        System.out.println(len);

        */

       

        char[] cbuf = newchar[2];

        intlen;

        StringBuildersb = newStringBuilder();

        while( (len=reader.read(cbuf)) != -1 ) {

            sb.append(cbuf,0,len);

        }

       

        System.out.println(sb);

    }

需求:写入字符到文件中

public static void main(String[] args) throwsIOException {

        

        

         File file = new File("d:\javatest\f.txt");

        

         FileWriterwriter = newFileWriter(file);

        

         // 【1】一次写入一个字符

         /*writer.write('中');

         writer.write('国');*/

        

         // 【2】一次写入多个字符

         /*char[] cbuf = {'h','e','l','l','o','中','国'};

         writer.write(cbuf);*/

        

         // 【3】一次写入一个字符串

         String str = "hello你好";

         writer.write(str);

        

        

         // 刷新字节缓冲区

         writer.flush();

        

         // 关闭流通道

         writer.close();

        

         System.out.println("写入完成");

     }

5. 转换流

InputStreamReader继承于Reader，是字节流通向字符流的桥梁，可以把字节流按照指定编码解码成字符流。

OutputStreamWriter继承于Writer，是字符流通向字节流的桥梁，可以把字符流按照指定的编码编码成字节流。

1.5.1            转换流工作原理

 

需求:写入utf8文件

/**

 * 把一个字符串以utf8编码写入文件

 */

publicclass Test01 {

     public static void main(String[] args) throwsIOException {

        

        

         String str = "hello中国";

         File file = new File("d:\javatest\g.txt");

        

         // 【1】创建管道

         FileOutputStreamout = newFileOutputStream(file);

         OutputStreamWriterwriter = newOutputStreamWriter(out, "utf8");

        

         // 【2】写入管道

         writer.write(str);

        

         // 【3】刷新缓冲区

         writer.flush();

        

         // 【4】关闭管道

         out.close();

         writer.close();

        

         System.out.println("写入完成");

     }

}

需求:读取utf8文件

/**

 * 读取utf8编码的文本文件

 */

public class Test01 {

     public static void main(String[] args) throwsIOException {

        

         File file = new File("d:\javatest\g.txt");

        

         // 【1】建立管道

         FileInputStreamin = newFileInputStream(file);

         InputStreamReaderreader = newInputStreamReader(in, "UTF-8");

        

         char[] cbuf = newchar[2];

         intlen;

        

         StringBuildersb = newStringBuilder();

         while( (len=reader.read(cbuf))!=-1 ) {

              sb.append(cbuf, 0, len);

         }

         System.out.println(sb.toString());

        

     }

}

注意:

[1]win平台默认的utf8编码的文本性文件带有BOM,java转换流写入的utf8文件不带BOM。所以用java读取手动创建的utf8文件会出现一点乱码(?hello中国,?是bom导致的)《详情见下篇文章》

[2]一句话:用字符集编码,一定用字符集解码!!

总结：

FileReader = InputStreamReader + GBK

packagecn.sxt07.outputstreamwriter;

 

importjava.io.File;

importjava.io.FileInputStream;

importjava.io.FileReader;

importjava.io.IOException;

importjava.io.InputStreamReader;

 

/**

 * 读取一个gbk编码的文本性文件

 */

publicclass Test02 {

     public static void main(String[] args) throwsIOException {

        

        

         File file = new File("d:\javatest\f.txt");

        

         // 【1】建立管道

         /*

          * FileInputStream in = new FileInputStream(file);

          * InputStreamReader reader =  newInputStreamReader(in, "GBK");

          */

 

         FileReaderreader = newFileReader(file);

        

         char[] cbuf = newchar[2];

         intlen;

        

         StringBuildersb = newStringBuilder();

         while( (len=reader.read(cbuf))!=-1 ) {

              sb.append(cbuf, 0, len);

         }

        

         reader.close();

        

         System.out.println(sb.toString());

     }

}

6. BufferedReader/BufferedWriter

BufferedReader继承于Reader，提供了

read

read(char[] cbuf)

readLine() 用于读取一行文本，实现对文本的高效读取。

BufferedReader初始化时需要一个reader，本质上BufferedReader在reader的基础上增加readLine()的功能。

BufferedWriter继承于Writer，提供了

write

write(char[] cbuf)

write(string)

newLine() 写入一个行分隔符。

需求:读取一首诗

public static void main(String[] args) throwsIOException {

                  

         // 按行读取gbk文本性文件

        

         File file = new File("d:\javatest\i.txt");

        

         // 【1】创建管道

         FileReaderreader = newFileReader(file);

         BufferedReaderbr = newBufferedReader(reader);

        

         // 【2】读取一行

         /*

         String line =  br.readLine();

         line =  br.readLine();

         line =  br.readLine();

         line =  br.readLine();

         */

        

         String line;

         while( (line=br.readLine()) != null) {

              System.out.println(line);

         }

     }

需求:以gbk编码写入一首诗到文件

public static void main(String[] args) throwsIOException {

        

         File file = new File("d:\javatest\j.txt");

        

         // 【1】创建gbk管道

         FileWriterwriter = newFileWriter(file);

         BufferedWriterbw = newBufferedWriter(writer);

        

         // 【2】写入一行

         bw.write("窗前明月光，");

         bw.newLine();

        

         bw.write("疑似地上霜。");

        

         // for win

         // bw.write("
");

        

         // for unix/linux/mac

         // bw.write("
");

        

         bw.write("举头望明月,");

         bw.newLine();

        

         // 【3】flush

         bw.flush();

        

         // 【4】关闭管道

         bw.close();

         writer.close();

     }

 需求:以utf8编码高效写入文件

/**

 * 以utf8写入一首诗

 * @author Administrator

 *

 */

public class Test02 {

     public static void main(String[] args) throwsIOException {

        

         File file = new File("d:\javatest\j-utf8.txt");

        

         // 【1】创建utf8管道

         FileOutputStream out = newFileOutputStream(file);

         OutputStreamWriter writer = newOutputStreamWriter(out, "UTF-8");

         BufferedWriter bw = newBufferedWriter(writer);

        

         // 【2】写入一行

         bw.write("窗前明月光，");

         bw.newLine();

        

         bw.write("疑似地上霜。");

        

         // for win

         bw.write("
");

        

         // for unix/linux/mac

         // bw.write("
");

        

         bw.write("举头望明月,");

         bw.newLine();

        

         // 【3】flush

         bw.flush();

        

         // 【4】关闭管道

         bw.close();
　　　　　out.close();
         writer.close();

     }

}

需求：以utf-8编码高效读取文件

package bufferedreader;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

    //以utf-8读取一首诗
public class Test01 {
    public static void main(String[]args) throws FileNotFoundException,IOException{
        File file=new File("f:\javatest\f.txt");
        
        FileInputStream in=new FileInputStream(file);
        InputStreamReader reader=new InputStreamReader(in,"utf-8");
        BufferedReader br=new BufferedReader(reader);
        
        String line;
        while( (line=br.readLine())!=null){
            System.out.println(line);
        }
        
        
        in.close();
        reader.close();
        br.close();
        
        
    }
}

7.  标准输入输出流

1） 标准输入流

源数据源是标准输入设备(键盘、鼠标、触摸屏)等输入设备。在java中用System.in 得到一个InputStream字节输入流。

需求:在控制台输入一句话，然后原样输出

public static void main(String[] args) throws IOException {

         // 需求:输入一句话，然原样输出

         InputStream in = System.in;

        

         byte[] buf = newbyte[1024];

         intlen;

         // buf中包含回车和换行

         len = in.read(buf);

        

         String str = new String(buf, 0, len);

         // System.out.println(Arrays.toString(buf));

         System.out.println(str);

     }

 注意:

 标准输入流以字节流流入内存，如果在控制台中输入字符，字符以默认编码(win简体:gbk)编码成字节进入标准输入流。

public static void main(String[] args) throws IOException {

         // 需求:从控制台高效读取一行数据。把一首诗写入文件。

        

         InputStream in = System.in;

         InputStreamReader reader = new InputStreamReader(in, "GBK");

         BufferedReader br = new BufferedReader(reader);

        

         File file = new File("d:\javatest\k.txt");

         FileWriter writer = new FileWriter(file);

         BufferedWriter bw = new BufferedWriter(writer);

        

         String end = "bye";

         while(true) {

              String line = br.readLine();

              if(line.equals(end)) {

                   break;

              }

             

              bw.write(line);

              // bw.newLine();

         }

        

         bw.flush();

        

         bw.close();

         writer.close();

        

     }

2）   标准输出流(PrintStream)

数据目的地是标准输出设备(显示器)等输出设备。在java中用System.out得到一个PrintStream 字节输出流(字节打印流)。提供了更强大的

print

println

打印方法用于打印各种数据类型。

需求:读取文件，显示到标准输出设备

public static void main(String[] args) throws IOException {

        

         Filefile = new File("d:\javatest\k.txt");

        

         FileReader reader = new FileReader(file);

         BufferedReader br = new BufferedReader(reader);

        

         PrintStreamps = System.out;

        

         String line;

         while( (line=br.readLine())!=null ) {

              ps.println(line);

         }

     }

PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。

public static void main(String[] args) throws IOException {

        

        

         String str = "hello中国";

         byte[] buf = str.getBytes("utf-8");

        

         PrintStream ps = System.out;

         ps.write(buf);

        

     }

8.  字符打印流PrintWriter

PrintWriter继承Writer

数据目的地是标准输出设备(显示器)等输出设备。在java中用System.out得到一个PrintSWriter 字符输出流(字符打印流)。提供了更强大的

print

println

writer(String str)

打印方法用于打印各种数据类型。

9. Scanner

通过scanner扫描文件、字节流等

public static void main(String[] args) throws IOException {

        

         // 扫描平台默认编码的文件

         /*File file = new File("d:\javatest\j.txt");

         Scanner sc = new Scanner(file);

         */

        

         // 扫描指定编码的文件

         Scanner sc = new Scanner(new FileInputStream(new File("d:\javatest\j-utf8.txt")), "UTF-8");

        

         String line;

         while (sc.hasNextLine()) {

              line = sc.nextLine();

              System.out.println(line);

         }

        

     }

 10. 序列化

把内存中的对象永久保存到硬盘的过程称为对象序列化，也叫做持久化。

把硬盘持久化的内存恢复的内存的过程称为对象反序列化。

1）    Serializable

类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化，并抛出异常

Exception in thread "main" java.io.NotSerializableException: cn.sxt05.serializable.Student

     at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)

     at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)

     at cn.sxt05.serializable.Test01.main(Test01.java:22)

 Serializable接口没有方法或字段，仅用于标识可序列化的语义

public class Student implements Serializable{

// 。。。

2）  序列化对象

ObjectOutputStream继承于OutputStream，专门用于把对象序列化到本地。提供了

writeXXX

writeObject() 用于写入一个对象

public static void main(String[] args) throws IOException {

       

        Studentstu = new Student("001", "大狗", 20, Gender.男);

       

        /**

         *  方案1:取stu所有的属性,通过特定的字符串（-），把各个属性值连接起来

         *  001-大狗-20-男

         */

       

        File file = new File("d:\javatest\l.txt");

        FileOutputStream out = new FileOutputStream(file);

        ObjectOutputStream oos = new ObjectOutputStream(out);

       

        oos.writeObject(stu);

       

        oos.close();

        out.close();

    }

3）    反序列化对象

ObjectInputStream继承于InputStream ，专门用于把本地持久化内容反序列化到内存，提供了

readXXX

readObject() 用于读取一个序列化内容并返回一个对象。

public static void main(String[] args) throws IOException, ClassNotFoundException {

        

         File file = new File("d:\javatest\l.txt");

        

        

         FileInputStream in = new FileInputStream(file);

         ObjectInputStreamois = newObjectInputStream(in);

        

         Student student = (Student) ois.readObject();

         System.out.println(student.getId());

         System.out.println(student.getName());

         System.out.println(student.getAge());

         System.out.println(student.getGender());

        

         ois.close();

         in.close();

     }

4） 序列化版本

当序列化完成后，后期升级程序中的类(Student),此时再反序列化时会出现异常。

Exception in thread "main" java.io.InvalidClassException: cn.sxt05.serializable.Student; local class incompatible: stream classdesc serialVersionUID = -6288733824962181189, local class serialVersionUID = 1690603786167234505

     at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:687)

     at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1876)

     at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1745)

     at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2033)

     at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1567)

     at java.io.ObjectInputStream.readObject(ObjectInputStream.java:427)

     at cn.sxt05.serializable.Test02.main(Test02.java:16)

异常原因:序列化流的serialVersionUID和升级后类的版本不匹配。

解决方案:给Student类加序列化版本号，有两种方式

 

default serial version ID 生成默认的serial version ID 一般值都是1L。

generatedserialversion ID根据当前类的属性、方法生成一个唯一ID。

public class Student implements Serializable {

 

     private static final long serialVersionUID = -1003763572517930507L;

5）   transient

开发过程中，如果想忽略某些字段不让其序列化时，可以使用transient修饰。

public class Student implements Serializable {

 

    private static final long serialVersionUID = 7222966748321328300L;

 

    private String id;

    private transient String name;

    private transient int age;

    private Gender gender;

    private String phone;

11.  DataInputStream/DataOutputStream

DataOutputStream 继承OutputStream，专门用于把基本java数据类型写入输出流。提供了writeXXX 写入基本java数据类型。

DataInputStream继承于InputStream，允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。

DataInputStream/DataOutputStream特别适合读取/写入在网络传输过程中的数据流。

写入基本java数据类型

public static void main(String[] args) throws IOException {

        

         File file = new File("d:\javatest\n.txt");

         FileOutputStream out= new FileOutputStream(file);

         DataOutputStreamdos = newDataOutputStream(out);

        

         dos.writeInt(10);

         dos.writeUTF("hello中国");

        

         dos.close();

         out.close();

        

         System.out.println("写入完成");

        

     }

读取基本java数据类型

public static void main(String[] args) throws IOException {

       

        File file = new File("d:\javatest\n.txt");

        FileInputStream in = new FileInputStream(file);

        DataInputStream dis = new DataInputStream(in);

       

        inta = dis.readInt();

        String str = dis.readUTF();

       

        System.out.println(a);

        System.out.println(str);

       

    }

注意:

以什么顺序写入基本java数据类型，就以什么顺序读取基本java数据类型。