精华内容
下载资源
问答
  • 2、转换流解决了字节读取文本文件时可能出现的中文乱码问题,转换流,就可以处理.doc文档了,不管.doc文件是否图片或文字,都可以使用转换流进行读取、写出。package com.winson.iotest;import org.junit....

    1、因为转换流也属于处理流,所以效率比节点流高很多;

    2、转换流解决了字节流读取文本文件时可能出现的中文乱码问题,有了转换流,就可以处理.doc文档了,不管.doc文件是否有图片或文字,都可以使用转换流进行读取、写出。

    package com.winson.iotest;

    import org.junit.Test;

    import java.io.*;

    /**

    * @description:输入、输出转换流整合(复制文件)

    * @date: 2020/7/5 22:43

    * @author: winson

    */

    public class InputSteamReaderOutputStreamWriterTest {

    @Test

    public void test1() {

    InputStreamReader inputStreamReader = null;

    OutputStreamWriter outputStreamWriter = null;

    try {

    FileInputStream fileInputStream = new FileInputStream("hello.txt");

    FileOutputStream fileOutputStream = new FileOutputStream("hello_GBK.txt");

    inputStreamReader = new InputStreamReader(fileInputStream, "utf-8");

    outputStreamWriter = new OutputStreamWriter(fileOutputStream, "GBK");

    char[] chars = new char[20];

    int len;

    while ((len = inputStreamReader.read(chars)) != -1) {

    outputStreamWriter.write(chars, 0, len);

    }

    } catch (IOException e) {

    e.printStackTrace();

    } finally {

    try {

    if (outputStreamWriter != null) {

    outputStreamWriter.close();

    }

    } catch (IOException e) {

    e.printStackTrace();

    }

    try {

    if (inputStreamReader != null) {

    inputStreamReader.close();

    }

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    }

    }

    展开全文
  • 流复制同步异步转换

    千次阅读 2021-07-09 15:52:17
    数据库流复制支持同步异步方式,同步方式能提供最大保护,异步方式能提供最大可用。同步方式在网络异常或备库宕机情况下,主库操作也会受影响,事务操作会出现等待状态。当出现以上场景时,我们总是希望进行降级,...

    作者:瀚高PG实验室(Highgo PG Lab)-Chrisx

    介绍

    数据库流复制支持同步和异步方式,同步方式能提供最大保护,异步方式能提供最大可用。同步方式在网络异常或备库宕机情况下,主库操作也会受影响,事务操作会出现等待状态。当出现以上场景时,我们总是希望进行降级,将同步转为异步,避免主库hang住。

    • 如果实在无法保持所要求数量的同步后备,那么应该减少synchronous_standby_names中指定的事务提交应该等待其回应的同步后备的数量(或者禁用),并且在主服务器上重载配置文件。

    • 即便当同步复制被启用时,个体事务也可以被配置为不等待复制,做法是将synchronous_commit参数设置为local或off。

    基于以上描述,可以实现流复制同步异步转换操作。必要时,可直接将同步复制降级为异步复制。

    同步异步转换

    修改synchronous_standby_names,然后reload生效。也就是说转换过程不需要重启服务器,这一点非常方便的。

    • 同步流复制,synchronous_standby_names指定需要启用同步复制策略的备用服务器
    • 异步流复制,synchronous_standby_names为空

    示例

    alter system set synchronous_standby_names='standby12';
    select pg_reload_conf();
    
    此时关闭备库,主库执行insert,主库hang住
    
    alter system set synchronous_standby_names='';
    select pg_reload_conf();
    
    此时insert就执行成功了
    

    同步复制不等待

    修改synchronous_commit参数设置为local或off,reload生效。即使为同步复制,主库事务也无需等待。此种情况也可以看做是另一种“同步转异步”

    示例

    alter system set synchronous_standby_names='standby12';
    alter system set synchronous_commit=local;
    select pg_reload_conf();
    
    此时关闭备库,主库执行insert,主库不受影响。但是注意
    
    DETAIL:  The transaction has already committed locally, but might not have been replicated to the standby.
    
    展开全文
  • 这里写自定义目录标题(IO,设置编码集)转换流实现文件复制常见的IO合理的创建标题,助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、...

    (IO,设置编码集)转换流实现文件复制

    大家好! 学习了有一阵子了,这两天练习了IO流方面,在此想分享给大家比较简单且有代表性的转换流实现文件复制功能,第一次写,如有不足,请大佬们指点。

    常见的IO流

    我们从两个维度来了解一下常用的一些流:

    字节流字符流
    输入流InputStreamReader
    输出流OutputStreamWriter

    I/O流继承结构

    https://imgconvert.csdnimg.cn/aHR0cHM6Ly9hdmF0YXIuY3Nkbi5uZXQvNy83L0IvMV9yYWxmX2h4MTYzY29tLmpwZw

    I/O流思维导图

    实现代码

    转换流实现复制功能(单字符读取)代码:

    /**
     * 字符转换流实现文件的复制操作
     */
    public class Testapi {
        public static void main(String[] args) {
    /**
     *     	
     *   这里我们输入需要复制的文件的地址  *注意 需要用到的 \ 的情况下java默认认为是转义字符
     *   所以输入磁盘路径地址需要在 \ 前再加一个 \    eg:D:\\ready\\a.txt       
     */
            System.out.println("请输入复制地址:");
            String f = new Scanner(System.in).nextLine();
            System.out.println("请输入目的地址:");
            String t = new Scanner(System.in).nextLine();
            copyOf(f,t);            //这里调用的下边自定义的静态方法
        }
    
        public static void copyOf(String f,String t){
            BufferedReader in = null;//定义缓冲字符输入流,用于后续的读取
            BufferedWriter out = null;//定义缓冲字符输出流,用于后续的输出
            try {
                 in = new BufferedReader(new InputStreamReader(new FileInputStream(f)));
                 out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(t)));
                 int b ;
                 while((b=in.read())!=-1){
                 	out.write(b);
                 }
                System.out.println("恭喜,复制成功");
    
            } catch (Exception e) {
                System.out.println("复制失败");
                e.printStackTrace();
            }finally {
                try {
                    in.close();
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
    
        }
    }
    

    转换流实现读取文件信息输出以及复制功能(多字符读取)代码:

    /**
     * 字符转换流实现文件的复制操作
     */
    public class Testapi {
        public static void main(String[] args) {
    /**
     *     	
     *   这里我们输入需要复制的文件的地址  *注意 需要用到的 \ 的情况下java默认认为是转义字符
     *   所以输入磁盘路径地址需要在 \ 前再加一个 \    eg:D:\\ready\\a.txt       
     */
            System.out.println("请输入复制地址:");
            String f = new Scanner(System.in).nextLine();
            System.out.println("请输入目的地址:");
            String t = new Scanner(System.in).nextLine();
            copyOf(f,t);            //这里调用的下边自定义的静态方法
        }
    
        public static void copyOf(String f,String t){
            BufferedReader in = null;//定义缓冲字符输入流,用于后续的读取
            BufferedWriter out = null;//定义缓冲字符输出流,用于后续的输出
            try {
                 in = new BufferedReader(new InputStreamReader(new FileInputStream(f)));
                 out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(t)));
                char []ch = new char[8192];//
                int len = in.read(ch);//将多字符读入数组,然后返回读取的字符数。 
                System.out.println(new String(ch,0,len));
                out.write(new String(ch,0,len));//String的构造方法,可见上边的介绍
                System.out.println("恭喜,复制成功");
    
            } catch (Exception e) {
                System.out.println("复制失败");
                e.printStackTrace();
            }finally {
                try {
                    in.close();
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
    
        }
    }
    
    
    展开全文
  • 写一下你对IO的心得,对于每个的理解如果我们把水当做文件,把水工厂当做file类,将运输用的大小水管当做inputstream,outputstream,reader,writer,再把瓢子,盘,水桶等容器当做数组,char等。file类是可以...

    写一下你对IO流的心得,对于每个流的理解

    如果我们把水当做文件,把水工厂当做file类,将运输用的大小水管当做inputstream,outputstream,reader,writer,再把瓢子,盘,水桶等容器当做数组,char等。file类是可以放很多很多的水的大仓库,通过inputstream,outputstream,reader,writer这四个节点流(=水管),将水运输到社区,最后,用不同容器(=数组,char)将水装出来用。

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

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

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

    节点流:直接与数据源相连,读入或写出

    处理流:与节点流一块使用,在节点流的基础上,再套接一层

    常用的流对文件进行操作:FileInputStream(字节输入流)、FileOutputStream(字节输出流)、FileReader(字符输入流)、FileWriter(字符输出流)

    对管道进行操作:PipedInputStream(字节输入流)、PipedOutStream(字节输出流)、PipedReader(字符输入流)、PipedWriter(字符输出流)

    字节/字符数组:ByteArrayInputStream、ByteArrayOutputStream、CharArrayReader、CharArrayWriter

    Buffered 缓冲流:BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter

    字节转化成字符流:InputStreamReader、OutputStreamWriter

    数据流:DataInputStream、DataOutputStream

    打印流:PrintStream、PrintWriter

    对象流:ObjectInputStream、ObjectOutputStream

    序列化流:SequenceInputStream

    使用字符流(就是用上BufferedReader等)复制一个文本文件

    81c9f58a79ea858ce83362cf6c89a5ca.png

    //字节流:

    //FileInputStream:字节输入流

    //FileOutputStream:字节输出流

    //字节流是可以读取任何文件,每次读取的时候是1字节

    //缓冲流(包装流):

    //BufferedReader:字符输入缓冲流

    //BufferedWriter:字符输出缓冲流

    //BufferedInputStream:字节输入缓冲流

    //BufferedOutputStream:字节输出缓冲流

    //为了提高读写流的效率,引入了缓冲机制,

    //进行批量的读写,提高了读写的效率。

    //Buffered包装类用于加快了读写内容的速度转换流:

    //两个功能:1.将输入的字节转换为字符

    //2.进行编码转换

    //InputStreamReader:字节输入转换流

    //OutputStreamWriter:字节输出转换流

    package all;

    import java.io.*;

    public class copy {

    public static void main(String[] args) throws IOException {

    File old = new File("xiangDui.txt");

    File copy = new File("xiangDuiCopy.txt");

    CopyFangFa(old,copy);

    }

    public static void CopyFangFa(File old,File copy)

    throws IOException {

    //用FileInputStream等来创建字节输入输出流对象:

    FileInputStream byteInput = new FileInputStream(old);

    FileOutputStream byteOut = new FileOutputStream(copy);

    //复制过程用字节数组和write写入来实现:

    //用每次读取1024的字节的话,执行所花的时间就会变得更少。

    int len;

    byte[] byteArray = new byte[1024];

    while ((len = byteInput.read(byteArray)) != -1) {

    byteOut.write(byteArray, 0, len);

    }

    //用close,关闭,之后可释放资源:

    byteOut.close();

    byteInput.close();

    }

    }

    ef6a5653b99e4ffd768e6a2d60129089.png

    b09f32e17e988d5a7e399fcf00c3c527.png

    使用字节流(FileInputStream等)复制一个图片

    28d54f166c454b9cf32d065deec95cfb.png

    package IO;

    import java.io.*;

    public class copyImg {

    public static void main(String[] args) throws Exception {

    File oldFile=new File("7.jpg");

    BufferedInputStream CharInput=

    new BufferedInputStream(

    new FileInputStream(oldFile));

    BufferedOutputStream CharOut=

    new BufferedOutputStream(new FileOutputStream("7Copy.jpg"));

    byte[] byteArray=new byte[1024];

    int length=0;

    while((length=CharInput.read(byteArray))!=-1){

    CharOut.write(byteArray,0,length);

    }

    CharOut.flush();

    CharOut.close();

    CharInput.close();

    System.out.println("复制成功!");

    }}

    2d5973ac9ac4e0531f7398411c141d43.png

    0d9068356e0be3187e22fd360231da84.png

    6ae2278124270a0ccc8a6e33092d3ba0.png

    使用缓冲流复制一个文件夹和里面的所有文件

    6965d8c7c142aedfaf11f9689b6ec9df.png

    package all;

    import java.io.*;

    public class copyWenJianjia {

    public static void copyAllFanFa(File oldFile, File copyFile)

    throws Exception{

    //用isDirectory判断原来的老的文件是否是文件夹

    if (oldFile.isDirectory()) {

    // 被复制的文件没复制成功,不存在,就创建文件夹

    if (!copyFile.exists()) {

    copyFile.mkdir();

    }

    // 将文件夹下的文件存入文件数组StringArray(字符串数组)

    String[] StringArray = oldFile.list();

    for (String File : StringArray) {

    //用new等创建文件夹下的子目录,src:路径或目录

    File oldFileSrc = new File(oldFile, File);

    File copyFileSrc = new File(copyFile, File);

    // 个人的理解:在自身方法中调用自身的方法,

    //                  这样的话调用一次方法,就是调用了

    //                  很多次正在循环执行的方法

    //                  直到文件等遍历完了,就是将文件进行下一层循环。

    copyAllFanFa(oldFileSrc, copyFileSrc);

    }

    } else {

    // 创建FileInputStream(文件输入字节流)

    //        :  用于读取文件内容,源文件

    FileInputStream byteInput = new FileInputStream(oldFile);

    // 创建FileOutputStream(文件输出的字节流)

    //              ,用于将读取到的文件内容

    //              写到另一个磁盘文件中,复制目标文件等

    FileOutputStream byteOut =

    new FileOutputStream(copyFile);

    int len = -1;

    byte[] byteArray = new byte[1024];

    while (true) {

    // 从FileInputStream(文件输入流)

    //     中读取数据。每执行一次,数据读到字节数组b中

    len = byteInput.read(byteArray, 0, 256);

    if (len == -1) {

    break;

    }

    //                  System.out.println(byteArray.toString());

    byteOut.write(byteArray);

    }

    //              byteOut.write("\r\n".getBytes()); // 换行

    byteInput.close();

    byteOut.close();

    }

    }

    public static void main(String[] args)

    throws Exception{

    copyAllFanFa(new File("NewFile"),new File("NewCopyFile"));

    }

    }

    f357a96364d6751b2419b8e8f94ddac7.png

    04f9b1d452596a597359871a17061eb3.png

    使用转换流复制一个文件夹下的所有txt文件,将文件的编码格式转换为utf-8

    3c10f13b2801088de5b43015880064d6.png

    package all;

    import java.io.*;

    public class copyAlltxt {

    public static void copyAllFanFa(File oldFile, File copyFile)

    throws Exception{

    if (oldFile.isDirectory()) {

    if (!copyFile.exists()) {

    copyFile.mkdir();

    }

    String[] StringArray = oldFile.list();

    for (String File : StringArray) {

    File oldFileSrc = new File(oldFile, File);

    File copyFileSrc = new File(copyFile, File);

    copyAllFanFa(oldFileSrc, copyFileSrc);

    }

    } else {

    FileInputStream byteInput =

    new FileInputStream(oldFile);

    InputStreamReader byteChangeInput=

    new InputStreamReader(byteInput,"UTF-8");

    //      InputStreamReader:字节输入转换流(个人的理解:

    //      把一些内容转格式后保存。)

    FileOutputStream byteOut =

    new FileOutputStream(copyFile);

    char[] charArray=new char[100];

    int len;

    byte[] byteArray= new byte[1024];

    while((len=byteChangeInput.read(charArray))!=-1){

    byteOut.write(byteArray);

    }

    byteChangeInput.close();

    byteInput.close();

    byteOut.close();

    }

    }

    public static void main(String[] args)

    throws Exception{

    copyAllFanFa(new File("NewFile"),new File("NewCopyFile"));

    }

    }

    af215b8b089103a72770044408c2ba43.png

    11b31e286a91b2559b78065b5847db98.png

    使用分割流复制一个文本文件

    1d18558507aeea675307710b8f978075.png

    //字节流:

    //FileInputStream:字节输入流

    //FileOutputStream:字节输出流

    //字节流是可以读取任何文件,每次读取的时候是1字节

    //缓冲流(包装流):

    //BufferedReader:字符输入缓冲流

    //BufferedWriter:字符输出缓冲流

    //BufferedInputStream:字节输入缓冲流

    //BufferedOutputStream:字节输出缓冲流

    //为了提高读写流的效率,引入了缓冲机制,

    //进行批量的读写,提高了读写的效率。

    //Buffered包装类用于加快了读写内容的速度转换流:

    //两个功能:1.将输入的字节转换为字符

    //2.进行编码转换

    //InputStreamReader:字节输入转换流

    //OutputStreamWriter:字节输出转换流

    package fenGeLiu;

    import java.io.*;

    public class copy {

    public static void main(String[] args) throws IOException {

    File old = new File("xiangDui.txt");

    File copy = new File("xiangDuiCopy.txt");

    CopyFangFa(old,copy);

    }

    public static void CopyFangFa(File old,File copy)

    throws IOException {

    //用FileInputStream等来创建字节输入输出流对象:

    RandomAccessFile byteInput=new RandomAccessFile(old,"r");

    //r:是固定不可变的“key”一般的,代表read的部分

    RandomAccessFile byteOut=new RandomAccessFile(copy,"rw");

    //rw:是固定不可变的“key”一般的,代表read后的write的部分

    //——————————————————

    //FileInputStream byteInput = new FileInputStream(old);

    //

    //FileOutputStream byteOut = new FileOutputStream(copy);

    //——————————————————————

    //复制过程用字节数组和write写入来实现:

    //用每次读取1024的字节的话,执行所花的时间就会变得更少。

    int len;

    byte[] byteArray = new byte[1024];

    while ((len = byteInput.read(byteArray)) != -1) {

    byteOut.write(byteArray, 0, len);

    }

    //用close,关闭,之后可释放资源:

    byteOut.close();

    byteInput.close();

    }

    }

    70b11ce954722048166cb044cf9ab089.png

    c825df4b32475870ae09adc24d5dd32f.png

    使用对象流保存一个对象的信息

    38c536c01aa5431a8d4f171a98144a9e.png

    package fenGeLiu;

    import java.io.*;

    import java.util.Date;

    public class baoLiuOneObject {

    public static void main(String[] args) throws Exception{

    student duiXiang1=new student(666,"诗书画唱三连关注",100.0f);

    File File=new File("new.txt");

    FileOutputStream FileOutput=new FileOutputStream(File);

    ObjectOutputStream ObjectOutput

    =new ObjectOutputStream(FileOutput);

    ObjectOutput.writeObject(duiXiang1);

    ObjectOutput.writeObject(null);

    ObjectOutput.close();

    System.out.println("存储成功");

    //下面是打印所有的存在new.txt的文件的对象的内容:

    //File File=new File("new.txt");

    //传入字节输入流:

    FileInputStream byteInputAll=new FileInputStream(File);

    //duiXiangInput【“拼音+英文”的自己的命名】(对象输入流)。

    ObjectInputStream duiXiangInput

    =new ObjectInputStream(byteInputAll);

    Object duiXiang="";

    while((duiXiang=duiXiangInput.readObject())!=null){

    System.out.println(duiXiang.toString());

    }

    duiXiangInput.close();

    }

    }

    class student implements Serializable{

    int bianHao;

    String name;

    //transient float chengJi;

    float chengJi;

    //这里用transient来让成绩(chengJi)不参与序列化,

    //就是后面用toString方法返回的时候,

    //不会打印出传入的真实成绩放的内容。

    public student(int bianHao, String name, float chengJi) {

    this.bianHao = bianHao;

    this.name = name;

    this.chengJi = chengJi;

    }

    @Override

    public String toString() {

    return "编号:" +

    bianHao + ", 姓名:" + name + ", 成绩("

    + "若该变量数据类型前"

    + "\n设置为transient,就不能打印传入的内容"

    + "\n出来的成绩默认为0.0):" +chengJi+ "\n";

    }

    }

    e37cdc9e414164544f7acde1cdd161a1.png

    d580bde942596f8321197669964e38d0.png

    b905da4a8dc5ea1b51f80b410af00316.png

    展开全文
  • packagestream;importjava.io.File;importjava.io.FileNotFoundException;importjava.io.FileReader;importjava.io.FileWriter;importjava.io.IOException;importorg.junit.jupiter.api..../** 的体系结构: 抽象...
  • 对于基本字节,Java后来提供了字节的缓冲流和字符的缓冲3.缓冲java.io.BufferedInputStream 字节缓冲(读)java.io.BufferedOutputStream 字节缓冲(写)java.io.BufferedReader 字符缓冲(读)java.io.B....
  • Java操作之转换流

    2021-02-13 02:08:09
    明确流和目的。数据源(源头):就是需要读取,可以使用两个体系:InputStream、Reader数据汇(目的地):就是需要写入,可以使用两个体系:OutputStream.Writer2.操作的数据是否是纯文本数据?如果是(读取/写入的是字符...
  • Java 在处理上分为字符流和字节。...Java 内用 Unicode 编码存储字符,字符处理类负责将外部的其他编码的字符流和 java 内 Unicode 字符之间的转换。而类 InputStreamReader OutputStreamWriter...
  • 主要分两大类:字节 字符2.在硬盘上的文件,都是以二进制字节形式存储的,所以不管啥文件,读写时都应该用字节3.在java的早期版本中,的确只有字节,没有字符4.一个数字或字母占1个字节,一个汉字占了2...
  • 转换流InputStreamReader OutputStreamWriter处理流用于将字节流转化成字符流,字符流与字节流之间的桥梁...Writer存在将字节流转换成字符流的转换流,因为字符流操作文本更简单不存在把字符流转...
  • 典型代码3.1 使用BufferedInputStreamBufferedOutputStream:处理非文本文件3.2 使用BufferedReaderBufferedWriter:处理文本文件 1.缓冲涉及到的类: BufferedInputStream BufferedOutputStream ...
  • 作用:将字节流和字符进行转换转换流属于字符 InputStreamReader :字节输入 -->字符的输入 OutputStreamWriter : 字符输出 -->字节的输出 InputStreamReader InputStreamReader 是...
  • 缓冲&转换流练习题

    2021-03-28 07:46:17
    练习一:高效字节输出写出字节数据 描述:利用高效字节输出往C盘下的d.txt文件输出一个字节数。 答案 操作步骤: 创建字节输出对象关联文件路径 利用字节输出对象创建高效字节输出对象 调用高效字节...
  • filebase641.file文件转换为base64,得到base64格式图片var reader = new FileReader();reader.readAsDataURL(this.files[0]);reader.onload = function(){console.log(reader.result); //获取到base64格式图片};2...
  • 我知道使用集合与的一种方法是通过实现AtomicReferences,它将方法的第一行替换为: AtomicReference> infos = new AtomicReference( new HashSet() ); 如何使用实现循环正在执行的相同功能?
  • 字符Writer(写文件) 字符输出Reader(读文件) 字符输入上面两个类是所有字符的父类(抽象类)基本的编码格式mac默认使用UTF-8格式(通用编码格式)一个中文字符占3个字节windows 默认使用GBK格式(简体中文格式)一...
  • /** * 利用字节流和字节数组是实现文件的复制 * @author User * */ public class lianxi17 { public static void main(String[] args) throws IOException { byte[] data=get("E:/test/2.txt"); set(data, "e:/...
  • JavaOOP一、缓冲1.1 概念1.2 原理1.3 字节缓冲1.3.1 构造方法1.3.2 使用高效字节进行文件复制1.4 字符缓冲1.4.1 构造方法1.4.2 字符缓冲特有方法1.4.3 使用字符高效进行文件复制1.4.4 统计文本文件行数...
  • Java 在处理上分为字符流和字节。...Java 内用 Unicode 编码存储字符,字符处理类负责将外部的其他编码的字符流和 java 内 Unicode 字符之间的转换。而类 InputStreamReader OutputStreamWriter...
  • 1、InputStream ReaderInputStream Reader 是所有输入的抽象基类,本身并不能创建实例来执行输入,但它们将成为所有输入的模板,所以它们的方法是所有输入都可使用的方法。在 InputStream 里包含如下三...
  • 二、图片的复制 与字符的复制不同,图片等文件是以byte的形式进行存储的,如用字符进行读取存储,都无法收获理想的效果,虽然我们可以通过字节-字符之间的转换,实现字符的R&W,但这样未免南辕北辙,因小失大...
  • 是一组顺序的,起点终点的字节集合,是对数据传输的总称或抽象。即数据在两设备间的传输称为的本质是数据传输,根据数据传输特性将抽象为各种类,方便更直观的进行数据操作。 分类: 按处理数据...
  • File类、io的分类、字节输入、字节输出、字节缓冲输入、字节缓冲输出
  • 比如能够高效读写的缓冲,能够转换编码的转换流,能够持久化存储对象的序列化等等。 1.1 概述 缓冲,也叫高效,是对4个基本的FileXxx 的增强,所以也是4个,按照数据类型分类: 字节缓冲:...
  • 转换流1.1 OutputStreamWriter类OutputStreamWriter 是字符流通向字节的桥梁:可使用指定的字符编码表,将要写入中的字符编码成字节。它的作用的就是,将字符串按照指定的编码表转成字节,在使用字节将这些...
  • 什么情况下使用哪种呢? 如果数据所在的文件通过windows自带的记事本打开并能读懂里面的内容,就用字符。其他用字节流。如果你什么都不知道,就用字节流。 二、IO基类概述 字节的抽象基类: InputStream,...
  • 转换流 序列化反序列化 复习 集合体系: Collection --List --ArrayList 基于数组 --LinkedList 基于链表 --Set --HashSet 基于HashMap --TreeSet 元素对应的类必须实现Comparable接口 实现...
  • 文章目录1.IO案例1.1集合到文件数据排序改进版【应用】1.1.1案例需求1.1.2分析步骤1.1.3代码实现1.2复制单级文件夹【应用】1.2.1案例需求1.2.2分析步骤1.2.3代码实现1.3复制多级文件夹【应用】1.3.1案例需求1.3.2...

空空如也

空空如也

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

复制流和转换有什么区别