第一件 File类
一、File类
a、用于将文件或者文件夹封装成对象
b、方便对文件与文件夹的属性信息进行操作
c、File对象可以作为参数传递给流的构造函数
d、了解File类中的常用方法
二、File对象的创建
a、File f=new File（"a：\\a.txt"）；
b、File f2=new File("C：\\abc","a.txt");//分开的好处是后一个参数能够使用其他对象如string
c、File d=new File("C:\\abc")
File f3=new File(d,"c.txt")
知识点File.seperator是跨平台的分隔符如：File f=new File（"a："+File.seperator+"a.txt"）；
二、File类的常见方法
1、创建
boolean createNewFile();
Boolean mkdir（）：创建文件夹，只能一级文件夹
Boolean mkdirs（）：增加了个就能创建多级文件夹了
2、删除
boolean delete();//删除文件或目录；文件存在返回true，不存在或被执行时，返回false
void deleteOnExit();//程序退出时删除
3、判断
boolean exists();//是否存在。经常用
boolean ifFile();//是否问价
boolean isDirectory；是否文件夹
boolean isHidden（）；是否隐藏文件
boolean isAbsolute（）；是否问价绝对路径
4、获取信息
String getName()//获取文件名
String getPath();//获取问价的相对路径（就是说文件创建时传什么就写什么）
String getParent（）；//获取文件父目录。返回的是绝对路径的父目录。如果获取的是相对路径，返回null，如果相对路径有上一层目录，则返回这个
String getAbsolutePath（）：获取文件的绝对路径
long lastModified（）：返回文件最后一次被修改的时间
long length（）；返回文件长度
boolean rename();有点类似剪切
5、列出文件及文件的过滤器
static File[] listRoots();//列出可用的文件系统根目录
String[] list()//列出单曲所有文件，放回string【】
File[] listFiles()//列出所有文件。返回的是路径
String【】 list（FilenameFilter filter（过滤器））//获取满足过滤器的文件，放回文件数组名
File[] ListFiles(FilenameFilter filter(过滤器))//满足过滤器的文件，返回的是文件路径
一下是使用过滤器寻找一个文件夹内的某类文件的例子：
1 /*练习：获得一个某一文件下的.jpg文件
2 * 思路：1、创建某一个File类，通过一个自定义的函数getJpg找到他的jpg文件；
3 * 2、使用listFiles（new FilenameFilter（）{//复写accept（）}）即可
4 */
5 import java.io.*;
6 public class GetFile {
7 public static void main(String[] args){
8 File file=new File("F:\\tupain");
9 getJpg(file);
10 }
11 //获得一个目录下所有jpg的方法
12 private static void getJpg(File file) {
13 // 传入FilenameFilter匿名内部类，并复写accept方法
14 File[] jfile=file.listFiles(new FilenameFilter() {
15 public boolean accept(File dir, String name) {//复写accpt
16 return name.endsWith(".jpg");
17 }
18 });//注意这个位置
19 for(File f:jfile){
20 System.out.println(f);
21 }
22 }
23 }
四、递归
1、定义：函数类每次循环都调用自身
1 /*
2 * 列出指定目录下文件或文件夹的目录，包括子目录
3 * 阶乘和二进制的递归方法
4 * 思路：
5 * 1、将需要搜索的文件夹使用listFiles后得到file数组
6 * 2、用for循环遍历
7 * 3、当出现不为空（使用ofDirectory（）判断）时，再次调用自身函数
8 * 注：上述调用自身函数的方法称为递归
9 */
10 import java.io.*;
11 public class DiGuiDemo {
12 public static void main(String[] args) {
13 File dir=new File("F:");
14 showDir(dir);
15 }
16 //遍历文件和其子文件
17 private static void showDir(File dir) {
18 System.out.println(dir+""+f);
25 }
26 }
27 // 二进制
28 public static void toBin(int n){
29 if(n>0){
30 toBin(n/2);
31 System.out.println(n%2);
32 }
33 }
34 // 阶乘
35 public static int getX(int n){
36 if(n==1){
37 return 1;
38 }
39 return n*getX(n-1);
40 }
41 }
练习3：
1 /*
2 * 练习题：
3 * 做一个指定目录下的.avi文件的绝对路径，存储到一个文本文件中。
4 * 思路：
5 * 1、对指定目录遍历；
6 * 2、获得递归过程所以的java文件路劲
7 * 3、将这些路径存储到集合
8 * 4、将集合中的数据写入一个文本中；
9 */
10 import java.io.*;
11 import java.util.*;
12 public class JavaFileList {
13 public static void main(String[] args){
14 // 指定目录
15 File dir=new File("F:");
16 // 定义一个list集合，用于存储.java文件的file对象
17 List<File> list=new ArrayList<File>();
18 // 调用获取文件路径方法,最后的list就获得了指定类型的文件路径
19 fileTolist(dir,list);
20 // 指定写入文件
21 File f=new File(dir,"avi大全.txt");
22 // 调用写入文件方法
23 writeTO(f,list);
24 }
25 //将集合中元素写入一个文本文件中
26 private static void writeTO(File f, List<File> list) {
27 BufferedWriter bw=null;
28 try {
29 // 使用字符流缓冲区对象关联写入的文件
30 bw=new BufferedWriter(new FileWriter(f));
31 for( File f0:list ){
32 bw.write(f0.getAbsolutePath());
33 bw.newLine();
34 bw.flush();
35 }
36
37 } catch (IOException e) {
38 throw new RuntimeException("写入文件失败");
39 }
40 finally{
41 try {
42 if(bw!=null)
43 bw.close();
44 } catch (IOException e2) {
45
46 }
47 }
48 }
49 //获取指定文件内所有的据对路径
50 private static void fileTolist(File dir, List<File> list) {
51 File[] files=dir.listFiles();//列出dir的目录
52 // 开始遍历
53 for(File f:files){
54 // 如果是非隐藏的且在目录内的继续
55 if(!(f.isHidden())&&f.isDirectory()){
56 fileTolist(f,list);
57 }else if(f.getName().endsWith(".avi")||f.getName().endsWith(".mov")){
58 list.add(f);
59 }
60 }
61 }
62 }
第二讲 Properties
一 概述
1、Properties是Hashtable的子类，它具备Map集合的特点，而且他里面还有存储的键值对，都是字符串，没泛型定义。是集合中和IO计算相结合的集合内容
2、特点
1）可以用于键值对形式的配置文件
2）在加载时，需要数据有固定的格式，常用的是键=值
二、特有方法
1、设置
Object setProperty(String key,String value)；//设置键和值，调用Hashtable的方法put
2、获取
String getProperty（String key）;//指定key得到value
Set<String> stringPropertyName();//返回属性列表的键集，存入Set集合
3、加载流和存入流
void load(InputStream ism);//从输入字节流中读取属性列表（键和元素对）。
1 /*
2 * 练习：要做一个软件有一定运行次数限制的注册软件
3 *
4 * 分析：由于需要每一次软件开关与关闭时该注册列表都保存有，所以需要使用io技术+键值对形式存储
5 * map+io====properties
6 * 思路：1、需要封装一个file文件用于判断原来的配置文件
7 * 2、使用集合properties为存储容易存储配置信息；分别用FileInputStream和FileOutputStream流
8 * 来传输信息
9 * 3、每运行一次，使用计数器count增加一次，最后通过判断
10 * 关键语句：porperties：load（）用于读取缓冲流信息 getProperty（key）：由键得值
11 * store（写入缓冲流对象，备注）
12 * Integer.parseInt()获得字符型变int型
13 * FileInputStream和FileOutputStream这里信息少不需要增强
14 */
15 import java.io.*;
16 import java.util.*;
17 public class RunCout {
18 public static void main(String[] args) throws IOException{
19 Properties prop=new Properties();//创建一个存放键值对的集合
20
21 File file=new File("D\\count.ini");//建立一个封装用的文件。后缀为ini
22
23 if(!file.exists()){//判断是否存在
24 file.createNewFile();
25 }
26 // 非存文本，硬盘里所以用FileInputStream读取
27 FileInputStream fis=new FileInputStream(file);
28 prop.load(fis);//集合读取的是缓冲流信息
29 int count=0;
30 String value=prop.getProperty("time");//由键读值，这个time应该是默认就有的
31 if(value!=null){
32 count=Integer.parseInt(value);//count获得value的信息
33 if(count>=5){
34 System.out.println("此路是我开，拿钱");
35 return;
36 }
37 }
38 count++;
39 prop.setProperty("time", "count");//设置一下time=count
40 // 至此prop集合已经设置好，只需要传进列表中需要FileOutputStream,传入源的file中
41 FileOutputStream fos=new FileOutputStream(file);
42 prop.store(fos, "");//
43 // 关流
44 fis.close();
45 fos.close();
46 }
47 }
第三讲 打印流
1|打印流：该流提供打印数据，将各个类型的数据原样打印
2、字节打印流：PrintStream
1、File对象。File
2、字符串路径：String
3、字节输出流：OutputStream
2、字节打印流：PrintWriter
1、File对象。File
2、字符串路径：String
3、字节输出流：OutputStream
4、多一个：字符输出流：writer
举个字符流的例子：
import java.io.*;
public class PrintStreamDemo {
public static void main(String[] args)throws IOException{
// 键盘录入
BufferedReader br=
new BufferedReader(new InputStreamReader(System.in));
// 使用打印流并关联文件
File file=new File("D:\\a.txt");
PrintWriter pw=new PrintWriter(new FileWriter(file),true);//true的刷新只针对流而已的
// 所以true前面的参数需要new一个FileWriter对象
String line=null;
while((line=br.readLine())!=null){
if(line.equals("over")){
System.out.println("程序结束");
break;
}
pw.println(line.toUpperCase());//大写输出
// pw.flush；由于前面prinyWriter（，true）所以不需要刷新
}
br.close();
pw.close();
}
}
总结：打印流很屌，可以多运用下~
第四讲 序列流
概述：
1、打印流SequenceInputStream，也称合并流，就是把多个流合并
2、常用构造函数：
SequenceInputStream(Enumeration<?extends FileInputStream> e);
常见合并多个流的步骤
1、创建Vector集合，将对象文件添加
2、创建Enumeration对象，将集合元素加入
3、创建SequenceInputStream对象，合并枚举对象
4、输出写入流相关联文件
5、数组缓冲读取法读取
1 /*合并流：SequenceINputStream
2 * 需求：将三个文本合并为一个
3 * 思路：
4 * 1、创建一个Vector集合（由于只能用枚举（Enumeration）），用于三个流添加到集合
5 * 2、创建Enumeration，创建SequenceInputStream对象关联Enumeration
6 * 3、输出流关联新文本
7 * 4、反复读写操作
8 * 关键字：Enumeration需要Vector集合
9 *
10 */
11 import java.util.*;
12 import java.io.*;
13 public class SequenInputDemo {
14 public static void main(String[] args) throws IOException{
15 Vector<FileInputStream> ve=new Vector<FileInputStream>();//创建几个智能方法InputStream流
16 ve.add(new FileInputStream("D:\\11.txt"));
17 ve.add(new FileInputStream("D:\\22.txt"));
18 ve.add(new FileInputStream("D:\\合并.txt"));
19
20 Enumeration<FileInputStream> en=ve.elements();//创建en枚举ve
21 // 合并流合并en
22 SequenceInputStream sis=new SequenceInputStream(en);
23 // 关联被写入的文件
24 FileOutputStream fos=new FileOutputStream("D:\\合并2.txt");
25 // 开始写了
26 byte[] buf=new byte[1024];
27 int len=0;
28 while((len=sis.read(buf))!=-1){
29 fos.write(buf,0,len);//写进fos的FileOutputStream中
30 }
31 fos.close();
32 sis.close();
33 }
34 }
最后一个分几节输送文件的栗子：
1 public class qiegeDemo {
2
3 public static void main(String[] args) throws IOException{
4 // 关联要切割文件，
5 File file=new File("D:\\dog.JPG");
6 int num=mysplit(file);//mysplit方法放回int型代表了分开了num节-1
7 // 合并后的文件
8 File fi=new File("D:\\zz.JPG");
9 myHebin(num,fi);
10 }
11 //开始切啦
12 private static int mysplit(File file) throws IOException {
13 BufferedInputStream bis=
14 new BufferedInputStream(new FileInputStream(file));
15
16 BufferedOutputStream bos=null;//由于要多次写入所以只定义不new
17
18 byte[] buf=new byte[1024*1024];//一兆
19
20 int len=0,count=1;
21
22 while((len=bis.read(buf))!=-1){
23 // 没满一兆就写入一个新文件,注意每次改名字后缀名随便取
24 bos=new BufferedOutputStream(new FileOutputStream("D:\\22\\"+(count++)+".part"));
25 bos.write(buf,0,len);
26 bos.close();//每次关闭
27 }
28 bis.close();
29 return count;
30 }
31 public static void myHebin(int num,File file)throws IOException
32 {
33 // 使用ArrayList
34 ArrayList<FileInputStream> al=new ArrayList<FileInputStream>();
35 for(int x=1;x<num;x++){
36 al.add(new FileInputStream("D:\\22\\"+x+".part"));
37 }
38 // Enumeration是Vector的特有方法，所以要创建匿名内包内改写
39 ListIterator<FileInputStream> it=al.listIterator();
40 Enumeration<FileInputStream> en=new Enumeration<FileInputStream>() {
41 public FileInputStream nextElement() {
42 return it.next();
43 }
44 @Override
45 public boolean hasMoreElements() {
46 return it.hasNext();
47 }
48 };
49
50 // 关联枚举对象
51 SequenceInputStream sis=new SequenceInputStream(en);
52 // 关联要写入的文件
53 FileOutputStream fos=new FileOutputStream(file);
54
55 // 一下考虑封装一下
56 byte[] buf=new byte[1024*1024];
57 int len=0;
58 while((len=sis.read(buf))!=-1){
59 fos.write(buf,0,len);
60 }
61 sis.close();
62 fos.close();
63 }
64 }