package File;
import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;
import java.io.IOException;
/*
* File
* 代表文件或者目录（文件夹）的类
*
* 1.路径:
* 1.1绝对路径 以盘符或者是/开头的路径 D:\\a.txt /home/software(Linux)
* 和当前所处的路径没有任何关系，直接定位到指定的路径
* 1.2相对路径 以盘符或者是/开头的路径 a.txt
* 需要以当前的位置来计算另一个位置 ../表示上一级目录 ../../表示上两级目录
* 路径发生改变的时候能够计算。
*
* a下 b和c a/b/d/e/path.html a/c/f/text.html
* b d e
* path.html找text.html ../../../c/f/text.html
*
*
*/
public class FileDemo01 {
public static void main(String[] args) throws IOException {
//1.给定路径名创建File对象。 File(String pathname)
//当创建File对象的时候，并不去计算机中检查文件是否存在。只是将路径字符串标记为一个File对象
File file=new File("E:\\ChenXunCode\\DaNeiBigDataCode\\a.txt");
//2.创建文件 boolean createNewFile() [只能创建文件，不能创建目录]
//文件存放的路径必须真实存在
boolean createFile=file.createNewFile(); // E:\\SASAAA\\a.tet SASAAA目录不存在,返回false
System.out.println(createFile); //只有这个文件不存在的时候才能创建成功，返回true.否则已存在了，返回false
//3.创建目录 boolean mkdir() [只能创建目录，不能创建文件]
//只能创建一层目录
boolean createDir=file.mkdir(); // new File(E:\\A) 可以 new File(E:\\A\\B\\C\\D) 不可以 ,但是如果A,B,C存在的时候，可以
System.out.println(createDir);
//4.创建多层目录 boolean mkdirs()
boolean createDirs=file.mkdirs(); // new File(E:\\A\\B\\C\\D)可以
System.out.println(createDirs);
//5.删除文件/空目录 boolean delete() [既能删除文件，又能删除空目录]
//把文件/目录从计算机中彻底移除，此操作不可逆
boolean deteleFile=file.delete(); //new File(E:\\A) 在删除的目录的时候，需要目录A中为空
System.out.println(deteleFile);
//6.获取所有子目录/子文件 File[] fs=file.listFiles();
File file1=new File("D:\\A");
File[] fs=file1.listFiles();
for(File f:fs) {
System.out.println(f); //注意:本身应该返回D:\\A\\B\\C 这里只能返回D:\A\B 如果是子目录，递归
}
//----------------IS-------------------------------------
//7.判断是否是目录 boolean .isDirectory()
boolean isDir=file1.isDirectory();
System.out.println(isDir);
//8.判断是否是文件 boolean .isFile()
boolean isFile=file1.isFile();
System.out.println(isFile);
//9.判断是否是隐藏文件 boolean isHidden()
System.out.println(file1.isHidden());
//10.判断是否是绝对路径 boolean isAbsolute()
System.out.println(file1.isAbsolute());
//11.判断file表示的文件或者目录是否真实存在
System.out.println(file1.exists());
//--------------- CAN-------------------------------------
//13.判断是否是可执行文件 boolean .canExecute()
//在winodws上碰不到不可执行文件，不可以
System.out.println(file1.canExecute());
//14.判断是否是只读文件 boolean canRead()
//在winodws上碰不到不可读文件，不可以
System.out.println(file1.canRead());
//15.判断是否是可写文件 boolean canWrite()
//在winodws上可测试,是否可写，可以
System.out.println(file1.canWrite());
//------------------set-设置成功返回true,失败返回false-----------------------------
//16.设置此文件是否可执行 boolean .setExecutable(boolean) 设置成功返回true,失败返回false
boolean b=file1.setExecutable(false);
System.out.println(b); //不可设置，返回设置失败false ,windows下此方法失效
//17.设置此文件是否可读 boolean .setReadable(boolean)
boolean c=file1.setReadable(false);
System.out.println(c); //不可设置，返回设置失败false ,windows下此方法失效
//18.设置此文件是否可写 boolean .setExecutable(boolean)
boolean d=file1.setWritable(false);
System.out.println(d); //可设置，返回设置成功true
//19.设置所有者或所有用户的写权限。boolean .setWritable(boolean可写?,boolean只能当前用户?)
boolean e=file1.setWritable(true, true); //表示只给当前用户设置可写权限
//20.设置最后一次修改时间 boolean setLastModified(long time)
boolean f=file1.setLastModified(2000); //无论怎么改都成功，可以改为创建之前的时间
//需要判断这个设置的数字是否合理 .lastModified()获取最后一次修改的时间
//--------------------get-------------------------------------------------------
//21.获取最后一次修改的时间long lastModified()
long g=file1.lastModified();
System.out.println(g);
//22.获取文件的绝对路径 .getAbsoulutePath()
System.out.println(file1.getAbsolutePath());
//23.获取文件的父路径 .getParent 直接字符串截取，不判断路径是否存在,字符串上没有父路径就是没有
System.out.println(file1.getParent());
//24.获取文件名 .getName()
System.out.println(file1.getName());
//25.名称分隔符 separatorChar
//在windows中分隔符目录用\\, 在Linux中分隔目录用\
File file3=new File("D:"+File.separatorChar+"A");
//26.路径分隔符 pathSeparatorChar
//在windows中区分路径用; ,在Linux中区分路径:
File file4=new File("D:"+File.pathSeparatorChar+"A");
//27.重新命名文件 boolean renameTo()
//要求存放的路径中没有同名文件
File file6=new File("D:\\a.txt");
//路径不改变而文件名改变的情况下做的是重命名
file6.renameTo(new File("D:\\b.txt"));
//文件名不改变而路径改变的情况下做的是剪切
file6.renameTo(new File("E:\\a.txt"));
//文件名和路径都改变做的是剪切和重命名
file6.renameTo(new File("E:\\b.txt"));
//--------1.Start 获取D盘下的所有的子文件------ FileFilter()--------------------------------------
// 返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。 File[] listFiles(FilenameFilter filter)
File file5=new File("D:\\");
File[] fs3=file5.listFiles(new FileFilter() {
//参数依次表示当前目录下的子文件和子目录
//把过滤规则写到accept方法中
//如果满足规则，则自动放入fs3的数组中
@Override
public boolean accept(File arg0) {
// TODO Auto-generated method stub
return arg0.isDirectory(); //只要返回目录
//return arg0.isFile() 只要返回文件
}
});
//获取D盘下的所有子目录
File[] fs4=file5.listFiles(fz -> fz.isDirectory());
for(File fz:fs4) {
System.out.println(fz);
}
//--------1.end-FileFilter()--------------------------------------------------------------
//--------2.Start-获取D盘下的所有含有数字的文件或者目录,这里要获取文件名----- FileFilter()----
//获取D盘下所有含有数字的文件或者目录 ，否则这里要获取文件名
File[] fs5=file5.listFiles(fz ->fz.getName().matches(".*\\d.*"));
for(File fz:fs5) {
System.out.println(fz);
}
//--------2.end--FileFilter()-------- --------------------------------------------------
//--------3.Start-获取D盘下的所有含有数字的文件或者目录,这里不用获取文件名----FilenameFilter() -----
File[] fs6=file5.listFiles(new FilenameFilter() {
//File arg0 表示文件所在的父目录
//String arg1 表示文件或者目录的名字
@Override
public boolean accept(File arg0, String arg1) {
// TODO Auto-generated method stub
return arg1.matches(".*\\d.*");
}
});
File[] fs7=file5.listFiles((dir,name)->name.matches(".*\\d.*"));
//获取含有大写的文件或者目录
File[] fs8=file5.listFiles((dir,name)->name.matches(".*[A-Z].*"));
//--------3.end---FilenameFilter()---------------------------------------------------------
}
}
package File;
import java.io.File;
public class FileExer {
//练习2. 注意:把统计个数定义在方法体外，否则每次递归初始化为0
private static int countJava=0;
private static int countClass=0;
public static void main(String[] args) {
//练习1.删除给定文件/目录下的所有东西 boolean delete() 可以删除文件，但是只能删除空目录
//思想：写成一个方法
// 如果传入的是文件直接删除
// 如果传入是目录(isDirectory()),获取这个目录下的所有子目录和子文件(listFiles()),进行递归判断是否是文件还是目录来进行删除
File file=new File("D:\\A");
deleteAll(file);
//练习2.统计工作空间中JAVA文件和class文件的个数
// 如果是目录，获取工作空间中的所有子文件和子目录，递归统计
// 如果是文件，获取名字file.getName(),判断是否是Class文件还是Java文件
// 注意:把统计个数定义在方法体外，否则每次递归初始化为0
File file2=new File("E:\\ChenXunCode\\DaNeiBigDataCode");
totalFile(file2);
System.out.println("JAVA文件"+FileExer.countJava);
System.out.println("Class文件"+countClass);
}
//-------------------------------------------------------------------------
//练习1.删除给定文件/目录下的所有东西 boolean delete() 可以删除文件，但是只能删除空目录
//思想：写成一个方法
// 如果传入的是文件直接删除
// 如果传入是目录(isDirectory()),获取这个目录下的所有子目录和子文件(listFiles()),进行递归判断是否是文件还是目录来进行删除
public static void deleteAll(File file) {
//判断是否为空
if(file==null) {
throw new NullPointerException("传入为空");
}
//判断传入参数是否是目录
if(file.isDirectory()) {
File[] fs=file.listFiles();
for(File f:fs) {
//依次遍历每一个元素，判断这个元素是否是文件还是目录，然后操作
//后续方法和当前方法功能一致，采用递归。
deleteAll(f);
}
}
//无论是否是目录还是文件都要删除
//删除文件/空目录
file.delete();
}
//--------------------------------------------------------------------------
//练习2.统计工作空间中JAVA文件和class文件的个数
// 如果是目录，获取工作空间中的所有子文件和子目录，递归统计
// 如果是文件，获取名字file.getName(),判断是否是Class文件还是Java文件
// 注意:把统计个数定义在方法体外，否则每次递归初始化为0
public static void totalFile(File file) {
//判断是否为空
if(file==null) {
throw new NullPointerException("传入为空");
}
//判断传入参数是否是目录
if(file.isDirectory()) { //如果是目录
File[] fs=file.listFiles();
for(File file2:fs) {
//依次遍历每一个元素，判断这个元素是否是文件还是目录，然后操作
//后续方法和当前方法功能一致，采用递归。
totalFile(file2);
}
}else { //如果是文件
//获取名字file.getName()
if(file.getName().endsWith(".class")){countClass++;}
else if(file.getName().endsWith(".java")){countJava++;}
}
}
}
package IODemo;
import java.io.FileWriter;
import java.io.IOException;
/*
* IO流
* IO流是JAVA中一套用于数据传输的API.
*
* 1.Input Output输入输出流。
* 输入流指数据从外部流向程序。 读取文件:数据从文件流向程序- ****输入流Read****
* 输出流指数据从程序流向外部。 写入文件:数据从程序流向文件- ****输出流Write***
*
* 2.根据数据的传输方法:输入流，输出流
* 根据数据的传输形式:字符流，字节流
*
* 字节流 字符流
* 输入流 InputStream Reader
* 输出流 OutputStream Writer
*
* 四个基本流都是抽象类，不能直接创建对象
*3. 数据的来源/目的地:硬盘，内存，网络，输入设备
*
*
*
*
*
*/
public class IODemo01 {
public static void main(String[] args) throws IOException {
// 向一个txt文件中写入一个字符串， 用字符流，输出流和文件相关的流FileWriter
//1. 根据给定的 File对象构造一个 FileWriter 对象。FileWriter(File file)
//创建一个文件，如果文件不存在自动创建，如果该文件已存在会被覆盖
FileWriter writer=new FileWriter("D:\\A\\a.txt");
//2.写入数据 .write()
//数据是先写到缓冲区，缓冲区满了之后再写到文件中。
//数据写到缓冲区之后，缓冲区还没满程序就结束，数据还在缓冲区中，没来的及写到文件中。
writer.write("abc");
//3.冲刷缓冲区 .flush()
//如果没有第三步冲刷缓冲区，writer后直接close也能写到文件中
writer.flush();
//4.关闭流对象
//如果没有第三步冲刷缓冲区，writer后直接close也能写到文件中
//关闭流对象之前，自动完成冲刷缓冲区的操作，防止数据死在缓冲区中。
writer.close();
System.out.println(writer); //输出java.io.FileWriter@55f96302，还占用内存资源
//5.释放资源
writer=null;
}
}
package IODemo;
import java.io.FileWriter;
import java.io.IOException;
/*
*
* 流中的异常处理:
* 1.将流对象放到try之外声明并且赋值为null,放到try之内创建
* 2.关流之前需要判断流对象是否初始化成功---判断流对象是否为null
* 3.关流之后需要将流对象设置为null
* 4.为了防止关流失败导致数据丢失，需要在写外之后手动冲刷一次缓冲区
*
*/
public class IODemo02 {
public static void main(String[] args) {
//a********//注意a:流对象需要放到try之外定义赋值为null，让finally{}里面的writer可以调用
FileWriter writer=null;
try {
//b********//注意b:流对象放到try{}之内创建，以处理异常
//1. 根据给定的 File对象构造一个 FileWriter 对象。FileWriter(File file)
writer=new FileWriter("D:\\A\\b.txt");
//2.写入数据 .write()
writer.write("acv");
//e******** //注意e:为了防止关流失败导致数据丢失
//3.冲刷缓冲区 .flush()
writer.flush();
} catch (IOException e) {
e.printStackTrace();
}finally {
//c**** //注意c:判断流对象是否初始化成功,否则null.close()空指针异常
if(writer!=null) {
//4.关闭流对象
try {
writer.close();
} catch (IOException e) {
e.printStackTrace();
}finally {
//d***** //注意d:如果关流失败，表示强制回收流对象以释放文件
// 如果关流成功，表示释放内存
//5.释放资源
writer=null;
}
}
}
}
}
package IODemo;
import java.io.FileWriter;
import java.io.IOException;
public class IODemo03 {
public static void main(String[] args) {
//这种方式，在执行完成之后会自动关闭流 4.writer.close(); 5.释放资writer=null;
//从jdk1.7开始，要求这个使用的类必须实现AutoCloseable
//try() {} catch{}
//1. 根据给定的 File对象构造一个 FileWriter 对象
try(FileWriter writer=new FileWriter("D:\\A\\c.txt")){
//2.写入数据 .write()
writer.write("acv");
//3.冲刷缓冲区 .flush()
writer.flush();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
package IODemo;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class IODemo04 {
public static void main(String[] args) throws IOException {
//1.创建输入流对象
FileReader reader=new FileReader("D:\\A\\a.txt");
//2.读取数据 int read
//输入流没有缓冲区，需要循环读取
//2.1 public int read() 读取单个字符 返回值是表示的这个数据的编码 aaada返回97 zdsads返回122
//定义一个变量记录每次读取的字符
int i=-1; //i的初始化必须赋值，值随意
//读到末尾，返回-1
while((i=reader.read())!=-1) {
System.out.println((char)i);
}
//输入流没有缓冲区，自己创建缓冲区
//2.2 public int read(char[] cbuf,int offset,int length) 读取多个字符 ，返回值是读取的字符数
//存放多个字符，表示每次存储7个字符
//定义一个变量来记录每次读取的字符个数
int len=-1;
char[] cs=new char[7];
//读到末尾，返回-1
while((len=reader.read(cs))!=-1) {
//System.out.println(new String(cs));
//如果是abcdefghilklmnopq 返回abcdefg hijklmn oprklmn 出现错误
// Java为了提供效率，需要覆盖之前的缓冲区 opr覆盖hij,而klmn没有覆盖
System.out.println(new String(cs,0,len)); //所以这么改，每次从0读到len
}
//3.关流 .close
reader.close();
//注意:输入流没有缓冲区，不用3.flush()冲刷，不用5.=null
}
}
package IODemo;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class IOExer {
public static void main(String[] args) throws IOException {
//1.复制文件
//思想:一个输入流读取文件，然后将读取到内容写到新文件中
// 一个输出流写到新文件
//1.创建输入流对象Reader,输出流对象Writer
FileReader reader=new FileReader("D:\\A\\a.txt");
FileWriter writer=new FileWriter("D:\\A\\d.txt");
//2.不断read(),不断写write()
int len=-1; // 定义一个变量来记录每次读取的字符个数
char[] cs=new char[256]; // 创建有一个字符数组作为缓冲区
//读到末尾，返回-1
while((len=reader.read(cs))!=-1) {
writer.write(cs,0,len); //写入数据
}
//3.关闭操作
//writer.flush();
writer.close();
//writer=null;
reader.close();
}
}
package JDK7;
/*
* JDK7特性
* 1.二进制: 0b0010
* 2.整数使用下划线进行分位: 1_000_015
* 3.switch-case中允许使用String
* 4.异常的分组: |
* 5.泛型的推导:<>
* 6.try(){ try多了()
* }catch{
* }
*/
public class JDK7Demo01 {
}