Java基礎---IO(二)--File類、Properties類、打印流、序列流（合併流）

時間  2019-12-05
標籤 java 基礎 file properties 打印 序列 合併 欄目 Java 简体版
原文   原文鏈接

第一講     File類java

1、概述linux

一、File類：文件和目錄路徑名的抽象表現形式編程

二、特色：windows

        1）用來將文件或文件夾封裝成對象數組

        2）方便於對文件與文件夾的屬性信息進行操做app

        3）File類的實例是不可變的；也就是說，一旦建立，File 對象表示的抽象路徑名將永不改變函數

        4）File對象能夠做爲參數傳遞給流的構造函數ui

 

2、File對象建立spa

方式一：      對象

             File f =new File("a.txt");

        將a.txt封裝成File對象。能夠將已有的和未出現的文件或者文件夾封裝成對象。

 方式二：

            File f2=newFile("c:\\abc","b.txt");

        將文件所在目錄路徑和文件一塊兒傳入，指定文件路徑。

 方式三：

            File d=new File("c:\\abc");

             File f3=new File(d,"c.txt");

        將文件目錄路徑封裝成對象。再建立文件對象。下降了文件於父目錄的關聯性。

小知識：

        File.separator表示目錄分隔符，能夠跨平臺使用。至關於路徑中的「\」（雙斜槓\\在windows中表示表示轉義後的分隔符，可是在linux系統中就不是）。

 

3、File類的常見方法

一、建立

        booleancreateNewFile();

        //在指定位置建立文件，若是該文件已經存在，則不建立，返回false。和輸出流不同，輸出流對象一創建就建立文件。並且文件已經存在，會覆蓋。

        boolean mkdir();//建立文件夾，只能建立一級文件夾

例：

        File dir=new File("abc");

        dir.mkdir();//建立abc這個文件夾

        boolean mkdirs();//建立多級文件夾

二、刪除

        boolean delete();

        //刪除文件或目錄。文件存在，返回true；文件不存在或者正在被執行，返回false。    

        void deleteOnExit();//在程序退出時刪除指定文件

三、判斷

        boolean canExecute();//是不是可執行文件

        boolean exists();//文件是否存在

        boolean isFile();//是不是文件

        boolean isDirectory();//是不是文件夾

        boolean isHidden();//是不是隱藏文件

        boolean isAbsolute();//文件是不是絕對路徑

記住：在判斷文件對象是不是文件或者目錄時，必需要判斷該文件對象封裝的內容是否存在。經過exists判斷。

四、獲取信息

        String getName();//獲取文件名

        String getPath();

        //獲取文件的相對路徑（即建立的對象傳入的參數是什麼就獲取到什麼）

        String getParent();

        //獲取文件父目錄。返回的是絕對路徑中的父目錄。若是獲取的是相對路徑，返回null。若是相對路徑中有上一層目錄，那麼該目錄就是返回結果。

        String getAbsolutePath();//獲取文件的絕對路徑      

        long lastModified();//返回文件最後一次被修改的時間

        long length();//返回文件長度

五、列出文件及文件過濾

        static File[] listRoots();//列出可用的文件系統根目錄，即系統盤符

        String[] list();

        //列出當前目錄下全部文件，包括隱藏。調用list方法的file對象必須是封裝了一個目錄。該目錄還必須存在。

        String[]list(FilenameFilter filter);

        //返回一個字符串數組，獲取目錄中知足指定過濾器的文件或目錄。

        //FilenameFilter：文件名過濾器，是一個接口，其中包含一個方法，accept(Filedir,String name)，返回的是boolean型，對不符合條件的文件過濾掉。

        File[] listFiles();//返回一個抽象路徑名數組，獲取當前文件夾下的全部文件和文件夾

        File[] ListFiles(FilenameFilterfilter);//返回抽象路徑名數組，獲取目錄中知足指定過濾器的文件或目錄。

[java] view plaincopy
 
  1. <span style="font-size:14px;">/* 
  2. 練習：用String[] list(FilenameFilter filter)方法獲取一個目錄下全部的.java文件，其餘文件不要。 
  3. 思路：一、FilenameFilter是一個過濾器接口，用匿名內部類傳入filter對象 
  4.       二、複寫FilenameFilter接口的accept(File file,String name)方法，並判斷name是不是java文件 
  5.       三、遍歷String類型數組 
  6. */  
  7.   
  8. import java.io.*;  
  9. class  GetJavaFile  
  10. {  
  11.     public static void main(String[] args)   
  12.     {  
  13.         File file=new File("E:\\Java Study\\Practice\\day07");  
  14.         getJavaFile(file);  
  15.     }  
  16.     //獲取一個目錄下全部的.java文件方法  
  17.     public static void getJavaFile(File dir)  
  18.     {  
  19.         //傳入FilenameFilter匿名內部類子類對象，並複寫accept方法  
  20.         String[] javaFile=dir.list(new FilenameFilter()  
  21.         {  
  22.             public boolean accept(File dir,String name)  
  23.             {  
  24.                 return name.endsWith(".java");//判斷文件名是不是以.java結尾  
  25.             }  
  26.         });  
  27.   
  28.         System.out.println("len:"+javaFile.length);  
  29.         //遍歷數組  
  30.         for (String s : javaFile )  
  31.         {  
  32.             System.out.println(s);  
  33.         }  
  34.     }  
  35. }  
  36. </span>  


4、遞歸

一、定義

       當函數內每一次循環還能夠調用本功能來實現，也就是函數自身調用自身。這種表現形式，或者編程手法，稱爲遞歸。

二、遞歸注意事項

        a、限定條件。是來結束循環調用，不然是死循環。

        b、注意遞歸的次數，儘可能避免內存溢出。由於每次調用自身的時候都會先執行下一次調用本身的方法，因此會不斷在棧內存中開闢新空間，次數過多，會致使內存溢出。

示例一

[java] view plaincopy
 
  1. /* 
  2. 需求：列出指定目錄下文件或文件夾，包含子目錄，即列出指定目錄下全部內容（帶層次的）。 
  3.  
  4. 分析，由於目錄中還有目錄，只有使用同一個列出目錄功能的函數完成便可，在列出過程當中出現的仍是目錄的話，還能夠再調用本功能，這就是利用遞歸原理。 
  5.  
  6. */  
  7. import java.io.*;  
  8. class  RecursionDemo  
  9. {  
  10.     public static void main(String[] args)   
  11.     {  
  12.         //關聯指定路徑  
  13.         File dir=new File("e:\\Java Study\\Practice");  
  14.           
  15.         //列出關聯路徑中全部的.java文件  
  16.         allFileList(dir,0);  
  17.     }  
  18.   
  19.     //列出指定目錄下的因此內容  
  20.     public static void allFileList(File dir,int level)  
  21.     {  
  22.         //有層次的輸出  
  23.         System.out.println(getLevel(level)+dir);  
  24.         level++;  
  25.         File[] fileArr=dir.listFiles();//獲取本目錄下的因此文件和目錄的抽象路徑  
  26.           
  27.         //遍歷  
  28.         for (File file : fileArr)  
  29.         {  
  30.             if(file.isDirectory())  
  31.             {  
  32.                 //若是目錄下仍是目錄，則繼續調用本函數  
  33.                 allFileList(file,level);  
  34.             }  
  35.             else  
  36.                 System.out.println(getLevel(level)+file);//顯示（列出）文件  
  37.         }     
  38.     }  
  39.   
  40.     //帶層次的列表  
  41.     public static String getLevel(int level)  
  42.     {  
  43.         StringBuilder sb=new StringBuilder();  
  44.         sb.append("|--");  
  45.         //每多一級目錄，就多輸出指定字符  
  46.         for (int x=level;x>0 ; x--)  
  47.         {  
  48.             //sb.append("|--");  
  49.             sb.insert(0,"|  ");  
  50.         }  
  51.         return sb.toString();  
  52.     }  
  53. }  

示例二

[java] view plaincopy
 
  1. /* 
  2. 刪除一個帶內容的目錄。 
  3. 刪除原理： 
  4. 在windows中，刪除目錄從裏面往外面刪除的。 
  5. 既然是從裏往外刪除。就須要用到遞歸。 
  6.  
  7. */  
  8. import java.io.*;  
  9. class RemoveDir   
  10. {  
  11.     public static void main(String[] args)   
  12.     {  
  13.         //指定目錄  
  14.         File dir=new File("e:\\1");  
  15.         //刪除目錄  
  16.         removeDir(dir);  
  17.   
  18.     }  
  19.   
  20.     //刪除傳入目錄  
  21.     public static void removeDir(File dir)  
  22.     {  
  23.         File[] files=dir.listFiles();//列出目錄下的因此文件和文件夾  
  24.         //遍歷  
  25.         for (File file : files )  
  26.         {  
  27.             //若是仍是目錄且非隱藏  
  28.             if(!file.isHidden()&&file.isDirectory())  
  29.                 removeDir(file);//繼續刪除目錄裏的內容  
  30.             else  
  31.                 System.out.println(file.toString()+":-file-:"+file.delete());//刪除文件  
  32.         }  
  33.         System.out.println(dir+":::dir:::"+dir.delete());//刪除目錄  
  34.     }  
  35. }  

示例三

[java] view plaincopy
 
  1. /* 
  2. 練習： 
  3. 將一個指定目錄下的java文件的絕對路徑，存儲到一個文本文件中。創建一個java文件列表的文件。 
  4. 思路： 
  5.      一、對指定的目錄進行遞歸。 
  6.      二、獲取遞歸過程全部的java文件的路徑。 
  7.      三、將這些路徑存儲到集合中。 
  8.      四、將集合中的數據寫入到一個文件中。 
  9. */  
  10. import java.util.*;  
  11. import java.io.*;  
  12.   
  13. class  JavaFileList  
  14. {  
  15.     public static void main(String[] args)   
  16.     {  
  17.         //指定目錄  
  18.         File dir=new File("e:/Java Study/Practice");  
  19.           
  20.         //定義一個List集合，用於存儲.java文件的File對象  
  21.         List<File> list =new ArrayList<File>();  
  22.           
  23.         //調用獲取文件路徑方法  
  24.         fileToList(dir,list);  
  25.           
  26.         //指定寫入文件  
  27.         File file=new File(dir,"javafilelist.txt");  
  28.         //調用寫入文件方法  
  29.         writeToFile(list,file);  
  30.       
  31.     }  
  32.     //獲取指定文件夾內的全部java文件的絕對路徑，並存入集合中  
  33.     public static void fileToList(File dir,List<File> list)  
  34.     {  
  35.         File[] files=dir.listFiles();//列出dir路徑下的因此文件和目錄，  
  36.         //遍歷  
  37.         for (File file : files)  
  38.         {  
  39.             //若是是目錄，則繼續獲取  
  40.             if(file.isDirectory())  
  41.             {  
  42.                 list.add(file.getAbsoluteFile());//把父目錄路徑也存入  
  43.                 fileToList(file,list);  
  44.             }  
  45.             //將是.java文件的絕對路徑存入  
  46.             else if(file.getName().endsWith(".java"))  
  47.                 list.add(file);  
  48.         }  
  49.     }  
  50.   
  51.     //將集合中元素寫入到一個文本文件中  
  52.     public static void writeToFile(List<File> list,File file)  
  53.     {  
  54.           
  55.         BufferedWriter bw=null;  
  56.               
  57.         try  
  58.         {   //使用字符流緩衝區對象關聯寫入的文件  
  59.             bw=new BufferedWriter(new FileWriter(file));  
  60.             for (File file0 : list )  
  61.             {  
  62.                 bw.write(file0.getAbsolutePath());//寫入  
  63.                 bw.newLine();//換行  
  64.                 bw.flush();//刷新  
  65.             }  
  66.         }  
  67.         catch (IOException e)  
  68.         {  
  69.             throw new RuntimeException("寫入文件失敗");  
  70.         }  
  71.         finally  
  72.         {  
  73.             try  
  74.             {  
  75.                 if(bw!=null)  
  76.                     bw.close();//關流  
  77.             }  
  78.             catch (IOException e)  
  79.             {  
  80.                 throw new RuntimeException("流資源關閉失敗");  
  81.             }  
  82.         }  
  83.     }  
  84. }  

 

第二講      Properties類

1、概述

一、Properties是Hashtable的子類，它具有Map集合的特色。並且它裏面還有存儲的鍵值對，都是字符串，無泛型定義。是集合中和IO技術想結合的集合容器。

二、特色：

        1）可用於鍵值對形式的配置文件

        2）在加載時，須要數據有固定的格式，經常使用的是：鍵=值

 

2、特有方法

一、設置

        Object setProperty(String key,String value);

        //設置鍵和值，調用Hashtable的方法put

二、獲取

        String getProperty(String key);

        //指定key搜索value

        Set<String> stringPropertyName();

        //返回屬性列表的鍵集，存入Set集合

三、加載流和存入流

        void load(InputStream ism);

        //從輸入字節流中讀取屬性列表（鍵和元素對）。又稱將流中的數據加載進集合。

        void load(Readerreader);

        //從輸入字符流中讀取屬性列表（鍵和元素對）。又稱將流中的數據加載進集合。

        voidlist(PrintStream out);//將屬性列表輸出到指定的輸出流

        void store(OutputStreamout,String comments);

        //對應load(InputStream )將屬性列表（鍵值對）寫入輸出流。comments屬性列表的描述。

        void store(Writerwriter, String comments);

        //對應load(Reader)將屬性列表（鍵值對）寫入輸出流。comments屬性列表的描述。

示例

[java] view plaincopy
 
  1. //演示，如何將流中的數據存儲到集合中。  
  2.     //想要將info.txt中鍵值數據存到集合中進行操做。  
  3.     /* 
  4.         1,用一個流和info.txt文件關聯。 
  5.         2，讀取一行數據，將該行數據用"="進行切割。 
  6.         3，等號左邊做爲鍵，右邊做爲值。存入到Properties集合中便可。 
  7.  
  8.     */  
  9.         //將文件數據存儲進Properties集合方法  
  10.     public static void method()throws IOException  
  11.     {  
  12.         //使用字符讀取緩衝流關聯文件  
  13.         BufferedReader bufr = new BufferedReader(new FileReader("info.txt"));  
  14.   
  15.         String line = null;  
  16.         //定義Properties集合  
  17.         Properties prop = new Properties();  
  18.   
  19.             while((line=bufr.readLine())!=null)  
  20.         {  
  21.             String[] arr = line.split("=");//將一行數據以「=」號進行分割  
  22.             //將=左邊做爲鍵存入，將=右邊做爲值存入  
  23.             prop.setProperty(arr[0],arr[1]);  
  24.         }  
  25.   
  26.         bufr.close();//關流  
  27.   
  28.         System.out.println(prop);  
  29.     }  

練習：

[java] view plaincopy
 
  1. /* 
  2. 練習：用於記錄應用程序運行次數。若是使用次數已到，那麼給出註冊提示。 
  3.      
  4. 分析： 
  5. 很容易想到的是：計數器。但是該計數器定義在程序中，隨着該應用程序的退出，該計數器也在內存中消失了。 
  6. 因此要創建一個配置文件，用於記錄該軟件的使用次數。該配置文件使用鍵值對的形式。鍵值對數據是map集合。數據是以文件形式存儲。使用io技術。那麼map+io——>Properties。 
  7.  
  8. 思路：一、用讀取流關聯文本信息文件。若是存在則讀取，若是不存在，則建立 
  9.       二、每次運行，將文件數據存入集合中，讀取值，判斷次數，若是小於等於5次，則次數增長1次，若是大於則輸出提示信息。 
  10.       三、將值小於等於5次的信息數據存入文件中傷感的句子
  11. */  
  12. import java.util.*;  
  13. import java.io.*;  
  14.   
  15. class  RunCount  
  16. {  
  17.     public static void main(String[] args)throws IOException   
  18.     {  
  19.         int count=runCount();  
  20.         if(count>5)//若是程序被使用了超過5次，則終止使用，並提示  
  21.         {  
  22.             System.out.println("次數到了，交錢！！！！！");  
  23.             return ;  
  24.         }  
  25.         else  
  26.             System.out.println("程序第"+count+"次Run！");  
  27.     }  
  28.     //獲取程序運行的次數  
  29.     public static int runCount()throws IOException  
  30.     {  
  31.         Properties ps=new Properties();//建立集合對象  
  32.   
  33.         File file=new File("info.ini");//將文件進行封裝  
  34.         if(!file.exists())//判斷是否存在  
  35.             file.createNewFile();  
  36.         FileReader fr=new FileReader(file);//將文件於讀取流進行關聯  
  37.           
  38.         ps.load(fr);//加載流中的文件數據到集合中  
  39.   
  40.         int count=0;//定義計數器  
  41.         String value=ps.getProperty("time");//獲取次數值  
  42.           
  43.         if(value!=null)//如過值不等於null，則將其賦值給count  
  44.         {  
  45.             count=Integer.parseInt(value);  
  46.         }  
  47.         count++;//每啓動一次自增  
  48.         ps.setProperty("time",count+"");//將次數記錄住集合  
  49.   
  50.         FileWriter fw=new FileWriter(file);  
  51.         ps.store(fw,"");//將集合中的數據存入硬盤文件中  
  52.           
  53.         fr.close();//關流  
  54.         fw.close();  
  55.   
  56.         return count;//返回程序啓動的次數  
  57.     }  
  58. }  

 

第三講    打印流

1、概述

        一、打印流包括：PrintStream和PrintWriter

        二、該流提供了打印方法，可將各類類型的數據都原樣打印。

 

2、字節打印流：PrintStream

構造方法中可接收的參數類型：

        一、File對象。File

        二、字符串路徑：String

        三、字符輸出流：OutputStream

 

3、字符串打印流：PrintWriter

構造方法中可接受的參數類型

        一、File對象：File

        二、字符串路徑：String

        三、字節輸出流：OutputStream

        四、字符輸出流：Writer

示例

[java] view plaincopy
 
  1. import java.io.*;  
  2.   
  3. class  PrintStreamDemo  
  4. {  
  5.     public static void main(String[] args) throws IOException  
  6.     {  
  7.         //鍵盤錄入  
  8.         BufferedReader bufr =   
  9.             new BufferedReader(new InputStreamReader(System.in));  
  10.   
  11.         //打印流關聯文件，自動刷新  
  12.         PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);  
  13.   
  14.         String line = null;  
  15.   
  16.         while((line=bufr.readLine())!=null)  
  17.         {  
  18.             if("over".equals(line))//結束字符  
  19.                 break;  
  20.             out.println(line.toUpperCase());  
  21.             //out.flush();  
  22.         }  
  23.           
  24.         //關流  
  25.         out.close();  
  26.         bufr.close();  
  27.   
  28.     }     
  29. }  

 

第四講    序列流

1、概述

一、SequenceInputStream對多個流進行合併。也被稱爲合併流。

二、經常使用構造函數

        SequenceInputStream(Enumeration<?extends FileInputStream> e)

 

2、常見合併多個流文件步驟

        一、建立集合，並將流對象添加進集合

        二、建立Enumeration對象，將集合元素加入。

        三、建立SequenceInputStream對象，合併流對象淘寶開店

        四、建立寫入流對象，FileOutputStream關聯寫入文件

        五、利用SequenceInputStream對象和FileOutputStream對象讀數據進行反覆讀寫操做。

示例：

[java] view plaincopy
 
  1. /* 
  2. SequenceInputStream 
  3. 合併流 
  4. 需求：將三個文本文件中的數據合併到一個文本文件中 
  5. 思路：一、建立一個Vector集合，將三個文本文件字節流添加到集合中 
  6.       二、建立Enumeration對象，建立SequnceInputStream對象關聯Enumeration 
  7.       三、輸出流關聯新文本文件 
  8.       四、反覆讀寫操做 
  9. */  
  10. import java.util.*;  
  11. import java.io.*;  
  12.   
  13. class  SequenceInputStreamDemo  
  14. {  
  15.     public static void main(String[] args)throws IOException  
  16.     {  
  17.         Vector<InputStream> ve=new Vector<InputStream>();//建立vector集合，並添加相關流對象  
  18.         ve.add(new FileInputStream("1.txt"));  
  19.         ve.add(new FileInputStream("2.txt"));  
  20.         ve.add(new FileInputStream("3.txt"));  
  21.   
  22.         Enumeration<InputStream> en=ve.elements();//建立枚舉對象  
  23.         SequenceInputStream sis=new SequenceInputStream(en);//合併流  
  24.   
  25.         FileOutputStream fos=new FileOutputStream("4.txt");//關聯寫入文件  
  26.           
  27.         //反覆讀寫操做  
  28.         byte[] buf=new byte[1024];  
  29.         int len=0;  
  30.         while((len=sis.read(buf))!=-1)  
  31.         {  
  32.             fos.write(buf,0,len);  
  33.         }  
  34.           
  35.         //關流  
  36.         fos.close();  
  37.         sis.close();  
  38.     }  
  39. }  

練習：

[java] view plaincopy
 
    1. /* 
    2. 切割文件 
    3. 需求：將一個mp3文件按1M大小切割成幾部分 
    4. 思路：一、使用文件字節流關聯mp3文件 
    5.       二、定義一個容器存儲1M大小的數據，當存儲滿時，寫入一個新文件中 
    6.  
    7. */  
    8. import java.util.*;  
    9. import java.io.*;  
    10.   
    11. class  SplitFile  
    12. {  
    13.     public static void main(String[] args) throws IOException  
    14.     {  
    15.         //指定要切割的文件  
    16.         File file=new File("C:\\Users\\asus\\Desktop\\蘇芮 - 同樣的月光.mp3");  
    17.         //將指定文件進行切割  
    18.         splitFile(file);  
    19.   
    20.         //指定要合併到的文件  
    21.         File file1=new File("E:\\Java Study\\Practice\\day20\\splitFile\\同樣的月光.mp3");  
    22.         //將部分文件進行合併指定文件中  
    23.         merge(file1);  
    24.   
    25.     }  
    26.     //接收一個文件，將其按1M大小進行切割  
    27.     public static void splitFile(File file)throws IOException  
    28.     {  
    29.         //關聯要切割的文件  
    30.         BufferedInputStream bis=new BufferedInputStream(new FileInputStream(file));  
    31.           
    32.         BufferedOutputStream bos=null;  
    33.   
    34.         //定義1M大小存儲容器  
    35.         byte[] buf=new byte[1024*1024];  
    36.         int len=0,x=0;  
    37.         while ((len=bis.read(buf))!=-1)  
    38.         {  
    39.             //每滿1M就寫入一個新文件中  
    40.             bos=new BufferedOutputStream(new FileOutputStream("E:\\Java Study\\Practice\\day20\\splitFile\\"+(++x)+".part"));  
    41.             bos.write(buf,0,len);  
    42.             bos.close();//沒寫完一個文件要記得關流  
    43.         }  
    44.         //關流  
    45.         bis.close();  
    46.     }  
    47.   
    48.     //將部分文件合併爲一個可執行文件  
    49.     public static void merge(File file)throws IOException  
    50.     {  
    51.         //定義一個集合存儲這些部分文件關聯路徑數據  
    52.         ArrayList<FileInputStream> al=new ArrayList<FileInputStream>();  
    53.   
    54.         for (int x=1;x<=6 ; x++)  
    55.         {  
    56.             al.add(new FileInputStream("E:\\Java Study\\Practice\\day20\\splitFile\\"+x+".part"));  
    57.         }  
    58.           
    59.         //由於Enumeration是Vector特有的迭代方法，因此這裏建立一個Enumeration類型的匿名內部類  
    60.         final  ListIterator<FileInputStream> it=al.listIterator();  
    61.         Enumeration<FileInputStream> en=new Enumeration<FileInputStream>()  
    62.         {  
    63.             public boolean hasMoreElements()  
    64.             {  
    65.                 return it.hasNext();  
    66.             }  
    67.   
    68.             public FileInputStream nextElement()  
    69.             {  
    70.                 return it.next();  
    71.             }  
    72.         };  
    73.   
    74.         //關聯枚舉對象  
    75.         SequenceInputStream sis=new SequenceInputStream(en);  
    76.   
    77.         //將合併的文件數據寫入指定文件中  
    78.         FileOutputStream fos=new FileOutputStream(file);  
    79.           
    80.         //定義臨時存儲數據的數組  
    81.         byte[] buf=new byte[1024];  
    82.         int len=0;  
    83.         while((len=sis.read(buf))!=-1)  
    84.         {  
    85.             fos.write(buf,0,len);//寫數據  
    86.         }  
    87.   
    88.         //關流  
    89.         fos.close();  
    90.         sis.close();  
    91.   
    92.     }  
    93.   
    94. }  
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程