Java IO流 装饰 字节流--19

Java IO流之装饰模式与适配器模式讲解 在Java IO流中,我们经常使用的是字节流与字符流,下面附上几张图可以很清楚的了解他们之间的继承关系,图片来源于网络,在此感谢图片的制作者。 1、字节流各个类的继承关系: 2、字符流各个类个继承关系: 一、装饰模式解读: 什么是装饰模式呢?就比如有一个瓶子,我为了让它好看点,给它插上些花,这就起到了装饰作用。   在我们的日常使用开发中,经常看到这各个类的嵌 阅读详情

缓冲区

缓冲区的出现是为了提高流的操作效率而出现的

所以在创建缓冲区之前,必须要现有流对象。

该缓冲区提供了一个跨平台的换行符

newLine();



import java.io.*;
class BufferedWriterDemo
{
    public static void main(String[] args) throws IOException
    {
        //创建一个字符写入流对象
        FileWriter fw = new FileWriter("buf.txt");

        //为了提高字符写入流的效率,加入了缓冲技术。
        //只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。
        BufferedWriter bufw = new BufferedWriter(fw);

        for(int x=0;x<5;x++)
        {
            bufw.write("abcde"+x);
            bufw.newLine();//换行
            bufw.flush();
        }


        //其实关闭缓冲区,就是关闭在关闭缓冲区中的流对象。
        bufw.close();


    }
}

字符读取流缓冲区

该缓冲区提供了一个一次读一行的方法 readLine,方便于对文本数据的获取。
当返回null时表示读到文件末尾。

readLine方法的原理:
无论是读一行,或者读取多个字符,其实最终都是在硬盘上一个一个的读取,所以最终使用的还是read方法一次读一个的方法

readLine方法返回的时候只返回回车符之前的数据内容,并不返回回车符

import java.io.*;
class BufferedReaderDemo 
{
    public static void main(String[] args)throws IOException
    {
        //创建一个读取流对象和文件相关联
        FileReader fr = new FileReader("buf.txt");

        //为了提高效率,加入缓冲技术
        //将字符读取流对象作为参数传递给缓冲对象的构造函数。
        BufferedReader bufr = new BufferedReader(fr);

        String line = null;

        while((line=bufr.readLine())!=null)
        {
            System.out.println(line);
        }

        bufr.close();

    }

}

这里写图片描述

通过缓冲区复制一个.java文件

import java.io.*;
class CopyTestByBuf
{
    public static void main(String[] args)
    {
        BufferedReader bufr = null;
        BufferedWriter bufw = null;

        try
        {
            bufr = new BufferedReader(new FileReader("BufferedWriterDemo.java"));
            bufw = new BufferedWriter(new FileWriter("bufWriter_Copy.txt"));

            String line = null;

            while((line=bufr.readLine())!=null)
            {
                bufw.write(line);
                bufw.newLine();
                bufw.flush();
            }
        }
        catch(IOException e)
        {
            throw new RuntimeException("读写失败");
        }
        finally
        {
            try
            {
                if(bufr!=null)
                    bufr.close();
            }
            catch(IOException e)
            {
                throw new RuntimeException("读取关闭失败");
            }
            try
            {
                if(bufw!=null)
                    bufw.close();
            }
            catch(IOException e)
            {
                throw new RuntimeException("写入关闭失败");
            }
        }
    }
}

明白了BufferedReader类中特有方法readLine()的原理后,
可以自定义一个类中包含一个功能和readLine()一致的方法,
来模拟一下BufferedReader

import java.io.*;
class MyBufferedReader
{
    private FileReader r;
    MyBufferedReader(FileReader r)
    {
        this.r = r;
    }

    //可以一次读一行数据的方法
    public String myReadLine()throws IOException
    {
        //定义一个临时容器,原BufferedReader中封装的是字符数组
        //为了演示方便,定义一个StringBuilder容器。因为最终还是要将数据变成字符串。
        StringBuilder sb = new StringBuilder();

        int ch = 0;

        while((ch=r.read())!=-1)
        {
            if(ch=='\r')
                continue;
            if(ch=='\n')
                return sb.toString();
            else
                sb.append((char)ch);

        }

        if(sb.length()!=0)
            return sb.toString();

        return null;

    }
    public void myClose()throws IOException
    {
        r.close();
    }
}


class MyBufferedReaderDemo
{
    public static void main(String[] args) throws IOException
    {
        FileReader fr = new FileReader("bufWriter_Copy.txt");

        MyBufferedReader myBuf = new MyBufferedReader(fr);

        String line = null;

        while((line=myBuf.myReadLine())!=null)
        {
            System.out.println(line);
        }

        myBuf.myClose();
    }
}

装饰类

装饰设计模式

当想要对已有的对象进行功能增强时,
可以定义类,将已有对象传入,基于已有的功能,并提供加强功能。
那么自定义的该类称为装饰类。

装饰类通常会通过构造方法接受被装饰的对象。
并基于被装饰的对象的功能,提供更强的功能。

吃饭的例子:

class Person
{
    public void chifan()
    {
        System.out.println("吃饭");
    }
}

class SuperPerson
{
    private Person p;
    SuperPerson(Person p)
    {
        this.p = p;
    }
    public void superChifan()
    {
        System.out.println("开胃酒");
        p.chifan();
        System.out.println("甜点");
    }
}

class PersonDemo
{
    public static void main(String[] args)
    {
        Person p = new Person();
        //p.chifan();

        SuperPerson sp = new SuperPerson(p);
        sp.superChifan();

    }
}

装饰模式与继承的比较

MyReader//专门用于读取数据的对象
|–MyTextReader
|–MyBufferTextReader
|–MyMediaReader
|–MyBufferMediaReader
|–MyDataReader
|–MyBufferDataReader

class MyBufferReader
{
MyBufferRead(MyDataReader data)
{}
MyBufferRead(MyMediaReader media)
{}
}
上面这个类扩展性差
找到其参数的共同类型,通过多态的形式,可以提高扩展性

class MyBufferRead extends MyReader
{
private MyReader r;
MyBufferReader(MyReader r)
{}
}

MyReader//专门用于读取数据的对象
|–MyTextReader
|–MyMediaReader
|–MyDataReader
|–MyBufferReader

装饰模式比继承要灵活,避免了继承体系的臃肿
而且降低了类与类之间的关系

装饰类因为增强已有对象,具备的功能和已有的是相同的,只不过提供了更强的功能
所以装饰类和被装饰类通常都属于一个体系

完善后的MyBufferedReader

import java.io.*;
class MyBufferedReader extends Reader
{
    private Reader r;
    MyBufferedReader(Reader r)
    {
        this.r = r;
    }

    //可以一次读一行数据的方法
    public String myReadLine()throws IOException
    {
        //定义一个临时容器,原BufferedReader中封装的是字符数组
        //为了演示方便,定义一个StringBuilder容器。因为最终还是要将数据变成字符串。
        StringBuilder sb = new StringBuilder();

        int ch = 0;

        while((ch=r.read())!=-1)
        {
            if(ch=='\r')
                continue;
            if(ch=='\n')
                return sb.toString();
            else
                sb.append((char)ch);

        }

        if(sb.length()!=0)
            return sb.toString();

        return null;

    }
/*
覆盖Reader类中的抽象方法

*/
public int read(char[] cbuf,int off,int len)throws IOException

{
return r.read(cbuf,off,len);
}
public void close()throws IOException

{
r.close();
}

    public void myClose()throws IOException
    {
        r.close();
    }
}


class MyBufferedReaderDemo
{
    public static void main(String[] args) throws IOException
    {
        FileReader fr = new FileReader("bufWriter_Copy.txt");

        MyBufferedReader myBuf = new MyBufferedReader(fr);

        String line = null;

        while((line=myBuf.myReadLine())!=null)
        {
            System.out.println(line);
        }

        myBuf.myClose();
    }




LineNumberReader
--------------------------------
import java.io.*;
class LineNumberReaderDemo
{
    public static void main(String[] args)
    {
        LineNumberReader lnr = null;

        try
        {
            lnr = new LineNumberReader(new FileReader("PersonDemo.java"));

            String line = null;

            lnr.setLineNumber(100);//从100开始计数

            while((line=lnr.readLine())!=null)
            {
                System.out.println(lnr.getLineNumber()+"::"+line);

            }

        }

        catch(IOException e)
        {
            throw new RuntimeException("读取失败");
        }

        finally
        {

            try
            {
                if(lnr!=null)
                    lnr.close();
            }
            catch(IOException e)
            {
                throw new RuntimeException("读取失败");
            }
        }
    }
}

这里写图片描述

自定义MyLineNumberReader

import java.io.*;
class MyLineNumberReader extends MyBufferedReader
{
    private int lineNumber;
    MyLineNumberReader(Reader r)
    {
        super(r);
    }
    public String myReadLine()throws IOException
    {
        lineNumber++;
        return super.myReadLine();
    }
    public void setLineNumber(int lineNumber)
    {
        this.lineNumber = lineNumber;
    }

    public int getLineNumber()
    {
        return lineNumber;
    }
}

/*
class  MyLineNumberReader
{
    private Reader r;
    private int lineNumber;
    MyLineNumberReader(Reader r)
    {
        this.r = r;
    }

    public String myReadLine()
    {
        try
        {
            lineNumber++;

            StringBuilder sb = new StringBuilder();

            int ch = 0;

            while((ch=r.read())!=-1)
            {
                if(ch=='\r')
                    continue;
                if(ch=='\n')
                    return sb.toString();
                else
                    sb.append((char)ch);
            }

            if(sb.length()!=0)
                return sb.toString();

            return null;

        }

        catch(IOException e)
        {
            throw new RuntimeException("读取失败");
        }

    }

    public void setLineNumber(int lineNumber)
    {
        this.lineNumber = lineNumber;
    }

    public int getLineNumber()
    {
        return lineNumber;
    }

    public void myClose()
    {
        try
        {
            if(r!=null)
                r.close();
        }
        catch(IOException e)
        {
            throw new RuntimeException("读取关闭失败");
        }
    }
}
*/
class MyLineNumberReaderDemo
{
    public static void main(String[] args) throws IOException
    {

        FileReader fr = new FileReader("CopyTestByBuf.java");

        MyLineNumberReader mylnr = new MyLineNumberReader(fr);

        String line = null;

        while((line=mylnr.myReadLine())!=null)
        {
            System.out.println(mylnr.getLineNumber()+"::"+line);

        }

        mylnr.myClose();



        /*
        FileReader fr = null;
        MyLineNumberReader mylnr = null;
        try
        {
            fr = new FileReader("CopyTestByBuf.java");

            mylnr = new MyLineNumberReader(fr);

            String line = null;

            //mylnr.setLineNumber(100);

            while((line=mylnr.myReadLine())!=null)
            {
                System.out.println(mylnr.getLineNumber()+"::"+line);

            }

        }
        catch(IOException e)
        {
            throw new RuntimeException("打印失败");

        }
        mylnr.myClose();
        */
    }
}

这里写图片描述

被注释的部分是手写练习try{}catch(){}的,没有抛异常。演示注意要去掉继抛异常。

字节流

字符流:
FileReader
FileWriter

BufferedReader
BufferedWriter

字节流:
InputStream
OutputStream

需求:想要操作图片数据
这时就要用到字节流

import java.io.*;
class FileStream
{
    public static void main(String[] args)throws IOException
    {
        //writeFile();
        readFile_3();
    }
    public static void readFile_3()throws IOException
    {
        FileInputStream fis = new FileInputStream("fos.txt");

        //int num = fis.available();//文件字节长度

        //定义一个刚刚好的缓冲区,不用循环了
        //慎用
        byte[] buf = new byte[fis.available()];

        fis.read(buf);

        System.out.println(new String(buf));

        fis.close();

    }

    public static void readFile_2()throws IOException
    {
        FileInputStream fis = new FileInputStream("fos.txt");

        byte[] buf = new byte[1024];

        int len = 0;

        while((len=fis.read(buf))!=-1)
        {
            System.out.println(new String(buf,0,len));
        }

        fis.close();
    }

    public static void readFile_1()throws IOException
    {
        FileInputStream fis = new FileInputStream("fos.txt");

        int ch = 0;

        while((ch=fis.read())!=-1)
        {
            System.out.println((char)ch);
        }

        fis.close();
    }

    public static void writeFile()throws IOException
    {
        FileOutputStream fos = new FileOutputStream("fos.txt");

        fos.write("abcde".getBytes());

        fos.close();
    }

}

复制一个图片

思路:
1,用字节读取流对象和图片相关联
2,用字节写入流对象创建一个图片文件,用于存储获取到的图片数据。
3,通过循环读写,完成数据的存储。
4,关闭资源。

import java.io.*;
class CopyPic
{
    public static void main(String[] args)
    {
        FileOutputStream fos = null;
        FileInputStream fis = null;
        try
        {
            fos = new FileOutputStream("c:\\2.jpg");
            fis = new FileInputStream("c:\\1.jpg");

            byte[] buf = new byte[1024];

            int len = 0;

            while((len = fis.read(buf))!=-1)
            {
                fos.write(buf,0,len);
            }
        }

        catch(IOException e)
        {
            throw new RuntimeException("复制文件失败");
        }
        finally
        {
            try
            {
                if(fis!=null)
                    fis.close();
            }
            catch(IOException e)
            {
                throw new RuntimeException("读取关闭失败");
            }

            try
            {
                if(fos!=null)
                    fos.close();
            }
            catch(IOException e)
            {
                throw new RuntimeException("写入关闭失败");
            }
        }

    }
}

注意目录下是否有要复制的图片。

演示MP3的复制。通过缓冲区

BufferedOutputStream
BufferedInputStream

import java.io.*;
class Copymp3
{
    public static void main(String[] args)throws IOException
    {
        long start = System.currentTimeMillis();
        copy_1();
        long end = System.currentTimeMillis();

        System.out.println((end-start)+"毫秒");   
    }

    //通过字节流的缓冲区完成复制
    public static void copy_1()throws IOException
    {
        BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("c:\\1.mp3"));

        BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\\2.mp3"));

        int by = 0;

        while((by= bufis.read())!=-1)
        {
            bufos.write(by);
        }

        bufis.close();
        bufos.close();
    }

}

自定义BufferedOutputStream方法

用此方法在Copymp3里演示发现复制的文件0KB
第一个字节打印的结果就是-1

11111111 11111111 11111111 11111111
00000000 00000000 00000000 11111111
———————————————————————————&
00000000 00000000 00000000 11111111

所以返回时&255,只保留低八位,前面补0
避免了第一个字节就是-1的情况,使文件正常写出。

import java.io.*;
class MyBufferedInputStream
{
    private InputStream in;

    private byte[] buf = new byte[1024];

    private int pos = 0,count = 0;

    MyBufferedInputStream(InputStream in)throws IOException
    {
        this.in = in;
    }
    public int myRead()
    {
        //通过in对象读取数据,并存储到buf中
        if(count==0)
        {
            count = in.read(buf);
            if(count<0)
                return -1;
            pos = 0;
            byte b = buf[pos];

            count--;
            pos++;

            return b&255;
        }
        else if(count>0)
        {
            byte b = buf[pos];

            count--;
            pos++;

            return b&0xff;
        }
        return -1;
    }

    public void myClose()throws IOException
    {
        in.close();
    }
}

转换流

读取键盘录入

System.out:对应的是标准的输出设备 控制台
System.in:对应的是标准的输入设备 键盘

需求:
通过键盘录入数据
当录入一行数据后,就将该行数据进行打印
如果录入的数据是over,就停止录入

import java.io.*;
class ReadIn
{
    public static void main(String[] args)throws IOException
    {
        InputStream in = System.in;

        StringBuilder sb = new StringBuilder();

        while(true)
        {
            int ch = in.read();
            if(ch=='\r')
                continue;
            if(ch=='\n')
            {
                String s = sb.toString();
                if("over".equals(s))
                    break;
                System.out.println(s.toUpperCase());
                sb.delete(0,sb.length());
            }
            else
                sb.append((char)ch);

        }
    }
}

这里写图片描述
字节流:
FileInputStream
FileOutputStream

BufferedInputStream
BufferedOutputStream

通过刚才的键盘录入一行数据并打印其大写,发现其实就是读一行数据的原理
也就是readLine方法

能不能直接使用readLine方法来完成一行数据的读取呢?

readLine方法是BufferedReader类中的方法
而键盘录入的read方法是字节流InputStream的方法

那么能不能将字节流转成字符流再使用字符流缓冲区的readLine方法呢?

InputStreamReader 是字节流通向字符流的桥梁

import java.io.*;
class TransStreamDemo
{
    public static void main(String[] args)throws IOException
    {
        //获取键盘录入对象
        //InputStream in = System.in;

        //将字节流对象转成字符流对象,使用转换流。InputStreamReader
        //InputStreamReader isr = new InputStreamReader(in);

        //为了提高效率,将字符串进行缓冲区技术高效操作,使用BufferedReader
        //BufferedReader bufr = new BufferedReader(isr);

        //三句话变一句话
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));


        //OutputStream out= System.out;

        //OutputStreamWriter osw = new OutputStreamWriter(out);

        //BufferedWriter bufw = new BufferedWriter(osw);

        //三句话变一句话
        BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));


        String line = null;

        while((line=bufr.readLine())!=null)
        {
            if("over".equals(line))
                break;
            bufw.write(line.toUpperCase());
            bufw.newLine();
            bufw.flush();
        }
        bufr.close();
        bufw.close();
    }

这里写图片描述
1,
源:键盘录入
目的:控制台

2,需求:想把键盘录入的数据存储到一个文件中。
源:键盘
目的:文件

3,需求:想要把一个文件的数据打印在控制台上
源:文件
目的:控制台

流操作的基本规律:
通过三个明确
1,源和目的
源:InputStream Reader
目的:OutputStream Writer
2,操作的数据是否是纯文本
是:字符流
不是:字节流

3,当体系明确后,再明确要使用哪个具体的对象
通过设备来进行区分:
源设备:内存,硬盘,键盘
目的设备:内存,硬盘,控制台

import java.io.*;
class TransStreamDemo2
{
    public static void main(String[] args)throws IOException
    {
        //1
        //BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

        //BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));


        //2
        //BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

        //BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("out.txt")));


        //3
        BufferedReader bufr = new BufferedReader(new InputStreamReader(new FileInputStream("out.txt")));

        BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));



        String line = null;

        while((line=bufr.readLine())!=null)
        {
            if("over".equals(line))
                break;
            bufw.write(line.toUpperCase());
            bufw.newLine();
            bufw.flush();
        }
        bufr.close();
        bufw.close();
    }
}


import java.io.*;
import java.util.*;
import java.text.*;
class ExceptionInfoDemo
{
    public static void main(String[] args)
    {
        try
        {
            int[] arr = new int[2];
            System.out.println(arr[3]);
        }
        catch(Exception e)
        {

            try
            {
                Date d = new Date();
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd  HH:mm:ss");
                String s = sdf.format(d);

                PrintStream ps = new PrintStream("exception.log");
                ps.println(s);
                System.setOut(ps);
            }
            catch(IOException ex)
            {
                throw new RuntimeException("日志文件创建失败");
            }

            e.printStackTrace(System.out);
        }
    }
}

log4j网络上用这个建立日至信息

import java.util.*;
import java.io.*;
class SystemInfo 
{
    public static void main(String[] args)throws IOException
    {
        Properties prop = System.getProperties();

        //System.out.println(prop);
        prop.list(new PrintStream("sysinfo.txt"));
    }
}
Visio 2013 Professional密钥安装激活全攻略:版本匹配与故障排查 产品密钥是软件授权体系中的核心凭证,用于验证用户对软件的使用权限。在微软Office产品线中,Visio 2013 Professional采用25位字符的密钥机制,通过联网或电话方式完成激活。正确使用密钥不仅能确保软件功能完整,还能避免因授权问题导致的工作中断。对于企业IT运维和个人用户而言,掌握密钥类型辨析、安装包匹配规则以及激活失败排查方法,是保障老版本软件稳定运行的关键。本文围绕Visio 2013 Professional,详细讲解密钥输入、激活流程及常见错误代码处理,帮助读者高效完成部署与维护。 阅读详情

相关推荐

手把手教你用STM32F103的IO口模拟XY2-100协议驱动数字振镜(附Keil O3优化代码)

本文详细介绍了如何使用STM32F103的IO口模拟XY2-100协议驱动数字振镜,包括协议解析、偶校验算法、寄存器级优化及Keil O3编译下的性能调优。通过硬件配置、核心代码实现和优化技巧,帮助开发者实现高速二维偏转控制,适用于工业激光雕刻和精密定位系统。

weixin_42527401的博客 261

IO操作java(6):装饰流数据流(DataInputStream/DataOutputStream)

数据流:DataInputStream/DataOutputStream 含义:使应用程序以便携方式将原始的java类型写入输出流,然后应用程序可以使用数据输入流来读取数据。(保留数据类型) 注意点:1、读取顺序和写出顺序要相同。2、先写出后读取 3、如果将文件转换为字节数组可以使用ByteArrayOutputStream 内置方法 public final int read(byte b[])...

weixin_42701161的博客 226

Yolov5 多边形标签转换,所有json文件自动转成txt格式[详细过程]

注:labelme是麻省理工(MIT)的计算机科学和人工智能实验室(CSAIL)研发的图像标注工具,人们可以使用该工具创建定制化标注任务或执行图像标注,项目源代码已经开源。通过labelme对图进行标注后,得到的是json文件,而Yolov5对数据进行模型构建的时候,读取需要的是txt格式的文件。txt_outer_path——保存txt文本的文件夹的绝对路径。json_name——json_name是json文本的名字。json_floder——读取json的文件夹的绝对路径。

Pandas_007的博客 1万+

java io流 装饰流_Java中IO流中的装饰设计模式(BufferReader的原理)

本文粗略的介绍下JavaIO的整体框架,重在解释BufferReader/BufferWriter的演变过程和原理(对应的设计模式)一.JavaIO的简介流按操作数据分为两种:字节流与字符流.流按流向分为:输入流(读),输出流(写)。字符流由来就是:早期的字节流+编码表,为了更便于操作文字数据。记住:只要是操作字符数据,应该优先使用字符流。字节流的抽象基类:InputStream ,OutputS...

weixin_29471541的博客 338

ICC2如何写出floorplan信息

不用-exclude 的话rows_tracks / vias /blockages / routing_rules信息都会写出去,即便用了-include {macro ports}也不行,所以不介意这些东西的话可以用以下两种种def方式去写floorplan。write_floorplan用法和write_def一样,因为写出来的文件夹里就包含def,用write_floorplan的好处和innovus saveFPlan一样,都能写出voltage area和bound信息。

m0_61544122的博客 1073

AI驱动的客户终身价值分析:深入理解公司的收入质量

客户终身价值(Customer Lifetime Value, CLV)是衡量客户在整个生命周期内能为企业带来多少利润的重要指标。传统的CLV计算方法往往过于简化,无法准确反映复杂的客户行为和收入模式。本文旨在介绍如何利用人工智能技术,特别是机器学习方法,构建更精确的CLV预测模型,从而帮助企业深入理解其收入质量。CLV的基本概念和商业意义传统CLV计算方法的局限性基于机器学习的CLV预测方法特征工程和模型选择策略实际应用案例和Python实现首先介绍CLV的基本概念和商业背景。

AI云原生与云计算技术学院 477

Java输入输出流(IO流)(从装饰者模式理解java.io)

Java输入输出流(IO流) 概述 程序运行时,将数据从硬盘或网络输入内存进行处理,再将数据从内存输出到硬盘或网络。Java对数据的输入输出依靠IO流实现。 Java的IO流分为两类: 字节流:传输数据的最小单位为byte(字节) 字符流:传输数据的最小单位char(字符) 对字节流的输入输出使用InputStream和OutputStream。 对字符流的输入输出使用Reader和Writer...

qq_30507459的博客 725

Matlab之App Designer 如何进行三维图形绘制教程

基于Matlab中的App Designer设计可视化界面并进行数据导入及3D绘图,可以直观的在可视化界面上展示分析结果,方便用户进行图形的操作。本文采用案例讲解的方式,详细介绍了如何采用Matlab App Designer建立数据3D绘图的GUI可视化界面的方法和详细的过程步骤,并介绍了导入数据进行计算时需要注意的相关事项,同时提供了详细的代码,以便读者进行学习和操作。

m0_59012156的博客 2067

Java IO流和装饰模式(Decorator)

最近在学习OOP的设计模式,其中的装饰模式最常见的应用就是在Java 的IO流中。众所周知,Java中的IO流不同于C/C++的流操作的一个重要的特点便在于存在处理流:FilterInputstream和FilterOutputStream,而这两个流的实现便是依靠装饰模式。     下面具体的将IO流中的类和装饰模式中的各部件(Component)对应起来:     1.abstra

yangtianyu1218的专栏 659

9、硬件工程师笔试面试知识器件篇——三极管(2025版本)

本文全面介绍了三极管的基础知识与应用,包括其结构、类型、工作原理、工作状态、功能、应用场景及特性参数。详细探讨了三极管在信号放大、无线通信、音频设备及医疗设备中的具体应用,并深入分析了设计放大电路时如何平衡增益与噪声、优化偏置电路以提高稳定性、使用负反馈改善性能等关键问题。此外,文章还涵盖了高频电路设计、温度补偿策略、电磁干扰防护等实用内容,为硬件工程师提供了全面的技术参考和设计指导。

XU157303764的博客 7315

【OpenCV-Python】——图像处理基础&读写及显示图像&读写及播放视频&灰度图/彩色图/图像通道操作、运算

在Python中,OpenCV使用NumPy数组存储图像,Numpy是使用Python进行数组计算的软件包,提供强大的N维数组对象,支持复杂的广播功能(数组运算),集成了C/C++和Fortran代码工具,支持线性代数、傅里叶变换和随机数等特性,还可作为通用数据的高效多维容器,如在OpenCV中显示图像。Numpy的知识点见数据处理专栏,主要包括数据类型、创建数组、数组形状、索引切片和迭代、数组运算等。作为初学者,里面可能有总结不全,后续深入学习后会改善文章!下次学习图形用户界面!

weixin_51658186的博客 2084

5. 1 IO流(字符流(6个),字节流(4个),(缓冲区装饰类(装饰设计模式)),(转换流))

1.输入流,输出流

言冘 1209

YOLO26优化:注意力魔改 | 用于微小目标检测的上下文增强和特征细化网络ContextAggregation,助力小目标检测,暴力涨点

用于微小目标检测的上下文增强和特征细化网络ContextAggregation,助力小目标检测

①答疑群聊服务;②YOLO大模型知识问答系统;③计算机视觉论文生成智能体; 492

【Java从入门到精通】第19篇:IO流的装饰器模式——字节流、字符流、缓冲流与对象序列化的管道设计

Java的IO类库以装饰器模式为核心设计理念,将不同类型的流通过层层包装组合出丰富的功能。本文从字节流与字符流的底层抽象出发,拆解FileInputStream到BufferedInputStream如何通过包装为流添加缓冲能力,InputStreamReader如何充当字节到字符的适配器桥梁,以及ObjectInputStream如何通过序列化与反序列化将对象图转化为可存储可传输的字节序列。理解IO流的装饰器架构,是掌握Java数据输入输出体系的关键。

2301_80672009的博客 165

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

IO流与装饰者模式

下面模拟JavaIO,写一个例子。

mf97532的博客 636

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

java IO流学习总结

学习了几天的java IO流,下面我来谈谈对java 输入输出流IO的个人见解吧! 转载自:https://blog.youkuaiyun.com/zhaoyanjun6/article/details/54292148/ java流类结构图 一.流的概念: 流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象。它的特性是进行数据传输; 例如从水源地长江把水导入自来水厂,然后又从自...

coder150806的博客 5万+

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

Java IO 流:从字节到字符再到Java 装饰者模式(Decorator Pattern),解析与应用掌握数据流动的艺术

在 Java 编程中,IO(输入输出)流是处理数据输入输出的核心工具。无论是读取文件、网络通信,还是处理用户输入,IO 流都扮演着重要角色。本文将深入探讨 Java IO 流的核心概念、分类、经典代码实例及其应用场景,帮助你全面掌握数据流动的艺术。

keshi12354的博客 1409

Java IO流笔记 (搬运)

文章目录@[toc]**1、流的概念和作用****1.2、Java IO所采用的模型**1.3、IO流的分类1.4、IO流特性1.5、IO流常用到的五类一接口**1.6、Java IO流对象**1.6.1、输入字节流InputStream1.6.2、输出字节流OutputStream1.6.3、字符输入流Reader1.6.4、字符输出流Writer1.6.5、字节流和字符流使用情况:(重要)1.7、字符流与字节流转换1.8、字节流和字符流的区别(重点)**1.9、System类对IO的支持** [外链图片

程序员小章的博客 1896

简述JAVA IO流以及IO流中的适配器模式、装饰模式

摘要:读完本章节,您对java 的IO流有更清晰深刻的认识,对适配器模式、装饰模式也有初步的了解。        一、关于流引用百度百科上的解释:        流是一种抽象概念,它代表了数据的无结构化传递。按照流的方式进行输入输出,数据被当成无结构的字节序或字符序列。从流中取得数据的操作称为提取操作,亦称读操作;而向流中添加数据的操作称为插入操作,亦称写操作。用来进行输入输出操作的流就称为IO流...

言必信,行必果 2822

IO流与装饰器设计模式的理解

在具体装饰里我们对eat进行了功能扩展,首先执行父类的构造函数,下面对action进行向下转型,如果前面理解了,我们是知道,action指向的是Dog类,那一定是可以转型到Dog的父类Animal的,获取对象的名字,通过父类指向子类获取对象的名称。这次我们传入的是猫这个对象,发现同样进行了扩展,所以这里也证明了我们可以对多个对象进行同一种功能的扩展,我们完全没有对原有的代码进行任何的修改,也没有添加过多的子类,就实现了功能的增加,希望大家能理解这种方式,

jiangyule的博客 1223

接收字节流_Java-IO流

目录1、流的概念和作用1.2、Java IO所采用的模型1.3、IO流的分类1.4、IO流特性1.5、IO流常用到的五类一接口1.6、Java IO流对象1.6.1、输入字节流InputStream1.6.2、输出字节流OutputStream1.6.3、字符输入流Reader1.6.4、字符输出流Writer1.6.5、字节流和字符流使用情况:(重要)1.7、字符流与字节流转换1.8、字节流和字...

weixin_35361584的博客 1128

IO流和装饰模式

解决的问题? 把程序中存储在内存中的数据,写入到文件中 把磁盘文件中存储的数据,读取到内存中

小懒虫的博客 724

java io流

java IO流 什么是IO流 io是input/output的简称。在我们大学学习计算原理的时候,我们知道计算的组成: 输入设备,输出设备,存储器(内存,外存),运算器,控制器。 程序 = 数据结构 + 算法 ; 程序需要处理能够读取输入的数据,并且经过程序处理之后需要输出到存储器进行持久化。 java对输入输出进行了封装,给我们提供了一系列的api,使我们脱离于对最底层硬件的操...

勿在浮沙筑高台 1万+

java io流不关闭有什么后果_Java IO流

一、基本概念 IO是Java对数据的操作是通过流的方式,数据传输是需要通道的,而IO流就是数据传输的通道。IO流可以形象的比喻为运送货物的传输带。IO流用来处理设备之间的数据传输,上传文件和下载文件,Java用于操作流的对象都在IO包中。总结一下,Java IO输入机制就是为了允许程序读取外部数据(包括来自于磁盘、光盘等存储设备的数据)和用户输入的数据。 Java的IO流通过java...

weixin_39563827的博客 2326

Java IO流之字节流【一】

1.IO 概述 生活中,你肯定经历过这样的场景。当你编辑一个文本文件,忘记了 ctrl+s ,可能文件就白白编辑了。 当你电脑上插入一个U盘,可以把一个视频,拷贝到你的电脑硬盘里。那么数据都是存储在哪些设备呢?内存、硬盘、外接设备(移动硬盘,U盘)等等。 数据的传输可以看做是数据的流动,按照流动的方向,以内存为基准,分为输入流input 和输出流output ,即流向内存是输入流,流出内存的输出流。 Java中I/O操作主要是指使用java.io包下的内容,进行输入、输出操作。 输入也叫做读取数据,输出也叫

会者定离,一期一祈 1901

JAVA基础 IO流技术

仅为个人学习使用

,,,,,,, 1097
上一篇: Java 集合Map --16
下一篇: java IO流 File类,Properties--20
飞鸿踏雪泥-
博客等级 码龄12年 4粉丝 48原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值