精华内容
下载资源
问答
  • 简单的说 处理流可以给结点流增加功能import java.io.*;//导入IO类 class Test{ public static void main(String args[]) { FileReader fileReader = null; BufferedReader bufferedReader = null; try ...

    简单的说 处理流可以给结点流增加功能


    import java.io.*;//导入IO类
    
    
    class Test{
    	public static void main(String args[])
    	{
    		FileReader fileReader = null;
    		BufferedReader bufferedReader = null;
    		try
    		{
    			//生成FileReader类型的对象作为结点流
    			fileReader = new FileReader("d:/java/src/users.txt");
    			//生成BufferedReader对象作为处理流
    			bufferedReader = new BufferedReader(fileReader);//(接收FileReader类型的对象)
    			//BufferedReader接收FileReader类型的对象
    			String line =null;
    			while(true)
    			{
    				line = bufferedReader.readLine();//读取文件的一行
    				//readline并不是从文件里面读取一行
    				//而是从对象FileReader中读取的内容进行处理
    				if(line == null){//如果返回的是null则说明读完了
    					break;
    				}
    				System.out.println(line);//打印出来
    			}
    		}
    		catch(Exception e){
    			System.out.println(e);
    		}
    		finally{
    			try{
    				bufferedReader.close();
    				fileReader.close();
    			}
    			catch(Exception e)
    			{
    				System.out.println(e);
    			}
    		}
    	}
    }
    By Urien 2018年4月10日 11:37:14

    展开全文
  • 输入|输出,字节|字符,结点流|处理流。 执行操作:该读就读,该写就写。考虑是一次性完成还行需要循环。 释放资源:程序中打开的文件 IO 资源不属于内存中的资源,垃圾回收无法回收,需要显示关闭。 三、 基本输入...

    一、IO流架构图

    在这里插入图片描述
    字节流可以处理各种文件。包括图片、视频、音频等。
    在这里插入图片描述
    字符流专门用于处理字符文件,处理字符效率比字节流高。

    二、IO操作步骤

    1. 建立联系 :这一步骤是为了获取流,如果此时是文件,则需要将文件抽象到内存形成对象。后期也可以是其他的数据源
    2. 选择流:从读写、数据单元和功能方面考虑。输入|输出,字节|字符,结点流|处理流。
    3. 执行操作:该读就读,该写就写。考虑是一次性完成还行需要循环。
    4. 释放资源:程序中打开的文件 IO 资源不属于内存中的资源,垃圾回收无法回收,需要显示关闭。

    三、 基本输入流

    字节流可以操作所有文件,字符流仅操作纯文本。

    1.抽象类:InputStream 和 Reader

    InputStream和Reader是所有输入流的基类,它们是两个抽象类,是所有输入流的模版,其中定义的方法在所有输入流中都可以使用。
    在InputStream种常用如下几个方法:
    在这里插入图片描述
    在Reader中常用如下几个方法
    在这里插入图片描述

    [1]FileReader(字符输入流)的使用
    		//创建指定文件对象
            File file=new File("F:\\iCode\\sxt\\day11\\src\\a.txt");
            //通过文件对象创建一个FileReader对象
            Reader r=new FileReader(file);
            int i=0;
            //使用Reader 对象的read()方法对字符进行读取,返回一个int类型的数据。若返回数据为-1,则说明文件中的内容已经读取完毕
            while ((i=r.read())!=-1){
                //将int类型的数据转换为char型并打印出来
                System.out.print((char) i);
            }
            r.close();
    

    使用数组进行缓存,先把文件内容读取至指定大小的数组,再将数组中的数据取出

    	 //指定数据源
            String path="F:\\iCode\\sxt\\day11\\src\\a.txt";
            //选择流
            FileReader reader = new FileReader(path);
    
            char[] car=new char[5];
            //读取
            int len=0;
            //reader.read(car))  将读取到的数据存储到指定的数组car中,返回本次读取字符串的长度
            while ((len=reader.read(car))!=-1){
                //通过new String(数组,开始位置,偏移量)来获得字符串
                System.out.println(new String(car,0,len));
            }
    
            //关闭数据源
            reader.close();
    
    [2]FileInputStream(字节输入流)的使用
    		 //确定数据源
            File file=new File("F:\\iCode\\sxt\\day11\\src\\a.txt");
            byte[] car=new byte[3];
            FileInputStream fis=null;
            try {
                //选择流
                fis = new FileInputStream(file);
                //读取
                int len = fis.read(car);
                System.out.println(len+"实际读取到的字节数");
                String s=new String(car,0,len);
                System.out.println(s);
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                try {
                    //关闭流
                    if (fis!=null){
                    fis.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    

    2.抽象类OutputStream 和 Writer

    用于将数据从Java内存输出到其他的防的流,称为输出流,有字符也有字节。也都类似,有两个抽象类OutputStream,Writer。OutputStream和Writer也非常相似。
    OutputStream 中常用如下方法:
    在这里插入图片描述
    在 Writer 中, 因为字符流直接以字符作为操作单位,所以 Writer 可以用字符串来代替字符数组,即以String对象来作为参数。 常用如下方法:
    在这里插入图片描述

    [1]FileWriter(字符输出流)的使用
     		//确定目标
            String path="src\\b.txt";
            //选择流
            FileWriter writer=new FileWriter(path);
            //写
            char[] car={'n','i','c','e'};
            writer.write(car);
    
            String str=" to meet you.";
            writer.write(str);
            //刷新
            writer.flush();
            //关闭资源
            writer.close();
    
    [2]FileOutputStream(字节输出流)的使用

    通过字节流完成图片的拷贝

     //确定源数据
            String source="C:\\Users\\asus\\Desktop\\picture\\email.png";
            //确定目标文件
            String target="src\\copy.png";
    
            //选择流
            InputStream is=new FileInputStream(source);
            OutputStream os=new FileOutputStream(target);
    
            byte[] car=new byte[1024];
            int len=-1;
    
            //边读
            while (((len=is.read(car))!=-1)){
                //边写
                os.write(car,0,len);
            }
            os.flush();
            //关闭流
            is.close();
            os.close();
    

    四、缓冲处理流

    BufferedInputStream和 BufferedReader
    缓冲提高性能: 字节流缓冲流直接套在节点流上即可使用;字符缓冲流 +新增方法(不能使用多态):

    1.BufferedReader

    在这里插入图片描述

    		//确定源数据
            String path="src\\c.txt";
            //选择流
            BufferedReader br=new BufferedReader(new FileReader(path));
            //读取
            String str=null;
            while ((str=br.readLine())!=null) {
                System.out.println(str);
            }
            //关闭流
            br.close();
    

    2.BufferedWriter

    在这里插入图片描述

    在这里插入图片描述

     	//确定目标文件
            File file=new File("src\\d.txt");
            //选择流
            BufferedWriter bw=new BufferedWriter(new FileWriter(file));
            //写
    
            String str="谏逐客书\n" +
                    "先秦:李斯\n" +
                    "\n" +
                    "  臣闻吏议逐客,窃以为过矣。昔缪公求士,西取由余于戎,东得百里奚于宛,迎蹇叔于宋,来丕豹、公孙支于晋。此五子者,不产于秦,而缪公用之,并国二十,遂霸西戎。孝公用商鞅之法,移风易俗,民以殷盛,国以富强,百姓乐用,诸侯亲服,获楚、魏之师,举地千里,至今治强。惠王用张仪之计,拔三川之地,西并巴、蜀,北收上郡,南取汉中,包九夷,制鄢、郢,东据成皋之险,割膏腴之壤,遂散六国之从,使之西面事秦,功施到今。昭王得范雎,废穰侯,逐华阳,强公室,杜私门,蚕食诸侯,使秦成帝业。此四君者,皆以客之功。由此观之,客何负于秦哉!向使四君却客而不内,疏士而不用,是使国无富利之实而秦无强大之名也。\n" +
                    "\n" +
                    "  今陛下致昆山之玉,有随、和之宝,垂明月之珠,服太阿之剑,乘纤离之马,建翠凤之旗,树灵鼍之鼓。此数宝者,秦不生一焉,而陛下说之,何也?必秦国之所生然后可,则是夜光之璧不饰朝廷,犀象之器不为玩好,郑、卫之女不充后宫,而骏良駃騠不实外厩,江南金锡不为用,西蜀丹青不为采。所以饰后宫,充下陈,娱心意,说耳目者,必出于秦然后可,则是宛珠之簪、傅玑之珥、阿缟之衣、锦绣之饰不进于前,而随俗雅化佳冶窈窕赵女不立于侧也。夫击瓮叩缶,弹筝搏髀,而歌呼呜呜快耳目者,真秦之声也;《郑》《卫》《桑间》《昭》《虞》《武》《象》者,异国之乐也。今弃击瓮叩缶而就《郑》《卫》,退弹筝而取《昭》《虞》,若是者何也?快意当前,适观而已矣。今取人则不然,不问可否,不论曲直,非秦者去,为客者逐。然则是所重者在乎色、乐、珠玉,而所轻者在乎人民也。此非所以跨海内、制诸侯之术也。\n" +
                    "\n" +
                    "  臣闻地广者粟多,国大者人众,兵强则士勇。是以太山不让土壤,故能成其大;河海不择细流,故能就其深;王者不却众庶,故能明其德。是以地无四方,民无异国,四时充美,鬼神降福,此五帝三王之所以无敌也。今乃弃黔首以资敌国,却宾客以业诸侯,使天下之士退而不敢西向,裹足不入秦,此所谓“藉寇兵而赍盗粮”者也。\n" +
                    "\n" +
                    "  夫物不产于秦,可宝者多;士不产于秦,而愿忠者众。今逐客以资敌国,损民以益仇,内自虚而外树怨于诸侯,求国无危,不可得也。";
            bw.write(str);
            bw.flush();
            //关闭流
            bw.close();
    

    3.BufferedInputStream

    在这里插入图片描述

    4.BufferedOutputStream

    构造器
    BufferedOutputStream(OutputStream) 创建使用默认大小的输出缓冲区的缓冲字节输出流
    BufferedOutputStream(OutputStream,int) 创建使用指定大小的输出缓冲区的缓冲字节输出流

    方法

    返回值类型 方法描述
    int write(int b)写一个int类型的字符到文件中
    int write(byte[])将一个字节类型的数组写到文件中
    int write(byte[],int ,int ) 将字节类型的数组写到文件中,指定开始位置和结束位置
    void flush() 刷新输出到文件中的内容
    void close()关闭流并释放与之相关的系统资源

    使用缓冲流进行文件拷贝

    /**
     * 使用缓冲流拷贝文件
     */
    public class Demo010 {
    
        public static void main(String[] args) throws Exception {
    
            //确定源文件
            String source="D:\\winTools\\feiGe\\repository\\第三周\\day10\\day15录像\\006ArrayList.mp4";
            //确定目标文件
            String target="E:\\arrayList.mp4";
    
            //选择流
            BufferedInputStream bis=new BufferedInputStream(new FileInputStream(source));
    
            BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(target));
    
            byte[] car=new byte[10*1024];
            int len=-1;
            //边读
            while (((len = bis.read(car)) != -1)) {
                //边写
                bos.write(car,0,len);
            }
            bis.close();
            bos.close();
    
        }
    }
    

    5.文件夹的复制

    public class Test {
        public static void main(String[] args) {
    
            //确定源文件
            File source=new File("D:\\winTools\\feiGe\\repository\\第三周\\day10");
            //确定目标文件
            File target=new File("E:\\设计模式");
            //拷贝文件
           copyDirectory(source,target);
    
        }
         //拷贝文件
    
        static void copy(File source,File target){
            //缓冲流
            BufferedInputStream bis=null;
            BufferedOutputStream bos=null;
            try {
                bis=new BufferedInputStream(new FileInputStream(source));
                bos=new BufferedOutputStream(new FileOutputStream(target));
                //创建一个大小为10M的byte类型的缓存数组
                byte[] car=new byte[10*1024];
                int len=-1;
                //读 一次读取大小为10M的字节,存入car数组中
                while ((len= bis.read(car))!=-1){
                    //写
                    bos.write(car,0,len);
                }
                //刷新
                bos.flush();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                try {
                    if (bis!=null){
                        bis.close();
                    }
                    if (bos!=null) {
                        bos.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
        static void copyDirectory(File sourceDir,File targetDir){
            //若目标文件夹不存在,则创建
            if (!targetDir.exists()){
                targetDir.mkdir();
            }
            //获得源文件目录下的所有子文件[夹]
            File[] files = sourceDir.listFiles();
            //遍历文件数组
            for (File file:files){
                //如果是文件
                if (file.isFile()){
                    //调用复制文件的方法,文件名为当前目录+\\+文件名,拷贝至目标文件夹+\\+文件名
                    copy(new File(sourceDir+"\\"+file.getName()),new File(targetDir+"\\"+file.getName()));
                }else {//如果是文件夹
                    //使用递归,参数为 当前文件夹+\\+子文件夹
                    copyDirectory(new File(sourceDir+"\\"+file.getName()),new File(targetDir+"\\"+file.getName()));
                }
            }
        }   
    }
    

    五、转换处理流

    1.处理转换流InputStreamReader

    转换流:将字节流转为字符流 处理乱码(编码集、解码集)
    将文件按照指定字符编码格式读取

    Reader reader = new InputStreamReader(new FileInputStream("src\\a.txt"), "gbk");
            char read =(char) reader.read();
            System.out.println(read);
            reader.close();
    

    2.数据处理流:DataInputStream

    可以处理基本类型和String类型,保留数据的类型。前提是读取顺序与写出顺序一致,否则读取数据不正确。
    将数据保存至文件,并且会保存文件的数据类型

    	//确定文件
            File file=new File("a.txt");
            //确定流
            DataOutputStream dos=new DataOutputStream(new FileOutputStream(file));
            //写
            //dos.writeInt(123);
            dos.writeBoolean(false);
            dos.flush();
            //关闭流
            dos.close();
    

    六、对象流

    以前我们学过的流都只能读写字节,字符形式的数据,而java中非常重要并且常见的对象类型的数据,如果想要存储到文件中应该怎么操作呢?这个时候就使用到了对象流。
    序列化: 是一个用于将对象状态转换为字节流的过程,可以将其保存到磁盘文件中或通过网络发送到任何其他程序
    反序列化: 从字节流创建对象的相反的过程称为 反序列化
    实体类

    //实现了Serializable接口表名该类可以被序列化
    public class Student implements Serializable {
    
        private String name;
        private int age;
        //使用了transient关键字的属性不能被序列化
        private transient boolean gender;
    
        public Student(String name, int age, boolean gender) {
            this.name = name;
            this.age = age;
            this.gender = gender;
        }
    
        public Student() {
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public boolean isGender() {
            return gender;
        }
    
        public void setGender(boolean gender) {
            this.gender = gender;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", gender=" + gender +
                    '}';
        }
    }
    
    /**
     *  对象输出流
     */
    public class Demo004 {
        public static void main(String[] args) throws Exception{
            //目标文件
            File file=new File("a.txt");
            //选择流
            ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(file));
            //输出
            Student student=new Student("张三",19,true);
            oos.writeObject(student);
            //关闭流
            oos.close();
        }
    }
    
    /**
     * 对象输入流
     */
    public class Demo005 {
        public static void main(String[] args) throws Exception{
            //确定数据源
            File file=new File("a.txt");
            //确定输入流
            ObjectInputStream ois=new ObjectInputStream(new FileInputStream(file));
            //读
            Object o = ois.readObject();
            System.out.println(o);
            //关闭流
            ois.close();
        }
    }
    

    七、Commons-io

    CommonsIO 是apache的一个开源的工具包,封装了IO操作的相关类,使用Commons IO可以很方便的读写文件,url源代码等。commons-IO 需要加入classpath 的第三方jar 包内的 class 文件才能在项目中使用。

     //拷贝文件
            IOUtils.copy(new FileInputStream("a.txt"),new FileOutputStream("b.txt"));
            //这个方法适合拷贝较大的数据流,比如2G以上
            IOUtils.copyLarge(new FileReader("a.txt"),new FileWriter("c.txt"));
            //去除目录和后缀后的文件名
            System.out.println(FilenameUtils.getBaseName("a.txt"));
            // 获取文件的后缀
            System.out.println(FilenameUtils.getExtension("a.txt"));
            //复制文件夹
            FileUtils.copyDirectory(new File("out"),new File("E:\\"));
            //复制文件
            FileUtils.copyFile(new File("a.txt"),new File("d.txt"));
            //把字符串写入文件
            FileUtils.writeStringToFile(new File("a.txt"),"长太息以掩涕兮","utf-8");
    
            //将文件中的内容读取至字符串
            System.out.println(FileUtils.readFileToString(new File("a.txt"), "utf-8"));     
            //查看磁盘可用的空间 System.out.println(FileSystemUtils.freeSpaceKb()/1024/1024);
    
    展开全文
  • 一、事件事件描述的是从页面接受事件的顺序,但是目前有两个概念...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中事件处理的作用域的问题,不过使用其添加移除事件也足够了。

    展开全文
  • Java中IO有哪些

    2020-09-16 09:18:16
    按数据流向:输入流和...按功能:节点流和处理流 节点流:直接与数据源相连,读入或写出 处理流:与结点流一块使用,在结点流的基础上,再套接一层 最根本的四大类: InputStream(字节输入流) OutputStream(字节输

    按数据流向:输入流和输出流
    其中输入和输出都是从程序的角度来讲的

    • 输入流:数据流向程序
    • 输出流:数据从程序流出

    按处理单位:字节流和字符流

    • 字节流:一次读入或读出是8位二进制
    • 字符流:一次读入或读出是16位二进制

    JDK中后缀是Stream是字节流;后缀是Reader,Writer是字符流

    按功能:节点流和处理流

    • 节点流:直接与数据源相连,读入或写出
    • 处理流:与结点流一块使用,在结点流的基础上,再套接一层

    最根本的四大类:

    • InputStream(字节输入流)
    • OutputStream(字节输出流)
    • Reader(字符输入流)
    • Writer(字符输出流)

    参考

    展开全文
  • IO文件

    2020-12-10 10:14:02
    根据处理数据类型的不同分为:字符流和字节流。 根据数据流向不同分为:输入流和输出流。 Java字节流 FileInputStream和FileOutputStream 两个类属于结点流,第一个类的源端和第二个类的目的端都是磁盘文件,它们...
  • JAVA的IO入门

    2015-11-30 16:37:26
    Java中流按功能分为:节点流(原始流)和处理流(包裹流) 处理流是在节点流的基础上提供了更加强大的读写功能,处理流不能独立存在,必须依附于结点流。 Java中流按处理数据的不同分为字节流和字符流 字节流:以...
  • IO详解

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

    2021-02-18 20:47:36
    按照角色分为结点流和处理流 可以从/向特定IO设备(如磁盘、网络)读/写数据的流称为节点流。节点流也被称为低级流,当使用节点流进行输入和输出时,程序直接连接到实际的数据源,和实际输入/输出节点连接。 处理流则...
  • 浅谈JAVA的IO

    2013-07-19 20:08:06
    一. 首先先解释一下关于字节流和字符流的区别: 1.字节流:处理单元为1字节的流。 InputStream是所有字节输入流的祖先,OutputStream是所有字节输出流的祖先。 2.字符流:处理单元为2字节的...1.结点流(Node Stream)
  • 按照功能可以分为结点流和处理流;按照处理数据的类型可以分为字节流和字符流。下面是Java的API为我们提供的操作IO的抽象类和接口。 下面将主要围绕这四大抽象类及其实现类讲解: 输入流:可以从其中读入一个字节...
  • Java I/O常用类小结

    2020-12-22 18:42:21
     我们将IO流类分为两个大类,节点流类过滤流类(也叫处理流类)。  1. 程序用于直接操作目标设备所对应的类叫节点流类  2. 程序也可以通过一个间接流类去调用结点流类,以达到更加灵活方便地读写各种类型的...
  • 首先是词法分析器处理字符序列(对应CharStream类),生成Token(对应TokenStream类,这是连接词法分析语法分析过程的桥梁)传给语法分析器,语法分析器再用它检查语法正确性,然后解析得到语法树(叶子结点对应...
  • Dom事件

    2011-11-10 14:15:50
    标准Dom事件,分三个阶段捕获阶段、目标阶段、冒泡阶段(也有人直接分为两个阶段,捕获冒泡)。其中捕获开始结点和冒泡的末尾结点 都是window。有人说在ie中,只有冒泡阶段没有捕获阶段,我在ie9下测试发现是有...
  • 思路:首先,还是处理出所有的结点的入-出,然后连向超级源点S,超级汇点T,无源无汇的那种情况相同,把源汇当成普通结点,先跑出最大了,再添加边,再跑一次最大,接着得到的(t1->s1)...
  • JavaScript 事件Vue的事件处理 JavaScript 事件 关键字 事件传递模型:捕获型与冒泡模型。事件顺序有两种类型:事件捕捉事件冒泡。 DOM事件:事件会在元素结点与根节点之间按特定的顺序传播,路径所经过的...
  • 工作最简单的就是京东的订单处理,它其实就是个简单的工作,每个节点可能有前驱节点(prev node)后继节点(next node),如图: 而这个结构让我们想起了数据结构里的“链表”(链表由一系列结点(链表中每一个...
  • 2,能方便的应对业务的变更(业务结点和流程分离) 3,实现流程的复用,结点的复用 4,记录流程追踪过程 5,状态的维护等    一直在说要用流程来管理业务(控制业务的处理流程),工作的每个结
  • 接着,加入虚拟结点处理目标缺失的问题,并给出其加速版:聚合虚拟结点。最后利用最大二值整数规划求解无向图以同时获得一系列团。实验在公共数据集上进行,结果表明,该算法可以实现实时跟踪,且跟踪结果较好。
  • McCabe度量法是由托马斯·麦克凯提出的一种基于程序控制的复杂性度量方法。McCabe复杂性度量又称环路度量。它认为程序的复杂性很大程度上...也就是说,把程序流程图的每一个处理符号都退化成一个结点,原来连接不...
  • 理论模型  一般 AND-split 配对使用。 <br /> 这种模式只处理 A、B 分支同时执行的情况,最直接的上文是采用 AND-split 使得 A、B 并发执行。这里 A、B 执行,若 A 先完成,则触发后躯结点 C,然后 B...
  • DOM 是一个树型结构,当一个HTML元素产生一个事件时,该事件会在该元素结点与根节点之间按特定的顺序传播,路径所经过的节点都会收到该事件,这个传播过程可称为DOM事件。而事件传播的顺序分为两种类型:事件捕捉...
  • javascript中的事件处理

    2015-03-19 10:18:00
    DOM(文档对象模型)是一个树形结构,当一个HTML的元素产生一个事件时,该事件会在元素结点与根节点之间按照特定的顺序传播,路径所经过的节点都会收到这个事件,这个传播过程就叫做DOM事件。 事件的顺序有两种...
  • Java中级

    2017-10-21 09:49:02
    1.java IO 1.基本概念 1.字节流和字符流 字节流指每次读入或者读出8位二进制,字符流是指每次读入或者读出8x...节点流和处理流 节点流:程序直接和数据源相连接;处理流:与节点流一块使用,在结点流的基础上再
  • McCabe方法

    2019-12-13 14:15:18
    1. 图 McCabe方法根据程序控制的复杂程度定量度量程序的复杂程度,这样度量出的结果称为程序的环形复杂度。 为了突出表示程序的控制,人们通常...程序流程图中的一个顺序的处理框序列一个菱形判定框,可以...
  • DOM事件事件委托

    2021-02-09 20:18:44
    DOM(文档对象模型)结构是一个树型结构,当一个HTML元素产生一个事件时,该事件会在元素结点与根结点之间的路径传播,路径所经过的结点都会收到该事件,这个传播过程可称为DOM事件。 DOM事件模型分为捕获冒泡,当...
  • 它将IO流分成底层节点流和上层处理流,其中节点流用于和底层的物流存储结点直接关联——不同的物流节点获取该结点流的方式可能存在一定差异,但程序可以把不同的物理节点流包装成统一的处理流,总而允许程序使用统一...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 124
精华内容 49
关键字:

结点流和处理流