黑马程序员——IO二

最新推荐文章于 2024-08-15 17:43:43 发布

原创最新推荐文章于 2024-08-15 17:43:43 发布 · 389 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#Java基础 #黑马程序员 #java #io #编码

Java基础专栏收录该内容

8 篇文章

订阅专栏

------- android培训、java培训、期待与您交流！ ----------

JAVA之IO二

一、编码

编码表：真实的字符和对应数值组成的一张表。

编码：将看得懂的变为看不懂的 String--->byte[] String的getByte("UTF-8")

解码：将看不懂的变为看得懂的 byte[]---->String new String(byte[] buf,"UTF-8")

常见的码表

ASCII------------1个字节7位表示

GBK-----------2字节

GBK2312-------3字节

Iso8859-1-------唯一一个码表全部有对应值得码表，欧洲人的码表

平台默认的码表在中国是GBK

unicode是一个标准，WINDOWS中unicode默认使用了utf-16

utf-8-------英文1字节中文3字节

utf-16------所有都是2字节,并且有-2、-1两个标志位

编码解码代码练习：

package it.heima.io;

import java.io.UnsupportedEncodingException;

public class GbkDemo {
	public static void main(String[] args) throws Exception {
		String s="你好";
		byte[] buf=s.getBytes("UTF-8");
		System.out.println(new String(buf,"GBK"));
		System.out.println(new String(buf,"utf-8"));
	}
}

二、转换流

作用：1、接收一个字节流，返回一个字符流

2、编码/解码

转换流：InputStreamReader和OutputStramWrite

OutputStreamWrite转换流：

构造函数：

OutputStramWrite(InputStream in);

OutputStramWrite(InputStream in,"UTF-8");

成员方法：(Write类)

public void write(int c)

public void write(char[] cbuf)

public void write(char[] cbuf,int off,int len)

public void write(String s)

public void write(String s,int off,int len)

代码练习：

package it.heima.io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

public class OutputSreamReaderDemo {
	public static void main(String[] args) throws IOException {
		OutputStreamWriter outputStreamWriter=new OutputStreamWriter(new FileOutputStream("F:\\d.txt"), "GBK");
		
		//Write类的5种write方法
		outputStreamWriter.write("中");
		outputStreamWriter.write(97);
		
		char[] cbuf={'a','v','a','j'};
		outputStreamWriter.write(cbuf);
		outputStreamWriter.write(cbuf,1,2);
		outputStreamWriter.write("我爱java",2,2);
		outputStreamWriter.close();
	}
}

InputStreamReader:

构造方法：

inputStream(InputStream)

inputStream(InputStream,"utf-8")

成员方法：

int read()

int read(char[] chs)

代码练习：

package it.heima.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

public class OutputSreamReaderDemo {
	public static void main(String[] args) throws IOException {
	
		InputStreamReader inputStreamReader=new InputStreamReader(new FileInputStream("F:\\d.txt"),"GBK");
		int len;
		/*char[] cbuf=new char[1024];
		while((len=inputStreamReader.read(cbuf))!=-1){
			System.out.println(new String(cbuf,0,len));
		}*/
		while((len=inputStreamReader.read())!=-1)
			System.out.print((char)len);
		inputStreamReader.close();
	}
}

三、缓冲字符类

缓冲输入字符流：BufferedReader

成员方法：String readLine()

2个Read（）方法

缓冲输出字符流：BufferedWriter

成员方法：void newLine()

5个write（）方法

用缓冲字符流读写数据代码练习：

package it.heima.io;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class BufferedWriteDemo {
	public static void main(String[] args) throws IOException {
		BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("F:\\a.txt")));
		bufferedWriter.write("中国");
		bufferedWriter.write(97);
		bufferedWriter.write("中国我爱你",2,3);
		char[] cbuf={'是','真','的'};
		bufferedWriter.write(cbuf);
		bufferedWriter.newLine();
		bufferedWriter.write(cbuf,1,2);
		bufferedWriter.close();
		
		BufferedReader bufferedReader=new BufferedReader(new FileReader("F:\\a.txt"));
		String line=null;
		int len;
		char[] rbuf=new char[1024];
		/*while((len=bufferedReader.read(rbuf))!=-1){
			System.out.println(new String(rbuf));
		}*/
		/*while((len=bufferedReader.read())!=-1){
			System.out.print((char)len);
		}*/
		while((line=bufferedReader.readLine())!=null){
			System.out.println(line);
		}
	}
}

四、打印流

字节打印流 PrintStream

字符打印流 PrintWriter

作用：打印任意类型数据进文件。可以传入String、File和Writer。

代码练习：

package it.heima.io;

import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

/*
 * 打印流：
 * 字节打印流	PrintOutputStream
 * 字符打印流	PrintWriter
 * */
public class PrintDemo {
	public static void main(String[] args) throws IOException {
		PrintWriter printWriter=new PrintWriter("F:\\a.txt");//直接传目的地
		//可以直接输入任意类型的
		printWriter.println("hello");
		printWriter.print(true);
		printWriter.print(100);
		printWriter.close();
		//自动刷新
		PrintWriter printWriter2=new PrintWriter(new FileWriter("F:\\b.txt"),true);//也可以传一个Writer
		//只能是println,printf,format这三个才能自动刷新,print不行
		printWriter2.println("hao");
		printWriter2.println(true);
		
		printWriter2.close();//不用来刷新，但还是要释放资源
	}
}

五：合并流SequenceInputStream

SequenceInputStream构造函数：

SequenceInputStream(Enumeraion<? extends InputStream>)

作用：创建一个集合用于存储inputStream，并通过迭代器，将所有输入流的内容都遍历。

这里用2种方法实现：

1、创建Vector集合，并通过调用elements()创建enumeration迭代器

2、创建Arraylist集合，并通过匿名内部类创建enumeration的子类，实现该迭代器的三个方法。可以直接用arraylist的iterator的方法。

练习代码1：

package cm.itcast.hometest;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Vector;

//SequenceInputStream的作用：合并流
//SequenceInputStream的两种构造方法
//SequenceInputStream(FileInputStream f1,FileInputStream f2)
//SequenceInputStream(Enumeration) Enumeration是Vector的迭代器，有两种使用方法
public class SequenceDemo {
	static int num;
	public static void main(String[] args) throws IOException {
		//cutMusic();
		combineMusic();
	}
	/*分割音乐文件步骤：
	 * 创建输入路径
	 * 
	 * 计算分割成几份
	 * 创建输出路径及文件
	 * 
	 * 
	 * */
	
	
	public static void cutMusic() throws IOException{
		File file=new File("F:\\喜欢你.mp3");
		FileInputStream fileInputStream=new FileInputStream(file);

		//计算分割成几份
		long length=file.length();
		
		if(length%(1024*1024)==0){
			num=(int)(length/(1024*1024));
		}else{
			num=(int)(length/(1024*1024))+1;
		}
		
		byte[] buf=new byte[1024*1024];//创建1M的数组
		
		for(int i=0;i<num;i++){
			int len=fileInputStream.read(buf);
			FileOutputStream fileOutputStream=new FileOutputStream("F:\\"+i+".mp3");
			fileOutputStream.write(buf,0,len);	
			fileOutputStream.close();
		}	
		fileInputStream.close();

	}
	
	//合并用SequenceInputStream
	public static void combineMusic() throws IOException{
		File file=new File("F:\\");
		
		Vector<FileInputStream> v1=new Vector<>();
		
		File[] fileList=file.listFiles();
		for(File item:fileList){
			if(item.getName().endsWith(".mp3")){
				v1.add(new FileInputStream(item));
			}
		}
		
		//v1.elements返回一个迭代器
		SequenceInputStream inputStream=new SequenceInputStream(v1.elements());
		
		FileOutputStream fileOutputStream=new FileOutputStream("F:\\喜欢你11.mp3");
	
		int len=0;
		byte[] buf=new byte[1024*1024];
		while((len=inputStream.read(buf))!=-1){
			fileOutputStream.write(buf, 0, len);
		}
		fileOutputStream.close();
		inputStream.close();
	}	
}

练习代码2：

package cm.itcast.hometest;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;



public class SequenceDemo2 {
	public static void main(String[] args) throws IOException {
		//cutMusic();
		combineMusic();
	}

	public static void cutMusic() throws IOException {
		File file = new File("F://1.pdf");
		FileInputStream fileInputStream = new FileInputStream(file);

		// 计算分割数
		long size = file.length();
		int num;
		if (size % (1024 * 1024) == 0) {
			num = (int) (size / (1024 * 1024));
		} else {
			num = (int) (size / (1024 * 1024) + 1);
		}

		int length;
		byte[] buf = new byte[1024 * 1024];
		for (int i = 0; i < num; i++) {
			FileOutputStream fileOutputStream = new FileOutputStream("F:\\" + i + ".mp3");
			length = fileInputStream.read(buf);
			fileOutputStream.write(buf, 0, length);
			fileOutputStream.close();
		}
		fileInputStream.close();
	}

	public static void combineMusic() throws IOException {
		
		File file = new File("F:\\");
		ArrayList<FileInputStream> arrayList = new ArrayList<>();
		File[] files = file.listFiles();

		for (File item : files) {
			if (item.getName().endsWith(".mp3")) {
				FileInputStream fileInputStream=new FileInputStream(item);
				arrayList.add(fileInputStream);
			}
		}
		
		final Iterator<FileInputStream> it=arrayList.iterator();
		SequenceInputStream inputStream = new SequenceInputStream(new Enumeration<InputStream>() {

			@Override
			public boolean hasMoreElements() {
				
				return it.hasNext();
			}

			@Override
			public InputStream nextElement() {
				return it.next();
			}

		

		});
		//这里用mp3会出现一直读一直写的问题，因为我将MP3所有文件都读成输入流了。
		FileOutputStream fileOutputStream=new FileOutputStream("F://100.pdfs");
		byte[] buf=new byte[1024*1024];
		int length=0;
		System.out.println("11111111111111");
		while((length=inputStream.read(buf))!=-1){
			fileOutputStream.write(buf,0,length);
			fileOutputStream.flush();
			//System.out.println(length);
		}
		
		fileOutputStream.close();
		inputStream.close();
	}
}

六、序列化流

ObjectInputStream 反序列化流

ObjectOutputStream 序列化流

对象的序列化：实际就是将一个对象存入到txt文档。

对象的反序列化：实际就是将一个对象从txt文档读出

序列化和反序列化的对象要实现Serializable接口。

Serializable这个接口没有方法。那么这个接口就是一个标记接口。

写入对象：ObjectOutputStream的WriteObject()方法。

读出对象：ObjectInputStream的ReadObject()方法。

序列化注意事项：每个文件只能写入一个对象。

原因：每个对象的序列化都会生成一个private final long serivalVersionUID，在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体（类）的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。而每次反序列化J VM会识别第一个servailVersionUID并跳过。遇到第二个对象的ServailVersionUID时会当做对象读取，读取会有异常。

最好自定义一个private final long servailVersionUID的值。

对象的序列化与反序列化练习代码：

package cn.itcast.enumeration;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;

public class ObjectOutputStreamDemo {
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		/*ArrayList<Person> list=new ArrayList<>();
		Address address=new Address("中国", "广州");
		list.add(new Person("张三", address, 10)); 
		list.add(new Person("李四", address, 20));
		*/
		/*这是写/读一个对象的代码
		 * //创建文件路径
		//FileOutputStream fileOutputStream=new FileOutputStream("F:\\Person.txt");
		
		//FileInputStream fileInputStream=new FileInputStream("F:\\Person.txt");
		//创建工具流
		ObjectOutputStream obj=new ObjectOutputStream(fileOutputStream);
		//ObjectInputStream objIn=new ObjectInputStream(fileInputStream);
		
		//obj.writeObject(list);
		
		ArrayList<Person> nlist=(ArrayList<Person>)objIn.readObject();
		
		System.out.println(nlist);
	}*/
		
		/*写 没问题，读对象时出现异常
		 * Address address=new Address("中国", "广州");
		Person p1=new Person("张三", address, 10);
		Person p2=new Person("李四", address, 20);
		
		FileOutputStream fileOutputStream=new FileOutputStream("F:\\Person.txt");
		
		FileInputStream fileInputStream=new FileInputStream("F:\\Person.txt");
				//创建工具流
		//ObjectOutputStream obj=new ObjectOutputStream(fileOutputStream);
		ObjectInputStream objIn=new ObjectInputStream(fileInputStream);
		//obj.writeObject(p1);
		//obj.writeObject(p2);
				
		Person p=(Person) objIn.readObject();
		System.out.println(p);*/
	}	
		
}

class Person implements Serializable{
	private final long serialVersionUID =10;

	String name;
	Address address;
	int age;
	
	transient int num;
	
	transient String score;
	public Person(String name, Address address, int age) {
		super();
		this.name = name;
		this.address =address;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", address=" + address + ", age=" + age + "]";
	}
	
	

}

class Address implements Serializable{
	String country;
	String city;
	public Address(String country, String city) {
		super();
		this.country = country;
		this.city = city;
	}
	@Override
	public String toString() {
		return "Address [country=" + country + ", city=" + city + "]";
	}
	
	
	
}

七、配置文件Properties

Properties是一个属于MAP体系HashMap的集合。Properties的内容以键值对存在。

通过Properties的setProperties(Stringkey,String value)将对象存入到集合。

通过Properties的store(fileOutputStream,comments)方法可以将集合内容存入进配置文件。

Store（）方法内会调用flush方法

通过Properties的load(InputSream)和load(Reader)可以读取配置文件。

通过Set<Entry<Object,Object>>set=p.entrySet()遍历。

注意：通过字节流和字符流都可以传入properties中的键值对。但是要传入中文的话要用字符流

注意：我的错误：导包时Entry导包错误。

properties的代码练习：

package cm.itcast.hometest;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;

public class PropertiesDemo {
	public static void main(String[] args) throws IOException {
		Properties properties=new Properties();
		properties.setProperty("张三", "100");
		properties.setProperty("李四", "120");
		
/*		字节流中文有乱码，字符流改进
		FileOutputStream out=new FileOutputStream("F:\\1.txt");
		properties.store(out, "conment");
		*/
		
		FileWriter fileWriter=new FileWriter("F:\\1.txt");
		properties.store(fileWriter," comments");
		
		FileReader fileReader=new FileReader("F:\\1.txt");
		properties.load(fileReader);
		//遍历方法一
		/*Set<Entry<Object, Object>> entrys=properties.entrySet();
		for(Entry<Object, Object> entry:entrys){
			System.out.println(entry.getKey());
			System.out.println(entry.getValue());
		}*/
		//遍历方法二
		Set<String> key=properties.stringPropertyNames();
		for(String k:key){
			System.out.println(k);
			System.out.println(properties.getProperty(k));
		}
		
	}
}