java i/o流一个简单又不能不熟悉的类
i/0中的System类的常用方法介绍
1.getProperty（） //获取本机的一些信息，系统的版本
2.Runtime（）
3.execute（）
4. destroy（）
5.thread.sleep（）
class Runtime{
public static void main(String[] args)throwsException
{
/*每个 Java 应用程序都有一个 Runtime 类实例，
*使应用程序能够与其运行的环境相连接。
*可以通过 getRuntime方法获取当前运行时。*/
Runtime s=Runtime.getRuntime();
//s.exec("c:\\cmd.exe");
//返回一个进程
Process p=s.exec("notepad.exeRuntime1.java");
// 在指定的毫秒数内让当前正在执行的线程休眠
Thread.sleep(3000);
//结束线程
p.destroy();
}
}
字符方法
Read Writer
FileReader
FileWriter
BufferedReader .readLine()
BufferedWriter .writer();
————————————————
字节流
InputStream OutputStream
FileInputStream
FileOutputStream
BufferedInputStream .writer()
BufferedOutputStream .read()
IO流常用基类
1.字节流的抽象基类
InputStream OutputStream
2.字符流的抽象基类
Read Writer
注意：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀,用类的功能为前缀名
数据最常见的体现形势是—文件
如：InputStream 的子类FileInputStream
如：Reader的子类FileReader
需求：在硬盘上，创建一个文件并写入一些文字数据
*/
import java.io.*;
class Writer
{
public static voidmain(String[] args) throws IOException
{
//创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件
//而且该文件会被创建到指定目录下，如果该目录下已有同名文件，将被覆盖
FileWriter fw = new FileWriter("demo.txt");
//调用write方法，将字符串写入到流中，不是应以的盘符里面
fw.write("abcde");
//刷新流对象缓冲区的数据，到目盘符
//关闭流对象
fw.close(); /*close()与flush()区别是。close（）关闭流对象之前会自动调用
flush()刷新缓冲 区，而flush（）只是刷新缓冲区，不关闭流对象。*/
}
}
2. 文件续写
import java.io.*;
class reReader
{
public static voidmain(String[] args) throws IOException
{
//传递一个true参数，代表不覆盖已有的文件，并在已有文件后面进行数据续定
FileWriter fw = new FileWriter("demo.txt",true);
//FileWriter从类 java.io.Writer 继承的write方法
fw.write("abc\r\nde"); // \r\n 换行作用（separator（）方法可以实现跨平
台的换行）
//调用的是windows资源，关闭
fw.close();
}
}
100. 文本文件读取方式一
import java.io.*;
class Textreader
{
publicstatic void main(String[] args) throws IOException
{
//创建一个文件读取流对象，和指定名称的文件相关联
//要保证该文件是已经存在的，如果不存在，会发出异常
FileReader fr = new FileReader("demo.txt");
//调用读取流对象的read方法
//read():一次读一个字符，而且会自动往下读
//int ch = fr.read();
//字符在内存当中有自己对应的数字
//读到最后会返回-1，这样我们就可以用-1来判断文件是否读到了末尾
int ch = 0;
while((ch = fr.read())!=-1)
{
System.out.println((char)ch);
}
//另外一种循环
/*
while(true)
{
int ch = fr.read();
if(ch==-1)
break;
System.out.println("ch="+(char)ch);
}
*/
}
}
3.文本文件读取的第二种方式
import java.io.*;
class Var
{
publicstatic void main(String[] args) throws IOException
{
FileReader fr = new FileReader("demo.txt");
//定义一个字符数组，用于存储读到字符
//读read(char[])返回的是读到字符个数
//意思是把1024个字节变成一个数组。当打印第二次时，就会出现-1
// int read(char[] cbuf) 方法
//返回： 读取的字符数，如果已到达流的末尾，则返回 -1
//打印出3，fr.read(buf)打印出来的是 字符数
//sop(fr.read(buf));
//sop(fr.read(buf)); 打印出-1
char[] buf = new char[1024];
int num = 0;
while((num=fr.read(buf))!=-1)
/* String方法
public String(char[] value,
int offset,
int count)分配一个新的 String，它包含来自该字符数组参数的一个子数组的字符。
offset 参数是子数组第一个字符的索引，count 参数指定子数组的长度。
该子数组的内容已被复制；后续对字符数组的修改不会影响新创建的字符串。
参数：
value - 作为字符源的数组。
offset - 初始偏移量。
count - 长度。
*/
{
System.out.println(new String(buf,0,num));
}
fr.close();
}
}
4. 复制文本文件
//将C盘一个文本文件复制到D盘
/*
复制的原理：
其实就是将C盘下的文件数据存储到D盘的一个文件中
步骤：
1.在D盘创建一个文件，用于存储C盘文件中的数据
2.定义读取流和C盘文件关联
3.通过不断的读写完成数据存储
4.关闭资源。
*/
import java.io.*;
class Var
{
public static void main(String[] args) throws IOException
{
copy_1();
copy_2();
}
public static void copy_2()
{
FileWriter fw = null;
FileWriter fr = null;
try
{
fw = new FileWriter("SystemDemo_copy.txt");
fr = new FileReader("SyustemDemo.java");
char[] buf = new char[1024];
int len = 0;
while((len=fr.read(buf))!=-1)
{
fw.write(buf,0,len)
}
}
catch ()
{
throw new RuntimeException ("读写失败");
}
finally
{
if(fr!=null)
try
{
fr.close()
}
catch ()
{
}
if(fw!=null)
try
{
fw.close()
}
catch ()
{
}
}
}
//从C盘读一个字符，就往D盘写一个字符
public static void copy_1() throws IOException
{
//创建目的地
FileWriter fw = new FileWriter("RuntimeDemo_copy.txt");
//与已有文件关联
FileReader fr = new FileReader("RuntimeDemo.java");
int ch = 0;
while((ch = fr.read())!=-1)
{
fw.writer(ch);
}
fw.close();
fr.close();
}
}
5. 写入缓冲区 BufferedWriter
import java.io.*;
class Var
{
public static void main(String[] args) throws IOException
{
//创建一个字符写入流对象
FileWriter fw = new FileWriter("buf.txt");
//为了提高字符写入流效率，加入了缓冲技术
//只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可
BufferedWriter bufw = new BufferedWriter(fw);
bufw.write("abcde");
//记住：只要用到缓冲区，就要记得刷新
bufw.flush();
//其实关闭缓冲区，就是在关闭缓冲区中的流对象
bufw.close() //fw.close()就不用写了
}
}
6. 字符读取流缓冲区 BufferedReader
/*
字符读取流缓冲区
该缓冲区提供了一个一次读一行的方法 readLine 方便于对文本数据的获取
当返回null时，表示读到文件末尾
*/
import java.io.*;
class Var
{
public static void main(String [] args)
{
//创建一个读取流对象和文件相关联
FileReader fr = new FileReader("buf.txt");
//为了提高效率。加入缓冲技术，将字符读取流对象作为参数传递给缓冲对象的构造
函数
BufferedReader bufr = new BufferedReader(fr);
String line = null;
//读取一个文本行果已到达流末尾，则返回 null
while((line = bufr.readLine())!=null)
{
System.out.println(line);
}
bufr.close();
}
}
