精华内容
下载资源
问答
  • JAVA:IO流 之 节点流与处理流(2)

    万次阅读 多人点赞 2017-05-15 15:37:24
    1. 流的分类 按数据流的方向不同:输入流,输出流。...按功能不同:节点流,处理流。 (1)程序用于直接操作目标设备所对应的类叫节点流。 (2)程序通过一个间接流类去调用节点流类,以达到更加灵活方...

    微信扫一扫关注该公众号
    在这里插入图片描述

    #1. 流的分类

    • 按数据流的方向不同:输入流,输出流。

    • 按处理数据单位不同:字节流,字符流。
      (1) 字节流:数据流中最小的数据单元是字节。
      (2)字符流:数据流中最小的数据单元是字符, Java中的字符是Unicode编码,一个字符占用两个字节。

    • 按功能不同:节点流,处理流。
      (1)程序用于直接操作目标设备所对应的类叫节点流。
      (2)程序通过一个间接流类去调用节点流类,以达到更加灵活方便地读写各种类型的数据,这个间接流类就是处理流。
      #2. 节点流
      ##2.1 节点流的类型
      这里写图片描述

    • (1)File 文件流。对文件进行读、写操作 :FileReader、FileWriter、FileInputStream、FileOutputStream。、

    • (2)Memory
      1)从/向内存数组读写数据: CharArrayReader与 CharArrayWriter、ByteArrayInputStream与ByteArrayOutputStream。
      2)从/向内存字符串读写数据 StringReader、StringWriter、StringBufferInputStream。

    • (3)Pipe管道流。 实现管道的输入和输出(进程间通信): PipedReader与PipedWriter、PipedInputStream与PipedOutputStream。
      ##2.2 节点流执行的图示
      这里写图片描述
      #3. 处理流
      ##3.1 处理流的类型
      这里写图片描述

    • (1)Buffering缓冲流:在读入或写出时,对数据进行缓存,以减少I/O的次数:BufferedReader与BufferedWriter、BufferedInputStream与BufferedOutputStream。

    • (2)Filtering 滤流:在数据进行读或写时进行过滤:FilterReader与FilterWriter、FilterInputStream与FilterOutputStream。

    • (3)Converting between Bytes and Characters 转换流:按照一定的编码/解码标准将字节流转换为字符流,或进行反向转换(Stream到Reader):InputStreamReader、OutputStreamWriter。

    • (4)Object Serialization 对象流 :ObjectInputStream、ObjectOutputStream。

    • (5)DataConversion数据流: 按基本数据类型读、写(处理的数据是Java的基本类型(如布尔型,字节,整数和浮点数)):DataInputStream、DataOutputStream 。

    • (6)Counting计数流: 在读入数据时对行记数 :LineNumberReader、LineNumberInputStream。

    • (7)Peeking Ahead预读流: 通过缓存机制,进行预读 :PushbackReader、PushbackInputStream。

    • (8)Printing打印流: 包含方便的打印方法 :PrintWriter、PrintStream。
      ##3.2 处理流执行的图示
      这里写图片描述
      ##3.3 缓冲流

    • 【1】对I/O进行缓冲是一种常见的性能优化,缓冲流为I/O流增加了内存缓冲区,增加缓冲区的两个目的:
      (1)允许Java的I/O一次不只操作一个字符,这样提高䇖整个系统的性能;
      (2)由于有缓冲区,使得在流上执行skip、mark和reset方法都成为可能。

    • 【2】缓冲流:它是要“套接”在相应的节点流之上,对读写的数据提供了缓冲的功能,
      提高了读写的效率,同时增加了一些新的方法。例如:BufferedReader中的readLine方法,
      BufferedWriter中的newLine方法。

    • 【3】J2SDK提供了4种缓存流,常用的构造方法为:

    //字符输入流
    BufferedReader(Reader in)//创建一个32字节的缓冲区
    BufferedReader(Reader in, int size)//size为自定义缓存区的大小
    
    //字符输出流
    BufferedWriter(Writer out)
    BufferedWriter(Writer out, int size)
    
    //字节输入流
    BufferedInputStream(InputStream in)
    BufferedInputStream(InputStream in, int size)
    
    //字节输出流
    BufferedOutputStream(OutputStream in)
    BufferedOutputStream(OutputStream in, int size)
    
    • 【4】其他
      (1)缓冲输入流BufferedInputSTream除了支持read和skip方法意外,还支持其父类的mark和reset方法;
      (2)BufferedReader提供了一种新的ReadLine方法用于读取一行字符串(以\r或\n分隔);
      (3)BufferedWriter提供了一种新的newLine方法用于写入一个行分隔符;
      (4)对于输出的缓冲流,BufferedWriter和BufferedOutputStream,写出的数据会先在内存中缓存,
      使用flush方法将会使内存的数据立刻写出。

    • 示例1:

    import java.io.*;
    public class TestBufferStream1 {
      public static void main(String[] args) {
        try {
          FileInputStream fis = new FileInputStream(
    		  "d:\\JavaProject\\demo13\\ProcessingStream\\TestBufferStream1.java");
          BufferedInputStream bis = new BufferedInputStream(fis);
          int c = 0;
          System.out.println((char)bis.read());
          System.out.println((char)bis.read());
          bis.mark(100);/*在当前输入流的当前位置上做一个标志,允许最多再读入100个字节*/
          for(int i=0;i<=10 && (c=bis.read())!=-1;i++){
            System.out.print((char)c+" ");
          }
          System.out.println(); 
          bis.reset();/*把输入指针返回到以前所做的标志处*/
          for(int i=0;i<=10 && (c=bis.read())!=-1;i++){
            System.out.print((char)c+" ");
          }
          bis.close();
        } catch (IOException e) {e.printStackTrace();}
      }
    }
    
    • 示例2:
    import java.io.*;
    public class TestBufferStream2
    {
    	public static void main(String[] args)
    	{
    	try{
    	BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\JavaProject\\demo13\\BufferStream\\dat2.txt"));
    	BufferedReader br = new BufferedReader(new FileReader("D:\\JavaProject\\demo13\\BufferStream\\dat2.txt"));
    	String s = null;
    	for(int i=0;i<10;i++)
    	{
    		s = String.valueOf(Math.random());//产生一个小于1的正的随机数,并转换成字符串形式
    		bw.write(s);//把字符串s写入到dat2.txt文件中
    		bw.newLine();//写入一个行分隔符
    	}
    	bw.flush();//使用flush方法将会使内存的数据立刻写出
    
    	while((s=br.readLine()) != null)
    	{
    		System.out.println(s);
    	}
    	bw.close();
    	br.close();
    	}
    	catch(IOException e)
    	{
    		e.printStackTrace();
    	}
    
    	}
    }
    

    ##3.4 转换流

    • 转换流有两种:
      (1)InputStreamReader:将字节流转换为字符流;
      (2)OutputStreamWriter:将字符流转换为字节流。
    • 什么时候使用转换流?由以下分析: 流对象很多,就要明确使用哪个流对象。
    通过三点来完成: 
    	1、明确数据的来源和数据到达的目的地。
    	             来源:输入流 [InputStream,Reader]。 
    	             目的:输出流 [OutputStream,Writer]。 
    	2、操作的数据是否是纯文本。  
    	             是:字符流,使用Reader与Writer; 
    	             否:字节流,使用InputStream与OutputStream。 
    	3、明确要使用哪个具体的对象。 通过设备来进行区分: 
    	             源设备:内存用数组,硬盘就加file,键盘用System.in; 
    	             目的设备:内存用数组,硬盘就加file,键盘用System.out。 
    	4、明确是否还需要其他额外功能:例如 
    	            (1)是否需要较高的效率,即是否需要使用缓冲区,是就加上Buffered;
    	            (2)是否需要转换,是,就使用转换流,InputStreamReader 和 OutputStreamWriter。
    
    • 用一个例子简单的说明: 将键盘录入的数据保存到一个文件中,输入“over”时表示录入结束。 详细分析:
    源:从InputStream,Reader中选择; 因为是键盘录入的是纯文本,所以使用Reader。 
    设备:键盘,所以用System.in; 发现System.in是字节流的操作,与Reader(字符流)矛盾,
    这时就要用到转换流 InputStreamReader 。为了提高操作效率,使用缓冲技术,选择BufferedReader。 
    
    目的:从 OutputStream,Writer中选择。 因为是文本文件,所以选择Writer。 
    设备:硬盘上,一个文件,选择FileWriter。 为了提高操作效率,使用缓冲技术,选择BufferedWriter。 
    
    • 示例1:
    import java.io.*; 
    	class ReadinFile 
    		{ 
    			public static void main(String[] args)throws IOException //这里为了方便阅读,先不做异常处理。 
    			{ 
    				BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in)); 
    				BufferedWriter bufw=new BufferedWriter(new FileWriter("readin.txt")); 
    				String line=null; 
    				while((line=bufr.readLine())!=null) 
    				{ 
    					if("over".equals(line)) break; 
    					bufw.write(line); 
    					bufw.newLine(); 
    				} 
    				bufw.close(); 
    				bufr.close(); 
    			} 
    		}
    
    • 示例2:
    import java.io.*;
    public class TestTransForm 
    {
    	public static void main(String[] args) throws IOException //这里为了方便阅读,先不做异常处理。 
    	{
    		InputStreamReader isr = new InputStreamReader(System.in);
    		BufferedReader br = new BufferedReader(isr);
    		OutputStreamWriter osw = new OutputStreamWriter(
    			                     new FileOutputStream("D:\\JavaProject\\demo13\\TransStream\\TransForm.txt",true));
    		BufferedWriter bw = new BufferedWriter(osw);
    		String str = null;
    		str = br.readLine();
    		while(str != null)
    		{
    			if(str.equalsIgnoreCase("exit")) break;
    			bw.write(str);
    			bw.newLine();
    			str = br.readLine();
    		}
    		br.close();
    		bw.close();
    	}
    }
    
    • 注意:
      (1)构造方法:public FileOutputStream(String name,boolean append) throws FileNotFoundException
      如果append为True,输出字节流就写入文件的末尾,而不是开头(覆盖原来的内容);
      如果append为False,输出字节流就写入文件的开头,即覆盖原来的内容从文件开始处写内容。
      (2)构造方法:public FileOutputStream(String name) throws FileNotFoundException
      每次覆盖原文件的内容,从文件开始处写内容。

    ##3.5 数据流——数据的存储和数据恢复

    • 数据流:DataInputStream和DataOutputStream
      (0)DataInputStream和DataOutputStream是面向字节的,因此要使用InputStream和OutputStream。
      (1)DataInputStream和DataOutputStream分别继承InputStream和OutputStream,
      它们属于处理流,需要分别“套接”在InputStream和OutputStream类型的节点流上。
      (2)DataInputStream和DataOutputStream提供了可以存取与机器无关的Java原始类数据(如:int,double等)的方法。
      (3)DataInputStream和DataOutputStream的构造方法:
         DataInputStream(InputStream in)
    	 DataOutputStream(OutputStream out)
    
    • 示例1:
    import java.io.*;
    public class TestDataStream
    {
    	public static void main(String[] args) throws IOException
    	{
    		FileOutputStream fout = new FileOutputStream("D:/JavaProject/demo13_IO/DataStream/demo.txt",true);
    	    BufferedOutputStream bout = new BufferedOutputStream(fout);
    	    DataOutputStream dout = new DataOutputStream(bout);
    		/*DataOutputStream,BufferedOutputStream,FileOutputStream这里使用了流栈。*/
    
    	    dout.writeInt(110);
    	    dout.writeUTF("hello,中国");
    	    dout.writeFloat(3.14f);
    	    dout.writeChar(97);/*97对应的是'a'*/
            dout.close();/*如果正在使用一个流栈,程序关闭最上面的一个流也就自动的关闭了栈中的所有底层流。*/
    		
    		FileInputStream fin = new FileInputStream("D:/JavaProject/demo13_IO/DataStream/demo.txt");
    		BufferedInputStream bin = new BufferedInputStream(fin);
    		DataInputStream din = new DataInputStream(bin);
    		
    		int i = din.readInt();
    		String str = din.readUTF();
    		float f = din.readFloat();
    		char c = din.readChar();
    		fin.close();/*如果正在使用一个流栈,程序关闭最上面的一个流也就自动的关闭了栈中的所有底层流。*/
            System.out.println("int:"+i+"\nString:"+str+"\nfloat:"+f+"\nchar:"+c);
    	}
    	
    }
    
    • 编译,运行:
    D:\JavaProject\demo13_IO\DataStream>javac TestDataStream.java
    
    D:\JavaProject\demo13_IO\DataStream>java TestDataStream
    int:110
    String:hello,中国
    float:3.14
    char:a
    
    • 注意:
            int i = din.readInt();
    		String str = din.readUTF();
    		float f = din.readFloat();
    		char c = din.readChar();
    		/*此段代码的顺序不能乱,要保证先写入的先读出来的原则,否则会出现错误。
    		*    因此,我们在写代码的时候,我们必须:
    		*         要么为文件中的数据采用固定的格式;
    		*         要么将额外的信息保存到文件中,以便能够对其进行解析以确定数据的寻访位置。
    		*/
    
    展开全文
  • 什么是节点流和处理流

    千次阅读 2018-11-18 18:01:53
    按照流是否直接与特定的地方(如磁盘、内存、设备等)相连,分为节点流和处理流两类。节点流:可以从或向一个特定的地方(节点)读写数据。如FileReader.处理流:是对一个已存在的流的连接和封装,通过所封装的流的功能...

    按照流是否直接与特定的地方(如磁盘、内存、设备等)相连,分为节点流和处理流两类。
    节点流:可以从或向一个特定的地方(节点)读写数据。如FileReader.
    处理流:是对一个已存在的流的连接和封装,通过所封装的流的功能调用实现数据读写。如BufferedReader.处理流的构造方法总                  是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装,称为流的链接。
    JAVA常用的节点流有以下几个:
    文 件 FileInputStream FileOutputStrean FileReader FileWriter 文件进行处理的节点流。
    字符串 StringReader StringWriter 对字符串进行处理的节点流。
    数 组 ByteArrayInputStream ByteArrayOutputStreamCharArrayReader CharArrayWriter 对数组进行处理的节点流(对应的不再是 文 件,而是内存中的一个数组)。
    管 道 PipedInputStream PipedOutputStream PipedReaderPipedWriter对管道进行处理的节点流。
    父 类 InputStream OutputStream Reader Writer
    常用处理流(关闭处理流使用关闭里面的节点流)
    缓冲流:BufferedInputStrean BufferedOutputStream BufferedReader BufferedWriter
    增加缓冲功能,避免频繁读写硬盘。
    转换流:InputStreamReader OutputStreamReader实现字节流和字符流之间的转换。
    数据流 DataInputStream DataOutputStream 等-提供将基础数据类型写入到文件中,或者读取出来。

    展开全文
  • 一、事件事件描述的是从页面接受事件的顺序,但是目前有两个概念...1、1事件冒泡这是IE的事件,即是事件从文档中嵌套最深的那个结点开始接受,然后依次传播到最为不具体的结点。;width: 200px ;height: 200px;">

    一、事件流

    事件流描述的是从页面接受事件的顺序,但是目前有两个概念,而且正好相反。IE的事件流是事件冒泡,Netscape Communicator的事件流是事件捕获。

    1、1事件冒泡

    这是IE的事件流,即是事件从文档中嵌套最深的那个结点开始接受,然后依次传播到最为不具体的结点。

    <div style="background-color: red;width: 200px ;height: 200px;">
        <div  style="background-color: yellow;width: 100px;height: 100px">
            click
        </div>
    </div>

    如上代码,则先接受到事件的是背景为yellow的div,其次才是red的那个div。事件顺序为:

    yellow div->red div ->body ->Element->Document

    1.2、事件捕获

    事件捕获则正好与事件冒泡相反,还是上面的代码,最先接受到事件的是

    Document->Element->body->red div -> yellow div

    1.3、DOM事件流

    “DOM2级事件”规定的事件流包括3个阶段:

    1. 事件捕获
    2. 处于目标阶段
    3. 事件冒泡阶段

      这第一个和第三个分别对应了前面介绍的两个,中间那个则是我们处理事件的时候。

    二、事件处理程序

    事件处理程序就是因用户或者浏览器自身执行的某种动作而响应的某个函数。

    2.1 HTML事件处理程序

    
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    <input type="button" value="点我" onclick="doSomeThing()">
    <script>
        function doSomeThing() {
            alert("do some thing")
        }
    </script>
    </body>
    </html>
    

    事件处理程序的代码在执行时,有权访问全局作用域中的任何代码。

    注意:上面指定事件处理程序会创建一个event变量。

    2.2、DOM0级事件处理

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    <input type="button" value="click me" id="btn">
    <script>
        var btn = document.getElementById("btn");
        btn.onclick = function () {
            alert("clicked");
        }
    </script>
    </body>
    </html>
    

    DOM0级方法指定的事件处理程序被认为是元素的方法,这个时候事件处理程序是在元素的作用域中运行,也就是说this指定是当前元素.
    这种方法添加的事件处理程序会在事件流的冒泡阶段被处理。

    // 删除DOM0级指定的事件处理程序
    btn.onclick = null 
    

    删除HTML事件将对应的onclick属性指定为null即可。

    2.3DOM2级事件处理程序

    DOM2级事件定义了两个方法

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    <input type="button" value="click me" id="btn">
    <script>
        var btn = document.getElementById("btn");
        btn.addEventListener("click", function () {
            alert("Hello");
        }, false);
        btn.addEventListener("click",function () {
            alert("World");
        },false);
    </script>
    </body>
    </html>
    

    与DOM0级不同的是,DOM2级主要好处是可以添加多个事件处理程序,事件触发按照它们添加的顺序。

    该方法的第三个bool值的参数为true:表示在捕获阶段调用事件处理程序,为false表示在冒泡阶段调用事件处理程序。

    这里添加的事件处理程序也是其衣服的元素的作用域中运行,和DOM级一样。

    // 删除事件处理
    btn.removeEventListener("click",fn);

    注意:这里的第二个参数必须是一个方法名,也就是说不能删除匿名函数的事件。

    2.4、IE事件处理程序

    IE中有两个和DOM类似的方法

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    <input type="button" value="click ie" id="btn">
    <script>
        var btn = document.getElementById("btn");
        btn.attachEvent("onclick", function () {
            alert("clicked");
        });
    
    </script>
    </body>
    </html>
    

    与DOM不同的是,IE事件处理的第一个参数是”onclick”而不是”click”.
    注意:使用attachEvent()方法,事件处理程序在全局作用域中运行,这里的this相当于window。

    和DOM2级类似,attachEvent方法也支持为一个元素添加多个事件处理。不过疑惑的是,这些事件的处理是按照添加顺序的相反执行的。

    2.5、跨浏览器的事件处理程序

    /**
     * Created by lw on 2017/1/26.
     */
    var EventUtil = {
        /**
         *  添加事件处理
         * @param element
         * @param type
         * @param handler
         */
        addHandler: function (element, type, handler) {
            if (element.addEventListener) { // 如果是Dom二级事件
                element.addEventListener(type, handler, false);
            } else if (element.attachEvent) { // 如果是IE事件处理
                element.attachEvent(type, handler);
            } else {
                element["on" + type] = handler; // dom0级
            }
        },
    
        /**
         * 移除事件处理
         * @param element
         * @param type
         * @param handler
         */
        removeHandler: function (element, type, handler) {
            if (element.removeEventListener) {
                element.removeEventListener(type, handler, false);
            } else if (element.detachEvent) { // 如果是IE事件处理
                element.detachEvent(type, handler);
            } else {
                element["on" + type] = null; // dom0级
            }
        }
    }
    

    当然,该工具类并不完善,例如前面提过的IE中事件处理的作用域的问题,不过使用其添加移除事件也足够了。

    展开全文
  • 什么是流处理流处理实现了什么效果) 流处理的设计思想 有哪些流处理技术并分析其优缺点、实用场景 具体在Spark Streaming上体现的优势不足 总结 转载:实时处理与流处理 ...

    转载自:实时处理与流处理 http://blog.csdn.net/dc_726/article/details/41143225
    正文:要说实时处理就得先提一下实时系统(Real-timeSystem)。所谓实时系统就是能在严格的时间限制内响应请求的系统。例如如果某系统能严格保证在10毫秒内处理来自网络的NASDAQ股票报价,那么这个系统就可以算作实时系统,至于系统是通过软件还是硬件或者通过怎样的设计达到的都不限。
    虽然看似简单,实际上现实世界中这种系统是很难实现的,尤其是软件实现的实时系统。因为你的进程可能随时被其他进程抢占,CPU调度器无法保证能给你的进程所需的时间和资源来在严格时间限制内完成响应。因此就有了各种实时操作系统内核。现实中实时系统的例子能想到的如军方的导弹控制系统和航天飞机等高精尖的软件系统了。
    那实时处理(Real-time Processingor Computing)又是什么?与实时系统类似,但软件工业中似乎对实时二字没有什么明确的定义。例如许多人说实时交易,实际上是因为市场数据瞬息万变,决策经常在毫秒间。一个软实时(Soft Real-time)的例子是Amazon要求所有软件子系统在处理99%的请求时,都能在100-200毫秒内要么给出结果要么立刻失败。
    说完实时处理再看流式处理(Stream Processing)。望文生义,流式处理就是指源源不断的数据流过系统时,系统能够不停地连续计算。所以流式处理没有什么严格的时间限制,数据从进入系统到出来结果可能是需要一段时间。然而流式处理唯一的限制是系统长期来看的输出速率应当快于或至少等于输入速率。否则的话,数据岂不是会在系统中越积越多(不然数据哪去了)?如此,不管处理时是在内存、闪存还是硬盘,早晚都会空间耗尽的。就像雪崩效应,系统越来越慢,数据越积越多。
    所以我们可以说Storm框架是一种流式处理系统的框架。如果我们的代码能够保证Storm的Topology中每个Bolt结点处理数据的时长一定,那么我们就相当于用Storm开发了一个(软)实时的系统。顺便提一句,又比如Spark这个主要是内存计算框架,在加入了Streaming Spark子项目后,能将数据流切分并转化成RDD进行后续计算,从而也支持了流式处理(否则之前Spark都是以固定的一坨数据为输入的)

    展开全文
  • ANSYS 有限元分析 后处理 结点解与单元解

    千次阅读 热门讨论 2020-07-07 10:57:38
      本文以如下图所示的悬臂梁为例,介绍 ANSYS 后处理中的结点解与单元解的主要区别。   悬臂梁长度为 60 mm,其横截面尺寸为 H×B = 10 mm × 6 mm。材料为钢材,牌号为 Q235B,其弹性模量为 200 Gpa,泊松比...
  • 实时处理与流处理

    万次阅读 2014-11-15 09:52:28
    偶然搜到一个不错的帖子,就总结一下实时处理和流式处理的区别吧。正文:要说实时处理就得先提一下实时系统(Real-timeSystem)。所谓实时系统就是能在严格的时间限制内响应请求的系统。例如如果某系统能严格保证在10...
  • 1. 的概念:  1) Java把所有设备中的有序数据抽象成,而(stream)就是指从源节点到目的节点的有序数据,而这里的节点就是存储节点;  2) 而上述只是一种对Java的的一种描述性概括,这里给出Java中流的...
  • Heron:Twitter的新一代流处理引擎

    千次阅读 2017-10-11 11:16:48
    计算又称实时计算,是继以Map-Reduce为代表的批处理之后的又一重要计算模型。随着互联网业务的发展以及...相比于传统的批处理计算,计算具有低延迟、高响应、持续处理的特点。在数据产生的同时,就可以进行计...
  • Storm数据处理

    千次阅读 2019-01-04 15:37:48
    目录 ####何为流处理 参考Streaming Systems - Tyler Akidau.pdf这样一本书
  • 本文对比了Heron常见的流处理项目,包括Storm、Flink、Spark StreamingKafka Streams,归纳了系统选型的要点。此外实践了Heron的一个案例,以及讨论了Heron在这一年开发的新特性。
  • 事件就是文档或浏览器窗口中发生的一些特定的交互瞬间。可以使用监听器(或处理...一、事件事件描述的是从页面中接受事件的顺序。事件冒泡事件开始时由最具体的元素(文档中嵌套层次最深的那个节点)接收,然后逐级向
  • 流处理、批处理、交互式查询

    千次阅读 2019-03-10 23:52:28
    我们将大数据处理按处理时间的跨度要求分为以下几类 &nbsp; &nbsp; 基于实时数据流的处理,通常的时间跨度在...1.流处理 流是一种数据传送技术,它把客户端数据变成一个稳定的流。正是由于数据传送呈现连续...
  • javascript的事件

    2017-08-15 12:01:26
    DOM(文档对象模型)结构是一个树型结构,当一个HTML元素产生一个事件时,该事件会在元素节点与根结点之间的路径传播,路径所经过的结点都会收到该事件,这个传播过程可称为DOM事件。DOM事件最独特的性质是,文本...
  • 我们将大数据处理按处理时间的跨度要求分为以下几类 基于实时数据流的处理,通常的时间跨度在数百毫秒到数秒之间 基于历史数据的交互式查询,通常时间跨度在数十秒到数分钟之间 ...流处理的主要应用场景:金融领域
  • 三分钟明白 Activiti工作 -- java运用

    万次阅读 多人点赞 2017-06-14 18:03:03
    一、 什么是工作 以请假为例,现在大多数公司的请假流程是这样的 员工打电话(或网聊)向上级提出请假申请——上级口头同意——上级将请假记录下来——月底将请假记录上交公司——公司将请假录入电脑 采用工作...
  • 计算又称实时计算,是继以Map-Reduce为代表的批处理之后的又一重要计算模型。随着互联网业务的发展以及数据...相比于传统的批处理计算,计算具有低延迟、高响应、持续处理的特点。在数据产生的同时,就可以进行计
  • Java中IO有哪些

    2020-09-16 09:18:16
    按数据流向:输入流和输出流 其中输入和输出都是从程序的角度来讲的 ...处理流:与结点流一块使用,在结点流的基础上,再套接一层 最根本的四大类: InputStream(字节输入流) OutputStream(字节输
  •  我们知道,WF包含两种类型的工作流:顺序工作流和状态机工作流。顺序工作流提供了一系列有组织的步骤,一般情况下,步骤是逐一执行的。可能有的步骤需要等待某些事件的发生才可以继续执行,但通常情况下顺序工作流...
  • JAVA基础再回首(二十三)——操作基本数据类型的、内存操作、打印、随机访问、合并、序列化 版权声明:转载必须注明本文转自程序员杜鹏程的博客:http://blog.csdn.net/m366917 有些日子没写博客了,...
  • java IO 初学总结

    2015-03-09 20:50:10
    输入流、输出流、字节流、字符流(1字符=2字节)、节点流(1结点=8bits)、处理流 Input , Output , Stream , Reader Writer , 直接连接的流 ,包装在直接流之上的流 I nputStream OutputStream
  • 将Bonita工作引擎eXo Portal相结合

    千次阅读 2006-09-14 08:24:00
    其中提及的核心技术主要有工作的表单可以 1 根据form.xml的定义自动生成 2 使用velocity定义表单模板如何利用JCR,JCR可以看成一种继承性的数据库,通过结点和属性来定义数据。在exo中,门户信息,规则,脚本,vel
  • 前提知识大概有 网络 + 一般预推进算法 &amp;&amp; 堆 掌握概念即可 (好吧其实之后也有提到一些) 前言:  以前学的东西 发的博客的代码 大多是看这些高大上的代码 然后自己修改成常规做法的 因此本人...
  • IEDOM事件的区别

    千次阅读 2017-05-28 16:10:21
    IEDOM事件的区别 ··IE采用 冒泡型 事件模型··   冒泡型事件模型: span->div->body (IE事件) 事件冒泡事件传递的一个过程,如果某一个父级元素具有了相同类型的事件,就会触发. 事件冒泡的执行顺序:从...
  • java IO学习总结

    千次阅读 2016-06-09 09:12:18
    最近在看javaIO,总结一下这部分内容,如果有问题欢迎大家指出。1.流的分类:按照数据流向的不同:输入流、输出流 按照处理数据的单位的不同:字节...处理流:是对一个已存在的流的连接封装,通过所封装的流的功能
  • 媒体及媒体传输协议简介

    千次阅读 多人点赞 2019-06-01 22:26:10
    媒体(streaming media):是指将一连串的媒体数据压缩后,经过网上分段发送数据,在网上即时传输影音以供观赏的一种技术与过程,此技术使得数据包得以像流水一样发送;如果不使用此技术,就必须在使用前下载整个...
  • IO详解

    2013-03-12 09:35:49
    根据处理数据类型的不同分为:字符流和字节流根据数据流向不同分为:输入流和输出流(java.io包中的类对应两类流,一类流直接从指定的位置(如磁盘文件或内存区域)读或写,这类流称为结点流(node stream),其它的...
  • 浅谈JAVA的IO

    2013-07-19 20:08:06
    一. 首先先解释一下关于字节流和字符流的区别: 1.字节流:处理单元为1字节的流。 InputStream是所有字节输入流的祖先,OutputStream是所有字节输出流的祖先。 2.字符流:处理单元为2字节的...1.结点流(Node Stream)

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,814
精华内容 17,925
关键字:

结点流和处理流