java学习第二十天之创建删除文件、文件夹、写入文件

package cn.myio.demo;

import java.io.File;

public class DeleteDirDemo {
/**
* @param 删除一个带内容的文件夹，必须从里往外删
*/
public static void main(String[] args) {
File dir = new File("D:\\java\\workspace\\Stage2\\src\\cn\\myio\\demo\\abc");
System.out.println(dir.delete());
delDir(dir);
}

/**
* @param dir
*/
private static void delDir(File dir) {
//      1、列出当前目录下的文件以及文件夹
File[] files=dir.listFiles();

//      2、对该数组进行遍历
for (File file : files) {
if(file.isDirectory()){
delDir(file);
}else {
System.out.println(file+"已删除"+file.delete());
}
}
System.out.println(dir+"已删除"+dir.delete());
}
}

package cn.myio.demo;

public class DiGuiDemo {
/**
* @param 递归：函数自身调用自身。函数内部又使用到了该函数的功能
* 什么时候使用？
* 功能被重复使用，但是每次该功能使用参与预算的数据不同是，可以考虑递归方式解决
*
* 使用时，一定要定义条件
* 注意递归次数过多，会出现内存溢出
*/
public static void main(String[] args) {
int sum = getSum(3);
System.out.println("sum"+":\t"+sum);
}
/**
* @param i
* @return
*/
private static int getSum(int i) {
if(i==1)
return i;
return i+getSum(i-1);
}
public void show() {
show();
}
}

package cn.myio.demo;

import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;
import java.util.jar.Attributes.Name;

public class FileBySuffix implements FilenameFilter{

private String suffix;
public FileBySuffix(String suffix) {
super();
this.suffix=suffix;
}
//   Name被遍历目录中的文件夹或者文件的名称

@Override
public boolean accept(File dir, String name) {
return name.endsWith(suffix);
}
}

package cn.myio.demo;

import java.io.File;

public class FileDemo {
/**
* @param args
* Flie类 常见方法
* 1、名字  获取名称
* String getName();
* 2、大小  获取大小
* long length();
* 3、获取类型
* 没有
* 4、获取所在目录
* String space();
*/
public static void main(String[] args) {

File file=new File("c:\\1.txt");

String file_name=file.getName();//获取名称
System.out.println(file_name);

long len=file.length();//获取大小
System.out.println(len);

String space=file.getPath();
System.out.println(space);
}
}

package cn.myio.demo;

import java.io.File;
import java.io.IOException;
import java.sql.Date;
import java.text.DateFormat;

public class FileDemo1 {
/**
* @param args
* File  方法
* 1、获取文件的绝对路径
*   String getAbsolutePath();
* 2、获取文件的路径
*   String getPath();
* 3、获取文件的最后一次修改时间，要求是X年X月X日。时间
*   String lastModified();
* 4、文件是否是隐藏的
*   boolean isHidden();
* 5、发现File对象封装的文件或者 文件夹是可以存在的也可以是不存在的
* 那么不存在的可否用file的功能创建按呢？
*   创建功能
*       boolean createNewFile();
*   删除功能
*       boolean delete();
* 6、一个File对象封装的文件或者文件夹到底是否存在内容？
* 是否存在
boolean exists();
*7、getFreeSpace()方法是什么意思？用Demo验证。getTotalSpace()  getUsableSpace()
* @throws IOException
*/
public static void main(String[] args) throws IOException {

File file=new File("D:\\java\\workspace\\Stage2\\src\\cn\\myio\\demo\\2.txt");

//      methodDemo1(file);

//      methodDemo2(file);

File file2=new File("D:\\java\\workspace\\Stage2\\src\\cn\\myio\\demo\\abc");
methodDemo3(file2);

methodDemo4();

}

/**
*
*/
private static void methodDemo4() {
File file =new File("C:\\");
System.out.println(file.getFreeSpace());//可用空间的大小
}

/**
* @param file2
*/
private static void methodDemo3(File file) {

//      创建文件夹
boolean dir=file.mkdir();
System.out.println(dir);

boolean exist=file.exists();
System.out.println(exist);

boolean del=file.delete();//删除文件夹时，必须保证该文件夹没有内容。有内容必须先把内容删除，才可以删除当前文件
System.out.println(del);

//      3、创建多级目录
boolean dirs=file.mkdirs();
System.out.println(dirs);

//      4、判断是不是文件、是不是文件夹
System.out.println("file:"+file.isFile());
System.out.println("dir:"+file.isDirectory());

}

/**
* @param file
* @throws IOException
*/
private static void methodDemo2(File file) throws IOException {
//      1、创建文件夹
boolean b=file.createNewFile();//创建文件  如果文件存在。则不创建返回false  不存在就创建 返回true
System.out.println(b);

//      2、删除
boolean d=file.delete();
System.out.println("delete:"+d);
}

/**
* @param file
*/
private static void methodDemo1(File file) {
String path=file.getAbsolutePath();//获取文件的绝对路径，即使封装的是相对的，获取的也是绝对的
System.out.println(path);//获取的是file对象的封装路径，封装的是什么，获取的的就是什么

String path1=file.getPath();
System.out.println(path1);

long time=file.lastModified();//现在的Unix时间戳(Unix timestamp)
Date date=new Date(time);//日期转换
String str_date=DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG).format(date);
System.out.println(str_date);

boolean b=file.isHidden();//判断文件是否隐藏
System.out.println("isHiddden"+b);
}
}

package cn.myio.demo;

import java.io.File;
import java.io.FilenameFilter;

public class FileDemo3 {
/**
* @param args
*/
public static void main(String[] args) {

//      获取指定文件夹中的所有文件和文件夹的名称。能不能只获取.java文件呢？
File file=new File("C:\\");
String[] names=file.list();//列出当前目录下的所有文件和文件夹名称，包含隐藏文件
//只能获取名称，不能获取大小
/*for(String name:names){
System.out.println(name);
}*/
/*
//同上面一种写法
if(names!=null){
for(String name:names){
System.out.println(name);
}
}
*/

File[] files=file.listFiles();
/*for(File f:files){
System.out.println(f);
}*/

//获取指定目录下.java文件
File file2=new File("D:\\java\\workspace\\Stage2\\src\\cn\\myio\\demo");

//      传入一个过滤器
//      String[] name_filter=file2.list(new FileBySuffix(".class"));//过滤后缀名的过滤器
FilenameFilter filter=new FileBySuffix(".java");//过滤后缀名的过滤器
filter=new FilerByContain("Demo");

String[] names2=file2.list(filter);
for(String name:names2){
//          if(name.endsWith(".java"))//相当于过滤
System.out.println(name);

}
}
}

package cn.myio.demo;

import java.io.File;
import java.io.FileFilter;

public class FileFilterDemo {
/**
* @param 文件过滤器  FileFilter
*/
public static void main(String[] args) {
File dir=new File("C:\\");
//      传递过滤器
FileFilter filter=new FilerByFile();
File[] files=dir.listFiles(filter);
for (File file : files) {
System.out.println(file);
}
}
}

package cn.myio.demo;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutPutStramDemo {
/**
* @param 将数据包写到文件当中
* 使用字节输出流
* FileOutputStream
* @throws IOException
*/
public static void main(String[] args) throws IOException {
File file=new File("D:\\java\\workspace\\Stage2\\src\\cn\\myio\\demo\\tempfile");
/*
1、创建字节输出流对象，用于从奥做文件，在对象初始化时，必须明确数据存储的目的地
输出流所关联的目的地，如果不存在，会自动创建
*/
FileOutputStream fileOutputStream=new FileOutputStream("D:\\java\\workspace\\Stage2\\src\\cn\\myio\\demo3.txt");

//      调用输出流的写功能
String string="3sdsfsf";
byte[] buf=string.getBytes();
fileOutputStream.write(buf);
fileOutputStream.write("我是大灰狼".getBytes());

//      3、释放资源
fileOutputStream.close();
}
}

package cn.myio.demo;

import java.io.File;
import java.io.FilenameFilter;

public class FilerByContain implements FilenameFilter {
private String content;

/**
* @param content
*/
public FilerByContain(String content) {
super();
this.content = content;
}

@Override
public boolean accept(File dir, String name) {
return name.contains(content);
}

}

package cn.myio.demo;

import java.io.File;
import java.io.FileFilter;

public class FilerByFile implements FileFilter {

@Override
public boolean accept(File pathname) {
return pathname.isFile();
}
/**
* @param args
*/
}

package cn.myio.demo;

import java.io.File;
import java.io.FileFilter;

/**
* @author john5
*
*/
public class FilterBySuffix implements FileFilter {
private String suffix;
@Override
public boolean accept(File pathname) {
return pathname.getName().endsWith(suffix);
}
/**
* @param suffix
*/
public FilterBySuffix(String suffix) {
super();
this.suffix = suffix;
}

}

package cn.myio.demo;

import java.io.File;

public class GetAllFile {
/**
* @param args
*/
public static void main(String[] args) {
/*
遍历指定目录下的内容（包含子目录中内容）
递归：函数自身调用自身，函数内部又使用到了该函数的功能
*/
File dir=new File("D:\\java\\workspace");
getAllfiles(dir);
}
public static void  getAllfiles(File dir) {
//获取该目录的文件对象数组
File[] files=dir.listFiles();

//      对数组进行遍历
for (File file : files) {
if(file.isDirectory()){
getAllfiles(file);
}else {
System.out.println(file);
}
System.out.println(file);
}
}
}

package cn.myio.demo;

import java.io.File;

public class IoDemo {
/**
* @param args
*
*  /**
* @param
* 流按操作数据分为两种：字节流与字符流
* 流按流向分为：输入流（读）输出流（写）
* 字节流的抽象基类：InputSream   OutputStream
* 字符流的抽象基类
*
*
* IO流用来处理设备之间的数据传输
Java对数据的操作是通过 流（系统资源） 的方式的
Java用于操作流的对象都在java.io包中

Io：用于处理设备上的数据的技术。设备：内存，硬盘。光盘
流：系统资源，windows系统本身就可任意操作设备，各种语言只是使用系统平台的这个资源
并对外提供了各种语言自己的操作功能，这些功能最终调用的是系统资源
使用完资源一定要记住：释放
设备上数据最常见的存储表现形式文件file

先学习一下文件的基本操作
描述文件或者文件夹的类是file
*/
private static final String FILE_SAPARATOR=System.getProperty("file.separator");

public static void main(String[] args) {
//      将具体的路径封装成了File对象。可以封装存在的文件或目录，也可以封装不存在的文件或目录

File file=new File("C:\\1.txt");

//File(String parent,String child)
File file1=new File("C:\\","1.txt");
File dir=new File("c:\\");
File file2=new File(dir,"1.txt");
File file3=new File("c:"+FILE_SAPARATOR+"abc"+FILE_SAPARATOR+"1.txt");
File file4=new File("C:\\abc\\1.txt");
System.out.println(file3);
}
}

package cn.myio.demo;

import java.io.File;
import java.io.FileFilter;
import java.util.ArrayList;
import java.util.List;

public class IODemo2 {
/**
* @param
* 获取一个想要的指定文件的集合 获取wokespace下（包含子目录）的所有的.java的文件对象，并存储到集合中
* 思路：
* 1、既然包含子集合，就需要递归
* 2、在递归过程中需要过滤器
* 3、满足条件，都添加到集合中
*
*
*/

/**
* 定义一个获取指定条件的文件的集合
*
*多级目录下都要用到相同的集合和过滤器  那么不要在递归方法中定义，而是不断地进行传递
* @param dir 需要遍历的目录
* @param list 用于存储符合条件的File对象
* @param filter 接受制定的过滤条件
*
*/
public static void main(String[] args) {
File dir=new File("D:\\java\\workspace");
List<File> list=fileList(dir);
for (File file : list) {
System.out.println(file);
}
}

public static void getFileList(File dir,List<File> list,FileFilter filter) {
//      1、通过listFiles放啊，获取dir当前下的所有的文件和文件夹对象
File[] files=dir.listFiles();
//      2、遍历该数组
for (File file : files) {
//          3、判断是否是文件夹，如果是，递归。如果不是，那就是文件夹，就需要对文件进行过滤
if(file.isDirectory()){
getFileList(dir, list, filter);
}else {
//              4、通过过滤器对文件进行过滤
if(filter.accept(file)){
list.add(file);
}
}

}
}
public static List<File> fileList(File dir) {
//      1、定义集合
List<File> list=new ArrayList<File>();
//      2、定义过滤器
/*FileFilter fileFilter=new FileFilter() {

@Override
public boolean accept(File pathname) {
return pathname;
}
};*/

FileFilter filter=new FilterBySuffix(".java");
getFileList(dir, list, filter);
return list;
}
}

package cn.myio.demo;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class IOExceptionDemo {
/**
* @param args
*/
static final String Line_SEPARATOR=System.getProperty("line.separator");
public static void main(String[] args) throws IOException {

FileOutputStream fileOutputStream=null;
try {
//  传入true  续写
fileOutputStream=new FileOutputStream("D:\\java\\workspace\\Stage2\\src\\cn\\myio\\demo3.txt",true);
fileOutputStream.write("\r\n我是大灰狼".getBytes());
fileOutputStream.write(Line_SEPARATOR.getBytes());

} catch (IOException e) {

}finally {
if(fileOutputStream!=null){//关闭资源前必须判断
try {
fileOutputStream.close();
} catch (IOException e) {
throw new RuntimeException("关闭失败"+e);
}
}

}
}
}