java学习之旅（day.15）
IO框架
I:input
O：output
流：内存与存储设备间传输数据的通道
数据借助流进行传输
流的分类
- 按流向分：
- 输入流：将存储设备中的内容读入到内存中（程序运行）
- 输出流：将内存中的内容写入到存储设备中（程序运行结果保存）
- 按单位分：
- 字节流：以字节为单位，可以读写所有数据
- 字符流：以字符为单位，只能读写文本数据
- 按功能分
- 节点流：具有实际传输数据的读写功能
- 过滤流：在节点流的基础之上增强功能
===================================================
字节流的使用：
字节流的父类（抽象类）
- 字节输入流（InputStream）：此抽象类是表示字节输入流的所有类的超类
- 字节输出流（OutputStream）：此抽象类是表示字节输出流的所有类的超类
字节流抽象类的两个子类
FileInputStream：用来读取文件的字节流
public int read(byte[] b) 从流中读取多个字节，将读到内容存入b数组，返回实际读到的字节数，如果达到文件的尾部，则返回-1
FileOutputStream：用来写入文件的字节流
public void write（byte[] b） 一次写多个字节，将b数组中所有字节，写入输出流
package com.zhang.IO;
import java.io.FileInputStream;
import com.sun.openpisces.TransformingPathConsumer2D.FilterSet;
//FileInputStream的使用
//文件字节输入流
public class Demo01 {
public static void main(String[] args) throws Exception {
//创建文件字节输入流FileInputStream,并指定文件路径
FileInputStream fis=new FileInputStream("e:\\无脑学习\\aaa.txt");//建的文件路径 这个文件可能有，也可能没有，所以报错，需抛出异常
//读取文件fis.read 该方法只能返回一个字节，要想全读出来，来个f循环
//读取完毕返回的是-1
/* int data=0;
while((data=fis.read())!=-1){//等于-1时说明读完了，-1自己取API看
System.out.println(data);//不加char的话队出来时ASCIII码值97 98 99 100 101 102 103
System.out.println((char)data);//a b c d e f g
*/
//也可一次读多个字节
//创建一个数组
//byte[] buf=new byte[3];//数组长度为3
//int count =fis.read(buf);//返回的是实际读取的个数
//System.out.println(new String(buf));//abc newStrimg 变成字符串
//System.out.println(count);//3
//int count2 =fis.read(buf);//返回的是实际读取的个数
//System.out.println(new String(buf));//def newStrimg 变成字符串
//System.out.println(count2);//3
//int count3 =fis.read(buf);//返回的是实际读取的个数
//System.out.println(new String(buf,0,count3));//g newStrimg 变成字符串
//System.out.println(count3);//1
//这样更麻烦了
//用循环
//创建一个buff数组
byte[] buff=new byte[3];//存储所读取的数据
int count4=0;
while((count4=fis.read(buff))!=-1){
System.out.print(new String(buff,0,count4));//abc def g
}
//}
//关闭
fis.close();
System.out.println("执行完毕");
}
}
===================================================
package com.zhang.IO;
import java.io.FileOutputStream;
import java.nio.charset.StandardCharsets;
//文件字节输出流FileOuputString
public class Demo02 {
public static void main(String[] args) throws Exception{
//创建字节输出流对象,并指定文件路径
FileOutputStream fos=new FileOutputStream("e:\\无脑学习\\bbb,txt");//若后加个true就不会覆盖之前的了，即：("e:\\无脑学习\\bbb,txt"，true)
//写入文件
fos.write(97);
fos.write('b');
fos.write('c');
//太麻烦
String string="helloworld";
fos.write(string.getBytes());
//关闭
fos.close();
System.out.println("执行完毕");//自己去文件里看
}
}
字节流复制文件
文件复制：硬盘的文件通过输入流读到内存中，再从内存写到到硬盘
package com.zhang.IO;
import java.io.FileInputStream;
import java.io.FileOutputStream;
//使用文件字节流实现文件的复制(文件图片都可以复制)
public class Demo03 {
public static void main(String[] args) throws Exception{
//创建流：创建一个文件字节输入流
FileInputStream fis=new FileInputStream("e:\\无脑学习\\aaa.txt");//这个文件存在
//创建一个文件字节输出流
FileOutputStream fos=new FileOutputStream("e:\\无脑学习\\ccc.txt");//文件不存在
//实现复制：一边读取，一边写入
byte[] buf=new byte[1024];//1k
int count=0;//保存实际读取的字节的个数
while ((count=fis.read(buf))!=-1) {
fos.write(buf,0,count);//若文件大于1k，读写可能出问题，所以有了0，count
}
//关闭
fis.close();
fos.close();
System.out.println("复制完毕");
}
}
字节缓冲流
文件字节流内部不带缓冲，所以这样效率不够高，缓冲流会在使用的过程中创建以恶缓冲区，读数据的时候，如果缓冲区里有，就不用从硬盘上读了，直接从缓冲区哪就可以，这样可以提高效率
缓冲流：BufferedInputStream
提高IO效率，减少磁盘访问次数
相互据存储在缓冲区中，flush是将缓冲区的内容写入文件中，也可以直接close
package com.zhang.IO;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
//使用字节缓冲流读取文件：BufferedInputStream
public class Demo04 {
public static void main(String[] args) throws Exception{
//创建一个BufferedInputSream并实例化
FileInputStream fis=new FileInputStream("e:\\无脑学习\\aaa.txt" );
BufferedInputStream bis=new BufferedInputStream(fis);//实例化缓冲流的时候要传一个节点流，而文件输入流实际上就是一个节点流，所以好药实例化一个fileinputStream
//其实上一行就是上上行的增强版
//读取：这次就不用fis读了，而用bis，因为fis每次都是从硬盘读，而bis是读了放入缓冲区
int data=0;
while ((data=bis.read())!=-1){
System.out.println((char)data);
}
/*
//当然自己也可以创建一个缓冲区
byte[] buf=new byte[1024];
int count=0;
while ((count=bis.read(buf))!=-1){
System.out.println(new String(buf,0,count));
}
*/
//关闭
bis.close();//这里关bis就可以，内部就把fis关了
}
}
=====================================================
package com.zhang.IO;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.nio.charset.StandardCharsets;
public class Demo05 {
public static void main(String[] args) throws Exception{
//创建字节输出缓冲流
FileOutputStream fos=new FileOutputStream("e:\\无脑学习\\ddd.txt");
BufferedOutputStream bos=new BufferedOutputStream(fos);
//写入文件
for (int i = 0; i < 10; i++) {
bos.write("helloworld\n".getBytes());// \n换行
bos.flush();
}
//关闭
bos.close();
}
}
对象流
对象流：ObjectOutputStream
ObjectInputStream
内存中的对象写入到硬盘，再从硬盘中读入重构一个对象，就要用到对象流
- 增强了缓冲区功能
- 增强了8种基本数据类型和字符功能
- 增强了读写对象的功能
readObject():从流中读取一个对象
writeObject():向流中写入一个对象
使用流传输对象的过程称为序列化、反序列化
序列化：将内存中的对象写入流中(文件中)
反序列化：从文件中读取一个对象
package com.zhang.IO.Xuleihua;
import java.io.Serializable;
public class Student implements Serializable {
//serialVersionUID 序列化版本号ID.作用：保证序列化的类和反序列化的类是同一个类（我在运行时没出现老师讲的报错，可能IDEA版本不一样把。所以，下一行可要可不要）
private static final long serialVersionUID=100L;
private String name;
private int age;//如果改为private transient 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 +
'}';
}
}
package com.zhang.IO.Xuleihua;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
//使用ObjectOutputSring实现对象的序列化（写入文件）
//注意事项：
// 1.序列化的类必须要实现Serializable接口
// 2.序列化版本号ID可保证序列化和反序列化的类是同一个类（也没报错呀？）
// 3.序列化类中对象属性要求实现Serializable接口
// 4.使用transient（瞬间的）修饰属性，这个属性不能序列化
// 5.静态属性也不能序列化
// 6.可序列化多个对象：可以一个一个的来，也可以把对象放入集合arraylist中，一次性把两个对象都写入到文件中（借助集合实现)
public class Demo06 {
public static void main(String[] args) throws Exception{
//创建对象流
FileOutputStream fos=new FileOutputStream("e:\\无脑学习\\stu.bin");
ObjectOutputStream oos=new ObjectOutputStream(fos);
//实现序列化（写入操作） 序列化多个
Student zhangsan=new Student("zhangsan",20);
Student zhang=new Student("zhang",25);
oos.writeObject(zhangsan);
oos.writeObject(zhang);
/* 或者Student zhangsan=new Student("zhangsan",20);
Student zhang=new Student("zhang",25);
ArrayList<Student>list=new ArrayList<>();
list.add(zhangsan);
list.add(zhang);
oos.writeObject(list);*/
//关闭
oos.close();
System.out.println("序列化完毕");//如果不在Student类中实现接口（implement Serializable），会报错
}
}
package com.zhang.IO.Xuleihua;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.ArrayList;
//使用ObjectInputStream实现反序列化（把文件读取到内存中，再重新构成类对象）
public class Demo07 {
public static void main(String[] args) throws Exception{
FileInputStream fis=new FileInputStream("e:\\无脑学习\\stu.bin");
ObjectInputStream ois=new ObjectInputStream(fis);
//读取文件（反序列化）
Student s =(Student)ois.readObject();//该方法的返回值是object类型，强转为student
Student s2 =(Student)ois.readObject();//该方法的返回值是object类型，强转为student
/* 或者ArrayList<Student>list=(ArrayList<Student>)ois.readObject();*/
//关闭
ois.close();
System.out.println("执行完毕");
System.out.println(s.toString());
System.out.println(s2.toString());
/* System.out.println(list.toString());*/
}
}
常见的字符编码
- ISO-8859-1 收录除ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号。采用一个字节来表示一个字符
- UTF-8 针对Unicode码表的可变长度字符编码 采用1个、2个或3个字节来表示一个字符
- GB2312 简体中文 采用1个或2个字节来表示一个字符
- GBK 简体中文、扩充（GB2312的升级版， 采用1个或2个字节来表示一个字符）
- BIG5 台湾，繁体中文
当编码与解码方式不一致时，文件会出现乱码
字符流抽象类
package com.zhang.IO;
import java.io.FileInputStream;
public class Demo08 {
public static void main(String[] args) throws Exception{
//创建FileInputStream读取文件 此处的hello.txt文件中若有汉字会处处乱码
//文件中的三个字节表示一个汉字，而文件字节流是一个字节一个字节读的，把汉字拆成一个字节一个字节的了，因此汉字会出现乱码
//另外，想看文件是以什么形式编码的，可以点另存为就能看到
//此时字节流不适合，因此要用字符流
FileInputStream fis=new FileInputStream("E:\\无脑学习\\hello.txt");
//读取
int data=0;
while ((data=fis.read())!=-1){
System.out.println((char)data);
}
//关闭
fis.close();
}
}
字符流的父类（抽象类）
Reader：字符输入流
- public int read(){} 读取1个字符
- public int read(char[] c){} 读取多个字符,读到char数组中
- public int read(char[] b, int off, int len){} 读取多个字符
Writer：字符输出流
- public void write(int n){} 写入1个字符
- public void write(String str){} 写入1个字符串
- public void write(char[] c){} 写入1个字符数组
文件字符流（FileReader,Filewriter）的使用
- FileReader：
public int read（char[] c） 从字符流中读取多个字符，将读到的内容存入c数组，返回实际读到的字符数；如果达到文件的尾部，则返回-1
- FileWriter：
public void write（String str） 一次写多个字符，将b数组中所有字符写入输出流
package com.zhang.IO;
import java.io.FileReader;
import java.sql.SQLOutput;
//使用FileReader读取文件
public class Demo09 {
public static void main(String[] args) throws Exception{
//创建FileReader 文件字符输入流
FileReader fr=new FileReader("E:\\无脑学习\\hello.txt");
//读取：有两种方式
//读取单个字符的方式
/* int data=0;
while ((data=fr.read())!=-1){//读取的不是字节，而实一个字符
System.out.println((char)data);
}*/
//或者：创建一个字符缓冲区
char[] buf=new char[1024];//1024改为2的话，读两次
int count=0;
while ((count=fr.read(buf))!=-1){
System.out.println(new String(buf,0,count));
}
//关闭
fr.close();
}
}
======================================================
package com.zhang.IO;
import java.io.FileWriter;
//使用FileWriter写入文件
public class Demo10 {
public static void main(String[] args) throws Exception{
//创建FileWriter对象
FileWriter fw=new FileWriter("e:\\无脑学习\\write.txt");
//写入
for (int i = 0; i < 10; i++) {
fw.write("java好难学呀\r\n");// \r\n换行
fw.flush();
}
//关闭
fw.close();
System.out.println("执行完毕");
}
}
字符流复制文件
使用FileReader和FileWriter复制文件（注意：只能复制文本文件）
package com.zhang.IO;
import java.io.FileReader;
import java.io.FileWriter;
//使用FileReader和FileWriter复制文件（注意：只能复制文本文件(有字符编码的)）
public class Demo11 {
public static void main(String[] args) throws Exception{
//还是一边读，一边写
//创建FileWriter和FileReader，并实例化
FileReader fr=new FileReader("e:\\无脑学习\\write.txt");//读取要复制的文件的位置
FileWriter fw=new FileWriter("e:\\无脑学习\\write2.txt");//复制后文件存放的位置
//读写
int data=0;
while((data=fr.read())!=-1){
fw.write(data);
fw.flush();
}
//关闭
fr.close();
fw.close();
System.out.println("复制完毕");
}
}
字符缓冲流
缓冲流：BufferedReader/BufferedWriter
- 高效读写
- 支持输入换行符
- 可一次写一行，读一行
BufferedReader：从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取
read() 读取单个字符
read(char[] cbuf, int off,int,len)将字符读入数组的某一部分
readLine() 读取一个文本行
BufferedWriter：将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入
newLine() 写入一个行分隔符
package com.zhang.IO;
import java.io.BufferedReader;
import java.io.FileReader;
//使用字符缓冲流读取文件：BufferedReader
public class Demo12 {
public static void main(String[] args) throws Exception{
//创建缓冲流
FileReader fr=new FileReader("e:\\无脑学习\\write.txt");
BufferedReader br=new BufferedReader(fr);
//读取(有2中方式)
/*//方式一
//创建一个缓冲区
char[] buf=new char[1024];
int count=0;
while ((count=br.read(buf))!=-1){
System.out.println(new String(buf,0,count));
}*/
//方式二：一行一行的读
String line=null;
while ((line=br.readLine())!=null){
System.out.println(line);
}
//关闭
br.close();
}
}
======================================================
package com.zhang.IO;
import java.io.BufferedWriter;
import java.io.FileWriter;
////使用字符缓冲流写入文件：BufferedWriter
public class Demo13 {
public static void main(String[] args) throws Exception{
//创建BufferedWriter对象
FileWriter fw=new FileWriter("e:\\无脑学习\\buffer.txt");
BufferedWriter bw=new BufferedWriter(fw);
//写入
for (int i = 0; i < 10; i++) {
bw.write("好好学习，天天向上");
bw.newLine();//写入一个换行符，或者直接加\r\n.即：bw.write("好好学习，天天向上\r\n");
bw.flush();
}
//关闭
bw.close();
System.out.println("执行完毕");
}
}
打印流
PrinteWriter
- 封装了print()/println()方法，支持写入后换行
- 支持数据原样打印
package com.zhang.IO;
import java.io.PrintWriter;
//PrintWriter的使用
public class Demo14 {
public static void main(String[] args) throws Exception{
//创建一个打印流
PrintWriter pw=new PrintWriter("e:\\无脑学习\\print.txt");
//打印(数据打印到相应的文件中)
pw.println(97);
pw.println(true);
pw.println('a');
pw.println(3.14);
//关闭
pw.close();
System.out.println("执行完毕");
}
}
转换流
转换流也叫桥转换流：InputStreamReader/OutputStreamWriter
内存当中的字符和硬盘中的字节的相互转换
- 可将字节流转换为字符流
- 可设置字符的编码方式
InputStreamReader：字节流通向字符流的桥梁
OutputStreamWriter：字符流通向字节流的桥梁
package com.zhang.IO;
import java.io.FileInputStream;
import java.io.InputStreamReader;
//使用InputStreamReader读取文件，还可以指定使用的编码
public class Demo15 {
public static void main(String[] args) throws Exception{
//创建InputStreamReader对象
FileInputStream fis=new FileInputStream("e:\\无脑学习\\write.txt");
InputStreamReader isr=new InputStreamReader(fis,"utf-8");//文件的编码方式和指定的编码方式要一致
//读取文件
int data=0;
while ((data=isr.read())!=-1){
System.out.print((char)data);
}
//关闭
isr.close();
}
}
=====================================================
package com.zhang.IO;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
//使用OutputStreamWriter写入文件，使用指定编码
public class Demo16 {
public static void main(String[] args) throws Exception{
//创建OutputStreamWriter对象
FileOutputStream fos=new FileOutputStream("e:\\无脑学习\\info.txt");
OutputStreamWriter osw=new OutputStreamWriter(fos,"gbk");
//写入
for (int i = 0; i < 10; i++) {
osw.write("java难\r\n");
osw.flush();
}
osw.close();
System.out.println("执行成功");
}
}
文件类
package com.zhang.IO;
import java.io.File;
import java.util.Date;
//File类的使用
//1.打印分隔符
//2.文件操作
//3.文件夹操作
public class Demo17 {
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 {
//2.1创建文件
// 创建文件之前要创建一个file对象
File file = new File("e:\\无脑学习\\file.txt");//现在在电脑上还不存在这个文件，这只是个文件对象
System.out.println(file.toString());//没啥用
//创建文件:调用createNewFile()方法
if (!file.exists()) {//看要建的文件是否存在
boolean b = file.createNewFile();//如果true表示创建成功，false失败
System.out.println("创建的结果：" + b);
}
//2.2删除文件
//2.2.1直接删除
//用file.delete();
//System.out.println(file.delete());//返回值为true（删除成功）或false（删除失败）
//2.2.2使用JVM退出时删除文件,调用file.deleteOnExit();
// file.deleteOnExit();
// Thread.sleep(5000);//休眠5秒，为了方便看结果（删除时有个间隔差），可不管
//2.3获取文件信息
System.out.println("获取文件的绝对路径：" + file.getAbsolutePath());//获取文件的绝对路径：e:\无脑学习\file.txt
System.out.println("获取路径" + file.getPath());//获取路径e:\无脑学习\file.txt 你写的什么路径就是什么路径
System.out.println("获取文件名称：" + file.getName());//获取文件名称：file.txt
System.out.println("获取父目录" + file.getParent());//获取父目录e:\无脑学习
System.out.println("获取文件的长度（大小）" + file.length());//获取文件的长度（大小）15
System.out.println("文件的创建时间" + file.lastModified());//文件的创建时间1610969123143 lastModified()的返回值类型为long，可以用new Date转成Date类型
System.out.println("文件的创建时间" + new Date(file.lastModified()).toLocaleString());//文件的创建时间2021-1-18 19:25:23
//2.4判断
System.out.println("是否可写" + file.canWrite());//判断这个文件能不能写,返回值为true（可写）或false（不可写）
System.out.println("是否是文件" + file.isFile());//返回值为true（是文件）或false（不是文件）
System.out.println("是否是隐藏文件" + file.isHidden());//返回值为true（是隐藏文件）或false（不是隐藏文件）
}
//3.文件夹操作
public static void directoryOpe () throws Exception{
//3.1创建文件夹
//先得创建一个文件夹对象
File dir = new File("e:\\无脑学习\\a\\b\\c");//还是没有，这只是个对象
System.out.println(dir.toString());//e:\无脑学习\a\b\c
//此时电脑上还没有这个文件，接下来创建，创建之前要判断下文件夹存不存在
if(!dir.exists()){
//要调用方法:dir.mkdir() 只能创建单级目录
// dir.mkdirs() 创建多继目录，返回值都为true或false
System.out.println("创建结果："+dir.mkdirs());
}
//3.2删除文件夹
//3.2.1直接删除 dir.delete() 返回值为true或false
//System.out.println("删除结果："+dir.delete());//这个删除并不是把刚建的三层文件夹都删除，而是只删除最里层的文件夹c,而且必须是空目录才行（文件夹c内为空）
//3.2.2使用JVM删除
//调用deleteOnExit()方法
//dir.deleteOnExit();
//Thread.sleep(5000);
//3.3获取文件夹信息
System.out.println("获取文件夹的绝对路径："+dir.getAbsolutePath());//获取文件夹的绝对路径：e:\无脑学习\a\b\c
System.out.println("获取路径：" +dir.getPath());// 你写的什么路径就是什么路径 e:\无脑学习\a\b\c
System.out.println("获取文件夹名称：" +dir.getName());//获取文件夹名称（只能获取到最里层的文件夹名称） c
System.out.println("获取父目录" + dir.getParent());//获取父目录e:\无脑学习\a\b
System.out.println("文件夹的创建时间" + new Date(dir.lastModified()).toLocaleString());//文件夹的创建时间2021-1-18 20:49:46
//3.4判断
System.out.println("是否是文件夹" + dir.isFile());//返回值为true（是文件夹）或false（不是文件夹）
System.out.println("是否是隐藏文件夹" + dir.isHidden());//返回值为true（是隐藏文件夹）或false（不是隐藏文件夹）
//3.5遍历文件夹：获取文件夹中的内容
File dir2=new File("e:\\无脑学习");
String[] files =dir2.list();//返回值为字符串类型的一个数组
System.out.println("======================");
for (String string:files) {
System.out.println(string);//把文件和文件夹都能遍历出来
}
//FileFilter接口的使用
File[] files2=dir2.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
if (pathname.getName().endsWith(".txt")) {//过滤出末尾为.txt的文件
return true;
}
return false;
}
});
for (File file:files2) {
System.out.println(file.getName());
}
}
}
FileFilter 文件过滤器
public interface FileFilter
该接口中包含一个accept()方法:
boolean accept(File pathname)
当调用File类中的listFiles（）方法时，支持传入FileFilter接口接口实现类，对获取的文件进行过滤，只有满足条件的文件才可出现在listFiles（）的返回值中
实例见上面的程序
递归遍历和删除
package com.zhang.IO;
import java.io.File;
//递归遍历文件夹
//递归删除文件夹
public class Demo18 {
public static void main(String[] args) {
listDir(new File("e:\\myfiles"));
deleteDir(new File("e:\\myfiles"));
}
//来个方法
//递归遍历文件夹
public static void listDir(File dir){
File[] files=dir.listFiles();//该方法的返回值为file数组
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());
}
}
}
}
//递归删除文件夹
public static void deleteDir(File dir){
File[] files=dir.listFiles();//得到myfiles文件夹下的所有文件和子文件夹
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(属性集合)
特点：
- 存储属性名和属性值
- 属性名和属性值都是字符串类型
- 没有泛型
- 和流有关
package com.zhang.IO;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.Properties;
import java.util.Set;
//Properties集合的使用
public class Demo19 {
public static void main(String[] args) throws Exception{
//1.创建集合
Properties properties=new Properties();
//2.向集合中添加数据
properties.setProperty("username","zhangsan");
properties.setProperty("age","20");
System.out.println(properties.toString());
//3.遍历
//3.1keyset properties.keyset
//3.2entryset
//3.3stringPropertyNames() 返回值是一个set集合
Set<String>pronames=properties.stringPropertyNames();
for (String pro:pronames) {
System.out.println(pro+"====="+properties.getProperty(pro));
}
//4.和流有关的方法
//4.1 列表 list方法
//PrintWriter pw=new PrintWriter("e:\\无脑学习\\print1.txt");//打印位置
//properties.list(pw);//要给一个打印流，所以去实例化一个打印流
//pw.close();
//4.2保存 store方法
FileOutputStream fos=new FileOutputStream("e:\\无脑学习\\store.properties");
properties.store(fos,"注释");
fos.close();
//4.3 加载 load方法
//创建一个新的集合
Properties properties2=new Properties();
//把数据加载到里面
FileInputStream fis=new FileInputStream("e:\\无脑学习\\store.properties");
properties2.load(fis);//需要传一个流
fis.close();
System.out.println(properties2.toString());
}
}
java学习之旅（day.15）的更多相关文章
- Java学习之旅开篇：运行机制及环境搭建
在写这篇博客之前,我想对自己进行简单概括:我从事软件开发工作已经三年多了,并且一直在从事.NET相关项目的开发.为什么突然间想学习Java呢?有以下几个原因: 1. 开发程序三年多来,已经对.NET相 ...
- Java学习之旅基础知识篇：面向对象之封装、继承及多态
Java是一种面向对象设计的高级语言,支持继承.封装和多态三大基本特征,首先我们从面向对象两大概念:类和对象(也称为实例)谈起.来看看最基本的类定义语法: /*命名规则: *类名(首字母大写,多个单词 ...
- Java学习之旅基础知识篇：数组及引用类型内存分配
在上一篇中,我们已经了解了数组,它是一种引用类型,本篇将详细介绍数组的内存分配等知识点.数组用来存储同一种数据类型的数据,一旦初始化完成,即所占的空间就已固定下来,即使某个元素被清空,但其所在空间仍然 ...
- Java学习之旅基础知识篇：数据类型及流程控制
经过开篇对Java运行机制及相关环境搭建,本篇主要讨论Java程序开发的基础知识点,我简单的梳理一下.在讲解数据类型之前,我顺便提及一下Java注释:单行注释.多行注释以及文档注释,这里重点强调文档注 ...
- 第一篇，java学习之旅
在java的这座殿堂中,我才刚刚推开了大门,就像是在岔路口找到了一条,走向前进java大门的路. 下面是一些java算法的问题 第一题: package project.model; import j ...
- Java学习之旅（一）：探索extends
鄙人为兴趣爱好,0基础入门学习Java,有些心得想法,记录于此,与君分享. 然毕竟新手,学识尚浅,错误之处,希望多多指正批评,也是对我最大的帮助! 前言:本篇文章,主要讨论在子类继承父类之后,一些继承 ...
- 我的java学习之旅--一些基础
(因为我粗略学过C,C++,Python,了解过他们的一些语法,所以为了使得java的入门更为顺畅,便会忽略一些和C语法相类似的地方,着重点明一些java自己的特色之处.也减轻一下自己写文字的负担.) ...
- Java学习之旅（二）：生病的狗1(逻辑推导)
前言:本篇文章属于个人笔记,例化了一些代码,不知是否合理,请指教. 中午看到一位同学的面试题,觉得很烧脑,烧脑不能一个人烧,要大家一起烧. 村子中有50个人,每人有一条狗.在这50条狗中有病狗(这种病 ...
- java学习之旅
jar文件其实就是一个压缩包,里面包含很多class文件(一个class文件是一个类的字节码).方便在网络上传输.可以规定版本号,更容易进行版本控制. var只能在方法内使用,不能用于定义成员变量. ...
- ROS2学习之旅（15）——编写简单的服务和客户节点（C++）
当节点使用服务进行通信时,发送数据请求的节点称为客户节点,响应请求的节点称为服务节点.请求和响应的结构由.srv文件决定. 本文的例子是一个简单的整数加法系统:一个节点请求两个整数的和,另一个节点响应 ...
随机推荐
- 内存分析利器之UMDH
近两周投入分析产品的内存泄漏问题. 测试团队反馈产品在安卓平台运行时,随用户操作,应用占用的内存出现上涨的趋势,停止操作并等待一段时间之后,应用占用的内存没有下降,怀疑存在内存泄漏问题. 结合复现的情 ...
- 小师妹学JavaIO之:文件写入那些事
目录 简介 字符输出和字节输出 格式化输出 输出其他对象 在特定的位置写入 给文件加锁 总结 简介 小师妹又对F师兄提了一大堆奇奇怪怪的需求,要格式化输出,要特定的编码输出,要自己定位输出,什么?还要 ...
- 搭载KaihongOS的工业平板、机器人、无人机等产品通过3.2版本兼容性测评，持续繁荣OpenHarmony生态
近日,搭载深圳开鸿数字产业发展有限公司(简称"深开鸿")KaihongOS 软件发行版的工业平板.机器人.无人机等商用产品均通过 OpenAtom OpenHarmony(以下简称 ...
- 面试必备HashMap源码解析
Map的实现有很多种,而HashMap算是最经典的实现之一了吧,在平时的使用中,绝大部分的使用也都是HashMap,我记得刚入行那会,脑子里对Map的使用就是Map map = new HashMap ...
- 记录一个小问题，django+Apache+win7，启动Apache后，打开网页，一直转圈圈，停不下来
做了一个小网站,主要是为了简单工作,只需要公司局域网访问,所以部署在自己的台式机上. 网站是用django 3.x版本开发的,电脑是win7系统,所以是用的Apache部署的 部署的啥问题都没有,检查 ...
- Redis之父萨尔瓦多·桑菲利波又名安蒂雷斯
萨尔瓦多·桑菲利波又名安蒂雷斯 个人博客连接 嗨,我是萨尔瓦多·桑菲利波,也被称为安提雷斯, 一位居住在卡塔尼亚的意大利计算机程序员. 我于7年1977月2020日出生在坎波贝洛迪利卡塔. 2022 ...
- Rome反序列化链分析
环境搭建 <dependencies> <dependency> <groupId>junit</groupId> <artifactId> ...
- 《深入理解Java虚拟机》读书笔记： 虚拟机类加载的时机和过程
虚拟机类加载的时机和过程 一.类加载的时机 类从被加载到虚拟机内存中开始,到卸载出内存为止,它的整个生命周期包括:加载(Loading).验证(Verification).准备(Preparation ...
- 第十三篇：HTML和CSS入门
一.HTML本质以及在WEB程序中的作用 1.一套规则,浏览器认识的规则. 2.开发者: 学习html规则 开发后台程序 - 写html文件(充当模板的作用) - 数据库获取数据,然后替换到html文 ...
- GAN的一些问题
GAN为什么难以训练? 大多深度模型的训练都使用优化算法寻找损失函数比较低的值.优化算法通常是个可靠的"下山"过程.生成对抗神经网络要求双方在博弈的过程中达到势均力敌(均衡).每个 ...