精华内容
下载资源
问答
  • 自己动手写工作

    千次阅读 2017-10-10 11:32:04
    很多时候,工作引擎就是系统的核心,可是很多工作框架太过死板,配置项也比较麻烦,归根结底工作引擎也不过是帮助我们完成事件的框架,其实可以根据自己的需求自己设计数据库,完成工作 首先工作必备的几...
        很多时候,工作流引擎就是系统的核心,可是很多工作流框架太过死板,配置项也比较麻烦,归根结底工作流引擎也不过是帮助我们完成事件的框架,其实可以根据自己的需求自己设计数据库,完成工作流
        首先工作流必备的几张表有:历史表,步骤表,步骤历史表和事件当前状态表,这四张表是最基础的,如果工作里比较复杂也可以根据自己的工作流自行增加删减
    

    历史表:历史表是对事件办理完成后的归档保存处理,所以历史表必须要包含事件的所有字段,这里就不给出具体表结构,根据自己的事件自己设计。
    步骤表:步骤表的作用,首先定义每个工作流的步骤,当流程开始时流程的每一步以及下一步是什么大致表结构如下:

    CREATE TABLE "FLOW_STATE" 
       ("CODE" NVARCHAR2(255), 
        "STATE_CODE" NVARCHAR2(255), 
        "BEROF_NUM" NVARCHAR2(255), 
        "AFTER_NUM" NVARCHAR2(255), 
        "STATE_NAME" NVARCHAR2(255), 
        "EXPLAIN" NVARCHAR2(255)
       )

    该表包括主键、步骤code、上一步code、下一步code,当前步骤名称,及步骤注释。
    步骤历史表:记录每个事件,每一步的历史留痕,事件每走一步,这张表就插入一条数据,表结构如下:

    
      CREATE TABLE "FLOW_STEP" 
       ("CODE" NVARCHAR2(255), 
        "CREATE_DATE" NVARCHAR2(255), 
        "PERSON_CODE" NVARCHAR2(255), 
        "BEFOR_STEP" NVARCHAR2(255), 
        "AFTER_STEP" NVARCHAR2(255), 
        "OPINION" NVARCHAR2(255), 
        "STEP_STATE" NVARCHAR2(255), 
        "MAIN_CODE" NVARCHAR2(255)
       ) 

    该表包括主键,操作时间按,操作人,上一步操作人,下一步操作人,意见,步骤code,以及事件当前状态表code。
    事件当前状态表:主要记录事件分类,事件当前状态等信息,表结构如下:

     CREATE TABLE "ARES"."FLOW_MAIN" 
       (    "CODE" NVARCHAR2(255), 
        "CREATE_DATE" NVARCHAR2(255), 
        "PERSON_CODE" NVARCHAR2(255), 
        "EVENT_CODE" NVARCHAR2(255), 
        "EVENT_STATE" NVARCHAR2(255) DEFAULT NULL, 
        "EVENT_NAME" NVARCHAR2(255), 
        "STEP_NUM" NVARCHAR2(255)
       )

    此表关联所有表的相关信息,包括主键,创建时间,创建人,事件code,事件状态,事件名称code以及事件步骤code

    展开全文
  • 【Java基础-3】吃透Java IO:字节、字符、缓冲

    万次阅读 多人点赞 2020-09-23 20:12:33
    什么是Java-IO?字符和字节的区别与适用场景是什么?缓冲到底实现了什么?如何高效地读写文件? 本文用大量的示例图和实例,带你吃透Java IO。

    前言

    有人曾问fastjson的作者(阿里技术专家高铁):“你开发fastjson,没得到什么好处,反而挨了骂背了锅,这种事情你为什么要做呢?”

    高铁答道:“因为热爱本身,就是奖励啊!”

    这个回答顿时触动了我。想想自己,又何尝不是如此。写作是个痛苦的过程,用心写作就更加煎熬,需字字斟酌,反复删改才有所成。然而,当一篇篇精良文章出自己手而呈现眼前时,那些痛苦煎熬就都那么值得。如果这些博文能有幸得大家阅读和认可,就更加是莫大的鼓舞了。技术人的快乐就是可以这么纯粹和简单。

    点波关注不迷路,一键三连好运连连!

    IO流是Java中的一个重要构成部分,也是我们经常打交道的。这篇关于Java IO的博文干货满满,堪称全网前三(请轻喷!)

    下面几个问题(问题还会继续补充),如果你能对答如流,那么恭喜你,IO知识掌握得很好,可以立即关闭文章。反之,你可以在后面得文章中寻找答案。

    1. Java IO流有什么特点?
    2. Java IO流分为几种类型?
    3. 字节流和字符流的关系与区别?
    4. 字符流是否使用了缓冲?
    5. 缓冲流的效率一定高吗?为什么?
    6. 缓冲流体现了Java中的哪种设计模式思想?
    7. 为什么要实现序列化?如何实现序列化?
    8. 序列化数据后,再次修改类文件,读取数据会出问题,如何解决呢?

    1 初识Java IO

    IO,即inout,也就是输入和输出,指应用程序和外部设备之间的数据传递,常见的外部设备包括文件、管道、网络连接。

    Java 中是通过流处理IO 的,那么什么是流

    流(Stream),是一个抽象的概念,是指一连串的数据(字符或字节),是以先进先出的方式发送信息的通道。

    当程序需要读取数据的时候,就会开启一个通向数据源的流,这个数据源可以是文件,内存,或是网络连接。类似的,当程序需要写入数据的时候,就会开启一个通向目的地的流。这时候你就可以想象数据好像在这其中“流”动一样。

    一般来说关于流的特性有下面几点:

    1. 先进先出:最先写入输出流的数据最先被输入流读取到。
    2. 顺序存取:可以一个接一个地往流中写入一串字节,读出时也将按写入顺序读取一串字节,不能随机访问中间的数据。(RandomAccessFile除外)
    3. 只读或只写:每个流只能是输入流或输出流的一种,不能同时具备两个功能,输入流只能进行读操作,对输出流只能进行写操作。在一个数据传输通道中,如果既要写入数据,又要读取数据,则要分别提供两个流。

    1.1 IO流分类

    IO流主要的分类方式有以下3种:

    1. 按数据流的方向:输入流、输出流
    2. 按处理数据单位:字节流、字符流
    3. 按功能:节点流、处理流

    在这里插入图片描述

    1、输入流与输出流

    输入与输出是相对于应用程序而言的,比如文件读写,读取文件是输入流,写文件是输出流,这点很容易搞反。

    在这里插入图片描述
    2、字节流与字符流

    字节流和字符流的用法几乎完成全一样,区别在于字节流和字符流所操作的数据单元不同,字节流操作的单元是数据单元是8位的字节,字符流操作的是数据单元为16位的字符。

    为什么要有字符流?

    Java中字符是采用Unicode标准,Unicode 编码中,一个英文为一个字节,一个中文为两个字节。
    在这里插入图片描述
    而在UTF-8编码中,一个中文字符是3个字节。例如下面图中,“云深不知处”5个中文对应的是15个字节:-28-70-111-26-73-79-28-72-115-25-97-91-27-92-124
    在这里插入图片描述

    那么问题来了,如果使用字节流处理中文,如果一次读写一个字符对应的字节数就不会有问题,一旦将一个字符对应的字节分裂开来,就会出现乱码了。为了更方便地处理中文这些字符,Java就推出了字符流。

    字节流和字符流的其他区别:

    1. 字节流一般用来处理图像、视频、音频、PPT、Word等类型的文件。字符流一般用于处理纯文本类型的文件,如TXT文件等,但不能处理图像视频等非文本文件。用一句话说就是:字节流可以处理一切文件,而字符流只能处理纯文本文件。
    2. 字节流本身没有缓冲区,缓冲字节流相对于字节流,效率提升非常高。而字符流本身就带有缓冲区,缓冲字符流相对于字符流效率提升就不是那么大了。详见文末效率对比。

    以写文件为例,我们查看字符流的源码,发现确实有利用到缓冲区:
    在这里插入图片描述
    在这里插入图片描述

    3、节点流和处理流

    节点流:直接操作数据读写的流类,比如FileInputStream

    处理流:对一个已存在的流的链接和封装,通过对数据进行处理为程序提供功能强大、灵活的读写功能,例如BufferedInputStream(缓冲字节流)

    处理流和节点流应用了Java的装饰者设计模式。

    下图就很形象地描绘了节点流和处理流,处理流是对节点流的封装,最终的数据处理还是由节点流完成的。
    在这里插入图片描述
    在诸多处理流中,有一个非常重要,那就是缓冲流

    我们知道,程序与磁盘的交互相对于内存运算是很慢的,容易成为程序的性能瓶颈。减少程序与磁盘的交互,是提升程序效率一种有效手段。缓冲流,就应用这种思路:普通流每次读写一个字节,而缓冲流在内存中设置一个缓存区,缓冲区先存储足够的待操作数据后,再与内存或磁盘进行交互。这样,在总数据量不变的情况下,通过提高每次交互的数据量,减少了交互次数。
    在这里插入图片描述

    联想一下生活中的例子,我们搬砖的时候,一块一块地往车上装肯定是很低效的。我们可以使用一个小推车,先把砖装到小推车上,再把这小推车推到车前,把砖装到车上。这个例子中,小推车可以视为缓冲区,小推车的存在,减少了我们装车次数,从而提高了效率。
    在这里插入图片描述
    需要注意的是,缓冲流效率一定高吗?不一定,某些情形下,缓冲流效率反而更低,具体请见IO流效率对比。

    完整的IO分类图如下:
    在这里插入图片描述

    1.2 案例实操

    接下来,我们看看如何使用Java IO。

    文本读写的例子,也就是文章开头所说的,将“松下问童子,言师采药去。只在此山中,云深不知处。”写入本地文本,然后再从文件读取内容并输出到控制台。

    1、FileInputStream、FileOutputStream(字节流)

    字节流的方式效率较低,不建议使用

    public class IOTest {
    	public static void main(String[] args) throws IOException {
    		File file = new File("D:/test.txt");
    
    		write(file);
    		System.out.println(read(file));
    	}
    
    	public static void write(File file) throws IOException {
    		OutputStream os = new FileOutputStream(file, true);
    
    		// 要写入的字符串
    		String string = "松下问童子,言师采药去。只在此山中,云深不知处。";
    		// 写入文件
    		os.write(string.getBytes());
    		// 关闭流
    		os.close();
    	}
    
    	public static String read(File file) throws IOException {
    		InputStream in = new FileInputStream(file);
    
    		// 一次性取多少个字节
    		byte[] bytes = new byte[1024];
    		// 用来接收读取的字节数组
    		StringBuilder sb = new StringBuilder();
    		// 读取到的字节数组长度,为-1时表示没有数据
    		int length = 0;
    		// 循环取数据
    		while ((length = in.read(bytes)) != -1) {
    			// 将读取的内容转换成字符串
    			sb.append(new String(bytes, 0, length));
    		}
    		// 关闭流
    		in.close();
    
    		return sb.toString();
    	}
    }
    

    2、BufferedInputStream、BufferedOutputStream(缓冲字节流)

    缓冲字节流是为高效率而设计的,真正的读写操作还是靠FileOutputStreamFileInputStream,所以其构造方法入参是这两个类的对象也就不奇怪了。

    public class IOTest {
    
    	public static void write(File file) throws IOException {
    		// 缓冲字节流,提高了效率
    		BufferedOutputStream bis = new BufferedOutputStream(new FileOutputStream(file, true));
    
    		// 要写入的字符串
    		String string = "松下问童子,言师采药去。只在此山中,云深不知处。";
    		// 写入文件
    		bis.write(string.getBytes());
    		// 关闭流
    		bis.close();
    	}
    
    	public static String read(File file) throws IOException {
    		BufferedInputStream fis = new BufferedInputStream(new FileInputStream(file));
    
    		// 一次性取多少个字节
    		byte[] bytes = new byte[1024];
    		// 用来接收读取的字节数组
    		StringBuilder sb = new StringBuilder();
    		// 读取到的字节数组长度,为-1时表示没有数据
    		int length = 0;
    		// 循环取数据
    		while ((length = fis.read(bytes)) != -1) {
    			// 将读取的内容转换成字符串
    			sb.append(new String(bytes, 0, length));
    		}
    		// 关闭流
    		fis.close();
    
    		return sb.toString();
    	}
    }
    

    3、InputStreamReader、OutputStreamWriter(字符流)

    字符流适用于文本文件的读写OutputStreamWriter类其实也是借助FileOutputStream类实现的,故其构造方法是FileOutputStream的对象

    public class IOTest {
    	
    	public static void write(File file) throws IOException {
    		// OutputStreamWriter可以显示指定字符集,否则使用默认字符集
    		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(file, true), "UTF-8");
    
    		// 要写入的字符串
    		String string = "松下问童子,言师采药去。只在此山中,云深不知处。";
    		osw.write(string);
    		osw.close();
    	}
    
    	public static String read(File file) throws IOException {
    		InputStreamReader isr = new InputStreamReader(new FileInputStream(file), "UTF-8");
    		// 字符数组:一次读取多少个字符
    		char[] chars = new char[1024];
    		// 每次读取的字符数组先append到StringBuilder中
    		StringBuilder sb = new StringBuilder();
    		// 读取到的字符数组长度,为-1时表示没有数据
    		int length;
    		// 循环取数据
    		while ((length = isr.read(chars)) != -1) {
    			// 将读取的内容转换成字符串
    			sb.append(chars, 0, length);
    		}
    		// 关闭流
    		isr.close();
    
    		return sb.toString()
    	}
    }
    

    4、字符流便捷类

    Java提供了FileWriterFileReader简化字符流的读写,new FileWriter等同于new OutputStreamWriter(new FileOutputStream(file, true))

    public class IOTest {
    	
    	public static void write(File file) throws IOException {
    		FileWriter fw = new FileWriter(file, true);
    
    		// 要写入的字符串
    		String string = "松下问童子,言师采药去。只在此山中,云深不知处。";
    		fw.write(string);
    		fw.close();
    	}
    
    	public static String read(File file) throws IOException {
    		FileReader fr = new FileReader(file);
    		// 一次性取多少个字节
    		char[] chars = new char[1024];
    		// 用来接收读取的字节数组
    		StringBuilder sb = new StringBuilder();
    		// 读取到的字节数组长度,为-1时表示没有数据
    		int length;
    		// 循环取数据
    		while ((length = fr.read(chars)) != -1) {
    			// 将读取的内容转换成字符串
    			sb.append(chars, 0, length);
    		}
    		// 关闭流
    		fr.close();
    
    		return sb.toString();
    	}
    }
    

    5、BufferedReader、BufferedWriter(字符缓冲流)

    public class IOTest {
    	
    	public static void write(File file) throws IOException {
    		// BufferedWriter fw = new BufferedWriter(new OutputStreamWriter(new
    		// FileOutputStream(file, true), "UTF-8"));
    		// FileWriter可以大幅度简化代码
    		BufferedWriter bw = new BufferedWriter(new FileWriter(file, true));
    
    		// 要写入的字符串
    		String string = "松下问童子,言师采药去。只在此山中,云深不知处。";
    		bw.write(string);
    		bw.close();
    	}
    
    	public static String read(File file) throws IOException {
    		BufferedReader br = new BufferedReader(new FileReader(file));
    		// 用来接收读取的字节数组
    		StringBuilder sb = new StringBuilder();
    
    		// 按行读数据
    		String line;
    		// 循环取数据
    		while ((line = br.readLine()) != null) {
    			// 将读取的内容转换成字符串
    			sb.append(line);
    		}
    		// 关闭流
    		br.close();
    
    		return sb.toString();
    	}
    }
    

    2 IO流对象

    第一节中,我们大致了解了IO,并完成了几个案例,但对IO还缺乏更详细的认知,那么接下来我们就对Java IO细细分解,梳理出完整的知识体系来。

    Java种提供了40多个类,我们只需要详细了解一下其中比较重要的就可以满足日常应用了。

    2.1 File类

    File类是用来操作文件的类,但它不能操作文件中的数据。

    public class File extends Object implements Serializable, Comparable<File>
    

    File类实现了SerializableComparable<File>,说明它是支持序列化和排序的。

    File类的构造方法

    方法名 说明
    File(File parent, String child) 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
    File(String pathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
    File(String parent, String child) 根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
    File(URI uri) 通过将给定的 file: URI 转换为一个抽象路径名来创建一个新的 File 实例。

    File类的常用方法

    方法 说明
    createNewFile() 当且仅当不存在具有此抽象路径名指定名称的文件时,不可分地创建一个新的空文件。
    delete() 删除此抽象路径名表示的文件或目录。
    exists() 测试此抽象路径名表示的文件或目录是否存在。
    getAbsoluteFile() 返回此抽象路径名的绝对路径名形式。
    getAbsolutePath() 返回此抽象路径名的绝对路径名字符串。
    length() 返回由此抽象路径名表示的文件的长度。
    mkdir() 创建此抽象路径名指定的目录。

    File类使用实例

    public class FileTest {
    	public static void main(String[] args) throws IOException {
    		File file = new File("C:/Mu/fileTest.txt");
    
    		// 判断文件是否存在
    		if (!file.exists()) {
    			// 不存在则创建
    			file.createNewFile();
    		}
    		System.out.println("文件的绝对路径:" + file.getAbsolutePath());
    		System.out.println("文件的大小:" + file.length());
    
    		// 刪除文件
    		file.delete();
    	}
    }
    

    2.2 字节流

    InputStreamOutputStream是两个抽象类,是字节流的基类,所有具体的字节流实现类都是分别继承了这两个类。

    InputStream为例,它继承了Object,实现了Closeable

    public abstract class InputStream
    extends Object
    implements Closeable
    

    InputStream类有很多的实现子类,下面列举了一些比较常用的:
    在这里插入图片描述
    详细说明一下上图中的类:

    1. InputStreamInputStream是所有字节输入流的抽象基类,前面说过抽象类不能被实例化,实际上是作为模板而存在的,为所有实现类定义了处理输入流的方法。
    2. FileInputSream:文件输入流,一个非常重要的字节输入流,用于对文件进行读取操作。
    3. PipedInputStream:管道字节输入流,能实现多线程间的管道通信。
    4. ByteArrayInputStream:字节数组输入流,从字节数组(byte[])中进行以字节为单位的读取,也就是将资源文件都以字节的形式存入到该类中的字节数组中去。
    5. FilterInputStream:装饰者类,具体的装饰者继承该类,这些类都是处理类,作用是对节点类进行封装,实现一些特殊功能。
    6. DataInputStream:数据输入流,它是用来装饰其它输入流,作用是“允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型”。
    7. BufferedInputStream:缓冲流,对节点流进行装饰,内部会有一个缓存区,用来存放字节,每次都是将缓存区存满然后发送,而不是一个字节或两个字节这样发送,效率更高。
    8. ObjectInputStream:对象输入流,用来提供对基本数据或对象的持久存储。通俗点说,也就是能直接传输对象,通常应用在反序列化中。它也是一种处理流,构造器的入参是一个InputStream的实例对象。

    OutputStream类继承关系图:
    在这里插入图片描述

    OutputStream类继承关系与InputStream类似,需要注意的是PrintStream.

    2.3 字符流

    与字节流类似,字符流也有两个抽象基类,分别是ReaderWriter。其他的字符流实现类都是继承了这两个类。

    Reader为例,它的主要实现子类如下图:
    在这里插入图片描述
    各个类的详细说明:

    1. InputStreamReader:从字节流到字符流的桥梁(InputStreamReader构造器入参是FileInputStream的实例对象),它读取字节并使用指定的字符集将其解码为字符。它使用的字符集可以通过名称指定,也可以显式给定,或者可以接受平台的默认字符集。
    2. BufferedReader:从字符输入流中读取文本,设置一个缓冲区来提高效率。BufferedReader是对InputStreamReader的封装,前者构造器的入参就是后者的一个实例对象。
    3. FileReader:用于读取字符文件的便利类,new FileReader(File file)等同于new InputStreamReader(new FileInputStream(file, true),"UTF-8"),但FileReader不能指定字符编码和默认字节缓冲区大小。
    4. PipedReader :管道字符输入流。实现多线程间的管道通信。
    5. CharArrayReader:从Char数组中读取数据的介质流。
    6. StringReader :从String中读取数据的介质流。

    WriterReader结构类似,方向相反,不再赘述。唯一有区别的是,Writer的子类PrintWriter

    2.4 序列化

    待续…

    3 IO流方法

    3.1 字节流方法

    字节输入流InputStream主要方法:

    • read() :从此输入流中读取一个数据字节。
    • read(byte[] b) :从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
    • read(byte[] b, int off, int len) :从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
    • close():关闭此输入流并释放与该流关联的所有系统资源。

    字节输出流OutputStream主要方法:

    • write(byte[] b) :将 b.length 个字节从指定 byte 数组写入此文件输出流中。
    • write(byte[] b, int off, int len) :将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
    • write(int b) :将指定字节写入此文件输出流。
    • close() :关闭此输入流并释放与该流关联的所有系统资源。

    3.2 字符流方法

    字符输入流Reader主要方法:

    • read():读取单个字符。
    • read(char[] cbuf) :将字符读入数组。
    • read(char[] cbuf, int off, int len) : 将字符读入数组的某一部分。
    • read(CharBuffer target) :试图将字符读入指定的字符缓冲区。
    • flush() :刷新该流的缓冲。
    • close() :关闭此流,但要先刷新它。

    字符输出流Writer主要方法:

    • write(char[] cbuf) :写入字符数组。
    • write(char[] cbuf, int off, int len) :写入字符数组的某一部分。
    • write(int c) :写入单个字符。
    • write(String str) :写入字符串。
    • write(String str, int off, int len) :写入字符串的某一部分。
    • flush() :刷新该流的缓冲。
    • close() :关闭此流,但要先刷新它。

    另外,字符缓冲流还有两个独特的方法:

    • BufferedWriternewLine()写入一个行分隔符。这个方法会自动适配所在系统的行分隔符。
    • BufferedReaderreadLine() :读取一个文本行。

    4 附加内容

    4.1 位、字节、字符

    字节(Byte)是计量单位,表示数据量多少,是计算机信息技术用于计量存储容量的一种计量单位,通常情况下一字节等于八位。

    字符(Character)计算机中使用的字母、数字、字和符号,比如’A’、‘B’、’$’、’&'等。

    一般在英文状态下一个字母或字符占用一个字节,一个汉字用两个字节表示。

    字节与字符:

    • ASCII 码中,一个英文字母(不分大小写)为一个字节,一个中文汉字为两个字节。
    • UTF-8 编码中,一个英文字为一个字节,一个中文为三个字节。
    • Unicode 编码中,一个英文为一个字节,一个中文为两个字节。
    • 符号:英文标点为一个字节,中文标点为两个字节。例如:英文句号 . 占1个字节的大小,中文句号 。占2个字节的大小。
    • UTF-16 编码中,一个英文字母字符或一个汉字字符存储都需要 2 个字节(Unicode 扩展区的一些汉字存储需要 4 个字节)。
    • UTF-32 编码中,世界上任何字符的存储都需要 4 个字节。

    4.2 IO流效率对比

    首先,对比下普通字节流和缓冲字节流的效率:

    public class MyTest {
    	public static void main(String[] args) throws IOException {
    		File file = new File("C:/Mu/test.txt");
    		StringBuilder sb = new StringBuilder();
    
    		for (int i = 0; i < 3000000; i++) {
    			sb.append("abcdefghigklmnopqrstuvwsyz");
    		}
    		byte[] bytes = sb.toString().getBytes();
    
    		long start = System.currentTimeMillis();
    		write(file, bytes);
    		long end = System.currentTimeMillis();
    
    		long start2 = System.currentTimeMillis();
    		bufferedWrite(file, bytes);
    		long end2 = System.currentTimeMillis();
    
    		System.out.println("普通字节流耗时:" + (end - start) + " ms");
    		System.out.println("缓冲字节流耗时:" + (end2 - start2) + " ms");
    
    	}
    
    	// 普通字节流
    	public static void write(File file, byte[] bytes) throws IOException {
    		OutputStream os = new FileOutputStream(file);
    		os.write(bytes);
    		os.close();
    	}
    
    	// 缓冲字节流
    	public static void bufferedWrite(File file, byte[] bytes) throws IOException {
    		BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream(file));
    		bo.write(bytes);
    		bo.close();
    	}
    }
    

    运行结果:

    普通字节流耗时:250 ms
    缓冲字节流耗时:268 ms
    

    这个结果让我大跌眼镜,不是说好缓冲流效率很高么?要知道为什么,只能去源码里找答案了。翻看字节缓冲流的write方法:

    public synchronized void write(byte b[], int off, int len) throws IOException {
        if (len >= buf.length) {
            /* If the request length exceeds the size of the output buffer,
               flush the output buffer and then write the data directly.
               In this way buffered streams will cascade harmlessly. */
            flushBuffer();
            out.write(b, off, len);
            return;
        }
        if (len > buf.length - count) {
            flushBuffer();
        }
        System.arraycopy(b, off, buf, count, len);
        count += len;
    }
    

    注释里说得很明白:如果请求长度超过输出缓冲区的大小,刷新输出缓冲区,然后直接写入数据。这样,缓冲流将无害地级联。

    但是,至于为什么这么设计,我没有想明白,有哪位明白的大佬可以留言指点一下。

    基于上面的情形,要想对比普通字节流和缓冲字节流的效率差距,就要避免直接读写较长的字符串,于是,设计了下面这个对比案例:用字节流和缓冲字节流分别复制文件。

    public class MyTest {
    	public static void main(String[] args) throws IOException {
    		File data = new File("C:/Mu/data.zip");
    		File a = new File("C:/Mu/a.zip");
    		File b = new File("C:/Mu/b.zip");
    
    		StringBuilder sb = new StringBuilder();
    
    		long start = System.currentTimeMillis();
    		copy(data, a);
    		long end = System.currentTimeMillis();
    
    		long start2 = System.currentTimeMillis();
    		bufferedCopy(data, b);
    		long end2 = System.currentTimeMillis();
    
    		System.out.println("普通字节流耗时:" + (end - start) + " ms");
    		System.out.println("缓冲字节流耗时:" + (end2 - start2) + " ms");
    	}
    
    	// 普通字节流
    	public static void copy(File in, File out) throws IOException {
    		// 封装数据源
    		InputStream is = new FileInputStream(in);
    		// 封装目的地
    		OutputStream os = new FileOutputStream(out);
    		
    		int by = 0;
    		while ((by = is.read()) != -1) {
    			os.write(by);
    		}
    		is.close();
    		os.close();
    	}
    
    	// 缓冲字节流
    	public static void bufferedCopy(File in, File out) throws IOException {
    		// 封装数据源
    		BufferedInputStream bi = new BufferedInputStream(new FileInputStream(in));
    		// 封装目的地
    		BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream(out));
    		
    		int by = 0;
    		while ((by = bi.read()) != -1) {
    			bo.write(by);
    		}
    		bo.close();
    		bi.close();
    	}
    }
    

    运行结果:

    普通字节流耗时:184867 ms
    缓冲字节流耗时:752 ms
    

    这次,普通字节流和缓冲字节流的效率差异就很明显了,达到了245倍。

    再看看字符流和缓冲字符流的效率对比:

    public class IOTest {
    	public static void main(String[] args) throws IOException {
    		// 数据准备
    		dataReady();
    
    		File data = new File("C:/Mu/data.txt");
    		File a = new File("C:/Mu/a.txt");
    		File b = new File("C:/Mu/b.txt");
    		File c = new File("C:/Mu/c.txt");
    
    		long start = System.currentTimeMillis();
    		copy(data, a);
    		long end = System.currentTimeMillis();
    
    		long start2 = System.currentTimeMillis();
    		copyChars(data, b);
    		long end2 = System.currentTimeMillis();
    
    		long start3 = System.currentTimeMillis();
    		bufferedCopy(data, c);
    		long end3 = System.currentTimeMillis();
    
    		System.out.println("普通字节流1耗时:" + (end - start) + " ms,文件大小:" + a.length() / 1024 + " kb");
    		System.out.println("普通字节流2耗时:" + (end2 - start2) + " ms,文件大小:" + b.length() / 1024 + " kb");
    		System.out.println("缓冲字节流耗时:" + (end3 - start3) + " ms,文件大小:" + c.length() / 1024 + " kb");
    	}
    
    	// 普通字符流不使用数组
    	public static void copy(File in, File out) throws IOException {
    		Reader reader = new FileReader(in);
    		Writer writer = new FileWriter(out);
    
    		int ch = 0;
    		while ((ch = reader.read()) != -1) {
    			writer.write((char) ch);
    		}
    		reader.close();
    		writer.close();
    	}
    
    	// 普通字符流使用字符流
    	public static void copyChars(File in, File out) throws IOException {
    		Reader reader = new FileReader(in);
    		Writer writer = new FileWriter(out);
    
    		char[] chs = new char[1024];
    		while ((reader.read(chs)) != -1) {
    			writer.write(chs);
    		}
    		reader.close();
    		writer.close();
    	}
    
    	// 缓冲字符流
    	public static void bufferedCopy(File in, File out) throws IOException {
    		BufferedReader br = new BufferedReader(new FileReader(in));
    		BufferedWriter bw = new BufferedWriter(new FileWriter(out));
    
    		String line = null;
    		while ((line = br.readLine()) != null) {
    			bw.write(line);
    			bw.newLine();
    			bw.flush();
    		}
    
    		// 释放资源
    		bw.close();
    		br.close();
    	}
    
    	// 数据准备
    	public static void dataReady() throws IOException {
    		StringBuilder sb = new StringBuilder();
    		for (int i = 0; i < 600000; i++) {
    			sb.append("abcdefghijklmnopqrstuvwxyz");
    		}
    		OutputStream os = new FileOutputStream(new File("C:/Mu/data.txt"));
    		os.write(sb.toString().getBytes());
    
    		os.close();
    		System.out.println("完毕");
    	}
    }
    

    运行结果:

    普通字符流1耗时:1337 ms,文件大小:15234 kb
    普通字符流2耗时:82 ms,文件大小:15235 kb
    缓冲字符流耗时:205 ms,文件大小:15234 kb
    

    测试多次,结果差不多,可见字符缓冲流效率上并没有明显提高,我们更多的是要使用它的readLine()newLine()方法。

    4.3 NIO

    待续…

    展开全文
  • 自己用jQuery写一个瀑布

    千次阅读 2015-10-16 15:43:31
    自己用jQuery写一个瀑布前言这个月一直在忙工作。一直没有机会学习新的知识。前两天,突然想写一个瀑布代码。倒不是找不到瀑布代码。而是我想自己练练脑子。 首先,先考虑思路。所有的图片,全部采用相对父...

    自己用jQuery写一个瀑布流

    前言

    这个月一直在忙工作。一直没有机会学习新的知识。前两天,突然想写一个瀑布流代码。倒不是找不到瀑布流代码。而是我想自己练练脑子。
    首先,先考虑思路。所有的图片,全部采用相对父目录定位的方式。然后用jQuery来找出它应该排在什么位置。最终,达成瀑布流的效果。
    想再多没用。开干。

    构建html构架

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>瀑布流jquery版本测试</title>
        <link rel="stylesheet" href="style/style.css">
        <script src="js/jquery/jquery.js"></script>
        <script src="js/FengWaterFall.beta2.js"></script>
    </head>
    <body>
    <h1 class="tc cf">瀑布流jquery版本测试</h1>
    <section id="waterfall">
        <ul class="piclist">
            <li><img src="image/1.jpg" alt=""><span>瀑布流测试1</span></li>
            <li><img src="image/2.jpg" alt=""><span>瀑布流测试2</span></li>
            <li><img src="image/3.jpg" alt=""><span>瀑布流测试3</span></li>
            <li><img src="image/4.jpg" alt=""><span>瀑布流测试4</span></li>
            <li><img src="image/5.jpg" alt=""><span>瀑布流测试5</span></li>
            <li><img src="image/6.jpg" alt=""><span>瀑布流测试6</span></li>
            <li><img src="image/7.jpg" alt=""><span>瀑布流测试7</span></li>
            <li><img src="image/8.jpg" alt=""><span>瀑布流测试8</span></li>
            <li><img src="image/9.jpg" alt=""><span>瀑布流测试9</span></li>
            <li><img src="image/10.jpg" alt=""><span>瀑布流测试10</span></li>
            <li><img src="image/1.jpg" alt=""><span>瀑布流测试1</span></li>
            <li><img src="image/2.jpg" alt=""><span>瀑布流测试2</span></li>
            <li><img src="image/3.jpg" alt=""><span>瀑布流测试3</span></li>
            <li><img src="image/4.jpg" alt=""><span>瀑布流测试4</span></li>
            <li><img src="image/5.jpg" alt=""><span>瀑布流测试5</span></li>
            <li><img src="image/6.jpg" alt=""><span>瀑布流测试6</span></li>
            <li><img src="image/7.jpg" alt=""><span>瀑布流测试7</span></li>
            <li><img src="image/8.jpg" alt=""><span>瀑布流测试8</span></li>
            <li><img src="image/9.jpg" alt=""><span>瀑布流测试9</span></li>
            <li><img src="image/10.jpg" alt=""><span>瀑布流测试10</span></li>
        </ul>
    </section>
    </body>
    </html>

    SCSS代码

    @charset "UTF-8";
    @import "reset.scss";
    
    .piclist {
        margin: auto;position: relative;
        li {width: 180px;padding: 10px;border-radius: 5px;box-shadow: 0 0 4px #ddd;position: absolute;}
        img {display: block;width: 180px;}
        span {display: block;text-align: center;height: 26px;overflow: hidden;line-height: 26px;}
    }

    关于 reser.scss 初始文件。其实里面没啥,只是清除了默认样式而已。大家有兴趣,可以看一下我之前写的博文:http://blog.csdn.net/fungleo/article/details/48027493
    页面宽度设置为100%

    $WinWitdh:100%; 

    jquery 实战 第一回合

    /*
        FengWaterFall.beta1.js
        这个版本基本实现了瀑布流的效果。但是其算法不是很优秀。
        当顺序操作到图片时,它不是找空白最大的一列,所以某些情况看上去会很怪。
        2015年10月15日 15:07:03
    */
    
    $(function(){
        var Obj = $("#waterfall"),
            Ul = Obj.children('ul'),
            Li = Ul.children('li');
        waterfall();
        $(window).resize(function(event) {
            waterfall();
        });
        function waterfall(){
            var WinW = $(window).width();
            var Blank = 20,                     // 每个图片之间的间隔留白
                LiW = 200+Blank,                // 一个图片距离上一个图片的宽度距离
                LiCol = parseInt(WinW/LiW),     // 计算在当前窗口下,有几列
                UlW = LiCol*LiW-Blank;          // 根据有几列,设定总的宽度(减掉最后一个留白)
            Ul.width(UlW);
            Li.each(function(i, e){
                var T = $(this),
                    TCol = i%LiCol,             // 用求余数的方法获知当前图片为一行中的第几个
                    TRow = parseInt(i/LiCol);   // 当前索引除以列数,并取整,得知为第几行
                /*
                    取得位于当前图片上侧的图片元素
                    获取这个元素本身的高度,和父元素顶部的距离,加上空格留白,得出当前图片距离顶部的距离。
                */
                var PrevLi = Li.eq(i-LiCol),
                    PrevLiSize = PrevLi.innerHeight()+PrevLi.position().top+Blank;
    
                TRow==0 ? Ttop = 0 : Ttop = PrevLiSize+'px';
    
                var Tleft = TCol*LiW+'px';
                T.css({
                    top: Ttop,
                    left: Tleft
                });
            });
        }
    })

    实现了第一个方法之后,通过预览效果,感觉算法不是很好。所以,开始勾勒第二版。

    jquery 实战 第二回合

    /*
        FengWaterFall.beta2.js
        完美实现了瀑布流效果。其中使用的是for循环来查找索引。
    */
    
    $(function(){
        var Obj = $("#waterfall"),
            Ul = Obj.children('ul'),
            Li = Ul.children('li');
        waterfall();
        $(window).resize(function(event) {
            waterfall();
        });
        function waterfall(){
            var WinW = $(window).width();
            var Blank = 20,                     // 每个图片之间的间隔留白
                LiW = 200+Blank,                // 一个图片距离上一个图片的宽度距离
                LiCol = parseInt(WinW/LiW),     // 计算在当前窗口下,有几列
                UlW = LiCol*LiW-Blank;          // 根据有几列,设定总的宽度(减掉最后一个留白)
            Ul.width(UlW);
    
            var AllLi = [];                     // 建立一个空数组变量
            Li.each(function(index, e){
                var T = $(this);
                if (index<LiCol) {                      // 第一行的处理
                    AllLi[index] = T.outerHeight();     // 给数组添加内容,为当前元素的高度值
                    T.css({
                        top: 0,
                        left: LiW*index+'px'
                    });
                } else{
                    var MinH = Math.min.apply(null,AllLi);      // 找到数组中,最小的那个值(也就是留白最大的)
    
                    // 通过 for 循环数组 找到最小的这个数字所在的索引值
                    for (var i = 0; i < AllLi.length; i++) {
                        if (AllLi[i] == MinH) {
                            var MinI = i;
                        };
                    };
    
                    var ThisH = T.outerHeight()+Blank;          // 自身的高度加上留白
    
                    AllLi[MinI] = parseInt(MinH+ThisH);         // 将被占位的数组重新赋值
    
                    T.css({
                        top: MinH+Blank+'px',
                        left: LiW*MinI+'px'
                    });
                };
            });
    
            // console.log(AllLi)
        }
    })

    第二个方法的逻辑是完全正确了。实现效果也是完美的。
    不过for循环比较怪。jquery嘛,应该用jquery的方法来实现。

    jquery 实战 第三回合

    /*
        FengWaterFall.beta3.js
        完美实现了瀑布流效果。jquery的each方法循环数组。但是被迫用了全局变量。
    */
    
    $(function(){
        var Obj = $("#waterfall"),
            Ul = Obj.children('ul'),
            Li = Ul.children('li');
        waterfall();
        $(window).resize(function(event) {
            waterfall();
        });
        function waterfall(){
            var WinW = $(window).width();
            var Blank = 20,                     // 每个图片之间的间隔留白
                LiW = 200+Blank,                // 一个图片距离上一个图片的宽度距离
                LiCol = parseInt(WinW/LiW),     // 计算在当前窗口下,有几列
                UlW = LiCol*LiW-Blank;          // 根据有几列,设定总的宽度(减掉最后一个留白)
            Ul.width(UlW);
    
            var AllLi = [];                     // 建立一个空数组变量
            Li.each(function(index, e){
                var T = $(this);
                if (index<LiCol) {                      // 第一行的处理
                    AllLi[index] = T.outerHeight();     // 给数组添加内容,为当前元素的高度值
                    T.css({
                        top: 0,
                        left: LiW*index+'px'
                    });
                } else{
                    var MinH = Math.min.apply(null,AllLi);      // 找到数组中,最小的那个值(也就是留白最大的)
    
                    // 通过each 循环数组的方式,找到索引
                    $.each(AllLi,function(index,value){
                        if (value == MinH) {
                            MinI = index;       // 因为 var 局部变量不能被用到下面去,所以用了全局变量
                        };
                    });
    
                    var ThisH = T.outerHeight()+Blank;          // 自身的高度加上留白
    
                    AllLi[MinI] = parseInt(MinH+ThisH);         // 将被占位的数组重新赋值
    
                    T.css({
                        top: MinH+Blank+'px',
                        left: LiW*MinI+'px'
                    });
                };
            });
    
            // console.log(AllLi)
        }
    })

    总结

    这时候,我去看了一下别人是怎么写的。结果发现整体思路如出一辙。但是其查找索引的用法比我用for或者each循环要简单可靠得多。不过我还没有弄懂到底是怎么运作的。所以,就不做搬运工了。

    展开全文
  • 新手小白学JAVA IO File 字节 字符

    万次阅读 多人点赞 2021-05-17 22:23:59
    在学习IO之前,我们首先需要学习的概念就是Stream 为了方便理解,我们可以把数据的读写操作抽象成数据在"管道"中流动,但需注意: 1.只能单方向流动 2.输入用来读取 → in 3.输出用来写出 → out 4.数据只能...

    IO简介

    1 流Stream

    在学习IO流之前,我们首先需要学习的概念就是Stream流
    为了方便理解,我们可以把数据的读写操作抽象成数据在"管道"中流动,但需注意:
    1.流只能单方向流动
    2.输入流用来读取 → in
    3.输出流用来写出 → out
    4.数据只能从头到尾顺序的读写一次
    所以以程序的角度来思考,In/out 相对于程序而言的输入(读取)/输出(写出)的过程.
    在这里插入图片描述

    2 IO流的继承结构

    在java中,根据处理的数据单位不同,可以把流分为字节流和字符流
    字节流 : 针对二进制文件
    字符流 : 针对文本文件,读写容易出现乱码的现象,在读写时,最好指定编码集为UTF-8
    在结合对应类型的输入和输出方向,常用的流有:

    File

    字节流:针对二进制文件

    InputStream

    FileInputStream
    BufferedInputStream
    ObjectInputStream

    OutputStream

    FileOutputStream
    BufferedOutputStream
    ObjectOutputStream

    字符流:针对文本文件

    Reader

    FileReader
    BufferedReader
    InputStreamReader

    Writer

    FileWriter
    BufferedWriter
    OutputStreamWriter
    PrintWriter一行行写出

    3 File文件类

    3.1概述

    封装一个磁盘路径字符串,对这个路径可以执行一次操作
    可以封装文件路径、文件夹路径、不存在的路径

    3.2创建对象

    File(String pathname)通过将给定路径名字符串转换为抽象路径名来创建一个新的File实例
    new File(“d:/abc/a.txt”);
    new File(“d:/abc”,”a.txt”);

    3.3常用方法

    在这里插入图片描述

    3.4 练习:测试常用方法

    创建包: cn.tedu.file
    创建类: TestFile.java

    package cn.tedu.file;
    
    import java.io.File;
    import java.io.IOException;
    import java.util.Arrays;
    
    /*本类用来测试文件类 File*/
    public class TestFile {
        public static void main(String[] args) throws IOException {
            //1.创建File文件对象
            /*1.构造函数的参数是String类型的pathname(路径名)
            * 这个路径可以是文件路径,也可以是文件夹路径*/
            /*2.\在代码中有特殊的意义,所以想要真正表示这是一个\,需要用\进行转义*/
            //注意:此处需要自己手动在D盘创建对应目录下的1.txt,并添加内容
            //注意:创建1.txt时,需要设置系统显示文件后缀名,如果没设置,文件名应该是1
            //注意:File需要导包:import java.io.File;
            File file = new File("D:\\ready\\1.txt");
    
            //2.测试常用方法
            //2.1文件与文件夹属性测试
            System.out.println(file.length());//12,获取指定文件的字节量大小
            System.out.println(file.exists());//true,判断指定文件是否存在
            System.out.println(file.isFile());//true,判断指定内容是否为文件
            System.out.println(file.isDirectory());//false,判断指定内容是否为文件夹
            System.out.println(file.getName());//1.txt,获取指定内容的名字
            System.out.println(file.getParent());//D:\ready,获取指定内容的上级
            System.out.println(file.getAbsolutePath());//D:\ready\1.txt,获取指定内容的绝对路径
    
            //2.2创建与删除
            file = new File("D:\\ready\\2.txt");
            /*如果指定创建文件的文件夹不存在,会报错:java.io.IOException
            * 系统找不到指定的路径,由于可能会发生异常,所以调用时需要抛出异常 */
            //在windows中创建不存在的文件2.txt,成功返回true
            System.out.println(file.createNewFile());//true
    
            file = new File("D:\\ready\\m");
            System.out.println(file.mkdir());//true,创建不存在的单层文件夹m
            file = new File("D:\\ready\\a\\b\\c");
            System.out.println(file.mkdirs());//true,创建不存在的多层文件夹a/b/c
    
            System.out.println(file.delete());//c被删除,删除文件或者空文件夹
            file  = new File("D:\\ready\\a");
            System.out.println(file.delete());//false,因为a目录里还有b目录
            file  = new File("D:\\ready\\2.txt");
            System.out.println(file.delete());//true,删除2.txt文件成功
    
            //2.3 文件列表测试
            file = new File("D:\\ready");
            String[] listName = file.list();
            System.out.println(Arrays.toString(listName));
    
            File[] fs = file.listFiles();
            System.out.println(Arrays.toString(fs));
            System.out.println(fs[0].length());
    
        }
    }
    
    

    4 字节流读取

    字节流是由字节组成的,字符流是由字符组成的.
    Java里字符由两个字节组成.字节流是基本流,主要用在处理二进制数据。
    所以字节流是比较常用的,可以可以处理多种不同种类的文件,比如文本文档/音频/视频等等

    4.1 InputStream抽象类

    此抽象类是表示字节输入流的所有类的超类/抽象类,不可创建对象哦

    常用方法:
    abstract int read() 从输入流中读取数据的下一个字节
    int read(byte[] b) 从输入流中读取一定数量的字节,并将其存储在缓冲区数组 b 中
    int read(byte[] b, int off, int len) 将输入流中最多 len 个数据字节读入 byte 数组,off表示存时的偏移量
    void close() 关闭此输入流并释放与该流关联的所有系统资源

    4.2 FileInputStream子类

    直接插在文件上,直接读取文件数据

    创建对象
    FileInputStream(File file)—直接传文件对象
    通过打开一个到实际文件的连接来创建一个 FileInputStream,该文件通过文件系统中的 File 对象 file 指定FileInputStream(String pathname)—传路径
    通过打开一个到实际文件的连接来创建一个 FileInputStream,该文件通过文件系统中的路径名 name 指定

    4.3 BufferedInputStream子类

    BufferedInputStream 为另一个输入流添加一些功能,在创建BufferedInputStream 时,会创建一个内部缓冲区数组(默认8k大小)。在读取或跳过流中的字节时,可根据需要从包含的输入流再次填充该内部缓冲区,一次填充多个字节。

    创建对象
    BufferedInputStream(InputStream in)
    创建一个 BufferedInputStream 并保存其参数,即输入流 in,以便将来使用。

    4.4 练习:字节流读取案例

    创建包: cn.tedu.file
    创建类: TestIn.java

    package cn.tedu.file;
    
    import java.io.*;
    
    /*本类用于练习字节输入流*/
    public class TestIn {
        public static void main(String[] args) {
            //method();//字节流的读取
            method2();//高效字节流的读取
        }
    
        //本方法用于测试高效字节流的读取
        private static void method2() {
            //定义一个在本方法中都生效的局部变量in,注意手动初始化,值为null
            InputStream in = null;
            try {
                //1.创建高效字节输入流对象
    //            InputStream in = new BufferedInputStream(
    //                    new FileInputStream(new File("E:\\ready\\1.txt")));
                  in = new BufferedInputStream
                          (new FileInputStream("E:\\ready\\1.txt"));
                //2.使用流进行读取
                int b;
                while ((b= in.read())!= -1){
                    System.out.println(b);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }finally {//关流操作写在finally{}中
                //3.流用完以后一定要关闭!!!
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
    
        }
    
        //本方法用于测试字节流的读取
        private static void method() {
            //创建一个在本方法都生效的局部变量注意手动初始化
            InputStream in = null;
            try {
                //1.创建字节输入流对象用于读取
                //InputStream in = new InputStream();//报错原因:抽象类不可实例化
                //InputStream in = new FileInputStream(new File("E:\\ready\\1.txt"));
                in = new FileInputStream("E:\\ready\\1.txt");
                //2.开始读取
                /*read()每次调用都会读取一个字节,如果读到了数据的末尾,返回-1*/
    //            System.out.println(in.read());
    //            System.out.println(in.read());
    //            System.out.println(in.read());
    //            System.out.println(in.read());
                //需求:需要循环读取文件中的所有内容,直至读完
                //定义变量,记录读到的数据
                int b;
                while((b=in.read())!= -1){
                    System.out.println(b);
                }
            } catch (Exception e) {
                e.printStackTrace();//打印错误信息
            /*try-catch结构中的第三个部分:finally{}
            * 这部分不论是否捕获到异常,是一定会被执行到的代码,常用于关流*/
            }finally {
                try {
                    //3.释放资源,流资源用完必须释放!!!
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    

    5 字符流读取

    常用于处理纯文本数据

    5.1 Reader抽象类

    用于读取字符流的抽象类。

    常用方法:
    int read() 读取单个字符
    int read(char[] cbuf) 将字符读入数组
    abstract int read(char[] cbuf, int off, int len) 将字符读入数组的某一部分
    int read(CharBuffer target) 试图将字符读入指定的字符缓冲区
    abstract void close() 关闭该流并释放与之关联的所有资源

    5.2 FileReader子类

    用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值,可以先在 FileInputStream 上构造一个 InputStreamReader。

    创建对象
    FileReader(String fileName) 在给定从中读取数据的文件名的情况下创建一个新 FileReader
    FileReader(File file) 在给定从中读取数据的 File 的情况下创建一个新 FileReader

    5.3 BufferedReader子类

    从字符输入流中读取文本,缓冲各个字符,从而实现字符、数组和行的高效读取。
    可以指定缓冲区的大小,或者可使用默认的大小。大多数情况下,默认值就足够大了。

    创建对象
    BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流

    5.4 练习:字符流读取案例

    创建包: cn.tedu.file
    创建类: TestIn2.java

    package cn.tedu.file;
    
    import java.io.*;
    
    /*本类用于测试字符流的读取*/
    public class TestIn2 {
        public static void main(String[] args) {
            //method();//测试普通字符输入流
            method2();//测试高效字符输入流
        }
        //创建一个用于测试高效字符输入流的方法
        private static void method2() {
            //1.定义一个在本方法都生效的局部变量,手动初始化值null
            Reader in=null;
            try{
                //1.创建高效字符读取流对象
                //in = new BufferedReader(new FileReader(new File("E:\\ready\\1.txt")));
                in = new BufferedReader(new FileReader("E:\\ready\\1.txt"));
                //2.使用流对象
                int b;
                while((b=in.read())!=-1){
                    System.out.println(b);
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                //3.关闭流对象
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        //创建一个用于测试普通字符输入流的方法
        private static void method() {
            //1.1创建一个在本方法中都生效的局部变量,注意初始化值null
            Reader in = null;
            try {
                //1.2创建字符输入流对象,注意需要捕获异常
                //Reader in = new Reader();//报错原因:抽象父级不可实例化
                //in = new FileReader(new File("E:\\ready\\1.txt"));
                in = new FileReader("E:\\ready\\1.txt");
                //2.使用流对象
                //System.out.println(in.read());
                //需求:循环读取文件中的所有内容,只要不是-1,就说明还有数据,继续读取
                //3.1定义变量,记录读取到的数据
                int b;
                while((b = in.read())!= -1){
                    System.out.println(b);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {//3.关流
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    

    6 字节流写出

    6.1 OutputStream抽象类

    此抽象类是表示输出字节流的所有类的超类.输出流接受输出字节并将这些字节发送到某个接收器.

    常用方法:
    Void close() 关闭此输出流并释放与此流相关的所有系统资源
    Void flush() 刷新此输出流并强制写出所有缓冲的输出字节
    Void write(byte[ ] b) 将b.length个字节从指定的byte数组写入此输出流
    Void write(byte[ ] b,int off ,int len) 将指定byte数组中从偏移量off开始的len个字节写入输出流
    Abstract void write(int b) 将指定的字节写入此输出流

    6.2 FileOutputStream 子类

    直接插在文件上,直接写出文件数据

    构造方法(创建对象):
    FileOutputStream(String name)
    创建一个向具有指定名称的文件中写入数据的文件输出流
    FileOutStream(File file)
    创建一个向指定File对象表示的文件中写入数据的文件输出流
    FileOutStream(File file,boolean append)—如果第二个参数为true,表示追加,不覆盖
    创建一个向指定File对象表示的文件中写入数据的文件输出流,后面的参数是指是否覆盖原文件内容

    6.3 BufferedOutputstream 子类

    该类实现缓冲的输出流,通过设置这种输出流,应用程序就可以将各个字节写入底层输出流中,而不必每次针对字节写出调用底层系统

    构造方法(创建对象):
    BufferedOutputStream(OutputStream out)
    创建一个新的缓冲输出流,用以将数据写入指定的底层输出流

    6.4 练习: 字节输出流测试:

    创建包: cn.tedu.file
    创建类: TestOut.java

    package cn.tedu.file;
    
    import java.io.*;
    
    /*本类用于测试字节输出流*/
    public class TestOut {
        public static void main(String[] args) {
            method();//用于测试普通字节输出流
            //method2();//用于测试高效字节输出流
        }
        //创建一个用于测试高效字节输出流的方法
        private static void method2() {
            //1.创建一个在本方法都生效的局部变量,注意手动初始化
            OutputStream out = null;
            try{
                //2.创建高效字节输出流对象
    //          out = new BufferedOutputStream(new FileOutputStream(new File("E:\\ready\\2.txt")));
                out = new BufferedOutputStream(new FileOutputStream("E:\\ready\\2.txt"));
                //3.使用流对象--进行写出操作
                out.write(97);
                out.write(97);
                out.write(97);
            }catch (Exception e){
                e.printStackTrace();
            }finally {//关流操作要放在finally{}中
                try {
                    //4.关流
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        //创建一个用于测试普通字节输出流的方法
        private static void method() {
            //1.创建一个在本方法中都生效的局部变量,注意手动初始化null
            OutputStream out = null;
            //2.创建try-catch-finally结构,因为IO操作可能会产生异常
            try{
                //3.创建普通字节输出流对象
                //out = new FileOutputStream(new File("E:\\ready\\2.txt"));
                //out = new FileOutputStream("E:\\ready\\2.txt");
                out = new FileOutputStream("E:\\ready\\2.txt",true);
                //4.使用流对象--进行写出操作
                out.write(99);//对应ASCII码表中的a
                out.write(99);//对应ASCII码表中的b
                out.write(99);//对应ASCII码表中的c
            }catch (Exception e){
                e.printStackTrace();
            }finally {//如果想要代码一定会执行,需要写在finally中
                try {
                    //5.关流操作
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    

    7 字符流写出

    7.1 Writer 抽象类

    写入字符流的抽象类

    常用方法:
    Abstract void close() 关闭此流,但要先刷新它
    Void write(char[ ] cbuf) 写入字符数组
    Void write(int c) 写入单个字符
    Void write(String str) 写入字符串
    Void write(String str,int off,int len) 写入字符串的某一部分
    Abstract void write(char[] cbuf,int off,int len)写入字符数组的某一部分

    7.2 FileWriter 子类

    用来写入字符文件的便捷类,此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的.如果需要自己自定义这些值,可以先在FileOutputStream上构造一个OutputStreamWriter.

    构造方法(创建对象):
    FileWriter(String filename)
    根据给定的文件名构造一个FileWriter对象
    FileWriter(String filename,boolean append)
    根据给定的文件名以及指示是否附加写入数据的boolean值来构造FileWriter

    7.3 BufferedWriter子类

    将文本写入字符输出流,缓冲各个字符,从而提供单个字符,数组和字符串的高效写入.可以指定缓冲区的大小,或者接受默认的大小,在大多数情况下,默认值就足够大了

    构造方法(创建对象):
    BufferedWriter(Writer out)
    创建一个使用默认大小输出缓冲区的缓冲字符输出流

    7.4 练习: 字符输出流测试:

    创建包: cn.tedu.file
    创建类: TestOut2.java

    package cn.tedu.file;
    
    import java.io.*;
    
    /*本类用于测试字符输出流*/
    public class TestOut2 {
        public static void main(String[] args) {
            //method();//用于测试普通字符输出流
            method2();//用于测试高效字符输出流
        }
        //创建一个用于测试高效字符输出流的方法
        private static void method2() {
            //1.创建一个在本方法都生效的局部变量,值为null,注意手动初始化!!!
            Writer out = null;
            //2.由于程序可能会抛出异常,所以需要写一个try-catch-finally结构
            try{//存放可能会抛出异常的代码
                //3.创建普通字符输出流对象
                //out = new BufferedWriter(new FileWriter(new File("E:\\ready\\2.txt")));
                //out = new BufferedWriter(new FileWriter("E:\\ready\\2.txt"));
                out = new BufferedWriter(new FileWriter("E:\\ready\\2.txt",true));
                //4.使用流对象
                out.write(100);
                out.write(100);
                out.write(100);
                out.write(100);
                out.write(100);
            }catch (Exception e){//匹配并捕获异常
                e.printStackTrace();//如果捕获到异常就打印错误信息
            }finally {//一定会被执行到的代码块,常用于关流
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        //创建一个用于测试普通字符输出流的方法
        private static void method() {
            //1.创建一个在本方法都生效的局部变量,值为null,注意手动初始化!!!
            Writer out = null;
            //2.由于程序可能会抛出异常,所以需要写一个try-catch-finally结构
            try{//存放可能会抛出异常的代码
                //3.创建普通字符输出流对象
                //out = new FileWriter(new File("E:\\ready\\2.txt"));
                //out = new FileWriter("E:\\ready\\2.txt");
                out = new FileWriter("E:\\ready\\2.txt",true);
                //4.使用流对象
                out.write(98);
                out.write(98);
                out.write(98);
                out.write(98);
            }catch (Exception e){//匹配并捕获异常
                e.printStackTrace();//如果捕获到异常就打印错误信息
            }finally {//一定会被执行到的代码块,常用于关流
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    

    8 拓展

    通过学习以上的几种流,我们也可以拓展尝试做下文件的复制:
    创建包: cn.tedu.file
    创建类: TestCopyFile.java

    package cn.tedu.file;
    
    import java.io.*;
    import java.util.Scanner;
    
    /*本类用于拓展练习,文件复制案例*/
    public class TestCopyFile {
        public static void main(String[] args) {
            //1.提示并接收用户输入的源文件路径和目标位置路径
            System.out.println("请输入源文件路径:");
            String f = new Scanner(System.in).nextLine();//--复制啥
            System.out.println("请输入目标文件路径:");
            String t = new Scanner(System.in).nextLine();//--复制到哪
    
            //2.调用使用字符流复制文件的方法,传入刚刚接收到的两个参数
            //ZFCopy(f,t);
            //3.调用使用字节流复制文件的方法,传入刚刚接收到的两个参数
            ZJCopy(f,t);
        }
        //创建一个使用字节流复制文件的方法,注意两个参数
        private static void ZJCopy(String f, String t) {
            //1.定义在整个方法都生效的局部变量,注意手动初始化,值为null
            InputStream in = null;
            OutputStream out = null;
            //2.由于代码可能会抛出异常,所以需要完成try-catch-finally结构
            try{
                //3.1创建一个高效字节输入流,传入的参数是目标文件的路径
                in = new BufferedInputStream(new FileInputStream(f));
                //3.2创建一个高效字节输出流,传入的参数是目标文件复制到哪的路径
                out = new BufferedOutputStream(new FileOutputStream(t));
    
                //4.拿到流对象以后就可以做具体业务操作了
                //4.1定义变量用来记录读到的数据
                int b ;
                //4.2使用循环读取目标文件,直到返回值为-1,没有数据时循环结束
                while((b = in.read())!=-1){//读取源文件的内容
                    out.write(b);//将本次循环读到的内容写出到指定位置的文件中
                }
                System.out.println("恭喜您!文件复制成功!");
            }catch(Exception e){
                System.out.println("很抱歉!文件复制失败!");
                e.printStackTrace();
            }finally {//一定会被执行到的代码需要放在finally中,比如关流操作
                /*关流是有顺序的:如果有多个流,最后创建的流最先关闭
                 * 多条关流语句需要各自try-catch*/
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
        //创建一个使用字符流复制文件的方法,注意:复制需要两个流对象
        private static void ZFCopy(String f, String t) {
            //1.定义在整个方法都生效的局部变量,注意手动初始化,值为null
            Reader in = null;
            Writer out = null;
            //2.由于代码可能会抛出异常,所以需要完成try-catch-finally结构
            try{
                //3.1创建一个高效字符输入流,传入的参数是目标文件的路径
                in = new BufferedReader(new FileReader(f));
                //3.2创建一个高效字符输出流,传入的参数是目标文件复制到哪的路径
                out = new BufferedWriter(new FileWriter(t));
    
                //4.拿到流对象以后就可以做具体业务操作了
                //4.1定义变量用来记录读到的数据
                int b ;
                //4.2使用循环读取目标文件,直到返回值为-1,没有数据时循环结束
                while((b = in.read())!=-1){//读取源文件的内容
                    out.write(b);//将本次循环读到的内容写出到指定位置的文件中
                }
                System.out.println("恭喜您!文件复制成功!");
            }catch(Exception e){
                System.out.println("很抱歉!文件复制失败!");
                e.printStackTrace();
            }finally {//一定会被执行到的代码需要放在finally中,比如关流操作
                /*关流是有顺序的:如果有多个流,最后创建的流最先关闭
                * 多条关流语句需要各自try-catch*/
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    

    9 总结:IO的继承结构

    1.主流分类

    1. 按照方向进行分类:输入流 输出流(相对于程序而言,从程序写数据到文件中是输出)
    2. 按照传输类型进行分类:字节流 字符流
    3. 组合: 字节输入流 字节输出流 字符输入流 字符输出流

    2.学习方法:在抽象父类中学习通用的方法,在子类中学习如何创建对象
    3.字节输入流:

    InputStream 抽象类,不能new,可以作为超类,学习其所提供的共性方法
    --FileInputStream 子类,操作文件的字节输入流,普通类
    --BufferedInputStream 子类,缓冲字节输入流,普通类
    

    4.字符输入流

    Reader 抽象类,不能new,可以作为超类,学习其所提供的共性方法
    --FileReader,子类,操作文件的字符输入流,普通类
    --BufferedReader,子类,缓冲字符输入流,普通类
    

    5.字节输出流:

    OutputStream 抽象类,不能new,可以作为超类,学习其所提供的共性方法
    --FileOutputStream 子类,操作文件的字节输出流,普通类
    --BufferedOutputStream 子类,缓冲字节输出流,普通类
    

    6.字符输出流

    Writer 抽象类,不能new,可以作为超类,学习其所提供的共性方法
    --FileWriter,子类,操作文件的字符输出流,普通类
    --BufferedWriter,子类,缓冲字符输出流,普通类
    
    展开全文
  •  在媒体项目中经常遇到需要自己搭建个实时视频rtsp地址,虽然网上有现成的,但总是有这样那样的问题导致不是很方便或者效率不理想。 2. 正题: (1)下载一个MP4的文件,当然没有的话,随便什么格式都可以,...
  • 电商系统如何制作自己的数据DFD图

    千次阅读 多人点赞 2019-02-18 16:30:55
    电商系统如何制作自己的数据DFD图   最近,要做一些系统分析,用数据的逻辑角度去理解系统,因此需要制作一个数据图。   制作这个图时,主要的障碍是,在制作过程中,很容易,把一些控制都考虑在里面。 ...
  • 是这样的:我想写个媒体服务器,把下载下来的视频缓存,同时开放端口播放器从缓存中读取媒体数据进行播放.但不太清楚这个原理是怎么实现的,怎么管理缓存中下载下来的媒体数据,一边下载,一边播放,缓存中已播放的数据...
  • 从Sharepoint 2007开始,工作作为一个真正的强有力的工具内置在SharePoint中。你可以通过设计工作,从而在网站或应用程序中添加自定义逻辑,而且不需要编写任何...本文将讨论如何能够非常容易地开发属于自己的Sha
  • 前言介绍如何搭建自己媒体服务器,并逐步实现客户端和服务器之间的通信。本文属于第一篇介绍如何搭建媒体服务器。媒体服务器开源的媒体服务器有很多,本文使用开源媒体解决方案live555。1. live555简介...
  • Java 字节 字符 转换

    万次阅读 2015-05-10 13:55:16
    我们知道Java中的分为字符和字节,其中字符主要针对字符文本进行处理,而字节处理范围更为广泛,毕竟图片、电影等只要是文件都是以二进制的形式存在的,而不是字符。 字符: FileReader FileWriter。 ...
  • 按官方说法:Oozie是一个基于工作引擎的服务器,其中每个工作的任务可以是Hadoop的Map/Reduce作业或者Pig作业等。Oozie是运行于Java servlet容器上的一个java web应用。Oozie的目的是按照DAG(有向无环图)调度...
  • 打造自己媒体服务器:安装Helix快速学习作者:heiyeluren博客:http://blog.csdn.net/heiyehuwu时间:2006-11-04Helix是Real Network公司开发的媒体服务器软件,能够运行在 Linux/FreeBSD/Windows 等平台上面...
  • EasyNVR媒体解决方案 EasyNVR能够通过简单的网络摄像机通道配置,将传统监控行业里面的高清网络摄像机IP Camera、NVR等具有RTSP协议输出的设备接入到EasyNVR,EasyNVR能够将这些视频源的音视频数据进行拉取,转换...
  • 媒体是将视频文件通过媒体服务器转换...不明白的是 媒体服务器将视频文件转换成的自己用代码直接读取视频文件的文件有什么区别么? 直接用IO操作视频文件读取的 然后再用socket发送出去,是媒体么?
  • Kafka数据让流处理更轻松

    千次阅读 2016-03-16 17:53:58
    Kafka Streams是一个使用Apache Kafka用于构建分布处理应用的Java库。这将是即将更新Kafka-0.10版本的一部分,并且已经提供可以很容易试用的预览版。   使用Kafka Stream构建一个处理应用如下所示:   ...
  • RTSP为取协议,取到码后需要解码显示,可以通过VLC播放器或者EasyPlayer播放器进行测试,IE等浏览器网页不支持RTSP协议直接取预览或者回放,需要安装OCX插件,这也是目前大部分安防厂家的做法。 目前也有很...
  • 1.自己动手写RTP服务器——关于RTP协议 ...2.自己动手写RTP服务器——用RTP协议传输TS http://www.cnblogs.com/lidabo/p/4160145.html 3.自己动手写RTP服务器——传输所有格式的视频 http://www.cnblogs
  • 下面就是代码的实现,如果通过自己实现的子类是实现文件的播放。 主要实现两个子类即可:FramedSource 和 FileServerMediaSubsession。Subsession来建立任务,Source获取视频源数据,然后susession新建rtpsink来...
  • Java

    千次阅读 热门讨论 2014-04-18 16:22:59
    是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象。即数据在两设备间的传输称为的本质是数据传输,根据数据传输特性将抽象为各种类,方便更直观的进行数据操作。 的分类:  数据类型...
  • 自学成才篇:字节和字符

    万次阅读 2016-02-14 15:34:20
    年假结束了,看着笔记小结一下字节和字符。 1.InputStream和OutputStream都是抽象类,分别表示字节输入和输出的所有类的超类。   2.Reader、Writer都是抽象类,用于字符的操作。 InputStreamReader...
  • 因为公司任务需要做一个直播的系统,经过一段时间的研究,和方便以后捡起来所以把这个写了下来 下载windows版本的nginx http://nginx-win.ecsds.eu/download/nginx 1.7.11.3 Gryphon.zip 解压到c盘,最好把...
  • 控制和数据

    万次阅读 2018-03-06 00:04:48
    数据 数据——描述程序运行过程中数据的流转方式及其行为状态 在MVC模型中,Model层的本质就是“数据”,数据在MVC的各个构成要素中流转并且在不同的层次扮演着不同的角色。当程序运行起来之后,我们会发现...
  • TS解析【PCR】自己的总结

    千次阅读 2018-08-30 18:19:49
    有的时候PCR的PID跟音频或者视频的PID相同,说明PCR会融进音视频的包,注意解析,有的时候PCR是自己单独的包;CAT、NIT、SDT、EIT的PID分别为: 0x01、0x10、0x11、0x12 。   PSI被分为4个表结构,他们应被...
  •  其中有面向用户的自定义工作设计器的代码包 都是第三方开发的 熟悉FLEX和JS的朋友可以用这些模块自己定制一个面向最终用户的设计器  当实现了流程设计器之后,就需要把设计器产生的XML文件解析到数据库中...
  • 杂谈——探秘字节与字符

    千次阅读 2018-12-02 19:58:05
    而程序中的所有数据,自然也有它自己。(哈哈,强行押韵最为致命 ヽ(✿゚▽゚)ノ) 今天我们要认识的就是字节和字符这两个小兔崽子。 想要认识它们,我们就得先获得“”这本秘籍,去看看“”到底是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,314,206
精华内容 525,682
关键字:

如何让自己流