【JAVA】IO流

最新推荐文章于 2024-07-22 20:36:44 发布
最新推荐文章于 2024-07-22 20:36:44 发布
阅读量506 收藏
点赞数
文章标签： 大数据 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56492261/article/details/125722503
版权

今天学习IO流的相关知识。 

  1. File类
  2. 输入及输出的概念
  3. 输入流与输出流
  4. 输入输出节点字节流
  5. 节点流与处理流
  6. 输入输出节点字符流
  7. Print流
  8. 对象输入输出流
  9. Serializable序列化接口

File类 

File类 在程序中抽象的表示计算机中的文件或目录。 一个File类对象可以表示文件和路径， 可以对文件的属性进行操作，但不能直接对文件进行读写操作。

路径有两种：

绝对路径，完整的路径 D:\File.txt

相对路径，不是全路径,是两个文件的相对同一个父级的路径 File.txt

import java.io.File;
import java.io.IOException;
import java.util.Date;

public class Demo1 {
    /*
    File类
    在程序中抽象的表示计算机中的文件或目录。
    一个File类对象可以表示文件和路径，
    可以对文件的属性进行操作，但不能直接对文件进行读写操作

    路径有两种：
    绝对路径，完整的路径   D:\File.txt
    相对路径，不是全路径,是两个文件的相对同一个父级的路径    File.txt
     */
    public static void main(String[] args) {
        File f1=new File("D:\\File.txt");//File类的构造方法

        String s="D:\\";
        new File(s,"File1.txt");
        new File(s,"File2.txt");
        new File(s,"File3.txt");

        File f2=new File("D:\\Files");
        if (!f2.exists()) {
            f2.mkdir();//创建一级目录(文件夹)
        }
        f2.delete();//删除目录时，目录要为空
        File f3=new File("D:\\File1\\File2\\File3");
        if (!f3.exists()) {
            f3.mkdirs();//创建多级目录
        }
        f3.delete();
        if (!f1.exists()){//判断文件是否存在
            try {
                f1.createNewFile();//新建一个文件
            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("路径不正确");
            }
        }
        System.out.println(f1.canRead());//判断文件是否可读
        System.out.println(f1.canWrite());//判断文件是否可写
        System.out.println(f1.getAbsoluteFile());//获取文件的绝对地址
        System.out.println(f1.getParent());//返回路径名的父
        System.out.println(f1.length());//获取文件的长度（字节数，以字节为单位）
        System.out.println(new Date(f1.lastModified()));//获取文件的最后修改时间
        System.out.println(f1.delete());//删除文件
        System.out.println(f1.isFile());//判断是否为路径
        System.out.println(f1.isDirectory());//判断是否为目录
    }
}

对目录遍历，获得所有子目录和文件

import java.io.File;
import java.io.FileFilter;

public class Demo3 {
    /*
        对目录遍历，获得所有子目录和文件
     */
    public static void main(String[] args) {
        //对目录里的文件进行遍历,获得某个目录中的所有子目录或文件的文件名,以String返回
        File f1=new File("C:/JAVA 非凡");
        String[] strings=f1.list();
        for (String s:strings){
            System.out.println(s);
        }

        //对目录里的文件进行遍历,获得某个目录中的所有子目录或文件,以File对象返回
        File f2=new File("C:/JAVA 非凡");
        File [] files=f2.listFiles();
        for (File s:files) {
            System.out.println(s);
        }

        //设置条件来选择要操作的对象,返回File对象
        File f3 = new File("C:/JAVA 非凡");
        File[]  files1=f3.listFiles(new MyFileFilter());
        for (File s:files1){
            System.out.println(s);
        }
    }
}

import java.io.File;
import java.io.FilenameFilter;

public class MyFileFilter implements FilenameFilter {

    @Override
    public boolean accept(File dir, String name) {
        return name.endsWith("java");
    }
}

输入及输出的概念

输入输出，将电脑的硬盘上的数据往程序读为输入，把程序中的数据往程序外读为输出。

IO流中的流意思是读写文件的操作类。

IO输入流和输出流，读写文件的操作，根据操作单位不同可分为：

1.字节流以字节为单位，读取时，每次读一个字节

InputStream 字节流输出

OutputStream 字节流输入

2.字符流 以子符为单位，读取时，每次读一个字符，只适合读文本文件

Reader read 字符流输出

Writer writer 字符流输入

import java.io.*;

public class Demo2 {
    /*
        IO输入流和输出流
        读写文件的操作
        根据操作单位不同可分为：
        1.字节流
        以字节为单位，读取时，每次读一个字节
        InputStream 字节流输出
        OutputStream 字节流输入

        2.字符流
        以子符为单位，读取时，每次读一个字符
        只适合读文本文件
        Reader read 字符流输出
        Writer writer 字符流输入
         */
    public static void main(String[] args) throws IOException {
        File file=new File("D:/File.txt");
        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件已存在");
        }
        FileInputStream in=new FileInputStream(file);
        FileOutputStream out=new FileOutputStream("D:/File2.txt");
        //字节流输出
        int n=0;
        while ((n=in.read())!=-1){
            System.out.println(n);
        }
        in.close();//关闭流的通道，释放对文件的占用
        //字节流输入
        int t=0;
        while ((t=in.read())!=-1){
            out.write(t);
        }
        out.close();//关闭流的通道，释放对文件的占用
    }
}

输入输出节点字节流

字节流的输入输出使用InputStream和OutputStream两种方法。

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo4 {
    /*
    字节流
     */
    public static void main(String[] args) throws IOException {
        FileInputStream in=null;
        FileOutputStream out=null;

        try {
            in =new FileInputStream("D:\\File.txt");
            out =new FileOutputStream("D:\\File1.txt");
            int n=0;
            while ((n=in.read())!=-1){
                //in.read();//读取时以int字节形式读取，一次读取一个字节，当文件读完时返回-1
                out.write(n);//写入时，一次向目标写入一个字节
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println(e.getMessage());//日志记录
        }finally {
            if (in!=null)
                in.close();//关闭流的通道，释放对文件的占用
            if (out!=null)
                out.close();//关闭流的通道，释放对文件的占用
        }

        byte[] bytes=new byte[10];


    }
}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo5 {
    public static void main(String[] args) throws IOException {
        FileInputStream in=null;
        FileOutputStream out=null;

        try {
            in =new FileInputStream("D:\\File.txt");
            out =new FileOutputStream("D:\\File1.txt");
            //这每次读一个字节，时间长
//            int n=0;
//            while ((n=in.read())!=-1){
//                out.write(n);//写入时，一次向目标写入一个字节
//            }
            //这根据定义的byte数组长度，每次读byte.length个字节
            //当最后一次剩余字节不足以将byte数组放满，则剩多少放多少
            byte[] bytes=new byte[5];
            int size=0;
            while ((size=in.read(bytes))!=-1){
                System.out.println("这次byte中放入字节数为："+size);
                //in.read();//读取时以int字节形式读取，一次读取一个字节，当文件读完时返回-1
                out.write(bytes,0,size);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println(e.getMessage());//日志记录
        }finally {
            if (in!=null)
                in.close();//关闭流的通道，释放对文件的占用
            if (out!=null)
                out.close();//关闭流的通道，释放对文件的占用
        }




    }
}

节点流与处理流

根据封装的类型，流可分为字节流和处理流。

节点流 流对象是直接对数据进行操作。 例如：构造方法（文件）

处理流(包装流) 流对象中包装的是另一个流，提供一些额外的数据处理。 例如：ObjectInputStream(InputStream in);

节点流中的常用类：

字节输入流 FileInputStream

字节输出流 FileOutputStream

字符输入流 FileReader

字符输出流 FileWriter 

import java.io.*;

public class Demo7 {
    /*
        节点流
        流对象是直接对数据进行操作。 例如：构造方法（文件）
        处理流(包装流)
        流对象中包装的是另一个流，提供一些额外的数据处理。 例如：ObjectInputStream(InputStream in);
       
         */
    public static void main(String[] args) throws IOException {
        FileInputStream in=new FileInputStream("C:\\Users\\Nexus\\Desktop\\2022-7-11_java第八章IO\\练习\\feige.exe");
        FileOutputStream out= new FileOutputStream("C:\\Users\\Nexus\\Desktop\\2022-7-11_java第八章IO\\练习\\feige.txt");
        BufferedInputStream bin = new BufferedInputStream(in);//缓存大小为DEFAULT_BUFFER_SIZE = 8192
        BufferedOutputStream bout =new BufferedOutputStream(out);

        int name=0;
        while ((name=bin.read())!=-1){//将数据读入底层的数组中（缓存区中），待读满缓存区中的8192个再输出
            bout.write(name);//并不是每次write都向磁盘去写数据，而是等缓存区数组满后再向磁盘输出
        }
        bin.close();
        bout.flush();//操作完成后，将缓存区刷新清空
        in.close();
        out.close();
    }
}

处理流中的常用类：

缓冲字节输出流 BufferedOutputStream

缓冲字节输入流 BufferedInputStream

缓冲字符输入流 BufferedReader

缓冲字符输出流 BufferedWriter

缓冲的输入流和输出流：

将数据读入底层的数组中（缓存区中，缓存大小为DEFAULT_BUFFER_SIZE = 8192），待读满缓存区中的8192个再输出；并不是每次write都向磁盘去写数据，而是等缓存区数组满后再向磁盘输出。

import java.io.*;

public class Demo6 {
        /*
        节点流
        流对象是直接对数据进行操作。 例如：构造方法（文件）
        处理流(包装流)
        流对象中包装的是另一个流，提供一些额外的数据处理。 例如：ObjectInputStream(InputStream in);

         */
    public static void main(String[] args) throws IOException {
        FileInputStream in=new FileInputStream("C:\\Users\\Nexus\\Desktop\\2022-7-11_java第八章IO\\练习\\feige.exe");
        FileOutputStream out= new FileOutputStream("C:\\Users\\Nexus\\Desktop\\2022-7-11_java第八章IO\\练习\\feige.txt");
        BufferedInputStream bin = new BufferedInputStream(in);//缓存大小为DEFAULT_BUFFER_SIZE = 8192
        //BufferedInputStream bin = new BufferedInputStream(in，1024);可改变缓存大小
        BufferedOutputStream bout =new BufferedOutputStream(out);

        byte[] bytes=new byte[1024*1024];//当自定义数组大于缓存区数组长度时，缓存区数组会失效
        int name=0;
        while ((name=bin.read(bytes))!=-1){//将1024个数据读入byte数组中，再读入底层的数组中（缓存区中），待读满缓存区中的8192个再输出
            System.out.println(bytes);
            bout.write(name);
        }
        bin.close();
        bout.flush();//操作完成后，将缓存区刷新清空
        in.close();
        out.close();
    }
}

输入输出节点字符流

字符流

字符输入流的基类：Reader

子类：FileReader extends InputStreamReader（转换流，将读到的字节按编码表(charsset)转换为字符）

字符输出流的基类：Writer extends OutputStream

子类：FileWriter extends InputStreamWriter（转换流，将读到的字符按编码表(charsset)转换为字节写出）

汉子的输入输出问题：

在uft-8编码表中，一个汉子等于三个字节，底层存储的单位是字节，通过转换流，将读到的字节按编码表(charsset)转换为字符。

import java.io.*;

public class Demo8 {
    /*
    字符流
    字符输入流的基类：Reader
    子类：FileReader extends InputStreamReader（转换流，将读到的字节按编码表(charsset)转换为字符）
    字符输出流的基类：Writer extends OutputStream
    子类：FileWriter extends InputStreamWriter（转换流，将读到的字符按编码表(charsset)转换为字节写出）
    汉子的输入输出问题：在uft-8编码表中，一个汉子等于三个字节，底层存储的单位是字节，通过转换流，将读到的字节按编码表(charsset)转换为字符。

    缓冲输入：BufferedReader
    缓冲输出：BufferedWriter
     */

    public static void main(String[] args) throws IOException {
        FileReader fileReader=new FileReader("C:\\Users\\Nexus\\Desktop\\2022-7-11_java第八章IO\\练习\\File1.txt");
        FileWriter fileWriter=new FileWriter("C:\\Users\\Nexus\\Desktop\\2022-7-11_java第八章IO\\练习\\File2.txt");

//        int name;
//        while ((name= fileReader.read())!=-1){
//            fileWriter.write(name);
//        }

        char[] chars=new char[5];
        int name;
        while ((name= fileReader.read(chars))!=-1){
            fileWriter.write(chars,0,name);
        }
        fileReader.close();
        fileWriter.close();
    }
}

字符流缓冲输入：BufferedReader

字符流缓冲输出：BufferedWriter

import java.io.*;

public class Demo9 {
       /*
        字符流
        缓冲输入：BufferedReader
        缓冲输出：BufferedWriter
        */
    public static void main(String[] args) throws IOException {

        FileReader fileReader=new FileReader("C:\\Users\\Nexus\\Desktop\\2022-7-11_java第八章IO\\练习\\File1.txt");
        FileWriter fileWriter=new FileWriter("C:\\Users\\Nexus\\Desktop\\2022-7-11_java第八章IO\\练习\\File2.txt");
        //FileWriter fileWriter=new FileWriter(fileName,true);写入数据时，可以保留之前的数据，追加内容
        BufferedReader bufferedReader=new BufferedReader(fileReader);
        BufferedWriter bufferedWriter=new BufferedWriter(fileWriter);

//        int name;
//        while ((name= fileReader.read())!=-1){
//            fileWriter.write(name);
//        }

//        char[] chars=new char[5];
//        int name;
//        while ((name= bufferedReader.read(chars))!=-1){
//            //bufferedWriter.write(chars);
//            bufferedWriter.write(chars,0,name);
//        }

        int name;
        String line;
        while ((line=bufferedReader.readLine())!=null){//readLine（）一次可以读取一行数据
            bufferedWriter.write(line);
            bufferedWriter.newLine();//插入换行符
        }

        bufferedReader.close();
        bufferedWriter.close();
        fileReader.close();
        fileWriter.close();
    }
    }

Print流

 Print流（打印流）：只做输出操作，单位的从程序向目标输出数据，没有输入操作。按打印的数据类型分可分为字节打印流和字符打印流。

PrintWriter：字符打印流print方法可以打印各种数据类型的数据。

import java.io.FileNotFoundException;
import java.io.PrintWriter;

public class Demo10 {
    /*
    Print流
    打印流：只做输出操作，单位的从程序向目标输出数据，没有输入操作。按打印的数据类型分可分为字节打印流和字符打印流。
    PrintWriter
    字符打印流print方法可以打印各种数据类型的数据
     */
    public static void main(String[] args) throws FileNotFoundException {
        PrintWriter printWriter=new PrintWriter("C:\\Users\\Nexus\\Desktop\\2022-7-12_java第八章IO\\练习\\test.html");

        printWriter.print("<h1>Hello world<h1>");
        printWriter.print("<h1>Hello world<h1>");
        printWriter.print("<h1>Hello world<h1>");
        printWriter.print("<h1>Hello world<h1>");
        printWriter.close();
    }
}

 对象输入输出流

 在编码过程中，对象被存储在内存中，程序终止运行时，内存数据会被刷新清空，有时需要保存对象中的数据，需要使用流对象，将对象数据输出到文件中，做到对象数据的持久化（长久保存）。

对象输入输出流,都属于处理流:

ObjectInputStream（反序列化）                                                                                  ObjectOutputStream（序列化）

这过程也称为对象序列化和反序列化。

import java.io.*;
import java.util.Date;

public class Demo11 {
    /*
    在编码过程中，对象被存储在内存中，程序终止运行时，内存数据会被刷新清空
    有事需要保存对象中的数据，需要使用流对象，将对象数据输出到文件中，做到对象数据的持久化（长久保存）
    对象输入输出流,都属于处理流:
        ObjectInputStream（反序列化）
        ObjectOutputStream（序列化）
    这过程也称为对象序列化和反序列化.

     */
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //对象序列化，对象序列化后有它自己特定的格式
        FileOutputStream fileOutputStream=new FileOutputStream("C:\\Users\\Nexus\\Desktop\\2022-7-12_java第八章IO\\练习\\temp\\test.txt");
        ObjectOutputStream objectOutputStream=new ObjectOutputStream(fileOutputStream);
        Date date=new Date();
        String s="ABCdef";
        objectOutputStream.writeObject(date);
        objectOutputStream.writeObject(s);

        objectOutputStream.flush();
        objectOutputStream.close();

        //对象反序列化，会新创建对象
        FileInputStream fileInputStream=new FileInputStream("C:\\Users\\Nexus\\Desktop\\2022-7-12_java第八章IO\\练习\\temp\\test.txt");
        ObjectInputStream objectInputStream=new ObjectInputStream(fileInputStream);
        Date date1=(Date) objectInputStream.readObject();
        String s1=(String)objectInputStream.readObject();
        System.out.println(date1);
        System.out.println(s1);
        objectInputStream.close();
    }
}

Serializable序列化接口

 Serializable 序列化接口：如果需要将某一对象进行序列化，那么此类必须实现Serializable接口 实现后，会生成一个版本号，如果不显示的定义版本号，会自定默认生成。

对象序列化，对象序列化后有它自己特定的格式；对象反序列化，会新创建对象。

自动生成版本号会有一个问题，每次当类改变了，版本号会重新生成 所以但一个类需要经常序列化和反序列化时，建议显式定义版本号。

序列化版本号，版本号的显式定义后，类信息发生改变后不会重新生成。

transient关键字：transient定义的属性，在序列化时不会保存到文件中。

import java.io.Serializable;

public class Animal implements Serializable {
    /*
    Serializable 序列化接口
    如果需要将某一对象进行序列化，那么此类必须实现Serializable接口
    实现后，会生成一个版本号，如果不显示的定义版本号，会自定默认生成，
    自动生成版本号会有一个问题，每次当类改变了，版本号会重新生成
    所以但一个类需要经常序列化和反序列化时，建议显式定义版本号
     */
    //序列化版本号，版本号的显式定义后，类信息发生改变后不会重新生成
    private static final long serialVersionUID = -5869686875672962881L;
    //transient定义的属性，在序列化时不会保存到文件中
    private transient int age;
    private String name;

    public Animal(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Animal{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

import java.io.*;
import java.util.Date;

public class AnimalTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //对象序列化，对象序列化后有它自己特定的格式
        FileOutputStream fileOutputStream=new FileOutputStream("C:\\Users\\Nexus\\Desktop\\2022-7-12_java第八章IO\\练习\\temp\\test.txt");
        ObjectOutputStream objectOutputStream=new ObjectOutputStream(fileOutputStream);
        Animal animal1=new Animal(5,"旺财");
        objectOutputStream.writeObject(animal1);

        objectOutputStream.flush();
        objectOutputStream.close();

        //对象反序列化，会新创建对象
        FileInputStream fileInputStream=new FileInputStream("C:\\Users\\Nexus\\Desktop\\2022-7-12_java第八章IO\\练习\\temp\\test.txt");
        ObjectInputStream objectInputStream=new ObjectInputStream(fileInputStream);
        Animal animal2=(Animal) objectInputStream.readObject();
        System.out.println(animal2);
        objectInputStream.close();
    }
}

爱吃草的羊驼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java 读写同时_java对同一个文件进行读写操作方法
weixin_36224054的博客
02-12 3299
同一个文件是不可以进行同时的读写的，因为我们写入文件会覆盖原文件的，如果这样，对于同一文件来来说，文件发生覆盖，无法进行下次读取当然，对于两个不同的文件，可以一边读一边写的操作题目：一个文本中存储26个无序字母，要求对字母排序后重新写入该文件中分析:可以在内存中用一定的形式存储读入的文件内容，然后进行写入，分开操作。1.用集合存储读入的文件public static void fileRevise...
java IO流详细笔记
07-12
Java IO流详解
java 文件同步读写的几种方式
aa112901a的博客
12-13 5339
方案1：利用RandomAccessFile的文件操作选项s，s即表示同步锁方式写 ? 1 RandomAccessFile file = new RandomAccessFile(file, "rws"); 方案2：利用FileChannel的文件锁 ?
Java 如何对文件进行多个Object对象流的读写操作
web开发
11-19 409
思路：把已经序列化的对象存入容器（如LinkedList&lt;?&gt;）中，然后用ObjectInputStream和ObjectOutputStream对这个实例化的LinkedList&lt;?&gt;对象进行读写。 测试主程序： /** * @Title: FileRW.java * @Package com.file * @Description: 文件、文件夹的创...
Java —— 对文件进行多个Object对象流的读写操作
starter_____的博客
12-17 3949
思路：把已经序列化的对象存入容器（如LinkedList）中，然后用ObjectInputStream和ObjectOutputStream对这个实例化的LinkedList对象进行读写 测试主程序： package com.file; import java.io.File; import java.io.FileInputStream; import java.io.Fi
javaIO流详解
weixin_46676497的博客
01-27 1756
java常用io流介绍
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 15万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
Java io流 详解
m0_68987535的博客
06-11 4569
"IO流"（Input/Output stream）指的是Java中用于处理输入输出（I/O）数据的机制。在Java中，所有的输入和输出都被抽象为“流”对象，并通过输入流读取数据、输出流写入数据。Java的I/O包提供了丰富的类和方法来支持不同类型的流，输入流和输出流之间可以自由地进行转换。它们分别主要包括字节流和字符流两种类型。其中，字节流是操作二进制数据的流，可以处理任何类型的数据，常见的例如InputStream和OutputStream；
java IO流
D大调奏鸣曲_第七序章_de博客
11-11 8万+
目录 序 一、IO流开篇 1、概念 2、流的分类 3、IO流的作用 4、IO流的使用场景 二、字节流 1、字节流抽象基类 2、字节流写数据 （1）基本步骤 （2）三种方式 （3）两个问题 （4）异常处理 3、字节缓冲流 （1）基本分类&概述 （2）构造方法 （3）代码演示 三、字符流 1、概念 2、分类 （1）字符流体系图 （2）字符输入流（Reader） （3）字符输出流（Writer） 3、字符缓冲流 （1）概念 （2）构造方法 （3）...
Java IO流（超详细！）
一只小菜鸡
05-07 5万+
一、什么是IO流 I : Input O : Output 通过IO可以完成硬盘文件的读和写。 二、IO流的分类 按照 流的方向 进行分类： 以内存作为参照物： 往内存中去：叫做输入(Input)。或者叫做读(Read)。 从内存中出来：叫做输出(Output)。或者叫做写(Write)。 按照 读取数据方式 不同进行分类： 按照 字节 的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。 这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文
Java IO流和文件操作实现过程解析
08-25
Java IO流和文件操作实现过程解析 Java IO流和文件操作实现过程解析是Java语言中的一种基本操作，IO流是Java中处理输入输出的基础。Java中的IO流主要包括两种类型：字节流和字符流。字节流用于处理二进制数据，而...
javaIO流javaIO流javaIO流
07-02
Java IO流是Java平台中用于处理输入输出操作的核心机制，它允许程序与各种数据源（如文件、设备、网络）进行交互。Java IO流体系结构是基于“流”的概念，流是一组有序的数据序列，可以是字节流或字符流。Java IO库...
java IO流文件的读写具体实例
09-04
Java IO流是Java平台中用于处理输入输出的重要机制，它允许程序与各种数据源和目的地进行交互，包括文件、网络连接、系统硬件等。在Java中，IO流分为四个主要类别，分别是字节流（处理二进制数据）、字符流（处理...
Java IO流 文件传输基础
09-02
Java IO流是Java平台中用于处理输入输出的重要机制，它涉及到数据从源到目标的传输。文件传输基础是Java IO流应用的一个核心场景，通过IO流可以实现对文件的读写操作，包括创建、打开、修改和删除文件。在本文中，...
Spark RPC框架详解
最新发布
小昌昌的博客
07-22 620
SparkContext构造过程的重要一步，就是Driver、ApplicationMaster以及Executor之间的协调和通信过程，这是基于RPC进行的。这里的Spark RPC是基于Netty的通信过程，而Netty的通信其实是基于Reactor架构进行的，Reactor架构其实是基于Java NIO模型进行的。本文详细讲解了基于Netty 的 SparkRPC 框架的实现细节。
Kudu节点数规划
07-19 584
由于Kudu是Hadoop生态的一部分（虽然它不依赖于Hadoop生态系统），因此大多数实际应用场景需要的不仅仅是Kudu；为了输入数据，可能需要Kafka、StreamSets或Spark Streaming；对于机器学习和数据处理，可能需要Spark；对于交互式SQL，我们也肯定想要Impala。实际上，Kudu和Hadoop生态系统紧密低集成正是其优势之一，因此我们很少单独使用Kudu，所以，在讨论Kudu集群规划时，一般不仅仅是考虑到Kudu。
科普文：搭建信贷业务大数据风控体系
为无为，事无事，味无味。
07-22 429
大家好，本期为大家介绍如何从0到1搭建大数据风控体系。分为：获客、贷前、贷中、贷后、主要数据维度，以及如何识别风险客户。
分享：大数据信用报告查询平台哪个好？
SEOsys的博客
07-21 792
接到上面的说，很多个人推广变过查询的，都是依靠网络平台进行，更不说有自己的网站还要有专门的客服，这本身就是不可能的。细心的人就会发现，在网上，看到最多的就是在文章中有一个二维码，或者是一个查询链接，这种往往是没有自己专属的网站，只有借助网络平台进行推广，而且有很多是怕用户找他们麻烦，躲躲藏藏的。的平台都是在网上或者是网站上挂一个版本的链接，用户根本没有选择的余地。也就是我们常说的大数据，相信很多朋友对这个词都不陌生，特别是在银行申贷的时候，听过比较多，因为在银行做信用贷款的时候都会审查申贷人的。
ranger审计日志对接CDH solr
07-19 495
作者：耀灵。
Java IO流详解：InputStream核心方法
此外，还概述了Java IO流的分类，如字节流、字符流、输入流、输出流，以及节点流和包装流的概念。" 在Java的IO系统中，InputStream是所有字节输入流的基类，它提供了读取字节数据的基本方法。以下是对这些方法的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值