/*
File类，各方法。递归。删除一个带内容的目录。Properties 。记录应用程序运行次数。打印流。切割合并文件。
*/
/*
File类
用来将文件或者文件夹封装成对象。
方便对文件与文件夹的属性信息进行操作
File对象可以作为参数传递给流的构造函数
了解File类中的常用方法
1,创建。
boolean creatNewFile();在指定位置创建文件，如果文件已经存在，
则不创建，返回false.
和输出流不一样，输出流对象一建立就创建文件，而且文件存在会覆盖
File creatTeamFile():创建临时文件.
boolean mkdir();创建一级目录,创建文件夹。
boolean mkdirs();创建多级目录
2。删除
boolean delete();删除失败返回false。
void deleteOnExit();在程序退出时删除指定文件。
3.判断
boolean exists();文件是否存在。
canExecute();能执行？
isDirectory();是否是目录
isFile();是否是文件
isHidden();是否是隐藏文件
f.ifAbsolute()；是否是抽象,是否是绝对路径。
4，获取信息
getName():
getPath();路径
getParent();
getAbsolutePath();//获取绝对路径
lastModified();最后修改时间
long length():文件大小
renameTo:和移动文件差不多啊！
*/
import java.io.*;
class FileDemo
{
public static void main(String[] args) throws IOException
{
method_1();
}
public static void method_5()
{
File f1 = new File("c:\\test.java");
File f2 = new File("c:\\hahaha.java");
sop("rename:"+f1.renameTo(f2));//改名字，成功返回true.可用于复制文件
}
public static void method_4()//获取信息
{
File f = new File("c:\\a.txt");
sop("path:"+f.getPath());//封装是什么路径，获取就是什么
sop("absPath:"+f.getAbsolutePath());//会在相对前加目录,绝对路径
sop("parent"+f.getParent());//没有明确指定，返回空。
//该方法返回的是绝对路径的父目录，如果获取相对路径，返回null.
//如果相对路径有上一级目录，就是返回结果
}
public static void method_3()
{
File f = new File("file.txt");//只关联，没有创建就不存在。
//f.creatNewFile();这里才是创建文件。
//f.mkdir();//这里是创建目录。
//记住在判断文件对象是否是文件或者是目录时，必须
//要先判断该文件对象封装的内容是否存在。exists()
sop("dir:"+f.isDirectory());//1.false，不能用主观判断
sop("file:"+f.isFile());//1.false
sop(f.ifAbsobute());//绝对路径，文件不存在也能判断
}
public static void method_2()//判断
{
File f = new File("file.txt");
sop("exists:"+f.exists());//exists：文件是否存在
//sop("canExecute"+f.canExecute());//文件是否能执行。
File dir = new File("abc\\kkk");
sop("mkdir:"+dir.mkdir());//mkdir()只能创建一级目录。
//mkdirs(),创建多级目录。
}
public static void method_1()throws IOException//创建和删除
{
File f = new File("file.txt");//将file.txt文件封装成file对象
//sop("create:"+f.createNewFile());//创建，创建成功打印true.
sop("delete"+f.delete());//删除成功返回true.如果程序异常，这句就读不到。
//放到finally也可能删不掉，程序可能正在应用。
f.deleteOnExit();//发生异常也没关系。在程序退出时会删除指定文件。
}
public static void consMethod()
{
File f1 = new File("a.txt");//将a.txt文件封装成file对象，这里不会创建。
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.separator是跨平台的分隔符。
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);
}
}
//------------------------------
import java.io.*;
class FileDemo2
{
public static void main(String[] args)
{
//listRootsDemo();
//listDemo();
}
public static void listDemo3()
{
File f = new File("c:\\");
File[] files = f.listFiles();//返回文件和文件对象，实际开发用这个。
for (File f1 : files )
{
System.out.println(f1.getName()+".."+f1.length());
}
}
public static void listDemo2()
{
File dir = new File("d:\\java0217\\day15");
String[] arr = dir.list(new FilenameFilter()//文件名过滤，只拿文件名。
{
public boolean accept(File dir,String name)
{
//通过返回值确定文件是否存在
//dir :上面的目录，name:文件名
/*
if (name.endsWith(".bak"))
{
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:\\");
String[] names = f.list();
//f必须是封装了一个目录，该目录必须存在。
//当f.list,f为一个文件时，数组为空，会发生异常。
for (String name: names)
{
System.out.println(name);//打印文件和文件夹名称，隐藏的也会打印。
}
}
public static void listRootsDemo()
{
File[] files = File.listRoots();//列出机器里的有效盘符
for (File f:files )
{
System.out.println(f);
//System.out.println(f.length());//0。
}
}
}
/*
列出指定目录下文件或者文件夹，包含子目录中的内容
也就是列出指定目录下所有内容
因为目录中还有目录，只要使用同一个列出目录的功能的函数完成
在列出过程中出现的还是目录的话，还可以再次调用本功能
也就是函数自身调用自身
这种表现形式，或者编程手法，称为递归
递归要注意
1。限定条件。。。下一级程序结束的条件
2。要注意递归的次数，尽量避免内存溢出
*/
import java.io.*;
class FileDemo3
{
public static void main(String[] args)
{
File f = new File("d:\\java\\package");
showDir(f,0);
//File f = new File("d:\\java0217");
//showFile(f);
//toBin(6);
//int sum = getSum(10);
//System.out.println(sum);
}
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 f,int level)
{
System.out.println(getLevel(level)+f.getName());
level++;
File[] files = f.listFiles();
for (int x = 0;x<files.length ;x++ )
{
if (files[x].isDirectory())
{
showDir(files[x],level);
}
else
System.out.println(getLevel(level)+f.getName());
}
}
public static int getSum(int i)//演示递归
{
if (i == 1)
{
return 1;
}
else
return i + getSum(i-1);
}
public static void toBin(int i)//演示递归
{
if (i>0)
{
toBin(i/2);
System.out.print(i%2);
}
}
public static void showFile(File f)
{
System.out.println(f);
File[] files = f.listFiles();
for (int x = 0;x<files.length ;x++ )
{
if (files[x].isDirectory())
{
showFile(files[x]);
}
else
System.out.println(files[x]);
}
}
}
/*
删除一个带内容的目录
删除原理：
在window中，删除目录从里面往外删除的。
从里往外删除，就需要用到递归。
*/
import java.io.*;
class RemoveDir
{
public static void main(String[] args)
{
File f = new File("d:\\test");
deldir(f);
}
public static void deldir(File f)
{
File[] files = f.listFiles();
for (int x = 0;x<files.length;x++ )
{
if (files[x].isDirectory())
{
deldir(files[x]);
}
else//不带else，会比较低效，因为是文件夹时已经删过一次了
System.out.println(files[x].toString() +"-:file:-"+files[x].delete());
}
System.out.println(f +" :dir:"+f.delete());
}
}
/*练习题
将一个指定目录下的java文件的绝对路径，存储到一个文本文件中
建立一个java文件列表文件。
1。对指定的目录进行递归
2。递归过程中拿到所有的java文件，存到集合中.
3。遍历集合，将这些文件路径存储到流中
4。将流中的数据写入到一个文件中
*/
import java.io.*;
import java.util.*;
class JavaFileList
{
public static void main(String[] args)throws IOException
{
File f = new File("d:\\java0217");
List<File> list = new ArrayList<File>();
FileToList(f,list);
//System.out.println(list.size());
File dir = new File(f,"info1.txt");
listToFile(list,dir.toString());
}
public static void fileToList(File f,List<File> list)
{
File[] files = f.listFiles();
for (File file:files)
{
if (file.isDirectory())
{
fileToList(file,list);
}
else
{
if (file.getName().endsWith(".java"))
{
list.add(file);
}
}
}
}
public static void listToFile(List<File> list,String name)throws IOException
{
BufferedWriter bufw = null;
try
{
bufw = new BufferedWriter(new FileWriter(name));//自己指定的文件路径name
for (File fi : list)
{
//bufw.write(fi.toString());//???
String path = fi.getAbsolutePath();
bufw.write(path);
bufw.newLine();
bufw.flush();
}
}
catch (IOException e)
{
throw e;
}
finally
{
try
{
if(bufw != null)
bufw.close();
}
catch (IOException e)
{
throw e;
}
}
}
}
/*
Properties 是hashtable的子类
也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串！
不需要泛型，是集合和IO技术相结合的集合容器
该对象的特点：可以用于键值形式的配置文件。
在加载数据时，需要数据有固定格式：键=值。
*/
import java.util.*;
import java.io.*;
class PropertiesDemo
{
public static void main(String[] args) throws IOException
{
//getSet();
//getProperties();
method();
}
/*
public static void getSet()
{
//设置
Properties prop = new Properties();
prop.setProperty("zhangsan","20");
prop.setProperty("lisi","29");
//System.out.println(prop);
String value = prop.getProperty("lisi");//获取
//System.out.println(value);
//Set<String> names = prop.stringPropertyNames();
//1.6版本之后才有这方法
for (String name:names)
{
String value1 = prop.getProperty(name);//get方法返回要强转
System.out.println(name + "=" + value1);
}
}
*/
//演示将流中的数据存储到集合中
//想要将info.txt中键值数据存到集合中进行操作
/*method_1方法
1用一个流和info.txt文件关联
2读取一行数据，将该行数据用“=”进行切割
3.等号左边作为键，右边作为值，存入到Properties集合中就可
*/
public static void method_1()throws IOException
{
BufferedReader bufr = new BufferedReader(new FileReader("info.txt"));
Properties prop = new Properties();
String line = null;
while ((line = bufr.readLine())!=null)
{
String[] arr = line.split("=");
prop.setProperty(arr[0],arr[1]);
}
System.out.println(prop);
}
public static void method3()throws IOException
{
FileInputStream fis = new FileInputStream("info.txt");//流。
Properties prop = new Properties();
prop.load(fis);//加载输入字节流
prop.setProperty("lisi","44");//改过来了，只改内存，但文件中没有保存。
FileOutputStream fos = new FileOutputStream("info.txt");
prop.store(fos,"");//这里存进了文件,修改了硬盘上的文件数据
//System.out.println(prop);
prop.list(System.out);//自己的输出方法。
}
}
/*练习题
用于记录应用程序运行次数
如果使用次数已到，那么给出注册提示
很容易想到的是：计数器。
可是该计数器定义在程序中，随着程序的运行而在内存中存在，
并进行了自增。可是随着应用程序的退出，该计数器也在内存中消失
下一次再启动该程序，又重新开始从0计数，
这样不是我们想要的。
程序结束，该计数器的值也存在，下次程序启动会先加载计数器的值，
并加1后再重新存储起来
所以要建立一个配置文件，用于该计数次数。
该配置文件使用键值对的形式便于阅读数据，并操作数据
键值对数据是map集合。数据是以文件夹形式存储，使用IO技术
那么map+io--->properties
配置文件可以实现应用程序数据的共享。
*/
import java.io.*;
import java.util.*;
class RunCount
{
public static void main(String[] args) throws IOException
{
File file = new File("count.ini");
if (!file.exists())
{
file.createNewFile();
}
FileInputStream fis = new FileInputStream(file);
Properties prop = new Properties();
prop.load(fis);
String value = prop.getProperty("time");
int count = 0;
if (value!=null)
{
count = Integer.parseInt(value);
if (count>=5)
{
System.out.println("使用次数到，请注册！！！");
return;
}
}
count++;
prop.setProperty("time",count+"");
FileOutputStream fos = new FileOutputStream(file);//这句话不能放到上面去，会重新创建文件。
prop.store(fos,"");
fis.close();
fos.close();
}
}
/*
打印流：
该流提供了打印方法，可以将各种数据类型的数据都原样打印.
字节打印流：
PrintStream：
构造函数可以接收的参数类型
1.file对象File
2.字符串路径String
3.字节输出流OutputStream
PrintWriter:字符打印流,web开发常用，把字符一条一条打出去。
构造函数可以接收的参数类型
1.file对象File
2.字符串路径String
3.字节输出流OutputStream
4.字符输出流，Writer.
-------------
SequenceInputStream类
合并流：多个源对应一个目的。先把多个源变成一个源，要用到枚举。
*/
import java.io.*;
class PrintStreamDemo
{
public static void main(String[] args) throws IOException
{
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));
//PrintWriter out = new PrintWriter(System.out,true);//true.流有自动刷新
PrintWriter out = new PrintWriter(new FileWriter("ab.txt"),true);
String line = null;
while ((line = bufr.readLine())!=null)
{
if ("over".equals(line))
{
break;
}
//out.write(line.toUpperCase());没有换行，用下面那个
//out.flush();没有true就要刷新。
out.println(line.toUpperCase());//加上true，就println自动刷新
}
bufr.close();
out.close();
}
}
import java.io.*;
import java.util.*;
class SequenceFile
{
public static void main(String[] args) throws IOException
{
sequenecFile();
}
public static void sequenecFile()throws IOException
{
//合并流，三个文件合成一个，三种方法拿到en.
/*1.Vector<FileInputStream> v = new Vector<FileInputStream> ();
v.add(new FileInputStream("c:\\file\\1.txt"));
v.add(new FileInputStream("c:\\file\\2.txt"));
v.add(new FileInputStream("c:\\file\\3.txt"));
Enumeration<FileInputStream> en = v.elements();*/
ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
for (int x =1;x<=3 ;x++ )
{
al.add(new FileInputStream("c:\\file\\" + x+ ".txt"));
}
//2.Enumeration <FileInputStream>en = Collections.enumeration(al);
//3.
final Iterator <FileInputStream> it = al.iterator();
Enumeration <FileInputStream>en = new Enumeration <FileInputStream>(){
public boolean hasMoreElements()
{
return it.hasNext();
}
public FileInputStream nextElement()
{
return it.next();
}
};
SequenceInputStream sis = new SequenceInputStream(en);
FileOutputStream fos = new FileOutputStream("c:\\file\\123.txt");
int len = 0;
byte[] buf = new byte[1024];
while ((len = sis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
sis.close();
fos.close();
}
}
import java.io.*;
import java.util.*;
//切割文件，再合并！
//切电影类的大文件别冲动！小心内存溢出。可以每装一次获取文件大小
//定个计数器，当装到100M的时候，再创建一个输出对象。
class SplitFile
{
public static void main(String[] args) throws IOException
{
FileInputStream fis = new FileInputStream("c:\\0.mp3");
byte[] buf = new byte[1024*1024];
int len = 0;int count = 1;
FileOutputStream fos = null;
while ((len = fis.read(buf))!=-1)
{
fos = new FileOutputStream("c:\\file\\"+ count+".part");
fos.write(buf,0,len);
count++;
fos.close();
}
fis.close();//切割文件
//-----------------
//合并文件
ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
for (int x =1;x<=4 ;x++ )
{
al.add(new FileInputStream("c:\\file\\"+ x+".part"));
}
Enumeration<FileInputStream> en = Collections.enumeration(al);
SequenceInputStream sis = new SequenceInputStream(en);
FileOutputStream fos1 = new FileOutputStream("c:\\file\\111.mp3");
byte[] buf1 = new byte[1024];
int len1 = 0;
while ((len1=sis.read(buf1))!=-1)
{
fos1.write(buf1,0,len1);
}
fos1.close();
sis.close();
}
}
