精华内容
下载资源
问答
  • 读写数据库Image类型数据

    千次阅读 2016-02-27 19:09:00
    读写数据库Image类型数据 读写数据库Image类型数据


    数据库的Image字段保存的是字节,所以写入数据库Image字段和从数据库Image字段读取的内容都应该为字节.

        1、数据库Image字段读写文件

        写文件:写文件的过程为将文件以流文件形式打开并将内容读取到一个byte数组,然后将此byte数组写入数据库的Image字段。

        源码:

      FileInfo finfo=new FileInfo("文件名");  //绝对路径
    
          if(finfo.Exists)
          {
    
            SqlConnection conn=new SqlConnection("连接字符串");
    
            SqlCommand InsertCommand=new SqlCommand();
    
            InsertCommand.Connection=conn;
    
            InsertCommand.CommandText="Insert into 表名(Image字段名) values(@Content)";
    
            InsertCommand.Parameters.Add("@Content",SqlDbType.Image,(int)finfo.Length,"Image字段名");   //注意,此处参数Size为写入的字节数
    
            //读取文件内容,写入byte数组
    
            byte[] content=new byte[finfo.Length];
    
            FileStream stream=finfo.OpenRead();
    
            stream.Read(content,0,content.Length);
    
            stream.Close();
    
            InsertCommand.Parameters["@Content"].Value=content;  //为参数赋值
    
            try
    
            {
    
                conn.Open();
    
                InsertCommand.ExcuteNonQuery();
    
            }
    
            finally
    
            {
    
                conn.Close();
    
            }
    
        }


        

        读文件:读文件的过程为从数据库的Image字段读取内容保存到byte数组,然后将此byte数组以文件流形式写入文件。

        

        源码:

     byte[] content;
    
        SqlConnetion conn=new SqlConnection("连接字符串");
    
        SqlDataAdapter da=new SqlDataAdapter("Select Image字段名 from 表名",conn);
    
        DataSet ds=new DataSet();
    
        da.Fill(da,"word");
    
        DataRow dr=ds.Tables["word"].Rows[0];    //将读取的第一行内容保存到dr
    
        
    
        content=(byte[])dr["Image字段名"];
    
        int ArraySize=content.GetUpperBound(0);
    
        FileStream stream=new FileStream("文件名",FileMode.OpenOrCreate,FileAccess.Write);
    
        stream.Write(content,0,ArraySize);
    
        stream.Close();


        

        2、数据库Image字段读写图片

        绑定到控件的方式:

         通过将Image字段绑定到PictureBox实现。文件中我提供了一个实例,要正常运行需要在Northwind中添加数据库表Employees, 数据库表的结构为EmployeeID Int(4) 自动增长,FirstName nvarchar(10),LastName nvarchar (20),Photo image(16) null。

        直接用SqlCommand实现:

        其实把握住Image 字段存的是byte类型数据,用SqlCommand实现添加、修改就很简单了,跟文本的区别就是在读出的时候需要将byte类型数据转化为Image图 片,在写入时需要将Image图片以流的形式转为为byte数组,然后再将byte数组保存到Image字段。

        实例:

           comm = "Insert into MyEmployees(FirstName,LastName,Photo) values(@FName,@LName,@Photo)";
    
               SqlCommand command=new SqlCommand(comm);
    
               command.Connection = conn;
    
               //创建Parameter
    
               command.Parameters.Add("@FName",SqlDbType.NVarChar);
    
               command.Parameters[0].Value = textBox1.Text;
    
               command.Parameters.Add("@LName", SqlDbType.NVarChar);
    
               command.Parameters[1].Value = textBox2.Text;
    
               command.Parameters.Add("@Photo",SqlDbType.Image);
    
               command.Parameters[2].Value = imgByte;

        其中imgByte为Byte数组,通过FileStream的Read填充的byte数据。



    展开全文
  • 在c++中常常使用的读写函数有:ofstream,ifstream,fstream, 可以参见:http://blog.csdn.net/kingstar158/article/details/6859379/,... 在C++中,有一stream类,所有的I/O都以这”类为基础的,包...

    在c++中常常使用的读写函数有:ofstream,ifstream,fstream,

    可以参见:http://blog.csdn.net/kingstar158/article/details/6859379/http://blog.csdn.net/augusdi/article/details/8865378

    在C++中,有一个stream类,所有的I/O都以这个“流”类为基础的,包括要认识的文件I/O,stream这个类有两个重要的运算符:
    1、插入器(<<)  向流输出数据。比如说系统有一个默认的标准输出流(cout),一般情况下就是指的显示器,所以,cout<<"Write Stdout"<<'\n';就表示把字符串"Write Stdout"和换行字符('\n')输出到标准输出流。
    2、析取器(>>)  从流中输入数据。比如说系统有一个默认的标准输入流(cin),一般情况下就是指的键盘,所以,cin>>x;就表示从标准输入流中读取一个指定类型(即变量x的类型)的数据。
      在C++中,对文件的操作是通过stream的子类fstream(file stream)来实现的,要用这种方式操作文件,须加入头文件fstream。

    一、打开文件  

    在fstream类中,有一个成员函数open(),就是用来打开文件的,其原型是:
    void open(const char* filename,int mode,int access);
    参数:
    filename:要打开的文件名
    mode:要打开文件的方式
    access:打开文件的属性  //基本很少用到

    打开文件的方式在类iOS(是所有流式I/O类的基类)中定义,常用的值如下:

    ios::in 为输入(读)而打开文件
    ios::out 为输出(写)而打开文件
    ios::ate 初始位置:文件尾
    ios::app 所有输出附加在文件末尾
    ios::trunc 如果文件已存在则先删除该文件
    ios::binary 二进制方式

    可以用“或”把以上属性连接起来,如ios::out|ios::binary

    打开文件的属性同样在ios类中也有定义:

    0 普通文件,打开操作
    1 只读文件
    2 隐含文件
    4 系统文件

    对于文件的属性也可以使用“或”运算和“+”进行组合使用。

    二、关闭文件  

    打开的文件使用完成后一定要关闭,fstream提供了成员函数close()来完成此操作,如:file1.close();就把file1相连的文件关闭。

     

    三、读写文件  

    读写的文件分为文本文件和二进制文件,对于文本文件的读取比较简单,用插入器和析取即可,而对于二进制的读取就要复杂些。

     

    3.1文本文件的读写

    #include <iostream>
    #include <fstream>
    using namespace std;
    
    int main() 
    {
    	ofstream out("F://IM_VIDEO//out.txt");
    //	ifstream in("F://IM_VIDEO//in.txt");
    	if (out.is_open())
    	{
    		out << "This is a line.\n";
    		out << "This is another line.\n";
    		out.close();
    	}
    	return 0;
    }

    运行后发现,在相应目录下生成了txt文件out.txt,里面添加了两句话:this is a line. This is another line.

    #include <iostream>
    #include <fstream>
    using namespace std;
    //读取out.txt文件,并把其内容显示到屏幕中
    int main() 
    {
    	char buffer[256];
    	ifstream in("F://IM_VIDEO//out.txt");
    	if (!in.is_open())
    	{
    		cout << "Error opening file"; exit(1);
    	}
    	while (!in.eof())
    	{
    		in.getline(buffer, 100);
    		cout << buffer << endl;
    	}
    	return 0;
    }

    除了例子中的eof,它是ifstream 从类 ios 中继承过来的成员函数。另外还有状态标志符的验证(Verification of state flags)

    bad()
    如果在读写过程中出错,返回 true 。例如:当我们要对一个不是打开为写状态的文件进行写入时,或者我们要写入的设备没有剩余空间的时候。
    fail()
    除了与bad() 同样的情况下会返回 true 以外,加上格式错误时也返回true ,例如当想要读入一个整数,而获得了一个字母的时候。
    eof()
    如果读文件到达文件末尾,返回true。
    good()
    这是最通用的:如果调用以上任何一个函数返回true 的话,此函数返回 false 。

    获得和设置流指针(get and put stream pointers):
    所有输入/输出流对象(i/o streams objects)都有至少一个流指针:
    ifstream, 类似istream, 有一个被称为get pointer的指针,指向下一个将被读取的元素。
    ofstream, 类似 ostream, 有一个指针 put pointer ,指向写入下一个元素的位置。
    fstream, 类似 iostream, 同时继承了get 和 put
    可以通过使用成员函数:tellg() 和 tellp()来读出或配置这些指向流中读写位置的流指针
    tellg() 和 tellp()

    这两个成员函数不用传入参数,返回pos_type 类型的值(根据ANSI-C++ 标准) ,就是一个整数,代表当前get 流指针的位置 (用tellg) 或 put 流指针的位置(用tellp).
    seekg() 和seekp()
    这对函数分别用来改变流指针get 和put的位置。两个函数都被重载为两种不同的原型:
    seekg ( pos_type position );
    seekp ( pos_type position );
    使用这个原型,流指针被改变为指向从文件开始计算的一个绝对位置。要求传入的参数类型与函数 tellg 和tellp 的返回值类型相同。
    seekg ( off_type offset, seekdir direction );
    seekp ( off_type offset, seekdir direction );

    #include <iostream>
    #include <fstream>
    using namespace std;
    
    const char * filename = "F://IM_VIDEO//out.txt";
    //获取文件字节数
    int main() {
    	long l, m;
    	ifstream in(filename, ios::in | ios::binary);
    	l = in.tellg();
    	in.seekg(0, ios::end);
    	m = in.tellg();
    	in.close();
    	cout << "size of  " << filename << " is " << (m - 1) << " bytes.\n" << endl;
    	return 0;
    }

     

    3.2二进制文件的读写

    (1)put()
      put()函数向流写入一个字符,其原型是ofstream &put(char ch),使用也比较简单,如file1.put('c');就是向流写一个字符'c'。
    (2)get()
      get()函数比较灵活,有3种常用的重载形式:
      1.和put()对应的形式:ifstream &get(char &ch);功能是从流中读取一个字符,结果保存在引用ch中,如果到文件尾,返回空字符。如file2.get(x);表示从文件中读取一个字符,并把读取的字符保存在x中。
      2.重载形式。原型是:int get();从流中返回一个字符,如果到达文件尾,返回EOF,如x=file2.get();和上例功能是一样的。
      3.ifstream &get(char *buf,int num,char delim='n');这种形式把字符读入由 buf 指向的数组,直到读入了 num 个字符或遇到了由 delim 指定的字符,如果没使用 delim 这个参数,将使用缺省值换行符'n'。例如:
      file2.get(str1,127,'A');//从文件中读取字符到字符串str1,当遇到字符'A'或读取了127个字符时终止。
    (3)读写数据块
      在二进制文件中,使用<< 和>>,以及函数(如getline)来操作符输入和输出数据。要读写二进制数据块,使用成员函数read()和write()成员函数,它们原型如下:
      read(unsigned char *buf,int num);
      write(const unsigned char *buf,int num);
      这里 buffer 是一块内存的地址,用来存储或读出数据。参数num是一个整数值,表示要从缓存(buffer)中读出或写入的字符数。read()从文件中读取 num 个字符到 buf 指向的缓存中,如果在还未读入 num 个字符时就到了文件尾,可以用成员函数 int gcount();来取得实际读取的字符数;而 write() 从buf 指向的缓存写 num 个字符到文件中,值得注意的是缓存的类型是 unsigned char *,有时可能需要类型转换。

    opencv读写txt文件:

    现使用opencv对图像Mat类型读写txt文件进行汇总~

    首先将一幅图像写入txt文件中(实例1):

    //#include <iterator>
    //#include <vector>
    #include<opencv2\opencv.hpp>  
    #include<core/core.hpp>    
    #include<highgui/highgui.hpp>     
    #include<cv.h>
    #include <iostream>
    #include <fstream>
    
    using namespace std;
    using namespace cv;
    /*
    * 功能 : 将 Mat 数据写入到 .txt 文件
    * 函数 : WriteData
    * 访问 : public
    * 返回 : -1:打开文件失败;0:写入数据成功;1:矩阵为空
    */
    int WriteData(string fileName, Mat& matData)
    {
    	int retVal = 0;
    	if (matData.empty())
    	{
    		cout << "矩阵为空" << endl;
    		retVal = 1;
    		return (retVal);
    	}
    
    	// 打开文件
    	ofstream outFile(fileName.c_str(), ios_base::out);	//按新建或覆盖方式写入
    	if (!outFile.is_open())
    	{
    		cout << "打开文件失败" << endl;
    		retVal = -1;
    		return (retVal);
    	}
    
    	// 写入数据
    	for (int i = 0; i < matData.rows; i++)
    	{
    		uchar* pixelPtr = matData.ptr<uchar>(i);            //获取矩阵每行首地址指针  
    		for (int j = 0; j < matData.cols*matData.channels(); j++)
    		{
    			int data = pixelPtr[j];
    			outFile << data<<"\t";
    		}
    		outFile << endl;
    	}
    	return (retVal);
    }
    
    int main(int argc, char* argv[])
    {
    	Mat scr = imread("F://IM_VIDEO//kobe.jpg");
    	WriteData("F://IM_VIDEO//kobe.txt", scr);
    }

    上面程序可以将图像像素写入到自己命名的txt文件中。

    如果txt数据量较大,可以使用matlab打开,命令为:

    data=importdata('data.txt') //matlab打开txt文件

    将txt中的数据写入Mat类型文件中,并保存为图片格式(实例2):

    #include<opencv2\opencv.hpp>  
    #include<core/core.hpp>    
    #include<highgui/highgui.hpp>     
    #include<cv.h>
    #include <iostream>
    #include <fstream>
    #include <string>
    using namespace std;
    using namespace cv;
    
    void getFromText(String nameStr, Mat &myMat, uchar *pCurrentFace)
    {
    	String nameFaceStr;
    	//nameFaceStr = nameStr + "kobe.txt";//the face file path
    	ifstream myFaceFile;
    	myFaceFile.open(nameFaceStr, ios::in);
    	int temp;
    	for (int r = 0; r < myMat.cols*myMat.rows*myMat.channels(); r++)
    	{
    		myFaceFile >> temp;
    		pCurrentFace[r] = (uchar)temp;
    	}
    
    	for (int i = 0; i < myMat.rows; i++)
    	{
    		uchar *pixelPtr = myMat.ptr<uchar>(i);
    		for (int j = 0; j < myMat.cols*myMat.channels(); j++)
    		{
    			pixelPtr[j] = pCurrentFace[i*myMat.cols*myMat.channels()+j];
    		}
    	}
    	myFaceFile.close();
    }
    
    int main(int argc, char* argv[])
    {
    	Mat scr = imread("F://IM_VIDEO//kobe.jpg");
    	imshow("kobe", scr);
        Mat TrainData = Mat::zeros(scr.rows, scr.cols, CV_32FC3);
    	imshow("juzhen", TrainData);
    	uchar *pCurrentFace = (uchar*)malloc(scr.rows * scr.cols * 3 * sizeof(uchar));
    	getFromText("F://IM_VIDEO//kobe.txt", TrainData, pCurrentFace);
    	imshow("xianshi", TrainData);
    	waitKey(0);
    }

     

    but,,,这个有问题,暂时没找到正确的办法,请赐教、、、

    参考:

    http://blog.csdn.net/ljh0600301217/article/details/8731190

    http://blog.csdn.net/bendanban/article/details/30306505?utm_source=tuicool&utm_medium=referral (MATLAB,c++)

    展开全文
  • 自己重写了一类继承自该MemoryStream类,并添加了对流写入short ,ushort,int,uint,long,ulong,float,double,bool,string等类型数据的写入和其在中读取出该数据类型的方法。 using UnityEngine; using System....

    1、主要是对MemoryStream.cs这个类的封装操作,自己重写了一个类继承自该MemoryStream类,并添加了对流写入short ,ushort,int,uint,long,ulong,float,double,bool,string等类型数据的写入和其在流中读取出该数据类型的方法。

    using UnityEngine;
    using System.Collections;
    using System.IO;
    using System;
    using System.Text;
    //数据转换
    public class MyMemoryStream :MemoryStream
    {
        public MyMemoryStream(byte[] buffer):base (buffer )
        {
    
        }
        public MyMemoryStream()
        {
    
        }
        #region Short
        /// <summary>
        /// 从流中读取一个short数据
        /// </summary>
        /// <returns></returns>
        public short  ReadShort()
        {
            byte[] arr = new byte[2];
            base.Read(arr, 0, 2);
            return BitConverter.ToInt16(arr, 0);
        }
        /// <summary>
        /// 把一个short数据写入流
        /// </summary>
        /// <param name="vaule"></param>
        public void WriteShort(short vaule)
        {
            byte[] arr = BitConverter.GetBytes (vaule);
            base.Write(arr, 0, arr.Length);
        }
        #endregion
        #region UShort
        /// <summary>
        /// 从流中读取一个short数据
        /// </summary>
        /// <returns></returns>
        public ushort ReadUShort()
        {
            byte[] arr = new byte[2];
            base.Read(arr, 0, 2);
            return BitConverter.ToUInt16(arr, 0);
        }
        /// <summary>
        /// 把一个short数据写入流
        /// </summary>
        /// <param name="vaule"></param>
        public void WriteUShort(ushort  vaule)
        {
            byte[] arr = BitConverter.GetBytes(vaule);
            base.Write(arr, 0, arr.Length);
        }
        #endregion
        #region Int
        /// <summary>
        /// 从流中读取一个short数据
        /// </summary>
        /// <returns></returns>
        public int  ReadInt()
        {
            byte[] arr = new byte[4];
            base.Read(arr, 0, 4);
            return BitConverter.ToInt32 (arr, 0);
        }
        /// <summary>
        /// 把一个short数据写入流
        /// </summary>
        /// <param name="vaule"></param>
        public void WriteInt(int  vaule)
        {
            byte[] arr = BitConverter.GetBytes(vaule);
            base.Write(arr, 0, arr.Length);
        }
        #endregion
        #region UInt
        /// <summary>
        /// 从流中读取一个short数据
        /// </summary>
        /// <returns></returns>
        public uint  ReadUInt()
        {
            byte[] arr = new byte[4];
            base.Read(arr, 0, 4);
            return BitConverter.ToUInt32(arr, 0);
        }
        /// <summary>
        /// 把一个short数据写入流
        /// </summary>
        /// <param name="vaule"></param>
        public void WriteUInt(uint  vaule)
        {
            byte[] arr = BitConverter.GetBytes(vaule);
            base.Write(arr, 0, arr.Length);
        }
        #endregion
        #region Long
        /// <summary>
        /// 从流中读取一个short数据
        /// </summary>
        /// <returns></returns>
        public long  ReadLong()
        {
            byte[] arr = new byte[8];
            base.Read(arr, 0, 8);
            return BitConverter.ToInt64(arr, 0);
        }
        /// <summary>
        /// 把一个short数据写入流
        /// </summary>
        /// <param name="vaule"></param>
        public void WriteLong(long  vaule)
        {
            byte[] arr = BitConverter.GetBytes(vaule);
            base.Write(arr, 0, arr.Length);
        }
        #endregion
        #region ULong
        /// <summary>
        /// 从流中读取一个short数据
        /// </summary>
        /// <returns></returns>
        public ulong  ReadULong()
        {
            byte[] arr = new byte[4];
            base.Read(arr, 0, 4);
            return BitConverter.ToUInt64(arr, 0);
        }
        /// <summary>
        /// 把一个short数据写入流
        /// </summary>
        /// <param name="vaule"></param>
        public void WriteULong(ulong vaule)
        {
            byte[] arr = BitConverter.GetBytes(vaule);
            base.Write(arr, 0, arr.Length);
        }
        #endregion
        #region Float
        /// <summary>
        /// 从流中读取一个short数据
        /// </summary>
        /// <returns></returns>
        public float  ReadFloat()
        {
            byte[] arr = new byte[4];
            base.Read(arr, 0, 4);
            return BitConverter.ToSingle (arr, 0);
        }
        /// <summary>
        /// 把一个short数据写入流
        /// </summary>
        /// <param name="vaule"></param>
        public void WriteFloat(float  vaule)
        {
            byte[] arr = BitConverter.GetBytes(vaule);
            base.Write(arr, 0, arr.Length);
        }
        #endregion
        #region Double
        /// <summary>
        /// 从流中读取一个short数据
        /// </summary>
        /// <returns></returns>
        public double  ReadDouble()
        {
            byte[] arr = new byte[8];
            base.Read(arr, 0, 8);
            return BitConverter.ToDouble (arr, 0);
        }
        /// <summary>
        /// 把一个short数据写入流
        /// </summary>
        /// <param name="vaule"></param>
        public void WriteDouble(double  vaule)
        {
            byte[] arr = BitConverter.GetBytes(vaule);
            base.Write(arr, 0, arr.Length);
        }
        #endregion
        #region Bool
        /// <summary>
        /// 从流中读取一个short数据
        /// </summary>
        /// <returns></returns>
        public bool  ReadBool()
        {
            return base.ReadByte() == 1;
        }
        /// <summary>
        /// 把一个short数据写入流
        /// </summary>
        /// <param name="vaule"></param>
        public void WriteBool(bool  vaule)
        {    
            base.WriteByte((byte )(vaule ==true ?1:0));
        }
        #endregion
        #region String
        /// <summary>
        /// 从流中读取一个short数据
        /// </summary>
        /// <returns></returns>
        public string  ReadUTF8String()
        {
            ushort len = this.ReadUShort();
            byte[] arr = new byte[len];
            base.Read(arr, 0, len);
            return Encoding.UTF8.GetString(arr);
        }
        /// <summary>
        /// 把一个short数据写入流
        /// </summary>
        /// <param name="vaule"></param>
        public void WriteString(string  vaule)
        {
            byte[] arr = Encoding.UTF8.GetBytes(vaule);
            if(arr.Length >65535)
            {
                throw new InvalidCastException("字符串超出范围");
            }
            this.WriteUShort((ushort)arr.Length);
            base.Write(arr, 0, arr.Length);
        }
        #endregion
    }
    

    2.应用例子,自己谢了一个Item的类,实例化一个该类并为其赋值,如下所示

    using UnityEngine;
    using System.Collections;
    
    public class TestMemoryStream : MonoBehaviour {
    
        // Use this for initialization
        void Start ()
        {
            Item item = new Item();
            item.Id = 1;
            item.Name = "测试输出";
            byte[] arr = null;
    
            //向流中写入我们自己的数据类信息
            using (MyMemoryStream ms = new MyMemoryStream())
            {
                ms.WriteInt(item.Id);
                ms.WriteString(item.Name);
                arr = ms.ToArray();
            }
    
            //if(arr !=null )
            //{
            //    for (int i = 0; i < arr.Length ; i++)
            //    {
            //        Debug.Log(string.Format("{0}={1}", i, arr[i]));
            //    }
            //}
            //从流中读取出我们想要的信息
            using (MyMemoryStream ms = new MyMemoryStream(arr ))
            {
                int id = ms.ReadInt();
                string name = ms.ReadUTF8String();
                Debug.Log(string.Format("id={0}:Name={1}", id, name));
            }
        }
    
        // Update is called once per frame
        void Update () {
    
        }
    }
    
    public class Item
    {
        public int Id;
        public string Name;
    }
    

    运行结果输出Log为;id=1:Name=测试输出

    展开全文
  • C# 二进制字节流读写封装

    千次阅读 2017-05-16 19:41:31
    提供不同数据类型读写接口,包括byte,short,int,float,string等。处理了大小端数据转换的问题,所以可用于网络数据的解析和发送。 using System.IO; using System.Net; using System; namespace ...

    完成以下功能:

    • 只针对内存字节流的读写,主要应用于数据的解析和写入。
    • 提供不同数据类型的读写接口,包括byte,short,int,float,string等。
    • 处理了大小端数据转换的问题,所以可用于网络数据的解析和发送。

    using System.IO; 
    using System.Net;
    using System;
    
    namespace Framework
    {
    	public class NetStream
    	{
    		private MemoryStream stream;
    		private BinaryReader reader;
    		private BinaryWriter writer;
    
    		public NetStream(byte[] buffer = null)
    		{
    			if (buffer == null)
    			{
    				this.stream = new MemoryStream();
    			}
    			else
    			{
    				this.stream = new MemoryStream(buffer);
    			}
    
    			this.reader = new BinaryReader(this.stream);
    			this.writer = new BinaryWriter(this.stream);
    		}
    
    		public void Close()
    		{
    			this.stream.Close();
    			this.reader.Close();
    			this.writer.Close();
    		}
    
    //-------------------------------------------------------------------------------
    
            public long ReadInt64()
    		{
    			return IPAddress.HostToNetworkOrder(this.reader.ReadInt64());
    		}
    
    		public int ReadInt32() 
    		{
    			return IPAddress.HostToNetworkOrder(this.reader.ReadInt32());
    		}
    
    		public short ReadInt16() 
    		{
    			return IPAddress.HostToNetworkOrder(this.reader.ReadInt16());
    		}
    
    		public byte ReadByte()
    		{
    			return this.reader.ReadByte();
    		}
    
            public float ReadFloat()
            {
                return this.reader.ReadSingle();
            }
    
            public string ReadString8() 
    		{
    			return System.Text.Encoding.UTF8.GetString(this.reader.ReadBytes(ReadByte()));
    		}
    
    		public string ReadString16() 
    		{
    			return System.Text.Encoding.UTF8.GetString(this.reader.ReadBytes(ReadInt16()));
    		}
    
    		public long Seek(long offset)
    		{
    			return this.stream.Seek(offset, SeekOrigin.Begin);
    		}
    
    //-------------------------------------------------------------------------------
    
    		public void WriteByte(byte value)
    		{
    			this.writer.Write(value);
    		} 
    
    		public void WriteInt16(short value)
    		{
    			this.writer.Write(BitConverter.GetBytes(IPAddress.HostToNetworkOrder(value)));
    		}
    
    		public void WriteInt32(int value)
    		{
    			this.writer.Write(BitConverter.GetBytes(IPAddress.HostToNetworkOrder(value)));
    		}
    
    		public void WriteInt64(long value)
    		{
    			this.writer.Write(BitConverter.GetBytes(IPAddress.HostToNetworkOrder(value)));
    		}
    
            public void WriteFloat(float value)
            {
                this.writer.Write(value);
            }
    
            public void WriteString8(string value)
    		{
    			byte[] byteArray = System.Text.Encoding.UTF8.GetBytes(value);
    
    			WriteByte((byte) byteArray.Length);
    
    			this.writer.Write(byteArray);
    		}
    
    		public void WriteString16(string value)
    		{
    			byte[] byteArray = System.Text.Encoding.UTF8.GetBytes(value);
    
    			WriteInt16((short) byteArray.Length);
    
    			this.writer.Write(byteArray);
    		}
    
    		public byte[] GetBuffer()
    		{
    			return this.stream.ToArray();
    		}
    
    		public int GetLength()
    		{
    			return (int) this.stream.Length;
    		}
    	}
    }
    
    


    展开全文
  • java数据流

    千次阅读 2018-11-13 14:44:27
    Java数据流 Java数据流分为两种:字节流(Byte)和字符流(Character) 标准流 字节流:以8位为为单位对二进制数据进行操作对数据不进行转换。这些类都是InputStream和OutputStream的子类. FileInputStream(File ...
  • C++读写文本数据

    万次阅读 多人点赞 2017-10-24 14:58:23
    1、C++读写二进制文件 /***************************************************************** * \author DreamerZhang ... * \brief 读取二进制文件,数据类型为short * \param fileName-文件名 readD...
  • c#文件流读写

    千次阅读 2013-04-10 16:14:50
    读写的完整流程例子可参考:stream简单读写excel 写文件: string demo="写入txt中"; StreamWriter demo_log = null; demo_log = File.CreateText("demo_log.txt"); demo_log.WriteLine(demo,Encoding.Get
  • JAVA数据流概念及标准数据流的实现

    千次阅读 2017-06-30 22:52:26
    1、数据流的概念计算机程序中,获取数据的方式有多种,比如:程序中直接给出、键盘输入、从数据文件中读取、从数据库中读取、通过网络读取等。 为了更有效地进行数据的输入/输出操作,Java将各种数据源的数据,抽象...
  • QDataStream 二进制数据读写

    万次阅读 2017-03-20 14:24:43
    个数据流如果是二进制编码的数据流,那么它肯定是与计算机的操作系统、CPU或者字节序无关的。例如,一个数据流是在一运行Windows系统的PC机上被写入的,那么它照样可以在一台运行Solaris的Sun SPARC的机器上被...
  • 使用Java 输出/输出流读写数据

    千次阅读 2006-11-22 19:58:00
    Java 输入/输出(I/O)机制提供了一套简单的,标准化的API以便从不同的数据源读取和写入字符和字节数据。在“面向对象编程:Java collection更有效管理elements”一文中,我们讨论了Java ...数据流Java所有的I/O机制都
  • IO读写操作

    千次阅读 2016-05-12 20:35:40
     除了按照流的方向可以把流划分为输入流和输出流两类,按照流读写数据的基本单位把流划分为字节流和字符流两类以外,还可以按照流是否直接连接实际数据源,例如文件、网络、字节数组等,将流又可以划分为实体流和...
  • 结构体类型,也是一种类型,用简单数据类型的思维去考虑复杂类型 fopen()函数 函数原型: FILE *fopen(const char *path, const char *mode) 使用注意:需要判断产生的文件指针是不是空指针fwrite()函数 函数...
  • 1、IO的分类A、按照流向【参照物JVM】 ...B、按照数据类型 (1)字节 a、字节输入 读取数据 InputStream b、字节输出 写出数据 OutputStream (2)字符 a、字符输入 读取数据 Read
  •  无论是MemoryStream,BufferedStream,FileStream数据流,一旦的读写开始,应用程序就会处于停滞状况。  直到数据读写完成,并返回。  文件数据的读写基本上是一种非常消耗资源的过程,处理的数据量越大,...
  • 在VS.NET平台上,包括了下面三种数据流类型 类型 命名空间 功能 网络流Network Stream System.Net.Sockets 网络数据的读写操作 内存流 Memory Stream System。IO 内存数据的处理和转换 文件
  • HDFS的读写方案

    千次阅读 2016-04-24 20:04:12
    上次我在文章末尾提到了针对Hadoop内部普通读写操作限的假设以及由此可能会造成的问题.但是我后来还是仔细想了一下,有的时候还是需要进行测试一下才能得到真正的结果.而且正巧的是,最近我们碰到了一严峻的问题,...
  • java中的数据流

    万次阅读 2013-01-10 18:09:54
    字节提供了处理字节的输入/输出方法,如在读写二进制数据时就要使用字节。顶层的是两抽象类是:InputStream(输入)和OutputStream(输出)。这两抽象类派生出来的具体子类提供了读写各种不同设备如磁盘文件...
  • 【0】README0.1) 本文描述转自 core java volume 2, 旨在理解 java与文件——读写二进制数据(DataOutput + DataInput)的相关知识; 0.2) for complete my diy code, please visit ...
  • Numpy基础之 ndarray的数据类型

    千次阅读 2018-03-13 11:59:17
    dtype(数据类型)是一特殊的对象,它含有ndarray将一块内存解释为特定数据类型所需的信息。这也是Numpy如此强大和灵活的原因之一。多数情况下,它们直接映射到相应的机器表示,这使得‘读写磁盘上的二进制数据流...
  • 本文章内容主要为数据流及相关辅助类: 流(Stream)、文件流(FileStream)、内存流(MemoryStream)、网络流(NetworkStream)、加密流(CryptoStream)以及文本读写的StreamReader、StreamWriter、用于二进制读写的...
  • java IO文件的读写具体实例

    千次阅读 2017-08-23 16:22:44
    1、根据数据对象来分: 高端:所有的内存中的都是高端,比如:InputStreamReader  低端:所有的外界设备中的都是低端,比如InputStream,OutputStream  如何区分:所有的对象的后缀中包含...
  • 通过实现文件读写的方法(上)

    千次阅读 2017-05-09 21:56:40
    可以通过如下三种方式对文件中的数据进行读取和写入:字节方式、字符方式以及缓冲区方式。
  • Java输入输出数据流

    千次阅读 2017-12-15 08:48:51
    目录(?...1 数据流2 输入流Input Stream 3 输出流数据流分类3 标准IO 命令行参数标准输入输出数据流4javaIO层次体系结构 5 非流式文件类–File类 6 JavaIO流类库 io流的四基本类io流的具体分类
  • Region中的数据操作之HFile读写

    千次阅读 2014-02-19 20:51:37
    HFile包含8种类型数据,分别为KV数据、KV数据索引、Bloom数据、Bloom数据索引、元数据、元数据索引、FileInfo、Trailer。...HFile文件分为四区域,不同区域的数据读写方式不同。如下图示,分别为扫描
  • MemoryStream有关内存数据读写

    千次阅读 2017-09-09 12:19:54
    MemoryStream内存数据的读写  电脑中最基本的单位是位(bit),但位这单位太小,所以字节(Byte)是电脑存储容量的... 基本的数据类型:byte 、short(2字节) 、int(4字节)、 long(8字节)、float(4
  • Java中的IO流之数据流和对象流

    千次阅读 2018-08-13 14:21:52
    数据流和对象流 数据流 数据输出流 数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后,应用程序可以使用数据输入流将数据读入。 通过 API 可以看到在 DataOutputStream 中是可以输出很...
  • 几种IO流读写文件

    万次阅读 多人点赞 2017-05-31 21:00:03
    字节: InputStream(读入) OutputStream(写出) 字符: Reader(字符 读入) Writer (字符写出) 二、文件操作 字节: FileInputStream ,FileOutputStream 字符: FileReader, FileWriter...
  • 从文件读写整数--C语言

    千次阅读 2016-12-07 10:29:59
    本文将介绍在文本中,读写整数的两接口– int getw(FILE *fp)和int putw(int w, FILE *fp),并且与你分享改进后的更实用的接口– unsigned int get_uint(FILE *fp)和unsigned int put_uint(unsigned int i,FILE *...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 186,350
精华内容 74,540
关键字:

个数据流所能读写的数据类型