Java中的IO流-最全最基础的IO流概述和简介

news2024/11/17 0:03:21

在这里插入图片描述

IO流简介

IO是什么

Java中的IO流是用于处理数据输入和输出的核心机制。通过应用IO流可以使Java程序能够与外部世界（如磁盘文件、网络、硬件设备等）进行数据交互。IO流的全称为输入/输出流（Input/Output Stream），它是Java编程语言中用于数据传输的一种抽象模型。流可以被想象为数据的连续流动，就像水通过管道一样，数据通过流从一个地方流向另一个地方。
在这里插入图片描述

应用场景

IO流在Java开发中几乎无处不在，任何涉及到数据读写的地方都会用到IO流。常见的应用场景包括文件读写、网络通信、数据持久化等

IO流的分类

IO流的分类可以从多个维度进行理解

  • 按流的方向：可以分为输入流InputStream)和输出流(FileOutputStream)
  • 按流的功能：可以分为节点流和处理流
  • 按数据处理单元：可以分为字节流(以字节读写为基本单位)和字符流（以字符读写为基本单位）

流的超类类型

在Java中，输入输出（IO）流的超类主要有两类，分别对应于字节流和字符流.

  1. 字节流（Byte Streams）
  • java.io.InputStream：所有字节输入流的超类。定义了从源读取字节的基本方法
  • java.io.OutputStream：所有字节输出流的超类。定义了向目的地写入字节的基本方法
  1. 字符流（Character Streams）
  • java.io.Reader：字符输入流的超类,定义了从源读取字符的基本方法
  • java.io.Writer：字符输出流的超类,定义了向目的地写入字符的基本方法

这些超类提供了基本的读写操作，而它们的子类则实现了特定的读写功能，例如从文件读取、向网络套接字写入、数据的缓冲等。例如：

  • 字节流的具体实现包括：
    • FileInputStream和FileOutputStream：用于读写文件。
    • BufferedInputStream和BufferedOutputStream：提供缓冲，从而提高读写效率。
    • ObjectInputStream和ObjectOutputStream：用于对象的序列化和反序列化。
    • …
  • 字符流的具体实现包括：
    • FileReader和FileWriter：用于读写文本文件。
    • BufferedReader和BufferedWriter、PrintWriter：提供字符缓冲，提高读写效率。
    • InputStreamReader和OutputStreamWriter：用于在字节流和字符流之间转换。
    • …
      这些类构成了Java IO流的层次结构，允许开发者根据不同的需求选择合适的流类型来进行数据的读写操作。

字节文件流应用

简介

文件流是用来连接我们的程序与文件之间的"管道",用来读写文件中的数据。

核心API

文件流是继承自InputStream和OutputStream的流对象，其分类为：

  • 文件输入流java.io.FileInputStream:读取文件数据的流
  • 文件输出流java.io.FileOutputStream:写入文件数据的流

文件输出流应用

java.io.FileOutputStream输出流对象用于向文件中写入数据，对象构建通常会借助如下两个构造方法：

FileOutputStream(String path)
创建文件输出流对指定的path路径表示的文件进行写操作，如果该文件不存在则将其创建出来

FileOutputStream(File file)
创建文件输出流对指定的file对象表示的文件进行写操作，如果该文件不存在则将其创建出来

案例

package io;

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

//API(工具-用于解决什么问题，怎么解决问题)
public class FOSDemo01 {
    public static void main(String[] args) throws IOException {
        //1.构建一个文件输出流对象
        //1)创建文件对象
        File file=new File("jsd/2406/fos.dat");//jsd/2406/是目录
        //2)获取文件对象的目录结构
        File parent = file.getParentFile();//jsd/2406/
        System.out.println(parent);
        //3).假如目录不存在则创建目录mkdirs();
        if(!parent.exists()){//parent.exists()假如返回true表示存在
            parent.mkdirs();//创建多层目录
            System.out.println("文件不存在，创建成功");
        }
        //4)创建文件输出流对象(用于向文件写数据-二进制)
        //构建对象方法1
        //FileOutputStream fos1=new FileOutputStream("jsd/2406/fos.dat");
        //构建对象方法2
        FileOutputStream fos2=new FileOutputStream(file);
        //5)向文件中写入数据
        fos2.write(3);//这里的3表示10进制数据,3的二进制数据为 00000011
        //0001  1(10进制)
        //0010  2
        //0011  3
        //0100  4
        //0101  5
        fos2.write(4);
        fos2.write(5);
        System.out.println("数据写入OK");
        //6)释放资源(关闭流对象)
        fos2.close();
    }
}

文件输入流应用

java.io.FileInputStream文件输入流对象用于从文件中读取数据，常用构造方法有：

FileInputStream(String path)
基于给定的路径对应的文件创建文件输入流

FileInputStream(File file)
基于给定的File对象所表示的文件创建文件输入流

案例

package io;

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

/**
 * 自己实践：
 * 构建文件输入流FileInputStream对象，并基于此对象
 * 从jsd/2406/fos.dat文件中读数据到程序中并输出。
 */
public class FISDemo01 {

    public static void main(String[] args) throws IOException {
        //1.构建文件输入流对象
        FileInputStream fis=new FileInputStream("jsd/2406/fos.dat");
        //2.读取数据
        //int a = fis.read();//读取一个字节
        //int b = fis.read();
        //int c = fis.read();
        //int d = fis.read();
        //System.out.println("a="+a+";b="+b+";c="+c+";d="+d);
        int n=0;
        while((n=fis.read())!=-1){
            System.out.println(n);
        }
        //3.关闭流对象(水龙头有打开是不是也会有关闭，否则浪费资源)
        fis.close();//流对象关闭后会释放内存
    }
}

文件的复制实践

复制文件的原理就是使用文件输入流从原文件中陆续读取出每一个字节，然后再使用文件输出流将字节陆续写入到另一个文件中完成的。
案例1

package io;

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

/**

 * 实现文件复制
 * 将当前目录中的a.png文件复制一份出来生成一个b.png文件
 */

public class FileCopyDemo01 {
    public static void main(String[] args) throws IOException {
        //一、实现思路
        //1.读文件内容(a.png)
        //2.将读取的内容写到b.png中
        //二、代码实现
        //1.构建文件输入流、输出流对象
        FileInputStream fis=
            new FileInputStream("a.png");//这个文件需要存在
        FileOutputStream fos=
            new FileOutputStream("b.png");//这个文件不存在会自动创建
        //2.读写数据(复制)
        int n=-1;
        while((n=fis.read())!=-1){//读取数据,n为读到的数据,-1表示读取到文件尾
            fos.write(n);//将读取的数据写入到b.png文件中
        }
        //3.关闭流对象
        fis.close();
        fos.close();
    }
}

块读写操作实践

  • 块读:一次性读取一组字节的方式
    InputStream中定义了块读的方法

int read(byte[] data)
一次性读取给定字节数组总长度的字节量并存入到该数组中。
返回值为实际读取到的字节数。如果返回值为-1表示本次没有读取到任何字节已经是流的末尾了

  • 块写:一次性写出一组字节的方式
    OutputStream中定义了块写的方法

void write(byte[] data)
一次性将给定数组中所有字节写出
void write(byte[] data,int offset,int len)
一次性将data数组中从下标offset处开始的连续len个字节一次性写出

案例实现：文件复制

package io;

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

/**
 * 实现文件复制
 * 将当前目录中的a.png文件复制一份出来生成一个b.png文件
 */
public class FileCopyDemo02 {
    public static void main(String[] args) throws IOException {
        //一、实现思路
        //1.读文件内容(a.png)
        //2.将读取的内容写到b.png中
        //二、代码实现
        //1.构建文件输入流、输出流对象
        FileInputStream fis=
            new FileInputStream("a.png");//这个文件需要存在
        FileOutputStream fos=
            new FileOutputStream("b.png");//这个文件不存在会自动创建
        //2.读写数据(复制)
        //2.1定义数组用于临时存储读取到数据
        byte[] data=new byte[1024];//这里数组的大小是自定义
        //2.2循环读取数据
        int length=-1;
        while((length=fis.read(data))!=-1){//这里数组大小是1024，所以最多一次读取1024个字节,length表示读取的字节数
            fos.write(data,0,length);//读了多少写多少,0表示起始位置，length表示写入的字节数
        }
        //3.关闭流对象
        fis.close();
        fos.close();
    }
}

文本数据操作

对于FileInputStream和FileOutputStream提供的方法只能读写字节数据，对于文本数据如何操作呢？
案例1：写文本数据

package io;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

/**
 * 文本数据的写操作实现
 */
public class WriteStringDemo01 {
    public static void main(String[] args) throws IOException {
        String str = "我爱Java";
        //构建文件输出流对象
        FileOutputStream fos=new FileOutputStream("./f1.txt");
        //写字符数据
        byte[] data=str.getBytes(StandardCharsets.UTF_8);
        fos.write(data);
        str="Hello Tedu";
        fos.write(str.getBytes(StandardCharsets.UTF_8));
        //释放资源
        fos.close();
    }
}

案例2：读文本数据

package io;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class ReadStringDemo01 {
    public static void main(String[] args) throws IOException {
        //1.构建文件输入流对象
        //方式1：
       // File file=new File("./f1.txt");
       // long size=file.length();
       // FileInputStream fis=new FileInputStream(file);
        //方式2：
        FileInputStream fis=new FileInputStream("./f1.txt");
        //2.读取文件内容(将数据读取到字节数组中)
        //byte[] data=new byte[(int)size];
        byte[] data=new byte[fis.available()];//fis.available()获取流中有效字节数
        int len=fis.read(data);
        //3.将字节数组内容转换为字符串并输出
        String str=new String(data,0,len);
        System.out.println(str);
        //4.关闭流
        fis.close();
    }
}

字节缓冲流应用

处理流

概述
处理流是Java IO流体系中的一类重要的流，它们是在已经存在的流（称为基础流或节点流）之上构建的，为这些流添加额外的功能，而不改变原流本身。处理流的主要目的是为了增强或改变流的行为，比如提供缓冲、转换数据类型、序列化等等。
应用特征
处理流的典型特征是它们自身并不直接连接到物理的输入/输出设备，而是“装饰”在其他流之上，利用这些流进行数据的读写，并在此基础上提供附加服务。处理流的实例通常会把读写操作委托给底层的流，同时可能对数据进行一些预处理或后处理。

处理流可以串联使用，即一个处理流的输出可以作为另一个处理流的输入，形成流的链式结构。例如，可以先使用BufferedInputStream对FileInputStream进行包装，然后再用其它处理流包装这个缓冲流。

字节缓冲流

Java中的缓冲流是一种处理流，有java.io.BufferedInputStream和BufferedOutputStream其作用就是加快读写效率，通常缓冲流的应用最终要链接在低级流上。

  • 缓冲字节输出流
    BufferedOutputStream(OutputStream out)
    实例化一个缓冲字节输出流并链接在指定的字节输出流上。默认缓冲区大小8kb(内部维护的byte[] buf数组长度8192)
    BufferedOutputStream(OutputStream out,int size)
    实例化一个指定缓冲区大小的缓冲字节输出流并链接在指定的字节输出流上。
  • 缓冲字节输入流
    BufferedInputStream(InputStream in)
    实例化一个缓冲字节输入流并链接在指定的字节输入流上。默认缓冲区大小8kb(内部维护的byte[] buf数组长度8192)
    BufferedInputStream(InputStream in,int size)
    实例化一个指定缓冲区大小的缓冲字节输入流并链接在指定的字节输入流上。

应用案例分析

package io;

import java.io.*;

/**
 * 基于缓冲流实现文件复制
 */
public class FileCopyDemo03 {
    public static void main(String[] args) throws IOException {
        //1.构建输入输出流对象(缓冲流增强文件流)
        BufferedInputStream bis =
                new BufferedInputStream(//处理流(这个流对象内置一个缓冲区-byte[])
                        new FileInputStream("./a.png"));//节点流
        BufferedOutputStream bos =
                new BufferedOutputStream(//处理流
                        new FileOutputStream("./c.png"));//节点流
        //2.读写数据(拷贝)
        byte[] data=new byte[16];
        int len;
        while ((len = bis.read(data)) != -1){
            bos.write(data,0,len);
        }
        bos.flush();//这里表示刷新缓冲区内容到文件
        //3.关闭流对象(关闭外层流时，内层流会自动关闭)
        bis.close();
        bos.close();
    }
}

对象流应用实践

简介

Java中的对象流也是一种处理流，有java.io.ObjectInputStream和java.io.ObjectOutputStream两个类型，用于实现对象的读写。也就是对象的序列化（把对象转化为字节）和反序列化（把字节转换为对象）。

  • ObjectOutputStream：用于将Java对象序列化为字节流，以便可以将对象写入文件、网络或其他任何形式的持久存储中。
  • ObjectInputStream：用于从字节流中反序列化Java对象，即将字节流重新转换为Java对象。

Serializable接口
为了能够被序列化，一个对象所属的类必须实现Serializable接口。Serializable是一个标记接口，不包含任何方法，它的存在仅仅是为了标识一个类是可序列化的。如果尝试序列化一个没有实现Serializable接口的类的对象，将会抛出NotSerializableException异常。

应用案例分析

设计一个Message对象类型

package io;

import java.io.Serializable;

/**
 * 消息对象
 */
public class Message implements Serializable {
    //Serializable只起到一个标识性作用
    //添加序列化id(序列化时类中没有写序列化id，系统也会基于类中的属性和方法自动生成)
    //private static final long serialVersionUID=1L;
    //Idea自动生成序列化ID如何进行配置?可以在大模型中去搜索
    private static final long serialVersionUID = 8725255648785219540L;
    /*消息id*/
    private Integer id;
    /**消息标题，
     * 假如这个属性不希望系列化，
     * 可以使用transient关键字修饰*/
    private transient String title;
    /**消息内容*/
    private String content;
    //private Integer userId;
    //.....
    public Message() {}
    public Message(Integer id, String title, String content) {
        this.id=id;
        this.title=title;
        this.content=content;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    //alt+insert
    @Override
    public String toString() {
        return "Message{" +
                "id=" + id +
                ", title='" + title + '\'' +
                ", content='" + content + '\'' +
                '}';
    }
}

对象序列化案例实现

package io;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

/**
 * 对象流应用
 */
public class ObjectOutputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        Message m1 = new Message(1, "传奇老师病了",  "做了个小手术");
        //1.构建流对象
        ObjectOutputStream oos =
                new ObjectOutputStream(
                                   new FileOutputStream("message.txt"));
        //2.写对象(序列化)
        oos.writeObject(m1);
        System.out.println("序列化OK");
        //3.关闭流对象
        oos.close();
    }
}

对象反序列化案例实现

package io;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
/**
 * 将message.txt文件中的内容进行反序列化
*/
public class ObjectInputStreamDemo02 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1.创建流对象
        ObjectInputStream ois=
                  new ObjectInputStream(
                           newFileInputStream("message.txt"));
        //2.读取对象(反序列化-先读出来的是字节，然后将字节转换对象)
        Message msg=(Message)ois.readObject();
        System.out.println(msg);
        //3.关闭资源
        ois.close();
    }
}

字符转换流应用

字符流

在Java中，字符流（Character Streams）是用于处理文本数据的一种流类型，其基类是java.io.Reader和java.io.Writer两个抽象类。
应用场景？
字符流广泛应用于读写文本文件，处理字符串，以及在网络通信中传输文本数据。由于文本文件通常包含人类可读的内容，字符流可以确保正确处理各种字符集和编码，从而避免乱码问题。
为什么使用字符流？

  • 编码透明性：字符流允许你指定字符编码，因此你可以读写使用不同编码的文本文件，而不需要了解具体的编码细节。
  • 字符边界处理：当处理多字节编码（如UTF-8）的字符时，字符流能确保每次读写的都是一个完整的字符，避免字节流中可能出现的字符截断问题（这里其实是乱码）

字符流超类

  • java.io.Writer 所有字符输入流的超类
    常用方法

void write(int c):写出一个字符,写出给定int值”低16”位表示的字符。
void write(char[] chs):将给定字符数组中所有字符写出。
void write(String str):将给定的字符串写出
void write(char[] chs,int offset,int len):将给定的字符数组中从offset处开始连续的len个字符写出

  • java.io.Reader 所有字符输出流的超类
    常用方法

int read():读取一个字符，返回的int值“低16”位有效。当返回值为-1时表达流读取到了末尾。
int read(char[] chs):从该流中读取一个字符数组的length个字符并存入该数组，返回值为实际读取到的字符量。当返回值为-1时表达流读取到了

字符转换流应用

在Java中，字符转换流是Java I/O体系中的一类流，它们实现了字节流和字符流之间的转换。这类流包括InputStreamReader和OutputStreamWriter两个核心类。*
InputStreamReader是一个读取字节并使用指定的字符集将其解码为字符的Reader；OutputStreamWriter则是一个接收字符并使用指定的字符集将其编码为字节的Writer。

应用场景

  • 当你需要从字节流中读取文本数据，并且想要控制使用的字符编码时。
  • 当你需要将字符数据写入到字节流中，并指定字符编码时。
  • 在网络通信中，当你发送或接收的数据是以字节形式存在，但你希望以字符形式处理时。

为什么用它？

  • 编码兼容性：不同的系统和文件可能使用不同的字符编码，字符转换流可以让你指定编码，从而正确解析或生成文本。
  • 国际化支持：为了支持多种语言和字符集，字符转换流提供了灵活的编码选择，这对于开发国际化应用非常重要。
  • 数据完整性：在处理多字节编码的字符时，字节流可能会导致字符被错误地分割，而字符转换流保证了字符的完整性和正确性。

应用案例分析和实践

  • OutputStreamWriter 应用案例(字符输出转化流应用)
    两个构造方法：

OutputStreamWriter(OutputStream out,Charset cs)
基于给定的字节输出流以及字符编码创建OSW

OutputStreamWriter(OutputStream out)
该构造方法会根据系统默认字符集创建OSW

具体应用：通过字符转换流将一些字符串写入到指定文件


package io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.nio.charset.StandardCharsets;

/**
 * 通过字符转换流将一些字符串写入到指定文件
 */
public class OutputStreamWriterDemo01 {
    public static void main(String[] args) throws IOException {
        //1.构建字符转换输出流对象
        OutputStreamWriter osw =
                new OutputStreamWriter(
                        new FileOutputStream("./osw.txt"),
                              StandardCharsets.UTF_8);
        //2.写数据(字符串)
        osw.write("你好");//这里不会自动换行
        osw.write("子千老师");
        System.out.println("数据写出完毕");
        //3.关闭流对象
        osw.close();
    }
}
  • IntputStreamReader 应用案例(字符输入转化流应用)
    构造方法：

InputStreamWriter(InputStream in,Charset cs)
基于给定的字节输入流以及字符编码创建当前转换流

InputStreamWriter(InputStream in)
该构造方法会根据系统默认字符集创建当前转换流

具体应用案例：基于字符转换流从文件读取字符数据

package io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;

/**
 * 基于字符转换流从文件读取字符数据
 */
public class InputStreamReaderDemo01 {
    public static void main(String[] args) throws IOException {
        //1.创建字符输入转换流对象
        InputStreamReader isr = new InputStreamReader(
                new FileInputStream("./osw.txt"), 
                          StandardCharsets.UTF_8);
        //2.读数据
        int data=0;
        while((data=isr.read())!=-1){
            System.out.print((char)data);
        }
        //3.关闭流对象
        isr.close();
    }
}

字符缓冲流应用

简介

在Java中，字符缓冲流是用于提高读写性能的一对流，它们包括BufferedReader和BufferedWriter。这些流通过内部缓存机制减少了对底层I/O设备的访问频率，从而提高了读写操作的效率。
在字符输出缓冲流应用时，通常会结合PrintWriter一起使用。这个对象可以一次写一行，并且可以自带刷新机制。

快速入门实现

案例1：PrintWriter 不同构造方法应用

package io;

import java.io.*;

/**
 * 打印流应用
 */
public class PrintWriterDemo01 {
    public static void main(String[] args) throws FileNotFoundException {
        //1.构建PrintWriter对象
        //方式1：需要手动刷新缓冲区或者关闭流
        PrintWriter pw=new PrintWriter("./pw.txt");
        //方式2：自动刷新,构造方法中的true表示自动刷新
        //PrintWriter pw = new PrintWriter(
                //new FileOutputStream("./pw.txt"),true);
        //2.写入数据
        pw.println("hello");
        pw.println("world");
        pw.println("Java");
        //3.关闭流对象
        pw.close();
    }
}

案例2：自己指定缓冲流

package io;

import java.io.*;

public class PrintWriterDemo02 {
    public static void main(String[] args) throws FileNotFoundException {
        //1.构建打印流对象(装饰模式)
        PrintWriter printWriter = new PrintWriter(
                new BufferedWriter(
                        new OutputStreamWriter(
                          new FileOutputStream("./pw.txt"，true))), true);
        //2.写数据
        printWriter.println("hello");
        printWriter.println("Java");
        //3.关闭流对象
        printWriter.close();
    }
}

案例3：字符输入缓冲流应用

package io;

import java.io.*;
import java.nio.charset.StandardCharsets;

/**
 * 编写一个程序，能从一个文件中读取数据，一次读取一行，并将读取的内容进行输出
 */
public class BufferedReaderDemo01 {
    public static void main(String[] args) throws IOException {
        //1.构建BufferedReader对象
        BufferedReader br = new BufferedReader(
                   new InputStreamReader(
                           new FileInputStream("./src/main/java/io/FISDemo01.java"),
                           StandardCharsets.UTF_8));
        //2.循环读取文件中数据，读一行，输出一行
        String line = null;
        while ((line = br.readLine()) != null) {//readLine用于读取一行
            System.out.println(line);
        }
        //3.关闭流对象
        br.close();
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2066694.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【Python】函数的定义和调用、形参和实参、函数的返回值、多元赋值、全局和局部变量

【Python】函数的定义和调用、形参和实参、函数的返回值、多元赋值、全局和局部变量

文章目录 函数的定义函数的调用形参和实参函数的返回值一个 return多个 return多元赋值 变量作用域函数内的变量全局变量和局部变量修改全局变量 函数的定义 函数的定义：分配任务 def 函数名(形参列表):函数体return 返回值def：define，定义…
阅读更多...
2024“钉耙编程”中国大学生算法设计超级联赛（8）

2024“钉耙编程”中国大学生算法设计超级联赛（8）

🚀欢迎来到本文🚀 🍉个人简介：陈童学哦，彩笔ACMer一枚。 🏀所属专栏：杭电多校集训 本文用于记录回顾总结解题思路便于加深理解。 不是哥们，怎么我tm什么都不会。 📢&…
阅读更多...
计算机Java项目｜基于SpringBoot的医院药品管理系统

计算机Java项目｜基于SpringBoot的医院药品管理系统

作者主页：编程指南针 作者简介：Java领域优质创作者、CSDN博客专家 、CSDN内容合伙人、掘金特邀作者、阿里云博客专家、51CTO特邀作者、多年架构师设计经验、多年校企合作经验，被多个学校常年聘为校外企业导师，指导学生毕业设计并参…
阅读更多...
大象机械臂myCobot 280 JN 2023和D435i相关环境配置

大象机械臂myCobot 280 JN 2023和D435i相关环境配置

目录 一、安装Google拼音输入法二、安装CUDA 10.2三、安装conda管理环境四、配置D435i相机SDK五、安装realsense-ros 大象机器人的这款机械臂，用的Jetson nano做的主控，给的系统的ubuntu20，默认python版本是3.8。并且没有配置CUDA&#xff0c…
阅读更多...
记录｜SPC理解+SPC的监控看板

记录｜SPC理解+SPC的监控看板

目录 前言一、Dashboard1.1 分布图1.2 控制图I-MR控制图：单值极差控制图Xbar-R图：均值极差控制图 1.3 趋势图 二、Xbar-R控制图判断异常的条件Xbar控制图R控制图 三、均值极差控制图【Xbar-R】3.1 基础理解XbarR最终绘制的Xbar-R图 3.2 如何看图看图顺序…
阅读更多...
Linux下安装python与pip源配置（详细教程）

Linux下安装python与pip源配置（详细教程）

文章目录 Linux下安装python前置准备解压数据编译安装配置环境变量方式1：设置软连接方式2：添加PATH PIP源配置系统设置pip源临时设置pip源 问题解决缺少zlib包 Linux下安装python 前置准备 # 下载地址 https://www.python.org/ftp/python/3.6.8/# wget…
阅读更多...
高精度夹治具的使用技巧和注意事项

高精度夹治具的使用技巧和注意事项

在现代工业生产中，高精度夹治具扮演着至关重要的角色。它们能够确保工件在加工过程中的稳定性和精度，提高生产效率和产品质量。然而，要充分发挥高精度夹治具的优势，必须掌握正确的使用技巧和注意事项。以下是时利和整理的一些内容…
阅读更多...
大数据-95 Spark 集群 SparkSQL Action与Transformation操作 详细解释与测试案例

大数据-95 Spark 集群 SparkSQL Action与Transformation操作 详细解释与测试案例

点一下关注吧！！！非常感谢！！持续更新！！！ 目前已经更新到了： Hadoop（已更完）HDFS（已更完）MapReduce（已更完&am…
阅读更多...
关于lettuce的一次pipeline反向优化

关于lettuce的一次pipeline反向优化

起因是后台job对一批数据做大量的redis读写操作，为了提高job的执行速度，直接使用pipeline对一些不能批量读写的命令进行管道优化 简单介绍什么是lettuce Spring Boot自2.0版本开始默认使用Lettuce作为Redis的客户端（注1）。Lettu…
阅读更多...
WEB渗透免杀篇-绕过

WEB渗透免杀篇-绕过

360白名单 需要足够的权限 360的扫描日志和设置白名单日志位置在：C:\Users[username]\AppData\Roaming\360Safe\360ScanLog 查看扫描日志内容可以查询到白名单文件 日志文件记录的是添加或移除白名单的时间、文件名、hash等信息，otc1为添加白名单&#…
阅读更多...
SadTalker翻译与代码调试

SadTalker翻译与代码调试

文章目录 SadTalker原文翻译SadTalker：学习风格化音频驱动单幅图像说话人脸动画的真实 3D 运动系数Abstract1. Introduction2. Related Work3. Method3.1. Preliminary of 3D Face Model3.2. Motion Coefficients Generation through Audio3.3. 3D-aware Face Rende…
阅读更多...
操作系统简介：设备管理

操作系统简介：设备管理

设备管理 1. 设备管理概述2. 设备管理技术通道技术DMA技术缓冲技术Spooling技术 3. 磁盘调度 设备管理是操作系统中最繁杂而且与硬件紧密相关的部分，不但要管理实际 I/O 操作的设备(如磁盘机、扫描仪、打印机、键盘和鼠标)，还要管理诸如设备控制器、DMA…
阅读更多...
Linux信号机制探析--信号的处理

Linux信号机制探析--信号的处理

🍑个人主页：Jupiter. 🚀 所属专栏：Linux从入门到进阶 欢迎大家点赞收藏评论😊 目录 🍑信号处理信号处理常见方式概览 🍒内核如何实现信号的捕捉 🍎内核态与用户态操作系统是如何正常…
阅读更多...
下载cmake操作步骤

下载cmake操作步骤

cmake官网链接 cmake-3.30.2.tar.gz源代码官网下载链接
阅读更多...
中国的人形机器人都有哪些出色的产品？

中国的人形机器人都有哪些出色的产品？

8月21日，2024世界机器人大会在北京亦庄正式开幕。本次大会共有169家企业集中展出了600余件机器人创新产品，人形机器人占比最大，大会还开设人形机器人专区，共亮相27款整机。 展会中多数人形机器人产品都偏向服务型，主要…
阅读更多...
乾坤大挪移！将脚趾移到手指上，江山邦尔骨科医院成功完成一例断指再植手术

乾坤大挪移！将脚趾移到手指上，江山邦尔骨科医院成功完成一例断指再植手术

2024年6月中旬，家住江山贺村的何阿姨经历一次不小的意外。 那天天气晴朗，何阿姨准备把院子修缮修缮。操作切割工具时，何阿姨没有握稳，让工具一下子飞了出去——飞出去的瞬间，工具切掉了她的左手拇指，血流不…
阅读更多...
网络安全大考，攻防演练驱动企业常态化安全运营升级！

网络安全大考，攻防演练驱动企业常态化安全运营升级！

当前，网络安全形势日益严峻，恶意软件、勒索软件肆虐，钓鱼攻击手段层出不穷，不断威胁企业数据安全与业务连续性。随着云计算、大数据、物联网等新兴技术的广泛应用，网络边界模糊化，攻击面急剧扩大&#xff0…
阅读更多...
Qt （10）【Qt窗口 —— 如何在窗口中创建浮动窗口和状态栏】

Qt （10）【Qt窗口 —— 如何在窗口中创建浮动窗口和状态栏】

阅读导航 引言一、如何在窗口中创建浮动窗口1. 浮动窗口的创建2. 设置停靠的位置 二、如何在窗口中创建状态栏1. 状态栏的创建2. 在状态栏中显示实时消息3. 在状态栏中显示永久消息4. 调整显示消息的位置，并加上进度条 引言 在上一篇文章中，我们一同探索…
阅读更多...
数据结构(6_3_1)——图的广度优先遍历

数据结构(6_3_1)——图的广度优先遍历

树和图的广度优先遍历区别 树的广度优先遍历&#xff1a; 图的广度优先遍历&#xff1a; 代码&#xff1a; 注:以下代码只适合连通图 #include <stdio.h> #include <stdbool.h>#define MAX_VERTEX_NUM 100typedef struct ArcNode {int adjvex; // 该边所指向的顶…
阅读更多...
慧灵夹爪：工业智能的创新先锋

慧灵夹爪：工业智能的创新先锋

慧灵作为一个知名老品牌&#xff0c;其机器人产品在众多场景中广为人知。随着智能化、自动化技术的不断提升&#xff0c;智能工业飞速发展&#xff0c;慧灵夹爪在其中发挥的作用也越来越多。 在工业自动化生产中&#xff0c;精准与灵活是衡量设备性能的重要标尺。慧灵夹爪以其卓…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023