Java中IO工具類、合併流以及線程基礎詳解

IO工具類(commons)

獲取路徑擴展名:static String getExtension(String filename)

    String extension = FilenameUtils.getExtension("/Users/lanou/Desktop/test/ppp.txt");
    System.out.println(extension);

獲取文件名:static String getName(String filename)

    String name = FilenameUtils.getName("/Users/lanou/Desktop/test/ppp.txt");
    System.out.println(name);

判斷是不是這個擴展名:static boolean isExtension(String filename,String extension)

    boolean extension2 = FilenameUtils.isExtension("/Users/lanou/Desktop/test/ppp.txt", "txt");
    System.out.println(extension2);

複製文件夾:static void copyDirectoryToDirectory(File src,File desc)

    FileUtils.copyDirectoryToDirectory(new File("/Users/lanou/Desktop/test"), new File("/Users/lanou/Desktop/level"));

複製文件:static void copyFile(File src,File desc)

    FileUtils.copyFile(new File("/Users/lanou/Desktop/test/ppp.txt"), new File("/Users/lanou/Desktop/test/ppp1.txt"));

寫字符串到文件中:static void writeStringToFile(File src,String date)

    FileUtils.writeStringToFile(new File("/Users/lanou/Desktop/test/ppp.txt"), "abcde");

按字符串讀取文件:static String readFileToString(File src)

    String str = FileUtils.readFileToString(new File("/Users/lanou/Desktop/test/ppp.txt"));
    System.out.println(str);

寫入文件(可以選取用什麼字節流寫入):static void write(String data, OutputStream output);

    File file = new File("/Users/lanou/Desktop/test/ppp.txt");
    IOUtils.write("123", new FileOutputStream(file));

讀取文件到集合中(以字符串形式):static List<String> readLines(InputStream input)

    List<String> list = IOUtils.readLines(new FileInputStream(file));
        for (String string : list) {
            System.out.println(string);
        }

學習方法:
    1.先找類 找到對應的類(先看後綴)
    2.看該類如何創建對象(獲取對象 怎麼調方法)
    3.看方法名 揣測方法的用意
    4.測試看結果 整理在方法集中

合併流

合併流(SequenceInputStream)
合併功能:可以把多個流讀成(合併)成一個流

SequenceInputStream(Enumeration<? extends InputStream> e)    
構造方法:參數是Vector特有迭代器,該Vector要保存的是InputStream的子類

SequenceInputStream(InputStream s1, InputStream s2)
構造方法:參數傳兩個字節輸入流

示例代碼:
    public static void main(String[] args) throws IOException {
        // 將三個文件寫成一個文件
        File file1 = new File("/Users/lanou/Desktop/test/1.txt");
        File file2 = new File("/Users/lanou/Desktop/test/2.txt");
        File file3 = new File("/Users/lanou/Desktop/test/3.txt");
        Vector<FileInputStream> vector = new Vector<>();
        vector.add(new FileInputStream(file1));
        vector.add(new FileInputStream(file2));
        vector.add(new FileInputStream(file3));
        // 獲取迭代器
        Enumeration<FileInputStream> elements = vector.elements();
        // 構建合併流 把三個文件都讀到一起
        SequenceInputStream sis = new SequenceInputStream(elements);
        // 寫入一個文件
        FileOutputStream fos = new FileOutputStream("/Users/lanou/Desktop/test/4.txt");
        // 數組方式寫入
        byte[] b = new byte[1024];
        int len = 0;
        while ((len = sis.read(b)) != -1) {
            fos.write(b, 0, len);
        }
        sis.close();
        fos.close();
    }

切割合成文件

切割:
    public static void fun1() throws IOException {
        FileInputStream fis = new FileInputStream("/Users/lanou/Desktop/test/dp.png");
        FileOutputStream fos = null;
        byte[] b = new byte[1024 * 1024];
        int len = 0;    
        int num = 1;
        while ((len = fis.read(b)) != -1) {
            fos = new FileOutputStream("/Users/lanou/Desktop/test/dp" + num + ".png");
            fos.write(b,0,len);
            fos.close();
            num++;
        }
        fis.close();
    }

合併:
    public static void fun2() throws IOException {
        Vector<FileInputStream> vector = new Vector<>();
        for (int i = 1; i < 8; i++) {
            vector.add(new FileInputStream("/Users/lanou/Desktop/test/dp" + i + ".png"));
        }
        // 獲取迭代器
        Enumeration<FileInputStream> elements = vector.elements();
        // 創建合併流
        SequenceInputStream sis = new SequenceInputStream(elements);
        // 寫到新路徑下
        FileOutputStream fos = new FileOutputStream("/Users/lanou/Desktop/test/dp_all.png");
        // 數組方式寫入
        byte[] b = new byte[1024 * 1024];
        int len = 0;
        while ((len = sis.read(b)) != -1) {
            fos.write(b, 0, len);
        }
        sis.close();
        fos.close();
    }

線程

進程：一個正在運行的程序(獨立運行的程序)
一個進程可以有一個線程稱爲單線程程序,也可以有多個線程稱爲多線程程序

線程：一個線程相當於一個CPU的執行路徑(一個獨立的運行單元)
優點：大大的提升了處理效率

單線程程序：絕對安全,程序由上至下依次執行,效率不高

代碼開啓線程流程：
    1.JVM調用main方法
    2.找操作系統(CPU)
    3.開啓一個執行路徑
main就是一個線程,main是線程的名字又叫主線程

創建線程

繼承方式創建線程的步驟
        1.需要繼承Thread類
        2.重寫父類中的run方法
線程默認名字:Thread-0 Thread-1 ...

代碼實例:
        public class Demo {
            public static void main(String[] args) {
                // 創建一個線程
                SubThread subThread = new SubThread();
                SubThread subThread2 = new SubThread("線程1");
                // 修改線程名
                subThread.setName("線程2");
                // 如果你直接調用run 方法 相當於就調了一個普通的成員方法
                //subThread.run();
                // 開啓線程
                // 注意:直接調用run方法不能開啓線程 需要調用start方法去開啓
                subThread.start();
                subThread2.start();

                // 獲取主線程的名字
                // 獲取當前執行的線程對象  靜態方法
                Thread currentThread = Thread.currentThread();
                for (int i = 0; i < 50; i++) {
                    System.out.println(currentThread.getName() + "---main---" + i);
                }
            }
        }

        class SubThread extends Thread{

            public SubThread() {
            }
            /*
             * Thread(String name) 該構造方法在創建線程的同時給線程起個名
             * 由於構造方法不能被繼承 要想使用父類的構造方法可以在子類中寫帶參數的構造方法
             */
            public SubThread(String name) {
                // 調用父類的有參構造方法
                super(name);
            }

            @Override
            public void run() {
                for (int i = 0; i < 50; i++) {
                    // 獲取線程名的方法getName
                    System.out.println(getName() + "---run---" + i);
                }
            }
        }

注意:Thread父類中已經有了getName()方法並且使用final修飾,所以不能被重寫

接口實現方式來創建線程

示例代碼：
public class Demo {
    public static void main(String[] args) {
        // 創建線程
        RunnableImpl runnableImpl = new RunnableImpl();
        Thread thread = new Thread(runnableImpl);
        thread.start();
    }
}

// 接口中run方法是個抽象方法(重寫)
class RunnableImpl implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
    }   
}