import java.io.*
class FileTest
{
public static void main(String[] args)
{
File f = new File("1.txt");
f.createNewFile(); //创建一个文件
f.mkdir(); //创建一个目录
File f = new File("E:\code\java\1.txt"); //使用绝对路径创建
f.createNewFile();
//separator是一个分隔符，解决的不同平台下分隔符不一样的问题
//例如在windows平台下是\ ，而在linux平台下是/
File fd = new File("File.separator"); //创建根目录
String sf = "e:" + File.separator + "code" + File.separator + "1.txt";
File f = new File(fd, sf);
f.createNewFile();
f.delete(); //删除文件
f.deleteOnExit(); //程序退出的时候删除
Thread.sleep(3000);
for(int i=0; i
{
//在默认的临时文件目录创建临时文件,java自动给文件加序号
//createTempFile是静态方法，可以直接访问，创建临时文件
File f = File.createTempFile("wj", ".tmp"); //在默认的临时文件目录创建临时文件,java自动给文件加序号
f.deleteOnExit();
}
Thread.sleep(3000);
//list()返回目录下所有的文件名和子目录名字
//FilenameFilter(),文件名过滤器，实现accept方法
String sf = "e:" + File.separator; + "code" + File.separator + "1.txt";
File f = new File(fd, sf);
f.createNewFile();
String[] names = f.list(new FilenameFilter()
{
public boolean accept(File dir, String name) //accept
{
return name.indexOf(“java”) != -1; //indexOf查找一个子串，不存在返回-1，存在返回索引值
}
});
for(int i=0; i
{
System.out.println(names[i]);
}
}
}
流(Stream)是字节的源或目的。
两种基本的流是：输入流(Input Stream)和输出流(Output Stream)。可从中读出一系列字节的对象称为输入流。而能向其中写入一系列字节的对象称为输出流。
节点流：从特定的地方读写的流类，例如：磁盘或一块内存区域。
过滤流：使用节点流作为输入或输出。过滤流是使用一个已经存在的输入流或输出流连接创建的。
三个基本的读方法：
abstract int read() ：读取一个字节数据，并返回读到的数据，如果返回-1，表示读到了输入流的末尾。
int read(byte[] b) ：将数据读入一个字节数组，同时返回实际读取的字节数。如果返回-1，表示读到了输入流的末尾。
int read(byte[] b, int off, int len) ：将数据读入一个字节数组，同时返回实际读取的字节数。如果返回-1，表示读到了输入流的末尾。off指定在数组b中存放数据的起始偏移位置；len指定读取的最大字节数。
其它方法：
long skip(long n) ：在输入流中跳过n个字节，并返回实际跳过的字节数。
int available() ：返回在不发生阻塞的情况下，可读取的字节数。
void close() ：关闭输入流，释放和这个流相关的系统资源。
void mark(int readlimit) ：在输入流的当前位置放置一个标记，如果读取的字节数多于readlimit设置的值，则流忽略这个标记。
void reset() ：返回到上一个标记。
boolean markSupported() ：测试当前流是否支持mark和reset方法。如果支持，返回true，否则返回false。
三个基本的写方法:
abstract void write(int b) ：往输出流中写入一个字节。
void write(byte[] b) ：往输出流中写入数组b中的所有字节。
void write(byte[] b, int off, int len) ：往输出流中写入数组b中从偏移量off开始的len个字节的数据。
其它方法
void flush() ：刷新输出流，强制缓冲区中的输出字节被写出。
void close() ：关闭输出流，释放和这个流相关的系统资源。
基本的流类：
FileInputStream和FileOutputStream
节点流，用于从文件中读取或往文件中写入字节流。如果在构造FileOutputStream时，文件已经存在，则覆盖这个文件。
BufferedInputStream和BufferedOutputStream
过滤流，需要使用已经存在的节点流来构造，提供带缓冲的读写，提高了读写的效率。
DataInputStream和DataOutputStream
过滤流，需要使用已经存在的节点流来构造，提供了读写Java中的基本数据类型的功能。
PipedInputStream和PipedOutputStream
管道流，用于线程间的通信。一个线程的PipedInputStream对象从另一个线程的PipedOutputStream对象读取输入。要使管道流有用，必须同时构造管道输入流和管道输出流。
import java.io.*;
class StreamTest
{
public static void main(String[] args) throws Exception
{
/*
int data;
while((data=System.in.read()) != -1)
{
System.out.write(data);
}
*/
/*
FileOutputStream fos = new FileOutputStream("1.txt");
//write方法只能写入字节数组，不能操作字符串；通过String类的getBytes方法返回一个字节数组
fos.write("www.baidu.com".getBytes());
fos.close();
BufferedOutputStream bos = new BufferedOutputStream("fos");
bos.write("www.baidu.com".getBytes());
bos.flush(); //刷新缓冲区
DataOutputStream dos = new DataOutputStream(bos);
byte b = 1;
char c = 'a';
dos.writeByte(b);
dos.writeChar(c);
dos.close();
FileInputStream fis = new FileInputStream("1.txt");
byte[] buf = new byte[100];
int len = fis.read(buf);
BufferedInputStream bis = new BufferedInputStream(fis);
int len = bis.read(buf);
//String方法构造一个字符串
System.out.println(new String(buf, 0, len));
DataInputStream dis = new DataInputStream(bis);
System.out.println(dis.readByte());
System.out.println(dis.readChar());
fis.close();
*/
//OutputStreamWriter和InputStreamReader是字节流和字符流直接的桥梁
//BufferedWriter和BufferedReader是操作字符流的类
//OutputStream和InputStream是操作字节流的类
FileOutputStream fos = new FileOutputStream("2.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos);
BufferedWriter bw = new BufferedWriter(osw);
bw.write("www.baidu.com");
FileInputStream fis = new FileInputStream("2.txt");
InputStreamReader isr = new InputStreamReader(fis);
BufferedReader bw = new BufferedReader(isr);
bw.readLine();
}
}