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 {
}
