1.读取键盘录入
读取键盘录入。 System.out:对应的是标准输出设备，控制台。
InputStream in= System.in; System.in:对应的标准输入设备：键盘。
需求： 通过键盘录入数据。 当录入一行数据后，就将该行数据进行打印。 如果录入的数据是over，那么停止录入。例:获取键盘录入数据，然后将数据流向显示器，那么显示器就是目的地。 通过System类的setIn，setOut方法对默认设备进行改变。 System.setIn(new FileInputStream(“1.txt”));//将源改成文件1.txt。 System.setOut(new FileOutputStream(“2.txt”));//将目的改成文件2.txt 因为是字节流处理的是文本数据，可以转换成字符流，操作更方便。 BfferedReader bufr = new BufferedReader(new InputStreamReader(System.in)); BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));实现代码：
import java.io.*;
class ReadIn
{
public static void main(String[] args) throws IOException
{
InputStream in = System.in;
StringBuilder sb = new StringBuilder();
while(true)
{
int ch = in.read();
if(ch=='\r')
continue;
if(ch=='\n')
{
String s = sb.toString();
if("over".equals(s))
break;
System.out.println(s.toUpperCase());
sb.delete(0,sb.length());
}
else
sb.append((char)ch);
}
}
}
2.流操作的规律
首先要看流操作对象的源和目的设备
1,
源：键盘录入。
目的：控制台。
2，需求：想把键盘录入的数据存储到一个文件中。
源：键盘。
目的：文件。
3，需求：想要将一个文件的数据打印在控制台上。
源：文件。
目的：控制台。
流操作的基本规律：
最痛苦的就是流对象有很多，不知道该用哪一个。
通过三个明确来完成。
1，明确源和目的。
源：输入流。InputStream Reader
目的：输出流。OutputStream Writer。
2，操作的数据是否是纯文本。
是：字符流。
不是：字节流。
3，当体系明确后，在明确要使用哪个具体的对象。
通过设备来进行区分：
源设备：内存，硬盘。键盘
目的设备：内存，硬盘，控制台。
1，将一个文本文件中数据存储到另一个文件中。复制文件。
源：因为是源，所以使用读取流。InputStream Reader
是不是操作文本文件。
是！这时就可以选择Reader
这样体系就明确了。
接下来明确要使用该体系中的哪个对象。
明确设备：硬盘。上一个文件。
Reader体系中可以操作文件的对象是 FileReader
是否需要提高效率：是！。加入Reader体系中缓冲区 BufferedReader.
FileReader fr = new FileReader("a.txt");
BufferedReader bufr = new BufferedReader(fr);
目的：OutputStream Writer
是否是纯文本。
是！Writer。
设备：硬盘，一个文件。
Writer体系中可以操作文件的对象FileWriter。
是否需要提高效率：是！。加入Writer体系中缓冲区 BufferedWriter
FileWriter fw = new FileWriter("b.txt");
BufferedWriter bufw = new BufferedWriter(fw);
三个明确很重要，这样才能在复杂的IO类中，轻松的找到你要使用的 方法和对象
---------------------------------------
2，需求：将键盘录入的数据保存到一个文件中。
这个需求中有源和目的都存在。
那么分别分析
源：InputStream Reader
是不是纯文本？是！Reader
设备：键盘。对应的对象是System.in.
不是选择Reader吗？System.in对应的不是字节流吗？
为了操作键盘的文本数据方便。转成字符流按照字符串操作是最方便的。
所以既然明确了Reader，那么就将System.in转换成Reader。
用了Reader体系中转换流,InputStreamReader
InputStreamReader isr = new InputStreamReader(System.in);
需要提高效率吗？需要！BufferedReader
BufferedReader bufr = new BufferedReader(isr);
目的：OutputStream Writer
是否是存文本？是！Writer。
设备：硬盘。一个文件。使用 FileWriter。
FileWriter fw = new FileWriter("c.txt");
需要提高效率吗？需要。
BufferedWriter bufw = new BufferedWriter(fw);
**************
扩展一下，想要把录入的数据按照指定的编码表（utf-8），将数据存到文件中。
目的：OutputStream Writer
是否是存文本？是！Writer。
设备：硬盘。一个文件。使用 FileWriter。
但是FileWriter是使用的默认编码表。GBK.
但是存储时，需要加入指定编码表utf-8。而指定的编码表只有转换流可以指定。
所以要使用的对象是OutputStreamWriter。
而该转换流对象要接收一个字节输出流。而且还可以操作的文件的字节输出流。FileOutputStream
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");
需要高效吗？需要。
BufferedWriter bufw = new BufferedWriter(osw);
所以，记住。转换流什么使用。字符和字节之间的桥梁，通常，涉及到字符编码转换时，
//键盘的最常见写法。
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));需要用到转换流。例子：将一个文本数据打印在控制台上。要按照以上格式自己完成三个明确。
class TransStreamDemo2
{
public static void main(String[] args) throws IOException
{
System.setIn(new FileInputStream("PersonDemo.java"));
System.setOut(new PrintStream("zzz.txt"));
//键盘的最常见写法。
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();
}
bufr.close();
}
}
3.File类
3.1 概念与方法
用来将文件或者文件夹封装成对象
方便对文件与文件夹的属性信息进行操作。
File对象可以作为参数传递给流的构造函数
方便对文件与文件夹的属性信息进行操作。
File对象可以作为参数传递给流的构造函数
File类常见方法： 1，创建。 boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。 和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。 boolean mkdir():创建文件夹。 boolean mkdirs():创建多级文件夹。 2，删除。 boolean delete()：删除失败返回false。如果文件正在被使用，则删除不了返回falsel。 void deleteOnExit();在程序退出时删除指定文件。 3，判断。 boolean exists() :文件是否存在. isFile(): isDirectory(); isHidden(); isAbsolute(); ，获取信息。 getName(): getPath(): getParent(): getAbsolutePath() long lastModified() long length()
class FileDemo
{
public static void main(String[] args) throws IOException
{
method_5();
}
public static void method_5()
{
File f1 = new File("c:\\Test.java");
File f2 = new File("d:\\hahah.java");
sop("rename:"+f2.renameTo(f1));
}
public static void method_4()
{
File f = new File("file.txt");
sop("path:"+f.getPath());
sop("abspath:"+f.getAbsolutePath());
sop("parent:"+f.getParent());//该方法返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。
//如果相对路径中有上一层目录那么该目录就是返回结果。
}
public static void method_3()throws IOException
{
File f = new File("d:\\java1223\\day20\\file2.txt");
//f.createNewFile();
//f.mkdir();
//记住在判断文件对象是否是文件或者目的时，必须要先判断该文件对象封装的内容是否存在。
//通过exists判断。
sop("dir:"+f.isDirectory());
sop("file:"+f.isFile());
sop(f.isAbsolute());
}
public static void method_2()
{
File f = new File("file.txt");
//sop("exists:"+f.exists());
//sop("execute:"+f.canExecute());
//创建文件夹
File dir = new File("abc\\kkk\\a\\a\\dd\\ee\\qq\\aaa");
sop("mkdir:"+dir.mkdirs());
}
public static void method_1()throws IOException
{
File f = new File("file.txt");
// sop("create:"+f.createNewFile());
//sop("delete:"+f.delete());
}
//创建File对象
public static void consMethod()
{
//将a.txt封装成file对象。可以将已有的和为出现的文件或者文件夹封装成对象。
File f1 = new File("a.txt");
//
File f2 = new File("c:\\abc","b.txt");
File d = new File("c:\\abc");
File f3 = new File(d,"c.txt");
sop("f1:"+f1);
sop("f2:"+f2);
sop("f3:"+f3);
File f4 = new File("c:"+File.separator+"abc"+File.separator+"zzz"+File.separator+"a.txt");
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
3.2 列出目录文件列表
（1）调用list方法的File对象必须是封装了一个目录，该目录还必须存在
File f = new File("c:\\abc.txt");
String[] names = f.list();
文件名过滤
FilenameFileter接口里面包含一个方法boolean accept（File dir,String name);---.>这个操作要掌握，很重要！！
import java.io.*;
class FileDemo2
{
public static void main(String[] args)
{
File dir = new File("c:\\");
File[] files = dir.listFiles();
for(File f : files)
{
System.out.println(f.getName()+"::"+f.length());
}
}
public static void listDemo_2()
{
File dir = new File("d:\\java1223\\day18");
String[] arr = dir.list(new FilenameFilter()
{
public boolean accept(File dir,String name)
{
// /System.out.println("dir:"+dir+"....name::"+name);
/*
if(name.endsWith(".bmp"))
return true;
else
return false;
*/
return name.endsWith(".bmp");
}
});
System.out.println("len:"+arr.length);
for(String name : arr)
{
System.out.println(name);
}
}
public static void listDemo()
{
File f = new File("c:\\abc.txt");
String[] names = f.list();//调用list方法的file对象必须是封装了一个目录。该目录还必须存在。
for(String name : names)
{
System.out.println(name);
}
}
public static void listRootsDemo()
{
File[] files = File.listRoots();
for(File f : files)
{
System.out.println(f);
}
(2)递归遍历（结合例子发现其实不难，就是自己调用自己）
列出指定目录下文件或者文件夹，包含子目录中的内容。 也就是列出指定目录下所有内容。 因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。 在列出过程中出现的还是目录的话，还可以再次调用本功能。 也就是函数自身调用自身。 这种表现形式，或者编程手法，称为递归。 递归要注意： 1，限定条件。 2，要注意递归的次数。尽量避免内存溢出。
import java.io.*; class FileDemo3 { public static void main(String[] args) { File dir = new File("d:\\testdir"); //showDir(dir,0); //toBin(6); //int n = getSum(8000); //System.out.println("n="+n); System.out.println(dir.delete()); } public static String getLevel(int level) { StringBuilder sb = new StringBuilder(); sb.append("|--"); for(int x=0; x<level; x++) { //sb.append("|--"); sb.insert(0,"| "); } return sb.toString(); } public static void showDir(File dir,int level) { System.out.println(getLevel(level)+dir.getName()); level++; File[] files = dir.listFiles(); for(int x=0; x<files.length; x++) { if(files[x].isDirectory()) showDir(files[x],level); else System.out.println(getLevel(level)+files[x]); } } //递归原理，二进制表现形式 public static int getSum(int n) { if(n==1) return 1; return n+getSum(n-1); } public static void toBin(int num) { if(num>0) { toBin(num/2); System.out.println(num%2); } } public static void method() { method(); } }
（3）改变文件后缀名
package com.itheima;
/**
* 9、 编写一个程序，将d:\java 目录下的所有.java 文件复制到d:\jad 目录下，并将原来文件的扩展名从.java 改为.jad。
*/
import java.io.*;
public class Text9 {
public static void main(String[] args) throws Exception {
//对文件路径封装为一个File对象
File srcDir = new File("d:\\java");
//对给出的文件路径进行判断，若不存在则抛出异常
if(!(srcDir.exists() && srcDir.isDirectory()))
throw new Exception("此目录不存在");
//对文件路径中的文件进行遍历，过滤出以java结尾的文件
File[] files = srcDir.listFiles(
//传一个匿名内部类
new FilenameFilter(){
//覆盖接口中的accept方法
public boolean accept(File dir, String name) {
//接收以java结尾的文件 ，以返回值为准作为accept的原理
return name.endsWith(".java");
}
}
);
//创建一个文件夹对象
File destDir = new File("d:\\jad");
//如果存在此目录，就创建此路径名指定的目录。
if(!destDir.exists()) destDir.mkdir();
//对文件遍历，将遍历到的文件读入到输入流中
for(File f :files){
FileInputStream fis = new FileInputStream(f);
//将此目录下的java文件替换为jad文件
String destFileName = f.getName().replaceAll(".java$", ".jad");
//输出流，将得到的文件输出
FileOutputStream fos = new FileOutputStream(new File(destDir,destFileName));
//复制动作，文件的内容进行复制
copy(fis,fos);
//关闭流操作
fis.close();
fos.close();
}
}
//复制方法
private static void copy(InputStream ips,OutputStream ops) throws Exception{
int len = 0;
//定义一个大小为1024的数组来接受数据，作为输入输出流的桥梁
byte[] buf = new byte[1024];
while((len = ips.read(buf)) != -1){
ops.write(buf,0,len);
}
}
}
4 properties类
Properties是hashtable的子类。
也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。
是集合中和IO技术相结合的集合容器。
该对象的特点：可以用于键值对形式的配置文件。
那么在加载数据时，需要数据有固定格式：键=值。
//演示，如何将流中的数据存储到集合中。
//想要将info.txt中键值数据存到集合中进行操作。
/*
1,用一个流和info.txt文件关联。
2，读取一行数据，将该行数据用"="进行切割。
3，等号左边作为键，右边作为值。存入到Properties集合中即可。
*/
public static void method_1()throws IOException
{
BufferedReader bufr = new BufferedReader(new FileReader("info.txt"));
String line = null;
Properties prop = new Properties();
while((line=bufr.readLine())!=null)
{
String[] arr = line.split("=");
///System.out.println(arr[0]+"...."+arr[1]);
prop.setProperty(arr[0],arr[1]);
}
bufr.close();
System.out.println(prop);
}
扫一扫
16万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
