Java知识点总结——IO流框架
IO框架
一、流的概念
概念:内存与存储设备之间传输数据的通道。
二、流的分类
按方向分类:
- 输入流:将<存储设备>中的内容读入到<内存>中
- 输出流:将<内存>中的内容读入到<存储设备>中
内存:内存是一种用于暂时存放[CPU]中的运算数据和外部储存器交换数据的随机储存器。
存储:一般可分为机械[硬盘]和[固态硬盘],是一种储存硬件,用于存放数据。
按单位进行划分:
- 字节流:以字节为单位,可以读写所有数据。
- 字符流:以字符为单位,只能读写文本数据。
按功能进行划分:
- 节点流:具有实际传输数据的读写功能。
- 过滤流:在节点流的基础上增强功能,比如缓冲流。
三、字节流
文件字节流
字节流的两个抽象父类:
- 字节输入流:
InputStream
这个抽象类是表示输入字节流的所有类的超类。
常用方法:
- 字节输出流:
OutputStream
这个抽象类是表示字节输出流的所有类的超类。 输出流接收输出字节并将其发送到某个接收器。
常用方法:
字节流的两个子类——文件字节流:
- 文件字节输入流:
FileInputStream
——读取文件
public class FileInputStream extends InputStream
从文件系统中的文件获取输入字节。 什么文件可用取决于主机环境。
FileInputStream
用于读取诸如图像数据的原始字节流。 要阅读字符串,请考虑使用FileReader
。
构造方法:
常用方法:
public int read(byte[] b)
从流中读取多个
字节,将读到的内容存入b
数组,返回实际读到的字节数
;如果达到文件的尾部,则返回-1
第一种读取方式:单个字节读取——效率不高!
【参考代码】
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class InputStreamTest {
public static void main(String[] args) throws Exception {
// 1.创建FileInputStream,并指定文件路径
FileInputStream fis = new FileInputStream("d:\\aaa.txt");
// 2.读取文件fis.read():一个一个的读
int data = 0;
while ((data = fis.read()) != -1){
System.out.println();
}
// 3.读完之后,关闭流
fis.close();
}
}
第二种读取方式:一次读取多个字节,多一个字节数组!
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class InputStreamTest {
public static void main(String[] args) throws Exception {
// 1.创建FileInputStream,并指定文件路径
FileInputStream fis = new FileInputStream("d:\\aaa.txt");
// 2.读取文件fis.read():一个一个的读
// int data = 0;
// while ((data = fis.read()) != -1){
// System.out.println();
// }
// 2.1一次读取多个字节
byte[] buf = new byte[1024];
int count = 0;
while ((count = fis.read(buf)) != -1){
System.out.println(new String(buf, 0, count)); // abcdefg
}
// 3.读完之后,关闭流
fis.close();
}
}
- 文件字节输出流:
FileOutputStream
——写入文件
public class FilterOutputStream extends OutputStream
这个类是过滤输出流的所有类的超类。 这些流位于已经存在的输出流( 底层输出流) 之上 ,它使用它作为数据的基本接收器,但是可能沿着数据方向转换或提供附加功能。
构造方法:
常用方法:
public int write(byte[] b)
一次写多个字节,将b数组中的所有字节,写入输出流中!
【参考代码】
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
public class FileOutPutStreamTest {
public static void main(String[] args) throws Exception {
// 创建文件输出流
FileOutputStream fos = new FileOutputStream("d:\\bbb.txt",true); // 加true后新的字节不会覆盖原字节
// 读入多个字节
String str = "abcdef";
fos.write(str.getBytes());
// 关闭流
fos.close();
System.out.println("加载完毕!");
}
}
注:如果是文本文件最好用字符流
案例:使用文件字节流进行文件复制
复制文件:利用文件字节流,一边读取,一边写入!
注:使用字节流可以复制任意文件,而字符流却不行!
【参考代码】
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class FileCopyDemon {
public static void main(String[] args) throws Exception{
// 创建文件输入流
FileInputStream fis = new FileInputStream("d:\\bbb.txt");
// 创建文件输出流
FileOutputStream fos = new FileOutputStream("d:\\ccc.txt");
//复制文件:一边读取,一边写入
byte[] buf = new byte[1024];
int count = 0;// count实际读取的个数
while ((count = fis.read(buf)) != -1){
fos.write(buf, 0, count);
}
fis.close();
fos.close();
System.out.println("复制完毕!");
}
}
文件字节缓冲流
缓冲流:BufferedInputStream/BufferedOutputStream
。提高IO效率,减少访问磁盘的次数;数据存储在缓冲区,flush
是将缓冲区的内容写入文件中,也可以直接close
。
- 字节输入缓冲流:
BufferedInputStream
——快速读取文件
BufferedInputStream
为另一个输入流添加了功能,即缓冲输入和支持mark
和reset
方法的功能。 当创建BufferedInputStream
时,将创建一个内部缓冲区数组。 当从流中读取或跳过字节时,内部缓冲区将根据需要从所包含的输入流中重新填充,一次有多个字节。 mark
操作会记住输入流中的一点,并且reset
操作会导致从最近的mark
操作之后读取的所有字节在从包含的输入流中取出新的字节之前重新读取。
构造方法:
常用方法:
【参考代码】
import java.io.BufferedInputStream;
import java.io.FileInputStream;
public class BufferedInputStreamDemon {
public static void main(String[] args) throws Exception{
FileInputStream fis = new FileInputStream("d:\\aaa.txt");
//1. 创建字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(fis); // 维护字节流,从缓冲区读取字节,加快效率
//2. 读取
int data = 0;
while((data = bis.read()) != -1){
System.out.println((char) data);
}
//3. 关闭缓冲流
bis.close();
}
}
- 字节输出缓冲流:
BufferedOutputStream
——快速写入文件
该类实现缓冲输出流。 通过设置这样的输出流,应用程序可以向底层输出流写入字节,不必为写入的每个字节导致底层系统的调用。
构造方法:
常用方法:
【参考代码】
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
public class BufferedOutputStreamDemon {
public static void main(String[] args) throws Exception{
FileOutputStream fos = new FileOutputStream("d:\\buff.txt");
//1. 创建输出缓冲流
BufferedOutputStream bos = new BufferedOutputStream(fos);
//2. 写入文件
String str = "hello";
for(int i = 0; i <= 5; i ++){
bos.write(str.getBytes()); // 写入8k缓冲区
bos.flush(); // 刷新到硬盘
}
//3. 关闭流(内部调用)
fos.close(flush方法);
}
}
四、编码方式
注:当编码方式和解码方式不一致时,就会出现乱码!
五、字符流
引入:3个字节相当于一个字符,当我们要读取汉字(字符)时,如果用字节流来读取的话,他是一个一个字节读取的,最终的结果是字节,而不是我们想要的字符了!
字符流的两个父类(抽象类):
Reader
:字符输入流常用方法:
public int read() {}
public int read(char[] c) {}
public int read(char[] b, int off, int len) {}
Write
:字符输出流常用方法:
public void write(int n) {}
public void write(String str) {}
public void write(char[] c) {}
文件字符流
FileReader
——文件字符输入流
阅读字符文件的便利课。 该类的构造函数假定默认字符编码和默认字节缓冲区大小是适当的。 要自己指定这些值,请在FileInputStream上构造一个InputStreamReader。
FileReader
是用于读取字符流。 要读取原始字节流,请考虑使用FileInputStream
。
public class FileReader extends InputStreamReader
构造方法:
常用方法:继承父类!
public int read(char[] c);
从流中读取多个字符,讲读到内容存入c数组,返回实际读到的字符数;如果文件达到尾部,则返回-1.
【参考代码】
import java.io.FileReader;
public class FileReaderDemon {
public static void main(String[] args) throws Exception{
//1. 创建FileReader 文件字符输入流
FileReader fr = new FileReader("d:\\hello.txt");
//2. 读取
//2.1 单个读取
// int data = 0;
// while ((data = fr.read()) != -1){ // 读取一个字符!
// System.out.println((char)data);
// }
char[] buf = new char[1024];
int count = 0;
while((count = fr.read(buf)) != -1){
System.out.println(new String(buf, 0, count));
}
//3. 关闭
fr.close();
}
}
FileWriter
——文件字符输出流
public void write(String str);
一次写入多个字符,将b数组中所有字符,写入输出流;
【参考代码】
import java.io.FileWriter;
public class FileWriterDemon {
public static void main(String[] args) throws Exception{
//1. 创建FileWriter对象
FileWriter fw = new FileWriter("d:\\write.txt");
//2. 写入字符
String str = "防不胜防";
for(int i = 0; i < str.length(); i ++){
fw.write(str);
fw.flush();
}
//3. 关闭
fw.close();
System.out.println("执行完毕");
}
}
案例:文件字符流实现文本文件复制
注:FileReader、FileWriter
只能复制文本文件,不能复制图片或者二进制文件!—— 文本文件有字符编码!
【参考代码】
import java.io.FileReader;
import java.io.FileWriter;
public class CopyDemon {
public static void main(String[] args) throws Exception{
//1. 创建FileReader FileWriter 对象
FileReader fr = new FileReader("d:\\write.txt");
FileWriter fw = new FileWriter("d:\\write2.txt");
//2. 读写
int data = 0;
while((data = fr.read()) != -1){
fw.write(data);
fw.flush();
}
//3. 关闭
fr.close();
fw.close();
System.out.println("复制完毕!");
}
}
字符缓冲流
字符缓冲流:BufferedReader/BufferedWriter
(1)高效读写
(2)支持输入换行
(3)可一次写一行,读一行。
BufferedReader
——字符缓冲输入流
从字符输入流读取文本,缓冲字符,以提供字符,数组和行的高效读取。
可以指定缓冲区大小,或者可以使用默认大小。 默认值足够大,可用于大多数用途。
通常,由读取器做出的每个读取请求将引起对底层字符或字节流的相应读取请求。 因此,建议将BufferedReader包装在其read()操 作可能昂贵的读取器上,例如FileReader
BufferedReader in = new BufferedReader(new FileReader("foo.in"));
将缓冲指定文件的输入。 没有缓冲,每次调用read()或readLine()可能会导致从文件中读取字节,转换成字符,然后返回,这可能非常低效。
构造方法:
常用方法:
【参考代码】
```
import java.io.BufferedReader;
import java.io.FileReader;
/**
* 字符缓冲流读取文件
*/
public class BufferedReaderDemon {
public static void main(String[] args) throws Exception{
//1. 创建缓冲流
FileReader fr = new FileReader("d:\\write.txt");
BufferedReader br = new BufferedReader(fr);
//2. 读取
//2.1 第一种读取方式
// char[] buf = new char[1024];
// int count = 0;
// while ((count = br.read(buf)) != -1){
// System.out.println(new String(buf, 0, count));
// }
//2.2 第二种读取方式。 一行一行的读取
String line = null;
while ((line = br.readLine()) != null){
System.out.println(line);
}
//3. 关闭
br.close();
}
}
BufferedWriter
——字符缓冲输出流(写入字符)
将文本写入字符输出流,缓冲字符,以提供单个字符,数组和字符串的高效写入。
可以指定缓冲区大小,或者可以接受默认大小。 默认值足够大,可用于大多数用途。
提供了一个newLine()方法,它使用平台自己的系统属性line.separator
定义的行分隔符概念。 并非所有平台都使用换行符('\ n')来终止行。 因此,调用此方法来终止每个输出行,因此优选直接写入换行符。
构造方法:
常用方法:
【参考代码】
import java.io.BufferedWriter;
import java.io.FileWriter;
public class BufferedWriterDemon {
public static void main(String[] args) throws Exception{
//1. 创建BufferedWriter对象
FileWriter fw = new FileWriter("d:\\buffer.txt");
BufferedWriter bw = new BufferedWriter(fw);
//2. 写入
for (int i = 0; i < 5; i ++){
bw.write("好好学习吧!");
bw.newLine();// 换行!
bw.flush();
}
//3. 关闭
bw.close();
}
}
打印流
PrintWriter
——打印流
将对象的格式表示打印到文本输出流。 这个类实现了全部在发现print种
方法PrintStream
。 它不包含用于编写原始字节的方法,程序应使用未编码的字节流。
不像类,如果启用自动刷新,它只会在调用的println,printf,
或format
方法来完成,而不是当一个换行符恰好是输出。 这些方法使用平台自己的行分隔符而不是换行符。
转换流
转换流:InputStreamReader/OutputStreamWriter
(1)可以将字节流转为字符流
(2)可设置字符的编码方式
转换流的使用:
InputStreamReader读取文件
【参考代码】
import java.io.FileInputStream;
import java.io.InputStreamReader;
public class ZhuanHuanLiuTest {
public static void main(String[] args) throws Exception{
//1. 创建InputStreamReader对象
FileInputStream fis = new FileInputStream("d:\\write.txt");
InputStreamReader isr = new InputStreamReader(fis, "utf-8"); // 转换流设置编码方式
//2.读取文件
int data = 0;
while ((data = isr.read()) != -1){
System.out.println((char) data);
}
//3. 关闭
isr.close();
}
}
OutputStreamWriter——写入文件
【参考代码】
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
public class ZhuanHuanLiuTest {
public static void main(String[] args) throws Exception{
//1. 创建OutputStreamWriter对象
FileOutputStream fos = new FileOutputStream("d:\\info.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos, "gbk"); // 转换流设置编码方式
//2. 写入
for(int i = 0; i < 5; i ++){
osw.write("我爱学习\r\n");
osw.flush();
}
//3. 关闭
osw.close();
}
}
六、对象流
对象流:ObjectInputStream/ObjectOutputStream
。
(1)增强了缓冲区功能
(2)增强了读取8种基本数据类型和字符串功能
(3)增强了读写对象的功能:
readObject() 从流中读取一个对象(反序列化)
writeObject(Object obj) 向流中写入一个对象(序列化)
使用流传输对象的过程称为序列化,和反序列化。
- 对象输出流:
ObjectOutputStream
——序列化(写入对象)
ObjectOutputStream将Java对象的原始数据类型和图形写入OutputStream。 可以使用ObjectInputStream读取(重构)对象。 可以 通过使用流的文件来实现对象的持久存储。 如果流是网络套接字流,则可以在另一个主机上或另一个进程中重构对象。
构造方法:
常用方法:
【参考代码】
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class ObjectOutputStreamDemon {
/**
* 使用ObjectOutputStream实现对象的序列化————读入对象
* 要求:序列化类必须实现接口
*/
public static void main(String[] args) throws Exception{
//1. 创建对象流
FileOutputStream fos = new FileOutputStream("d:\\stu.bin");
ObjectOutputStream oos = new ObjectOutputStream(fos);
//2. 序列化(写入操作)
Student student = new Student("张三",19);
oos.writeObject(student);
//3. 关闭(自带flush()方法了)
oos.close();
System.out.println("序列化完毕");
}
}
class Student implements Serializable {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
使用ObjectOutputStream实现对象的序列化————写入对象
要求:序列化类必须实现接口
- 对象输入流:
ObjectInputStream
——反序列化(读取重构成对象)
ObjectInputStream反序列化先前使用ObjectOutputStream编写的原始数据和对象。
构造方法:
常用方法:
【参考代码】
import java.io.*;
public class ObjectInputStreamDemon {
public static void main(String[] args) throws Exception{
//1. 创建对象流
FileInputStream fis = new FileInputStream("d:\\stu.bin");
ObjectInputStream ois = new ObjectInputStream(fis);
//2. 读取文件(反序列化)
Student st = (Student) ois.readObject();
//3. 关闭
ois.close();
System.out.println(st.toString());// Student{name='张三', age=19}
}
}
序列化和反序列化注意事项:
(1)序列化类必须实现Serializable
接口
(2)序列化类中对象属性要求实现Serializable接口
(3)序列化版本号ID,保证序列化的类和反序列化的类是同一个类
(4)使用transient(瞬间的)修饰属性,这个属性不能序列化
(5)静态属性不能序列化
(6)序列化多个对象,可以借助集合
七、File类
概念:代表物理磁盘中的一个文件或者文件夹(目录)。
常用方法:
文件操作
(1)分隔符:
- 路径分隔符
;
- 名称分隔符
\
(2)文件操作:
创建文件
createNewFile()
boolean createNewFile()
当且仅当具有该名称的文件尚不存在时,原子地创建一个由该抽象路径名命名的新的空文件。if(!file.exists()){ // 如果文件不存在则创建
boolean b = file.createNewFile();
System.out.println("创建结果" + b);
}
删除文件
直接删除:
delete()
boolean delete()
删除由此抽象路径名表示的文件或目录JVM退出时删除:
file.deleteOnExit();
Thread.sleep(5000); // 休眠五秒
获取文件信息
getAbsolutePath()
:获取到文件的绝对路径getPath()
:获取到文件的路径getName()
:获取文件的名称getParent()
:获取文件的父级目录length()
:获取文件的长度lastModified()
:获取文件的创建时间System.out.println("文件创建时间:" + new Date(file.lastModified()));
判断
canWrite()
:判断文件是否可写isFile()
:判断是否是文件isHidden()
:判断文件是否隐藏
【参考代码】
import java.io.File;
import java.util.Date;
public class FileTest {
public static void main(String[] args) throws Exception{
fileOpe();
}
/**
* 文件操作
*/
public static void fileOpe() throws Exception{
//1. 创建文件
File file = new File("d:\\file.txt"); // 只是创建了一个文件对象,此时在d盘下并没有该文件
if(!file.exists()){ // 如果文件不存在则创建
boolean b = file.createNewFile();
System.out.println("创建结果" + b);
}
//2. 删除文件
//2.1 直接删除
// System.out.println("删除结果" + file.delete());
// //2.2 JVM退出时删除
// file.deleteOnExit();
// Thread.sleep(5000); // 休眠五秒
//3. 获取文件信息
System.out.println("获取文件绝对路径" + file.getAbsolutePath()); // 获取文件绝对路径d:\file.txt
System.out.println("获取路径" + file.getPath());
System.out.println("获取文件名称" + file.getName());
System.out.println("获取文件父目录" + file.getParent());
System.out.println("获取文件长度" + file.length());
System.out.println("文件创建时间:" + new Date(file.lastModified()));
//4. 判断
System.out.println("是否可写" + file.canWrite());
System.out.println("是否是文件" + file.isFile());
System.out.println("是否隐藏" + file.isHidden());
}
}
文件夹操作
创建文件夹
boolean
mkdir()
创建由此抽象路径名命名的目录。boolean
mkdirs()
创建由此抽象路径名命名的目录,包括任何必需但不存在的父目录。File dir = new File("d:\\aaa\\bbb\\ccc");
if(! dir.exists()){
dir.mkdir();// 只能单级目录
System.out.println("创建结果:" + dir.mkdirs()); //mkdirs();//可以创建多级目录
}
删除文件夹
直接删除:
delete()
——只能删除空目录JVM删除:
file.deleteOnExit();Thread.sleep(5000);
// 休眠五秒获取文件夹信息
getAbsolutePath()
:获取到文件夹的绝对路径getPath()
:获取到文件夹的路径getName()
:获取文件夹的名称(最里层)getParent()
:获取文件夹的父级目录lastModified()
:获取文件的创建时间
判断
isDirectory()
:判断是否是文件夹isHidden()
:判断文件是否隐藏
遍历文件
(1)
list()
String[]
list()
返回一个字符串数组,命名由此抽象路径名表示的目录中的文件和目录。//5. 遍历文件夹
File dir2 = new File("e:\\picture");
String[] files = dir2.list();
for(String str: files){
System.out.println(str);
}
(2)
listFiles()
File[]
listFiles()
返回一个抽象路径名数组,表示由该抽象路径名表示的目录中的文件。//5. 遍历文件夹
File dir2 = new File("e:\\picture");
File[] files = dir2.listFiles(); // 文件数组
for(File file: files){
System.out.println(file.getName());
}
FileFilter接口
当调用File类中的listFiles()
方法时,支持传入FileFilter
接口接口实现类,对获取文件进行过滤,只有满足条件的文件才可以出现在listFiles()
方法的返回值中。
File[] |
listFiles(FileFilter filter) 返回一个抽象路径名数组,表示由此抽象路径名表示的满足指定过滤器的目录中的文件和目录。 |
---|
【参考代码】
File dir2 = new File("e:\\picture");
// 过滤:过滤出满足条件的文件
File[] file2 = dir2.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
if(pathname.getName().endsWith(".png")){ // 只要.png结尾的图片
return true;
}
return false;
}
});
// 遍历输出
for(File file : file2){
System.out.println(file.getName());
}
递归遍历与删除
递归遍历文件夹:
遍历拿到dir.listFiles()
路径的路径数组,数组不为空且有文件的情况下,如果是文件夹递归则进去,直到不是文件夹,然后输出文件,否则输出当前目录下的文件!
【参考代码】
import java.io.File;
public class ListDemon {
public static void main(String[] args) {
listDir(new File("e:\\aaa"));
}
//递归遍历文件夹
public static void listDir(File dir){
File[] files = dir.listFiles();// 得到所有得子文件与子文件夹
System.out.println("路径:"+ dir.getAbsolutePath());
if(files != null && files.length > 0){
for(File file : files){
if(file.isDirectory()){// 判断是否为文件夹
listDir(file); // 如果是文件夹递归进去,直到不是文件夹
}else{// 不是文件夹 则输出
System.out.println(file.getAbsolutePath());
}
}
}
}
}
我电脑E盘下的aaa文件如下图:
递归删除文件夹:
我们直到delete()
方法只能删除空目录。如果目录里边有内容,delete()
方法是无法删除的,即我们想用delete()
方法删除上述aaa文件是行不通的!
为此,我们得先将aaa
文件中所有内容给删除之后,才能将aaa
文件删除掉!aaa
里边有bbb
文件夹,为此得先把它里边得内容先删掉,bbb
里边有ccc
文件夹为此得先把它里边得内容先删掉........然后再逐步回退删除文件夹!
【参考代码】
import java.io.File;
public class ListDemon {
public static void main(String[] args) {
deleteDir(new File("e:\\aaa"));
}
// 递归删除文件夹
public static void deleteDir(File dir){
File[] files = dir.listFiles();
if(files != null && files.length > 0){
for(File file : files){
if(file.isDirectory()){
deleteDir(file); // 递归
}else {
// 删除文件
System.out.println(file.getAbsolutePath() + "删除:" + file.delete());
}
}
}
// 删除文件夹
System.out.println(dir.getAbsolutePath() + "删除:" + dir.delete());
}
}
图示:
Properties
Properties:属性集合
public class Properties extends Hashtable<Object,Object>
Properties
类表示一组持久的属性。 Properties
可以保存到流中或从流中加载。 属性列表中的每个键及其对应的值都是一个字符串。
属性列表可以包含另一个属性列表作为其“默认值”; 如果在原始属性列表中找不到属性键,则会搜索此第二个属性列表。
特点:
- 存储属性名和属性值
- 属性名和属性值都是字符串类型
- 没有泛型
- 和流有关
String |
getProperty(String key) 使用此属性列表中指定的键搜索属性,得到对应得value。 |
---|---|
Object |
setProperty(String key, String value) 同 Hashtable 方法 put 。 |
void |
list(PrintStream out) 将此属性列表打印到指定的输出流。 |
void |
load(InputStream inStream) 从输入字节流读取属性列表(键和元素对)。 |
void |
store(OutputStream out, String comments) 将此属性列表(键和元素对)写入此 Properties 表中,以适合于使用方法加载到 Properties 表中的格式输出流。 |
后面学习的JDBC连接数据会用得到.properties
文件!
八、总结
注:如果文章有任何错误或不足,请各位大佬尽情指出,评论留言留下您宝贵的建议!如果这篇文章对你有些许帮助,希望可爱亲切的您点个赞推荐一手,非常感谢啦
Java知识点总结——IO流框架的更多相关文章
- JAVA知识点 I/O流框架简要笔记
I/O 框架 流的概念 内存与存储设备之间传输数据的通道 流的分类 按方向[重点] 输入流:将<存储设备>中的内容读到<内存>中 输出流:将<内存>中的内容写到&l ...
- 第53节:Java当中的IO流(上)
Java当中的IO流 在Java中,字符串string可以用来操作文本数据内容,字符串缓冲区是什么呢?其实就是个容器,也是用来存储很多的数据类型的字符串,基本数据类型包装类的出现可以用来解决字符串和基 ...
- Java中的IO流大体介绍
由于Java中的IO流是在是知识点繁多,所以我大约花了1周的时间将其整理起来.但是整理起来后并不是将完事了,我还是要分字节流和字符流来讲述.然后字节流和字符流中还有是否带有缓冲流. 讲述完IO流后我将 ...
- Java中的IO流(五)
上一篇<Java中的IO流(四)>记录了一下Properties类,此类不属于IO流,它属于集合框架.接下来说一下IO流中的其它流 一,打印流PrintStream PrintStream ...
- Java中的IO流(六)
上一篇<Java中的IO流(五)>把流中的打印流PrintStream,PrintWriter,序列流SequenceInputStream以及结合之前所记录的知识点完成了文件的切割与文件 ...
- Java中的IO流(四)
上一篇<Java中的IO流(三)>把IO流中的文件及目录操作的对象File类记录了一下,本篇把本不属性IO流但又和IO流有关系的一个对象作一下记录,此对象本属于集合框架里的一个子集,即Pr ...
- Java当中的IO流(上)
Java当中的IO流 在Java中,字符串string可以用来操作文本数据内容,字符串缓冲区是什么呢?其实就是个容器,也是用来存储很多的数据类型的字符串,基本数据类型包装类的出现可以用来解决字符串和基 ...
- java中的IO流
Java中的IO流 在之前的时候我已经接触过C#中的IO流,也就是说集中数据固化的方式之一,那么我们今天来说一下java中的IO流. 首先,我们学习IO流就是要对文件或目录进行一系列的操作,那么怎样操 ...
- 第55节:Java当中的IO流-时间api(下)-上
Java当中的IO流(下)-上 日期和时间 日期类:java.util.Date 系统时间: long time = System.currentTimeMillis(); public class ...
随机推荐
- Python - 一行代码查看当前操作系统默认的编码标准
一句代码 在 cmd 中执行 > python3 -c 'import locale; print(locale.getpreferredencoding())' UTF-8
- 部署一个支持Dapr 的Kubernetes APISIX Ingress
在这篇文章中,我将展示如何创建一个 APISIX控制器,该控制器在 Kubernetes 集群中公开启用 Dapr 的应用程序. 本质上,APISIX控制器将配置相同的标准 Dapr annotati ...
- Python进阶(多线程)
多线程结构 import threading def worker():#子线程要执行的具体逻辑代码函数 print('threading') t1 = threading.current_threa ...
- Django笔记&教程 2-1 URL与View关系
Django 自学笔记兼学习教程第2章第1节--URL与View关系 点击查看教程总目录 参考:how-django-processes-a-request 1- Django处理请求(request ...
- 基于ambari搭建hadoop生态圈大数据组件
Ambari介绍1Apache Ambari是一种基于Web的工具,支持Apache Hadoop集群的供应.管理和监控.Ambari已支持大多数Hadoop组件,包括HDFS.MapReduce.H ...
- 『学了就忘』Linux软件包管理 — 48、给源码包打补丁
目录 1.补丁的生成 2.补丁的打入 在以前的软件源码包,需要打补丁的时候比较多.现在的源码包很少进行打补丁了,因为根据需求安装不同的版本即可,比较商业化了.(也就是知道如何给源码包打补丁就可以了,了 ...
- Pycharm整体缩进和减少缩进
整体缩进:鼠标拉选住代码块,按下tab键. 反向缩进:鼠标拉选住代码块,按下shift+tab键.
- 【2020五校联考NOIP #6】最佳观影
题意: 给出一个 \(k \times k\) 的网格和 \(n\) 次操作.其中 \(k\) 为奇数. 每次操作给出一个数 \(m\).每次你要找出一个三元组 \((x,l,r)\) 使得: \(r ...
- R shinydashboard ——1. 基本用法
shiny和shinydashboard使用虽然简单,但控件众多,需及时总结归纳. install.packages("shinydashboard") shinydashboar ...
- R语言与医学统计图形-【29】地图的绘制
R绘制地图原理: R使用一个个多边形(polygon)来表示每个区域,通过顺次连接GIS数据提供的每个区域多边形的坐标来逐点绘制这些多边形,所以理论上只要得到GIS数据就可绘制相应的地图. 地图绘制说 ...