java基础io流

最新推荐文章于 2024-07-27 17:56:15 发布
最新推荐文章于 2024-07-27 17:56:15 发布
阅读量88 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36581251/article/details/115069381
版权

IO流

字节缓冲区流的概述和使用

字节缓冲区流
字节流一次读写一个数组的速度比一次读写一个字节的速度快很多，  这是加入了数组这样的缓冲区效果，java本身在设计的时候，也是考虑到了这样的设计思想，所以提供了字节缓冲区流
字节缓冲输出流
BufferedOutputStream
字节缓冲输入流
BufferedInputStream

import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*BufferedOutputStream(OutputStream out)
 *使用这种构造方法，它提供了一种默认的缓冲区大小，所以我们一般使用默认的就好了
 *字节缓冲区流仅仅提供缓冲区，而真正的底层的读写数据还得需要基本的流对象进行操作*/
public class BufferedStreamDemo {
	public static void main(String[] args) throws IOException {
 		//BufferedOutputStream(OutputStream out)
 		//FileOutputStream fos = new FileOutput("a.txt");
 		//BufferedOutputString bos = new BufferedOutStream(fos);
 		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.txt"));
 		bos.write("hello".getBytes());
 		bos.close();
 		//BufferedInputStream(InputStream in)
 		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));
 		//方式1：一次读取一个字节
 		int by;
 		while((by=bis.read())!=-1){
 			System.out.print((char)by);
 		//方式2：一次读取一个数组
 		byte[] bys = new byte[1024];
 		int len;
 		while((len=bis.read(bys))!=-1) {
 			System.out.print(new String(bys, 0, len));
 		}
	}
}

字节流四种方式复制AVI并测试效率

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputSream;
import java.io.IOException;
/*
 *把d:\\xxx.avi复制到当前项目目录下的copy.avi中
 *数据源：d:\\xxx.avi
 *目的地：copy.avi
 *四种方式比较复制效率
 *基本字节流一次读写一个字节
 *基本字节流一次读写一个字节数组
 *缓冲字节流一次读写一个字节
 *缓冲字节流一次读写一个字节数组
 *提示：
 *复制文件的时间计算可以采用System类的方法实现
 *public static long currentTimeMillis():返回以毫秒为单位的当前时间
 */
public class CopyAviTest {
	public static void main(String[] args) {
		//记录开始时间
		long start = System.currentTimeMillis();
		method1();
		method2();
		method3();
		method4();
		//记录结束时间
		long end = System.currentTimeMillis();
		System.out.println("共耗时："+(end-start)+"毫秒"）；
	}
	//基本字节流一次读写一个字节数组
	private static void method2() throws IOException {
		//封装数据源
		FileInputStream fis = new FileInputStream("d:\\复制图片.avi");
		//封装目的地
		FileOutputStream fos = new FileOutputStream("copy.avi");
		byte[] bys = new byte[1024];
		int len;
		while((len=fis.read(bys))!=-1){
			fos.write(bys,0,len);
		}
	}
	//基本字节流一次读写一个字节
	private static void method1() throws IOException{
		//封装数据源
		FileInputStream bis = new BufferedInputStream(new FileInputStream("d:\\复制图片"))
		//封装目的地
		FileOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.avi"));
		int by;
		while((by=fis.read())!=-1){
			fos.write(by);
		}
		fos.close();
		fis.close();
	}
	//缓冲字节流一次读写一个字节
	private static void method3() throws IOException {
		//封装数据源
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("d:\\复制图片.avi"));
		//封装目的地
		BufferedOutStream bos = new BufferedOutStream(new FileOutputStream("copy.avi"));
		int by;
		while((by=bis.read())!=-1){
			bos.write(by);
		}
		bos.close();
		bis.close();
	}
	//缓冲字节流读写一个字节数组
	private static void method4() throws IOException {
		//封装数据源
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("d:\\复制图片.avi"));
		//封装目的地的
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutStream("copy.avi"));
		byte[] bys = new byte[1024];
		int len;
		while((len=bis.read(bys))!=-1){
		bos.write(bys,0,len);
		}
		bos.close();
		bis.close();
	}
	private static void method3() throws IOException {
		//封装数据源
		FileInputStream fis = new FileInputStream("d:\\复制图片.avi");
		//封装目的地
		FileOutputStream fos = new FileOutputStream("copy.avi");
		byte[] bys = new byte[1024];
		int len;
		while((len=fis.read(bys))!=-1){
			for.write(bys,0,len);
		}
		fos.close();
		fis.close();
	}
}

转换流出现的原因

由于字节流操作中文不是特别方便，所以，java就提供了转换流。
转换流 = 字节流+编码表

String类中的编码和解码问题

/*
 *编码
 *把看得的懂的变成看不懂的
 *public byte[] getBytes(String charseName) throws UnsupportedEncodingException
 *使用指定的字符集将此String 编码为byte序列，并将结果存储到一个新的byte数组中
 *解码
 *把看不懂的变成看得懂的
 *public String(byte[] bytes,String charsetName)
 *通过使用指定的charset解码指定的byte数组，构成一个新的String
 */
public class StringDemo {
	public static void main(String[] args){
		//定义一个字符串
		String s = "你好"；
		//编码
		byte[] bys = s.getBytes();
		//默认编码GBK
		//[-60,-29,-70,-61]
		//byte[] bys = s.getBytes("GBK");
		//[-60,-29,-70,-61]
		//byte[] bys = s.getBytes("UTF-8");
		//[-28,-67,-96,-27,-91,-61]
		System.out.println(Arrays.toString(bys));
		//解码
		//String ss = new String(bys);
		String ss = new String(bys,"GBK");
		System.out.println(ss);
	}
}

转换流中的编码和解码问题

/*
 *import java.io.FileNotFoundException;
 *import java.io.FileOutputStream;
 *import java.io.OutputStreamWriter;
 *转换流其实就是一个字节流
 *OutputStreamWrite 字符输出流
 *public OutputStreamWrite(OutputStream out):根据默认编码把字节流的数据转换为字符流
 *public OutputStreamWrite(OutputStream out,String charsetName):根据指定编码把字节流转换为字符流
 *InputStreamReader字符输入流
 *public InputStreamReader(InputStream in)：用默认的编码
 *public InputStreamReader(InputStream in,String charsetName):用指定的编码读数据
 */
public class ConversionStreamDemo{
	public static void main(String[] args) throws IOException {
		OutputStreamWrite osw = new OutputStreamWrite(new FileOutputStream("osw.txt"),"UTF-8");
		//调用写数据的方法
		osw.write("你好")；
		//释放资源
		osw.close();
		System.out.println("-------")
	
		InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"),"UTF-8");
		int ch;
		while((ch=isr.read())!=-1){
			System.out.print((char)ch);
		}
		//释放资源
		isr.close();
	}
}

OutputStream写数据的5种方式

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
/*
 *OutputStreamWrite写数据方法；
 *public void write(int c):写一个字符
 *public void write(char[] cbuf):写一个字符数组
 *public void write(char[] cbuf,int off,int len):写一个字符数组的一部分
 *public void write(String str):写一个字符串
 *public void write(String str,int off,int len):写一个字符串的一部分
 */
public class OutputStreamWriteDemo {
	public static void main(String[] args) throws IOException {
		//创建字符输出流对象
		OutputStreamWrite osw = new OutputStreamWriter(new FileOutputStream("b.txt"));
		//public void write(int c):写一个字符
		osw.write(97);
		osw.write('a');
		//1字符=2字节
		//文件的数据存储单位是字节
		//public void write(char[] cbuf):写一个字符数组
		char[] chs = {'a','b','c','d','e'};
		//osw.write(chs,1,3);
		//osw.write("hello");
		//void flush():刷新该流的缓冲
		//osw.flush();
		osw.close();
	}
}

InputStreamRead读数据的2种方式

/*
 *InputStreamReader读数据方法
 *public int read():一次读一个字符
 *public int read(char[] cbuf):一次读取一个字符数据
*/
public class InputStreamReaderDemo {
	public static void main(String[] args) throws IOException {
		//创建字符输入流对象
		InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));
		InputStreamReader isr = new InputStreamReader("OutputStream");
		//public int read():一次读取一个字符
		int ch;
		which((ch=isr.read())!=-1){
			System.out.print((char)ch);
		}
		//public int read(char[] cbuf):一次读取一个字符数组
		char[] chs = new char[1024];
		int len;
		while((len=isr.read(chs))!=-1) }
			System.out.print(new String(chs,0,len));
		}
		//释放资源
		isr.close();
	}
}

字符流的练习之复制java文件

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
/*
 *把当前项目目录下的StringDemo.java内容复制到当前项目目录下的Copy.java
 *数据源：StringDemo.java --- 读数据 --- 字符流 --- InputStreamReader
 *目的地：Copy.java --- 写数据 --- 字符流 --- OutputStreamWriter
*/
public class CopyJavaTest {
	public static void main(String[] args) throws IOException {
		//封装数据源
		InputStreamReader isr = new InputStreamReader(new FileInputStream("StringDemo.java"));
		//封装目的地
		OutputStreamWrite osw = new OutputStreamWriter(new FileOutputStream("Copy.java"));
		//读写数据
		//方式1：一次读写一个字符
		int ch;
		while((ch=isr.read())!=-1){
			osw.write(ch);
		}
		//方式2：一次读写一个字符数组
		char[] chs = new char[1024];
		int len;
		while((len=isr.read(chs))!=-1){
			osw.write(chs,0,len);
		}
		//释放资源
		osw.close();
		isr.close();
	}
}

改进版

/*
 *把当前项目目录下的StringDemo.java内容复制到当前项目目录下的Copy.java中
 *准换流的名字比较长，而我们常见的操作都是按照本地默认编码实现的，所以，为了简单我们的书写，转换流提供了对应的子类。
 *FileWriter:用来写入字符文件的便捷性：OutputStreamWriter
 *FileReader:用来读取字符文件的便捷性：InputStreamReader
 *OutputStreamWriter = FileOutputStream + 编码表（GBK）
 *FileWriter = FileOutputStream + 编码表
 *FileWriter(String fileName)
 *
 *InputStreamReader = FileInputStream + 编码表
 *FileRead = FileInputStream + 编码表
 *FileReader(String fileName)
 *
 *数据源：StringDemo.java --- 读数据 --- 字符流 ---InputStreamReader --- FileReader
 *目的地：Copy.java --- 写数据 --- 字符流 --- OutputStreamWriter --- FileWriter
*/
public class CopyJavaTest2 {
	public static void main(String[] args) throws IOException {
		//封装数据源
		FileReader fr = new FileReader("StringDemo.java");
		//封装目的地
		FileWriter fw = new FileWriter("Copy.java");
		//读写数据
		//一次读写一个字符
		int ch;
		while((ch=fr.read())!=-1){
			fw.write(chs,0,len);
		}
		//释放资源
		fw.close();
		fr.close();
	}
}

字符缓冲区流的概述和使用

import java.io.BufferedWriter;
import java.io.FileWriter;
/*
 *字符缓冲区流：
 *BufferedWriter:
 *将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入
 *构造方法：BufferedWriter(Writer out)

 *BufferedReader;
 *从字符输入流读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取
 *构造方法：BufferedReader(Reader in)
*/
	public static void main(String[] args) throws IOException {
		//创建字符缓冲输出流对象
		BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));
		//调用写数据的方法
		bw.write("hello");
		//释放资源
		bw.close();

		//创建字符缓冲输入流对象
		BufferedReader br = new BufferedReader(new FileReader("BufferedStreamDemo.java"));
		//方式1：一次读取一个字符
		int ch;
		while((ch=br.read())!=-1) {
			System.out.print((char)ch);
		}	
		//方式2：一次读取一个字符数组
		char[] chs = new char[1024];
		int len;
		while((len=br.read(chs))!=-1) {
			System.out.print(new String(chs,0,len));
		}
		//释放资源
		br.close();
	}
}

字符缓冲区流的练习之复制文本文件

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWrite;
import java.io.IOException;
/*
 *把项目目录下的a.txt内容复制到项目目录下的b.txt中
 *数据源：a.txt---读数据---字符流---InputStreamReader---FileReader---BufferedReader
 *目的地：b.txt---写数据---字符流---OutputStreamWriter---FileWriter---BufferedWriter
*/
public class CopyText {
	public static void main(String[] args) throws IOException{
		//封装数据源
		BufferedReader br = new BufferedReader(new FileReader("a.txt"));
		//封装目的地
		BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
		//读写数据
		//一次读写一个字符数组
		char[] chs = new char[1024];
		int len;
		while((len=br.read(chs))!=-1) {
			bw.write(chs,0,len);
		}
		//释放资源
		bw.close();
		br.close();
	}
}

字符缓冲区流的特殊功能

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
/*
 *特殊功能
 *BuffereredWriter
 *void newLine():写入一个行分隔符，这个行分隔符是由系统确定的
 *BufferedReader
 *String readLine()
 */
public class BufferedStreamDemo {
	public static void main(String[] args) throws IOException {
		//创建字符缓冲输出流对象
		BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
		//写数据
		for(int x=0;x<3;x++) {
			bw.write("hello9");
			
		}
		//释放资源
		bw.close();
		//创建字符缓冲输入流对象
		BufferedReader br = new BufferedReader(new FileReader("bw.txt"));
		//读取一次
		String line = br.readLione();
		System.out.println(line);
		//最终代码
		String line;
		while((line=br.readLine())!=null) {
			System.out.println(line);
		}
		br.close();
	}	
}

字符缓冲区流的特殊功能复制java文件，文本文件

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/*
 *字符缓冲流特殊功能复制java文件
 *数据源：
 *BufferedStreamDemo.java --- BufferedReader
 *目的地：
 *Copy.java---BufferedWriter
/*
public class CopyJavaTest {
	public static void main(String[] args) throws IOException {
		//封装数据源
		BufferedReader br = new BufferedReader(new FileReader("BufferedStreamDemo.java"));
		BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
		//读写数据
		String line;
		while((line=br.readLine())!=null) {
			bw.write(line);
			bw.newLine();
			bw.flush();
		}
		//释放资源
		bw.close();
		br.close();
	}
}

/*
 *需求：5种方式复制文本文件
 *数据源：d:\\xxx.txt
 *目的地：yyy.txt
 *5种方式：
 *基本字符流一次读写一个字符
 *基本字符流一次读写一个数组
 *缓冲字符流一次读写一个字符
 *缓冲字节流一次读取一个字符数组
 *缓冲字符串一次读写一个字符串
 */
public class CopyFileTest {
	public static void main(String[] args) {
		method1();
		method2();
		method3();
		method4();
		method5();
	}
	//基本字符流一次读取一个字节
	private static void method1() throws IOExeption {
		FileReader fr = new FileReader("d:\\xxx.txt");
		FileWriter fw = new FileWriter("yyy.txt");
		int ch;
		while((ch=fr.read())!=-1){
			fw.write(ch);
		}
		fw.close();
		fr.close();
	}
	//基本字符流一次读取一个字符数组
	private static void method2() throws IOException {
		FileReader fr = new FileReader("d:\\xxx.txt");
		FileWriter fw = new FileWriter("yyy.txt");
		char[] chs = new char[1024];
		int len;
		while((len=fr.read(chs))!=-1){
			fw.write(chs,0,len);
		}
		fw.close();
		fr.close();
	}
	//缓冲字符流一次读取一个字符
	private static void method3() throws IOException {
		BufferedReader br = new BufferedReader(new FileReader("d:\\xxx.txt"));
		BufferedWriter bw = new BufferedWriter(new FileWriter("yyy.txt"));
		int ch;
		while((ch=br.read())!=-1) {
			bw.write(ch);
		}
		bw.close();
		br.close();
	}
	//缓冲字符流一次读写一个字符数组
	private static void method4() throws IOException {
		FileReader br = new FileReader("d:\\xxx.txt");
		FileWriter bw = new FileWriter("yyy.txt");
		char[] chs = new char[1024];
		int len;
		while((len=fr.read(chs))!=-1){
			bw.write(chs,0,len);
		}
		bw.close();
		br.close();
	}
	//缓冲字符流读写一个字符串
	private static void method5() throws IOException {
		FileReader br = new FileReader("d:\\xxx.txt");
		FileWriter bw = new FileWriter("yyy.txt");
		char[] chs = new char[1024];
		int len;
		while((len=fr.read(chs))!=-1){
			bw.write(chs,0,len);
		}
		bw.close();
		br.close();
	}
}
【世事如棋】
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java之io流
xiaoxiaobaie的博客
12-15 90
什么是流 概念： 内存与存储设备之间传输数据的通道 流的分类 按方向【重点】： 输入流：将<存储设备>中的内容读入到<内存>中 输出流：将<内存>中的内容写入到<存储设备>中 按单位： 字节流：以字节为单位，可以读写所有的数据 字符流：以字符为单位，只能读写文本数据 按功能： 节点流：具有实际传输数据的读写功能 过滤流：在节点流的基础之上增强功能 字节流 InputStream：字节输入流 public int read(
java基础之IO流
asd7786225的博客
05-19 162
1、IO流结构 IO流 字节流 1、直接操作文件，操作二进制文件速度更快 2、以字节为单位按8位传输 InputStream字节输入流 处理流 ObjectInputStream FilterInputStream BufferedInputStream DataInputStream 节点流 FileInputStream ByteArrayInputStream OutputStream字节输出流 ...
对FileInputStream.read()方法的一点心得
weixin_38036079的博客
03-26 1425
先上代码 1 2 3 4 5 6 7 FileOutputStream outputStream =newFileOutputStream("data.txt"); byte[] bytes =newbyte[1024]; intnum =0; while((num=fileInputStream.read(bytes)) != -1){ ...
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 15万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
Java基础IO流
m0_61894608的博客
07-03 1306
自学IO流
java基础 IO流
09-05
此文档属于本人当初学习java基础之IO流，所整理的文档。里面有字节流与字符流的比较，也有总结使用不同方式读取文档的demo。希望对你的学习有帮助，谢谢！
IO:java基础io流
03-21
在Java中，IO流分为两大类：字节流和字符流，每类又有输入流和输出流之分。此外，还有缓冲流、转换流、对象流、文件流、网络流等多种类型，它们构成了Java IO体系。 1. 字节流：字节流处理单个字节的数据。Java中，...
Java IO流 文件传输基础
09-02
文件传输基础是Java IO流应用的一个核心场景，通过IO流可以实现对文件的读写操作，包括创建、打开、修改和删除文件。在本文中，我们将深入探讨Java IO流在文件传输中的基础知识，特别是涉及文件编码的概念。 文件的...
Java-Io流，练习
07-06
本练习旨在帮助初学者理解和掌握Java IO流的基础知识。 一、IO流的概念 IO流在Java中分为两大类：输入流（Input Stream）和输出流（Output Stream）。输入流用于从源（如文件、网络连接等）读取数据，而输出流则...
golang 接口
m0_70982551的博客
07-24 837
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 373
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
【Java算法专场】二分查找(下）
最新发布
zhyhgx的博客
07-27 457
本道题是要在一个从0~n-1的数组中找缺失的数，我们可以采用哈希表来解决，但此时时空复杂度达到了O(n),这是一个有序的数组，我们可以采用二分查找来解决，使时间复杂度达到O(logn).我们可以发现，每个数组的下标和其元素是相同的，那么我们可以通过判断下标和元素的大小，来确定缺失值的位置。3.mid=4+(5-4)/2=4,nums[mid]=5
springboot之自动装配
weixin_50153914的博客
07-23 520
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 451
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 359
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 337
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
学习笔记---java篇（0723）
m0_70630166的博客
07-23 818
java、数据类型、循环、选择等
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 145
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
Java IO流详解：从基础到实践
Java的IO流技术是Java编程中至关重要的部分，它涉及数据的输入/输出操作，以"流"的形式进行管理和传输。Java 2 SDK提供了丰富的流类，主要集中在java.io包中，这些类和接口构成了Java IO体系的基础。 首先，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值