程序博客网 > 广联达算量软件怎么用

《Java编程思想第四版》笔记---18章（3） I/O 流式部分--字符流字节流

来源：互联网 发布：广联达算量软件怎么用 编辑：程序博客网 时间：2024/05/21 19:45

Java.IO流类库

在java.io包中有四个基本类：InputStream、OutputStream及Reader、Writer类，它们分别处理字节流和字符流：



JDK1.4版本开始引入了新I/O类库，它位于java.nio包中，新I/O类库利用通道和缓冲区等来提高I/O操作的效率。

在java.io包中， java.io.InputStream 表示字节输入流， java.io.OutputStream表示字节输出流，处于java.io包最顶层。这两个类均为抽象类，也就是说它们不能被实例化，必须生成子类之后才能实现一定的功能。


二. io流的具体分类

（一）按I/O类型来总体分类：

1. Memory

1）从/向内存数组读写数据: CharArrayReader、 CharArrayWriter、ByteArrayInputStream、ByteArrayOutputStream

2）从/向内存字符串读写数据 StringReader、StringWriter、StringBufferInputStream

2.Pipe管道

实现管道的输入和输出（进程间通信）: PipedReader、PipedWriter、PipedInputStream、PipedOutputStream

3.File 文件流

对文件进行读、写操作 ：FileReader、FileWriter、FileInputStream、FileOutputStream

4. ObjectSerialization 

对象输入、输出 ：ObjectInputStream、ObjectOutputStream

5.DataConversion数据流 

按基本数据类型读、写（处理的数据是Java的基本类型（如布尔型，字节，整数和浮点数））：DataInputStream、DataOutputStream

6.Printing 

包含方便的打印方法 ：PrintWriter、PrintStream

7.Buffering缓冲  

在读入或写出时，对数据进行缓存，以减少I/O的次数：BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream

8.Filtering 滤流

在数据进行读或写时进行过滤：FilterReader、FilterWriter、FilterInputStream、FilterOutputStream过

9.Concatenation合并输入 

把多个输入流连接成一个输入流 ：SequenceInputStream

10.Counting计数  

在读入数据时对行记数 ：LineNumberReader、LineNumberInputStream

11.Peeking Ahead 

通过缓存机制，进行预读 ：PushbackReader、PushbackInputStream

12.转换流

字节流转字符流：InputStreamReader、OutputStreamWriter


（二）按数据来源（去向）分类：

1、File（文件）： FileInputStream, FileOutputStream, FileReader, FileWriter

2、byte[]：ByteArrayInputStream, ByteArrayOutputStream

3、Char[]: CharArrayReader, CharArrayWriter

4、String: StringBufferInputStream, StringReader, StringWriter

5、网络数据流：InputStream, OutputStream, Reader, Writer


三、字节流InputStream/OutputStream

1. InputStream抽象类

InputStream 为字节输入流，它本身为一个抽象类，必须依靠其子类实现各种功能，此抽象类是表示字节输入流的所有类的超类。 继承自InputStream  的流都是向程序中输入数据的，且数据单位为字节（8bit）；

InputStream是输入字节数据用的类，所以InputStream类提供了3种重载的read方法.


Inputstream类中的常用方法：

（1） public abstract int read( )：读取一个byte的数据，返回值是高位补0的int类型值。若返回值=-1说明没有读取到任何字节读取工作结束。

（2） public int read(byte b[ ])：读取b.length个字节的数据放到b数组中。返回值是读取的字节数。该方法实际上是调用下一个方法实现的

（3） public int read(byte b[ ], int off, int len)：从输入流中最多读取len个字节的数据，存放到偏移量为off的b数组中。

（4） public int available( )：返回输入流中可以读取的字节数。注意：若输入阻塞，当前线程将被挂起，如果InputStream对象调用这个方法的话，它只会返回0，这个方法必须由继承InputStream类的子类对象调用才有用，

（5） public long skip(long n)：忽略输入流中的n个字节，返回值是实际忽略的字节数, 跳过一些字节来读取

（6） public int close( ) ：我们在使用完后，必须对我们打开的流进行关闭.

主要的子类：


1） FileInputStream把一个文件作为InputStream，实现对文件的读取操作

2） ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用

3） StringBufferInputStream：把一个String对象作为InputStream

4） PipedInputStream：实现了pipe的概念，主要在线程中使用

5） SequenceInputStream：把多个InputStream合并为一个InputStream


2．OutputStream抽象类

OutputStream提供了3个write方法来做数据的输出，这个是和InputStream是相对应的。

1. public void write(byte b[ ])：将参数b中的字节写到输出流。

2. public void write(byte b[ ], int off, int len) ：将参数b的从偏移量off开始的len个字节写到输出流。

3. public abstract void write(int b) ：先将int转换为byte类型，把低字节写入到输出流中。

4. public void flush( ) : 将数据缓冲区中数据全部输出，并清空缓冲区。

5. public void close( ) : 关闭输出流并释放与流相关的系统资源。

主要的子类：


1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中

2) FileOutputStream：把信息存入文件中

3) PipedOutputStream：实现了pipe的概念，主要在线程中使用

4) SequenceOutputStream：把多个OutStream合并为一个OutStream

流结束的判断：方法read()的返回值为-1时；readLine()的返回值为null时。


3. 文件输入流： FileInputStream类

FileInputStream可以使用read()方法一次读入一个字节，并以int类型返回，或者是使用read()方法时读入至一个byte数组，byte数组的元素有多少个，就读入多少个字节。在将整个文件读取完成或写入完毕的过程中，这么一个byte数组通常被当作缓冲区，因为这么一个byte数组通常扮演承接数据的中间角色。


作用：以文件作为数据输入源的数据流。或者说是打开文件，从文件读数据到内存的类。

使用方法(1)

File  fin=new File("d:/abc.txt");

FileInputStream in=new FileInputStream( fin);

使用方法(2)

         FileInputStream  in=new  FileInputStream(“d: /abc.txt”);

程序举例：

将InputFromFile.java的程序的内容显示在显示器上


import java.io.IOException;
import java.io.FileInputStream;
public class TestFile {
    public static void main(String args[]) throws IOException {
        try {
            FileInputStream rf = new FileInputStream("InputFromFile.java");
            int n = 512;
            byte buffer[] = new byte[n];
            while ((rf.read(buffer, 0, n) != -1) && (n > 0)) {
                System.out.println(new String(buffer));
            }
            System.out.println();
            rf.close();
        } catch (IOException IOe) {
            System.out.println(IOe.toString());
        }
    }

}  


4.文件输出流:FileOutputStream类

作用：用来处理以文件作为数据输出目的数据流；或者说是从内存区读数据入文件

FileOutputStream类用来处理以文件作为数据输出目的数据流；一个表示文件名的字符串，也可以是File或FileDescriptor对象。

创建一个文件流对象有两种方法：

方式1：

File   f=new  File (“d:/myjava/write.txt ");

FileOutputStream  out= new FileOutputStream (f);

方式2：

         FileOutputStream out=new FileOutputStream(“d:/myjava/write.txt ");

方式3：构造函数将 FileDescriptor()对象作为其参数。

FileDescriptor() fd=new FileDescriptor();

FileOutputStream f2=new FileOutputStream(fd);

方式4：构造函数将文件名作为其第一参数，将布尔值作为第二参数。

         FileOutputStream f=new FileOutputStream("d:/abc.txt",true);

注意：

（1）文件中写数据时，若文件已经存在，则覆盖存在的文件；

（2）读/写操作结束时，应调用close方法关闭流。

程序举例：使用键盘输入一段文章，将文章保存在文件write.txt中


import java.io.IOException;
import java.io.FileOutputStream;
public class TestFile {
    public static void main(String args[]) throws IOException {
        try {
            System.out.println("please Input from      Keyboard");
            int count, n = 512;
            byte buffer[] = new byte[n];
            count = System.in.read(buffer);
            FileOutputStream wf = new FileOutputStream("d:/myjava/write.txt");
            wf.write(buffer, 0, count);
            wf.close(); // 当流写操作结束时，调用close方法关闭流。
            System.out.println("Save to the write.txt");
        } catch (IOException IOe) {
            System.out.println("File Write Error!");
        }
    }

}  


5. FileInputStream和FileOutputStream的应用

利用程序将文件file1.txt 拷贝到file2.txt中。

import java.io.File;
import java.io.IOException;
import java.io.FileOutputStream;
import java.io.FileInputStream;
public class TestFile {
    public static void main(String args[]) throws IOException {
        try {
            File inFile = new File("copy.java");
            File outFile = new File("copy2.java");
            FileInputStream finS = new FileInputStream(inFile);
            FileOutputStream foutS = new FileOutputStream(outFile);
            int c;
            while ((c = finS.read()) != -1) {
                foutS.write(c);
            }
            finS.close();
            foutS.close();
        } catch (IOException e) {
            System.err.println("FileStreamsTest: " + e);
        }
    }

}  


6. 缓冲输入输出流 BufferedInputStream/ BufferedOutputStream


      计算机访问外部设备非常耗时。访问外存的频率越高，造成CPU闲置的概率就越大。为了减少访问外存的次数，应该在一次对外设的访问中，读写更多的数据。为此，除了程序和流节点间交换数据必需的读写机制外，还应该增加缓冲机制。缓冲流就是每一个数据流分配一个缓冲区，一个缓冲区就是一个临时存储数据的内存。这样可以减少访问硬盘的次数,提高传输效率。

BufferedInputStream:当向缓冲流写入数据时候，数据先写到缓冲区，待缓冲区写满后，系统一次性将数据发送给输出设备。

BufferedOutputStream :当从向缓冲流读取数据时候，系统先从缓冲区读出数据，待缓冲区为空时，系统再从输入设备读取数据到缓冲区。

1）将文件读入内存：

将BufferedInputStream与FileInputStream相接

FileInputStream in=new  FileInputStream( “file1.txt ” );

BufferedInputStream bin=new  BufferedInputStream( in);

2）将内存写入文件：

将BufferedOutputStream与 FileOutputStream相接

FileOutputStreamout=new FileOutputStream(“file1.txt”);

BufferedOutputStream  bin=new BufferedOutputStream(out);

3）键盘输入流读到内存

将BufferedReader与标准的数据流相接

InputStreamReader sin=new InputStreamReader (System.in) ；

BufferedReader bin=new  BufferedReader(sin);


import java.io.*;
public class ReadWriteToFile {
    public static void main(String args[]) throws IOException {
        InputStreamReader sin = new InputStreamReader(System.in);
        BufferedReader bin = new BufferedReader(sin);
        FileWriter out = new FileWriter("myfile.txt");
        BufferedWriter bout = new BufferedWriter(out);
        String s;
        while ((s = bin.readLine()).length() > 0) {
            bout.write(s, 0, s.length());
        }
    }

}  

程序说明：

从键盘读入字符，并写入到文件中BufferedReader类的方法：String readLine()

作用：读一行字符串，以回车符为结束。

BufferedWriter类的方法：bout.write(String s,offset,len)

作用：从缓冲区将字符串s从offset开始，len长度的字符串写到某处。

四、 字符流Writer/Reader

Java中字符是采用Unicode标准，一个字符是16位，即一个字符使用两个字节来表示。为此，JAVA中引入了处理字符的流。

字符流的原理

        Java支持字符流和字节流，字符流本身就是一种特殊的字节流， 之所以要专门有字符流，是因为Java中有大量对于字符的操作，所以专门有字符流。字节流和字符流的转换是以InputStreamReader和 OutputStreamWriter为媒介的，InputStreamReader可以将一个字节流中的字节解码成字 符，OutputStreamWriter可以将写入的字符编码成自节后写入一个字节流。

InputStreamReader中的解码字节，是由StreamDecoder完成的，StreamDecoder是Reader的实现类，定义在InputStreamReader的开头：

  1. public class InputStreamReader extends Reader {
  2.     private final StreamDecoder sd;

同样，OutputStreadWriter中的编码字节，是由StreamEncoder完成的，StreamEncoder是Writer的实现类，定义在OutputStreamWriter的开头：

  1. public class OutputStreamWriter extends Writer {
  2.     private final StreamEncoder se;

假如不对StreamDecoder和StreamEncoder指定Charset编码格式，将使用本地环境中的默认字符集，例如中文环境中将使用GBK编码。

InputStreamReader有两个主要的构造函数：

1、InputStreamReader(InputStream in)

2、InputStreamReader(InputStream in, String charsetName)

OutputStreamWriter也有两个主要的构造函数：

1、OutputStreamWriter(OutputStream out)

2、OutputStreamWriter(OutputStream out, String charsetName)

从构造函数就可以看出，字符流是利用字节流实现的。InputStreamReader和OutputStreamWriter的两个构造函数的区别在于，一个是使用的默认字符集，一个可以指定字符集名称。其实FileReader和FileWriter可以看一下源码，很简单，只有构造函数，里面都是分别根据传入的文件绝对路径或者传入的File实例，new出FileInputStream和FileOutputStream，在调用InputStreamReader和OutputStreamWriter的构造方法。这么做，帮助开发者省去了实例化FileInputStream和FileOutputStream的过程，让开发者可以直接以fileName或file作为构造函数的参数。

1. Reader抽象类

用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。


1) FileReader :与FileInputStream对应

主要用来读取字符文件，使用缺省的字符编码，有三种构造函数：

(1) 将文件名作为字符串 ：FileReader f=new FileReader(“c:/temp.txt”);

(2) 构造函数将File对象作为其参数。

File f=new file(“c:/temp.txt”);

FileReader f1=new FileReader(f);

(3) 构造函数将FileDescriptor对象作为参数

FileDescriptor() fd=new FileDescriptor()

FileReader f2=new FileReader(fd);

2) CharArrayReader：与ByteArrayInputStream对应

3) StringReader : 与StringBufferInputStream对应

4) InputStreamReader

   从输入流读取字节，在将它们转换成字符:Public inputstreamReader(inputstream is);

5) FilterReader: 允许过滤字符流

   protected filterReader(Reader r);

6) BufferReader :接受Reader对象作为参数，并对其添加字符缓冲器，使用readline()方法可以读取一行。

   Public BufferReader(Reader r);


Reader类中有这些方法：

方    法作    用abstract void close()关闭该流并释放与之关联的所有资源void mark(int readAheadLimit)标记流中的当前位置boolean markSupported()判断此流是否支持mark()操作int read()从文件中读取单个字符int read(char[] cbuf)从文件中读取字符到cbufabstract int read(char[] cbuf, int off, int len)将文件中的字符读入cbuf数组，从off位置开始，读取len个字符。三个read方法在字符可用、发生I/O异常或者已经到达流的末尾前，此方法会一直阻塞int read(CharBuffer target)试图将文件中的字符读入指定的字符缓冲区boolean ready()判断是否准备读取此流voi reset()重置该流long skip(long n)跳过n个字符
来源： http://www.cnblogs.com/szlbm/p/5513124.html


2. Writer抽象类

写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。 其子类如下：


1） FileWrite: 与FileOutputStream对应

将字符类型数据写入文件，使用缺省字符编码和缓冲器大小。

Public FileWrite(file f);

2)  chararrayWrite:与ByteArrayOutputStream对应 ,将字符缓冲器用作输出。

         Public CharArrayWrite();

3) PrintWrite:生成格式化输出

         public PrintWriter(outputstream os);

4) filterWriter:用于写入过滤字符流

         protected FilterWriter(Writer w);

5) PipedWriter：与PipedOutputStream对应

6) StringWriter：无与之对应的以字节为导向的stream


主要方法：

方    法作    用Writer append(char c)将制定字符添加到此writerWriter append(CharSequence csq)将制定字符序列添加到此writerWriter append(CharSequence csq, int start, int end)将指定字符序列的子序列添加到此writer.Appendableabstract void close()关闭此流，但要先flush()它abstract void flush()刷新该流的缓冲void write(char[] cbuf)将cbuf中的内容写入文件abstract void write(char[] cbuf, int off, int len)将字符数组cbuf中从off开始的len个字节写入文件void write(int c)写入单个字符到文件中void write(String str)写入字符串到文件中void write(String str, int off, int len)写入str从off位置开始的len个字符到文件中

3 .InputStream与Reader差别 OutputStream与Writer差别

（1）区别一：字符流编码转换问题

InputStream和OutputStream类处理的是字节流，数据流中的最小单位是字节(8个bit)

Reader与Writer处理的是字符流，在处理字符流时涉及了字符编码的转换问题

  1. import java.io.*;
  2. public class EncodeTest {
  3.     private static void readBuff(byte[] buff) throws IOException {
  4.         ByteArrayInputStream in = new ByteArrayInputStream(buff);
  5.         int data;
  6.         while ((data = in.read()) != -1)
  7.             System.out.print(data + "  ");
  8.         System.out.println();
  9.         in.close();
  10.     }
  11.     public static void main(String args[]) throws IOException {
  12.         System.out.println("内存中采用unicode字符编码：");
  13.         char c = '好';
  14.         int lowBit = c & 0xFF;
  15.         int highBit = (c & 0xFF00) >> 8;
  16.         System.out.println("" + lowBit + "   " + highBit);
  17.         String s = "好";
  18.         System.out.println("本地操作系统默认字符编码：");
  19.         readBuff(s.getBytes());
  20.         System.out.println("采用GBK字符编码：");
  21.         readBuff(s.getBytes("GBK"));
  22.         System.out.println("采用UTF-8字符编码：");
  23.         readBuff(s.getBytes("UTF-8"));
  24.     }
  25. }


Reader类能够将输入流中采用其他编码类型的字符转换为Unicode字符，然后在内存中为其分配内存

Writer类能够将内存中的Unicode字符转换为其他编码类型的字符，再写到输出流中。

（2）区别二：缓存问题

  1. public static void main(String[] args) throws Exception
  2. {
  3.     File file = new File("D:/writer.txt");
  4.     Writer out = new FileWriter(file);
  5.     // 声明一个String类型对象
  6.     String str = "Hello World!!!";
  7.     out.write(str);
  8.     out.close();
  9.         
  10.     // 读文件操作
  11.     Reader in = new FileReader(file);
  12.     // 开辟一个空间用于接收文件读进来的数据
  13.     char c0[] = new char[1024];
  14.     int i = 0;
  15.     // 将c0的引用传递到read()方法之中，同时此方法返回读入数据的个数
  16.     i = in.read(c0);
  17.     in.close();
  18.         
  19.     if (-1 == i)
  20.     {
  21.         System.out.println("文件中无数据");
  22.     }
  23.     else
  24.     {
  25.         System.out.println(new String(c0, 0, i));
  26.     }
  27. }

第8行"out.close()"注释掉可以看一下效果，"writer.txt"一定是空的，控制台上输出的是"文件中无数据"，说明一下原因。

字符流和字节流非常相似，但也有区别，从网上找了一张图：


      从图上看，字符流和字节流最大的区别在于，字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的，而字符流操作时使用了缓冲区，通过缓冲区再操作文件。这也解释了上面程序的那个问题，为什么不对资源进行close()就无法写入文件的原因。因为在关闭字符流时会强制性地将缓冲区中的内容进行输出，但是如果没有关闭，缓冲区中的内容是无法输出的。

      什么是缓冲区？简单理解，缓冲区就是一块特殊的内存区域。为什么要使用缓冲区？因为如果一个程序频繁操作一个资源（文件或数据库），则性能会很低，为了提升性能，就可以将一部分数据暂时读入到内存的一块区域之中，以后直接从此区域读取数据即可，因为读取内存的速度要快于读取磁盘中文件内容的速度。

在字符流的操作中，所有的字符都是在内存中形成的，在输出前会将所有的内容暂时保存在内存之中，所以使用了缓冲区。

如果不想在关闭时再输出字符流的内容也行，使用Writer的flush()方法就可以了。


4、FileReader和FileWriter

FileReader类创建了一个可以读取文件内容的Reader类，最常用的构造方法是：

1、FileReader(String fileName)

2、FileReader(File file)

FileWriter创建了一个可以写文件的Writer类，最常用的构造方法是：

1、FileWriter(String fileName)

2、FileWriter(String fileName, boolean append)

3、FileWriter(File file)

其中第二个构造方法，如果append为true，那么输出是追加到文件结尾的。FileWriter类的创建不依赖文件是否存在，在创建文件之前，FileWriter将在创建对象时打开它来作为输出。如果试图打开一个只读文件，那么将引发一个IOException。看一下FileWriter和FileReader的使用，现在D盘目录下没有"writer.txt"：

  1. public static void main(String[] args) throws Exception{
  2.     File file = new File("D:/writer.txt");
  3.     Writer out = new FileWriter(file);
  4.     // 声明一个String类型对象
  5.     String str = "Hello World!!!";
  6.     out.write(str);
  7.     out.close();
  8.         
  9.     // 读文件操作
  10.     Reader in = new FileReader(file);
  11.     // 开辟一个空间用于接收文件读进来的数据
  12.     char c0[] = new char[1024];
  13.     int i = 0;
  14.     // 将c0的引用传递到read()方法之中，同时此方法返回读入数据的个数
  15.     i = in.read(c0);
  16.     in.close();
  17.         
  18.     if (-1 == i) {
  19.         System.out.println("文件中无数据");
  20.     }else{
  21.         System.out.println(new String(c0, 0, i));
  22.     }
  23. }

利用FileWriter和FileReader进行了一次的读写操作，先看一下D盘下是否有"writer.txt"，假如有"writer.txt"那"writer.txt"中又是什么：


看来利用FileWriter写入一个内存中的字符串到文件中是成功了，那么利用利用FileReader读入文件中的内容到内存呢，看一下运行结果

  1. Hello World!!!

打印结果和文件中的内容一致，说明FileReader的操作也成功。

这就是FileWriter和FileReader的使用，和FileOutputStream和FileInputStream的使用差不多，不过实际操作中一般不会用FileWriter和FileReader。


5、BufferedWriter、BufferedReader

为了达到最高的效率，避免频繁地进行字符与字节之间的相互转换，最好不要直接使用FileReader和FileWriter这两个类进行读写，而 使用BufferedWriter包装OutputStreamWriter，使用BufferedReader包装 InputStreamReader。同样，在D盘下没有"buffered"这个文件，代码示例为：

  1. public static void main(String[] args) throws Exception{
  2.     File file = new File("D:/buffered.txt");
  3.     Writer writer = new FileWriter(file);
  4.     BufferedWriter bw = new BufferedWriter(writer);
  5.     bw.write("1234\n");
  6.     bw.write("2345\n");
  7.     bw.write("3456\n");
  8.     bw.write("\n");
  9.     bw.write("4567\n");
  10.     bw.close();
  11.     writer.close();
  12.         
  13.     if (file.exists() && file.getName().endsWith(".txt")){
  14.         Reader reader = new FileReader(file);
  15.         BufferedReader br = new BufferedReader(reader);
  16.         String str = null;
  17.         while ((str = br.readLine())!= null){
  18.             System.out.println(str);
  19.         }
  20.         reader.close();
  21.         br.close();
  22.     }    
  23. }

运行一下，首先D盘下多出了"buffered.txt"这个文件，文件中的内容为：


然后看一下控制台的输出结果：

  1. 1234
  2. 2345
  3. 3456
  5. 4567

没什么问题，输出了文件中的内容。注意两点：

1、利用BufferedWriter进行写操作，写入的内容会放在缓冲区内，直 到遇到close()、flush()的时候才会将内容一次性写入文件。另外注意close()的顺序，一定要先关闭BufferedWriter，再关 闭Writer，不可以倒过来，因为BufferedWriter的写操作是通过Writer的write方法写的，如果先关闭Writer的话，就无法 将缓冲区内的数据写入文件了，会抛出异常

2、利用BufferedReader进行读操作，不可以用父类Reader指向它，因为readLine()这个方法是BufferedReader独有的，readLine()的作用是逐行读取文件中的内容

0 0
广联达算量软件怎么用 广联达算量软件怎么用
原创粉丝点击
热门IT博客
乌龟之间怎么交流 知乎乌龟之间怎么交流 知乎
淘宝紫砂壶谁家的好淘宝紫砂壶谁家的好
淘宝的周期怎么算
淘宝 惠惠购物助手
股票信息软件
太阳知乎
百度站长seo
log4j 输出json格式
百度算法之轮流展现法
java如何校验时间格式
晨风qq机器人php源码
硫酸钙网络地板
中国美国耕地面积知乎
淘宝旺旺申请
制药工程 知乎
会计进销存软件
超宏资金博弈指标源码
ubuntu win10引导修复
淘宝号怎么升级为钻号
sybase查看数据库空间
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 小油菜炖豆腐 蒜蓉油菜的做法 男性长期吃油菜花粉 油菜的家常做法 蘑菇油菜的做法 油菜的做法大全 香菇油菜的做法大全 呛油菜的做法 蘑菇油菜怎么炒好吃 烧油菜怎么做 家常油菜的做法 油菜粉丝的做法 炒小油菜的做法 虾米油菜的做法 油菜豆腐的做法大全 油菜做法大全家常 小油菜怎么吃 油菜炖豆腐的做法 油菜虾米的做法 爆炒油菜的做法 小油菜的功效与作用 耗油油菜的做法 油菜怎么凉拌好吃 蒜蓉小油菜做法 油菜怎么炒好吃 油菜炒鸡蛋的做法 怎么炒油菜好吃 油菜大虾的做法 油菜怎么做好吃家常菜 小油菜怎么做 油菜的做法大全家常菜 油菜炖豆腐家常做法 油菜炒肉的做法 小油菜怎么炒好吃 烧油菜的家常做法 红烧油菜的做法 小油菜的做法大全家常 清炒油菜的做法 油菜的做法大全家常 香菇油菜做法步骤 豆腐油菜的做法大全

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里