您的位置：首页 > 编程语言 > Java开发

Java基础---IO流

2015-07-16 23:40 501 查看

在流之前这个必须要知道~~!

File类

判断方法

|– exists()判断路径是不是存在

|– isDirectory()判断封装的是不是文件夹,目录

/*
* File类的判断方法
* 返回值都是boolean类型
*/

public class FileDemo {
public static void main(String[] args) {
method_6();
}
/*
* 判断File构造方法中,封装的文件能不能写入
* boolean canWrite()文件可以写入,返回true
*/
public static void method_6(){
//创建File对象,封装路径
File file = new File("c:\\1.txt");
//判断,封装的文件,能不能写入
boolean b = file.canWrite();
System.out.println(b);
}

/*
* 判断File构造方法中,封装的文件能不能读取
* 判断文件能不能读
* boolean canRead()文件可以读取,返回true
*/
public static void method_5(){
//创建File对象,封装路径
File file = new File("c:\\1.txt");
//判断,封装的文件,能不能读取
boolean b = file.canRead();
System.out.println(b);
}

/*
* 判断File构造方法中,封装的文件是不是隐藏属性
* boolean isHidden()如果是隐藏属性返回true
*/
public static void method_4(){
//创建File对象,封装路径
File file = new File("c:\\1.txt");
//判断,文件是不是隐藏属性  isHidden()
boolean b = file.isHidden();
System.out.println(b);
}

/*
* 判断File构造方法中,封装的路径,是不是绝对路径
* boolean isAbsolute()如果是绝对路径返回true
*/
public static void method_3(){
//创建File对象,封装路径
File file = new File("c:\\eclipse");
//判断,路径是不是绝对路径 isAbsolute()
boolean b = file.isAbsolute();
System.out.println(b);
}

/*
* 判断File构造方法中,封装的路径,是不是文件
* boolean isFile()如果是文件返回true
*/
public static void method_2(){
//创建File对象,封装路径
File file = new File("c:\\eclipse");
//判断,路径是不是文件 isFile()
boolean b = file.isFile();
System.out.println(b);
}

/*
* 判断File构造方法中,封装的路径,是不是文件夹
* boolean isDirectory()如果是文件夹返回true
*/
public static void method_1(){
//创建File对象,封装路径
File file = new File("c:\\eclipse");
//判断,路径是不是一个文件夹 isDirectory()
boolean b = file.isDirectory();
System.out.println(b);
}

/*
* 判断File构造方法中,封装的路径,是不是存在
* boolean exists(),路径存在返回true
*/
public static void method(){
//创建File对象,封装路径
File file = new File("C:\\eclipse\\eclipse.ex");
//调用方法exists()判断,路径是不是存在
boolean b = file.exists();
System.out.println(b);
}
}

获取方法

|– getName() 获取路径最后部分名字

|– getParentFile() 获取父路径

|– getAbsoluteFile() 获取绝对路径

/*
* File类中的获取功能
*/

import java.util.*;
import java.text.*;
public class FileDemo1 {
public static void main(String[] args) {
method_5();
}
/*
* 获取File构造方法中,封装的文件的最后修改时间的毫秒值
* long lastModified()
*/
public static void method_5(){
//创建File对象,封装文件
File file = new File("c:\\windows\\RtlExUpd.dll");
//获取文件的最后修改事件,毫秒值 lastModified()
long msecond = file.lastModified();
System.out.println(msecond);
//毫秒值转成日期对象
Date date = new Date(msecond);
DateFormat df = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG);
String str = df.format(date);
System.out.println(str);

}

/*
* 获取File构造方法中,封装的文件的字节数
* long length()
*/
public static void method_4(){
//创建File对象,封装文件
File file = new File("c:\\windows\\RtlExUpd.dll");
//获取文件的字节数 length
long length = file.length();
System.out.println(length);
}

/*
* 获取File构造方法中,封装的路径的绝对路径
* String getAbsolutePath()
*   获取的绝对路径,返回字符串,继续调用String类的方法
* File   getAbsoluteFile()
*   获取的绝对路径,返回File对象,继续调用File方法
*
*   不写绝对路径,默认工厂根目录,绝对路径
*/
public static void method_3(){
//创建File对象,封装一个路径
File file = new File("");
//获取构造方法中,路径的绝对路径,带着盘符
File absolute = file.getAbsoluteFile();
System.out.println(absolute);
}

/*
* 将File构造方法中,封装的路径,变成字符串
*/
public static void method_2(){
//创建File对象,封装路径
File file = new File("C:\\Java\\jre7");
//将路径,变成字符串 getPath()
String path = file.getPath();
System.out.println(path);

path = file.toString();
System.out.println(path);
}

/*
* 获取File构造方法,封装的路径的父路径
* String getParent()
*   返回字符串,获取到结果可以使用String类的方法
* File   getParentFile()
*   返回的是File对象,获取到结果可以使用File类方式
*/
public static void method_1(){
//创建File对象,封装路径
File file = new File("C:\\Java\\jre7");
//调用方法 getParentFile 父路径,返回File对象
File parent = file.getParentFile();
System.out.println(parent);
}

/*
* 获取File构造方法,封装的路径中的名字
* String getName()
* 获取的是路径最后部分的文件名,或者文件夹名
*
*/
public static void method(){
//创建File对象,封装路径
File file = new File("C:\\Java\\jre7\\bin\\server\\jvm.dll");
//获取封装路径名字
String name = file.getName();
System.out.println(name);

}
}

高级获取

|– static listRoots() 获取系统根

|– list() 获取路径下的文件名和文件夹名,返回String数组

|– listFiles() 获取路径下的文件名和文件夹名,返回File数组

|– listFiles()带文件过滤器传递 FileFilter接口实现类

/*
* File类高级获取功能
*/
public class FileDemo2 {
public static void main(String[] args) {
method_3();
}
/*
* 获取指定目录的所有图片
*/
public static void method_3(){
//创建File对象,封装路径 c:
File file = new File("c:\\abc");
File[] files = file.listFiles(new MyFilter());
for(File f : files){
System.out.println(f);
}
}

/*
* 获取File构造方法中,封装的路径下的文件和文件夹
* File[] listFiles()
* 封装目录下的文件和文件夹的全路径
*/
public static void method_2(){
//创建File对象,封装路径 c:
File file = new File("c:");
//调用方法listFiles获取.c目录下的文件和文件夹
File[] files = file.listFiles();
for(File f : files){
System.out.println(f);
}
}

/*
* 获取File构造方法中,封装的路径下的文件和文件夹
* String[] list()
* 封装目录下的文件夹名字,和文件名
*/
public static void method_1(){
//创建File对象,封装路径 c:
File file = new File("c:");
//调用方法list获取.c目录下的文件和文件夹
String[] str = file.list();
for(String s : str){
System.out.println(s);
}
}

/*
* 获取当前系统根
*  static File[]  listRoots()
*/
public static void method(){
//File类,调用静态方法listRoots
File[] files = File.listRoots();
for(File f : files){
System.out.println(f);
}
}
}

———————————————————-

1. 流对象的总和

IO流分类

1 文件分

|– 字节任意文件

|– 字符文本文件

2 流向分

|– 输出流写

|– 输入流读

3 抽象基类
|-- OutputStream       write 写,字节,字节数组
|-- InputStream          read 读,字节,字节数组
字节输出流
OutputStream        字节数组
FileOutputStream  写文件
BufferedOutputStream 提高效率(这个就不写代码了~~!)

/*
*  字节输出流,写文件
*  抽象基类OutputStream write
*  找他的子类,创建子类的对象  FileOutputStream
*  子类的构造方法
*     传递File对象,File对象封装的是文件
*     传递String文件名
*
*  字节流写文件的实现步骤
*    1, 创建字节输出流的子类对象
*    2, 调用父类方法write
*    3, 释放资源
*/

public class FileOutputStreamDemo {
public static void main(String[] args)throws FileNotFoundException,IOException {
//创建FileOutputStream子类对象,传递字符串文件名
//创建子类对象,完成哪些事情
//创建对象在堆里面,调用Windows底层功能,创建文件,如果有就覆盖
//抛出异常
FileOutputStream fos = new FileOutputStream("a.txt");
//调用方法write写数据
//写单个字节
fos.write(97);

//写字节数组
fos.write("\r\nabcd".getBytes());
fos.write("\r\n你\r\n".getBytes());

//写入字节数组一部分
byte[] bytes = {101,102,103,104,105};
fos.write(bytes, 0, 3);
//关闭资源
fos.close();
}
}

字节输入流
InputStream           字节数组
FileInputStream     读取文件
BufferedInputStream 提高效率(这个就不写代码了~~!)

package cn.itcast.iostream;
/*
* 字节输入流读取 文件
*  抽象基类 InputStream
*  创建子类的对象
*    FileInputStream
*  构造方法
*    传递File类型对象  , File类对象封装的是文件
*    传递字符串的文件名
*
*  int read() 读取单个字节
*    读取文件的步骤
*      1. 创建FileInputStream对象,传递字符串文件名
*      2. 调用父类方法read读取
*      3. 输出读取到的结果
*      4. 关闭资源
*
*  read 方法 每次调用方法,自动向后读取一个字节
*  读取到文件结尾的时候,返回-1
*/
import java.io.*;
public class FileInputStreamDemo {
public static void main(String[] args) throws IOException{
//创建FileInputStream对象,传递字符串的文件名
FileInputStream fis = new FileInputStream("c:\\a.txt");
//调用父类方法read读取单个字节
//定义变量,接收read方法返回值
int len = 0 ;
//利用循环进行读取,循环结束条件 read()返回-1的时候
while( (len=fis.read()) !=-1){
System.out.print((char)len);
}

/*  len = fis.read();
System.out.println(len);

len = fis.read();
System.out.println(len);

len = fis.read();
System.out.println(len);

len = fis.read();
System.out.println(len);

len = fis.read();
System.out.println(len);*/
//关闭资源
fis.close();
}
}

package cn.itcast.iostream;
/*
*  字节输入流 读取文件
*  FileInputStream 方法read()
*  传递字节数组
*    int read(byte[])
*  数组的作用,int返回值表示什么意思
*  读取的字节,存储到数组中
*  int返回值 每次存储到数组中的有效字节个数
*
*  数组缓冲技术,提高流的读取效率
*/
import java.io.*;
public class FileInputStreamDemo1 {
public static void main(String[] args) throws IOException{
FileInputStream fis = new FileInputStream("c:\\a.txt");
//读取文件,read方法,传递字节数组
byte[] bytes = new byte[1024];
//定义变量,接收read方法返回值
int len = 0 ;
//read方法,文件末尾返回-1,利用循环读取
while((len = fis.read(bytes))!=-1){
//  System.out.println(len);
System.out.print(new String(bytes,0,len));
}

/*len = fis.read(bytes);
System.out.println(len); //2
System.out.println(new String(bytes));//ab

len = fis.read(bytes);
System.out.println(len);//2
System.out.println(new String(bytes));//cd

len = fis.read(bytes);
System.out.println(len);//1
System.out.println(new String(bytes));//ed

len = fis.read(bytes);
System.out.println(len);//-1
System.out.println(new String(bytes));//ed
*/
//关闭资源
fis.close();
}
}

字符输出流

Writer 字符数组字符串

OutputStreamWriter 转换流字符转字节 ,带编码表

FileWriter 便捷类,本地默认编码

BufferedWriter 字符输出流缓冲区 newLine

字符输入流

Reader

InputStreamReader 转换流字节转字符,带编码表

FileReader 便捷类,本地默认编码

BufferedReader 字符输入流缓冲区 readLine

/*
*  OutputStreamWrite 转换流,自己本身也是一个字符流,输出流
*    继承Writer  写的方法write 单个字符,字符数组,数组一部分,字符串
*
* OutputStreamWrite 字符流向字节的桥梁,将字符流转成字节流
*  构造方法
*    OutputStreamWriter(OutputStream out)
*  传递字节输出流对象  FileOutputStream
*    new OutputStreamWriter(new FileOutputStream("XXX.txt"))
*    数据写到字节输出流中,OutputStreamWriter写的字符串转成字节,写到目的中
*
*    OutputStreamWriter(OutputStream out,"编码表的名字")
*/

public class OutputStreamWriterDemo {
public static void main(String[] args) throws IOException{
writeUTF();
}
/*
* 转换流+字符输出流,写字符串
* 写UTF-8效果
*/
public static void writeUTF()throws IOException{
//创建字节输出流对象,封装文件
FileOutputStream fos = new FileOutputStream("c:\\utf.txt");
//创建转换流对象,将字符变成字节,写到字节流
OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");

osw.write("你好");

osw.flush();
osw.close();

}

/*
* 转换流+字节输出流,写字符串
* 将字符串转成字节数组,写到字节输出流
* 写GBK的效果
*/
public static void writeGBK()throws IOException{
//创建字节输出流对象,封装文件
FileOutputStream fos = new FileOutputStream("c:\\gbk.txt");
//创建转换对象,字符转成字节
OutputStreamWriter osw = new OutputStreamWriter(fos);
//调用转换流,写字符的方法
osw.write("你好");
//刷新方法,将内存中的数据刷新到目的中去
osw.flush();

/*osw.write("大家好");
osw.flush();*/
osw.close();
}
}

/*
* InputStreamReader 转换流
*   继承Reader  读取的方法read 单个字符 字符数组
*
* InputStreamReader 字节流向字符的桥梁
*   将字节流转成字符流对象
*   FileInputStream 每次读取一个字节  -- > 字符
*   InputStreamReader 读取一个字节,判断负数,再次读取一个字节
*  构造方法
*   InputStreamReader(InputStream in)
*   传递字节输入流对象  InputStream的子类对象
*    FileInputStream
*
*  char  0 1
*  short 0 1
*  new InputStreamReader(new FileInputStream("XXX.txt"))
*/

public class InputStreamReaderDemo {
public static void main(String[] args) throws IOException{
readUTF();
}
/*
* 使用转换流+字节输入流读取文件
* 读取UTF-8编码文件
*/
public static void readUTF()throws IOException{
//创建字节输入流,封装文件
FileInputStream fis = new FileInputStream("c:\\utf.txt");
//创建转换流对象,封装字节输入流
InputStreamReader isr = new InputStreamReader(fis,"utf-8");
char[] cbuf = new char[1024];
int len = 0 ;
while((len = isr.read(cbuf))!=-1){
System.out.print(new String(cbuf,0,len));
}
isr.close();
}

/*
* 使用转换流+字节输入流读取文件
* 读取GBK编码的文件
*/
public static void readGBK()throws IOException{
//创建字节输入流,封装文件
FileInputStream fis = new FileInputStream("c:\\gbk.txt");
//创建转换流对象,封装字节输入流
InputStreamReader isr = new InputStreamReader(fis);
//读取方法 read 读取单个字符
/*  len = isr.read();
System.out.println((char)len);

len = isr.read();
System.out.println((char)len);

len = isr.read();
System.out.println(len);*/
int len = 0 ;
/*while((len= isr.read())!=-1){
System.out.print((char)len);
}*/
//定义字符数组
char[] cbuf = new char[1024];
while((len = isr.read(cbuf))!=-1){
System.out.println(new String(cbuf,0,len));
}

isr.close();
}
}

package cn.itcast.iostream;
/*
* FileWriter 写入文本文件的便捷类
*   继承 OutputStreamWriter  继承 Writer
* FileWriter 只能查询编码表GBK
*   构造方法
*     传递File对象
*     传递String文件名
*  写的方法,使用的都是他的父类方法
*/
import java.io.*;
public class FileWriterDemo {
public static void main(String[] args) throws IOException{
//创建FileWriter类对象,封装文件
FileWriter fw = new FileWriter("c:\\a.txt");
//写字符串
fw.write("abcdefg");
fw.flush();

//写单个字符
fw.write(65);
fw.flush();

//写字符数组
char[] ch ="\r\n你好我好大家好".toCharArray();
fw.write(ch,0,4);
fw.flush();

fw.close();
}
}

package cn.itcast.iostream;
/*
* FileReader 读取文本文件便捷类
*   继承 InputStreamReader 继承 Reader
*   查询本机默认编码表GBK
*
* 构造方法
*   传递 File对象
*   传递String文件名
*
*/
import java.io.*;
public class FileReaderDemo {
public static void main(String[] args) throws IOException{
//创建字符输入流对象,封装文件
FileReader fr = new FileReader("c:\\a.txt");
//读取一个字符
int len = 0 ;
while((len = fr.read())!=-1){
System.out.print((char)len);
}

//读取字符数组
char[] cbuf = new char[1024];
while((len = fr.read(cbuf))!=-1){
System.out.print(new String(cbuf,0,len));
}

fr.close();
}
}

package cn.itcast.iostream;
/*
*  字符输入流的缓冲区对象 BufferedReader
*    继承Reader 字符输入流  读取字符,字符数组 ,读取行
*
*  构造方法
*    BufferedReader(Reader r)
*    传递的任意字符输入流对象,传递的是谁,我就对谁高效
*    InputStreamReader  FileReader
*
*  new BufferedReader(new FileReader)
*  new BufferedReader(new InputStreamReader)
*
*     读取文本一行
*     String newLine() 返回文本一行,没有换行符\r\n
*/
import java.io.*;
public class BufferedReaderDemo {
public static void main(String[] args) throws IOException{
//创建FileReader对象,封装文件
FileReader fr = new FileReader("c:\\a.txt");
//创建字符输入流缓冲区对象,传递字符输入流
BufferedReader bfr = new BufferedReader(fr);
//读取文本行  readLine 返回字符串
//readLine方法读取文件结尾返回null
String line = null;
while((line = bfr.readLine())!=null){
System.out.println(line);
}

/*String line = bfr.readLine();
System.out.println(line);

line = bfr.readLine();
System.out.println(line);

line = bfr.readLine();
System.out.println(line);

line = bfr.readLine();
System.out.print(line);*/
bfr.close();
}
}

package cn.itcast.iostream;
/*
* 字符输出流的缓冲区对象,提高字符输出流的写入效率
*   BufferedWriter 继承 Writer
*
* 构造方法
*    BufferedWriter(Writer w)
*    传递任意字符输出流   Writer子类对象
*    OutputStreamWriter  FileWriter
*  new BufferedWriter(new FileWriter)
*  new BufferedWriter(new OutputStreamWriter)
*
*    缓冲区对象自己特有功能
*     void newLine() 写入换行符
*   \r\n 文本换行
*   为什么 提供单独换行的功能
*   方法newLine()写入换行与平台无关 ,不理会操作系统
*   Windows  \r\n
*   Linux     \n
*   安装的JVM是Windows版本 newLine写的就是\r\n
*   安装 的JVM是Linux版本    newLine写的就是\n
*   \r 回车符  13
*   \n 换行符  10
*/
import java.io.*;
public class BufferedWriterDemo {
public static void main(String[] args)throws IOException {
//创建字符输出流对象,封装文件
FileWriter fw = new FileWriter("c:\\a.txt");
//创建字符输出流缓冲区对象,传递字符输出流对象
BufferedWriter bfw = new BufferedWriter(fw);
bfw.write("第一行");
bfw.newLine();
bfw.flush();

bfw.write("第二行");
bfw.flush();

bfw.close();
}

}

使用方法,规律

流对象读取和写入数据

明确数据源: 读取 read

数据源是文本文件

|– FileReader

|– InputStreamReader 操作编码表

需要提高读取效率,如果需要提高

|– 字符数组缓冲

|– BufferedReader 行读取 readLine

数据源不是文本

|– FileInputStream

需要提高效率,如果需要提高

|– 字节数组缓冲

|– BufferedInputStream

数据源是什么文件不明确

package cn.itcast.iostream;
/*
* ByteArrayOutputStream
*   内存流,不占用操作系统资源,将字节数组写到内存
* 构造方法  空参数构造方法
*   write方法,写字节数组,写在内存中
* toByteArray()直接从流中,获取字节数组
* toString()字节数组转成字符串
*
* ByteArrayInputStream
*   内存流,不占用操作系统资源,读取字节数组
* 构造方法 传递字节数组,这个流数据源
*/
import java.io.*;
public class ByteArrayStreamDemo {
public static void main(String[] args)throws IOException {
readWrite();
}
public static void readWrite()throws IOException{
ByteArrayOutputStream bos = new ByteArrayOutputStream();
bos.write("abcd你好".getBytes());

ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
byte[] bytes = new byte[1024];
int len = 0 ;
while((len = bis.read(bytes))!=-1){
System.out.println(new String(bytes,0,len));
}
new FileOutputStream("c:\\1.txt").write(bos.toByteArray());
}

/*
* 字节输入流,读取字节数组
*/
public static void read()throws IOException{
//创建字节数组输入流,构造方法,写字节数组
ByteArrayInputStream bis = new ByteArrayInputStream("abc".getBytes());
int len = 0 ;
byte[] bytes = new byte[1024];
while((len = bis.read(bytes))!=-1){
System.out.println(new String(bytes,0,len));
}
}

/*
* 字节输出流,将字节数组写到内存中
*/
public static void write()throws IOException{
//创建字节数组输出流对象
ByteArrayOutputStream bos = new ByteArrayOutputStream();
//写字节数组
bos.write("abc".getBytes());

bos.write("你好".getBytes());

//toByteArray直接获取字节数组
byte[] bytes = bos.toByteArray();
for(byte b : bytes){
System.out.println(b);
}
System.out.println(new String(bytes));

//调用toString()直接将内存字节数组变成字符串
String s = bos.toString();
System.out.println(s);
}
}

打印流

PrintWriter

|– 构造方法

|– 字节,字符,String,File 数据目的

|– 不抛异常,方便输出数据,不操作数据源

|– 自动刷新三个方法 println,printf,format

/*

* 打印流对象

* PrintStream 继承OutputStream

*

* 作用,为其他输出流添加了功能,也是一个装饰流

* 方便打印各种形式的数据

* 打印流不会抛出IOException

* 此流只操作数据目的,不操作数据源

*

* 使用场景: 做数据输出的时候,优先考虑使用打印流
* JAVAWeb程序服务器端使用打印流,将数据打印回客户端浏览器

*

* PrintStream 字节输出流继承 OutputStream

* PrintWriter 字符输出流继承 Writer

*

* 数据目的写哪里,写在流对象的构造方法中

* PrintStream 构造方法,接收哪些类型的数据目的

* 接收File对象

* 接收字节输出流OutStream子类

* 接收字符串文件名

*

* PrintWriter 构造方法,接收哪些类型数据目的

* File对象

* 接收字节输出流OutputStream类

* 接收字符串文件名

* 接收字符输出流Writer子类

*

*/

标准输入输出流

System.in System.out

package cn.itcast.iostream;

import java.io.*;

/*
* System类的标准输入流
*  System类的静态成员变量  System.in;
* 运行结果InputStream的子类对象  BufferedInputStream
* 流中的read方法,等待的特性,线程阻塞
*
* read方法,读取键盘录入一行,打印出来
* 一行数据,不需要换行符
*
* 代码和读取一行的readLine功能几乎是一样
* 能不能使用readLine直接读取键盘一行
* readLine 读取键盘一行  System.in
* InputStreamReader 字节转成字符
*/
public class SystemInDemo {
public static void main(String[] args) throws IOException {
InputStream in = System.in;
// InputStream类的方法read读取
StringBuilder builder = new StringBuilder();
int len = 0;
while ((len = in.read()) != -1) {
if (len == '\r')
continue;
if (len == '\n') {
if ("over".equals(builder.toString())) {
// if(builder.toString().equals("over")){
break;
}
// 将字符串缓冲区打印出来
System.out.println(builder);
// 清空缓冲区
builder.delete(0, builder.length());
} else {
builder.append((char) len);
}
}
}

/*public static void a() {

* boolean b = true; if(true=b){
*
* }else{
*
* }

String s = null;
System.out.println("abc".equals(s));
System.out.println(s.equals("abc"));

}*/
}

package cn.itcast.iostream;
/*
* 标准输出流
*  System.out 返回值是OutputStream类型
*  System.out返回是打印流对象,打印流对象println方法,数据打印在控制台
*
* write方法写字节数组,写到控制台
*   转成字节数组,换行\r\n
* newLine()换行,跨平台
* BufferedWriter 类的方法newLine
* write("字符串")
* newLine
*
* OutputStreamWriter转换流,字符转成字节
* OutputStreamWriter(OutputStream out)
* new OutputStreamWriter(new FileOut(),"gbk");
*/
import java.io.*;
public class SystemOutDemo {
public static void main(String[] args)throws IOException {
OutputStream out = System.out;
out.write("abc".getBytes());

}
}

!流里面还有一个可以把集合与流连接起来的特殊的~

/*
* Properties和IO流关联使用
*   日后你们开发:读取配置文件
*
* load(传递字节或者字符输入流)
*   流对象读取文件,文件中的键值对保存到集合
*
* store(传递字节或者字符输出流,String s)
*   将集合中的键值对,保存会文件中
*/
import java.io.*;
import java.util.*;

public class PropertiesDemo {
public static void main(String[] args) throws IOException {
method_2();
//System.out.println('\u6CA1');
}

/*
* 集合方法list()传递打印流*/
public static void method_2()throws IOException{
Properties pro = new Properties();
pro.setProperty("a", "1");
pro.setProperty("b", "2");
pro.setProperty("c", "3");
pro.list(new PrintStream(new FileOutputStream("c:\\a.txt")));
}

/*
* IO读取配置文件,键值对存储到集合 修改键值对,将修改后的内容存储回配置文件
*/
public static void method_1() throws IOException {
// 创建字节输入流,封装文件
FileInputStream fis = new FileInputStream("c:\\pro.txt");
// 创建集合对象
Properties pro = new Properties();
// 使用集合方法load传递字节输入流
pro.load(fis);
fis.close();
System.out.println(pro);

//将age修改成30
pro.setProperty("age", "30");
System.out.println(pro);
//创建字节输出流,封装文件
FileOutputStream fos = new FileOutputStream("c:\\pro.txt");
//调用集合方法store传递字节输出流
pro.store(fos, "");
fos.close();
}

/*
* IO读取配置文件,键值对存储到集合
*/
public static void method() throws IOException {
// 创建字节输入流,封装文件
FileInputStream fis = new FileInputStream("c:\\pro.txt");
// 创建集合对象
Properties pro = new Properties();
// 使用集合方法load传递字节输入流
pro.load(fis);
fis.close();
System.out.println(pro);
// 通过键获取值
String name = pro.getProperty("name");
String age = pro.getProperty("age");
String address = pro.getProperty("address");
System.out.println(name + age + address);

// 修改集合中的键值对
/*
* pro.setProperty("age", "30"); System.out.println(pro);
*/
}
}

最后的最后我们来说一下,对象的序列化~~!

/*

对象的序列化

使用IO流技术,将对象中的数据,写到文件中,永久保存

将对象中的数据写到文件中,对象的序列化

将文件中保存的数据还原回对象,对象的反序列化

io包

ObjectOutputStream 写对象,序列化流

构造方法

ObjectOutputStream(OutputStream out)

传递字节输出流,字节输出流中封装文件

writeObject(Object obj)

*/

这个我就不写代码了~~!

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航