IO流
IO流之数据流
在IO流中,可以通过DataInputStream和DataOutputStream字节流直接操作基本数据类型和字符串
- DataOutputStream
import java.io.*;
//TODO 数据流,简单的说,就是容许字节流直接操作基本数据类型和字符串。
public class DataInputStream_DataOutputStream {
public static void main(String[] args) throws IOException {
String dataPath = "D:\\price.data";// 数据源
DataOutputStream outputStream = null;
try {//向文件中存数据
//String[] rosterArray = { "张三", "李四", "王五", "薛六" }; double[] priceArray = { 5.2, 7.3, 1.5, 6.7, 8.0 };// 单价
outputStream = new DataOutputStream(
new BufferedOutputStream(
new FileOutputStream(dataPath)));
for (int i = 0; i < priceArray.length; i++) {
// 以与机器无关方式使用 UTF-8 修改版编码将一个字符串写入数据输出流。
//outputStream.writeUTF(rosterArray[i]);
outputStream.writeDouble(priceArray[i]); //字符变成字节存进去;
System.out.println("单价为:"+outputStream.toString());
}
} finally {
if(outputStream!=null){
outputStream.close();
}
}
DataInputStream inputStream = null;
try {//从文件中读数据
inputStream = new DataInputStream(
new BufferedInputStream(new FileInputStream(dataPath)));
while (true) {
//String name = inputStream.readUTF();
double price = inputStream.readDouble();//字节变成字符输出来
System.out.println("单价为:"+price);
}
} catch (EOFException e) {
System.out.println("数据读取完毕......");
}finally {
if(inputStream!=null){
inputStream.close();
}
}
}
}
IO流之打印流
Java.io.outputstream.PrintStream:
字节打印流,字符打印流
1:提供了更多的功能,比如打印方法。可以直接打印任意类型的数据。
2:它有一个自动刷新机制,创建该对象,指定参数,对于指定方法可以自动刷新。
3:它使用的本机默认的字符编码.
4:该流的print方法不抛出IOException。
该对象的构造函数。
PrintStream(File file) :创建具有指定文件且不带自动行刷新的新打印流。
PrintStream(File file, String csn) :创建具有指定文件名称和字符集且不带自动行刷新的新打印流。
PrintStream(OutputStream out) :创建新的打印流。
PrintStream(OutputStream out, boolean autoFlush) :创建新的打印流。
PrintStream(OutputStream out, boolean autoFlush, String encoding) :创建新的打印流。
PrintStream(String fileName) :创建具有指定文件名称且不带自动行刷新的新打印流。
PrintStream(String fileName, String csn)
PrintStream可以操作目的:
1:File对象。2:字符串路径。3:字节输出流。
前两个都JDK1.5版本才出现。而且在操作文本文件时,可指定字符编码了。
当目的是一个字节输出流时,如果使用的println方法,可以在printStream对象上加入一个true参数。这样对于println方法可以进行自动的刷新,而不是等待缓冲区满了再刷新。最终print方法都将具体的数据转成字符串,而且都对IO异常进行了内部处理。
既然操作的数据都转成了字符串,那么使用PrintWriter更好一些。因为PrintWrite是字符流的子类,可以直接操作字符数据,同时也可以指定具体的编码。
PrintWriter:具备了PrintStream的特点同时,还有自身特点:
该对象的目的地有四个:
1:File对象。
2:字符串路径。
3:字节输出流。
4:字符输出流。
开发时尽量使用PrintWriter。
方法中直接操作文件的第二参数是编码表。
直接操作输出流的,第二参数是自动刷新。
读取键盘录入将数据转成大写显示在控制台.
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));//源:键盘输入
//目的:把数据写到文件中,还想自动刷新。设置true后自动刷新
PrintWriter out = new PrintWriter(new FileWriter("out.txt"),true);
String line = null;
while((line=bufr.readLine())!=null){
if("over".equals(line))
break;
out.println(line.toUpperCase());//转大写输出
}
//注意:System.in,System.out这两个标准的输入输出流,在jvm启动时已经存在了。
//随时可以使用。当jvm结束了,这两个流就结束了。但是,当使用了显示的close方法关闭时,这两个流在提前结束了。
out.close();
bufr.close();
复制文本文件
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
PrintWriter pw = new PrintWriter(new FileWriter("b.txt"),true);
String line = null;
while((line=br.readLine())!=null) {
pw.println(line);
}
pw.close();
br.close();
IO流之转换流
字节流操作中文数据不是特别的方便,所以就出现了转换流. 转换流的作用就是把字节流转换字符流来使用。
转换流特有功能:
转换流可以将字节转成字符,原因在于,将获取到的字节通过查编码表获取到指定对应字符。
转换流的最强功能就是基于 字节流 + 编码表 。没有转换,没有字符流。
发现转换流有一个子类就是操作文件的字符流对象:
|--FileReader
|--FileWrier
想要操作文本文件,必须要进行编码转换,而编码转换动作转换流都完成了。所以操作文件的流对象只要继承自转换流就可以读取一个字符了。
但是子类有一个局限性,就是子类中使用的编码是固定的,是本机默认的编码表,对于简体中文版的系统默认码表是GBK。
FileReader fr = new FileReader("a.txt");
InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"gbk");
以上两句代码功能一致,
如果仅仅使用平台默认码表,就使用FileReader fr = new FileReader("a.txt"); //因为简化。
如果需要制定码表,必须用转换流。
转换流 = 字节流+编码表。
转换流的子类File = 字节流 + 默认编码表。
凡是操作设备上的文本数据,涉及编码转换,必须使用转换流。
InputStreamReader
OutputStreamWriter
IO流中的编码问题
A: OutputStreamWriter
OutputStreamWriter(OutputStream os):默认编码,GBK
OutputStreamWriter(OutputStream os,String charsetName):指定编码。
B: InputStreamReader
InputStreamReader(InputStream is):默认编码,GBK
InputStreamReader(InputStream is,String charsetName):指定编码
C: 编码问题其实很简单
编码只要一致即可
键盘输入
Java使用System.in代表键盘输入,这个输入流是InputStream类的实例,键盘输入的内容一般都是文本内容,能否使用某种方法将其转化成字符输入流?答案是肯定的:InputStreamReader
假设有这样的需求:使用一个输入字符缓冲流读取用户在命令行输入的一行数据。
分析这个需求,首先得知需要用输入字符缓冲流读取数据,我们想到了使用刚才学习的BufferedReader这个类。需要获取的是用户在命令行输入的一行数据,通过之前的学习我们知道,System.in是InputStream类(字节输入流)的静态对象,可以从命令行读取数据字节。现在问题出现了,需要把一个字节流转换成一个字符流,我们可以使用InputStreamReader和OutputStreamWriter这两个类来进行转换
输入一句话到控制台
//记住,只要一读取键盘录入,就用这句话。
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));//输出到控制台
String line = null;
while((line=bufr.readLine())!=null){
if("over".equals(line))
break;
bufw.write(line.toUpperCase());//将输入的字符转成大写字符输出
bufw.newLine();
bufw.flush();
}
bufw.close();
bufr.close();
import java.io.*;
public class StreamToReaderTest {
public static void main(String[] args) {
//以不变应万变。。。。。。。
//假设有这样的需求:使用一个输入字符缓冲流读取用户在命令行输入的一行数据。
//分析这个需求,首先得知需要用输入字符缓冲流读取数据,
//我们想到了使用刚才学习的BufferedReader这个类。
//需要获取的是用户在命令行输入的一行数据,通过之前的学习我们知道,
//System.in是InputStream类(字节输入流)的静态对象,可以从命令行读取数据字节。
//现在问题出现了,需要把一个字节流转换成一个字符流,我们可以使用InputStreamReader
//和OutputStreamWriter这两个类来进行转换
BufferedReader reader = null;
try {
reader = new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入你今天最想说的话:");
String words = reader.readLine();
System.err.println(words);
} catch (IOException e) {
System.out.println(e.getMessage());
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
输入一句话存到一个文档里
import java.io.*;
public class InputStreamReader1 {
public static void main(String[] args) {
//TODO 输入一句话存到一个文档里
BufferedReader Reader = null;
BufferedWriter Writer = null;
try {
Reader = new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入一句话");
FileWriter fileWriter=new FileWriter("F:/ 情人.txt");
Writer = new BufferedWriter(fileWriter);
String validBufferLength = Reader.readLine();
Writer.write(validBufferLength);
Writer.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (Reader != null) {
try {
Reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (Writer != null) {
try {
Writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
IO流之内存操作流
(1)有些时候我们操作完毕后,未必需要产生一个文件,就可以使用内存操作流。
(2)三种
A: ByteArrayInputStream:源:内存 ByteArrayOutputStream:目的:内存。
这两个流对象不涉及底层资源调用,操作的都是内存中数组,所以不需要关闭。
直接操作字节数组就可以了,为什么还要把数组封装到流对象中呢?因为数组本身没有方法,只有一个length属性。为了便于数组的操作,将数组进行封装,对外提供方法操作数组中的元素。
对于数组元素操作无非两种操作:设置(写)和获取(读),而这两操作正好对应流的读写操作。这两个对象就是使用了流的读写思想来操作数组。
- B:CharArrayReader,CharArrayWriter
- C:StringReader,StringWriter
IO流之标准输入输出流
(1)System类下面有这样的两个字段
in 标准输入流
out 标准输出流
(2)三种键盘录入方式
A:main方法的args接收参数
B:System.in通过BufferedReader进行包装
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
C:Scanner
Scanner sc = new Scanner(System.in);
(3)输出语句的原理和如何使用字符流输出数据
A:原理
System.out.println("helloworld");
PrintStream ps = System.out;
ps.println("helloworld");
B:把System.out用字符缓冲流包装一下使用
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
IO流之随机访问流RandomAccessFile:
(1)可以按照文件指针的位置写数据和读数据。
特点:
1:该对象即可读取,又可写入。
2:该对象中的定义了一个大型的byte数组,通过定义指针来操作这个数组。
3:可以通过该对象的getFilePointer()获取指针的位置,通过seek()方法设置指针的位置。
4:该对象操作的源和目的必须是文件。
5:其实该对象内部封装了字节读取流和字节写入流。注意:实现随机访问,最好是数据有规律。
class RandomAccessFileDemo{
public static void main(String[] args) throws IOException{
write();
read();
randomWrite();
}
//随机写入数据,可以实现已有数据的修改。
public static void randomWrite()throws IOException{
RandomAccessFile raf = new RandomAccessFile("random.txt","rw");
raf.seek(8*4);
System.out.println("pos :"+raf.getFilePointer());
raf.write("王武".getBytes());
raf.writeInt(102);
raf.close();
}
public static void read()throws IOException{
RandomAccessFile raf = new RandomAccessFile("random.txt","r");//只读模式。
//指定指针的位置。
raf.seek(8*1);//实现随机读取文件中的数据。注意:数据最好有规律。
System.out.println("pos1 :"+raf.getFilePointer());
byte[] buf = new byte[4];
raf.read(buf);
String name = new String(buf);
int age = raf.readInt();
System.out.println(name+"::"+age);
System.out.println("pos2 :"+raf.getFilePointer());
raf.close();
}
public static void write()throws IOException{
//rw:当这个文件不存在,会创建该文件。当文件已存在,不会创建。所以不会像输出流一样覆盖。
RandomAccessFile raf = new RandomAccessFile("random.txt","rw");//rw读写模式
//往文件中写入人的基本信息,姓名,年龄。
raf.write("张三".getBytes());
raf.writeInt(97);
raf.close();
}
}
IO流之合并流SequenceInputStream:
作用就是将多个读取流合并成一个读取流。实现数据合并。
表示其他输入流的逻辑串联。它从输入流的有序集合开始,并从第一个输入流开始读取,直到到达文件末尾,接着从第二个输入流读取,依次类推,直到到达包含的最后一个输入流的文件末尾为止。
这样做,可以更方便的操作多个读取流,其实这个序列流内部会有一个有序的集合容器,用于存储多个读取流对象。
该对象的构造函数参数是枚举,想要获取枚举,需要有Vector集合,但不高效。需用ArrayList,但ArrayList中没有枚举,只有自己去创建枚举对象。
但是方法怎么实现呢?因为枚举操作的是具体集合中的元素,所以无法具体实现,但是枚举和迭代器是功能一样的,所以,可以用迭代替代枚举。
合并原理:多个读取流对应一个输出流。
切割原理:一个读取流对应多个输出流。
import java.io.*;
import java.util.*;
class SplitFileDemo{
private static final String CFG = ".properties";
private static final String SP = ".part";
public static void main(String[] args) throws IOException{
File file = new File("c:\\0.bmp");
File dir = new File("c:\\partfiles");
meger(dir);
}
//数据的合并。
public static void meger(File dir)throws IOException{
if(!(dir.exists() && dir.isDirectory()))
throw new RuntimeException("指定的目录不存在,或者不是正确的目录");
File[] files = dir.listFiles(new SuffixFilter(CFG));
if(files.length==0)
throw new RuntimeException("扩展名.proerpties的文件不存在");
//获取到配置文件
File config = files[0];
//获取配置文件的信息。
Properties prop = new Properties();
FileInputStream fis = new FileInputStream(config);
prop.load(fis);
String fileName = prop.getProperty("filename");
int partcount = Integer.parseInt(prop.getProperty("partcount"));
//--------------------------
File[] partFiles = dir.listFiles(new SuffixFilter(SP));
if(partFiles.length!=partcount)
throw new RuntimeException("缺少碎片文件");
//---------------------
ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
for(int x=0; x<partcount; x++){
al.add(new FileInputStream(new File(dir,x+SP)));
}
Enumeration<FileInputStream> en = Collections.enumeration(al);
SequenceInputStream sis = new SequenceInputStream(en);
File file = new File(dir,fileName);
FileOutputStream fos = new FileOutputStream(file);
byte[] buf = new byte[1024];
int len = 0;
while((len=sis.read(buf))!=-1){
fos.write(buf,0,len);
}
fos.close();
sis.close();
}
//带有配置信息的数据切割。
public static void splitFile(File file)throws IOException{
//用一个读取流和文件关联。
FileInputStream fis = new FileInputStream(file);
//创建目的地。因为有多个。所以先创建引用。
FileOutputStream fos = null;
//指定碎片的位置。
File dir = new File("c:\\partfiles");
if(!dir.exists())
dir.mkdir();
//碎片文件大小引用。
File f = null;
byte[] buf = new byte[1024*1024];
//因为切割完的文件通常都有规律的。为了简单标记规律使用计数器。
int count = 0;
int len = 0;
while((len=fis.read(buf))!=-1){
f = new File(dir,(count++)+".part");
fos = new FileOutputStream(f);
fos.write(buf,0,len);
fos.close();
}
//碎片文件生成后,还需要定义配置文件记录生成的碎片文件个数。以及被切割文件的名称。
//定义简单的键值信息,可是用Properties。
String filename = file.getName();
Properties prop = new Properties();
prop.setProperty("filename",filename);
prop.setProperty("partcount",count+"");
File config = new File(dir,count+".properties");
fos = new FileOutputStream(config);
prop.store(fos,"");
fos.close();
fis.close();
}
}
class SuffixFilter implements FileFilter{
private String suffix;
SuffixFilter(String suffix){
this.suffix = suffix;
}
public boolean accept(File file){
return file.getName().endsWith(suffix);
}
}
以下介绍IO包中扩展功能的流对象:基本都是装饰设计模式。
IO流之管道流:管道读取流和管道写入流可以像管道一样对接上,管道读取流就可以读取管道写入流写入的数据。
注意:需要加入多线程技术,因为单线程,先执行read,会发生死锁,因为read方法是阻塞式的,没有数据的read方法会让线程等待
public static void main(String[] args) throws IOException{
PipedInputStream pipin = new PipedInputStream();
PipedOutputStream pipout = new PipedOutputStream();
pipin.connect(pipout);
new Thread(new Input(pipin)).start();
new Thread(new Output(pipout)).start();
}
IO流之对象的序列化:
目的:将一个具体的对象进行持久化,写入到硬盘上。
注意:静态数据不能被序列化,因为静态数据不在堆内存中,是存储在静态方法区中。
如何将非静态的数据不进行序列化?用transient 关键字修饰此变量即可。
Serializable:用于启动对象的序列化功能,可以强制让指定类具备序列化功能,该接口中没有成员,这是一个标记接口。这个标记接口用于给序列化类提供UID。这个uid是依据类中的成员的数字签名进行运行获取的。如果不需要自动获取一个uid,可以在类中,手动指定一个名称为serialVersionUID id号。依据编译器的不同,或者对信息的高度敏感性。最好每一个序列化的类都进行手动显示的UID的指定。
import java.io.*;
class ObjectStreamDemo {
public static void main(String[] args) throws Exception{
writeObj();
readObj();
}
public static void readObj()throws Exception{
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));
Object obj = ois.readObject();//读取一个对象。
System.out.println(obj.toString());
}
public static void writeObj()throws IOException{
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));
oos.writeObject(new Person("lisi",25)); //写入一个对象。
oos.close();
}
}
class Person implements Serializable{
private static final long serialVersionUID = 42L;
private transient String name;//用transient修饰后name将不会进行序列化
public int age;
Person(String name,int age){
this.name = name;
this.age = age;
}
public String toString(){
return name+"::"+age;
}
}
IO流之Properties
Java.util.Properties:
一个可以将键值进行持久化存储的对象。Map--Hashtable的子类。
|--Hashtable
|--Properties:用于属性配置文件,键和值都是字符串类型。
特点:1:可以持久化存储数据。2:键值都是字符串。3:一般用于配置文件。
|-- load():将流中的数据加载进集合。
原理:其实就是将读取流和指定文件相关联,并读取一行数据,因为数据是规则的key=value,所以获取一行后,通过 = 对该行数据进行切割,左边就是键,右边就是值,将键、值存储到properties集合中。
|-- store():写入各个项后,刷新输出流。
|-- list():将集合的键值数据列出到指定的目的地。
(1)是一个集合类,Hashtable的子类
(2)特有功能
A:public Object setProperty(String key,String value)
B:public String getProperty(String key)
C:public Set<String> stringPropertyNames()
(3)和IO流结合的方法
把键值对形式的文本文件内容加载到集合中
public void load(Reader reader)
public void load(InputStream inStream)
把集合中的数据存储到文本文件中
public void store(Writer writer,String comments)
public void store(OutputStream out,String comments)
(4)案例:
A:根据给定的文件判断是否有键为"lisi"的,如果有就修改其值为100
B:写一个程序实现控制猜数字小游戏程序不能玩超过5次
.properties配置文件
key-value类型的配置文件:
password=123456
id=dean
读取配置文件
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
public class LoadSample {
private static Properties properties = null;
static {
InputStream fis = null;
properties = new Properties();
try {
//反射
// fis = LoadSample.class.getClassLoader().getResourceAsStream("app.properties");
//读取指定文件夹
fis = new FileInputStream("conf/app.properties");//properties路径
properties.load(fis);
properties.list(System.out);
} catch (IOException e) {
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
}
}
}
}
public static String getProperty(String key) {
return properties.getProperty(key);
}
public static void main(String args[]) throws Exception {
System.out.println("\nThe foo property: " + LoadSample.getProperty("id"));
}
}
内存写入配置文件
//通过list 方法将Properties写入Properties文件,会将文件中的全部覆盖
import java.io.IOException;
import java.io.File;
import java.io.FileInputStream;
import java.io.PrintStream;
import java.util.Properties;
public class Test {
public static void main(String[] args) {
Properties p = new Properties();
p.setProperty("id","dean");
p.setProperty("password","123456");
try{
PrintStream fW = new PrintStream(new File("conf/app.properties"));
p.list(fW );
System.out.println("jieshu");
} catch (IOException e) {
e.printStackTrace();
}
}
}
XML方法:
Xml文件
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
<comment>Hi</comment>
<entry key="foo">bar</entry>
<entry key="fu">baz</entry>
</properties>
读取配置文件
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
public class LoadSampleXML {
private static Properties properties = null;
static {
InputStream fis = null;
properties = new Properties();
try {
//反射
// fis = LoadSample.class.getClassLoader().getResourceAsStream("NewFile.xml");
//读取指定文件夹
fis = new FileInputStream("conf/NewFile.xml");//properties路径
properties.load(fis);
properties.list(System.out);
} catch (IOException e) {
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
}
}
}
}
public static String getProperty(String key) {
return properties.getProperty(key);
}
public static void main(String args[]) throws Exception {
System.out.println("\nThe foo property: " + LoadSample.getProperty("id"));
}
}
内存写入配置文件
import java.io.IOException;
import java.io.File;
import java.io.FileInputStream;
import java.io.PrintStream;
import java.util.Properties;
public class TestXml {
public static void main(String[] args) {
Properties p = new Properties();
p.setProperty("id","dean");
p.setProperty("password","123456");
try{
PrintStream fW = new PrintStream(new File("NewFile.xml"));
p.storeToXML(fW,"test");
System.out.println("结束");
} catch (IOException e) {
e.printStackTrace();
}
}
}
递归:
就是函数自身调用自身。
什么时候用递归呢?
当一个功能被重复使用,而每一次使用该功能时的参数不确定,都由上次的功能元素结果来确定。
简单说:功能内部又用到该功能,但是传递的参数值不确定。(每次功能参与运算的未知内容不确定)。
递归的注意事项:
1:一定要定义递归的条件。
2:递归的次数不要过多。容易出现 StackOverflowError 栈内存溢出错误。
其实递归就是在栈内存中不断的加载同一个函数。
A:要有出口,否则就是死递归
B:次数不能过多,否则内存溢出
C:构造方法不能递归使用