流
- 概念:内存与存储设备之间传输数据的通道
1.流的分类
- 按方向
- 输入流:将存储设备中的内容读入到内存中
- 输出流:将内存中的内容写入存储设备中
- 按单位
- 字节流:以字节为单位,可以读写所有数据
- 字符流:以字符为单位,只能读写文本数据
- 按功能
- 节点流:具有实际传输数据的读写功能
- 过滤流:在节点流得到基础上增强功能
2.字节流
字节流的父类(抽象类):
- InputStream:字节输入流
- OutputStream:字节输出流
3.文件字节流
- FileInputStream:
- public int read(byte[] b)//从流中读取多个字节,将内存存入b数组,返回实际读到的字节数;如果达到文件的尾部,则返回-1。
- FileOutputStream:
- public void write(byte[] b)//一次写多个字节,将b数组中所有字节,写入输出流。
/**
* FileInputStream使用
* 文件字节输入流
*/
public class Demo01 {
public static void main(String[] args) throws Exception{
//1.创建FileInputStream
FileInputStream fileInputStream = new FileInputStream("E:\\aaa.txt");
//2.读取文件
//2.1单个字节读取
// int data = 0;
// while ( (data=fileInputStream.read() )!=(-1) ){
// System.out.println((char) data);
// }
//2.2一次读取多个字节
// byte[] bytes = new byte[4];
// int count = 0;
// while ( ( count=fileInputStream.read(bytes) )!=(-1) ){
// System.out.println(new String(bytes,0,count));
// }
//3.关闭
fileInputStream.close();
System.out.println("close");
}
}
/**
* FileOutputStream
* 文件字节输出流
*/
public class Demo01 {
public static void main(String[] args) throws Exception{
//1.创建文件字节流输出对象
FileOutputStream fileOutputStream = new FileOutputStream("e:\\bbb.txt",true);//append设置为true,为追加
//2.写入文件
// fileOutputStream.write(97);
// fileOutputStream.write('b');
String str = "hellowrold";
fileOutputStream.write(str.getBytes());
//3.关闭
fileOutputStream.close();
System.out.println("执行完成");
}
}
4.字节缓冲流
缓冲流:BufferedInputStream/BufferedOutputStream
提高IO效率,减少访问磁盘的次数;
数据存储在缓冲区中,flush是将缓存区的内容写入文件中,也可以直接close。
/**
*BufferedInputStream
*/
public class Demo01 {
public static void main(String[] args) throws Exception{
//1.创建BufferedInputStream
FileInputStream fis = new FileInputStream("E:\\aaa.txt");
BufferedInputStream bufferedInputStream = new BufferedInputStream(fis);
//2.读取
int data = 0;
while ( (data = bufferedInputStream.read() )!= -1 ){
System.out.println((char)data);
}
// byte[] buf = new byte[1024];
// int count = 0;
// while ( (count = bufferedInputStream.read(buf) )!= -1 ){
// System.out.println( new String(buf,0,count));
// }
//3.关闭
bufferedInputStream.close();
}
}
public class Demo01 {
public static void main(String[] args) throws Exception{
//1.创建字节缓冲输出流
FileOutputStream fos = new FileOutputStream("e:\\bbb.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
//2.写入文件
for (int i = 0; i < 10; i++) {
bos.write("hellowrold\r\n".getBytes());//写入8K缓冲区
bos.flush();//刷新到硬盘
}
//3.关闭(内部调用flush方法)
bos.close();
}
}
5.对象流
对象流:ObjectOutputStream/ObjectInputStream
- 增强了缓冲区功能
- 增强了读写8种基本数据类型和字符串功能
- 增强了读写对象的功能:readObject()从流中读取一个对象
- writeObject(Object obj)向流中写入一个对象
/**
* 学生类
*/
public class Student implements Serializable{
private String name;
private int age;
public Student(){
}
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 "[Name:"+this.name+" Age:"+this.age+"]";
}
}
/**
* 使用ObjectOutputStream实现对象的序列化
* 要求:
* (1)序列化类必须要实现Serializable接口
* (2)序列化类中对象属性要求实现Serializable接口
* (3)序列化版本号ID,保证序列化的类和反序列化的类是同一个类
* (4)使用transient(瞬间的)修饰属性,这个属性就不能序列化
* (5)静态属性不能序列化
* (6)序列化多个对象,可以借助集合实现
*/
public class Demo01 {
public static void main(String[] args) throws Exception{
//1.创建对象流
FileOutputStream out = new FileOutputStream("e:\\stu.bin");
ObjectOutputStream objectOutputStream = new ObjectOutputStream(out);
//2.序列化(写入操作)
Student s1 = new Student("A",20);
Student s2 = new Student("B",21);
ArrayList<Student> list = new ArrayList<Student>();
list.add(s1);
list.add(s2);
objectOutputStream.writeObject(list);
//3.关闭
objectOutputStream.close();
System.out.println("关闭");
}
}
/**
* 使用ObjectInputStream实现反序列化,读取重构
*/
public class Demo02 {
public static void main(String[] args) throws Exception{
//1.创建对象流
FileInputStream fileInputStream = new FileInputStream("e:\\stu.bin");
ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
//2.读取文件(反序列化)
// Student s = (Student) objectInputStream.readObject();
// Student s2 = (Student) objectInputStream.readObject();
ArrayList<Student> list = ( ArrayList<Student> ) objectInputStream.readObject();
//3.关闭
objectInputStream.close();
System.out.println("关闭成功");
System.out.println(list);
//System.out.println(s.toString());
//System.out.println(s2.toString());
}
}
5.字符编码
- ISO-8859-1 收录除ASCII外,还包括西欧、希腊语、泰语等等
- UTF-8:针对Unicode码表的可变长度字符编码
- GB2312:简体中文
- GBK:简体中文、扩充
- BIG5台湾:繁体中文
6.字符流
字符流的父类(抽象类)
- Reader:字符输入流
- public int read
- Writer:字符输出流
- public void write(int n)d
7.文件字符流
- FileReader
- public int read(char[] c)//从流中读取多个字符,将读到内容存入数组,返回实际读到的字符数;如果达到文件的尾部,则返回-1.
- FileWriter
- public void write(String str)//一次写多个字符,将b数组中所有字符,写入输出流。
/**
* 使用FileReader读取文件
*/
public class Demo02 {
public static void main(String[] args) throws Exception{
//1.创建FileReader
FileReader fileReader = new FileReader("e:\\hello.txt");
//2.读取
//2.1单个字符读取
// int data = 0;
// while ((data = fileReader.read())!=-1){
// System.out.println((char)data);
// }
//2.2
char[] buf = new char[1024];
int count = 0;
while ((count = fileReader.read(buf))!=-1){
System.out.println(new String(buf ,0,count));
}
//3.关闭
fileReader.close();
}
}
/**
* 使用FileWrite写入文件
*/
public class Demo03 {
public static void main(String[] args) throws Exception{
//1.创建FileWriter对象
FileWriter fileWriter = new FileWriter("e:\\write.txt");
//2.写入
for (int i = 0; i < 10; i++) {
fileWriter.write("语言\r\n");
fileWriter.flush();//刷新
}
//3.关闭
fileWriter.close();
}
}
/**
* 使用FileReader和FileWriter复制文本文件,不能复制图片或二进制文件
*/
public class Demo04 {
public static void main(String[] args) throws Exception{
//1.创建对象
FileReader fileReader = new FileReader("e:\\write.jpeg");
FileWriter fileWriter = new FileWriter("E:\\copy.jpeg");
//2.读取
//2.1读取单个字符
int data = 0;
while( ( data=fileReader.read() ) !=-1){
fileWriter.write(data);
}
//2.2读取到缓冲区
// int count = 0;
// char[] buf = new char[1024];
// while ( (count = fileReader.read(buf) ) != -1){
// fileWriter.write(new String(buf,0,count));
// }
//3.关闭
fileReader.close();
fileWriter.close();
System.out.println("复制完毕");
}
}
8.字符缓冲流
缓冲流:BufferedReader/BufferedWriter
- 高效读写
- 支持输入换行符
- 可一次写一行、读一行
/**
* 使用BufferedReader读取文件
*/
public class Demo01 {
public static void main(String[] args) throws Exception{
//1.创建BufferedReader
FileReader fileReader = new FileReader("e:\\hello.txt");
BufferedReader bufferedReader = new BufferedReader(fileReader);
//2.读取
//2.1 第一种
// char[] buf = new char[1024];
// int count = 0;
// while ( (count = bufferedReader.read(buf) ) !=-1){
// System.out.println(new String(buf,0,count) );
// }
//2.2 读取一行
String line = null;
while ( (line = bufferedReader.readLine() ) !=null){
System.out.println(line);
}
//3.关闭
bufferedReader.close();
}
}
/**
* 使用BufferedWriter
*/
public class bufferWriter {
public static void main(String[] args) throws Exception{
//1.创建对象
FileWriter fileWriter = new FileWriter("e:\\write.txt");
BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
//2.写入
for (int i = 0; i < 10; i++) {
bufferedWriter.write("好好学习");
bufferedWriter.newLine();//换行
bufferedWriter.flush();
}
//3.关闭
bufferedWriter.close();
System.out.println("执行完毕");
}
}
9.打印流
PrintWriter:
- 封装了print/println方法,支持写入后换行
- 支持数据原样打印
/**
* 使用PrintWriter
*/
public class Demo01 {
public static void main(String[] args) throws Exception{
//1.创建打印流
PrintWriter pw = new PrintWriter("e:\\print.txt");
//2.打印
pw.println(97);
pw.println(true);
pw.println(3.14);
pw.println('a');
pw.println("AS");
//3.关闭
pw.close();
System.out.println("执行完毕");
}
}
10.转换流
桥转换流:InputStreamReader/OutputStreamWriter
- 可将字节流转换为字符流
- 可设置字符的编码方式
/**
* InputStreamReader读取文件,指定使用的编码
*/
public class Demo01 {
public static void main(String[] args) throws Exception{
//1.创建对象
FileInputStream fileInputStream = new FileInputStream("e:\\write.txt");
InputStreamReader iSR = new InputStreamReader(fileInputStream,"gbk");
//2.读取文件
int data = 0;
while ( (data = iSR.read())!=-1){
System.out.print((char)data);
}
//3.关闭
iSR.close();
System.out.println("执行成功");
}
}
/**
* 使用OutputStreamWriter
*/
public class Demo02 {
public static void main(String[] args) throws Exception{
//1.创建对象
FileOutputStream fileOutputStream = new FileOutputStream("e:\\info.txt");
OutputStreamWriter osw = new OutputStreamWriter(fileOutputStream,"utf-8");
//2.写入
for (int i = 0; i < 10; i++) {
osw.write("好好学习\r\n");
osw.flush();
}
//3.关闭
osw.close();
System.out.println("finish");
}
}
11.File类
概念:代表物理盘中的一个文件或者文件夹
方法:
- createNewFile()//创建一个新的空文件
- mkdir()//创建目录
/**
* File类的使用
* (1)分隔符
* (2)文件操作
* (3)文件夹操作
*/
public class Demo01 {
public static void main(String[] args) throws Exception{
// separator();
// fileOpe();
directoryOpe();
}
//(1)分隔符
public static void separator(){
System.out.println("路径分隔符"+ File.pathSeparator);
System.out.println("名称分隔符"+File.separator);
}
//(2)文件操作
public static void fileOpe() throws Exception{
//1.创建文件
File file = new File("e:\\file.txt");
if (!file.exists()){
boolean b = file.createNewFile();
System.out.println("result:"+b);
}
//2.删除文件
//2.1直接删除
//System.out.println("delete:" +file.delete());
//2.2使用JVM退出删除
// file.deleteOnExit();
// Thread.sleep(5000);
//3.获取文件信息
System.out.println("获取文件绝对路径:"+file.getAbsolutePath());
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()).toLocaleString());
//4.判断
System.out.println("是否可写:"+file.canWrite());
System.out.println("是否是文件:"+file.isFile());
System.out.println("是否隐藏:"+file.isHidden());
}
//(3)文件夹操作
public static void directoryOpe() throws Exception{
//1.创建文件夹
File dir = new File("e:\\a\\b\\ccc");
System.out.println(dir);
if ( !dir.exists()){
//dir.mkdir();//只能创建单级目录
System.out.println(dir.mkdirs());//创建多级目录
}
//2.删除
// //2.1直接删除
// System.out.println("delete:"+dir.delete());//只删除最底层的目录(且为空目录)
// //2.2使用JVM删除
// dir.deleteOnExit();
// Thread.sleep(5000);
//3.获取文件夹信息
System.out.println("获取绝对路径:"+dir.getAbsolutePath());
System.out.println("获取路径:"+dir.getPath());
System.out.println("获取名称:"+dir.getName());//获得的最底层的名称
System.out.println("获取父目录:"+dir.getParent());
System.out.println("获取创建时间:"+ new Date(dir.lastModified()).toLocaleString());
//4.判断
System.out.println("是文件夹吗:"+dir.isDirectory());
System.out.println("是隐藏的:"+dir.isHidden());
//5.遍历文件夹
File dir2 = new File("C:\\Users\\LK\\Desktop\\图片");
String[] str = dir2.list();
for (String s:str) {
System.out.println(s);
}
//使用FileFilter
System.out.println("========fileFilter接口使用");
File[] file2 = dir2.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
if (pathname.getName().endsWith(".jpeg"))
return true;
else
return false;
}
});
for (File f:file2) {
System.out.println(f.getName());
}
}
}
FileFilter接口
public interface FileFilter
当调用File类中的listFiles()方法时,支持传入FileFilter接口实现类,对获取文件进行过滤,只有满足条件的文件才可以出现在listFiles()的返回值中。
//使用FileFilter
System.out.println("========fileFilter接口使用");
File[] file2 = dir2.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
if (pathname.getName().endsWith(".jpeg"))
return true;
else
return false;
}
});
for (File f:file2) {
System.out.println(f.getName());
}
/**
* 递归遍历文件夹
*/
public class Demo02 {
public static void main(String[] args) {
File dir = new File("e:\\a");
listDir(dir);
// System.out.println("=======");
// deleteDir(dir);
}
//递归遍历文件夹
public static void listDir(File dir){
File[] f = dir.listFiles();
System.out.println(dir.getAbsolutePath());
if (f!=null && f.length>0){
for (File f1:f) {
if (f1.isDirectory()){
listDir(f1);
}
else{
System.out.println(f1.getAbsolutePath());
}
}
}
}
//递归删除文件夹
public static void deleteDir(File dir){
File[] file = dir.listFiles();
if (file != null && file.length>0){
for (File f:file) {
if (f.isDirectory()){
deleteDir(f);
}
else{
System.out.println(f.getAbsolutePath()+" 删除:"+f.delete());
}
}
}
System.out.println(dir.getAbsolutePath()+"删除:"+dir.delete() );
}
}
12.Properties
Properties:属性集合
特点
- 存储属性名和属性值
- 属性名和属性值都是字符串类型
- 没有泛型
- 和流有关
/**
* Properties集合的使用
*/
public class Demo01 {
public static void main(String[] args) throws Exception{
//1.创建集合
Properties properties = new Properties();
//2.添加数据
properties.setProperty("username","A");
properties.setProperty("age","20");
System.out.println(properties.toString());
//3.遍历
//3.1 keyset
//3.2 entryset
//3.3 stringPropertyNames()
Set<String> set = properties.stringPropertyNames();
for (String str:set) {
System.out.println(str+"==="+properties.getProperty(str));
}
//4.和流有关的方法
// 1.list方法
// PrintWriter pw = new PrintWriter("e:\\print.txt");
// properties.list(pw);
// pw.close();
// // 2.store方法
// FileOutputStream fileOutputSteam = new FileOutputStream("e:\\store.properties");
// properties.store(fileOutputSteam,"注释");
// fileOutputSteam.close();
// 3.load方法
Properties properties1 = new Properties();
FileInputStream fis = new FileInputStream("e:\\store.properties");
properties1.load(fis);
fis.close();
System.out.println(properties1.toString());
}
}