一.File类
- java.io.File类代表系统文件（文件和目录）
- 访问文件属性步骤
（1）创建文件对象
格式：File file=new File(String pathname);
（2）调用方法:操作文件目录的属性（路径，权限，日期和时间等）
- File类的属性(separator默认名称分隔符)
（1）在UNIX系统上，此字段的值为 ’/ ’;在window系统上，它为‘\’
（2）为了程序的跨平台性，文件的路径应该用这个属性值来代表
- File类的常用方法
|
方法名称 |
说明 |
|
Boolean exists() |
判断文件或目录是否存在 |
|
Boolean isFile() |
判读那是否是文件 |
|
Boolean isDirectory（） |
判断是否是目录 |
|
String getName（） |
返回此对象表示的文件或目录的名称 |
|
String getPath（） |
返回此对象的文件相对的路径名 |
|
String getAbsolutePath（） |
返回此对象表示的文件的绝对路径名 |
|
Boolean delete() |
删除此对象指定文件或目录 |
|
Boolean greateNewFile() |
创建名称的空文件，不创建文件夹 |
|
Long.length() |
返回文件的长度，单位为字节，如果文件不存在，则返回0L |
|
Boolean mkdir() |
创建此抽象路径名指定的目录 |
|
Boolean mkdirs() |
创建此抽象路径名指定的目录，包括所必须但不存在的目录 |
|
String[] list() |
返回此目录中的文件名和目录名的数组 |
|
File[] listFiles() |
返回此目录中的文件和目录的File实例数组 |
例1（以上述方法为例）：
package file;
import java.io.*;
public class FileDemo {
public static void main(String[] args) {
File f=new File("e:"+File.separator+"test01");
boolean flag=f.mkdir();
System.out.println(flag?"文件创建成功":"文件创建失败");
System.out.println(f.getPath());
System.out.println(f.getParent());
File f1=new File("e:"+File.separator+"test01"+File.separator+"tset02"+File.separator+"test03");
boolean f0=f1.mkdir();
System.out.println(f0?"文件创建成功":"文件创建失败");
boolean flag1=f1.mkdirs();
System.out.println(flag1?"文件创建成功":"文件创建失败");
System.out.println(f1.getPath());
System.out.println(f1.getParent());
}
}
运行结果为：
文件创建成功
e:\test01
e:\
文件创建失败
文件创建成功
e:\test01\tset02\test03
e:\test01\tset02
例2（同以上述方法为例）：
package file;
import java.io.*;
public class FileMedthDemo {
public static void main(String[] args) {
File f=new File("e:"+File.separator+"test01");
if(f.exists()){
f.delete();
System.out.println("文件以删除~~~");
}else{
try {
f.createNewFile();
System.out.println("文件以创建成功！！！");
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果为：
文件以创建成功！！！
例3（以 listFile（）方法为例，遍历d盘中Licenses目录下的所有文件名）：
package file;
import java.io.File;
public class ListFileDemo {
public static void main(String[] args) {
File f=new File("d:"+File.separator+"Licenses");
File[] files=f.listFiles();
System.out.println("Licenses中的文件个数是："+files.length);
System.out.println("遍历得到的Licenses中所有文件名是：");
for(File fi:files){
System.out.println(fi);
}
}
}
运行结果为：
Licenses中的文件个数是：52
遍历得到的Licenses中所有文件名是：
d:\Licenses\Apache 2.0 License - English.pdf
d:\Licenses\Boost 1.0 License - English.pdf
d:\Licenses\BSD 3-clause License - English.rtf
.................等等（文件太多不全部表示，明白即可）
练习题：递归遍历文件夹（以d盘为例）
package file;
import java.io.File;
public class ShowAllFile {
public static void main(String[] args) {
File f=new File("d:"+File.separator);
showAllFiles(f);
}
public static void showAllFiles(File f){
if(f!=null){
if(f.isDirectory()){ // 是否为目录
File[] files=f.listFiles(); // 返回当前正在遍历的目录中的文件和目录的File实例数组
if(files!=null){
for(File file:files){
showAllFiles(file);
}
}
}else{
System.out.println(f.getPath());
}
}
}
}
运行结果：
d:\workspace\.metadata\.plugins\org.eclipse.core.resources\.history\d5\906a7bc527f9001714258078aa1e333d
d:\workspace\.metadata\.plugins\org.eclipse.core.resources\.history\d6\104a5b0059f8001717a2e0c7060c64aa
d:\workspace\.metadata\.plugins\org.eclipse.core.resources\.history\d6\70bfedd764f8001717a2e0c7060c64aa
d:\workspace\.metadata\.plugins\org.eclipse.core.resources\.history\d7\700032f253fb00171db3c17fb618e481
d:\workspace\.metadata\.plugins\org.eclipse.core.resources\.history\d7\e05b3c1bb3e8001715a0bf823f4db32a
d:\workspace\.metadata\.plugins\org.eclipse.core.resources\.history\da\2014f5fa43f9001714258078aa1e333d
d:\workspace\.metadata\.plugins\org.eclipse.core.resources\.history\da\506eb837d3fd0017115f946708cf4cf7
d:\workspace\.metadata\.plugins\org.eclipse.core.resources\.history\da\806422da5bfc00171659a677f877470f
.......................................等等（文件太多不在此全部显示了）
二．IO流的基本原理
1.数据 流（Stream）是指数据通信的通道
2.java程序中对程序的输入，输出操作是以流的方式进行的。JDK中提供了各种的“流”流类来获取不同种类的数据
文件-----010110101流--------------》程序
文件《----------010100010010流-----程序
网络连接--------01010011001------》程序
文件---010101----》——”java”——> 程序
三.IO流的分类
- 按流向分：
(1)输入流：程序从数据源读取数据的流
(2)输出流：程序向数据原写入数据的流
- 按数据传输单位分：
(1)字节流：以字节为单位传输数据的流
(2)字符流：以字符为单位传输数据的流
- 按功能分：
(1)节点流：用于直接操作目标设备的流
(2)处理流：是对一个已存在的连接和封装，通过对数据的处理为程序提供更为强大，灵活的读写功能
- JDK所提供的所有流类位于javan.io包中，都分别继承以下四种抽象类
|
字节流 |
字符流 |
|
|
输入流 |
InputStream |
Reader |
|
输出流 |
OutputStream |
Writer |
- IO流四个抽象类的重要方法
<1>InputStream:read(xx)读取字节系列方法
<2>OutputStream:writer(xx)写入字节系列方法
<3>Reader:read(xx)读取字符系列方法
<4>Writer:writer(xx)写入字符系列方法
四.文件字节流与文件字符流
- 文件字节流：
FileInputStream和FileOutputStream
- 文件字符流：
FileReader与FileWriter
- FileInputStream类构造方法
(1)FileInputStream(File file)
(2)FileInputStream(String name)
例1（以读取D盘中message.txt文件为例）：
package stream;
import java.io.*;
public class FileInputStreamDemo {
public static void main(String[] args) {
File f=new File("d:"+File.separator+"message.txt");
InputStream input=null;
try {
input=new FileInputStream(f);
byte[] b=new byte[1024];
int len=0;
while((len=input.read(b))!=-1){
System.out.println(new String(b));
}
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
input.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果为：
举办年份|举办地|冠军国
1930|巴拉圭|巴拉圭
1934|意大利|法国
1938|法国|巴西
1942|巴西|巴西
1946|美国|意大利
1952|德国|中国
1956|波兰|瑞士
1960|英国|德国
4.FileOutputStream构造方法
(1)FileOutputStream(File file)
(2)FileOutputStream(String name)
(3)FileOutputStream(String name,boolean append)//追加模式
注意：<1>前两种构造方法在向文件中写入数据时将覆盖文件中原有的内容
<2>创建FileOutputStream实例时，如果相应的文件并不存在，则会自动建成一个空的文件
例（创建一个文件并写入内容）：
package stream;
import java.io.*;
public class FileOutputStreamDemo {
public static void main(String[] args) {
OutputStream output=null;
try {
output=new FileOutputStream("e:"+File.separator+"test03",true);
output.write("×××中央人民政府".getBytes());
output.write("AAFUDSJESG".getBytes());
byte[] b="法兰西第一帝国".getBytes();
output.write(b, 0, 7);
System.out.println("写入成功");
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
output.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果为：
写入成功（如下图片）
5.FileReader类构造方法
(1)FileReader(File file):在给定File从中读取数据的File的情况下创建一个新的FileReader
(2)FileReader(String fileName):在给定从中读取数据数据的文件名的情况下创建一个新的FileReader
例：
package stream;
import java.io.*;
public class FileReaderDemo {
public static void main(String[] args) {
Reader r=null;
try {
r=new FileReader("d:"+File.separator+"test05");
char[] b=new char[1024];
int len=0;
while((len=r.read(b))!=-1){
System.out.println(b);
}
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
r.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果为：
中国acfA123243546×××
6.FileWriter类构造方法：
（1）FileWriter(File file) ：根据给定的 File 对象构造一个 FileWriter 对
（2）FileWriter(File file, boolean append) ：根据给定的 File 对象构造一个 FileWriter 对象。
（3）FileWriter(String fileName) ：根据给定的文件名构造一个 FileWriter 对象。
（4）FileWriter(String fileName, boolean append)：根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。
例：
package stream;
import java.io.*;
public class FileWriterDemo {
public static void main(String[] args) {
Writer wr=null;
try {
wr=new FileWriter("d:"+File.separator+"test05");
wr.write("中国");
char[] b={'a','c','f','A'};
wr.write(b);
wr.write("123243546");
String str="×××";
wr.write(str);
wr.flush();
System.out.println("写入成功~~~");
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
wr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果：写入成功~~~
五.缓冲流
- 缓冲流是处理流的一种，建立在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，还增加了一些新的方法
- JDK提供了四种缓冲流
（1）BufferedInputStream可以对InputStream流进行包装
（2）BuffereedOutputStream可以对任何的OutputStream流进行包装
（4）BufferedReader可以对任何的Reader流进行包装
*还增加了readLine()方法用于一次读取一行字符串
（4）BufferedWriter可以对任何的Writer流进行包装
*新增了方法newLine()用与写出一个行分隔符
- 对于缓冲输出流，写出的数据会缓存在内存缓存区中，关闭此流前要用flush()方法将缓存区中的数据立即写出，关闭缓存流会自动关闭缓存流所包装的所有底层流
例1(以读取d盘中的message.txt文件为例，应用BufferedInputStream缓存流)：
package buffered;
import java.io.*;
public class BufferedInputStreamDemo {
public static void main(String[] args) {
File f=new File("d:"+File.separator+"message.txt");
InputStream input=null;
BufferedInputStream bis=null;
try {
input=new FileInputStream(f);
bis=new BufferedInputStream(input);
byte[] b=new byte[1024];
int len=0;
System.out.println("开始使用缓存流 进行读取：");
while((len=bis.read(b))!=-1){
System.out.println(new String(b));
}
System.out.println("缓存流读取结束~~~");
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
bis.close();
input.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果为：
开始使用缓存流 进行读取：
举办年份|举办地|冠军国
1930|巴拉圭|巴拉圭
1934|意大利|法国
1938|法国|巴西
1942|巴西|巴西
1946|美国|意大利
1952|德国|中国
1956|波兰|瑞士
1960|英国|德国
缓存流读取结束~~~
例2（BuffereedOutputStream缓存流的应用）：
package buffered;
import java.io.*;
public class BufferedOutputStreamDemo {
public static void main(String[] args) {
OutputStream output=null;
BufferedOutputStream bos=null;
try {
output=new FileOutputStream("d:"+File.separator+"test09");
bos=new BufferedOutputStream(output);
bos.write("ABFSHEFEG".getBytes());
bos.flush();
System.out.println("写入成功~~");
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
output.close();
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果为：写入成功~~
例3（BufferedReader缓存流的应用）：
package buffered;
import java.io.*;
public class BufferedReaderDemo {
public static void main(String[] args) {
Reader re=null;
BufferedReader br=null;
int count=0;
try {
re=new FileReader("d:"+File.separator+"message.txt");
br=new BufferedReader(re);
String str="";
while((str=br.readLine())!=null){
count++;
System.out.println(count+" "+str);
}
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
re.close();
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果为：
1 举办年份|举办地|冠军国
2 1930|巴拉圭|巴拉圭
3 1934|意大利|法国
4 1938|法国|巴西
5 1942|巴西|巴西
6 1946|美国|意大利
7 1952|德国|中国
8 1956|波兰|瑞士
9 1960|英国|德国
例4（BufferedWriter缓冲流的应用）：
package buffered;
import java.io.*;
public class BufferedWriterDemo {
public static void main(String[] args) {
Writer wr=null;
BufferedWriter bw=null;
try {
wr=new FileWriter("e:"+File.separator+"test.txt");
bw=new BufferedWriter(wr);
bw.write("\t"+"白日依山尽");
bw.newLine();
bw.write("\t"+"黄河入海流");
bw.newLine();
bw.write("\t"+"欲穷千里目");
bw.newLine();
bw.write("\t"+"更上一层楼");
bw.newLine();
bw.flush();
System.out.println("写入成功");
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
wr.close();
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果为：写入成功
六.转换流
&&：*在IO包中，实际上只有字节流，字符流是在字节流的基础上转换出来的。
*转换流用于在字节流和字符流之间转换。
*JDK提供了两种转换流
1.InputStreamReader:
(1)是Reader的子类，将输入的字节流变为字符流，即：将一个字节流的输入对象变为字符流的输入对象。
(2)InputStreamReader需要和InputStream“套接”，它可以将字节流中读入的字节解码成字符
2.OutputStreamWriter：
(1)是Writer的子类，将输出的字符流变为字节流，即：将一个字符流的输出对象变为字节流的输出对象。
(2)OutputStreamWriter需要和OutputStream“套接”，它可以将要写入字节流的字符编码成字节
3.转换步骤：
（1）写出数据：程序—转换流—>OutputStreamWriter—字节流—>文件
（2）读入数据：程序<—转换流—ItputStreamWriter<—字节流—文件
例1（InputStreamReader转换流）：
package convert;
import java.io.*;
public class InputStreamReaderDemo {
public static void main(String[] args) {
InputStreamReader isr=new InputStreamReader(System.in); // 包装的是读取键盘输入的输入流
BufferedReader br=new BufferedReader(isr); // 将InputStreamReader包装到BufferedReader
System.out.print("请输入：");
try {
String content=br.readLine(); // 读取键盘输入，输入完成之前一直阻塞
System.out.println("您输入的内容是："+content);
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果为：请输入：1但是如果发生过
您输入的内容是：1但是如果发生过
例2（OutputStreamWriter转换流应用）：
package convert;
import java.io.*;
public class OutputStreamWriterDemo {
public static void main(String[] args) {
OutputStream out=null;
OutputStreamWriter osw=null;
BufferedWriter bw=null;
try {
out=new FileOutputStream("e:"+File.separator+"mess.txt");
osw=new OutputStreamWriter(out); // 将out对象包装到OutputStreamWriter对象中
bw=new BufferedWriter(osw); // 将osw对象包装到BufferedWriter对象中
bw.write("hello java");
bw.newLine(); // 换行
bw.write("中国");
System.out.println("写入成功！");
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果为：写入成功！
例3（指定InputStreamReader的编码指定InputStreamReader的编码）
package convert;
import java.io.*;
public class DecodeDemo {
public static void main(String[] args) {
InputStream input=null;
InputStreamReader isr=null;
try {
input=new FileInputStream("c:"+File.separator+"test.txt");
isr=new InputStreamReader(input,"utf-8"); // 指定InputStreamReader的编码
char[] c=new char[1024];
int len=isr.read(c);
System.out.println("读取的内容是："+new String(c,0,len));
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
isr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果为：读取的内容是：?й?acfA123243546?л???????
例4（对OutputStreamWriter设置编码）：
package convert;
import java.io.*;
public class EncodeDemo {
public static void main(String[] args) {
OutputStream out=null;
OutputStreamWriter osw=null;
try {
out=new FileOutputStream("c:"+File.separator+"test.txt");
osw=new OutputStreamWriter(out,"utf-8"); // 对OutputStreamWriter设置编码
osw.write("×××");
osw.flush();
System.out.println("写入成功！");
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
osw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果：写入成功！
七．Properties类补充其属于Hashtable的子类
1.Java中的properties文件是一种配置文件，主要用于表达配置信息，文件类型为*.properties，格式为文本文件，文件中的格式是“键=值”的格式，在properties文件中可以用#来注释。
2.Properties中的重要方法
（1）getProperty(String key),用于指定的键在此列属性表中搜索属性，也就是通过该参数key,得到对应的value值
（2）load(inputStream inStream)从输入流中读取属性列表（键和元素对），通过对指定的文件进行装载来获取该文件中的所有键值对，以供getProperty(String key)方法来搜索
（3）setProperty(String key,String value)调用Hashtable的方法put方法，他通过调用基类的put方法来设置键值对
（4）store（OutputStream out,String comments）以适合使用load方法加载到Properties表中的格式，将此Properties表中的属性列表（键值元素对）写入输入流，与load方法相反,该方法将键值对写入到指定文件中去
（5）clear(),清除所有转载的键值对，该方法是在基类中提供
例1（store（OutputStream out,String comments）方法的应用）：
package properties;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Properties;
public class PropertiesStore {
public static void main(String[] args) {
Properties pro=new Properties();
pro.setProperty("mode","OPEN");
pro.setProperty("isVIP","no");
pro.setProperty("updatetime","20180101");
OutputStream out=null;
try {
out=new FileOutputStream("c:"+File.separator+"myinfo.properties");
pro.store(out,"this is my default information"); // 写入属性文件中
System.out.println("属性文件写入成功！");
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果为：属性文件写入成功！
例2（load(inputStream inStream)应用方法）：
package properties;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
public class PropertiesLoadDemo {
public static void main(String[] args) {
Properties pro=new Properties();
InputStream input=null;
try {
input=new FileInputStream("d:"+File.separator+"myinfo.properties");
pro.load(input); // 从字节流中读取数据加载到Properties中
System.out.println("是否为VIP："+pro.getProperty("isVIP"));
System.out.println("上次更新时间："+pro.getProperty("updatetime"));
System.out.println("应用模式："+pro.getProperty("mode"));
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
input.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果为：是否为VIP：no
上次更新时间：20180101
应用模式：OPEN
练习：
1.要求从键盘输入两个数字，之后完成两个整数的加法操作。
eg: 3回车,5回车--->8,键盘必须输入的是数字。
解析：
package work01;
import java.io.*;
public class SumNumber {
public static void main(String[] args) {
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
System.out.print("请输入加数一：");
try {
String x=br.readLine();
int t=Integer.parseInt(x);
System.out.print("请输入加数二：");
String y=br.readLine();
int h=Integer.parseInt(y);
int temp=(t+h);
System.out.println("加的结果为："+temp);
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
isr.close();
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果为：请输入加数一：3
请输入加数二：6
加的结果为：9
2.先从键盘输入文件名称，再输入内容，根据输入的文件名称创建
文件，并且将内容写入文件。
解析：
package work01;
import java.io.*;
public class TxtDemo {
public static void main(String[] args) {
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
Writer wr=null;
BufferedWriter bw=null;
try {
System.out.print("请输入文件名：");
String txtName=br.readLine();
wr=new FileWriter("d:"+File.separator+txtName,true);
bw=new BufferedWriter(wr);
System.out.print("请输入文件内容：");
String str=br.readLine();
bw.write(str);
bw.flush();
bw.newLine();
String str1=br.readLine();
bw.write(str1);
bw.flush();
bw.newLine();
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
isr.close();
br.close();
bw.close();
wr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果为：请输入文件名：dhdh
请输入文件内容：hyrshdfh
sfdhyfdhj
3.读取message.txt文件，根据文件中的内容查询相应的年份、举办地、冠军国
先给出客户选择提示：通过年份查询1,通过举办地查询2,通过冠军国
查询3,退出0:
若用户选择通过年份查询，则根据输入的年份，查询出当年的举办地和冠军国；
若用户选择通过冠军国查询，则输出该国的举办年份和举办地；
若用户选择通过举办地查询，则输出该举办地的举办年份和冠军国。
解析：
世界杯类：
package wc;
public class WordCup {
private String year;
private String address;
private String winner;
public WordCup() {
super();
}
public WordCup(String year, String address, String winner) {
super();
this.year = year;
this.address = address;
this.winner = winner;
}
public String getYear() {
return year;
}
public void setYear(String year) {
this.year = year;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getWinner() {
return winner;
}
public void setWinner(String winner) {
this.winner = winner;
}
@Override
public String toString() {
return "WordCup [year=" + year + ", address=" + address + ", winner="
+ winner + "]";
}
}
世界杯工具类：
package wc;
import java.io.*;
import java.util.*;
public class WordCupUtil {
private static List<WordCup> list=new ArrayList<>();
static{
File f=new File("d:"+File.separator+"message.txt");
Reader r=null;
BufferedReader br=null;
try {
r=new FileReader(f);
br=new BufferedReader(r);
br.readLine();
String str="";
while((str=br.readLine())!=null){
String[] array=str.split("\\|");
WordCup wc=new WordCup(array[0],array[1],array[2]);
list.add(wc);
}
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
r.close();
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//通过年份查询信息
public static WordCup infoByYear(String year){
for(WordCup wc:list){
if(wc.getYear().equals(year)){
return wc;
}
}
return null;
}
//通过举办地查询信息
public static List<WordCup> infoByAdress(String adress){
List<WordCup> resultlist=new ArrayList<>();
for(WordCup wc:list){
if(wc.getAddress().equals(adress)){
resultlist.add(wc);
}
}
return resultlist;
}
//通过冠军国查询信息
public static List<WordCup> infoByWinner(String winner){
List<WordCup> resultlist=new ArrayList<>();
for(WordCup wc:list){
if(wc.getWinner().equals(winner)){
resultlist.add(wc);
}
}
return resultlist;
}
}
世界杯测试类：
package wc;
import java.io.*;
import java.util.List;
public class TestWc {
public static void main(String[] args) {
WordCupUtil wcu=new WordCupUtil();
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
System.out.println("开始读取文件!!!");
System.out.println("1 通过年份查询信息 2 通过举办地查询信息 3 通过冠军国查询信息 0 退出系统 ");
System.out.print("请输入你的选择：");
try {
String chioce=br.readLine();
switch(chioce){
case "1":
System.out.print("请输入你要查询的年份：");
String year=br.readLine();
WordCup str=wcu.infoByYear(year);
System.out.println("显示查询结果 ：");
System.out.println(str);
break;
case "2":
System.out.print("请输入你要查询的举办地：");
String adress=br.readLine();
List<WordCup> list=wcu.infoByAdress(adress);
System.out.println("显示查询结果：");
for(WordCup wc:list){
System.out.print(wc+"\n");
}
break;
case "3":
System.out.print("请输入你要查询的冠军国：");
String winner=br.readLine();
List<WordCup> list1=wcu.infoByWinner(winner);
System.out.println("显示查询结果：");
for(WordCup wc:list1){
System.out.print(wc+"\n");
}
break;
case "0":
System.out.print("你选择退出系统，正在退出~~~");
System.exit(0);
default:
System.out.println("未找到匹配数据，运行结束！！！");
break;
}
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
isr.close();
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果：
（1）：
开始读取文件!!!
1 通过年份查询信息 2 通过举办地查询信息 3 通过冠军国查询信息 0 退出系统
请输入你的选择：1
请输入你要查询的年份：1930
显示查询结果 ：
WordCup [year=1930, address=乌拉圭, winner=乌拉圭]
（2）
开始读取文件!!!
1 通过年份查询信息 2 通过举办地查询信息 3 通过冠军国查询信息 0 退出系统
请输入你的选择：2
请输入你要查询的举办地：意大利
显示查询结果：
WordCup [year=1934, address=意大利, winner=意大利]
WordCup [year=1990, address=意大利, winner=德国]
（3）
开始读取文件!!!
1 通过年份查询信息 2 通过举办地查询信息 3 通过冠军国查询信息 0 退出系统
请输入你的选择：3
请输入你要查询的冠军国：巴西
显示查询结果：
WordCup [year=1958, address=瑞典, winner=巴西]
WordCup [year=1962, address=智利, winner=巴西]
WordCup [year=1970, address=墨西哥, winner=巴西]
WordCup [year=1994, address=美国, winner=巴西]
WordCup [year=2002, address=韩国和日本, winner=巴西]
（4）
开始读取文件!!!
1 通过年份查询信息 2 通过举办地查询信息 3 通过冠军国查询信息 0 退出系统
请输入你的选择：0
你选择退出系统，正在退出~~~
（5）
开始读取文件!!!
1 通过年份查询信息 2 通过举办地查询信息 3 通过冠军国查询信息 0 退出系统
请输入你的选择：刚好是梵蒂冈
未找到匹配数据，运行结束！！！
4.复制图片练习
解析：
package fileinputstream;
import java.io.*;
public class CopyImage {
public static void main(String[] args) {
File src=new File("d:"+File.separator+"java.png");
File dest=new File("e:"+src.getName());
copy(src,dest);
}
public static void copy(File src,File dest){
InputStream input=null;
FileOutputStream out=null;
try {
input=new FileInputStream(src);
out=new FileOutputStream(dest);
byte[] b=new byte[1024];
int len=0;
try {
while((len=input.read(b))!=-1){
out.write(b, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("图片复制成功~~~");
} catch (FileNotFoundException e) {
e.printStackTrace();
}finally{
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果：图片复制成功~~~
【本次总结完毕】 2018.1.20
原文地址：http://blog.51cto.com/13501268/2063431