记录学习每一天-day23

1.15 文件复制

 1,文件复制：本质就是输入和输出
 *                   1.1完成文件输入，读取文件
 *                   1.2完成文件输出
 *                   1.3 整合输入和输出完成复制
 * 2获取目录下所有的子目录
 *                   2.1 获取目录对象
 *                   2.2 获取该目录下所有直接子目录
 *                   2.3 递归获取子目录下面的子目录(获取后代目录)
 * 3整合代码
 *                 3.1 获取所有后代目录后,得到每一个文件对象
 *                 3.2 通过文件对象就可以获取该文件的全路径
 *                 3.3 有了全路径,就可以创建流对象
 *                 3.4 然后就能完成复制功能

 /**
 * 注意：文件复制的时候,目标路径和原路径 不能一样
 * 
 *     1 会清空该文件,因为在创建输出流的时候,可以指定是覆盖还是追加,如果是覆盖写入,
 *             那么在创建输出流的时候,会把该文件清空
 * 
 * 2 追加写入,导致永远读取不完,因为一边读 一边复制,永远没有执行不完
 */

文件复制大概流程（代码实现）：

import java.io.*;

public class FileCopy {
    public static void main(String[] args) throws FileNotFoundException, IOException {
        File file=new File("要复制的目标文件路径");
        test(file);
        System.out.println("复制完毕");
    }

    public static void test(File file) throws FileNotFoundException, IOException {
        //判断是否是文件
        if(file.isFile()){
            //获得全路径
            String filepath =file.getAbsolutePath();
            /*注意 : 文件复制的时候,目标路径和原路径 不能一样*/
            //目标目录,复制到E盘,进行拼接字符串
            String newFilePath ="E"+filepath.substring(1);
            
            //判断目标目录是否存在
            // 获取目标文件对象
            File newfile =new File(newFilePath);
            //获取父文件对象
            File parentFile = newfile.getParentFile();
            //判断是否存在
            if(!parentFile.exists()){
                //不存在就创建
                parentFile.mkdir();
            }
            //创建字节流对象等，准备复制
            try(  
                    //filepath 全路径
                    FileInputStream fis = new FileInputStream(filepath);
                    //目标目录,上面已经拼接好了字符串
                    FileOutputStream fos = new FileOutputStream(newFilePath);
                    BufferedInputStream bis = new BufferedInputStream(fis);
                    BufferedOutputStream bos = new BufferedOutputStream(fos);
                    ){
                  byte[] bytes=new byte[1024];
                  int coun=0;
                  while((coun=bis.read(bytes))!=-1){
                      bos.write(bytes,0,coun);
                      bos.flush();
                  }
              }catch(Exception e){
                  e.printStackTrace();
              }
            }else{
                //进入else说明是文件夹
                //获取所有的子文件
                File[] files=file.listFiles();
                //遍历所有子文件，判断是不是文件
                for (File subFile:files){
                    test(subFile);
                }              
        }         
    }    

}
 

 JavaSE-16-线程

1. 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一 段静态的代码，静态对象。
2. 进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
3. 线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。

 并行和并发

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。

并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事1

 

 线程的创建和使用

方式一:Tread类

创建线程 1 继承 Thread 类并覆写run方法
               2 Runnable 接口，并实现run方法
               
  run方法 就等于是新线程中的main方法
  
  启动线程 只有一种方式，就是调用线程对象的start()方法

public static void main(String[] args) {
        //创建线程类对象  继承方式
        Thread t1=new Processor();
        //创建线程类对象   实现接口方式
        Thread t2=new Thread(new Prcess());
        //启动该线程
        t1.start();
        t2.start();
        //不能手动调用run方法，因为这样就是调用方法，而不是线程了
        //t1.run();
        System.out.println("-----------");
        System.out.println("-------");
        
    }
        
}
class Processor  extends Thread{
    @Override
    public void run(){
        for (int i = 1; i < 4; i++) {
            System.out.println("t1:"+i);        
        }
    }
}

class Prcess implements Runnable{
    @Override
    public void run() {
        for (int i = 1; i < 4; i++) {
            System.out.println("t2:"+i);
        }            
    }        
}
 

 常用方法：

 * getName():获取当前线程的名字
 * setName(): 设置线程的名字，默认是Thread-0,Thread-1 依次递增
 * setPriority():设置优先级，java有10个优先级，1-10
 *           在Thread 类中 用三个常量表示
 *               public final static int MIN_PRIORITY = 1;
 *               public final static int NORM_PRIORITY = 5;
 *               public final static int MAX_PRIORITY = 10;
 *                 默认子类继承父类优先级，而Thread的优先级为5
 *                 
 * static currentThread():获取当前线程对象，写在哪个类中，获取哪个线程类对象
 * 
 * static sleep(): 让当前线程进入睡眠状态,参数是睡眠的毫秒数,写在哪个类中,就睡眠哪个线程类 

 public static void main(String[] args) {
        Thread t1=new Thread(new Pro());
        //设置优先级
        t1.setPriority(10);
        // 设置名字
        t1.setName("t1");
        t1.start();

        for (int i = 0; i < 10; i++) {
            try {

                 //注意这里睡眠的是t1
                t1.sleep(500);   
            } catch (InterruptedException e) {
                e.printStackTrace();}
        // currentThread 获取当前线程对象
        // getName : 获取当前线程对象名字
        System.out.println(Thread.currentThread().getName()+" : "+i);
            }
    }

class Pro implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // currentThread 获取当前线程对象
            // getName : 获取当前线程对象名字
            System.out.println(Thread.currentThread().getName()+" : "+i);
        }
    }
    
}