java基礎第十五篇之IO流和遞歸算法

FileInputStream : 輸入流

int available() : 一次讀取全部的字節數

read() : 將文件上的字節讀取到內存的數組中

FileOutputStream : 輸出流

write(byte[] b) : 將字節數組中的字節數據寫到文件上

緩衝區會在內存中建立一個8192容量的字節數組,內存的運算效率比硬盤要高的多全部只要下降到硬盤的讀寫次數就會提升效率.

定義小數組的標準格式:進行讀寫字節數據,要比緩衝流快一點點,由於定義小數組是操做一個的是一個數組,而緩衝流操做的是兩個數組.

public class Demo3_ArrayCopy {
public static void main(String[] args) throws IOException {
//method();
// method2();

FileInputStream fis = new FileInputStream("韓雪 - 想起.mp3");
FileOutputStream fos = new FileOutputStream("Copy.mp3");

byte[] arr = new byte[1024*8];
int len;
while((len = fis.read(arr)) != -1) {
fos.write(arr,0,len);
}
fis.close();
fis.close();

}


close方法:具有刷新的功能,在關閉流以前,就會先刷新一次緩衝區,將緩衝區的字節全都刷新到文件上.
* flush : 具有刷新的功能,刷完以後還能夠繼續寫.


* 字節流讀取中文的問題:字節流在讀中文的時候有可能會讀到半個中文,形成亂碼.
* 字節流寫中文的問題:字節流直接操做字節,全部寫出中文比較將字符串轉換成字節數組
* 寫出回車換行write("\r\n".getBytes());

//這是1.6版本以及之前的標準處理異常代碼
private static void method() throws FileNotFoundException, IOException {
//爲何要加null?這裏是局部變量,全部必需要賦值.
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream("xxx.txt");
fos = new FileOutputStream("yyy.txt");

int b;
while((b = fis.read()) != -1) {
fos.write(b);
}

}finally {
//try finally的嵌套目的是能關一個就儘可能關一個
try {
if(fis != null) {
fis.close();
}
}finally {

if(fos != null) {
fos.close();
}

}



}
}
}

///這些抽象類具有自動關閉功能,只要實現了AutoCloseable就具有了,自動關閉釋放流的功能
//這是jdk1.7版本的標準異常處理代碼
原理:在try()中建立的流對象必須實現了AutoCloseable這個接口,若是實現了,在try後面的{}(讀寫代碼)執行後就會自動調用流對象的close方法將流關閉釋放.
try (
//這些抽象類具有自動關閉功能,只要實現了AutoCloseable就具有了,自動關閉釋放流的功能
FileInputStream fis = new FileInputStream("xxx.txt");
FileOutputStream fos = new FileOutputStream("yyy.txt");
MyClose mc = new MyClose();

){
int b ;
while((b = fis.read()) != -1) {
fos.write(b);
}

/*FileInputStream fis = new FileInputStream("xxx.txt");
FileOutputStream fos = new FileOutputStream("yyy.txt");*/


}
/*fis.close();
fos.close();*/

}

/*
* 圖片加密
* 將寫出的字節異或上一個數,這個數就是密鑰,解密的時候再次異或就能夠了.
*/
public class Test1 {
public static void main(String[] args) throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("2017619-星期一-141543.jpg"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("Copy.jpg"));

int b;
while((b = bis.read()) != -1) {
//運算符 ^ 異或兩次就是他自己,全部這裏異或一次,進行加密
bos.write(b ^ 123);
}
bis.close();
bos.close();


}

//解密
/*BufferedInputStream bis = new BufferedInputStream(new FileInputStream("Copy.jpg"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("Copy2.jpg"));

int b;
while((b = bis.read()) != -1) {
//運算符 ^ 異或兩次就是他自己,全部這裏異或一次,進行加密
bos.write(b ^ 123);
}
bis.close();
bos.close();
*
*
*/

}

* 在控制檯錄入文件的路徑,將文件拷貝到當前項目下
*
* 分析:
*
* 1.建立鍵盤錄入對象,定義方法對鍵盤錄入的路徑進行判斷,若是是文件就返回
* 2.在主方法中接收該文件
* 3.讀和寫該文件
*
*
*/
public class Test2 {
public static void main(String[] args) throws IOException {
//獲取文件
File file = getFile();

BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file.getName()));

int b;
while((b = bis.read()) != -1) {
bos.write(b);
}
bis.close();
bos.close();

}

/*
* 定義一個方法獲取鍵盤錄入的文件路徑,並封裝成File對象返回
* 1.返回值類型File
* 2.參數列表無
*
*/
public static File getFile() {
Scanner sc = new Scanner(System.in);
//接收鍵盤錄入路徑
//String line = sc.nextLine();
System.out.println("請輸入一個文件的路徑");
while(true) {
String line = sc.nextLine();
//封裝成File對象,並對其進行判斷
File file = new File(line);
if(!file.exists()) {
System.out.println("您錄入的文件路徑不存在,請從新錄入:");
}else if(file.isDirectory()) {
System.out.println("請錄入的是文件夾路徑,請從新錄入");
}else {
return file;
}


}


}
}

/*
* 鍵盤錄入的數據拷貝到當前項目下的text.txt文件中,鍵盤錄入數據當遇到quit時就退出
*
* 分析:
* 1.建立鍵盤錄入對象
* 2.建立輸出流對象,關聯text.txt文件
* 3.定義無限循環
* 4.遇到quit退出循環
* 5.若是不quit,就將內容寫出
* 6.關閉流
*
*/
public class Test3 {
public static void main(String[] args) throws IOException {
//1.建立鍵盤錄入對象
Scanner sc = new Scanner(System.in);
//2.建立輸出流對象,關聯text.txt文件
FileOutputStream fos = new FileOutputStream("text.txt");
System.out.println("請輸入數據");
//3.定義無限循環
while (true) {
String lin = sc.nextLine();
//4.遇到quit退出循環
if("quit".equals(lin)) {
break;
}
//5.若是不quit,就將內容寫出
//字符串寫出鼻血轉換成字節數組
fos.write(lin.getBytes());
fos.write("\r\n".getBytes());
}
fos.close();


}
}
*/
/*
* 從鍵盤錄入一個文件夾路徑,統計該文件夾大小
*
* 從鍵盤錄入一個文件夾路徑
* 1.一個無限循環
* 2.定義一個無限循環
* 3.將獎品錄入的結果存儲並封裝成File對象
* 4.對File對象判斷
* 5.將文件夾路徑對象返回
*
* 統計該文件夾大小
* 1.定義一個求和變量
* 2.獲取該文件夾下全部的文件和文件夾ListFiles();
* 3.遍歷數組
* 4.判斷是文件就計算大小並累加
* 5.判斷是文件夾,遞歸調用
*
*/
public class Test1 {
public static void main(String[] args) {
/*File dir = getDir();
System.out.println(getFileLength(dir));*/
//直接獲取文件的大小是0
File dir = new File("F:\\day06");
System.out.println(dir.length());

}

/*
* 從鍵盤錄入接收一個文件夾路徑
* 1.返回值類型File
* 2.參數列表無
*
*/
public static File getDir() {
//1.建立鍵盤錄入對象
Scanner sc = new Scanner(System.in);
System.out.println("請輸入一個文件夾路徑:");
//2.循環
while(true) {
//將鍵盤錄入的結果存儲並封裝成File對象
String line = sc.nextLine();
File dir = new File(line);
//對File對象判斷
if(!dir.exists()) {
System.out.println("您錄入的文件夾路徑不存在,請輸入一個文件夾路徑:");
}else if(dir.isFile()) {
System.out.println("您錄入的是文件路徑,請輸入一個文件夾路徑:");
}else {
//將文件夾路徑對象返回
return dir;
}
}


}


/*
* 統計該文件夾大小
* 1.返回值類型 long
* 2.參數列表File
*
*/
public static long getFileLength(File dir) {
//1.定義一個求和變量
long len = 0;
// 2.獲取該文件夾下全部的文件和文件夾ListFiles();
File[] subFiles = dir.listFiles();
// 3.遍歷數組
for (File subFile : subFiles) {
//4.判斷是文件就計算大小並累加
if(subFile.isFile()) {
len = len + subFile.length();
// 5.判斷是文件夾,遞歸調用
}else {
len = len + getFileLength(subFile);
}

}




return len;
}

}
*/

/*

/*從鍵盤接收一個文件夾路徑,刪除該文件夾
*
* 刪除該文件夾
* 分析:
* 1.獲取該文件夾下的全部的文件和文件夾
* 2.遍歷數組
* 3.判斷是文件直接刪除
* 4.若是是文件夾,遞歸調用
* 5.循環結束後,把空文件夾刪掉
*
*/
public class Test2 {
public static void main(String[] args) {
//獲取文件夾路徑
File dir = Test1.getDir();

deleteFile(dir);

}
/*
* 刪除該文件夾
* 1.返回值類型void
* 2.參數列表:File dir
*
*/
public static void deleteFile(File dir) {
// 1.獲取該文件夾下的全部的文件和文件夾
File[] subFiles = dir.listFiles();
//2.遍歷數組
for (File subFile : subFiles) {
//3.判斷是文件直接刪除
if(subFile.exists()){
subFile.delete();
//4.若是是文件夾,遞歸調用
}else {
deleteFile(subFile);
}
}
//5.循環結束後,把空文件夾刪掉
dir.delete();


}
}

/*
* 從鍵盤接收兩個文件夾路徑,把其中一個文件夾中(包含內容)拷貝到另外一個文件夾中
*
* 分析:
* 1.在目標文件夾中建立原文件夾
* 2.獲取原文件夾中全部的文件和文件夾,存儲在File數組中
* 3.遍歷數組
* 4.若是是文件就用io流讀寫
* 5.若是是文件夾就遞歸調用
*
*/
public class Test3 {
public static void main(String[] args) throws IOException {
File src = Test1.getDir();
File dest = Test1.getDir();
if(src.equals(dest)) {
System.out.println("目標文件夾是原文件夾的子文件夾");
}else {
copy(src,dest);

}

}

/*把其中一個文件夾中(包含內容)拷貝到另外一個文件夾中
* 1.返回值類型void
* 2.參數列表:File src,File dest
*
*/
public static void copy(File src, File dest) throws IOException {
//1.在目標文件夾中建立原文件夾
File newDir = new File(dest, src.getName());
newDir.mkdir();
// 2.獲取原文件夾中全部的文件和文件夾,存儲在File數組中
File[] subFiles = src.listFiles();
//3.遍歷數組
for (File subFile : subFiles) {
if(subFile.isFile()) {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(subFile));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(new File(newDir,subFile.getName())));
int b;
while((b = bis.read()) != -1) {
bos.write(b);
}
bos.close();
bis.close();

}else {
copy(subFile,newDir);
}
}


}
UTF-8:用UTF-8編碼的Java文件英文字符佔一個字節,中文字符佔三個字節.

GBK:用GBK編碼的中文佔用兩個字節,英文佔用一個字節.

在Windows裏面的.txt文件中編碼的一個字符是佔用一個字節,一箇中文字佔用兩個字節(日文的一個日文字也佔用兩個字節)



}
/*
read() : 一次讀取一個字節
//建立一個文件輸入流對象,並關聯aaa.txt
FileInputStream fis = new FileInputStream("aaa.txt");
//定義變量,記錄每次讀到的字節
int b;
//將每次讀到的字節賦值給b並判斷是不是-1
while((b = fis.read() != -1) {
syso(b);
}
fis.close();

read()方法返回值爲何是int?
由於字節輸入流能夠操做任意類型的文件,好比圖片音頻等,這些文件底層都以二進制形式的存儲的,若是每次讀取都返回byte,有可能在讀到中間的時候遇到11111111
那麼這個11111111是byte類型的-1,咱們的程序是遇到-1就會中止不讀了,後面的數據就讀不到了,因此在讀取的時候用int類型接收,若是11111111會在其前面補上
24個0湊足4個字節,那麼byte類型的-1就編程int類型的255了這樣能夠保證整個數據讀完,而結束標記的-1就是int類型

write() : 一次寫出一個字節
//若是沒有bb.txt,會建立一個
FileOutputStream fos = new FileOutputStream("bb.txt");
//雖然寫出的是一個int數,可是在寫出的時候會將前面的24個0去掉,全部寫出的一個byte.
//fos.write(97);
fos.write(98);
fos.write(99);
fos.close();

緩衝思想:
字節流一次讀寫一個數組的速度明顯比一次讀寫一個字節的數據快不少,
這是加入了數組這樣的緩衝區效果,java自己在設計的時候.
也考慮到了這樣的設計思想(裝飾設計模式) , 因此提供了字節緩衝區流

BufferedInputStream
BufferedInputStream內置了一個緩衝區(數組)
從BufferedInputStream中讀取一個字節時
BufferedInputStream會一次性從文件中讀取8192個,存在緩衝區中,返回給程序一個
程序再次讀取時,就不用找文件了,直接從緩衝區中獲取.
直到緩衝區中全部的都被使用過,才從新從文本中讀取8192個.

BufferedOutputStream
BufferedOutputStream也內置了一個緩衝區(數組)
程序向流中寫字節時,不會直接寫到文件,先寫到緩衝區中
直到緩衝區寫滿,BufferedOutputStream纔會把緩衝區中的數據一次性寫到文件裏

拷貝代碼:
//建立文件輸入流對象,關聯致青春.mp3
FileInputStream fis = new FileInputStream("知情權.mp3");
//建立緩衝區對fis修飾
BufferedInputStream bis = new BufferedInputStream(fis);
//建立輸出流對象,關聯copy.MP3
FileOutputStream fos = new FileOutputStream("copy.mp3");
//建立緩衝區對fos裝飾
BufferedOutputStream bos = new BufferedOutputStream(fos);

int b;
while((b = bis.read() != -1) {
bos.write;
}
//只關裝飾後的對象便可
bis.close();
bos.close();

小數組的讀寫和帶Buffered的讀取那個更快?
定義小數組若是是8192個字節大小和Buffered比較的話
定義小數組會略勝一籌,由於讀和寫操做的是同一個數組
而Buffered操做的是兩個數組

flush和close的讀取那個更快?
flush()方法:
用來刷新緩衝流區的,刷新後能夠再次寫出
close()方法:
用來關閉流程釋放資源的,若是是帶緩衝區的流對象的close()方法,不但會關閉流,還會再關閉以前刷新緩衝區,關閉後不能再寫出.

* File類:文件和目錄路徑名的抽象表示形式。
*
* 文件:能夠保存數據的文件
* 目錄路徑名:指的文件夾,能夠保存文件的
*
* 一個File對象 能夠指一個文件 也能夠指一個文件夾
* 構造方法:
* 1.public File(String filename);
* 2.public File(String parent,String child)
* 3.public File(File parent,String child)
*/
public class FileDemo01 {

public static void main(String[] args) {
// TODO Auto-generated method stub
//1.public File(String filename);
File f1 = new File("E:\\黑馬66期\\1.txt");
System.out.println(f1);
//2.public File(String parent, String child)
File f2 = new File("E:\\黑馬66期","1.txt");
System.out.println(f2);
//3.public File(File parent, String child)
File parent = new File("E:\\黑馬66期");
File f3 = new File(parent, "1.txt");
System.out.println(f3);
}

}

* 文件:能夠保存數據的文件
* 目錄路徑名:指的文件夾,能夠保存文件的
* File類的成員方法:
* 第一組 獲取方法
*
* public String getAbsolutePath();//獲取絕對路徑(以盤符開頭的路徑);
*
* public String getPath();//獲取路徑,你用構造方法建立File對象時寫那個路徑
*
* public String getName();//獲取不帶路徑的文件名
*
* public long length();//獲取只能文件字節大小
*
*
*
*/
public class FileDemo02 {

public static void main(String[] args) {
// TODO Auto-generated method stub
//獲取絕對路徑
File f1 = new File("E:\\黑馬66期\\1.txt");
// File f1 = new File("a.txt");
// String absolutePath = f1.getAbsolutePath();
// System.out.println(absolutePath);
//獲取路徑
// String path = f1.getPath();
// System.out.println(path);
//獲取名字
// String name = f1.getName();
// System.out.println(name);
//獲取文件的長度
// long len = f1.length();
// System.out.println(len);
//能不能獲取文件夾的長度,不能獲取,獲取到的是一個不肯定的值
// File f2 = new File("E:\\黑馬66期\\test");
// long len = f2.length();
// System.out.println(len);
}

}

* 文件和文件夾的建立刪除等
*
* 1.public boolean createNewFile();//只能建立文件類型File對象,若是此文件存在 那麼建立失敗
*
* 2.public boolean mkdir();//makeDirectory,建立文件夾類型的File對象
*
* 3.public boolean exists();//判斷File 對象是否存儲在
*
* 4.public boolean isDirectory();//判斷是不是文件夾
*
* 5.public boolean isFile();//判斷是不是一個文件
*
* 6.public boolean delete();//刪除文件和文件夾對象
*
7.public boolean endsWith() : 判斷
*/
public class FileDemo03 {

public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
//1.建立文件
File f1 = new File("E:\\黑馬66期\\test\\a.txt");
// boolean b = f1.createNewFile();
// System.out.println(b);
//2.建立文件夾
// File f2 = new File("E:\\黑馬66期\\test\\a.txt");
// boolean b = f2.mkdir();
// System.out.println(b);
//3.判斷File對象是否存在
// File f3 = new File("E:\\黑馬66期\\test\\abcd.txt");
// System.out.println(f3.exists());
//4.判斷究竟是文件仍是文件夾
// System.out.println(f1.isDirectory());
// System.out.println(f1.isFile());
//5.刪除File對象(能夠是文件也能夠是文件夾)
File fd = new File("E:\\黑馬66期\\test\\abc.txt");
System.out.println(fd.delete());

}

}

* File類中另外兩個比較重要的方法
*
* 1. public String[] list();//列出表明文件夾的File對象中的文件和目錄,
* 若是調用方法的File對象表示的是一個文件,會返回null
*
*
* 2. public File[] listFiles();//列出表明文件夾的File對象中的文件和目錄,
* 若是調用方法的File對象表示的是一個文件,會返回null
*
*/
public class FileDemo01 {

public static void main(String[] args) {
// TODO Auto-generated method stub
//1.public String[] list()
// File fileDir = new File("F:\\demo");
// String[] files = fileDir.list();
// //遍歷這個files數組
// for (String file : files) {
// System.out.println(file);
// }
//2.File[] listFiles()
File fileDir = new File("F:\\demo\\1.txt");
File[] files = fileDir.listFiles();
for (File file : files) {
System.out.println(file.getAbsolutePath());
}

}

}

listFiles():過濾器

案例:
Java.io.File.listFiles(FileFilter filter) 返回抽象路徑名數組，表示在目錄中此抽象路徑名錶示，知足指定過濾器的文件和目錄。

聲明
如下是java.io.File.listFiles(FileFilter filter) 方法的聲明：

public File[] listFiles(FileFilter filter) 參數
filter - File filter

返回值
該方法返回抽象路徑名數組，表示在目錄中此抽象路徑名錶示，知足指定過濾器的文件和目錄。

異常
SecurityException -- 若是安全管理器存在而且其SecurityManager.checkRead(java.lang.String) 方法拒絕對文件的讀訪問

例子
下面的例子顯示 java.io.File.listFiles(FileFilter filter)方法的用法。

package com.yiibai;

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

public class FileDemo {
public static void main(String[] args) {

File f = null;
File[] paths;

try{
// create new file
f = new File("c:/test");

FileFilter filter = new FileFilter() {
@Override
public boolean accept(File pathname) {
return pathname.isFile();
}
};

// returns pathnames for files and directory
paths = f.listFiles(filter);

// for each pathname in pathname array
for(File path:paths)
{
// prints file and directory paths
System.out.println(path);
}
}catch(Exception e){
// if any error occurs
e.printStackTrace();
}
}
}
讓咱們編譯和運行上面的程序，這將產生如下結果：

c:\test\child_test.txt
c:\test\child_test.xlsx

* 遞歸:是一個算法,只要含有方法這種概念的編程語言均可以使用
* 就是在一個方法內部,調用了本身
* StackOverflowError:堆棧溢出錯誤(內存溢出)
* 遞歸:1.不能無限的調用本身,必須有出口
* 2.必須保證遞歸調用方法的次數有必定限制
* 遞歸在JavaEE開中用的仍是比較少的
* 並且遞歸有一個致命的缺點:急劇消耗內存(建議:實際開發能不用就不用)
* 遞歸的分類:
* 直接遞歸: A方法內部調用A方法
* 間接遞歸: A方法內部調用B B方法內部調用C .... Z方法內部調用A
* 遞歸的練習:
* 遞歸的代碼演示，計算1-n之間的和，使用遞歸完成
* 1.使用遞歸: a.肯定規律(分解式子) b.肯定出口
* 遞歸的代碼演示: 計算第100個斐波那契數列的元素的值
* a.肯定規律(分解式子) b.肯定出口
* 第一百個斐波那契數列的元素的值 f(100) = f(99)+f(98)
* ...
* f(1) = 1 f(2) = 1



* 世界一個著名的算法 漢諾塔算法
*
* 求斐波那契數列的前20個數和
*/
1+1+2+3+5+8+12+20

public class DiGuiDemo01 {

public static int getSum1(int a,int b){ //a = 1,b = 1
if(b > ((b-1)+(b-2)) {
return sum;
}
int temp = b;
b = a + b ;



a = temp;

sum = b + getsum1(a,b);

return sum ;b + getsum1(a , b);//b = 2,a = 1;b = 3,a = 2;b = 5,
}

public static void main(String[] args) {
// TODO Auto-generated method stub
// int num = getSum(1000);
// System.out.println(num);
long num = getFBNum(30);//1 1 2 3 5 8 13 21 34 55
System.out.println(num);
}
/*
* 求第100個斐波那契數列的元素的值
*/
public static long getFBNum(int n){
if(n==1 || n == 2){
return 1;
}
return getFBNum(n-1)+getFBNum(n-2);
}


/*
* 寫一個方法求1-n的和
* 1+2+...+n=== f(n)
* 1+2+...n-1 === f(n-1)+n
* f(n) = f(n-1)+n;
* f(n-1) = f(n-2)+(n-1)
* f(n-2) = f(n-3)+n-2..
* ....
* f(2) = f(1)+2
* f(1) = 1
*
*/
public static int getSum(int n){
if(n == 1){
return 1;
}
return getSum(n-1)+n;
// int sum = 0;
// for (int i = 1; i < n+1; i++) {
// sum+=i;
// }
// return sum;
}
public static void demo01(){
System.out.println("demo01");
demo01();
}

}

import java.io.File;

/*
* 需求: 給你一個文件夾的File對象
* 要求列出該文件夾下全部文件(若是包括有文件夾,那麼要求也要列出子文件夾下的文件)
*
*/
public class FileDiGuiDemo {

public static void main(String[] args) {
// TODO Auto-generated method stub
showFiles(new File("D:\\"));
}
/*
* 定義方法:列出一個文件夾的File對象的中的文件
*/
public static void showFiles(File fileDir){//參數表明一個文件夾的File對象
if(fileDir==null || fileDir.isFile()){
System.out.println("我要的是一個文件夾的File,文件的File不行!");
return;
}
File[] files = fileDir.listFiles();
if(files==null){
return;
}
for (File file : files) {
if(file.isFile()){
System.out.println(file);
}else if(file.isDirectory()){
//是一個文件夾 那麼無論他
showFiles(file);//調用本身 ,傳入一個文件夾
}
}
// File[] files = fileDir.listFiles();
// System.out.println(files);
// System.out.println(files.length);

}

}

/*
* File中的另一個方法:
* File[] listFiles(FileFilter filter);//列出當前文件夾下 咱們要求的File對象
*
*
*/
public class FilterDemo01 {

public static void main(String[] args) {
// TODO Auto-generated method stub
//1.建立文件夾對象
File fileDir = new File("F:\\demo");
//2.調用方法
//2.1先建立一個過濾器的實現類對象
FileFilter ff = new FileFilter(){

@Override
public boolean accept(File pathname) {
// TODO Auto-generated method stub
if(pathname.getName().length() <= 6){
return true;
}
return false;
}

};

File[] files = fileDir.listFiles(ff);

System.out.println(files.length);
for (File file : files) {
System.out.println(file);
}
}

}

/*
* 策略設計模式:
* 核心思想:把邏輯和算法分離,提升程序的擴展和靈活性.
*
* 核心技術:把方法做爲參數傳遞(傳遞的一個接口的實現類)
*
* 自定義一個工具類 MyCollections 提供一個靜態方法sort用來排序數組
* 自定義一個工具類 MyCollections 提供一個靜態方法sort用來字符串數組
*
*/
public class CeLveDemo2 {
public static void main(String[] args) {
demo01();
System.out.println();
demo02();
}

public static void demo02() {
String[] strs = {"java","hello","world","heimama","baiducn","man","idaidaodo"};
MyCollections.sortString(strs, new CompareStringInterface() {

@Override
public boolean compare(String str1, String str2) {
// TODO Auto-generated method stub
if(str1.charAt(0)>str2.charAt(0)) {
return true;
}
return false;
}
});
for(String string : strs) {
System.out.print(string + " ");
}
System.out.println();

}

/*
* 排序int 數組
*
*/
public static void demo01() {
int[] num3 = {2,56,3,5674,67,43,35,67890};
MyCollections.sort(num3, new CompareInterface() {

@Override
public boolean compare(int num1, int num2) {
// TODO Auto-generated method stub
if(num1 < num2) {
return true;
}
return false;
}

});
for(int num : num3) {
System.out.print(num + " ");
}
}

}

public class MyCollections {
private MyCollections() {}
public static void sort(int[] nums,CompareInterface ci) {
//冒泡
for(int i = 0; i < nums.length -1; i++) {
for(int j = 0 ; j< nums.length - 1- i; j++) {
//交換
int temp = nums[j];
nums[j] = nums[j+1];
nums[j+1] = temp;
}
}



}
/*
* 字符串排序
*
*/
public static void sortString(String[] arr,CompareStringInterface sci) {
for(int i = 0; i < arr.length-1 ; i++) {
for(int j = 0; j < arr.length-1-i; j++) {
//比較 arr[j] arr[j+1]
if(sci.compare(arr[j], arr[j+1])) {
String str = arr[j];
arr[j] = arr[j+1];
arr[j+1] = str;
}
}
}
}




}

interface CompareInterface {
public abstract boolean compare(int num1,int num2);
}

interface CompareStringInterface {
public abstract boolean compare(String str1,String str2);
}

File file = new File("demo02.txt");

//文件的大小
System.out.println(file.getTotalSpace());

//File對象的路徑名
System.out.println(file.getPath());
//文件的絕對路徑
System.out.println(file.getAbsolutePath());

/*
import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;

public class Test5 {
public static void main(String[] args) {
File file = new File("D:\\新建文件夾\\新建文件夾");
System.out.println(file);
/*
FileFilter ff = new FileFilter() {

@Override
public boolean accept(File pathname) {


//File file = new File(pathname);



return pathname.isFile() && pathname.getName().endsWith(".txt");


//return false;
}

};


File[] list = file.listFiles(ff);

for (File file2 : list) {
System.out.println(file2);
}
*/

/* File[] files = file.listFiles(new FileFilter() {
//把文件夾下面的全部文件包括文件夾進行判斷,若是返回true則添加到File[] files數組中
@Override
public boolean accept(File pathname) {//這個File pathname : 表示的是這個是路徑的File對象
// TODO Auto-generated method stub
//File file = new File(pathname);
System.out.println(pathname);
return true;
}
});*/
/*File[] files = file.listFiles(new FilenameFilter() {

@Override
public boolean accept(File dir, String name) {
//File dir :這個是盤符的意思(也就是文件名稱之前的東西),name : 這個是文件名稱
// TODO Auto-generated method stub
File file = new File(dir,name);
return file.isFile() && file.getName().endsWith(".txt");
}
});*/

File[] files = file.listFiles(new FilenameFilter() {

@Override
public boolean accept(File dir, String name) {
// TODO Auto-generated method stub

System.out.println(dir);
System.out.println(name);
return true;
}
});

/*for (File file2 : files) {
System.out.println(file2);
}*/

}
}
*/

/*
File : renameTo(File file) : 重命名的方法(將原先的File對象的名字修改成一個新的File對象)

* newLine() 與 \r\n的區別
* newLine()是跨平臺的方法
* \r\n只支持的是windows系統

標準讀寫字符流操做

*將一個文本文檔上的文本反轉,第一行和倒數第一行交換,第二行和倒數第二行交換
*
* 分析:
* 1.建立輸入輸出流對象
* 2.建立集合對象
* 3.將讀到的數據存儲在集合中
* 4.倒着遍歷集合將數據寫到文件上
* 5.關流
*
* 注意事項:
* 流對象儘可能晚開早關
*
*/
public class Tet1 {
public static void main(String[] args) throws IOException {
//改寫後儘可能晚開早關
//1.建立輸入輸出流對象
BufferedReader br = new BufferedReader(new FileReader("xxx.txt"));

//2.建立集合對象
ArrayList<String> list = new ArrayList<>();
//3.將讀到的數據存儲在集合中
String line;
while((line = br.readLine()) != null) {
list.add(line);
}
br.close();
BufferedWriter bw = new BufferedWriter(new FileWriter("yyy.txt"));
//4.倒着遍歷集合將數據寫到文件上
for(int i = list.size() -1; i >= 0;i--) {
bw.write(list.get(i));
bw.newLine();
}
//關流

bw.close();

}
}

public class Demo5_LineNumberReader {
public static void main(String[] args) throws IOException {
//多了一個行號:能夠添加行號
LineNumberReader lnr = new LineNumberReader(new FileReader("xxx.txt"));

String line;
//添加的行號以101開始的
lnr.setLineNumber(100);
while((line = lnr.readLine()) != null) {
System.out.println(lnr.getLineNumber() + ":" + line);
}

lnr.close();
}
}

/*
* 裝飾設計模式:耦合性不強,被裝飾的類的變化與裝飾類的變化無關
*
*/
public class Demo_Wrap {
public static void main(String[] args) {
HeiMaStudent hms = new HeiMaStudent(new Student());

hms.code();

}
}

interface Coder {
public void code();
}

class Student implements Coder {

@Override
public void code() {
// TODO Auto-generated method stub
System.out.println("javase");
System.out.println("javaweb");
}

}

class HeiMaStudent implements Coder {
//獲取學生引用(獲取學生對象)
//獲取被裝飾類的引用
private Student s;
//2.在構造方法中傳入被裝飾類的對象
public HeiMaStudent(Student s) {
this.s = s;
}
//3.對原有的的功能進行升級
@Override
public void code() {
// TODO Auto-generated method stub
s.code();
System.out.println("ssh");
System.out.println("數據庫");
System.out.println("大數據");
System.out.println("...");


}

}

public class Demo7_TransTo {
public static void main(String[] args) throws IOException {
//method();
//method1();
/*
* BufferedReader -- InputStreamReader(字節流,編碼表)字節通向字符的橋樑,經過指定的編碼表將字節轉換爲字符.---FileInputStream -- ut-8txt
* BufferedWriter -- OutputStreamWriter(字節流,編碼表)字符通向字節的橋樑,經過指定的編碼表將字符轉換爲字節 -- FileOutputStream -- gbk.txt
*
*
*/

//更高效的讀
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("utf-8.txt"), "utf-8"));
//更高效的寫
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("gbk.txt"), "gbk"));
int c;
while((c = br.read()) != -1) {
bw.write(c);
}
br.close();
bw.close();



}

private static void method1() throws UnsupportedEncodingException, FileNotFoundException, IOException {
//指定碼錶讀字符
InputStreamReader isr = new InputStreamReader(new FileInputStream("utf-8.txt"),"uTf-8");
//指定碼錶寫字符
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk.txt"), "gbk");

int c;
while((c = isr.read()) != -1) {
osw.write(c);
}
isr.close();
osw.close();
}

private static void method() throws FileNotFoundException, IOException {
//用默認編碼表讀寫,出現亂碼
FileReader fr = new FileReader("utf-8.txt");
FileWriter fw = new FileWriter("gbk.txt");
int c;
while(( c = fr.read()) != -1) {
fw.write(c);
}
fr.close();
fw.close();
}
}

/*
* 當咱們下載一個試用軟件,沒有購買正版的時候,每執行一次就會體系咱們換有多少次使用機會用學過的IO流只是,模擬試用版軟件
* 使用10次機會,執行一次就提示一次您換有幾回機會,若是次數到了
*
* 分析:
* 1.建立帶緩衝的輸入流對象,由於要使用readLine方法,能夠保證數據的原樣性
* 2.將讀到的字符串轉換爲int數
* 3.對int數進行判斷,若是大於零,就將其--寫回去,若是不大於零,就提示請購買正版
* 4.在if判斷中要將--的結果打印,並將結果經過輸出流寫到文件上
* 5.
*/
public class Test2 {
public static void main(String[] args) throws IOException {
//1.建立帶緩衝的輸入流對象,由於要使用readLine方法,能夠保證數據的原樣性
BufferedReader br = new BufferedReader(new FileReader("config.txt"));
//2.將讀到的字符串轉換爲int數
String line = br.readLine();
//System.out.println(line);
//將數字字符串轉換爲數字
int times = Integer.parseInt(line);
//3.對int數進行判斷,若是大於零,就將其--寫回去,若是不大於零,就提示請購買正版
if(times > 0) {
//4.在if判斷中要將--的結果打印,並將結果經過輸出流寫到文件上
System.out.println("您還有" + times-- + "次機會");
FileWriter fw = new FileWriter("config.txt");
fw.write(times + "");
fw.close();


}else {
System.out.println("您的試用次數已到,請購買正版");
}
br.close();

}
}

* 遞歸:方法字節調用本身
*
* 遞歸的弊端:不能調用次數過多,容易致使棧內存溢出
* 遞歸的好處:不用知道循環次數
*
* 構造方法用不能使用遞歸調用
*
* 遞歸調用不必定必須有返回值


* IO流對象: 數據進行讀取和寫入
* Input:數據讀取
* Output:數據寫出
*

Java中IO流分類:
按照操做數據分類
字節流:能讀全部任意的文件
字符流:只能讀寫文本文件,((只要能用文本工具打開並且打開後還能看懂的)(記事本,notepad++等等)這些都是文本文件)
文本文件有:.txt,.java.html,.css,.其餘編程語言的源碼
注意:world,excel,ppt都不是文本文件

按照數據的流向分類
輸入流:從外界設備 讀取數據 到內存;
輸出流:從內存寫數據 到外界設備.

總結:總共有四種流

1.字符輸入流:reader是根類(基類)(抽象類) 方法:read(讀一個字符,讀一個字符數組)
FileReader,BufferedReader

2.字符輸出流 :writer是根類(基類)(抽象類) 方法:writer(寫一個字符,寫一個字符數組(一部分),寫一個字符串(一部分)
FileWriter,BufferedWriter

3.字節輸入流: InputStream(基類)(抽象類) 方法:read(一個字節,讀一個字節數組)
FileInputStream

4.字節輸出流:OutputStream(基類)(抽象類) 方法:writer(寫一個字節,寫一個字節數組(一部分)
FileOutputStream

java中的流命名十分講究:
功能+流的基類(FileReader,OutputStream)

OutputStream:字節輸出流根類
1.public voidwrite(int b) ; 寫一個字節

2.

* InputStream:字節輸入流(讀數據)
* 子類:FileInputStream
* 1.public int read();//讀取一個字節
*
* 2.public int read(byte[] bs);//讀取一個字節數組
*
*/
public class InputStreamDemo01 {

public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
//1.建立字節輸入流對象(多態)
InputStream is = new FileInputStream("a.txt");
/*
* 1.建立了一個字節輸入流對象
* 2.若是文件不存在 那麼報錯
* 3.把流指向文件
*/
//2.一次讀取一個字節
//int b = is.read();//0000 0000 0000 0000 0000 0000 0101 0100
//System.out.println((char)b);//0000 0000 0101 0100
//b = is.read();//0000 0000 0000 0000 0000 0000 0101 0100
//System.out.println((char)b);//0000 0000 0101 0100
//3.一次讀取一個字節數組
byte[] bs = new byte[4];
int len = is.read(bs);
System.out.println(len);
System.out.println(new String(bs,0,len));

//再讀一次
len = is.read(bs);
System.out.println(len);
System.out.println(new String(bs,0,len));


}

}

* OutputStream:字節輸出流根類
* 子類:FileOutputStream
* 1.public void write(int b);//寫一個字節
* 2.public void wirte(byte[] bs);//寫一個字節數組
*
* 3.public void wirte(byte[] bs,int start,int len);//寫一個字節數組的一部分
*
*
* 追加問題:
* 只要建立流的時候;
* new FileOutputStream("a.txt",true);
* 換行問題:
* windows: \r\n
* Linux: \n
* Mac Os: \r
*/
public class OutputStreamDemo01 {

public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
//1.建立一個文件的字節輸出流(多態的方式)
OutputStream os = new FileOutputStream("a.txt");
/*
* 1.建立了一個字節輸出流對象
* 2.若是文件不存在,建立這個文件對象
* 3.讓這個流指向這個文件
*/
//2.調用寫數據方法 write
//寫一個字節
// os.write(106);
// os.write(97);
// os.write(118);
// os.write(97);
//寫一個字節數組 ILOVEYOUTIGER
// byte[] bs = {106,97,118,97,97,97};
//byte[] bs = "ILoveJavaEE".getBytes();
//寫"中國我愛你"
// byte[] bs1 = "中國我愛你".getBytes();
// System.out.println( bs1.length);
// System.out.println(bs1[0]);
// System.out.println(bs1[1]);
// os.write(bs1);
//寫一個字節數組的一部分
// byte[] bs = "中國我愛你".getBytes();
// os.write(bs, 0, 6);
for(int i = 0;i< 10;i++){
os.write("我愛你中國".getBytes());
os.write("\r\n".getBytes());
}

//3.關閉流
os.close();

}

}

/*
* 字節流複製文件(能夠複製任意文件) C:\Users\yingpeng\Desktop\pictures\3.png
*
* 1.源文件 : 3.png---->FileInputStream
* 2.目標文件: copy.png---->FileOutputStream
*
*
*
*/
public class CopyFileDemo01 {

public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
//1.建立流對象(2個,一個讀 一個寫)
FileInputStream fis = new FileInputStream("C:\\Users\\yingpeng\\Desktop\\pictures\\3.png");
FileOutputStream fos = new FileOutputStream("copy.png");
//2.一邊讀取數據 一邊寫入數據
//a.一次讀取一個字節 寫入一個字節
// int b = fis.read();
// fos.write(b);
//標準代碼==================
// int b = 0;
// while( (b = fis.read())!=-1){
// fos.write(b);
// }
//b.一次讀取一個字節數組
long s = System.currentTimeMillis();
//標準代碼
byte[] bs = new byte[1024];//保存讀取到的數據
int len = 0;//保存實際讀取到的字節數
while( (len = fis.read(bs))!=-1 ){
fos.write(bs,0,len);
}
//3.釋放資源
fos.close();
fis.close();

long e = System.currentTimeMillis();
System.out.println(e-s);
}

}

* FileReader---->BufferedReader
* FileWriter---->BufferedWriter
*
* FileInputStream---->BufferedInputStream
* FileOutputStream----->BufferedOutputStream
*
* 1.BufferedOutputStream:字節緩衝輸出流(寫數據)
* public BufferedOutputStream(OutputStream out)
* a.public void write(int b);
* b.public void write(byte[] bs);
* c.public void wirte(byte[] bs,int start,int len);
*
*
*/
public class BufferedDemo01 {

public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
//1.建立字節緩衝輸出流對象
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.txt"));
//2.調用bos的寫數據方法
//寫一個字節
// bos.write(49);
// bos.write(48);
// bos.write(48);
//寫一個字節數組
// byte[] bs = {49,48,48,48};
// bos.write(bs);
//寫 "helloworld"
// byte[] bs = "helloworld".getBytes();
// bos.write(bs);
byte[] bs = "鳳a姐".getBytes();
System.out.println(bs.length);
bos.write(bs,2,3);
//3.關閉流
bos.close();

}

}

/*
* BufferedInputStream-->字節緩衝輸入流(讀數據)
*
* 構造:
* public BufferedInputStream(InputStream in)
*
* 練習:使用BufferedInputStream讀取一個txt文件打印到控制檯
*/
public class BufferedInputStreamDemo {

public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
//1.建立字節緩衝輸入流對象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("ArrayList.java"));
//a.一次讀取一個字節
// int b = 0;//保存讀取到字節
// while((b = bis.read())!=-1){
// System.out.print((char)b);
// }
//b.一次讀取一個字節數組
int len = 0;//實際讀取的個數
byte[] bs = new byte[1024];
while((len=bis.read(bs))!=-1){
System.out.print(new String(bs,0,len));
}

//3.關閉
bis.close();

}
public static void demo01() throws IOException{
//1.建立字節緩衝輸入流對象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("1.txt"));
//調用bis的讀數據方法
//a.一次讀取一個字節
// int b = bis.read();
// System.out.println((char)b);
//b.一次讀取一個字節數組
// byte[] bs = new byte[2];
// int len = bis.read(bs);
// System.out.println(len);
// System.out.println(new String(bs,0,len));
//
// len = bis.read(bs);
// System.out.println(len);
// System.out.println(new String(bs,0,len));
//3.關閉
bis.close();

}
}

*/

/*
/*
* 內存輸出流:該輸出流能夠向內存中寫數據,把內存看成一個緩衝區,寫出以後
*
* FileInputStream讀取中文的時候會出現亂碼
*
* 解決方案:
* 1.使用字符流
*
* InputStream:字節輸入流(讀數據)
* 子類:FileInputStream
* 1.public int read();//讀取一個字節
*
* 2.public int read(byte[] bs);//讀取一個字節數組
*
*/
public class InputStreamDemo01 {

public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
//1.建立字節輸入流對象(多態)
InputStream is = new FileInputStream("a.txt");
/*
* 1.建立了一個字節輸入流對象
* 2.若是文件不存在 那麼報錯
* 3.把流指向文件
*/
//2.一次讀取一個字節
//int b = is.read();//0000 0000 0000 0000 0000 0000 0101 0100
//System.out.println((char)b);//0000 0000 0101 0100
//b = is.read();//0000 0000 0000 0000 0000 0000 0101 0100
//System.out.println((char)b);//0000 0000 0101 0100
//3.一次讀取一個字節數組
byte[] bs = new byte[4];
int len = is.read(bs);
System.out.println(len);
System.out.println(new String(bs,0,len));

//再讀一次
len = is.read(bs);
System.out.println(len);
System.out.println(new String(bs,0,len));


}

}

*/
public class DmeoByteArrayOutputStream {
public static void main(String[] args) throws IOException {
//emthod();
//在內存中建立了能夠增加的內存數組
FileInputStream fis = new FileInputStream("e.txt");
//ByteArrayOutputStream不用關流
ByteArrayOutputStream baos = new ByteArrayOutputStream();
int b;
//將讀取到的數據逐個寫到內存中
while ((b = fis.read()) != -1) {
baos.write(b);
}
//
//將緩衝區的數據所有獲取出來,並賦值給arr數組
//他可使用指定的編碼表轉換
byte[] arr = baos.toByteArray();
System.out.println(new String(arr));
//使用的是默認的編碼表進行轉換輸出
//將緩衝區的內容轉換爲了字符串,在輸出語句中能夠省略調用toString()方法
System.out.println(baos.toString());
fis.close();


}

//使用字符流解決問題中文輸入問題
private static void emthod() throws FileNotFoundException, IOException {
FileInputStream fis = new FileInputStream("e.txt");
byte[] arr = new byte[3];
int len;
while((len = fis.read(arr)) != -1) {
System.out.println(new String(arr,0,len));
}

fis.close();
}
}

/*

public class Test {
public static void main(String[] args) throws IOException {
//建立流對象(2個,一個讀,一個寫)
//一次讀取一個字節數組
FileInputStream fis = new FileInputStream("韓雪 - 想起.mp3");
FileOutputStream fos = new FileOutputStream("Copy.mp3");
//標準代碼
//保存讀到到的數據
byte[] bs = new byte[1024];
//保存實際讀取到的字節數
int len;
while((len = fis.read(bs)) != -1) {
fos.write(bs,0,len);
}
//3.釋放資源
fos.close();
fis.close();



}
}

* 複製單級文件夾:
*
* 0.建立目標文件夾(若是不存在) F:\\test
*
* 1.建立一個File對象(表明要複製的源文件夾) E:\\demo
*
* 2.調用File對象的listFiles方法 獲取文件夾中全部的文件對象
*
* 3.挨個複製文件對象 到 目標文件夾中
* 源文件 E:\\demo\\1.txt---> 目標文件 F:\\test\\1.txt
*/
public class CopyDirectoryDemo {

public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
//0.建立目標文件夾(若是不存在) F:\\test
File fileDest = new File("F:\\test");
if(!fileDest.exists()){
fileDest.mkdir();
}
//1.建立源文件夾的File對象
File fileSrc = new File("E:\\demo");
//調用fileSrc的listFiles
File[] files = fileSrc.listFiles();
for (File file : files) {
System.out.println(file);//源文件 E:\demo\1.txt
File newFile = new File(fileDest,file.getName());//目標文件 F:\\test\\1.txt
System.out.println(newFile);
//複製文件 從file 複製到newFile
copyFile(file,newFile);
}
}

public static void copyFile(File file, File newFile) throws IOException {
// TODO Auto-generated method stub
//複製文件 源文件 file 目標文件 newFile
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(newFile));

//循環讀取文件 寫入文件
int len = 0;
byte[] bs = new byte[1024];
while((len= bis.read(bs))!=-1){

bos.write(bs, 0, len);
}
//關閉流
bis.close();
bos.close();
System.out.println("複製文件"+file.getAbsolutePath()+"成功!");
}

}

*
* 求前n個斐波那契數列的元素之和
* 1.求第n個斐波那契數列的元素
* f(n) = f(n-1)+f(n-2)
* f(2) = 1
* f(1) = 1
* 2.求前n個斐波那契數列的元素之和
* sum(n) = sum(n-1)+ getFBNum(n)
* sum(1) = 1
*
* 留一個題:
* 求前n個數的和
* 1 1+2 1+2+3 1+2+3+4 1+2+3+4+5

第n個數爲
1 3 6 10 15
*
*/
public class DiGuiDemo {

public static int sum(int n) {
if(n == 1) {
return 1;
}
return n + sum(n-1); //n = 3,(3+2+1)
}

public static int getSum(int n) {
if(n == 1) {
return 1;
}
return sum(n) + getSum(n-1);
}

public static void main(String[] args) {
// TODO Auto-generated method stub
//測試
// int num = getFBNum(5);
// System.out.println(num);
int sum = getSum(6);//1 1 2 3 5 8
System.out.println(sum);
}
/*
* 求第n個斐波那契數列的元素
*/
public static int getFBNum(int n){
if(n==1){
return 1;
}
if(n==2){
return 1;
}
return getFBNum(n-1)+getFBNum(n-2);
}

/*
*前n個元素之和
*/
public static int getSum(int n){
if(n==1){
return 1;
}
//sum(n) = sum(n-1)+ getFBNum(n)
return getSum(n-1)+getFBNum(n);
}
}

* Properties類:是Map接口的一個實現,具備map接口下的全部功能
* 沒有泛型,Key和Value都是String類型
* 1.put(String key,String value)---->setProperty(String key,String value)
* 2.get(String key)---->getProperty(String key);
* 3.刪除方法 仍是使用 map接口中的remove方法
*
* 4.keySet();//以鍵找值 ----->Set<String> stringPropertyNames();
* 5.entrySet();//鍵值對 只要map中有
*
* 持久屬性集的用法:
* public void store(OutputStream out, String comments);
* 把屬性集Properties對象中數據保存到 一個輸入流中
* public void load(InputStream inStream);
* 從輸入流中加載數據
*/
public class PropertiesDemo {
public static void main(String[] args) throws IOException {
// //1.建立一個Properties對象
// Properties ps = new Properties();
// //2.添加數據
// ps.setProperty("zhangsan", "18");
// ps.setProperty("lisi", "28");
// ps.setProperty("rose", "38");
// ps.setProperty("jack", "48");
// //3.保存數據
// ps.store(new FileOutputStream("abc.properties"), "");

//4.從輸入流中加載數據
Properties ps = new Properties();
System.out.println(ps);
ps.load(new FileInputStream("abc.properties"));
System.out.println(ps);

}
/*
* 基本用法
*/
public static void demo01(){
//1.建立一個Properties對象
Properties ps = new Properties();
//2.添加數據
ps.setProperty("zhangsan", "18");
ps.setProperty("lisi", "28");
ps.setProperty("rose", "38");
ps.setProperty("jack", "48");
//System.out.println(ps);
// String value = ps.getProperty("jack");
// System.out.println(value);
//遍歷ps集合
Set<String> namesSet = ps.stringPropertyNames();
//foreach或者迭代器
for (String name : namesSet) {
String value = ps.getProperty(name);
System.out.println(name+"="+value);
}
}
}

/*
* 一個文件夾複製到另一個盤符下(這個被複制的文件夾裏面有還有文件夾,文件夾裏面還有文件.)
* 複製多個文件夾以及內容進行復制
*
* 分析:
* 1.建立新的文件路徑(這個是須要複製到的位置)對象,再建立一個路徑對象
* 2.定義方法,這個方法裏面判斷當前文件夾下面全部的文件,
* 3.若是是文件用方法進行復制,
* 4.若是是文件夾就用新的file對象去封裝成一個新的盤符路徑,再把新的盤符路徑和這個循環出來的文件進行遞歸
*
*/
public class Test5 {
public static void main(String[] args) throws IOException {
File file = new File("F:\\demo");
File newFile = new File("E:\\dmeo2");
method(file,newFile);
}
//用方法進行遞歸判斷尋找文件並建立文件夾
public static void method(File file,File newFile) throws IOException {
File[] files = file.listFiles();
for (File file2 : files) {
if(file2.isDirectory()) {
File file3 = new File(newFile,file2.getName());
file3.mkdirs();
method(file2,file3);
}else {
File file4 = new File(newFile,file2.getName());
copy(file2,file4);
}
}

}
//用方法進行文件複製
private static void copy(File file2, File file4) throws IOException {
// TODO Auto-generated method stub
FileInputStream fis = new FileInputStream(file2);
FileOutputStream fos = new FileOutputStream(file4);
byte[] b = new byte[1024];
int i;
while((i = fis.read(b)) != -1) {
fos.write(b, 0, i);
}
fis.close();
fos.close();


}
}

UTF-8:字母表明一個字節,漢子表明三個字節

GBK : 字母是一個字節,漢子是兩個字節

public static void main(String[] args) throws IOException {
//1.封裝源目錄:
File srcDir = new File("D:\\單級目錄");
//2.封裝目標目錄:
File destDir = new File("E:\\");
//3.判斷目標目錄下是否包含要複製的目錄:
destDir = new File(destDir,srcDir.getName());//new File("E:\\單級目錄");
if(!destDir.exists()){
destDir.mkdir();//建立目錄
}
//4.獲取源目錄下全部子文件的File數組;
File[] fileArray = srcDir.listFiles();
if(fileArray!= null){
//5.遍歷數組,獲取每一個File對象;
for(File f : fileArray){
//針對每一個File對象建立獨立的輸入流(字節流)
FileInputStream in = new FileInputStream(f);
//並向目標位置建立獨立的輸出流(字節流)
FileOutputStream out = new FileOutputStream(new File(destDir,f.getName()));
//開始複製-->一次複製一個字節數組
byte[] byteArray = new byte[1024 * 8];
int len = 0;
while((len = in.read(byteArray)) != -1){
out.write(byteArray,0,len);
}
out.close();
in.close();
}

}
System.out.println("複製完畢!");
}
<上一題

public static void main(String[] args) throws Exception {
//建立源目錄
File file = new File("D:/java");
//獲取文件
File[] files = file.listFiles();
//建立輸入流對象
InputStream in = null;
//建立輸出流對象
OutputStream out = null;
//記錄源文件夾中文件的名稱
String fileName = null;
// 記錄 目標文件夾中文件的名稱
String destName = null;
//指定目標文件夾
File f = new File("D:/jad");
//遍歷
for (File file2 : files) {
in = new FileInputStream(file2);
//查看 目標文件夾 是否存在
if(!f.exists()){
f.mkdir();
}
//獲取源文件夾中文件的名稱
fileName = file2.getName();
destName = fileName;
//建立複製的文件輸出流
out = new FileOutputStream(new File("D:/jad/"+destName));
int len = 0;
byte[] b = new byte[1024];
//完成複製
while((len = in.read(b))!= -1){
out.write(b, 0, len);
//System.out.println(new String(b,0,len));
}
}
}
<上一題

1.刪除目錄主要用到的知識：File類和遞歸。
2.本題的完整代碼爲：
public class Test {
public static void main(String[] args) {
delete(new File("D:/a"));
}

public static void delete(File f) {
// 判斷是不是文件夾
if (f.isDirectory()) {
File[] files = f.listFiles();
for (File file : files) {
delete(file);
file.delete();
}
}
// 刪除操做
f.delete();
}
}

public static void main(String[] args) throws Exception {
//一、明確源文件與目的地
File sourse = new File("E:\1.mp3");
File order = new File("E:\\1_copy.mp3");
//二、建立兩個流對象
FileOutputStream out = new FileOutputStream(order);
FileInputStream in = new FileInputStream(sourse);
//三、循環讀，而且將每一次讀到的內容都使用輸出流輸出到目的地
int len = -1;
byte[] b = new byte[1024];
while((len = in.read(b))!=-1){
//四、說明內容有效，文件尚未結束，能夠循環讀
//五、此時向目的地寫數組中的內容，要明確有效數據的個數
out.write(b,0,len);
}
//五、循環結束後，就複製完成了，關閉資源
out.close();
in.close();
}

package cn.baidu04_Test;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 複製文件夾（含子文件夾）
*
* 需求： D:\\YesDir 文件夾 複製到 當前項目下的 Copy目錄中
*
* 分析：
* 數據源 --- D:\\YesDir 文件夾
* 目的地 --- Copy 文件夾
*
* 1.找到數據源，看數據源是否存在
* 指定目的地
* 2.看是否有目的地文件夾
* 若是沒有目的地文件夾，建立目的地文件夾
* 3.獲取數據源中全部的File對象
* 4.經過遍歷，獲得數據源中每個File對象
* 5.判斷是否爲文件夾
* 是：說明是文件夾， 進入到子文件夾中
* file -- D:\\YesDir\\小視頻
* 完成子文件夾的複製
* a.找到數據源，看數據源是否存在
* file -- D:\\YesDir\\小視頻
* b,指定目的地
* dest -- Copy\\小視頻
* 子文件夾名稱 = 目的地文件夾 \ 當前要複製的File目錄的名稱
* c, 遞歸，回到步驟2
*
* 否：說明是文件,複製文件
* file -- D:\YesDir\大話西遊.mp3
* a,指定數據源 file -- D:\YesDir\大話西遊.mp3
* b,指定目的地 dest -- Copy\大話西遊.mp3
* 目的地文件名稱 = 目的地文件夾 + 當前要複製的File文件的名稱
* c,讀數據源中的數據
* d,把數據寫到目的地
* e,關閉流
*/
public class CopyDirs {
public static void main(String[] args) throws IOException {
//1.找到數據源，看數據源是否存在
File srcPath = new File("D:\\YesDir");
//2.目的地
//File destPath = new File("D:\\YesDir\\Yes"); --》死循環複製（直到磁盤滿，不能刪除，得使用遞歸刪除或者使用360強制刪除）
File destPath = new File("Copy");
//3,開始進行復制文件夾
copyDir( srcPath, destPath);
}
//複製文件夾的方法
private static void copyDir(File srcPath, File destPath) throws IOException {
/首先 感嘆號 是‘非’的意思，
f應該是一個對象的實例，這裏應該是file對象，
exists()， 是f那個實例對應的對象的方法 從名字看 是是否存在的意思，
連起來的意思就是：
f這個文件對象是否是不存在
//2.看是否有目的地文件夾,若是沒有目的地文件夾，建立目的地文件夾
if (!destPath.exists()) {
destPath.mkdir();
}

//3.獲取數據源中全部的File對象
File[] files = srcPath.listFiles();

if (files == null) {
System.out.println(srcPath);
//System.out.println("該文件夾是受系統保護的文件夾，它拒絕訪問！");
return ; //這樣處理的好處是，保證程序不會出現NullPointerException
}

//4.經過遍歷，獲得數據源中每個File對象
for (File file : files) {
//5.判斷是否爲文件夾
if (file.isDirectory()) {
//是：說明是文件夾， 進入到子文件夾中
//file -- D:\\YesDir\\小視頻
//dest -- Copy\\小視頻
//子文件夾名稱 = 目的地文件夾 \ 當前要複製的File目錄的名稱
File dest = new File(destPath, file.getName());
copyDir(file, dest);//這裏寫dest爲了建立子文件夾

} else {
//否：說明是文件,複製文件
//file -- D:\YesDir\大話西遊.mp3
//dest -- Copy\大話西遊.mp3
//目的地文件名稱 = 目的地文件夾 + 當前要複製的File文件的名稱
File dest = new File(destPath, file.getName());
copyFile(file, dest);//這裏的dest是要複製到新的文件名稱
}
}
}
//複製文件
private static void copyFile(File file, File dest) throws IOException {
//指定數據源
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
//指定目的地
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(dest));
//讀
byte[] buffer = new byte[1024];
int len = -1;
while ( (len = bis.read(buffer)) != -1) {
//寫
bos.write(buffer, 0, len);
}
//關閉流
bos.close();
bis.close();
}
}

* 計算機中只能識別是0101010101001
*
* 1.老美 想了一個辦法 把英文和英文符號----->對應成一個10進制數字------>轉成2進制---->電腦
* A---65 a---97 0---48
* 2.ASCII碼錶,把全部的英文和符號 對應了一個十進制(全部其餘碼錶都必須兼容它)
*
* 3.GB2312: 把經常使用中文(6000-7000),一一對應成數字,中文兩個字節
*
* 4.GBK: 把基本全部的中文(20000多個),一一對應成數字,中文兩個字節
*
* 5.Unicode(萬國碼表):在這個碼標中,全部的字符 都是兩個字節
* A----65---- 0000 0000 0100 0001
* 6.UTF-8:(基於Unicode),一個字節能表示的字符,堅定不用兩個字節
* 英文1個字節, 中文(3個字節)
* 經常使用的中文碼錶:GBK(中文2個字節),UFT-8(中文3字節)
*
* 流的分類:
* 根據操做的數據:
* 字節流
* 字符流
* 根據數據的流向;
* 輸入流
* 輸出流
*
* java中四大流
* 字節輸入流:InputStream
* 讀取數據read:一個字節,一個字節數組
*
* 字節輸出流:OutputStream
* 寫出數據write:一個字節,一個字節數組
*
* 字符輸入流:reader
* 讀取數據(read):一個字符,一個字符數組
* 字符輸出流:writer
* 寫出數據(write):一個字符,一個字符數組,一個字符串
* java流命名是十分規範,好比:FileReader(字符輸入流)
*
*
*
*/
public class IODemo02 {

public static void main(String[] args) {
// TODO Auto-generated method stub

}

}

/*
* OutputStreamWriter extends Writer (字符輸出流)
* write方法: 一個字符,一個字符數組, 一個字符串
*
* OutputStreamWriter 是字符流通向字節流的橋樑,查表(編號)
*
* 構造方法:
* public OutputStreamWriter(OutputStream out, String charsetName);//查指定的碼錶
* public OutputStreamWriter(OutputStream out);//默認查GBK碼錶
*
* InputStreamReader extends Reader (字符輸入流)
* 讀取方法:一個字符,一個字符數組
*
* InputStreamReader 是字節流通向字符流的橋樑：查表(解碼)
*
* 構造方法:
* public InputStreamReader(InputStream in, String charsetName);//查指定碼錶
* public InputStreamReader(InputStream in);//默認GBK碼錶
*
*
*/
public class OutputStreamWriterDemo {

public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
//建立一個流對象
// InputStreamReader isr = new InputStreamReader(new FileInputStream("gbk.txt"));
InputStreamReader isr = new InputStreamReader(new FileInputStream("utf8.txt"),"GBK");
int ch = isr.read();
System.out.println((char)ch);
ch = isr.read();
System.out.println((char)ch);
ch = isr.read();
System.out.println((char)ch);
isr.close();

}

public static void demo01() throws IOException{
// OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk.txt"));
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("utf8.txt"),"UTF-8");
//ows調用寫數據方法
osw.write("你好");
//關閉
osw.close();
}

}

/*
* 序列化流:寫對象到字節輸出流中,由字節輸出流再去寫文件
* ObjectOutputStream
* 構造:
* public ObjectOutputStream(OutputStream out);
*
*
* 反序列化流:從字節輸入流中讀取數據,再解析成對象
* ObjectInputStream
* 構造:
* public ObjectInputStream(InputStream in);
*
* 異常:
*
* 1.只要寫序列化的過程當中出現NotSerializableException異常
* 那麼確定是 該類沒有實現java.io.Serializable接口
* 2.若是出現這個異常InvalidClassException異常:找不到類異常
* 2.1 在寫入對象以後,修改了原來的類,那麼讀取的時候就會InvalidClassException異常:找不到類異常
*
* 2.2該類包含未知數據類型
* 2.3該類沒有可訪問的無參數構造方法(寫一個標準的類必須有無參構造)
*
* 3.關於java.io.Serializable的問題:
* 3.1一個類實現java.io.Serializable接口,而這接口中沒有方法
* 這個接口就是一個標記,若是有標記能夠序列化,若是沒有標記不能序列化
* 3.2java爲會這個類提供一個版本號,若是類修改了,那麼這個版本號就會改變
* 就是經過這個版本號來表示類改沒改變
* 4.瞬態關鍵字: transient
* 這個關鍵字能夠修飾成員變量,這個成員變量,當序列化的時候會被忽略
*
*
*/
public class SerializableDemo01 {

public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
//writeObject();
readObject();
}
public static void readObject()throws Exception{
//建立反序列化流對象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.txt"));
//調用ois讀對象的方法
Object obj = ois.readObject();
//打印對象(obj對象其實是Person對象)
System.out.println(obj);
}

public static void writeObject()throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
//調用寫對象的方法
Person p = new Person(10, "小王",10086);
//java.io.NotSerializableException
oos.writeObject(p);
//關閉
oos.close();
}

}

/*
* 打印流:
* PrintWriter:能夠打印到File對象,字符串形式的文件名中,字節輸出流中,字符輸出流中
* PrintStream:能夠打印到File對象,字符串形式的文件名中,字節輸出流中
* 以上兩個流的用法徹底同樣
* 只有一點區別:打印的目的地有所不一樣
*
*/
public class PrintDemo01 {

public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
PrintWriter pw = new PrintWriter("aaa.txt");
pw.print("abc");
pw.print(true);
pw.print(12);
pw.close();
//咱們之前用的
// System.out實際上就是一個打印流
}
}

/* * Properties類:實現了map接口,那麼咱們能夠認爲就是一個map集合(HashMap) * * 1.Properties沒有泛型,屬性名和屬性值,都是String類型 * * 2.它是一個能夠持久化的屬性集(自帶寫數據到文件 ,從文件中讀取數據) * * 3.這些持久化的方法都是和流有關係的 * * 特殊的成員方法: * 1. setProperty(String key,String value);//相似於map.put(K,V); * * 2. public String getProperty(String key);//相似於map.get(K); * * 3. public Set<String> stringPropertyNames();//相似於map.keySet(); * * 持久化相關的方法: * 將Properties對象中的數據 保存到文件中 * store(OutputStream out); * store(Writer w); * * 將文件中的鍵值對 讀取到Properties對象 * load(InputStream intput); * load(Reader r); * Properties一般做爲配置文件 * * */public class PropertiesDemo { public static void main(String[] args) throws IOException { readProperties(); } public static void readProperties() throws IOException{ Properties ps = new Properties();//就當作一個map集合 //讀取數據 ps.load(new FileInputStream("abc.properties")); System.out.println(ps); } public static void writeProperties() throws IOException{ Properties ps = new Properties();//就當作一個map集合 ps.setProperty("zhangsna", "18"); ps.setProperty("alilbba", "28"); ps.setProperty("rose", "38"); ps.setProperty("jack", "48"); ps.setProperty("isAutoGengxin", "0"); //寫數據到文件中 FileOutputStream fos = new FileOutputStream("abc.properties"); ps.store(fos, "a啊解放路啊fagg"); fos.close(); } /* * 演示基本方法 */ public static void demo01(){ //建立Properties對象 Properties ps = new Properties();//就當作一個map集合 ps.setProperty("zhangsna", "18"); ps.setProperty("alilbba", "28"); ps.setProperty("rose", "38"); ps.setProperty("jack", "48"); //System.out.println(ps); Set<String> names = ps.stringPropertyNames(); Iterator<String> it = names.iterator(); while(it.hasNext()){ String name = it.next(); String value = ps.getProperty(name); System.out.println(name+"="+value); } }}