IO流----字节流

字节流

  • 字节流：
    • 操作：
      • 文件字节输入输出流 ：
        • 写入数据：
        • 读取数据：
        • 文件拷贝：
      • 带缓冲区的字节输入输出流：
        • 拷贝文件：
        • 写入数据：
        • 读取数据:
    • 深入 带缓冲区的字节输出流 ：
      • 底层源码：

字节流：

应用场景：操作二进制数据（音频、视频、图片）

abstract class InputStream – 字节输入流的基类（抽象类）

abstract class OutputStream – 字节输出流的基类（抽象类）

class FileInputStream extends InputStream – 文件字节输入流

class FileOutputStream extends OutputStream – 文件字节输出流

class FilterInputStream extends InputStream – 过滤器字节输入流

class FilterOutputStream extends OutputStream – 过滤器字节输出流

class BufferedInputStream extends FilterInputStream – 带缓冲区的字节输入流

class BufferedOutputStream extends FilterOutputStream – 带缓冲区的字节输出流

默认缓冲区大小：8192字节----> new byte[8192]

在这里插入图片描述

 
 

操作：

文件字节输入输出流 ：

写入数据：

利用 文件字节输出流 向文件 写入 数据。
 
​        1. 不处理异常

​        2. 当文件存在时

​        3. 当文件不存在时
 
经验：所有的输出流，当文件不存在时都会创建该文件。

public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		FileOutputStream fos = new FileOutputStream("io.txt");
		
		//2.写入数据
		//fos.write(97);//写入UniCode码
		//fos.write("123abc".getBytes());//字符串转为byte数组，并写入文件中
		fos.write("123abc".getBytes(), 2, 3);//写入byte数组、偏移量、写入长度
		
		//3.关闭资源
		fos.close();
		
	}

 
 

利用 文件字节输出流 向文件 写入 数据。
 
​        1. 不处理异常

​        2. 当文件存在时

​        3. 当文件不存在时

​        4. 在文件末尾追加内容
 
经验：在文件末尾追加考虑基础流的构造方法。

public static void main(String[] args) throws IOException {
		
		//1.创建流对象 + 设置在文件末尾追加
		FileOutputStream fos = new FileOutputStream("io.txt",true);
		
		//2.写入数据
		fos.write("123abc".getBytes());//写入byte数组
		
		//3.关闭资源
		fos.close();
		
	}

 
 

利用 文件字节输出流 向文件 写入 数据。
 
​        1. 不处理异常

​        2. 当文件存在时

​        3. 当文件不存在时

​        4. 在文件末尾追加内容

​        5. 处理异常

public static void main(String[] args) {
		
		
		FileOutputStream fos = null;
		try {
			//1.创建流对象 + 设置在文件末尾追加
			fos = new FileOutputStream("io.txt",true);
			
			//2.写入数据
			fos.write("123abc".getBytes());//写入byte数组
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			
			//3.关闭资源
			if(fos != null){
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

 
 

读取数据：

利用 文件字节输入流 读取文件里的数据。
 
​        1. 不处理异常

​        2. 文件存在

public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		FileInputStream fis = new FileInputStream("io.txt");
		
		//2.读取数据
		//read()：一个字节一个字节的读取数据，读取到文件末尾返回-1
		int read = fis.read();
		System.out.println(read);
		read = fis.read();
		System.out.println(read);
		read = fis.read();
		System.out.println(read);
		read = fis.read();
		System.out.println(read);
		read = fis.read();
		System.out.println(read);
		read = fis.read();
		System.out.println(read);
		read = fis.read();
		System.out.println(read);
		
		
		//3.关闭资源
		fis.close();
	}

 
 

改进：

public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		FileInputStream fis = new FileInputStream("io.txt");
		
		//2.读取数据
		//read()：一个字节一个字节的读取数据，读取到文件末尾返回-1
		int read;
		while((read = fis.read()) != -1){
			System.out.println((char)read);
		}
		
		
		//3.关闭资源
		fis.close();
	}

 
 

再改进：

public static void main(String[] args) throws IOException{
		
		//1.创建流对象
		FileInputStream fis = new FileInputStream("io.txt");
		
		//2.读取数据
		//read(bs)：读取bs长度的数据，并把数据放入数组，返回读取到的有效字节数，如果读取到文件末尾则返回-1
		byte[] bs = new byte[1024];
		int len;
		while((len = fis.read(bs)) != -1){
			System.out.println(new String(bs, 0, len));
		}
		
		
		//3.关闭资源
		fis.close();
	}

 
 

利用 文件字节输入流 读取文件里的数据。

​        1. 不处理异常

​        2. 文件存在

​        3. 文件不存在

​        4. 处理异常

public static void main(String[] args){
		
		
		FileInputStream fis = null;
		try {
			//1.创建流对象
			fis = new FileInputStream("io.txt");
			
			//2.读取数据
			//read(bs)：读取bs长度的数据，并把数据放入数组，返回读取到的有效字节数，如果读取到文件末尾则返回-1
			byte[] bs = new byte[1024];
			int len;
			while((len = fis.read(bs)) != -1){
				System.out.println(new String(bs, 0, len));
			}
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			//3.关闭资源
			if(fis != null){
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		
	}

 
 

文件拷贝：

读取源文件，写入目标文件。

public static void main(String[] args) throws IOException {
		
		FileInputStream fis = new FileInputStream("Original.mp4");
		FileOutputStream fos = new FileOutputStream("copy.mp4");
		
    	//一个一个字节的拷贝，速度太慢
		int read;
		while((read = fis.read()) != -1){
			fos.write(read);
		}
		
		fis.close();
		fos.close();
	}

 
 

改进:

public static void main(String[] args) throws IOException {
		
		FileInputStream fis = new FileInputStream("Original.mp4");
		FileOutputStream fos = new FileOutputStream("copy.mp4");
		//read(bs)：读取bs长度的数据，并把数据放入数组，
    	//返回读取到的有效字节数，如果读取到文件末尾则返回-1
		byte[] bs = new byte[1024];
		int len;
		while((len = fis.read(bs)) != -1){
			fos.write(bs, 0, len);
		}
		
		fis.close();
		fos.close();
	}

 
 

异常处理：

public static void main(String[] args){
		
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try {
			fis = new FileInputStream("Original.mp4");
			fos = new FileOutputStream("copy.mp4");
			
			byte[] bs = new byte[1024];
			int len;
			while((len = fis.read(bs)) != -1){
				fos.write(bs, 0, len);
			}
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			
			if(fis != null){
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			
			if(fos != null){
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

 
 

改进：

public static void main(String[] args){
		
		//注意：小括号里创建的流会在try...catch后自动关闭
		try(FileInputStream fis = new FileInputStream("Original.mp4");
				FileOutputStream fos = new FileOutputStream("copy.mp4");) {
			
			byte[] bs = new byte[1024];
			int len;
			while((len = fis.read(bs)) != -1){
				fos.write(bs, 0, len);
			}
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

 
 

带缓冲区的字节输入输出流：

拷贝文件：
public static void main(String[] args) throws IOException {
		
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("Original.mp4"));
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.mp4"));
		
		byte[] bs = new byte[1024];
		int len;
		while((len = bis.read(bs)) != -1){
			bos.write(bs, 0, len);
		}
		
		bis.close();
		bos.close();
	}

 
 

写入数据：

利用 带缓冲区的字节输出流 向文件写入数据
 
​ 1. 不处理异常的方式

​ 2. 文件存在的情况
3. 文件不存在的情况
 
经验：所有的输出流，文件不存在的情况都会创建文件。

public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("io.txt"));
		
		//2.写入数据
		bos.write("123abc".getBytes());
		
		//3.关闭资源
		bos.close();
		
	}

 
 

利用 带缓冲区的字节输出流 向文件写入数据
 

  1. 不处理异常的方式

  2. 文件存在的情况

  3. 文件不存在的情况

  4. 在文件末尾追加内容
     
    经验：在文件末尾追加考虑基础流的构造方法。

public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("io.txt",true));
		
		//2.写入数据
		bos.write("123abc".getBytes());
		
		//3.关闭资源
		bos.close();
		
	}

 
 

利用 带缓冲区的字节输出流 向文件写入数据
 

  1. 不处理异常的方式

  2. 文件存在的情况

  3. 文件不存在的情况

  4. 在文件末尾追加内容

  5. 处理异常

public static void main(String[] args){
		
		
		BufferedOutputStream bos = null;
		try {
			//1.创建流对象
			bos = new BufferedOutputStream(new FileOutputStream("io.txt",true));
			//2.写入数据
			bos.write("123abc".getBytes());
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			//3.关闭资源
			if(bos != null){
				try {
					bos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

 
 

读取数据:

利用 带有缓冲区的字节输入流 读取文件里的数据。
 

  1. 不处理异常

  2. 文件存在

  3. 文件不存在
     
    经验：所有输入流，当文件不存在都会报错

public static void main(String[] args) throws IOException {
		
		//1.创建流对象 （默认缓冲区大小：8192字节）
		//BufferedInputStream bis = new BufferedInputStream(new FileInputStream("io.txt"));
		
		//1.创建流对象 （自定义缓冲区大小：2048字节）
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("io.txt"),2048);
		
		//2.读取数据 
		byte[] bs = new byte[1024];
		int len;
		while((len = bis.read(bs)) != -1){
			System.out.println(new String(bs, 0, len));
		}
		
		//3.关闭资源
		bis.close();
	}

 
 

利用 带有缓冲区的字节输入流 读取文件里的数据。
 

  1. 不处理异常
  2. 文件存在
  3. 文件不存在
  4. 异常处理
public static void main(String[] args) {
		
		
		BufferedInputStream bis = null;
		try {
			//1.创建流对象 （默认缓冲区大小：8192字节）
			bis = new BufferedInputStream(new FileInputStream("io.txt"));
			
			//2.读取数据 
			byte[] bs = new byte[1024];
			int len;
			while((len = bis.read(bs)) != -1){
				System.out.println(new String(bs, 0, len));
			}
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			//3.关闭资源
			if(bis != null){
				try {
					bis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

 
 

深入 带缓冲区的字节输出流 ：

public static void main(String[] args) throws IOException{
		
//		FileOutputStream fos = new FileOutputStream("io.txt");
//		//写几次，就和硬盘交互几次  -- 6次（内存与硬盘交互的次数）
//		fos.write("1".getBytes());
//		fos.write("2".getBytes());
//		fos.write("3".getBytes());
//		fos.write("a".getBytes());
//		fos.write("b".getBytes());
//		fos.write("c".getBytes());
//		fos.close();
		
//		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("io.txt"));
//		//将数据写入到字节缓冲数组中 -- 1次（内存与硬盘交互的次数）
//		bos.write("1".getBytes());
//		bos.write("2".getBytes());
//		bos.write("3".getBytes());
//		bos.write("a".getBytes());
//		bos.write("b".getBytes());
//		bos.write("c".getBytes());
//		//关闭时才将数据写入到文件中
//		bos.close();
		
		//默认缓冲区 -- 8192个字节(8*1024)
		//BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("io.txt"));
		
		//自定义缓冲区大小 -- 2048个字节
//		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("io.txt"), 2048);
	}

 
 

底层源码：

//继承关系
public class FilterOutputStream extends OutputStream {
    
	protected OutputStream out;//0x001
    
    //out - 0x001
    public FilterOutputStream(OutputStream out) {
        this.out = out;
    }
    
    //b - [65]
    public void write(byte[] b) throws IOException {
        this.write(b, 0, b.length);
    }
    
    @SuppressWarnings("try")
    public void close() throws IOException {
        try (OutputStream ostream = out) {
            flush();
        }
    }
}

//源码
public class BufferedOutputStream extends FilterOutputStream {
    //缓冲区数组
    protected byte[] buf;//new byte[8192]
    //缓冲区存放数据的个数
    protected int count;//1
    
    //out - 0x001
    public BufferedOutputStream(OutputStream out) {
        this(out, 8192);
    }
    
    //out - 0x001
    //size - 8192
    public BufferedOutputStream(OutputStream out, int size) {
        super(out);
        if (size <= 0) {
            throw new IllegalArgumentException("Buffer size <= 0");
        }
        buf = new byte[size];
    }
    
    //b - [65]
    //off - 0
    //len - 1
    public synchronized void write(byte b[], int off, int len) throws IOException {
        //判断现在需要写出的数据长度是否大于缓冲区数组
        if (len >= buf.length) {//1 >= 8192
            //将缓冲区数组里的数据写入到文件,将缓冲区清空
            flushBuffer();
            //将线程需要写出的数据写入到文件
            out.write(b, off, len);
            return;
        }
        
        //判断现在需要写出的数据长度 超过了缓冲区剩余的存储长度
        if (len > buf.length - count) {//1 > 8192-0
            //将缓冲区数组里的数据写入到文件,将缓冲区清空
            flushBuffer();
        }
        //将数据写入到缓冲区数组里
        System.arraycopy(b, off, buf, count, len);
        //更新缓冲区数组数据个数
        count += len;
    }
    
    private void flushBuffer() throws IOException {
        //count > 0说明缓冲区数组里有数据
        if (count > 0) {
            super.out.write(buf, 0, count);//调用的是FileOutputSteam的write()
            count = 0;//缓冲区清空
        }
    }
    
    public synchronized void flush() throws IOException {
        //将缓冲区数组里的数据写入到文件,将缓冲区清空
        flushBuffer();
        super.out.flush();//调用的是FileOutputSteam的close() -- 关流
    }
}

//应用场景
FileOutputStream fos = new FileOutputStream("io.txt");//0x001
BufferedOutputStream bos = new BufferedOutputStream(fos);

bos.write("1".getBytes());
bos.write("2".getBytes());
bos.write("3".getBytes());
bos.write("a".getBytes());
bos.write("b".getBytes());
bos.write("c".getBytes());

bos.close();

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

C语言基础学习之位运算

C语言基础学习之位运算

枚举类型 enum 枚举名 { 枚举常量 //名字 }; 注意: 1.c语言中 对于枚举类型 实际上是 当作整型处理的 2.提高代码可读性&#xff0c; 写成枚举&#xff0c;可以做语法检查 3.枚举常量&#xff0c;之间用逗号隔开 4.枚举常量&#xff0c;可以给初值&#xff0c;给了初值之后&…
阅读更多...
React（五）useEffect、useRef、useImperativeHandle、useLayoutEffect

React（五）useEffect、useRef、useImperativeHandle、useLayoutEffect

(一)useEffect useEffect – React 中文文档 useEffect hook用于模拟以前的class组件的生命周期&#xff0c;但比原本的生命周期有着更强大的功能 1.类组件的生命周期 在类组件编程时&#xff0c;网络请求&#xff0c;订阅等操作都是在生命周期中完成 import React, { Com…
阅读更多...
二叉树练习题（2024/6/5）

二叉树练习题（2024/6/5）

1翻转二叉树 给你一棵二叉树的根节点 root &#xff0c;翻转这棵二叉树&#xff0c;并返回其根节点。 示例 1&#xff1a; 输入&#xff1a;root [4,2,7,1,3,6,9] 输出&#xff1a;[4,7,2,9,6,3,1]示例 2&#xff1a; 输入&#xff1a;root [2,1,3] 输出&#xff1a;[2,3,1]…
阅读更多...
空间不够用了怎么办

空间不够用了怎么办

空间告急啊哥们 整理一下清理空间有用的一些blog吧。 【linux】公共服务器如何清理过多的.cache缓存 linux根目录空间不足&#xff0c;追加空间到根目录下 【linux】linux磁盘空间 目录查看清理 和 文件查看清理
阅读更多...
windows系统 flutter 开发环境配置

windows系统 flutter 开发环境配置

1、管理员运行powershell&#xff0c;安装&#xff1a;Chocolatey 工具&#xff0c;粘贴复制运行下列脚本: Chocolatey 官方安装文档 Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol [System.Net.ServicePointManage…
阅读更多...
韩顺平0基础学Java——第17天

韩顺平0基础学Java——第17天

p342-373 上课的时候一部分在纸上写过了&#xff0c;就不在这里复盘了。 this可以调用本类的所有方法&#xff0c;super可以调用父类的非private方法 Test Demo Rose Jack John jack 重写equals方法&#xff1a; 15&#xff1a; 1.调用C的有参构造器 2.进入B的有参构造器…
阅读更多...
数字化营销有哪些模式？企业采用数字营销方式有什么意义？

数字化营销有哪些模式？企业采用数字营销方式有什么意义？

在当今快速发展的商业环境中&#xff0c;营销已经远远超越了传统的推广和销售概念&#xff0c;演变成一种复杂而全面的组织职能。随着信息技术的飞速发展&#xff0c;数字化营销应运而生&#xff0c;为企业与消费者之间的互动带来了革命性的改变。数字化营销不仅为企业提供了全…
阅读更多...
Spark SQL - 操作数据帧

Spark SQL - 操作数据帧

本教程将通过一个具体的案例来演示如何在Spark SQL中操作数据帧。我们将从获取学生数据帧开始&#xff0c;包括两种方法&#xff1a;一是由数据集转换而来&#xff0c;二是直接读取文件生成数据帧。然后&#xff0c;我们将对数据帧进行各种操作&#xff0c;如投影、过滤、统计和…
阅读更多...
SpringCache 缓存 - @Cacheable、@CacheEvict、@CachePut、@Caching、CacheConfig 以及优劣分析

SpringCache 缓存 - @Cacheable、@CacheEvict、@CachePut、@Caching、CacheConfig 以及优劣分析

目录 SpringCache 缓存 环境配置 1&#xff09;依赖如下 2&#xff09;配置文件 3&#xff09;设置缓存的 value 序列化为 JSON 格式 4&#xff09;EnableCaching 实战开发 Cacheable CacheEvict CachePut Caching CacheConfig SpringCache 的优势和劣势 读操作…
阅读更多...
【网络协议 | HTTP】HTTP总结与全梳理（一） —— HTTP协议超详细教程

【网络协议 | HTTP】HTTP总结与全梳理（一） —— HTTP协议超详细教程

&#x1f525;博客简介&#xff1a;开了几个专栏&#xff0c;针对 Linux 和 rtos 系统&#xff0c;嵌入式开发和音视频开发&#xff0c;结合多年工作经验&#xff0c;跟大家分享交流嵌入式软硬件技术、音视频技术的干货。   ✍️系列专栏&#xff1a;C/C、Linux、rtos、嵌入式…
阅读更多...
nginx代理vue项目路由跳转刷新

nginx代理vue项目路由跳转刷新

常规代理 在我们日常开发中&#xff0c;前端部署到服务器&#xff0c;需要用到nginx部署&#xff0c;简单代理如下&#xff1a; #user nobody; worker_processes 1;#error_log logs/error.log; #error_log logs/error.log notice; #error_log logs/error.log info;#pid…
阅读更多...
GPT革命：AI如何重塑我们的未来！

GPT革命：AI如何重塑我们的未来！

GPT革命&#xff1a;AI如何重塑我们的未来&#xff01; &#x1f604;生命不息&#xff0c;写作不止 &#x1f525; 继续踏上学习之路&#xff0c;学之分享笔记 &#x1f44a; 总有一天我也能像各位大佬一样 &#x1f3c6; 博客首页 怒放吧德德 To记录领地 &#x1f31d;分享…
阅读更多...
并查集算法

并查集算法

目录 1.算法介绍 1.1什么是并查集呢&#xff0c;它又是用来干什么的呢&#xff1f; 1.2问题引入 2.算法解析 2.1初始化 2.2合并操作 2.3查找 路径压缩 2.4问题解决代码 3.变式突破 1.算法介绍 1.1什么是并查集呢&#xff0c;它又是用来干什么的呢&#xff1f; 逐字拆…
阅读更多...
经典的泡泡龙游戏源码免费下载

经典的泡泡龙游戏源码免费下载

源码介绍 HTML5泡泡龙冒险小游戏是一款休闲网页游戏&#xff0c;游戏玩法是玩家从下方中央的弹珠发射台射出彩珠&#xff0c;多于3个同色珠相连则会消失。 源码下载 经典的泡泡龙游戏源码免费下载
阅读更多...
【Python绘画】画正方形简笔画

【Python绘画】画正方形简笔画

本文收录于 《一起学Python趣味编程》专栏&#xff0c;从零基础开始&#xff0c;分享一些Python编程知识&#xff0c;欢迎关注&#xff0c;谢谢&#xff01; 文章目录 一、前言二、代码示例三、知识点梳理四、总结 一、前言 本文介绍如何使用Python的海龟画图工具turtle&#…
阅读更多...
docker-compose入门级实战教程

docker-compose入门级实战教程

&#x1f31f;&#x1f30c; 欢迎来到知识与创意的殿堂 — 远见阁小民的世界&#xff01;&#x1f680; &#x1f31f;&#x1f9ed; 在这里&#xff0c;我们一起探索技术的奥秘&#xff0c;一起在知识的海洋中遨游。 &#x1f31f;&#x1f9ed; 在这里&#xff0c;每个错误都…
阅读更多...
Flutter Bloc之简单记录

Flutter Bloc之简单记录

目录 0.库安装 1.插件和自动生成 2.状态的配置 1.初始化中&#xff1a; 2.赋值完成后&#xff1a; 3.如果出错&#xff1a; 3.事件的配置 1.定义一个读取事件 2.定义一个更改事件 4.Bloc的设置 5.Bloc的使用 1.BlocProvider 2.内部调用 参考文章进行类的配置 0.库…
阅读更多...
【ARM Cache 系列文章 2.1 -- Cache PoP 及 PoDP 介绍】

【ARM Cache 系列文章 2.1 -- Cache PoP 及 PoDP 介绍】

请阅读【ARM Cache 及 MMU/MPU 系列文章专栏导读】 及【嵌入式开发学习必备专栏】 文章目录 PoP 及 PoDPCache PoDPCache PoP应用和影响PoP 及 PoDP Cache PoDP 点对深度持久性（Point of Deep Persistence, PoDP）是内存系统中的一个点，在该点达到的任何写操作即使在系统供电…
阅读更多...
跳跃游戏二

跳跃游戏二

方法一&#xff1a;&#xff08;双指针法&#xff09;此题参考跳台阶问题&#xff0c;题目要求求到达最后一个点的最小跳跃次数&#xff0c;那么我们就可以从最后一个往前推&#xff0c;先看谁能离得最远&#xff0c;并且能跳到最后一个。假设i位置是离最后一个位置最远&#x…
阅读更多...
网工内推 | 联通公司，云计算售前，AWS认证优先

网工内推 | 联通公司，云计算售前，AWS认证优先

01 联通数字科技有限公司 &#x1f537;招聘岗位&#xff1a;云计算售前工程师 &#x1f537;职责描述&#xff1a; 1.了解私有云&#xff0c;公有云&#xff0c;混合云等云计算技术知识&#xff0c;了解云计算行业现状及发展趋势。 2.承担区域项目售前工作支持&#xff0c;为…
阅读更多...
最新文章

Copyright @ 2022~2023