∆ 字节流、字符流
∆ SequenceInputStream(序列流)
序列流，对多个流进行合并。
SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。
需求：的内容合并
public class Demo1 {
public static void main(String[] args) throws IOException {
merge3();
}
//把三个文件合并成一个文件
public static void merge3() throws IOException{
//找到目标文件
File file1 = new File("F:\\a.txt");
File file2 = new File("F:\\b.txt");
File file3 = new File("F:\\c.txt");
File file4 = new File("F:\\d.txt");
//建立对应 的输入输出流对象
FileOutputStream fileOutputStream = new FileOutputStream(file4);
FileInputStream fileInputStream1 = new FileInputStream(file1);
FileInputStream fileInputStream2 = new FileInputStream(file2);
FileInputStream fileInputStream3 = new FileInputStream(file3);
//创建序列流对象
Vector<FileInputStream> vector = new Vector<FileInputStream>();
vector.add(fileInputStream1);
vector.add(fileInputStream2);
vector.add(fileInputStream3);
Enumeration<FileInputStream> e = vector.elements();
SequenceInputStream sequenceInputStream = new SequenceInputStream(e);
//读取文件数据
byte[] buf = new byte[1024];
int length = 0;
while((length = sequenceInputStream.read(buf))!=-1){
fileOutputStream.write(buf,0,length);
}
//关闭资源
sequenceInputStream.close();
fileOutputStream.close();
}
// 使用SequenceInputStream合并文件。
public static void merge2() throws IOException{
//找到目标文件
File inFile1 = new File("F:\\a.txt");
File inFile2 = new File("F:\\b.txt");
File outFile = new File("F:\\c.txt");
//建立数据的输入输出通道
FileOutputStream fileOutputStream = new FileOutputStream(outFile);
FileInputStream fileInputStream1 = new FileInputStream(inFile1);
FileInputStream fileInputStream2 = new FileInputStream(inFile2);
//建立序列流对象
SequenceInputStream inputStream = new SequenceInputStream(fileInputStream1,fileInputStream2);
byte[] buf = new byte[1024];
int length = 0 ;
while((length = inputStream.read(buf))!=-1){
fileOutputStream.write(buf,0,length);
}
//关闭资源
inputStream.close();
fileOutputStream.close();
}
//需求：把a.txt与b.txt 文件的内容合并。
public static void merge1() throws IOException{
//找到目标文件
File inFile1 = new File("F:\\a.txt");
File inFile2 = new File("F:\\b.txt");
File outFile = new File("F:\\c.txt");
//建立数据的输入输出通道
FileOutputStream fileOutputStream = new FileOutputStream(outFile);
FileInputStream fileInputStream1 = new FileInputStream(inFile1);
FileInputStream fileInputStream2 = new FileInputStream(inFile2);
//把输入流存储到集合中，然后再从集合中读取
ArrayList<FileInputStream> list = new ArrayList<FileInputStream>();
list.add(fileInputStream1);
list.add(fileInputStream2);
//准备一个缓冲数组
byte[] buf = new byte[1024];
int length = 0 ;
for(int i = 0 ; i< list.size() ; i++){
FileInputStream fileInputStream = list.get(i);
while((length = fileInputStream.read(buf))!=-1){
fileOutputStream.write(buf,0,length);
}
//关闭资源
fileInputStream.close();
}
fileOutputStream.close();
}
}
举例Demo: 需求： 把一首mp3先切割成n份，然后再把这些文件合并起来。
public class Demo2 {
public static void main(String[] args) throws IOException {
// cutFile();
mergeFlile();
}
//合并
public static void mergeFlile() throws IOException{
//找到目标文件
File dir = new File("F:\\music");
//通过目标文件夹找到所有的MP3文件，然后把所有的MP3文件添加到vector中。
Vector<FileInputStream> vector = new Vector<FileInputStream>();
File[] files = dir.listFiles();
for(File file : files){
if(file.getName().endsWith(".mp3")){
vector.add(new FileInputStream(file));
}
}
//通过Vector获取迭代器
Enumeration<FileInputStream> e = vector.elements();
//创建序列流
SequenceInputStream inputStream = new SequenceInputStream(e);
//建立文件的输出通道
FileOutputStream fileOutputStream = new FileOutputStream("F:\\合并.mp3");
//建立缓冲数组读取文件
byte[] buf = new byte[1024];
int length = 0 ;
while((length = inputStream.read(buf))!=-1){
fileOutputStream.write(buf,0,length);
}
//关闭资源
fileOutputStream.close();
inputStream.close();
}
//切割MP3
public static void cutFile() throws IOException{
File file = new File("F:\\美女\\1.mp3");
//目标文件夹
File dir = new File("F:\\music");
//建立数据的输入通道
FileInputStream fileInputStream = new FileInputStream(file);
//建立缓冲数组读取
byte[] buf = new byte[1024*1024];
int length = 0;
for(int i = 0 ; (length = fileInputStream.read(buf))!=-1 ; i++){
FileOutputStream fileOutputStream = new FileOutputStream(new File(dir,"part"+i+".mp3"));
fileOutputStream.write(buf,0,length);
fileOutputStream.close();
}
//关闭资源
fileInputStream.close();
}
}∆ 对象的输入输出流
当创建对象时,程序运行时它就会存在,但是程序停止时,对象也就消失了.但是如果希望对象在程序不运行的情况下仍能存在并保存其信息，将会非常有用，对象将被重建并且拥有与程序上次运行时拥有的信息相同。可以使用对象的序列化。
对象的序列化： 将内存中的对象直接写入到文件设备中
对象的反序列化： 将文件设备中持久化的数据转换为内存对象
基本的序列化由两个方法产生：一个方法用于序列化对象并将它们写入一个流，另一个方法用于读取流并反序列化对象。
ObjectOutput
writeObject(Object obj)
将对象写入底层存储或流。
ObjectInput
readObject()
读取并返回对象。ObjectOutputStream的使用步骤：
对象输入输出流要注意的细节：
- 如果对象需要被写出到文件上，那么对象所属的类必须要实现Serializable接口。 Serializable接口没有任何的方法，是一个标识接口而已。
- 对象的反序列化创建对象的时候并不会调用到构造方法的、
- serialVersionUID 是用于记录class文件的版本信息的，serialVersionUID这个数字是通过一个类的类名、成员、包名、工程名算出的一个数字。
- 使用ObjectInputStream反序列化的时候，ObjeectInputStream会先读取文件中的serialVersionUID，然后与本地的class文件的serialVersionUID进行对比，如果这两个id不一致，那么反序列化就失败了。
- 如果序列化与反序列化的时候可能会修改类的成员，那么最好一开始就给这个类指定一个serialVersionUID，如果一类已经指定的serialVersionUID，然后在序列化与反序列化的时候，jvm都不会再自己算这个 class的serialVersionUID了。
- 如果一个对象某个数据不想被序列化到硬盘上，可以使用关键字transient修饰。
- 如果一个类维护了另外一个类的引用，那么另外一个类也需要实现Serializable接口。
代码举例：
class Address implements Serializable{
String country;
String city;
public Address(String country,String city){
this.country = country;
this.city = city;
}
}
class User implements Serializable{
private static final long serialVersionUID = 1L;
String userName ;
String password;
transient int age; // transient 透明
Address address ;
public User(String userName , String passwrod) {
this.userName = userName;
this.password = passwrod;
}
public User(String userName , String passwrod,int age,Address address) {
this.userName = userName;
this.password = passwrod;
this.age = age;
this.address = address;
}
@Override
public String toString() {
return "用户名："+this.userName+ " 密码："+ this.password+" 年龄："+this.age+" 地址："+this.address.city;
}
}
public class Demo3 {
public static void main(String[] args) throws IOException, Exception {
writeObj();
// readObj();
}
//把文件中的对象信息读取出来-------->对象的反序列化
public static void readObj() throws IOException, ClassNotFoundException{
//找到目标文件
File file = new File("F:\\obj.txt");
//建立数据的输入通道
FileInputStream fileInputStream = new FileInputStream(file);
//建立对象的输入流对象
ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
//读取对象信息
User user = (User) objectInputStream.readObject(); //创建对象肯定要依赖对象所属 的class文件。
System.out.println("对象的信息："+ user);
}
//定义方法把对象的信息写到硬盘上------>对象的序列化。
public static void writeObj() throws IOException{
//把user对象的信息持久化存储。
Address address = new Address("中国","广州");
User user = new User("admin","123",15,address);
//找到目标文件
File file = new File("F:\\obj.txt");
//建立数据输出流对象
FileOutputStream fileOutputStream = new FileOutputStream(file);
//建立对象的输出流对象
ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
//把对象写出
objectOutputStream.writeObject(user);
//关闭资源
objectOutputStream.close();
}
}
∆ Properties（配置文件类）
主要用于生产配置文件与读取配置文件的信息。
可以和流相关联的集合对象Properties.
Map
|--Hashtable
|--PropertiesProperties:该集合不需要泛型，因为该集合中的键值对都是String类型。
1，存入键值对：setProperty(key,value);
2，获取指定键对应的值：value getProperty(key);
3，获取集合中所有键元素：
Enumeration propertyNames();
Properties要注意的细节：
- 如果配置文件的信息一旦使用了中文，那么在使用store方法生成配置文件的时候只能使用字符流解决，如果使用字节流生成配置文件的话，默认使用的是iso8859-1码表进行编码存储，这时候会出现乱码。
- 如果Properties中的内容发生了变化，一定要重新使用Properties生成配置文件，否则配置文件信息不会发生变化。
public class Demo4 {
public static void main(String[] args) throws IOException {
creatProperties();
// readProperties();
}
//读取配置文件的信息
public static void readProperties() throws IOException{
//创建Properties对象
Properties properties = new Properties();
//加载配置文件信息到Properties中
properties.load(new FileReader("F:\\persons.properties"));
//遍历
Set<Entry<Object, Object>> entrys = properties.entrySet();
for(Entry<Object, Object> entry :entrys){
System.out.println("键："+ entry.getKey() +" 值："+ entry.getValue());
}
//修改狗娃的密码
//把修改后的Properties再生成一个配置文件
properties.setProperty("狗娃", "007");
properties.store(new FileWriter("F:\\persons.properties"), "hehe");
}
//保存配置文件文件的信息。
public static void creatProperties() throws IOException{
//创建Properties
Properties properties = new Properties();
properties.setProperty("狗娃", "123");
properties.setProperty("狗剩","234");
properties.setProperty("铁蛋","345");
// 遍历Properties
/*Set<Entry<Object, Object>> entrys = properties.entrySet();
for(Entry<Object, Object> entry :entrys){
System.out.println("键："+ entry.getKey() +" 值："+ entry.getValue());
}*/
//使用Properties生产配置文件。
//properties.store(new FileOutputStream("F:\\persons.properties"), "haha"); //第一个参数是一个输出流对象，第二参数是使用一个字符串描述这个配置文件的信息。
properties.store(new FileWriter("F:\\persons.properties"), "hehe");
}
}代码举例： 使用properties实现本软件只能 运行三次，超过了三次之后就提示购买正版，退jvm.
public class Demo5 {
public static void main(String[] args) throws IOException {
File file = new File("F:\\count.properties");
if(!file.exists()){
//如果配置文件不存在，则创建该配置文件
file.createNewFile();
}
//创建Properties对象。
Properties properties = new Properties();
//把配置文件的信息加载到properties中
properties.load(new FileInputStream(file));
FileOutputStream fileOutputStream = new FileOutputStream(file);
int count = 0; //定义该变量是用于保存软件的运行次数的。
//读取配置文件的运行次数
String value = properties.getProperty("count");
if(value!=null){
count = Integer.parseInt(value);
}
//判断使用的次数是否已经达到了三次，
if(count==3){
System.out.println("你已经超出了试用次数，请购买正版软件！！");
System.exit(0);
}
count++;
System.out.println("你已经使用了本软件第"+count+"次");
properties.setProperty("count",count+"");
//使用Properties生成一个配置文件
properties.store(fileOutputStream,"runtime");
}
}∆ 打印流（printStream）
打印流（printStream） 打印流可以打印任意类型的数据，而且打印数据之前都会先把数据转换成字符串再进行打印。
PrintStream:
是一个字节打印流，System.out对应的类型就是PrintStream。
它的构造函数可以接收三种数据类型的值。
- 字符串路径。
- File对象。
- OutputStream。
public static void main(String[] args) throws IOException {
PrintStream ps = System.out;
// 普通write方法需要调用flush或者close方法才会在控制台显示
// ps.write(100);
// ps.close();
// 不换行打印
ps.print(100);
ps.print('a');
ps.print(100.5);
ps.print("世界");
ps.print(new Object());
System.out.println("--------------");
// 换行
ps.println(100);
ps.println('a');
ps.println(100.5);
ps.println("世界");
ps.println(new Object());
// 重定向打印流
PrintStream ps2 = new PrintStream(new File("c:\\a.txt"));
System.setOut(ps2);
// 换行
ps2.println(100);
ps2.println('a');
ps2.println(100.5);
ps2.println("世界");
ps2.println(new Object());
// printf(); 格式化
ps2.printf("%d,%f,%c,%s", 100, 3.14, '中', "世界你好!!!");
ps2.printf("%4s和%8s 打价格战", "京东", "苏宁");
} }代码举例：
class Animal{
String name;
String color;
public Animal(String name,String color){
this.name = name;
this.color = color;
}
@Override
public String toString() {
return "名字："+this.name+ " 颜色："+ this.color;
}
}
public class Demo6 {
public static void main(String[] args) throws IOException {
/*FileOutputStream fileOutputStream = new FileOutputStream("F:\\a.txt");
fileOutputStream.write("97".getBytes());
fileOutputStream.close();*/
//打印流可以打印任何类型的数据，而且打印数据之前都会先把数据转换成字符串再进行打印。
File file = new File("F:\\a.txt");
//创建一个打印流
PrintStream printStream = new PrintStream(file);
/*
printStream.println(97);
printStream.println(3.14);
printStream.println('a');
printStream.println(true);
Animal a = new Animal("老鼠", "黑色");
printStream.println(a);
//默认标准的输出流就是向控制台输出的，
System.setOut(printStream); //重新设置了标准的输出流对象
System.out.println("哈哈，猜猜我在哪里！！");
*/
//收集异常的日志信息。
File logFile = new File("F:\\2015年1月8日.log");
PrintStream logPrintStream = new PrintStream( new FileOutputStream(logFile,true) );
try{
int c = 4/0;
System.out.println("c="+c);
int[] arr = null;
System.out.println(arr.length);
}catch(Exception e){
e.printStackTrace(logPrintStream);
}
}
}∆ 编码
∆ 转换流:
输入字节流的转换流：InputStreamReader 是字节流通向字符流的桥
InputStreamReader
输出字节流的转换流：
OutputStreamWriter 可以把输出字节流转换成输出字符流 。
转换流的作用：
1. 如果目前所 获取到的是一个字节流需要转换字符流使用，这时候就可以使用转换流。 字节流----> 字符流
2. 使用转换流可以指定编码表进行读写文件。
public class Demo8 {
public static void main(String[] args) throws IOException {
// readTest();
// writeTest();'
// writeTest2();
readTest2();
}
//使用输入字节流的转换流指定码表进行读取文件数据
public static void readTest2() throws IOException{
File file = new File("F:\\a.txt");
FileInputStream fileInputStream = new FileInputStream(file);
//创建字节流的转换流并且指定码表进行读取
InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream,"utf-8");
char[] buf = new char[1024];
int length = 0;
while((length = inputStreamReader.read(buf))!=-1){
System.out.println(new String(buf,0,length));
}
}
//使用输出字节流的转换流指定码表写出数据
public static void writeTest2() throws IOException{
File file = new File("F:\\a.txt");
//建立数据的输出通道
FileOutputStream fileOutputStream = new FileOutputStream(file);
//把输出字节流转换成字符流并且指定编码表。
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, "utf-8");
outputStreamWriter.write("新中国好啊");
//关闭资源
outputStreamWriter.close();
}
public static void writeTest() throws IOException{
File file = new File("F:\\a.txt");
FileOutputStream fileOutputStream = new FileOutputStream(file);
//把输出字节流转换成输出字符流。
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream);
outputStreamWriter.write("大家好");
outputStreamWriter.close();
}
public static void readTest() throws IOException{
InputStream in = System.in; //获取了标准的输入流。
// System.out.println("读到 的字符："+ (char)in.read()); //read()一次只能读取一个字节。
//需要把字节流转换成字符流。
InputStreamReader inputStreamReader = new InputStreamReader(in);
//使用字符流的缓冲类
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
String line = null;
while((line = bufferedReader.readLine())!=null){
System.out.println("内容："+ line);
}
}
}
扫一扫
792
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
