标签:ide 长度 ref 的区别 img unicode rgs keyset 构造
目录
根据数据的流向分为:输入流和输出流。
其他设备
上读取到内存中
的流。内存中
写入其他设备
上的流。输入流 | 输出流 | |
---|---|---|
字节流 | 字节输入流 InputStream |
字节输出流 OutputStream |
字符流 | 字符输入流 Reader |
字符输出流 Writer |
一切文件数据(文本、图片、音频、视频等等)在存储的时候,都是以二进制数字的形式保存,都是一个一个的字节,那么传输时也一样如此。所以,字节流可以传输任意文件数据。在操作流的时候,我们要时刻明确,无论使用什么样的流对象,底层传输的始终为二进制数据。
定义了一些子类共性的成员方法:
构造方法的作用:
写入数据的原理(内存 --> 硬盘):
java程序 --> JVM(java虚拟机) --> OS(操作系统) --> OS调用写数据的方法 --> 把数据写入到文件中。
字节输出流的使用步骤(重要):
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo01OutputStream {
public static void main(String[] args) throws IOException {
// 1. 创建FileOutputStream对象,构造方法中传递写入数据的目的地
FileOutputStream fos = new FileOutputStream("D:\\aaa\\abc.txt");
// 2. 调用FileOutputStream中的方法,write,把数据写入到文件
fos.write(97);
// 3. 释放资源
fos.close();
/*
写入数据的原理:
写数据的时候会把十进制的97装换成二进制的整数
硬盘中存储的都是数据的字节
1 个字节 = 8 个比特位
注意:
任意的文本编辑器(记事本、notepad++...)
在打开文件的时候,都会查询编码表,把字节装换成字符表示
0~127:查询ASCII表
其他值:查询系统默认码表(中文系统 GBK)
*/
}
}
可以使用 String类中的方法 getBytes,把字符串装换为字节数组。
byte[] getBytes():把字符串装换为字节数组。
实例:
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
public class Demo02FileOutputStream {
public static void main(String[] args) throws IOException {
// 创建FileOutputStream对象,构造方法中传递目的地
FileOutputStream fos = new FileOutputStream("D:\\aaa\\abc.txt");
// public void write(byte[] b)
byte[] bytes = {97, 98, 99, 100};
fos.write(bytes); // abcd
// System.out.println(bytes);
// System.out.println(Arrays.toString(bytes));
// public void write(byte[] b, int off, int len)
fos.write(bytes, 1, 3); // abcdbcd
byte[] bytes2 = {-48, -49, -50, -51, 65};
System.out.println(Arrays.toString(bytes2));
fos.write(bytes2); // abcdbcd邢瓮A
// 写入字符串
byte[] bytes3 = "你好".getBytes();
System.out.println(Arrays.toString(bytes3));
fos.write(bytes3);
byte[] bytes4 = {-28, -67, -96, -27, -91, -67};
fos.write(bytes4);
// 释放资源
fos.close();
}
}
追加写 / 续写:使用两个参数的构造方法
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo03FileOutputStream {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("D:\\aaa\\abc.txt", true);
for (int i = 0; i < 10; i++) {
fos.write("你好".getBytes());
// windows 换行
fos.write("\r\n".getBytes());
}
fos.close();
}
}
定义了所有子类共性的方法:
构造方法的作用:
读取数据的原理
java程序 --> JVM(java虚拟机) --> OS(操作系统) --> OS调用读数据的方法 --> 读取文件。
字节输入流的使用步骤(重点):
import java.io.FileInputStream;
import java.io.IOException;
public class Demo04FileInputStream {
public static void main(String[] args) throws IOException {
// 1. 创建FileInputStream对象
FileInputStream fis = new FileInputStream("D:\\aaa\\123.txt");
// 2. 调用FileInputStream中的方法read,读取文件
/*
int len = fis.read();
System.out.println(len);
*/
/*
布尔表达式(len = fis.read()) != -1)
1. fis.read():读取一个字节
2. len = fis.read():把读取的字节赋值给变量len
3. (len = fis.read()) != -1):判断变量len是否不等于-1
错误写法:
while (fis.read() != -1) { // 读取
System.out.println(fis.read());
}
*/
int len = 0; // 记录读取到的字节
while ((len = fis.read()) != -1) {
System.out.println((char) len);
}
// 3. 释放资源
fis.close();
}
}
明确两件事情:
String类的构造方法
import java.io.FileInputStream;
import java.io.IOException;
public class Demo05FileInputStream {
public static void main(String[] args) throws IOException {
// 创建FileInputStream对象,构造方法中传递读取的数据源
FileInputStream fis = new FileInputStream("D:\\aaa\\123.txt");
// 创建一个字节数组,用来缓冲一次读取到的字节
byte[] bytes = new byte[1024];
// 调用FileInputStream中的方法,read读取数据,参数中传递bytes
/*
int len = fis.read(bytes);
System.out.println("len = " + len); // 2
System.out.println(new String(bytes)); // ab
len = fis.read(bytes);
System.out.println("len = " + len); // 1
System.out.println(new String(bytes)); // cb
len = fis.read(bytes);
System.out.println("len = " + len); // -1
System.out.println(new String(bytes)); // cb
*/
int len = 0; // 记录读取有效字节的个数
while ((len = fis.read(bytes)) != -1) {
System.out.println(new String(bytes, 0, len));
}
// 释放资源
fis.close();
}
}
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
文件复制练习:一读一写
明确:
数据源:
数据的目的地:
文件复制的步骤:
1. 创建一个字节输入流对象,构造方法中绑定要读取的数据源
2. 创建一个字节输出流对象,构造方法中绑定要写入的目的地
3. 使用字节输入流对象中的 read方法读取文件
4. 使用字节输出流对象中的 write方法,把读取到的字节写入到目的地中
5. 释放资源
*/
public class Demo05CopyFile {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("C:\\Users\\孙忠杰\\Pictures\\Saved Pictures\\3.jpeg");
FileOutputStream fos = new FileOutputStream("D:\\3.jpeg");
// 计算文件复制所耗费的时间
long start = System.currentTimeMillis();
// 一次读取一个字节,写入一个字节的方式
/*int len = 0;
while ((len = fis.read()) != -1) {
fos.write(len);
}*/
// 使用字节数组缓冲,一次读取多个字节,写入多个字节的方式
int len = 0;
// 创建字节数组,缓冲一次读取到的多个字节
byte[] bytes = new byte[1024];
while ((len = fis.read(bytes)) != -1) {
fos.write(bytes, 0, len);
}
// 释放资源(先关写的,后关读的;如果写完了,肯定读取完毕了)
fos.close();
fis.close();
long end = System.currentTimeMillis();
System.out.println("文件复制耗费:" + (end - start) + "毫秒");
}
}
当使用字节读取文本文件时,可能会有一个小问题,就是遇到中文字符时,可能不会显示完整的字符,那是因为一个中文可能占用多个字节存储。所以Java提供一些字符流类,以字符为单位读写数据,专门用于处理文本文件。
共性的成员方法:
FileReader构造方法的作用
字符输入流的使用步骤:
String类中的构造方法:
import java.io.FileReader;
import java.io.IOException;
public class Demo01Reader {
public static void main(String[] args) throws IOException {
// 1. 创建FileReader对象,绑定要读取的数据源
FileReader fr = new FileReader("D:\\aaa\\123.txt");
// 2. 调用FileReader中的方法 read,读取数据
// 一次读取一个字符
/*
int len = 0; // 记录读取到的字符
while ((len = fr.read()) != -1) {
System.out.println((char)len);
}
*/
// 一次读取多个字符
char[] cs = new char[1024]; // 存储一次读取的多个字符
int len = 0; // 记录读取的有效字符个数
while ((len = fr.read(cs)) != -1) {
System.out.println(new String(cs, 0, len));
}
}
}
共性的成员方法:
构造方法的作用:
字符输出流的使用步骤(重点):
import java.io.FileWriter;
import java.io.IOException;
/*
FileWriter的使用步骤:
*/
public class Demo01Writer {
public static void main(String[] args) throws IOException {
// 1. 创建FileWriter对象,构造方法中绑定要写入数据的目的地
FileWriter fw = new FileWriter("D:\\ideaproject\\itcast-code\\a.txt");
// 2. 调用FileWriter中的方法,writer,将数据写入到内存缓冲区中(字符转换为字节的过程)
fw.write(97);
// 3. 调用FileWriter中的方法,flush,将内存缓冲区中的内容刷新到文件中
fw.flush();
// 4. 释放资源(会先把内存缓冲区中的数据刷新到文件中)
fw.close();
}
}
flush方法和close方法的区别:
import java.io.FileWriter;
import java.io.IOException;
/*
FileWriter中 flush方法和 close方法的区别:
*/
public class DemoFlushAndClose {
public static void main(String[] args) throws IOException {
// 创建字符输出流对象,构造方法中绑定写入数据的目的地
FileWriter fw = new FileWriter("D:\\ideaproject\\itcast-code\\b.txt");
// 调用FileWriter中的方法 writer,将数据写入到内存缓冲区中
fw.write(97);
// 调用flush方法,刷新内存缓冲区
fw.flush();
// 继续写入数据
fw.write(48);
// 关闭流对象
fw.close();
// fw.write(65); // Stream closed
}
}
import java.io.FileWriter;
import java.io.IOException;
/*
字符输出流写数据的其他方法:
1. void writer(char[] cbuf)
2. void writer(char[] cbuf, int off, int len)
3. void writer(String str)
4. void writer(String str, int off, int len)
*/
public class Demo02Writer {
public static void main(String[] args) throws IOException {
// 创建字符输出流对象
FileWriter fw = new FileWriter("D:\\ideaproject\\itcast-code\\b.txt");
// 创建一个字符数组
char[] cs = new char[]{'a', 'b', 'c', 'd', 'e'};
// void writer(char[] cbuf)
fw.write(cs);
// void writer(char[] cbuf, int off, int len)
// 写字符数组的一部分
fw.write(cs, 1, 2);
// void writer(String str)
fw.write("传智播客");
// void writer(String str, int off, int len)
fw.write("黑马程序员", 2, 3);
// 释放资源
fw.close();
}
}
续写(追加写):使用两个参数的构造方法
换行:换行符号
\r\n
\n
\r
当我们单纯读 或者 写文本文件时,使用字符流,其他情况使用字节流。
try {
可能会出现异常的代码
} catch (异常类型 变量名称) {
异常的处理逻辑
} finally {
一定会执行的代码
(资源释放)
}
import java.io.FileWriter;
import java.io.IOException;
/*
在jdk1.7之前,使用 try cathc finally 处理异常
*/
public class DemoTryCatchFinally {
public static void main(String[] args) {
/*
提高变量 fw 的作用域,让finally可以使用
【局部变量在定义的时候,可以没有值,但是使用的时候必须有值】
new FileWriter("w:\\ideaproject\\itcast-code\\b.txt", true);
执行失败,fw没有值,fw.close 会报错
*/
FileWriter fw = null;
try {
fw = new FileWriter("w:\\ideaproject\\itcast-code\\b.txt", true);
fw.write("hello java");
} catch (IOException e) {
System.out.println(e);
} finally {
// 创建对象失败,fw的给定值为null,null是不能调用方法的,
// 会抛出NullPointerException,需要增加一个判断,不是null,把资源释放
if (fw != null) {
try {
// fw.close方法声明抛出了IOException异常,所以我们要处理这个异常对象,要么throws,要么try catch
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
在try的后边可以增加一个(),在括号中可以定义流对象,那么这个流对象的作用域就在 try中有效,try中的代码执行完毕,会自动把流对象释放,不用写 finally
try (定义流对象;定义流对象...) {
可能会产生异常的代码
} catch (异常类型 变量名称) {
异常的处理逻辑
}
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
JDK 1.7 的新特性
*/
public class DemoJDK7 {
public static void main(String[] args) {
// 流对象的定义
// 可能会产生异常的代码
try (FileInputStream fis = new FileInputStream("C:\\Users\\孙忠杰\\Pictures\\Saved Pictures\\3.jpeg");
FileOutputStream fos = new FileOutputStream("D:\\3.jpeg");) {
// 一次读取一个字节,写入一个字节的方式
int len = 0;
while ((len = fis.read()) != -1) {
fos.write(len);
}
} catch(IOException e){
// 异常的处理逻辑
System.out.println(e);
}
}
}
try的前边可以定义流对象,在try后边的()中可以直接引入流对象的名称(变量名),在try代码执行完毕之后,流对象也可以自动释放掉,不用写finally
A a = new A();
B b = new B();
try (a;b) {
// 可能产生异常的代码
} catch (异常类型 变量名称) {
// 异常的处理逻辑
}
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
JDK9新特性
try的前边可以定义流对象
在try后边的()中可以直接引入流对象的名称(变量名)
在try代码执行完毕之后,流对象也可以自动释放掉,不用写finally
格式:
A a = new A();
B b = new B();
try (a;b) {
// 可能产生异常的代码
} catch (异常类型 变量名称) {
// 异常的处理逻辑
}
*/
public class DemoJDK9 {
public static void main(String[] args) throws FileNotFoundException {
// 1. 创建输入流对象,构造方法中绑定读取数据的目的地
FileInputStream fis = new FileInputStream("D:\\3.jpeg");
// 2. 创建输出流对象,构造方法中绑定写入数据的目的地
FileOutputStream fos = new FileOutputStream("d:\\aaa\\3.jpeg");
// 引入流对象
try (fis; fos) {
// 定义一个字节数组,用来缓冲数据
byte[] bytes = new byte[1024];
// 记录读取字节的有效个数
int len = 0;
while ((len = fis.read(bytes)) != -1) {
fos.write(bytes, 0, len);
}
} catch (IOException e) {
System.out.println(e);
}
}
}
java.util.Properties
继承于Hashtable
,用来表示一个持久的属性集。它使用键值结构存储数据,每个键及其对应的值都是一个字符串,该类也被许多Java类使用,比如获取系统属性的时,System.getProperties()
方法返回的就是一个Properties
对象。
public Properties()
:创建一个空的属性列表<String>
stringPropertyNames():返回此属性列表中的键集,其中该键及其对应值是字符串,此方法相当于Map集合中的keySet方法import java.util.Properties;
import java.util.Set;
public class Demo01Properties {
public static void main(String[] args) {
// 创建Properties集合对象
Properties prop = new Properties();
// 使用 setProperty往集合中添加元素
prop.setProperty("赵丽颖", "168");
prop.setProperty("迪丽热巴", "165");
prop.setProperty("马儿扎哈", "170");
// 使用stringPropertiesNames 把Properties集合中的键取出,存储到一个Set集合中
Set<String> set = prop.stringPropertyNames();
// 遍历Set集合,取出Properties集合中的每一个键
for (String key : set) {
String value = prop.getProperty(key);
System.out.println(key + " = " + value);
}
}
}
使用步骤:
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
public class Demo02Properties {
public static void main(String[] args) throws IOException {
// 创建Properties集合对象
Properties prop = new Properties();
// 使用 setProperty往集合中添加元素
prop.setProperty("赵丽颖", "168");
prop.setProperty("迪丽热巴", "165");
prop.setProperty("马儿扎哈", "170");
/*
// 创建字符输出流对象,构造方法中绑定要输出的目的地
FileWriter fw = new FileWriter("D:\\ideaproject\\itcast-code\\prop.txt");
// 使用Properties中的方法,store,临时数据 --> 硬盘
prop.store(fw, "save data");
// 释放资源
fw.close();
*/
// 使用字节输出流输出中文,出现乱码
prop.store(new FileOutputStream("D:\\ideaproject\\itcast-code\\a.txt"), "");
}
}
使用步骤:
注意事项:
- 存储键值对的文件中,键与值的默认连接符号可以使用=, 空格(其他符号)
- 存储键值对的文件中,可以使用#进行注释,被注释的键值对不会再被读取.
- 存储键值对的文件中,键与值默认都是字符串,不用再加引号.
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;
public class Demo03Load {
public static void main(String[] args) throws IOException {
// 创建Properties对象
Properties prop = new Properties();
// 调用 load方法,读取硬盘中的数据
prop.load(new FileReader("D:\\ideaproject\\itcast-code\\prop.txt"));
// 遍历集合
Set<String> set = prop.stringPropertyNames();
for (String key : set) {
String value = prop.getProperty(key);
System.out.println(key + "=" + value);
}
}
}
标签:ide 长度 ref 的区别 img unicode rgs keyset 构造
原文地址:https://www.cnblogs.com/blog-S/p/11481816.html