例: 关于键盘录入
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);
}
}
}