Java中的IO介绍

本章内容

一 、File概念

File可以代表一个目录或者一个文件，并不能代表文件的内容 文件和流的区别：File关注的是文件本身的特征，如名称、路径、修改时间、大小。 流关注的是文件的内容。

二、File基本的操作

  1. 常见构造方法

    | File(String pathname) | 建立一个以pathname为路径的File对象， pathname可以是相对路径，也可以是绝对路径。 | | ———————————————— | —————————————————————————————— | | File(String parent,String child) | 建立一个以parent加上child为路径的File对象 | | File(File parent,String child) | 建立一个以parent加上child为路径的File对象 |

    注意：文件的路径如果考虑跨平台，就使用File.seperator

    相对路径：javase程序中，相对参照点为项目目录 src/test.项目目录下的src/test 绝对路径：e:/test

  2. 创建文件操作

    mkdir:创建单层目录 dir1/dir2:必须保证dir1是存在的，才能成功创建dir2 mkdirs：创建层级目录 dir1/dir2：如果dir1不存在，会先创建dir1,再创建dir2 createNewFile:创建文件 dir1/a :必须保证dir1是存在的，否则，会报系统找不到指定的路径的异常

  3. 文件的常用读操作（文件名称、文件名称）

    exists() //文件或者目录是否存在 isFile() //是否是文件 isDirectory() //是否是目录 getName() //取文件或者目录的名字 getPath() //取文件或者目录的路径 getAbsolutePath() //取文件绝对路径 lastModified() //最后修改日期 length() //文件或者目录的字节大小 list()//获得当前File对象所表示目录下的文件和目录名称，返回String[]类型的数据。 listFiles()//获得当前File对象所表示目录下的文件和目录，返回File[]类型的数据。

    代码实例

  4. 修改文件名称

    注意：修改的新文件名需要是不存在的 ,如果修改前后的目录一致，那就是重命名的效果，如果修改前后目录不一致，相当于会删除旧目录中的文件，以新的名称出现在新目录中

    //      File file = new File(baseDir,"11.txt");
//      file.renameTo(new File(baseDir,"bbb/111.txt"));

  5. 删除文件

            File file = new File(baseDir,"2.txt"); file.delete();

  6. 删除文件夹

    递归：

    1、自己调用自己

    2、必须要一个条件

    private static void myDelete(File dir) {// TODO Auto-generated method stubif(dir.isDirectory()) {File[] listFiles = dir.listFiles();for (File file : listFiles) {if(file.isDirectory()) {myDelete(file);}file.delete();}dir.delete();}}
​

  • 得有一个明确的递归出口(什么情况下不递归了)

  • 递归算法代码简洁，但是效率比较低

    1到n的累加和执行过程：

    | n=1 | 0x01 return 1 | fun(1) =1 | | —— | ———————- | ———————————- | | n=2 | 0x02 2+fun(1) | fun(2) =2+fun(1)=2+1=3 | | n=3 | 0x02 ：3+fun(2) | fun(3)= 3+fun(2)=3+3=6 | | n=4 | 0x02 ：4+fun(3) | fun(4)=4+fun(3)=4+6=10 | | n=5 | 0x02: 5+fun(4) | fun(5)=5+fun(4)=5+10=15 | | 栈底 | | |

    入栈：记录信息

    出栈：根据入栈记录的信息计算结果 fun(1) fun(2) ….. fun(5)

    public static int fun(int n){if(n<=1){return 1;           //0x01}else{return n+fun(n-1);  //0x02}}

public static void deleteFile(File f){        if(!f.exists()){           return;        }        //如果是一个文件        if(f.isFile()){            f.delete();//删除文件            System.out.println("删除文件"+f.getName());        } //如果是一个目录 if(f.isDirectory()){File fs[]=f.listFiles();//满足这个条件，不是空目录if(fs.length>0){for(File subFile:fs){deleteFile(subFile);}}//删除空目录 f.delete();System.out.println("删除目录"+f.getName());}    
}
三、流的概念

File类关心的是磁盘上存储的文件位置和名称等，而流是指程序运行中的数据通信信道，当然流类所关心的是文件的内容。

四、流的分类

根据流向分为：输入流，输出流

根据传输单位:字节流，字符流

根据是否和数据源可以直接交互:节点流，处理流

节点流：可以和数据源直接交互，FileInputStream,FileOutPutStream,FileWriter,FileReader

处理流：需要连接嵌套其它的流使用,BufferedReader,BufferedWriter

五、流的四个根类

  1. InputStream（字节输入流）

    • FileInputStream:节点流，字节输入流，按照字节为单位读文件，文件复制

    • ObjectInputStream：处理流，对象输入流，需要嵌套一个字节输入流进行使用，如FileInputStream，反序列化

  2. OutputStream（字节输出流）

    • FileOutputStream：节点流，字节输出流，按照字节为单位写，文件复制

    • ObjectOutPutStream：处理流，对象输出流，需要嵌套一个字节输出流，如FileOutputStream进行使用，序列化

  3. Reader（字符输入流）

    • FileReader：节点流，针对文件的字符输入流，以字符为单位读文件，存在乱码问题，不能直接按行进行读

    • BufferedReader：处理流，带缓冲区的字符输入流，以行为单位读文件 readLine:返回值为null表示读取结束

    • InputStreamReader：处理流，转换流（可以将字节流转换为字符流）,需要嵌套节点流使用，读文件的指定字符集编码，解决乱码问题

  4. Writer

    • FileWriter：节点流，针对文件的字符输出流，以字符为单位写文件，存在乱码问题，不能直接按行写

    • BufferedWriter ：处理流，带缓冲区的字符输出流，按照行写字符，newLine

    • OutPutStreamWriter：处理流，转换流（可以将字节流转换为字符流），需要嵌套节点流使用，写文件的时候指定字符集编码，解决乱码问题

六、字节流

  1. FileInputStream

    常用api

    FileInputStream是InputStream的子类。 FileInputStream是读取文件的字节输入流。 FileInputStream常用的构造方法： FileInputStream(File file) FileInputStream(String filename) FileInputStream覆盖实现了父类如下方法： int available() void close()

    字节输入流的代码结构

    ​
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;
​
public class StreamDemo {
​public static void main(String[] args) throws IOException {//字节流//1、建立文件源（数据源的一种）File file = new File("src/1.txt");//2、建立流链接文件源FileInputStream input = new FileInputStream(file);//3、读取数据int read = input.read();byte[] bs = new byte[1024];int len = input.read(bs);int read2 = input.read(bs, 2, 5);//使用数据//4、关闭流input.close();}
​
}
​

    int read():一次读取1个字节，返回值表示读取的一个字节的数据（一个字节的数据不一定表示一个字符的编码），返回值为-1表示读取结束

    import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
​
public class StreamDemo {
​public static void main(String[] args) {//字节流//public abstract class InputStreamFile file = new File("src/1.txt");try {//如果是输入流，文件必须存在FileInputStream fileInputStream = new FileInputStream(file);int n;//read()读取流中的数据while((n=fileInputStream.read())!=-1) {System.out.println(n);}//关闭流fileInputStream.close();} catch (FileNotFoundException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}
​}
​
}
​

    int read(byte[ ] b)：将文件中读到的数据放到数组中，返回值为读取到的字节长度，返回值为-1表示读取结束

    ​
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;
​
public class StreamDemo {
​public static void main(String[] args) {//字节流//public abstract class InputStreamFile file = new File("src/1.txt");try {//如果是输入流，文件必须存在FileInputStream fileInputStream = new FileInputStream(file);byte[] bs = new byte[1024];//int read(byte b[]) 将文件中的所有数据读到字节数组中（bs）//返回值是读取了多少个字节int len = fileInputStream.read(bs);
//          System.out.println(Arrays.toString(bs));
//          System.out.println(len);String str = new String(bs);System.out.println(str.trim());//关闭流fileInputStream.close();} catch (FileNotFoundException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}
​}
​
}
​

    int read(byte[] b,int off,int len)：将文件中读到的数据放到数组中的指定位置，指定长度，返回值为读取到的字节长度，返回值为-1表示读取结束

    import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;public class StreamDemo {public static void main(String[] args) {//字节流//public abstract class InputStreamFile file = new File("src/1.txt");try {//如果是输入流，文件必须存在FileInputStream fileInputStream = new FileInputStream(file);//			int n;
//			//read()读取流中的数据，每次读取一个字节
//			while((n=fileInputStream.read())!=-1) {
//				System.out.println(n);
//			}byte[] bs = new byte[1024];//int read(byte b[]) 将文件中的所有数据读到字节数组中（bs）//返回值是读取了多少个字节//第一个参数bs存了读取的数据//第二个参数1设置了bs数组从下标1的位置开始存//第三个参数3设置了从文件中读取几个字节int len = fileInputStream.read(bs,1,3);System.out.println(Arrays.toString(bs));System.out.println(len);String str = new String(bs);System.out.println(str);//关闭流fileInputStream.close();} catch (FileNotFoundException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}

    注意：read（）和int read(byte[ ] b)方法返回值代表的意义

  2. FileOutputStream

    FileOutputStream是OutputStream的子类 FileOutputStream是写入文件的字节输出流 FileOutputStream常用的构造方法： FileOutputStream(File file) FileOutputStream(String filename) FileOutputStream(File file,boolean append) FileOutputStream(String filename,boolean append) FileOutputStream覆盖实现了父类如下方法： void close() void flush() void write(int b) ：写入一个字节的数据，参数就是要写入的数据的编码

    void write(byte[] b) ：将数组中的数据写到文件中，数组中存放的是字符的编码

    void write(byte[] b,int off,int len）：将数组指定位置指定长度的数据写入的文件中

    import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;public class OutputStreamDemo {public static void main(String[] args) throws IOException {//FileOutputStream//按照单位，字节流//按照方向，输出流//按照是否跟源进行关联，节点流//1、声明文件源File file = new File("src/output.txt");//2、创建字节输出流FileOutputStream fos = new FileOutputStream(file);//3、写出数据String str = "abcdefg";
//		for(int i=0;i<str.length();i++) {
//			fos.write(str.charAt(i));
//		}fos.write(str.getBytes(), 1, 3);//4、关闭流fos.close();}}

  3. 文件复制

    import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;public class CopyDemo {public static void main(String[] args) throws IOException {//文件复制File sourceFile = new File("G:\\video\\20220530-1-File概念.mp4");File targetFile = new File("f:\\64\\1.mp4");FileInputStream input = new FileInputStream(sourceFile);FileOutputStream output = new FileOutputStream(targetFile);//缓存可以减少io次数，可以大大的提升速度byte[] bs = new byte[1024*8];int len;while((len=input.read(bs))!=-1) {output.write(bs);bs = new byte[1024*8];}input.close();output.close();sourceFile.delete();}}

七、字符流

字符流：适合读写文本字符（按照字符读取，不能直接按照行读取）

  1. FileReader

    • 常用API:

      int read() ：一次读一个字符，返回值是读到的一个字符的编码，-1表示读取结束

      int read(char[] cbuf) ：返回值表示读取到字符的个数，参数表示存放读取到的数据的数组

      int read(char[] cbuf,int off,int len)：返回值表示读取到字符的个数，参数表示存放读取到的数据的数组

      void close()

  2. FileWriter

    • 常用API:

      void write(int ch) :写入单个字符到调用的输出流。

      void write(String str) :写入str到输出流。

      void write(String str, int off, int len),写入字符串的某一部分。

      void write(char[] cbuf)

      void write(char[] cbuf,int off,int len):写入字符数组的某一部分。

      void flush() :清空输出缓冲区。

      void close() ：关闭输出流。

import java.io.File;
import java.io.FileReader;
import java.io.IOException;public class CharIODemo {public static void main(String[] args) throws IOException {//Reader	字符输入流的父类//FileReader 文件字符输入流FileReader fr = new FileReader(new File("src/1.txt"));int n;while((n=fr.read())!=-1) {System.out.println((char)n);}char[] cs = new char[1024];while(fr.read(cs,1,3)!=-1) {System.out.println(new String(cs).trim());cs = new char[1024];}fr.close();//FileWriter 文件字符输出流//		FileWriter fw = new FileWriter(new File("src/1.txt"));fw.write("你吃了么?".toCharArray());fw.write(25105);fw.write((int)'我');
//		//参数为Stringfw.write("人情味儿发我放散阀");
//		fw.close();}}

八、嵌套流

流对象被其他处理流的多次连接，称为流的嵌套。

直接与数据源相连接的流是节点流

处理流连接节点流，提供附加性能

处理流可以被其它处理流继续连接，以获取需要的其它性能。

处理流不可以与节点（数据源）直接连接

image-20210721145536019

九、缓冲流

默认带了8192个字符的缓冲区，是为了提高性能，减少频繁和硬盘进行io的次数，

BufferedReader:处理流，字符输入流，是Reader的子类提供了readLine方法，很实用

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;public class BufferedReaderDemo {public static void main(String[] args) throws IOException {// BufferedReader//生成数据源File sourceFile = new File("src/1.txt");//生成节点流FileReader fr = new FileReader(sourceFile);//生成处理流 缓冲流BufferedReader br = new BufferedReader(fr);//boolean ready()返回true，则可以读while(br.ready()) {//String readLine()可以读出文件中的一行内容，如果没有则返回nullSystem.out.println(br.readLine());}br.close();}}

获得所有学生，并返回集合

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;public class StuDemo {public static void main(String[] args) throws IOException {//文件中读取内容，先封装成学生对象，再封装到集合中List<Stu> stuList = new ArrayList<Stu>();BufferedReader br = new BufferedReader(new FileReader(new File("src/stu.txt")));while(br.ready()) {//1,张三,18String stuStr = br.readLine();//{"1","张三","18"}String[] arr = stuStr.split(",");Stu stu = new Stu(Integer.parseInt(arr[0]),arr[1],Integer.parseInt(arr[2]));stuList.add(stu);}br.close();for (Stu stu : stuList) {System.out.println(stu);}}}

BufferedWriter:处理流，字符输出流，是Writer的子类，提供了newLine() write(str)方法

写入一个学生

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;public class BufferedWriterDemo {public static void main(String[] args) throws IOException {//BufferedWriterFile file = new File("src/stu.txt");//第二个参数为是否追加，true为追加写，false为覆盖写FileWriter fw = new FileWriter(file,true);BufferedWriter bw = new BufferedWriter(fw);Stu stu = new Stu(5,"田七",23);String str = stu.getSid()+","+stu.getSname()+","+stu.getSage();bw.write(str);bw.newLine();bw.close();}}

十、序列化

  1. 对象流

    • 对象输入流（ObjectInputStream）：

      ObjectInputStream in=newObjectInputStream(输入流对象);

      相应的方法：in.readObject();

    • 对象输出流（ObjectOutputStream）：

      ObjectOutputStream out=new ObjectOutputStream(输出流对象);

      相应的方法：out.writeObject(Object obj);

  2. 序列化

    • 序列化：就是将对象的内容分解成字节流，以便存储在文件中或在网络上传输。

      属性的要求：非transient 非静态 是可序列化类型（Serializable）

    • 反序列化：就是打开并读取字节流，且从该流中恢复该对象

      没有执行过反序列化的类型对应的代码块及构造方法

      能够序列化的对象必须是Serializable类型，对应的类型必须实现Serializable接口

    序列化类型中一般会要求提供一个serialVersionUID，作用是保证读（反序列化）和写（序列化）的过程中类型版本的一致性。如 写的时候版本id为1 那么读的时候版本id也必须是1，才能成功

     public static void write1() throws IOException{         //处理流           ObjectOutputStream writer=new ObjectOutputStream(new FileOutputStream(new File("src/data")));         for (int i = 0; i < 10; i++) {             Goods goods=new Goods("00"+i, "商品"+i, i+10.1f);             writer.writeObject(goods);        }         writer.flush();         writer.close();         }     
public static void read1() throws IOException, ClassNotFoundException{         //处理流           ObjectInputStream reader=new ObjectInputStream(new FileInputStream(new File("src/data")));         while(true){             try {                Object obj=reader.readObject();                System.out.println(obj);            } catch (EOFException e) {//EOFException:表示文件读取到末尾了                // TODO Auto-generated catch block                System.out.println("读取结束");                break;            }}reader.close();
}

    注意：使用EOFException判断文件是否读取到末尾

问题描述： 用类ObjectOutputStream向文件写读对象时，碰到一个问题：新建一个文件，用输出流ObjectOutputStream向文件连续写几个对象，关闭输出流，然 后读取，这些对象都可以读出；这时在向该文件增加对象，新写的对象就读不出了

问题出现的原因： ObjectOutputStream建立后第一次写入一个对象时， 会在对象数据前写入一些标志的数据“AC ED 00 05”（用二进制方式查看打开），应该是流相关的信息。当你关闭 ObjectOutputStream 后再重新打开往文件里面写对象时（append方式），就会再一次把“AC ED 00 05”写入文件，而这些信息并不是你写入对象的数据，所以当你用ObjectInputStream来读取对象时，流会将除第一个“AC ED 00 05”以外的数据当作各个对象的数据，造成无法解析，所以读取时有一个java.io.StreamCorruptedException出现。 这个可以通过编辑Info.dat来验证，只要将“AC ED 00 05”删除（第一个“AC ED 00 05”保留）就可以正常读出后来加入的对象。 给出一个比较笨的解决方法： 在以后要添加新的对象到Info.dat时，将里面原有的对象读出放入ArrayList中，清空文件，再将对象集一次写入。

尝试解决办法:

那个“AC ED 00 05”是 ObjectOutputStream.writeSystemHeader()写进去的，你可以继承ObjectOutputStream类，覆盖这个方法。 在你自己的writeSystemHeader()里判断是不是第一次写入一个文件，如果是向一个文件大小不为零的文件追加的话，就调用 super.reset(),如果是第一次写这个文件，不是追加，就调用super.writeSystemHeader()

/** * 此类继承ObjectOutputStream，重写writeStreamHeader()方法,以实现追加写入时去掉头部信息 */  
public static class MyObjectOutputStream extends ObjectOutputStream {  private static File f;  // writeStreamHeader()方法是在ObjectOutputStream的构造方法里调用的  // 由于覆盖后的writeStreamHeader()方法用到了f。如果直接用此构造方法创建  // 一个MyObjectOutputStream对象，那么writeStreamHeader()中的f是空指针  // 因为f还没有初始化。所以这里采用单态模式  private MyObjectOutputStream(OutputStream out, File f) throws IOException, SecurityException {  super(out);  }  // 返回一个MyObjectOutputStream对象，这里保证了new MyObjectOutputStream(out, f)  // 之前f已经指向一个File对象  public static MyObjectOutputStream newInstance(File file, OutputStream out) throws IOException {  f = file;// 本方法最重要的地方：构建文件对象，两个引用指向同一个文件对象  return new MyObjectOutputStream(out, f);  }  @Override  protected void writeStreamHeader() throws IOException {  // 文件不存在或文件为空,此时是第一次写入文件，所以要把头部信息写入。  if (!f.exists() || (f.exists() && f.length() == 0)) {  super.writeStreamHeader();  } else {  // 不需要做任何事情  }  }  
}  

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

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

相关文章

以用户为中心，酷开科技荣获“消费者服务之星”

以用户为中心，酷开科技荣获“消费者服务之星”

在企业顺应消费升级的道路中&#xff0c;企业自身不仅要着力强化对于消费者服务意识的提升&#xff0c;并且要树立诚信自律的行业示范带头作用&#xff0c;助力消费环境稳中向好&#xff0c;不断满足人民群众对美好生活的期待。企业的发展需要消费者的认可&#xff0c;酷开科技…
阅读更多...
常见的单片机及其功能

常见的单片机及其功能

在当今电子技术快速发展的时代&#xff0c;单片机作为核心组件&#xff0c;在各类电子项目和产品中扮演着至关重要的角色。它们的应用范围从简单的家用电器控制到复杂的工业自动化系统&#xff0c;几乎无处不在。接下来&#xff0c;我们将以轻松的语言&#xff0c;探讨几种广泛…
阅读更多...
放大器设计

放大器设计

目录 简介单阶段放大器：低噪声放大器例题例题2例题3简介 放大器能够放大信号，是电路设计中不可或缺的一种重要软件。根据应用和结构的不同，可以将放大器分为三类。 小信号：设计目标是在输入输出匹配条件下，获取一个特定的传输增益，对输出信号的功率没有要求。低噪声：相…
阅读更多...
Spring 如何解决循环依赖？Spring三级缓存

Spring 如何解决循环依赖？Spring三级缓存

什么是循环依赖 说白是一个或多个对象实例之间存在直接或间接的依赖关系&#xff0c;这种依赖关系构成了构成一个环形调用。 自己依赖自己 两个对象间的依赖关系 多个对象间的依赖关系 Spring出现循环依赖的场景 单例的setter注入 Service public class A {Resourceprivate…
阅读更多...
五(一)java高级-集合-集合与迭代器（二）

五(一)java高级-集合-集合与迭代器（二）

5.1.2 Iterator迭代器 1、Iterator 所谓迭代器&#xff1a;就是用于挨个访问集合元素的工具/对象 方法&#xff1a; boolean hasNext():判断当前遍历集合后面是否还有元素可以迭代Object next():取出当前元素&#xff0c;并往后移→noSuchelementExceptionvoid remove():删…
阅读更多...
通过容器化释放云的力量

通过容器化释放云的力量

NCSC (英国国家网络安全中心) 经常被问到的一个问题是是否在云中使用容器。这是一个简单的问题&#xff0c;但答案非常微妙&#xff0c;因为容器化的使用方式有很多种&#xff0c;其中一些方法比其他方法效果更好。 今天&#xff0c;我们发布了有关使用容器化的安全指南&#…
阅读更多...
「深度学习」dropout 技术

「深度学习」dropout 技术

一、工作原理 1. 正则化网络 dropout 将遍历网络的每一层&#xff0c;并设置消除神经网络中节点的概率。 1. 每个节点保留/消除的概率为0.5: 2. 消除节点&#xff1a; 3. 得到一个规模更小的神经网络&#xff1a; 2. dropout 技术 最常用&#xff1a;反向随机失活 "…
阅读更多...
锐捷（二十一）全局地址绑定

锐捷（二十一）全局地址绑定

vlan划分和vlanif接口配置略&#xff0c;注意vlanif接口里要no shutdown配置如下&#xff1a; Address-bind 192.168.1.1 AAAA.BBBB.CCCCAddress-bind uplink g0/0Address-bind binding-filter loggingAddress-bind install 此时&#xff0c;IP为192.168.1.1 mac地址为AAAA.B…
阅读更多...
『运维备忘录』之 Netstat 命令详解

『运维备忘录』之 Netstat 命令详解

运维人员不仅要熟悉操作系统、服务器、网络等只是&#xff0c;甚至对于开发相关的也要有所了解。很多运维工作者可能一时半会记不住那么多命令、代码、方法、原理或者用法等等。这里我将结合自身工作&#xff0c;持续给大家更新运维工作所需要接触到的知识点&#xff0c;希望大…
阅读更多...
GaussDB HCS 轻量化部署软件下载指引

GaussDB HCS 轻量化部署软件下载指引

一、Support 账号准备 1. 账号说明 华为的软件服务在华为support网站发布&#xff0c;注册该账号后&#xff0c;可以申请软件、下载离线文档&#xff0c;查看技术案例等功能 2. 账号注册 步骤 1&#xff1a;点击如下官方链接 华为运营商技术支持 - 华为 步骤 2&#xff1…
阅读更多...
kafka教程

kafka教程

Kafka 中&#xff0c;Producer采用push模型&#xff0c;而Consumer采用pull模型。 Topic Topic&#xff08;主题&#xff09;是消息的逻辑分类或通道。它是Kafka中用于组织和存储消息的基本单元。一个Topic可以被看作是一个消息发布的地方&#xff0c;生产者将消息发布到一个…
阅读更多...
机器学习9-随机森林

机器学习9-随机森林

随机森林&#xff08;Random Forest&#xff09;是一种集成学习方法&#xff0c;用于改善单一决策树的性能&#xff0c;通过在数据集上构建多个决策树并组合它们的预测结果。它属于一种被称为“集成学习”或“集成学习器”的机器学习范畴。 以下是随机森林的主要特点和原理&…
阅读更多...
IT行业含金量高的证书-软考

IT行业含金量高的证书-软考

软考全称计算机技术与软件专业技术资格&#xff08;水平&#xff09;考试&#xff0c;软考既是职业资格考试&#xff0c;又是职称资格考试。2021年12月2号发布新版的国家职业资格目录&#xff0c;软考是在计算机技术领域中的唯一的国家职业资格。 一、好处 软考是一个神奇又特…
阅读更多...
【数据结构】14 队列（带头结点的链式存储和顺序存储实现）

【数据结构】14 队列（带头结点的链式存储和顺序存储实现）

定义 队列是一个有序线性表&#xff0c;但是队列的插入、删除操作是分别在线性表的两个不同端点进行的。 设一个队列 Q ( a 1 , a 2 , . . . , a n ) Q (a_1, a_2,...,a_n) Q(a1​,a2​,...,an​)&#xff0c;那么 a 1 a_1 a1​被称为队头元素&#xff0c; a n a_n an​为队…
阅读更多...
手把手教你开发Python桌面应用-PyQt6图书管理系统-图书信息修改实现

手把手教你开发Python桌面应用-PyQt6图书管理系统-图书信息修改实现

锋哥原创的PyQt6图书管理系统视频教程&#xff1a; PyQt6图书管理系统视频教程 Python桌面开发 Python入门级项目实战 (无废话版) 火爆连载更新中~_哔哩哔哩_bilibiliPyQt6图书管理系统视频教程 Python桌面开发 Python入门级项目实战 (无废话版) 火爆连载更新中~共计24条视频&…
阅读更多...
从互联网的公开信息中，找到属于你的赚钱思路

从互联网的公开信息中，找到属于你的赚钱思路

一、教程描述 人们在互联网上的每一次搜索、每一次关注、每一次点击、每一次点赞、每一次评论、每一次付费&#xff0c;都生成了大量的数据和信息&#xff0c;暴露着人们的真实想法、欲望、恐惧和需求。这些数据和信息&#xff0c;就是我们身边的一座“金矿”&#xff0c;而大…
阅读更多...
1【算法】——最大子数组问题（maximum subarray）

1【算法】——最大子数组问题（maximum subarray）

一.问题描述 假如我们有一个数组&#xff0c;数组中的元素有正数和负数&#xff0c;如何在数组中找到一段连续的子数组&#xff0c;使得子数组各个元素之和最大。 二.问题分析 分治法求解&#xff1a; 初始状态&#xff1a; low0&#xff1b;highA.length-1&#xff1b;mid&am…
阅读更多...
最新的 Ivanti SSRF 零日漏洞正在被大规模利用

最新的 Ivanti SSRF 零日漏洞正在被大规模利用

Bleeping Computer 网站消息&#xff0c;安全研究员发现 Ivanti Connect Secure 和 Ivanti Policy Secure 服务器端请求伪造 (SSRF) 漏洞&#xff08;CVE-2024-21893 &#xff09;正在被多个威胁攻击者大规模利用。 2024 年 1 月 31 日&#xff0c;Ivanti 首次就网关 SAML 组件…
阅读更多...
万维网的文档

万维网的文档

目录 1 万维网的文档 动态万维网文档 CGI CGI 网关程序 活动万维网文档 用 Java 语言创建活动文档 1 万维网的文档 分为&#xff1a; 静态万维网文档。内容不会改变。简单。(html、xml、css) 动态万维网文档。文档的内容由应用程序动态创建。 活动万维网文档。由浏览器端…
阅读更多...
SpringBoot3整合Knife4j

SpringBoot3整合Knife4j

前置&#xff1a; 官网&#xff1a;快速开始 | Knife4j gitee&#xff1a;swagger-bootstrap-ui-demo: knife4j 以及swagger-bootstrap-ui 集成框架示例项目 - Gitee.com 1.依赖引入&#xff1a; ps&#xff1a;json处理需要引入相关包 <dependency><groupId>c…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023