Java IO 流第三方工具类 与 多线程(一) 解析

commons-io

阿帕奇旗下推出Commons IO是针对开发IO流功能的工具类库。
下面为大家演示几个常用的简单方法!
工具包下载地址 : http://download.csdn.net/download/forevernagisa/10241145

public class Demo02 {
    public static void main(String[] args) throws IOException {
        // 获取路径扩展名 
    String extension = FilenameUtils.getExtension("/Users/james/Desktop/level/001.txt ");
    System.out.println(extension);
        // 获取文件名字
    String name = FilenameUtils.getName("/Users/james/Desktop/level/001.txt");
    System.out.println(name);
        // 判断是不是这个扩展名
    boolean extension2 = FilenameUtils.isExtension("/Users/james/Desktop/level/001.txt", "txt");
    System.out.println(extension2);
        // 复制文件夹
    FileUtils.copyDirectoryToDirectory(new File("/james/lanou/Desktop/level"), new File("/Users/lanou/Desktop/test"));
        // 复制文件
    FileUtils.copyFile(new File("/Users/james/Desktop/level/001.txt"), new File("/Users/lanou/Desktop/001.txt"));
        // 写入字符串到文件中
    FileUtils.writeStringToFile(new File("/Users/james/Desktop/level/001.txt"), "CLANNAD");
        // 按字符串读取文件
    String readFileToString = FileUtils.readFileToString(new File("/Users/james/Desktop/level/001.txt"));
    System.out.println(readFileToString);
    // 写入文件 参数 可以选取用字节流写入
    IOUtils.write("CLANNAD AFTER STORY",new FileOutputStream("/Users/james/Desktop/level/001.txt"));
    // 读取文件到集合中 以字符串形式
    List readLines = IOUtils.readLines(new FileInputStream("/Users/james/Desktop/level/001.txt"));
    for (String string : readLines) {
        System.out.println(string);
    }
    }
}

SequenceInputStream(合并流)

它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。

合并流构造方法

SequenceInputStream ( Enumeration < ? extends InputStream> e)
参数: 是迭代器 Vector 特有的 该Vector 要保存的是 InputStream 的子类
SequenceInputStream(InputStream s1, InputStream s2)
参数: 传入两个字节输入流

代码示例:

// 将一个图片分成7份 然后合并
public class Demo04 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = fun1();
        // 创建集合
        Vector vector = new Vector<>();
        // 循环拼接路径 并且添加到集合中
        for (int i = 0; i < 7; i++) {
            String string = "/Users/james/Desktop/level/" + i + ".png";
            File file = new File(string);
            FileInputStream fis1 = new FileInputStream(file);
            vector.add(fis1);
        }
        // 获取迭代器
        Enumeration elements = vector.elements();
        // 将迭代器放入其中
        SequenceInputStream sis = new SequenceInputStream(elements);
        // 写到新路径下
        FileOutputStream fos1 = new FileOutputStream("/Users/james/Desktop/level/图8.png");
        int len1 = 0;
        byte[] bs1 = new byte[1024 * 1024];
        while ((len1 = sis.read(bs1)) != -1) {
            fos1.write(bs1, 0, len1);
        }
        fos1.close();
        sis.close();
        fis.close();
    }

    /** 切割图片
     * @return
     * @throws FileNotFoundException
     * @throws IOException
     */
    public static FileInputStream fun1() throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream("/Users/james/Desktop/level/图7.png");
        byte[] bs = new byte[1024 * 1024];
        FileOutputStream fos = null;
        int len = 0;
        for (int i = 0; i <7; i++) {
            len = fis.read(bs);
            String string = "/Users/james/Desktop/level/" + i + ".png";
             fos = new FileOutputStream(string);
            fos.write(bs, 0, len);
            fos.close();
        }
        return fis;
    }
}

进程

一个正在运行的程序(独立运行的)
一个进程中有很多线程
一个进程中只有一个线程叫单线程程序

线程

一个线程 相当于一个CPU的执行路径(多线程 大大提升了处理效率) 相当于一个独立运行单元

单线程程序的好处与坏处:

好处 : 程序由上到下 绝对安全
坏处: 效率不高

创建线程代码演示:

public class Demo03 {
    public static void main(String[] args) {
        // 如果直接调用run()方法相当于调用一个普通的方法
        SubThread s = new SubThread("cl");

        // 开启线程的方法
        // 重写的调用run()方法 不能开启线程 需要掉start方法开启线程
        s.start();
        for (int i = 0; i < 50; i++) {
            System.out.println("--main--" + i);
        }
        //获取主线程名字
        // 获取当前执行的线程对象方法 静态方法
        Thread currentThread = Thread.currentThread();
        System.out.println(currentThread.getName());
    }
}
// Thread(String name)  该方法在创建线程名的同时给线程起名  
// 构造方法不能被继承 要想使用父类的构造方法 可以在子类中写带参数的构造方法
class SubThread extends Thread{

    public SubThread() {
        super();
        // TODO Auto-generated constructor stub
    }

    public SubThread(String name) {
        // 调用父类的有参构造方法
        super(name);
        // TODO Auto-generated constructor stub
    }

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

那么代码是如何开启线程的呢?

JVM 调用 main方法 —> 操作系统(cpu) —> 开启一个执行路径 –> 开启一个叫main的执行路径
main就是一个线程 main是线程名字 又叫主线程

创建线程注意点!

代码示例:

class NameThread extends Thread{
     private String name;

    public NameThread() {
        super();
    }

    public NameThread(String name, String myName) {
        super(name);
        // 给自己类的name赋值
        // 建议不要使用name 
        this.name = myName;
    }

    public String getMyName() {
        return name;
    }

    public void setMyName(String name) {
        this.name = name;
    }   


/*在创建name 的get/set方法时会报错
 * 父类中(Thread)已经有了getName方法 并且用final修饰 不能被重写 所有报错
 * 解决方法 改名字!
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }   
    */

    @Override
    public void run() {
        // TODO Auto-generated method stub
        super.run();
    }   
}

创建线程第二种方式

代码示例:

// 接口实现方式来创建线程对象
public class Demo05 {
    public static void main(String[] args) {
        RunnableImpl impl = new RunnableImpl();
        // 开启线程
        new Thread(impl).start();
    }
}

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