------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
黑马程序员 java 基础 毕向东 面向对象 IO操作
File Properties PrintWriter PrintStream 应用
1 Java IO操作中File类的
package day20File;
import java.io.File;
import java.io.IOException;
import java.util.Date;
public class F1_FileDemo {
/*
* File 类的常见方法
* 1：创建
* boolean createNewFile() throws IOException
* 且仅当不存在具有此抽象路径名指定名称的文件时，
* 不可分地创建一个新的空文件。
* 不存在，创建； 存在，不创建
* 创建文件夹：
* 返回：
boolean mkdir() 当且仅当已创建目录时，返回 true；否则返回 false
boolean mkdirs()创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。
注意，此操作失败时也可能已经成功地创建了一部分必需的父目录。
返回：
当且仅当已创建目录以及所有必需的父目录时，返回 true；否则返回 false
* 2：删除
* boolean delete()删除成功返回真，失败,假
* void deleteOnExit()；
* 在虚拟机终止时，请求删除此抽象路径名表示的文件或目录
*
* 3：判断
boolean canExecute()
测试应用程序是否可以执行此抽象路径名表示的文件。
boolean canRead()
测试应用程序是否可以读取此抽象路径名表示的文件。
boolean canWrite()
测试应用程序是否可以修改此抽象路径名表示的文件。
int compareTo(File pathname)
按字母顺序比较两个抽象路径名。
boolean exists()
测试此抽象路径名表示的文件或目录是否存在。
boolean isDirectory()
测试此抽象路径名表示的文件是否是一个目录。
boolean isFile()
测试此抽象路径名表示的文件是否是一个标准文件
在判断文件对象是文件还是目录时，必须要先判断文件是否存在
通过 exists（）
boolean isDirectory()
测试此抽象路径名表示的文件是否是一个目录。
boolean isFile()
测试此抽象路径名表示的文件是否是一个标准文件。
boolean isHidden()
测试此抽象路径名指定的文件是否是一个隐藏文件。
boolean isAbsolute()
测试此抽象路径名是否为绝对路径名。
* 4：获取
* String getName()
返回由此抽象路径名表示的文件或目录的名称。
如果指定的是相当路径，返回null
如果相当路径中有上一层目录，返回该目录
String getParent() 也就是指定绝对路径的父目录
返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
*
* String getPath()
将此抽象路径名转换为一个路径名字符串。
String getAbsolutePath()
返回此抽象路径名的绝对路径名字符串。
long lastModified()
返回此抽象路径名表示的文件最后一次被修改的时间。
long length()
返回由此抽象路径名表示的文件的长度。
long lastModified() 注意类型
返回此抽象路径名表示的文件最后一次被修改的时间。
long length()
返回由此抽象路径名表示的文件的长度。
boolean renameTo(File dest)
重新命名此抽象路径名表示的文件。
* */
public static void main(String[] args) throws IOException {
// consMethod();
// method_1();
// method_2();
// method_3();
method_4();
}
static void method_4() throws IOException{
File f=new File("F:\\out.txt");
System.out.println(f.createNewFile());
// f.mkdir();
System.out.println( "getPath:"+f.getPath());
System.out.println( "getParent:"+f.getParent());
System.out.println("getAbsolutePath:"+ f.getAbsolutePath());
System.out.println("lastModified:"+ new Date(f.lastModified()));
System.out.println("length:"+ f.length());
System.out.println("renameTo:"+f.renameTo(new File("E:\\22222.txt")));
}
static void method_3() throws IOException{
File f=new File("F:\\222.txt");
// f.createNewFile();
f.mkdir();
System.out.println("isDirectory:"+f.isDirectory());
System.out.println("isFile:"+f.isFile());
System.out.println(""+f.isAbsolute());
}
static void method_2() throws IOException{
File f=new File("1.txt");
System.out.println("canExecute:"+f.canExecute());
System.out.println("exists:"+f.exists());
}
static void method_1() throws IOException{
File f=new File("F:\\file\\abc");
// System.out.println("create:"+f.createNewFile());
System.out.println("create:"+f.mkdir());
System.out.println("create:"+f.mkdirs());
// System.out.println("delete:"+f.delete());
// f.deleteOnExit();
}
static void consMethod(){
/*将a.txt 封装成对象，可以将已有的和没有的文件或者文件夹封装成对象*/
File f1=new File("a.txt");
File f2=new File("F:\\abc","b.txt");
File f3=new File("F:\\abc");//这样的分隔符不利于跨平台运行
File f4=new File(f3,"c.txt");
/*File 封装了 分隔符
* separator
* public static final String separator
* 与系统有关的默认名称分隔符，
* 为了方便，它被表示为一个字符串。
* 此字符串只包含一个字符，
* 即 separatorChar。 */
File f6=new File("F:"+File.separator+"abc");
System.out.println("f1"+f1);
System.out.println("f1"+f2);
System.out.println("f1"+f3);
System.out.println("f1"+f4);
System.out.println("f1"+f6);
}
}
2 File 类listRoots list 方法使用
package day20File;
import java.io.File;
import java.io.FilenameFilter;
public class F2_FileDemo2 {
/*
*
* static File[] listRoots()
列出可用的文件系统根。
String[] list() (文件 和 目录 包含隐藏文件)
调用list方法必须是目录，而且必须存在，否则返回null
返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
String[] list(FilenameFilter filter)
返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。
File[] listFiles()
返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。
File[] listFiles(FileFilter filter)
返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。
File[] listFiles(FilenameFilter filter)
返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。
*/
public static void main(String[] args) {
// listDemo();
// listFilterDemo();
listDemo2();
}
static void listDemo2(){
File file=new File("F:\\picture");
File [] files=file.listFiles();
for(File f:files){
System.out.println("F:"+f+"-"+f.length());
}
}
static void listFilterDemo(){
File file=new File("F:\\picture\\爱");
String[] files=file.list(new FilenameFilter() {
public boolean accept(File dir, String name) {
System.out.println("dir:"+dir+":name:"+name);
return name.endsWith(".png");
}
});
for(String f:files){
System.out.println("F:"+f);
}
}
static void listRootsDemo(){
File []files=File.listRoots();
for(File f:files){
System.out.println("F:"+f);
}
}
static void listDemo(){
File file=new File("F:");
String[] files=file.list();
for(String f:files){
System.out.println("F:"+f);
}
}
}
3 列出指定目录下的所有文件和文件夹，包含子目录中的内容，也就是列出所有内容；使用递归
package day20File;
import java.io.File;
public class F3_FileDemo3 {
/*
* 列出指定目录下的所有文件和文件夹
* 包含子目录中的内容
* 也就是列出所有内容
*
*
因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
在列出过程中出现的还是目录的话，还可以再次调用本功能。
也就是函数自身调用自身。
这种表现形式，或者编程手法，称为递归。
递归要注意：
1：限定条件。
2：要注意递归的次数。尽量避免内存溢出。StackOverflowError
*/
public static void main(String[] args) {
File file =new File("D:\\WorkSpace\\HM");
System.out.println(file);
traverse(file,0);
// toBin(6);
// System.out.println(getSum(80000));
}
static StringBuilder getLevel(int level){
StringBuilder sb=new StringBuilder();
sb.append("————");
for (int i = 0; i < level; i++) {
sb.insert(0, " ");
}
return sb;
}
static void traverse(File f,int level){
File [] fileArr=f.listFiles();
level++;
for(File f2:fileArr){
if(f2.isFile())
System.out.println(getLevel(level).insert(level*2, '+')+f2.getName());
if(f2.isDirectory()){
System.out.println(getLevel(level).insert(level*2, '-')+""+f2.getName());
traverse(f2,level);
}
}
// for(File f2:fileArr){
// if(f2.isFile())
// System.out.println("file:"+f2.getName());
// if(f2.isDirectory()){
//// else{
// System.out.println("----------Dir：----------"+f2.getName());
// traverse(f2);
// }
// }
// for (int i = 0; i < fileArr.length; i++) {
// if(fileArr[i].isFile())
// System.out.println("file:"+fileArr[i].getName());
//// if(fileArr[i].isDirectory())
// else{
// System.out.println("----------Dir：----------"+fileArr[i].getName());
// traverse(fileArr[i]);
// }
// }
}
static void toBin(int i){
if(i>0){
toBin(i/2);
System.out.println(i%2);
}
}
static int getSum(int i){
if(i==1){
return 1;
}
return getSum(i-1)+i;
}
}
4删除一个带有内容的目录（删除目录从里面往外删除，需要递归）
package day20File;
import java.io.File;
public class F4_RemoveDir {
/*
* 删除一个带有内容的目录
* 删除原理
*
* 在windows中
*
* 删除目录从里面往外删除
* 既然从里往外就用到的递归
* */
public static void main(String[] args) {
File f= new File("F:\\deleteTest");
removeDir(f);
}
static void removeDir(File dir){
File [] dirArr=dir.listFiles();
for(File f:dirArr){
if(f.isFile()){
f.delete();
System.out.println("remove:"+f.getAbsolutePath());
}
if(!f.isHidden()&&f.isDirectory())
removeDir(f);
}
dir.delete();
System.out.println(dir.getAbsolutePath()+"is removed");
}
}
5将一个指定目录下的java文件的绝对路径，存储到一个文本文件中，建立一个java文件列表文件
package day20File;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class F5_JavaFileList {
/*
* 练习
将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。
建立一个java文件列表文件
*
*思路：
*1：对指定目录进行递归
*2：获取递归过程中所有java文件的路径
*3：将路径存储到集合中
*4：将集合中的数据存储到文件
*/
public static void main(String[] args) {
File dir =new File("D:\\WorkSpace\\HM\\src");
List<File> list=new ArrayList<File>();
fileToList(dir, list);
System.out.println(list.size());
writeToFile(list,"F:\\javapath.txt");
}
static void writeToFile(List<File> list,String path){
BufferedWriter bw = null;
try {
bw=new BufferedWriter(new FileWriter(path));
for (Iterator<File> iterator = list.iterator(); iterator.hasNext();) {
File file = iterator.next();
bw.write(file.getAbsolutePath());
bw.newLine();
bw.flush();
}
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
static void fileToList(File dir,List<File> list){
File[] fileArr=dir.listFiles();
for(File f:fileArr){
if(!f.isHidden()&&f.isDirectory()){
fileToList(f, list);
}
if(f.isFile()){
if(f.getName().endsWith(".java"))
list.add(f);
}
}
}
}
6 Properties （Hashtable的子类）应用于配置文件，存储键值对形式的数据，融合了Map和java io
package day20File;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;
public class F6_PropertiesDemo {
/*
* Properties 是Hashtable的子类
* 也就是说他具备了map集合 的特点
* 而且他存储的键值对都是字符串
*
* 是集合和io相结合的容器
*
* 该对象的特点：
* 可以用于键值对形式的配置文件
*
* 想要将流中的键值对数据存的集合中
* 思路：
* 1：用流和Info.txt关联
* 2：读取一行数据，用等号切割
* 3：等号左边作为键，右作为值存入Properties
*
* */
public static void main(String[] args) {
// setAndGet();
// method_1();
loadDemo();
}
static void loadDemo(){
FileInputStream fis=null;
FileOutputStream fos=null;
Properties p=new Properties();
try {
fis=new FileInputStream("F:\\info.txt");
p.load(fis);
fos=new FileOutputStream("F:\\info.txt");
p.list(System.out);
p.setProperty("lisi", "90");
p.store(fos, "hahaa");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
// System.out.println(p);
p.list(System.out);
}
static void method_1(){
BufferedReader br=null;
Properties p=new Properties();
try {
br=new BufferedReader(new FileReader("F:\\info.txt"));
String lineStr;
while((lineStr=br.readLine())!=null){
System.out.println("-:"+lineStr);
String[] sArr=lineStr.split("=");
p.setProperty(sArr[0],sArr[1]);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println(p);
}
static void setAndGet(){
Properties p=new Properties();
p.setProperty("zhangsan","20");
p.setProperty("lisi","29");
String name1=p.getProperty("zhangsan");
String name2=p.getProperty("lisi");
Set<String> s=p.stringPropertyNames();
// for (Iterator<String> iterator = s.iterator(); iterator.hasNext();) {
// String str = iterator.next();
// System.out.println("-->"+str);
// }
for(String str:s){
System.out.println("-->"+str);
}
}
}
7 记录程序运行次数
package day20File;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;
public class F7_Runcount {
/*
* 记录程序运行次数
*
* 如果使用次数到，给出注册提示
*
* 计数器？
* 计数器定义在程序中，随着程序的运行在内存中自增
* 随着程序的退出，该计数器在内存中消失
*
* 下一次用从 0 计数
* 需要即使程序退出
* 计数器也存在
* 下次运行时自动加载该数据
* 该配置文件使用键值对的形式
* 这样便于阅读数据，并操作数据
* 键值对数据是map集合
* 数据以文件存储
* 使用io 和 map 技术
* 配置文件使用应用程序的共享
* * */
public static void main(String[] args) throws IOException {
Properties p=new Properties();
File propFile=new File("F:\\count.properties");
if(!propFile.exists())
propFile.createNewFile();
FileInputStream fis=new FileInputStream(propFile);
p.load(fis);
int count = 0 ;
String val=p.getProperty("time");
if(val!=null)
count=Integer.parseInt(val);
if(count>=5){
System.out.println("请注册");
return;
}
count++;
p.setProperty("time",count+"");
FileOutputStream fos=new FileOutputStream(propFile);
p.store(fos, "");
fis.close();
fos.close();
}
}
8 打印流 PrintWriter（字符） PrintStream（字节）
package day20File;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import com.sun.imageio.plugins.common.InputStreamAdapter;
public class F8_PrintStream {
/*
* 打印流
* 该流提供了打印方法
* 可以将各种数据类型的数据原样打印
* PrintStream
* 字节打印流；
* 他的构造函数可以接受：
* 1:File 对象、
* 2:字符串路径String
* 3:字节输出流 OutputStream
*
* PrintWriter
*
* 1:File 对象、
* 2:字符串路径String
* 3:字节输出流 OutputStream
* 4:字符输出流 Writer
* */
public static void main(String[] args) throws IOException {
// BufferedInputStream bis=new BufferedInputStream(System.in);
BufferedReader br=
new BufferedReader(new InputStreamReader(System.in));
// PrintWriter out=new PrintWriter(System.out);
// PrintWriter out=new PrintWriter(System.out,true);
// PrintWriter out=new PrintWriter("F:\\out111.txt");
PrintWriter out=new PrintWriter(new FileWriter("F:\\out111.txt"),true);
String lineStr;
while((lineStr=br.readLine())!=null){
if("over".equals(lineStr))
break;
out.println(lineStr);
// out.println(lineStr);
// out.flush();
}
br.close();
out.close();
}
}
9 SequenceInputStream 其他输入流的逻辑串联
package day20File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;
public class F9_SequenceInputStreamDemo {
/*
* */
public static void main(String[] args) throws IOException {
Vector<InputStream> v=new Vector<InputStream>();
v.add(new FileInputStream("F:\\1.txt"));
v.add(new FileInputStream("F:\\2.txt"));
v.add(new FileInputStream("F:\\3.txt"));
Enumeration<InputStream> e=v.elements();
SequenceInputStream sis=new SequenceInputStream(e);
FileOutputStream fos=new FileOutputStream("F:\\4.txt");
int length;
byte [] buffer=new byte[1024];
while((length=sis.read(buffer))!=-1){
fos.write(buffer,0, length);
}
sis.close();
fos.close();
}
}
10 SequenceInputStream应用 文件切割与合并
package day20File;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
public class F91_SpileFile {
/*
* 切割文件
* */
public static void main(String[] args) throws IOException {
// spileFile();
merge();
}
public static void merge() throws IOException{
SequenceInputStream sis;
ArrayList<FileInputStream> al=new ArrayList<FileInputStream>();
for (int i = 1; i <=5; i++) {
al.add(new FileInputStream("F:\\"+i+"1.part"));
}
final Iterator<FileInputStream> it=al.iterator();
Enumeration<FileInputStream> e=new Enumeration<FileInputStream>() {
public boolean hasMoreElements() {
return it.hasNext();
}
public FileInputStream nextElement() {
return it.next();
}
};
sis=new SequenceInputStream(e);
// FileOutputStream fos=new FileOutputStream("F:\\121.mp3");
FileOutputStream fos=new FileOutputStream("F:\\fam121.jpg");
int len;
byte[] b=new byte[1024*1024];
while((len=sis.read(b))!=-1){
fos.write(b,0,len);
}
fos.close();
sis.close();
}
public static void spileFile() throws IOException{
// FileInputStream fis=new FileInputStream("F:\\1.mp3");
FileInputStream fis=new FileInputStream("F:\\fam.jpg");
FileOutputStream fos=null;
byte[] buffer=new byte[1024*1024];
int len=0;
int count=0;
// filePart=0;
while((len=fis.read(buffer))!=-1){
fos=new FileOutputStream("F:\\"+(++count)+"1.part");
fos.write(buffer,0,len);
fos.close();
}
fis.close();
}
}