例: 关于键盘录入

package day22;

import java.io.IOException;

import java.io.InputStream;

public class ReadKey {

/**

* 关于键盘录入。

*/

public static void main(String[] args) throws IOException {

//readKey();

readKey2();

}

public static void readKey() throws IOException {

/*

* 需求：读取一个键盘录入的数据，并打印出来。

* 键盘本身就是一个标准的输入设备，java对于这种输入设备都有对应的对象。

*/

InputStream in=System.in;

int ch=in.read();           //阻塞式方法。

System.out.println(ch);     //这个流不需要关闭，关了就再也启动不了了。

//默认输入流和输出流不需要关闭。

}

private static void readKey2() throws IOException {

/*

* 获取用户键盘录入的数据并变成大写输出。

* 如果用户输入over，结束键盘录入。

*

* 思路：

* 1.因为键盘录入只读取一个字节，要判断是否是over，要先将读到的字节拼成字符串。

* 2.那就需要一个容器。StringBuilder比较合适。

* 3.在用户回车之前将录入的数据变成字符串判断即可。

*/

//1.创建容器

StringBuilder sb=new StringBuilder();

//2.获取键盘读取流

InputStream in=System.in;

//3.定义变量记录读取到的字节，并循环获取。

int ch=0;

while((ch=in.read())!=-1){

//在存储之前判断是否是换行标记，因为换行标记不存储。

if(ch=='\r')

continue;

if(ch=='\n'){

String temp=sb.toString();

if("over".equals(temp))

break;

System.out.println(temp.toUpperCase());

sb.delete(0, sb.length());           //这句是清空，否则就会把上一次的数据和这一次的数据一块输出。

}

//将读取到的字节存储到StringBuilder中。

else

sb.append((char)ch);

}

}

}

上面代码一个一个读，然后自己还要考虑换行啥的太麻烦了，就想到了readline()方法，

可是那是字符流的方法，怎么办呢？

这就用到了字符流和字节流之间的转换。

package day22;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

public class TransStreamDemo {

/** 对ReadKey中readKey2()方法的简化。

* 转换流：InputStreamReader,字节流转向字符流的桥梁。

* 相反，OutputStreamWriter,是字符流转向字节流的桥梁。

* @throws IOException

*/

public static void main(String[] args) throws IOException {

/*

InputStream in=System.in;

InputStreamReader isr=new InputStreamReader(in);

BufferedReader bufr=new BufferedReader(isr);

String line=null;

while((line=bufr.readLine())!=null){

if("over".equals(line))

break;

System.out.println(line.toUpperCase());

}

*/

//这句话一定牢记，以后一提到键盘录入就写这句话。其实就是上面注释了的代码的前三句。

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();

}

/* 思考

* 1.需求：将键盘录入的数据写入到一个文件中。

* 还是上面的代码，只将System.out换成文件地址即可。

* 2.需求：将一个文本文件内容显示在控制台上。

* 同理，还是上面的代码，只将System.in换成文件地址就行。

* 3.需求：讲一个文件的内容复制到另一个文件中。

* 把上面的System.out和System.in都换成文件地址就行。

*/

}

}

转换流：

InputStreamReader,字节流转向字符流的桥梁。解码

OutputStreamWriter,是字符流转向字节流的桥梁。编码

流的操作规律：

之所以要弄清楚这个规律，是因为流对象太多，开发时不知道到底要用那个对象合适。

想要知道开发时用到那些对象，只要通过四个明确即可。

1.明确源和目的（汇）

源：InputStream Reader

目的：OutputStream Writer

2.明确数据是否是纯文本数据。

源：是：Reader    否：InputStream

目的：是：Writer  否：OutputStream

3.明确具体的设备。

硬盘：File

键盘：System.in    控制台：System.out

内存：数组

网络：Socket流

4.明确是否需要其他额外功能。

高效（缓冲区）    转换

需求1：复制一个文本文件。

步骤：1.明确源和目的。 都有

2.明确数据是否是纯文本数据。是

3.明确具体的设备。硬盘

FileReader fr=new FileReader("demo.txt");

FileWriter fw=new FileWriter("demo.txt");

4.明确是否需要其他额外功能。NO

需求2：读取键盘录入信息，并写入到一个文件中。

步骤：1.明确源和目的。 都有

2.明确数据是否是纯文本数据。是

3.明确具体的设备。源：键盘    目的：硬盘

InputStream in=System.in;

FileWriter fw=new FileWriter("demo.txt");

这样可以完成，但是麻烦。将读取的字节数据转换成字符串，再由字符流操作。

4.明确是否需要其他额外功能。

是，转换，字节流转成字符流。因为已经明确的源是reader，这样操作文本数据更便捷。

InputStreamReader isr=new InputStreamReader(System.in);

FileWriter fw=new FileWriter("demo.txt");

还要功能吗？  要 ，高效

BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));

FileWriter fw=new BufferedWriter(FileWriter("demo.txt"));

需求3：将文本文件数据显示在控制台上。

BufferedReader bufr=new BufferedReader(new FileReader("demo.txt"));

BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(System.out));

需求4：将键盘录入的数据显示在控制台上

BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));

BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(System.out));

需求5：将一个中文字符串数据"你好"按照指定的编码表"UTF-8"写入到一个文本文件中。

这题的重点在指定的编码表上。中文Windows的默认编码表是gbk。

需求中已经明确了编码表，所以就不能用FileWriter，因为它内部是使用默认的本地编码表。

只能使用其父类OutputStreamWriter。OutputStreamWriter接受一个字节输出流对象，既然是          操作文件，那么该对象应该是FileOutputStream。

package day22;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

public class TransStreamDemo2 {

/**

* 转换流的第二个功能：可以使用指定的编码表编码。FileWriter只能用默认编码表。

* @throws IOException

*/

public static void main(String[] args) throws IOException {

writeText_3();

readText();       //读也得用指定编码表解码，要不就是乱码。

}

public static void readText() throws IOException {

InputStreamReader isr=new InputStreamReader(new FileInputStream("u8_1.txt"),"UTF-8");

char[] buf=new char[10];

int len=isr.read(buf);

String str=new String(buf,0,len);

System.out.println(str);

isr.close();

}

public static void writeText_3() throws IOException{

OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("u8_1.txt"),"UTF-8");

osw.write("你好");

osw.close();

//在属性里可以发现前面两个文件都是4个字节，而这个是6个字节。因为UTF-8编码表中一个汉字3个字节。

}

public static void writeText_2() throws IOException {

OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("gbk_2.txt"),"GBK");

//FileWriter fw=new FileWriter("gbk_1.txt");

/*

* 这两句代码的功能是相同的。

* FileWriter：其实就是转换流指定了本机默认码表的体现。而且这个转换流的子类对象，可以方便操作文本文件。

*   简单说，操作文件的字节流+本机的默认码表。这是按照默认码表操作文件的便捷类。

* 如果操作文件需要明确具体的编码表，FileWriter就不行了，必须用转换流。

*/

osw.write("你好");

osw.close();

}

public static void writeText() throws IOException {

FileWriter fw=new FileWriter("gbk_1.txt");

fw.write("你好");

fw.close();

}

}

什么时候使用转换流呢？、

1.源或者目的对应的设备是字节流，但是操作的却是文本数据，可以使用转换作为桥梁，提高对文本的操作便捷。

2.一旦操作文本涉及到具体的指定编码表时，必须用转换流。

File类

用来将文件或者文件夹封装成对象。方便对文件与文件夹的属性信息进行操作。

File对象可以作为参数传递给流的构造函数。

package day22;

import java.io.File;

import java.io.IOException;

import java.text.DateFormat;

import java.util.Date;

public class FileDemo {

/**

* @param args

* @throws IOException

*/

public static void main(String[] args) throws IOException {

ConstructorDemo();

}

public static void ConstructorDemo() throws IOException {

//可以将一个已存在的，或者不存在的文件或者目录封装成File对象。

File file=new File("E:\\demo.txt");

File file2=new File("E:\\","demo.txt");

File file3=new File("E:"+File.separator+"demo.txt");

System.out.println(file3);

fileMethodDemo();

}

public static void fileMethodDemo() throws IOException {

/*

* File对象的常见方法

* 1.获取

* 1.1 获取文件名称

* 1.2 获取文件路径

* 1.3 获取文件大小

* 1.4 获取文件修改时间

*/

File f=new File("demo.txt");

String name=f.getName();

String abspath=f.getAbsolutePath();         //获取绝对路径

String path=f.getPath(); //获取相对路径

long length=f.length();

long time=f.lastModified();

Date date=new Date(time);

DateFormat dateFormat=DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);

String str_time=dateFormat.format(date);

System.out.println("name"+":"+name);

System.out.println("abspath"+":"+abspath);

System.out.println("path"+":"+path);

System.out.println("length"+":"+length);

System.out.println("str_time"+":"+str_time);

/*

* 2.创建与删除

* boolean

*/

createAndDeleteFile();

}

public static void createAndDeleteFile() throws IOException {

File file=new File("file.txt");

/*

* 和输出流不一样，如果文件不存在，则创建，否则，不创建。

*/

boolean b=file.createNewFile();

System.out.println(b);

boolean b1=file.delete();

System.out.println(b1);

//文件夹的创建与删除。

File dir=new File("abc");

boolean b2=dir.mkdir();

System.out.println(b2);

isDemo();

}

/*

* 3.判断

*/

public static void isDemo(){

File f=new File("abc.txt");

boolean b=f.exists();

System.out.println(b);

//最好先判断是否存在。

System.out.println(f.isFile());

System.out.println(f.isDirectory());

renameToDemo();

}

/*

* 4.重命名

*/

public static void renameToDemo(){

File f1=new File("demo.txt");

File f2=new File("Abc.txt");

f2.renameTo(f1);

}

}

过滤器的演示：

package day22;

import java.io.File;

import java.io.FilenameFilter;

public class FilterByJava implements FilenameFilter {

//java文件过滤器

public boolean accept(File dir, String name) {

return name.endsWith(".java");

}

}

package day22;

import java.io.File;

import java.io.FilenameFilter;

public class SuffixFilter implements FilenameFilter {

//文件后缀名过滤器

private String suffix;

public SuffixFilter(String suffix){

super();

this.suffix=suffix;

}

public boolean accept(File dir, String name) {

return name.endsWith(suffix);

}

}

package day22;

import java.io.File;

import java.io.FileFilter;

public class FilterByHidden implements FileFilter {

//隐藏文件过滤器

public boolean accept(File pathname) {

return !pathname.isHidden();

}

}

package day22;

import java.io.File;

public class FileListDemo {

/**

* @param args

*/

public static void main(String[] args) {

listDemo_4();

}

public static void listDemo_4() {

File dir=new File("e:\\");

File[] files=dir.listFiles(new FilterByHidden());    //过滤掉隐藏文件

for(File file:files){

System.out.println(file);

}

}

public static void listDemo_3() {                        //这个比demo_2方便，传啥过滤啥

File dir=new File("e:\\");

String[] names=dir.list(new SuffixFilter(".java"));   //如果想过滤.txt文件，直接在这传.txt就行，不用去修改过滤器，方便一些。

for(String name:names){

System.out.println(name);

}

}

public static void listDemo_2() {

File dir=new File("e:\\");

String[] names=dir.list(new FilterByJava());         //过滤掉非Java类型的文件

for(String name:names){

System.out.println(name);

}

}

public static void listDem() {

File file=new File("e:\\");

/*

* 获取当前目录下的文件以及文件夹的名称，包含隐藏文件。

* 调用List方法的File对象中封装的必须是目录，否则空指针异常。访问系统级目录也会空指针异常。

* 如果目录存在但是没有内容，会返回一个数组，但是长度为零。

*/

String[] names=file.list();

for(String name:names){

System.out.println(name);

}

}

}