【18】JAVASE-IO专题【从零开始学JAVA】

Java零基础系列课程-JavaSE基础篇

Lecture：波哥

在这里插入图片描述

  Java 是第一大编程语言和开发平台。它有助于企业降低成本、缩短开发周期、推动创新以及改善应用服务。如今全球有数百万开发人员运行着超过 51 亿个 Java 虚拟机，Java 仍是企业和开发人员的首选开发平台。

一、File类

文件和目录路径名的抽象表示

1.静态属性

static String	pathSeparator
//与系统相关的路径分隔符字符，为方便起见，表示为字符串。
static char	pathSeparatorChar
//与系统相关的路径分隔符。
static String	separator
//与系统相关的默认名称 - 分隔符字符，以方便的方式表示为字符串。
static char	separatorChar
//与系统相关的默认名称分隔符。

/*** File*     静态属性* @param args*/
public static void main(String[] args) {System.out.println(File.pathSeparator);System.out.println(File.pathSeparatorChar);System.out.println(File.separator);System.out.println(File.separatorChar);
}

输出结果：

;
;
\
\

举例：D:\tools\P4课程资料\011 IO流 Windows下的路径表示

​ D:/tools/P4课程资料/011 IO流 Linux操作系统下面路径的表示方式和Windows中的表示是不一样

​

2.构造方法

File(File parent, String child)
//从父抽象路径名和子路径名字符串创建新的 File实例。
File(String pathname)
//通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
File(String parent, String child)
//从父路径名字符串和子路径名字符串创建新的 File实例。
File(URI uri)
//通过将给定的 file: URI转换为抽象路径名来创建新的 File实例。

public static void main(String[] args) {File f1 = new File("D:\\tools\\io\\b.txt");System.out.println(f1);File f2 = new File("D:\\tools\\io\\","c.txt");System.out.println(f2);File f3 = new File("d:/tools/io");System.out.println(f3);File f4 = new File(f3,"d.txt");}

D:\tools\io\b.txt
D:\tools\io\c.txt
d:\tools\io

相对路径和绝对路径的问题

绝对路径: 盘符开头(D: http: ftp:)

相对路径：不以盘符开头

/*** File*    相对路径和绝对路径* @param args*/
public static void main(String[] args) {// 绝对路径File f1 = new File("d:/tools/io/a.txt");// 相对路径File f2 = new File("a.txt");System.out.println(f2.getAbsolutePath());File f3 = new File("src/com/bobo/file/FileDemo03.java");System.out.println(f3.getAbsolutePath());
}

输出结果：

D:\workspace\IdeaWorkSpace\JavaSEProject14\a.txt
D:\workspace\IdeaWorkSpace\JavaSEProject14\src\com\bobo\file\FileDemo03.java

3.File操作

3.1 创建文件

boolean	createNewFile()
//当且仅当具有该名称的文件尚不存在时，原子地创建一个由该抽象路径名命名的新的空文件。
boolean	mkdir()
//创建由此抽象路径名命名的目录。
boolean	mkdirs()
//创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录。

package com.bobo.file;import java.io.File;
import java.io.IOException;public class FileDemo04 {/*** File*    创建文件及文件夹* @param args*/public static void main(String[] args) throws IOException {File f1 = new File("a.txt");// 如果路径有问题 那么就会创建失败  返回true 创建成功  false 说明文件存在创建失败boolean b1 = f1.createNewFile();System.out.println(b1);b1 = f1.createNewFile();System.out.println(b1);File f2 = new File("test");// createNewFile 只能够创建文件 不能够创建文件夹b1 = f2.createNewFile();System.out.println(b1);// 创建文件夹/目录File f3 = new File("a");b1 = f3.mkdir(); // 创建一个目录  创建成功true  存在 返回falseSystem.out.println(b1);File f4 = new File("a/b/c/d");// 创建的目录的父目录不存在，那么 mkdir是不会创建成功的b1 = f4.mkdir();System.out.println(b1);// mkdirs 如果父目录不存在会先创建该目录b1 = f4.mkdirs();System.out.println(b1);}
}

在这里插入图片描述

3.2 删除文件

​ delete方法可以删除文件和目录，注意：delete不能删除非空的目录，这时我们就需要逐级的删除文件及文件夹

boolean	delete()
// 删除由此抽象路径名表示的文件或目录

/*** File*    删除* @param args*/
public static void main(String[] args) {File f1 = new File("a.txt");System.out.println(f1.delete());File f2 = new File("test");System.out.println(f2.delete());File f3 = new File("a/b/c/d");System.out.println(f3.delete());File f4 = new File("a/b/c");System.out.println(f4.delete());
}

3.3 修改功能

​ 在File中的修改其实就是修改File名称

/*** File*     修改  renameTo* @param args*/
public static void main(String[] args) throws IOException {// 修改目录的名称/*File f1 = new File("a");System.out.println(f1.renameTo(new File("hello")));// 修改文件的名称File f2 = new File("hello/a.txt");boolean newFile = f2.createNewFile();System.out.println(newFile);*/File f2 = new File("hello/a.txt");System.out.println(f2.renameTo(new File("User.java")));
}

3.4 文件的判断功能

	public boolean isFile()  是否文件public boolean isDirectory()  是否目录public boolean canRead()  是否可读public boolean canWrite()  是否可写public boolean exists()  是否存在public boolean isHidden()  是否隐藏public long length()  长度public String getAbsolutePath()  绝对路径public String getPath()  定义的路径public String getName()  file名字public long lastModified()  最后一次修改时间

public static void main(String[] args) {File f1 = new File("User.java");// 判断是否是文件System.out.println(f1.isFile());// 判断是否是目录System.out.println(f1.isDirectory());// 判断是否可读System.out.println(f1.canRead());// 判断是否可写System.out.println(f1.canWrite());// 判断是否存在System.out.println(f1.exists());// 判断是否隐藏System.out.println(f1.isHidden());// 长度System.out.println(f1.length());// 获取绝对路径System.out.println(f1.getAbsolutePath());// 定义的路径System.out.println(f1.getParent());// 获取文件名称System.out.println(f1.getName());// 获取最后一次修改时间System.out.println(f1.lastModified());Date d = new Date(f1.lastModified());SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");System.out.println(sdf.format(d));
}

输出结果

true
false
true
true
true
false
0
D:\workspace\IdeaWorkSpace\JavaSEProject14\User.java
null
User.java
1607758080631
2020-12-12 15:28:00

3.5 遍历功能

​ 获取文件夹下的所有的文件

String[]	list()
//返回一个字符串数组，命名由此抽象路径名表示的目录中的文件和目录。
String[]	list(FilenameFilter filter)
//返回一个字符串数组，命名由此抽象路径名表示的目录中满足指定过滤器的文件和目录。
File[]	listFiles()
//返回一个抽象路径名数组，表示由该抽象路径名表示的目录中的文件。
File[]	listFiles(FileFilter filter)
//返回一个抽象路径名数组，表示由此抽象路径名表示的满足指定过滤器的目录中的文件和目录。
File[]	listFiles(FilenameFilter filter)
//返回一个抽象路径名数组，表示由此抽象路径名表示的满足指定过滤器的目录中的文件和目录。
static File[]	listRoots()
// 列出可用的文件系统根。

package com.bobo.file;import java.io.File;public class FileDemo08 {/*** File 遍历功能** @param args*/public static void main(String[] args) {File f1 = new File("D:\\tools\\io");// 遍历功能String[] list = f1.list();for(String fileName : list){System.out.println(fileName);}System.out.println("-----------------------");File[] files = f1.listFiles();for(File file:files){System.out.println(file.getAbsoluteFile());System.out.println(file.getName());System.out.println(file.length());System.out.println("***********");}}
}
public class FileDemo09 {/*** File 遍历功能** @param args*/public static void main(String[] args) {File f1 = new File("D:\\tools\\io");String[] list = f1.list(new FilenameFilter() {/*** 添加过滤条件* @param dir  目录* @param name  文件名称* @return*    true 获取*    false  过滤*/@Overridepublic boolean accept(File dir, String name) {// System.out.println(dir.getName()+ "----" + name);if(name.endsWith(".txt")){return true;}return false;}});for(String fileName:list){System.out.println(fileName);}}
}

public class FileDemo10 {/*** File 遍历功能** @param args*/public static void main(String[] args) {File f1 = new File("D:\\tools\\io");File[] files = f1.listFiles(new FileFilter() {/*** 获取目录下的所有的File，然后对File过滤* @param pathname* @return*/@Overridepublic boolean accept(File pathname) {return pathname.getName().startsWith("a");}});for (File file:files){System.out.println(file.getName());}}
}

3.6 课堂案例

判断某个目录下是否有后缀为.java的文件，如果有，统计该文件的个数，并输出次文件名称

package com.bobo.file;import java.io.File;
import java.io.FileFilter;public class FileDemo12 {/*** 判断某个目录下是否有后缀为.java的文件，如果有，统计该文件的个数，并输出次文件名称* @param args*/public static void main(String[] args) {File path = new File("d:/tools/io/");System.out.println(getFileCount2(path,".java"));}/*** 获取目录下特定后缀文件的个数及名称* @param srcFile 目录* @param suffix  后缀名* @return*/public static int getFileCount(File srcFile,String suffix){// 统计满足条件的文件的个数int count = 0 ;File[] files = srcFile.listFiles();// 遍历获取每一个文件for(File file:files){// 获取文件名称String fileName = file.getName();// 判断if(file.isFile() && fileName.endsWith(suffix)){// 满足条件  统计自增count ++;// 打印满足条件的信息System.out.println(fileName);}}return count;}/*** 获取目录下特定后缀文件的个数及名称* @param srcFile 目录* @param suffix  后缀名* @return*/public static int getFileCount2(File srcFile,String suffix){// 该方式要比第一种方式效率高很多File[] files = srcFile.listFiles(new FileFilter() {@Overridepublic boolean accept(File pathname) {return pathname.isFile() && pathname.getName().endsWith(suffix);}});for(File file : files){System.out.println(file.getName());}return files.length;}
}

输出结果：

FileDemo01.java
FileDemo02.java
FileDemo03.java
FileDemo04.java
FileDemo05.java
FileDemo06.java
6

4. File的批处理操作

4.1 批量查询

把D盘下面某个文件夹下的所有的java文件输出到控制台上

package com.bobo.file;import java.io.File;public class FileDemo13 {//记录总数的public static Integer count = 0 ;/*** 把D盘下面某个文件夹下的所有的java文件输出到控制台上**    分析：*       1.封装文件的路径*       2.获取目录下的所有的目录和文件*       3.获取到的每个目录或者文件做相应的判断*       4.判断是文件还是文件夹*          文件*            判断是否是java文件  是输出  不是 不处理*          文件夹*            回到第二步  递归处理** @param args*/public static void main(String[] args) {getAllJavaFile(new File("d:/workspace/"),".java");System.out.println(getAllJavaFileCount(new File("d:/workspace/"),".java"));}/*** 递归获取Java文件的方法* @param srcFolder 传递的目录*/public static void getAllJavaFile(File srcFolder,String suffix){// 获取该目录下的所有的文件及文件夹File[] files = srcFolder.listFiles();for(File file:files){// 判断是文件还是文件夹if(file.isFile()){// 是文件  判断是否是Java文件String fileName = file.getName();if(fileName.endsWith(suffix)){// 输出文件的名称System.out.println(fileName);}}else{// 是文件夹 递归处理getAllJavaFile(file,suffix);}}}/*** 统计文件的个数* @param srcFolder* @param suffix* @return*/public static int  getAllJavaFileCount(File srcFolder,String suffix){// 获取该目录下的所有的文件及文件夹File[] files = srcFolder.listFiles();for(File file:files){// 判断是文件还是文件夹if(file.isFile()){// 是文件  判断是否是Java文件String fileName = file.getName();if(fileName.endsWith(suffix)){// 输出文件的名称// System.out.println(fileName);FileDemo13.count++;}}else{// 是文件夹 递归处理getAllJavaFileCount(file,suffix);}}return count;}
}

4.2 批量删除

​ 采用递归的方式删除指定文件夹里面的所有的内容

package com.bobo.file;import java.io.File;public class FileDemo14 {/*** 通过递归的方式删除 d:/360downloads 下的所有的目录及文件*    1.封装目录为对应的File对象*    2.获取该目录下的所有的文件及文件夹*    3.遍历获取每个文件及文件夹*    4.判断该File是文件还是文件夹*    5.是文件  采用delete方法删除即可*    6.如果是空的文件夹  删除文件夹接口*    7.如果不是空的文件夹 回到第二步 递归处理* @param args*/public static void main(String[] args) {deleteFolder(new File("d:/360downloads"));}/*** 递归删除目录下的所有的文件* @param srcFolder*/public static void deleteFolder(File srcFolder){if(srcFolder == null){throw new NullPointerException("不能传递Null的目录！！！");}// 获取该目录下的所有的文件及文件夹File[] files = srcFolder.listFiles();if(files.length != 0){// 说明当前目录下是有文件及文件夹的for(File file :files){// 判断是文件还是文件夹if(file.isFile()){// 是文件System.out.println(file.delete() + " 已经删除了" + file.getName() + " 文件" );}else{// 说明是文件夹deleteFolder(file);}}}System.out.println(srcFolder.delete() + " 已经删除了" + srcFolder.getName() + " 文件夹" );}
}

5.作业讲解

一，已知文件的路径为c:\mygames.txt

要求得到：

是否存在

取得文件名

取得文件路径

得到绝对路径名

得到父文件夹名

判断文件是否存在

判断文件是否可写

判断文件是否可读

判断是否是目录

判断是否是文件

是否是绝对路径名称

文件最后的修改时间

文件的大小

public static void main(String[] args) {File f = new File("d:/tools/io/a.txt");System.out.println("是否存在：" + f.exists());System.out.println("文件名：" + f.getName());System.out.println("文件路径：" + f.getPath());System.out.println("绝对路径：" + f.getAbsolutePath());System.out.println("父文件夹名称:" + f.getParent());System.out.println("是否存在:" + f.exists());System.out.println("是否可写:" + f.canRead());System.out.println("是否可读：" + f.canWrite());System.out.println("是否是目录:" + f.isDirectory());System.out.println("是否是文件：" + f.isFile());System.out.println("是否是绝对路径名称：" + f.isAbsolute());System.out.println("文件的最后修改时间：" + new Date(f.lastModified()));System.out.println("文件的大小：" + f.length());
}

输出结果

是否存在：true
文件名：a.txt
文件路径：d:\tools\io\a.txt
绝对路径：d:\tools\io\a.txt
父文件夹名称:d:\tools\io
是否存在:true
是否可写:true
是否可读：true
是否是目录:false
是否是文件：true
是否是绝对路径名称：true
文件的最后修改时间：Sat Dec 12 14:34:52 CST 2020
文件的大小：0

二、

1、在本地磁盘D盘中创建一个iotest文件夹

2、在文件夹中创建一个以自己名字的拼音组成的文件名

3、获取创建的这个文件的最后修改日期并打印到控制台

4、将创建的这些文件和文件夹全部删除。

public static void main(String[] args) throws IOException {// 在本地磁盘D盘中创建一个iotest文件夹File file = new File("d:/iotest");if(!file.exists()){file.mkdirs();}//在文件夹中创建一个以自己名字的拼音组成的文件名File f1 = new File("d:/iotest/bobo");if(!f1.exists()){f1.createNewFile();}// 获取创建的这个文件的最后修改日期并打印到控制台long l = f1.lastModified();Date date = new Date(l);SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");System.out.println("最后的修改时间是：" + sdf.format(date));// 将创建的这些文件和文件夹全部删除。File[] files = file.listFiles();// 先删除文件if(files.length > 0){// 说明文件夹中有具体的文件，我们应该先删除for(File f : files){f.delete();}}file.delete();
}

三、

1、在本地磁盘上，选择某个有内容的txt文件，将文件 名修改为test.txt

2、计算修改名字后的文件的大小，文件的最后修改日 期、文件的名称及文件的父级目录，将这些信息打印到

控制台

3、删除这个文件

public static void main(String[] args) {File file = new File("d:/tools/io/a.txt");File file1 = new File("d:/tools/io/test.txt");file.renameTo(file1);System.out.println("文件大小：" + file1.length());System.out.println("文件的修改日期：" + new Date(file1.lastModified()));System.out.println("文件名称:" + file1.getName());System.out.println("文件的父目录：" + file1.getParent());file1.delete();
}

输出结果：

文件大小：11
文件的修改日期：Sat Dec 12 21:34:28 CST 2020
文件名称:test.txt
文件的父目录：d:\tools\io

二、IO流

1. IO流的引入

	程序中的基本数据类型，引用类型【数组，集合】存储的数据都是在内存中，当程序运行的时候存储在内存中，当程序执行完成后，数据就消失了，我们想要实现数据的持久化，那么我就得通过Java中提供的IO来实现数据持久化。

    /***  内存: 运行时存储*  缺点：在程序执行的时候动态的分配内存，程序执行结束后数据就消失了。*  File类：可以操作存储在硬盘中文件【创建，删除,修改文件的属性】*  持久化存储：存储在文件系统中(C: U盘  数据库 移动硬盘 远程电脑)* @param args*/public static void main(String[] args) {int a = 10;int[] arr = {1,2,3,4,5};List<Integer> list = Arrays.asList(1,2,3,4,5);}

在这里插入图片描述

2. IO流概念

​ IO流也称为数据流(Stream),数据通信的通道。Java程序对数据的输入、输出操作都是以流的形式进行的，JDK中提供了各种流类来获取不同种类的数据。流是Java内存中的一组有序数据序列。

在这里插入图片描述

3. IO流分类

3.1 按流向分类

输入流：程序可以从中读取数据

​ 以InputStream和Reader为基类

输出流：程序能向其中写入数据

​ 以OutputStream和Writer为基类

在这里插入图片描述

3.2 按传输单位分类

字节流：以字节为单位传输数据的流

​ 以InputStream和OutputSteam为基类

字符流：以字符为单位传输数据的流

​ 以Reader和Writer为基类

3.3 按功能分类

节点流：用于直接操作目标设备的流

​ 节点流是直接从一个源读写数据的流【FileInputStream】

处理流：是对一个已存在的流的连接和封装，通过对数据的处理为程序提供更为强大、灵活的读写操作

​ 是在节点流的基础上的一种流【BufferedInputStream】

3.4 IO抽象类

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

在这里插入图片描述

4. File字节流

4.1 字节输出流

​ 将数据从内存中写入到文件中。基类是OutputStream，我们通过FileOutputStream来介绍

构造方法

FileOutputStream(File file)
//创建文件输出流以写入由指定的 File对象表示的文件。
FileOutputStream(File file, boolean append)
//创建文件输出流以写入由指定的 File对象表示的文件。
FileOutputStream(FileDescriptor fdObj)
//创建文件输出流以写入指定的文件描述符，表示与文件系统中实际文件的现有连接。
FileOutputStream(String name)
//创建文件输出流以指定的名称写入文件。
FileOutputStream(String name, boolean append)
//创建文件输出流以指定的名称写入文件。

案例代码：

    /*** FileOutputStream** @param args*/public static void main(String[] args) throws IOException {// 如果文件不存在 会帮我们创建该文件OutputStream out = new FileOutputStream("a.txt");// 把 hello world 输出到 a.txt文件中out.write("hello world".getBytes());// 在IO操作的时候最后我们都得关闭流out.close();// 数据流关闭后就不能再做其他操作了 java.io.IOException: Stream Closedout.write("abc".getBytes());}

字节输出流注意实现：

  1. 数据写入完成后记得调用close方法关闭流对象，如果没有关闭流对象并且还在继续使用会抛出异常， Stream closed
  2. 如果要追加写入使用带有两个参数的构造方法 且为true
  3. 不同的操作系统针对的换行符也不一致要注意(windows \r\n Linux \n Mac \r )
  4. 数据写入中存在两个异常 FileNotFoundException IOException

结合异常处理IO的标准写法

package com.bobo.io.outputstream;import java.io.*;public class FileOutputSteamDemo05 {public static void main(String[] args)  {// 异常我们要自己处理OutputStream out = null;try{out = new FileOutputStream(new File("f:/b.txt"),true);// 把 hello world 输出到 a.txt文件中out.write("helloworld\r\n".getBytes());out.write("helloworld\r\n".getBytes());out.write("helloworld\r\n".getBytes());out.write(97);out.write("\r\n".getBytes());byte[] bytes = "abcdedfg".getBytes();// 在IO操作的时候最后我们都得关闭流out.write(bytes,3,4);out.close();}catch (FileNotFoundException e){e.printStackTrace();}catch (IOException e) {e.printStackTrace();}finally {// 关闭IO流程if(out != null){try {out.close();} catch (IOException e) {e.printStackTrace();}}}System.out.println("**********");}
}

JDK1.8提供的try catch新的语法可以简化我们的IO标准代码

package com.bobo.io.outputstream;import java.io.*;public class FileOutputSteamDemo06 {/*** FileOutputStream*    windows \r\n*    Linux \n*    mac  \r* @param args*/public static void main(String[] args)  {// 异常我们要自己处理try(OutputStream out = new FileOutputStream(new File("b.txt"),true)){out.write("abc".getBytes());// 不用我们自己显示的关闭IO流  try(){}catch(...){} 这个语句会自动帮助我们把 try()中声明IO关闭}catch (FileNotFoundException e){e.printStackTrace();}catch (IOException e) {e.printStackTrace();}System.out.println("**********");}
}

4.2 字节输入流

FileInputStream从文件系统中的文件获取输入字节。 什么文件可用取决于主机环境。

FileInputStream用于读取诸如图像数据的原始字节流。 要阅读字符串，请考虑使用FileReader

构造方法：如果读取的文件不存在会抛异常 FileNotFoundException异常

在这里插入图片描述

read()方法

  1. 每次读取一个字节的数据

  2. 将指针移动到下一个位置

  3. 读取到文件的末尾会返回-1

在这里插入图片描述

案例代码

package com.bobo.io.fileinputstream;import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;public class FileInputStreamDemo02 {/*** FileInputStream*    字节输入流*    在字节输出流中，如果文件不存在系统会帮助我们创建该文件*    但是在字节输入流中，如果文件不存在那么会抛FileNotFoundException* @param args*/public static void main(String[] args) throws IOException {// 获取一个字节输入流InputStream in = new FileInputStream("b.txt");// 读取数据// 当文本读取结束的时候返回-1int b = 0 ;while((b = in.read()) != -1){// 没有读取到文件的结尾System.out.print((char)b);}/*while(b != -1){b = in.read();if(b == -1){System.out.print(b );}else{System.out.print((char)b );}}*/System.out.println();System.out.println("文件读取结束...");// 关闭IO流in.close();}
}

输出结果

helloworld
文件读取结束...

通过read方法读取中文的时候会出现乱码

一次读取多个字节信息

package com.bobo.io.fileinputstream;import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;public class FileInputStreamDemo04 {/*** FileInputStream*    字节输入流*    英文字母占据的是一个字节而中文在GBK中一个中文汉字，占据的是两个字节，也就是一个字符*       read() 每次读取一个字节  把中文的两个字节拆开了，当然就乱码了，那这个时候怎么办?  字符流或者一次读取多个字节* @param args*/public static void main(String[] args) throws IOException {// 获取一个字节输入流InputStream in = new FileInputStream("a.txt");// 读取数据// 当文本读取结束的时候返回-1byte[] b = new byte[3];int number = in.read(b);System.out.println(new String(b) + "  : " + number);number = in.read(b);System.out.println(new String(b) + "  : " + number);number = in.read(b);System.out.println(new String(b) + "  : " + number);System.out.println("文件读取结束...");// 关闭IO流in.close();}
}

输出结果

abc  : 3
dec  : 2
dec  : -1
文件读取结束...

原因分析：

在这里插入图片描述

package com.bobo.io.fileinputstream;import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;public class FileInputStreamDemo05 {/*** FileInputStream*    字节输入流*    英文字母占据的是一个字节而中文在GBK中一个中文汉字，占据的是两个字节，也就是一个字符*       read() 每次读取一个字节  把中文的两个字节拆开了，当然就乱码了，那这个时候怎么办?  字符流或者一次读取多个字节* @param args*/public static void main(String[] args) throws IOException {// 获取一个字节输入流InputStream in = new FileInputStream("b.txt");// 读取数据// 当文本读取结束的时候返回-1byte[] b = new byte[1000];int num = 0; // 记录读取的长度，读到结尾返回的是-1while((num = in.read(b)) != -1){System.out.print(new String(b,0,num));}System.out.println("");System.out.println("文件读取结束...");// 关闭IO流in.close();}
}

输出结果：

hello
中国
abcdef文件读取结束...

4.3 课堂案例

文件复制的课堂案例：

​ 通过字节输入流和字节输出流将d:\IO目录下的文件(视频，图片，文本文件)拷贝到d:\NewIO目录下

package com.bobo.io.fileinputstream;import com.sun.xml.internal.ws.policy.privateutil.PolicyUtils;import java.io.*;public class FileInputStreamDemo07 {/*** 通过字节输入流和字节输出流将*     d:\IO目录下的文件(视频，图片，文本文件)拷贝到d:\NewIO目录下* @param args*/public static void main(String[] args) throws IOException {copy02("d:/IO/1.txt","d:/NewIO/1.txt");copy02("d:/IO/1.mp4","d:/NewIO/1.mp4");copy02("d:/IO/1.png","d:/NewIO/1.png");}/*** 实现文件的复制操作* @param srcFile  源文件*          将源文件中的内容读取到内存中 byte[]* @param descFile  目标文件*           将内存中存储中 byte[] 中的信息输出到 目标文件中*/public static void copy01(String srcFile ,String descFile) throws IOException {// 先读取到内存中，然后再从内存中将数据写入到另一个文件中// 获取读取文件的对象InputStream in = new FileInputStream(srcFile);// 获取文件写入的对象OutputStream out = new FileOutputStream(descFile);// 一个字节一个字节的读取int b = 0 ;while((b = in.read()) != -1){// 每读取到一个字节我们就把这个信息写入到另一个文件中去out.write(b);}// 千万不要忘了关闭流out.close();in.close();}/*** 实现文件的复制操作* @param srcFile  源文件*          将源文件中的内容读取到内存中 byte[]* @param descFile  目标文件*           将内存中存储中 byte[] 中的信息输出到 目标文件中*/public static void copy02(String srcFile,String descFile) throws IOException {InputStream in = new FileInputStream(srcFile);OutputStream out = new FileOutputStream(descFile);byte[] bytes = new byte[1024*1024];int num = 0 ;while((num = in.read(bytes)) != -1){out.write(bytes,0,num);}// 关闭in.close();out.close();}
}

5. File字符流

​ 字节流在处理文本的时候因为中文的问题，在处理的时候就不是很完美，Java是采用Unicode标准，默认是通过GBK编码的，一个字符占据2个字节，通过字节流去操作文本的时候就有可能出现分割中文两个字节的情况这时Java中给我们提供了字符流，也就是读写操作都是一个字符。字符流的两个基类 Reader 和 Writer

5.1 字符输出流

​ 输出的时候以字符为单位

    /***  write方法 不是直接将字符串写入到文件中，而是先将要写入的文件缓存起来* @param args* @throws IOException*/public static void main(String[] args) throws IOException {Writer writer = new FileWriter("a.txt",true);writer.write("abcHelloWorld");writer.write("\r\n");// 刷新，将缓存中的信息一次性写入到 文本中writer.flush();writer.write("你好啊，中国");// close 方法是关闭IO流，如果缓存中还有没有写入的数据会再执行一次flush方法writer.close();}

写入结果：

​

在这里插入图片描述

5.2 字符输入流

​ 读取数据的时候以字符单位

    /*** 字符输入流* @param args*/public static void main(String[] args) throws IOException {// 创建读取文件的对象 如果文件不存在会抛异常Reader reader = new FileReader("a.txt");// 读取文件int n = 0 ;while((n = reader.read()) != -1){System.out.print((char)n);}}

输出结果

HelloWorld
你好啊，中国

一次读取多个字符操作

package com.bobo.io.reader;import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;public class ReaderDemo04 {/*** 字符输入流*    一次性读取多个字符* @param args*/public static void main(String[] args) throws IOException {// 创建读取文件的对象 如果文件不存在会抛异常Reader reader = new FileReader("a.txt");// 读取文件char[] ch = new char[4];int num = 0;while((num = reader.read(ch)) != -1){System.out.print(new String(ch,0,num));}}
}

和字节输入流的操作没多大的区别，读取中文也没有问题了

HelloWorld
你好啊，中国

5.3 课堂案例

文件复制的课堂案例：

​ 通过字符输入流和字符输出流将d:\IO目录下的文件(视频，图片，文本文件)拷贝到d:\NewIO目录下

package com.bobo.io.reader;import java.io.*;public class ReaderDemo05 {/*** 文件复制的课堂案例：**      通过字节输入流和字节输出流将d:\IO目录下的文件(视频，图片，文本文件)拷贝到d:\NewIO目录下* @param args*/public static void main(String[] args) throws IOException {copy("d:/IO/1.txt","d:/NewIO/1.txt");copy("d:/IO/1.mp4","d:/NewIO/1.mp4");copy("d:/IO/1.png","d:/NewIO/1.png");}/*** 通过字符实现文件的复制操作* @param srcFile  源文件* @param descFile  目标文件*/public static void copy(String srcFile,String descFile) throws IOException {// 获取对应的字符输入输出流对象Reader reader = new FileReader(srcFile);Writer writer = new FileWriter(descFile);// 保存每次读取的数据char[] ch = new char[1024*1024];// 记录每次读取的数据的长度int i = 0; // 每个10次 flush一次int num = 0;while((num = reader.read(ch)) != -1){writer.write(new String(ch,0,num));/*if( i %10 ==0){writer.flush();}i++;*/}// 关闭IO流reader.close();writer.close();}
}

​ 通过字符流对非文本文件读写操作的时候出现了意想不到的情况，对于非文本文件不推荐使用字符流！对于文本操作中的中文出现了乱码的情况，这个是什么原因呢？

6.编码和解码

​ 有关编码的问题在有中文的Java开发中是一个大问题，但是其实解决起来是非常容易。

6.1 编码

​ 编码是信息从一种形式或格式转换为另一种形式或格式的过程。

​ 简单的来说，编码就是将看得懂的信息通过编码表转换为看不懂的信息

6.2 解码

​ 解码是编码的逆过程

​ 简单的来说，解码就是将看不懂的信息通过编码表转换为看得懂的信息

6.3 编码表

​ 现实世界中的字符对应的数组组成的一张参照表

现实生活中的案例：电报

在这里插入图片描述

6.4 常见的编码表

  1. ASCII 美国标准信息交换码
  2. Unicode 国际标准码
  3. UTF-8 最多用三个字节来表示一个字符
  4. ISO-8859-1 拉丁码表，欧洲码表
  5. GB2312、GBK、GB18030 中文码表
  6. Java平台默认采用的编码方式GBK

在这里插入图片描述

造成中文乱码的原因就是因为编码和解码使用的编码表不一致造成的

在这里插入图片描述

Java中支持的编码方式

public class EncodeDemo01 {/*** 编码和解码*     Java中支持的编码方式是非常多的，可以通过Charset来查看*     1、对字符进行编码和解码*     2、对字符串进行编码和解码*     3、对文件进行编码和解码* @param args*/public static void main(String[] args) {// Java支持的编码方式有哪些？SortedMap<String, Charset> map = Charset.availableCharsets();Set<String> keys = map.keySet();for(String key:keys){System.out.println(key+":" + map.get(key));}}
}

字符串的编解码：

package com.bobo.encode;import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.Set;
import java.util.SortedMap;public class EncodeDemo02 {/*** 编码和解码*     Java中支持的编码方式是非常多的，可以通过Charset来查看*     1、对字符进行编码和解码*     2、对字符串进行编码和解码*     3、对文件进行编码和解码* @param args*/public static void main(String[] args) throws Exception {// 1、对字符进行编码和解码char ch = 'a';System.out.println((int)ch);System.out.println(Integer.toBinaryString(ch));// 2、对字符串进行编码和解码String str = "中国，你好...";// 编码byte[] b1 = str.getBytes("GBK");System.out.println(Arrays.toString(b1));// 解码System.out.println(new String(b1,"GBK"));// 3、对文件进行编码和解码  在字节流和字符流中没有提供编码解码的方法 我们需要学习一种新的流来解决这个问题}
}

输出结果:

97
1100001
[-42, -48, -71, -6, -93, -84, -60, -29, -70, -61, 46, 46, 46]
中国，你好...

7.转换流

实现在字节流和字符流之间转换的流

7.1 InputStreamReader

​ 是Reader的子类，将输入的字节流变为字符流，既：将一个字节流的输入对象变为字符输入流对象

案例代码：

使用默认的编码表来解码

package com.bobo.io.convert;import java.io.*;public class InputStreamReaderDemo01 {/*** 输入转换流*   InputStreamReader* @param args*/public static void main(String[] args) throws IOException {// 读取一个文件InputStream in = new FileInputStream("d:/IO/1.txt");// 通过输入转换流 将字节流转换为字符流  设置对应的编码表Reader reader = new InputStreamReader(in);char[] ch = new char[1024];int num = 0 ;while((num = reader.read(ch)) != -1){System.out.print(new String(ch,0,num));}reader.close();in.close();}
}

出现了乱码:

public class FileInputStreamDemo04 {/*** FileInputStream*    �ֽ�������*    Ӣ����ĸռ�ݵ���һ���ֽڶ�������GBK��һ�����ĺ��֣�ռ�ݵ��������ֽڣ�Ҳ����һ���ַ�*       read() ÿ�ζ�ȡһ���ֽ�  �����ĵ������ֽڲ��ˣ���Ȼ�������ˣ������ʱ����ô��?  �ַ�������һ�ζ�ȡ����ֽ�* @param args*/public static void main(String[] args) throws IOException {// ��ȡһ���ֽ�������InputStream in = new FileInputStream("a.txt");// ��ȡ����// ���ı���ȡ������ʱ�򷵻�-1byte[] b = new byte[3];int number = in.read(b);System.out.println(new String(b) + "  : " + number);number = in.read(b);System.out.println(new String(b) + "  : " + number);number = in.read(b);System.out.println(new String(b) + "  : " + number);System.out.println("�ļ���ȡ����...");// �ر�IO��in.close();}
}

设置对应的解码方式

package com.bobo.io.convert;import java.io.*;public class InputStreamReaderDemo01 {/*** 输入转换流*   InputStreamReader* @param args*/public static void main(String[] args) throws IOException {// 读取一个文件InputStream in = new FileInputStream("d:/IO/1.txt");// 通过输入转换流 将字节流转换为字符流  设置对应的编码表Reader reader = new InputStreamReader(in,"GBK");char[] ch = new char[1024];int num = 0 ;while((num = reader.read(ch)) != -1){System.out.print(new String(ch,0,num));}reader.close();in.close();}
}
package com.bobo.io.fileinputstream;import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;public class FileInputStreamDemo04 {/*** FileInputStream*    字节输入流*    英文字母占据的是一个字节而中文在GBK中一个中文汉字，占据的是两个字节，也就是一个字符*       read() 每次读取一个字节  把中文的两个字节拆开了，当然就乱码了，那这个时候怎么办?  字符流或者一次读取多个字节* @param args*/public static void main(String[] args) throws IOException {// 获取一个字节输入流InputStream in = new FileInputStream("a.txt");// 读取数据// 当文本读取结束的时候返回-1byte[] b = new byte[3];int number = in.read(b);System.out.println(new String(b) + "  : " + number);number = in.read(b);System.out.println(new String(b) + "  : " + number);number = in.read(b);System.out.println(new String(b) + "  : " + number);System.out.println("文件读取结束...");// 关闭IO流in.close();}
}

7.2 OutputStreamWriter

​ 是Writer的子类，将输出的字符流装换为字节流，即：将一个字符流的输出对象变为字节流的输出对象

package com.bobo.io.convert;import java.io.*;public class OutputStreamWriterDemo01 {/*** 输出转换流*    OutputStreamWriter* @param args*/public static void main(String[] args) throws IOException {String str = "你好啊，程序员";// 获取字节输出流OutputStream out = new FileOutputStream("b.txt");// 通过输出转换流 将字节流转换为字符流Writer writer = new OutputStreamWriter(out,"GBK");// 通过字符流来操作writer.write(str);writer.flush();writer.close();}
}

同样的在转换流中我们也需要指定对应的编码解码方式

7.3 字符流文件复制

前面我们通过字符流复制文件造成的中文乱码问题，这时我们就可以通过转换流的方式彻底的来解决了

package com.bobo.io.convert;import java.io.*;public class ReaderDemo05 {/*** 文件复制的课堂案例：**      通过字节输入流和字节输出流将d:\IO目录下的文件(视频，图片，文本文件)拷贝到d:\NewIO目录下* @param args*/public static void main(String[] args) throws IOException {copy("d:/IO/1.txt","d:/NewIO/1.txt");/*copy("d:/IO/1.mp4","d:/NewIO/1.mp4");copy("d:/IO/1.png","d:/NewIO/1.png");*/}/***  通过转换流的方式实现编解码的操作* @param srcFile  源文件* @param descFile  目标文件*/public static void copy(String srcFile,String descFile) throws IOException {// 通过转换流来实现Reader reader = new InputStreamReader(new FileInputStream(srcFile),"GBK");Writer writer = new OutputStreamWriter(new FileOutputStream(descFile),"GBK");// 保存每次读取的数据char[] ch = new char[1024*1024];// 记录每次读取的数据的长度int i = 0; // 每个10次 flush一次int num = 0;while((num = reader.read(ch)) != -1){writer.write(ch,0,num);System.out.println(new String(ch,0,num));/*if( i %10 ==0){writer.flush();}i++;*/}// 关闭IO流reader.close();writer.close();}
}

8. 缓冲流

​ 缓冲流是处理流的一种，是建立在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时还新增了一些方法。

JDK中提供了四种缓冲流：

  1. BufferedInputStream 对任何的InputStream流进行包装
  2. BufferedOutputStream 对任何的OutputStream流进行包装
  3. BufferedReader 对任何的Reader流进行了包装
  4. BufferedWriter 对任何的Writer流进行了包装

BufferedInputStream案例

package com.bobo.io.buffered;import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;public class BufferedInputStreamDemo01 {/*** 缓冲字节输入流*    BufferedInputStream* @param args*/public static void main(String[] args) throws IOException {// 获取一个对应的BufferedInputStream对象BufferedInputStream bis = new BufferedInputStream(new FileInputStream("b.txt"));byte[] bytes = new byte[1024];int num = 0 ;while((num = bis.read(bytes)) != -1){System.out.print(new String(bytes,0,num));}bis.close();}
}

BufferedOutputStream案例代码

package com.bobo.io.buffered;import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class BufferedOutputStreamDemo01 {/*** 字节输出缓冲流* @param args*/public static void main(String[] args) throws IOException {// 获取缓冲字节输出流BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("c.txt"));String str = "你好啊....";bos.write(str.getBytes());// 同样的数据会被缓冲，所以写入一定的数据后我们需要通过flush方法来刷新bos.flush();bos.close();}
}

在字节缓冲流中没有提供特别的新的方法

BufferedReader

package com.bobo.io.buffered;import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;public class BufferedReaderDemo01 {/*** 缓冲字符输入流*    BufferedReader  新增了一个单行读取的方法  readLine() 方法* @param args*/public static void main(String[] args) throws IOException {// 获取一个BufferedReader实例BufferedReader br = new BufferedReader(new FileReader("a.txt"));String str = null;while((str = br.readLine()) != null){System.out.println(str);}/*String s = br.readLine();System.out.println(s);s = br.readLine();System.out.println(s);s = br.readLine();System.out.println(s);*/br.close();}
}

输出结果：

HelloWorld
你好啊，中国

中文出现乱码的情况如何处理

在这里插入图片描述

将字节流通过转换流转换为特定编码的字符流，然后再转换为对应的包装流

package com.bobo.io.buffered;import java.io.*;public class BufferedReaderDemo02 {/*** 缓冲字符输入流*    BufferedReader  新增了一个单行读取的方法  readLine() 方法* @param args*/public static void main(String[] args) throws IOException {//Reader reader = new FileReader("b.txt");// 将字节流转换为字符流Reader reader = new InputStreamReader(new FileInputStream("b.txt"),"GBK");// 获取一个BufferedReader实例  将字符流包装为缓冲流BufferedReader br = new BufferedReader(reader);String str = null;while((str = br.readLine()) != null){System.out.println(str);}br.close();}
}

在这里插入图片描述

BufferedWriter

package com.bobo.io.buffered;import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;public class BufferedWriterDemo01 {/*** 字符输出缓冲流*    BufferedWriter 新增加了一个换行的方法* @param args*/public static void main(String[] args) throws IOException {BufferedWriter bw = new BufferedWriter(new FileWriter("d.txt"));bw.write("abcdefg");bw.newLine(); // 换行bw.write("你好啊");bw.flush();bw.close();}
}

BufferedWriter结合转换流

package com.bobo.io.buffered;import java.io.*;public class BufferedWriterDemo02 {/*** 字符输出缓冲流*    BufferedWriter 新增加了一个换行的方法* @param args*/public static void main(String[] args) throws IOException {// 将字节输出流转换为字符输出流Writer writer = new OutputStreamWriter(new FileOutputStream("e.txt"),"UTF-8");// 字符输出流包装为对应的缓冲流BufferedWriter bw = new BufferedWriter(writer);bw.write("abcdefg---utf-8");bw.newLine(); // 换行bw.write("你好啊");bw.flush();bw.close();}
}

9.标准输入输出流(了解)

​ 我们刚开始接触Java的时候，接收键盘输入的代码是如下：

Scanner in = new Scanner(System.in);

在这里的System.in是什么含义呢？

package com.bobo.io.system;import java.io.IOException;
import java.io.InputStream;public class SystemInDemo01 {/*** 标准的输入输出流*    System.in* @param args*/public static void main(String[] args) throws IOException {// System.in 从控制台读取信息InputStream in = System.in;byte[] b = new byte[1024];int num = 0 ;while((num = in.read(b)) != -1){System.out.println("--->" + new String(b,0,num));}in.close();}
}

在这里插入图片描述

package com.bobo.io.system;import java.io.IOException;
import java.io.PrintStream;public class SystemOutDemo01 {/*** 标准的输出*    System.out* @param args*/public static void main(String[] args) throws IOException {// System.out 将内存中的信息输出到控制台中PrintStream out = System.out;out.write("hello ....".getBytes());out.println("aadfsa");out.append("scddsfdadf");out.close();}
}

输出结果

在这里插入图片描述

10.对象流

​ 将对象持久化操作

我们直接将一个自定义的对象添加到了文件中，会出现如下的错误

package com.bobo.io.object;public class Student {public Integer id;public String name;String address;protected  String gender;private String desc;public void run(){System.out.println("run");}public static void sleep(){System.out.println("sleep ...");}
}
package com.bobo.io.object;import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;public class ObjectDemo01 {/*** 对象流*    ObjectInputStream：对象流的输入流*    ObjectOutputStream：对象流的输出流* @param args*/public static void main(String[] args) throws IOException {Student s = new Student();s.id = 666;s.name = "zhangsan";s.gender = "男";s.address = "中国";Student s1 = new Student();s1.id = 6661;s1.name = "zhangsan1";s1.gender = "女";s1.address = "中国1";ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("o1.txt"));oos.writeObject(s);oos.writeObject(s1);oos.flush();oos.close();}
}

出现了如下的错误

在这里插入图片描述

要通过对象流操作的对象都必须要实现Serializable接口 序列化

package com.bobo.io.object;import java.io.Serializable;public class Student implements Serializable {static final long serialVersionUID = 42L;public Integer id;public String name;String address;protected  String gender;private String desc;public void run(){System.out.println("run");}public static void sleep(){System.out.println("sleep ...");}
}

然后添加就成功了

在这里插入图片描述

对象流读取对象信息 反序列化

package com.bobo.io.object;import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;public class ObjectDemo02 {/*** 对象流* @param args*/public static void main(String[] args) throws Exception {ObjectInputStream ois = new ObjectInputStream(new FileInputStream("o1.txt"));Student s1 = (Student)ois.readObject();System.out.println(s1.id + "  " + s1.name + " "  + s1.gender + " " + s1.address);Student s2 = (Student)ois.readObject();System.out.println(s2.id + "  " + s2.name + " "  + s2.gender + " " + s2.address);System.out.println(ois.readObject());ois.close();}
}

输出结果：

在这里插入图片描述

序列化的步骤

  1. 自定义一个类，实现Serializable接口
  2. 实例化一个自定义的类，并初始化成员变量
  3. 通过ObjectOutputStream把实例化的对象存储起来

反序列化的步骤

  1. 通过对象流读取之前爆出的文件中的信息
  2. 得到对象包含上次保存的对象的可见信息

transient声明的变量不能实现序列化

序列化是不能对static属性实现的。

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

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

相关文章

时间序列分析-无模型

时间序列分析-无模型

本节内容介绍了无模型的时间序列分析方法&#xff0c;包括时间序列作趋势图、逐年分解、时间序列分解、直方图、ACF与PACF图&#xff0c;主要是作图。 首先导入数据和对应的库&#xff1a; import pandas as pd import numpy as np import matplotlib.pyplot as plt import se…
阅读更多...
与Apollo共创生态：让汽车更聪明，让出行更简单

与Apollo共创生态：让汽车更聪明，让出行更简单

目录 前言Apollo X 企业解决方案Studio X 企业协同开发工具链Apollo开放平台携手伙伴共创生态Apollo开发平台生态共创计划 前言 百度2013年开始布局自动驾驶&#xff0c;2017年推出全球首个自动驾驶开放平台Apollo。目前百度Apollo已经在自动驾驶、智能汽车、智能地图等领域拥有…
阅读更多...
Spring6 当中 Bean 的生命周期的详细解析：有五步，有七步，有十步

Spring6 当中 Bean 的生命周期的详细解析：有五步，有七步，有十步

1. Spring6 当中 Bean 的生命周期的详细解析&#xff1a;有五步&#xff0c;有七步&#xff0c;有十步 文章目录 1. Spring6 当中 Bean 的生命周期的详细解析&#xff1a;有五步&#xff0c;有七步&#xff0c;有十步每博一文案1.1 什么是 Bean 的生命周期1.2 Bean 的生命周期 …
阅读更多...
Flask 3 保姆级教程（一）：快速上手

Flask 3 保姆级教程（一）：快速上手

一、创建项目 PyCharm 中新建项目 创建完成后会出现这么个项目 以下是代码解析&#xff1a; # 导入了 Flask 类 from flask import Flask# 创建了一个 Flask web 应用的实例&#xff0c;并将其赋值给变量 app # __name__ 是一个特殊的 Python 变量&#xff0c;它表示当前模块…
阅读更多...
第49期|GPTSecurity周报

第49期|GPTSecurity周报

GPTSecurity是一个涵盖了前沿学术研究和实践经验分享的社区&#xff0c;集成了生成预训练Transformer&#xff08;GPT&#xff09;、人工智能生成内容&#xff08;AIGC&#xff09;以及大语言模型&#xff08;LLM&#xff09;等安全领域应用的知识。在这里&#xff0c;您可以找…
阅读更多...
变电站自动化控制系统应用案例分析

变电站自动化控制系统应用案例分析

变电站自动化控制系统介绍 变电站自动化控制系统用于大中型企业变电站项目&#xff0c;这类企业变压器多&#xff0c;日耗电量大。把多个变压器集中到一个电器平台上&#xff0c;集中管理分析&#xff0c;优化厂区用电管理&#xff0c;从而达到集中控制、集中分析、集中管理的…
阅读更多...
VOS系统录音文件REC转MP3，REC录音转WAV与WAV转MP3具体项目中实现方式，以及占用空间变化！

VOS系统录音文件REC转MP3，REC录音转WAV与WAV转MP3具体项目中实现方式，以及占用空间变化！

前面讲解了VOS3000系统的录音REC转MP3的安装步骤&#xff0c;不清楚的&#xff0c;可以移步这里查看&#xff1a;http://t.csdnimg.cn/OXNT9 或者 点击这里查看安装步骤&#xff0c;下面继续讲下他们的使用方法&#xff0c;以及实际项目中的运用&#xff0c;首先我们需要明确我…
阅读更多...
Android中的屏幕刷新机制（动画视频形象说明机制）

Android中的屏幕刷新机制（动画视频形象说明机制）

一&#xff0c;刷新率和帧率&#xff0c;60hz和60fps的区别 在Android系统中&#xff0c;刷新率和帧率是两个不同的概念&#xff0c;它们各自在显示过程中扮演着不同的角色。以下是对它们的详细解释&#xff1a; 刷新率&#xff0c;单位是Hz&#xff0c;是指屏幕在一秒内刷新…
阅读更多...
STK与matlab交互 Astrogator模块（13）

STK与matlab交互 Astrogator模块（13）

一、背景介绍 在本文介绍一个场景&#xff0c;五颗蓝方卫星和一颗红方卫星&#xff0c;在两个小时之内&#xff0c;使用神经网络等人工智能算法&#xff0c;实现一个轨道追踪的问题&#xff0c;其中接口输入是六颗卫星在J2000坐标系下的坐标&#xff0c;接口输出是该六颗卫星沿…
阅读更多...
windows下安装onlyoffice

windows下安装onlyoffice

文章目录 1、 安装ErLang2、 安装rabbitmq3、 安装postgresql4、 安装onlyoffice(社区版) 1、 安装ErLang 下载地址&#xff1a;https://erlang.org/download/otp_win64_24.2.exe opt_wind64_24.2.exe 直接运行&#xff0c;一步一步安装 2、 安装rabbitmq 下载地址&#xf…
阅读更多...
.NET C# ORM 瀚高数据库

.NET C# ORM 瀚高数据库

SqlSugar ORM SqlSugar 是一款 老牌 .NET开源ORM框架&#xff0c;由果糖大数据科技团队维护和更新 &#xff0c;开箱即用最易上手的ORM 优点 &#xff1a;【生态丰富】【高性能】【超简单】 【功能全面】 【多库兼容】【适合产品】 【SqlSugar视频教程】 支持 &#xff1a…
阅读更多...
linux部署java1.8（java17）

linux部署java1.8（java17）

两种方式&#xff1a; 方式一 1.输入查找命令&#xff1a; yum -y list java*2.输入安装命令&#xff1a; yum install -y java-1.8.0-openjdk.x86_643.测试是否已经安装&#xff1a; java -version方式二&#xff1a; 点击链接进入官网&#xff1a;https://www.oracle.com/…
阅读更多...
H3C无线AP管理命令

H3C无线AP管理命令

先上链接 01-AP管理命令-新华三集团-H3C display wlan ap all
阅读更多...
redis安装配置

redis安装配置

简单启动一个redis容器 拉取redis镜像&#xff1a;(更多版本看https://hub.docker.com/_/redis/tags) sudo docker pull redis:7.2.4简单启动一个redis服务 &#xff0c;–requirepass 指定密码 123456 sudo docker run -d \ --name redis \ --restartalways \ -p 6379:6379…
阅读更多...
Java 如何避免代码中大量的 if else 判断

Java 如何避免代码中大量的 if else 判断

文章目录 Java 如何避免代码中大量的 if else 判断解决方案1.策略模式2.工厂模式3.策略模式 工厂模式4.提前 return&#xff08;适用于分支逻辑很简单的 if else&#xff09;5.枚举 Java 如何避免代码中大量的 if else 判断 在代码中经常会出现 if else 判断&#xff0c;如下…
阅读更多...
当众演讲技巧的方法有哪些（3篇）

当众演讲技巧的方法有哪些（3篇）

当众演讲技巧的方法有哪些&#xff08;3篇&#xff09; 当众演讲技巧的方法有很多&#xff0c;下面我将分三篇来详细阐述其中的一些关键技巧&#xff1a; **篇&#xff1a;准备与开场技巧 充分准备&#xff1a;提前规划演讲内容&#xff0c;明确主题和目标&#xff0c;准备详…
阅读更多...
【蓝桥杯C++A组省三 | 一场勇敢的征途与致19岁的信】

【蓝桥杯C++A组省三 | 一场勇敢的征途与致19岁的信】

随着4.13西大四楼考场的倒计时结束… 就这样蓝桥杯落幕了 省三的名次既满足又不甘心&#xff0c;但又确乎说得上是19岁途中的又一枚勋章 从去年得知&#xff0c;纠结是否要报名、到寒假开始战战兢兢地准备、陆续开始创作博客&#xff0c;记录好题和成长……感谢你们的关注&…
阅读更多...
APT预警攻击平台截获Nday

APT预警攻击平台截获Nday

APT预警攻击平台截获Nday 2024年4月26日 设备漏洞【漏洞利用】H3C Magic R100任意代码执行漏洞(CVE-2022-34598) 0000 &#xff1a; 0010 &#xff1a; 0020 &#xff1a; 0030 &#xff1a; 0040 &#xff1a; 0050 &#xff1a; 0060 &#xff1a; 0070 &#xff1a;6F 72…
阅读更多...
请求接口报错：java.lang.IllegalStateException: argument type mismatch

请求接口报错：java.lang.IllegalStateException: argument type mismatch

目录 一、场景二、报错信息三、控制器四、接口调用五、原因六、解决 一、场景 1、调用后端接口报错 2、接口参数以Json方式传递 – 二、报错信息 java.lang.IllegalStateException: argument type mismatch Controller [com.xxx.huarunshouzheng.controller.MallControlle…
阅读更多...
CCF-CSP真题题解：201409-3 字符串匹配

CCF-CSP真题题解：201409-3 字符串匹配

201409-3 字符串匹配 #include <iostream> #include <cstring> #include <algorithm> using namespace std;int n, type; string s, p;string tolower(string s) {string res;for (char c : s) res tolower(c);return res; }int main() {cin >> p >…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023