1.Properties
来自集合体系HashTable
java.util.Properties -- 可以从文件中加载,也可以写出到文件中 -- 经常用做程序的配置文件
Properties信息也可以保存在.properties格式的文件中。properties文件中"#"之后的内容是被注释掉了。
Properties中不允许存储中文数据,如果需要保存非ISO8859-1的数据,需要保存成\uxxxx格式
Properties()
Object setProperty(String key, String value)
String getProperty(String key) 用指定的键在此属性列表中搜索属性。
String getProperty(String key, String defaultValue) 用指定的键在属性列表中搜索属性。
load(InputStream in)
load(Reader reader)
store(OutputStream String)
store(Writer String)
package com.zll.properties;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.Reader;
import java.io.Writer;
import java.util.Properties;
/**
Properties演示
*/
public class PropDemo1 {
public static void main(String[] args) throws Exception {
// Properties prop = new Properties();
// prop.setProperty("name", "zhangsan");
// prop.setProperty("age", "19");
//
// String value = prop.getProperty("name");
// System.out.println(value);
// System.out.println(prop.getProperty("addr","wudangshan"));
Reader reader = new FileReader("1.properties");
Properties prop = new Properties();
prop.load(reader);
reader.close();
String user = prop.getProperty("user");
String password = prop.getProperty("password");
System.out.println(user+":"+password);
prop.setProperty("url", "jdbc:mysql:///day09");
Writer writer = new FileWriter("1.properties");
prop.store(writer, null);
writer.close();
System.out.println();
}
}
2.打印流
WriterPrintWriter
通过String路径
通过File对象
通过包装其他Writer
通过包装其他OutputStream
在调用 println、printf 或 format 方法时底层会自动刷新不需要我们刷新
写数据的方法没有异常抛出
提供了对各种类型支持的print方法和println方法,底层就是将传入的内容输出到流中pathSeparator
OutputStream
FilterOutputStream
PrintStream
在调用 println、printf 或 format 方法时底层会自动刷新不需要我们刷新
写数据的方法没有异常抛出
提供了对各种类型支持的print方法和println方法,底层就是将传入的内容输出到流中
3.SequenceInputStream
序列流,可以将多个字节输入流包装成一个流,相当于将流合并。
package zll.material.java_base_homework;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.SequenceInputStream;
import java.util.Vector;
public class SequenceInputStreamDemo1 {
public static void main(String[] args) throws Exception {
InputStream in1 = new FileInputStream("e:\\1.txt");
InputStream in2 = new FileInputStream("e:\\2.txt");
InputStream in3 = new FileInputStream("e:\\3.txt");
Vector v = new Vector();
v.add(in1);
v.add(in2);
v.add(in3);
SequenceInputStream sis = new SequenceInputStream(v.elements());
OutputStream out = new FileOutputStream("e:\\4.txt");
int i = -1;
while((i = sis.read())!=-1){
out.write(i);
}
out.close();
sis.close();
}
}
切分视屏,合并视屏
package zll.material.java_base_homework;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Properties;
/**
切割文件
*/
public class SplitFileDemo1 {
public static void main(String[] args) throws Exception {
File file = new File("e:\\1.mp4");
InputStream in = new FileInputStream(file);
byte bs [] = new byte[1024*1024];
int i = -1;
int count = 0;
while((i = in.read(bs))!=-1){
count++;
OutputStream out = new FileOutputStream("e:\\part"+count+".data");
out.write(bs,0,i);
out.close();
}
in.close();
OutputStream out = new FileOutputStream("config.properties");
Properties prop = new Properties();
prop.setProperty("fname", "1.avi");
prop.setProperty("count", count+"");
prop.store(out, null);
out.close();
}
}
package zll.material.java_base_homework;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.SequenceInputStream;
import java.util.Properties;
import java.util.Vector;
public class CombineFile {
public static void main(String[] args) throws Exception {
Properties prop = new Properties();
prop.load(new FileInputStream("config.properties"));
//原来文件的名字
String fname = prop.getProperty("fname");
//切割的块的数量
int count = Integer.parseInt(prop.getProperty("count"));
Vector v = new Vector();
for(int i = 1;i<=count;i++){
InputStream in = new FileInputStream("e:\\part"+i+".data");
v.add(in);
}
SequenceInputStream sis = new SequenceInputStream(v.elements());
OutputStream out = new FileOutputStream("F:\\"+fname);
byte [] bs = new byte[1024];
int i = -1;
while((i = sis.read(bs))!=-1){
out.write(bs,0,i);
}
sis.close();
out.close();
}
}
4.RandomAccessFile
随机读写文件的流。既可以读取也可以写入。在此类看来一个被操作的文件就像一个非常大的字节数组一样,并在该字节数组内部维系了一个指针,这个指针可以被设置到指定位置,从而从指定位置开始进行读写的操作。RandomAccessFile提供了读写文件指定位置部分字节信息的能力。
RandomAccessFile(File file, String mode)
RandomAccessFile(String name, String mode)
如果文件不存在就创建该文件。如果文件已经存在就直接使用而不会覆盖。
int skipBytes(int n) //让指针跳过指定字节指向后续位置
void seek(long pos) //移动指针到指定位置,其中的参数表示从文件的开始位置计算的字节偏移量。
package com.zll.io;
import java.io.IOException;
import java.io.RandomAccessFile;
/**
* RandomAccessFile的使用
* 文件随机读写流
*/
public class RandomAccessFileDemo1 {
public static void main(String[] args) throws IOException {
// RandomAccessFile raf = new RandomAccessFile("c:\\1.txt", "rw");
// raf.skipBytes(27);
// raf.write("男".getBytes());
// raf.close();
byte [] bs = new byte[4];
RandomAccessFile raf = new RandomAccessFile("c:\\1.txt", "rw");
raf.skipBytes(5);
raf.read(bs);
raf.close();
String str = new String(bs);
System.out.println(str);
}
}
5.对象持久化流
ObjectOutputStream(OutputStream out)ObjectInputStream(InputStream in)
利用这两个流可以将对象持久化到设备中,可以从设备中将之前持久化的对象再读取回来。
想要被序列化的对象的类必须实现Serializable接口。
静态成员变量属于类,不能被序列化
某个想要被序列化的对象类中的某个属性如果没有实现Serializable接口,则在序列化过程中,该属性不能被序列化。
如果想要手动指定某个属性不被序列化,可以使用java中的transient关键字
序列化和反序列化时,会根据serialVersionUID来判断序列化之前的类和要反序列化的列是否是同一个。
serialVersionUID默认自动取值,每次编译值都不同。
我们可以通过在类中指定private static final long serialVersionUID = 999888777l;手动指定一个serialVerwsionUID,实现即使类发生轻微变化仍然可以反序列化、实现远程对象传递时的序列化反序列化问题。
package com.zll.domain;
public class Dog {
private String name;
public Dog() {
}
public Dog(String name) {
super();
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package com.zll.domain;
import java.io.Serializable;
public class Person implements Serializable {
private static final long serialVersionUID = 999888777l;
private String name;
private int age;
private Dog dog;
private String addr;
public Person() {
}
public Person(String name, int age,Dog dog) {
super();
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;
}
public Dog getDog() {
return dog;
}
public void setDog(Dog dog) {
this.dog = dog;
}
}
package com.zll.io;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import com.tarena.domain.Person;
/**
* 序列化流案例
*/
public class ObjectInputStreamDemo1 {
public static void main(String[] args) throws Exception{
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("c:\\p1.data"));
Person p = (Person) ois.readObject();
System.out.println(p.getName());
System.out.println(p.getAge());
System.out.println(p.getDog());
System.out.println(p);
}
}
package com.zll.io;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import com.tarena.domain.Dog;
import com.tarena.domain.Person;
/**
序列化流
*/
public class ObjectOutputStreamDemo1 {
public static void main(String[] args) throws Exception {
Person p = new Person("zhangsan",19,new Dog("阿黄"));
System.out.println(p);
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("c:\\p1.data"));
oos.writeObject(p);
oos.close();
}
}
6.基本数据流
ByteArrayInputStream ByteArrayOutputStream-- 数据来源/目的地 是内存中的字节数组的流
ByteArrayOutputStream()
ByteArrayOutputStream(int size)
byte[] toByteArray() //将ByteArrayOutputStream中的保存的字节转换位字节数组返回。
ByteArrayInputStream(byte[] buf)
ByteArrayInputStream(byte[] buf, int offset, int length)
package com.zll.io;
import java.io.ByteArrayInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;
/**
* ByteArrayInputStream 案例
*/
public class ByteArrayInputStreamDemo1 {
public static void main(String[] args) throws Exception {
byte [] bs = "中国北京大钟寺".getBytes();
ByteArrayInputStream in = new ByteArrayInputStream(bs);
OutputStream out = new FileOutputStream("c:\\2.txt");
int i = -1;
while((i = in.read())!=-1){
out.write(i);
}
in.close();
out.close();
}
}
package com.zll.io;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.InputStream;
/**
* ByteArrayOutputStream 案例
*/
public class ByteArrayOutputStreamDemo1 {
public static void main(String[] args) throws Exception {
InputStream in = new FileInputStream("c:\\1.txt");
ByteArrayOutputStream bos = new ByteArrayOutputStream();
int i = -1;
while((i=in.read())!=-1){
bos.write(i);
}
byte [] arr = bos.toByteArray();//将ByteArrayOutputStream中的保存的字节信息转换为字节数组返回
System.out.println(new String(arr));
in.close();
bos.close();
}
}
CharArrayReader CharArrayWriter
-- 数据来源/目的地 是内存中的字符数组的流package com.zll.io;
import java.io.CharArrayReader;
import java.io.CharArrayWriter;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;
/**
* CharArrayWriter 案例
*/
public class CharArrayWriterDemo1 {
public static void main(String[] args) {
CharArrayWriter writer = new CharArrayWriter();
CharArrayReader reader = new CharArrayReader(new char[]{});
}
}
StringReader StringWrtier
-- 数据来源/目的地 是字符串
package com.zll.io;
import java.io.FileWriter;
import java.io.IOException;
import java.io.StringReader;
import java.io.Writer;
/**
* StringReader案例
*/
public class StringReaderDemo1 {
public static void main(String[] args) throws Exception {
StringReader reader = new StringReader("xyzopqrstzyx");
Writer writer = new FileWriter("c:\\3.txt");
int i = -1;
while((i = reader.read())!=-1){
writer.write(i);
}
reader.close();
writer.close();
}
}
package com.zll.io;
import java.io.FileReader;
import java.io.Reader;
import java.io.StringWriter;
/**
* StringWriter案例
*/
public class StringWriterDemo1 {
public static void main(String[] args) throws Exception {
StringWriter writer = new StringWriter();
Reader reader = new FileReader("c:\\1.txt");
int i = -1;
while((i = reader.read())!=-1){
writer.write(i);
}
String str = writer.toString();
System.out.println(str);
reader.close();
writer.close();
}
}