Java合并流与线程

合并流

1.合并功能(可以把多个文件合并成差一个文件)
2.SequenceInputStream 合并功能(多个流合并成一个流)
3.构造方法
1.参数是迭代器 是Vector特有的子类
2.SequenceInputStream(Enumeration<? extends InputStream> e) 
参数:传入两个流
SequenceInputStream(Input s1,inputStream s2)

2.合并文件

1.将三个文件合并成一个
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;

public class text {
         public static void main(String[] args) throws IOException {
                //1.锁定三个文件
               File file1 = new File("/Users/lanou/Desktop/test/kk.txt");
               File file2 = new File("/Users/lanou/Desktop/test/kke.txt");
               File file3 = new File("/Users/lanou/Desktop/test/kkle.txt");
               //2.创建装纳容器
               Vector<FileInputStream> vector = new Vector<>();
               vector.add(new FileInputStream(file1));//3.向容器存入要合并的文件
               vector.add(new FileInputStream(file2));
               vector.add(new FileInputStream(file3));

               //4.获取迭代器
               Enumeration<FileInputStream> element = vector.elements();
               //5.构建合并流
               SequenceInputStream sis = new SequenceInputStream(element);
               //6.写入到一个文件里
               FileOutputStream fos = new FileOutputStream("/Users/lanou/Desktop/test/4.txt");
               //7.数组方式写入
               byte[]  b = new byte[1024];
               int len = 0;
               while((len = sis.read(b)) != -1) {
                   //8.写入
                   fos.write(b,0,len);
               }
               fos.close();//9.关闭资源
               sis.close();
    }
}

3.将文件拆成碎片

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class text {
         public static void main(String[] args) throws IOException {
             //1.读取目标文件
            FileInputStream fis = new FileInputStream("/Users/lanou/Desktop/test/dp.png");
            FileOutputStream os = null;///2.初始化拆分文件
            BufferedInputStream bfo = new BufferedInputStream(fis);
            byte[] b = new byte[1024 * 1024];//3.初始化读取空间
            int len = 0;//4.初始化指针位置
            int num = 1;//5.创建名字变量
            while ((len = bfo.read(b)) != -1) {//6.创建写入文件
                os = new FileOutputStream("/Users/lanou/Desktop/test/" + num + ".哈哈哈");
                os.write(b,0,len);//6.向碎片文件写入内容,一个写人1M内容
                num++;//7.名字变量自增
            }
            fis.close();//8.关闭资源
            os.close();
         }
}

4.合并碎片文件

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;

public class text {
     public static void main(String[] args) throws IOException {
         Vector<FileInputStream>vector = new Vector<>();//1.用构造方法创建一个容器
         for (int i = 1; i < 19; i++) {//2. 锁定被拆分的文件
            File file= new File("/Users/lanou/Desktop/day28作业/" + i + ".suipian");
            vector.add(new FileInputStream(file));//3.将所有拆分文件存入容器中
        }
         //4.获取迭代器
         Enumeration<FileInputStream>element = vector.elements();
         //5.创建合并流
         SequenceInputStream sis = new SequenceInputStream(element);
         //6.创建要合并成的文件
         FileOutputStream fos = new FileOutputStream("/Users/lanou/Desktop/day28作业/"+"1.txt");
         byte[] b = new  byte[1024];//1.初始化读取空间
         int len = 0;//2.初始化指针位置
         while ((len = sis.read(b)) != -1) {
            fos.write(b,0,len);//7.将所有碎片文件存入新文件中
        }
         fos.close();//8.关闭资源
         sis.close();   
    }
}

1.线程

1.线程与进程
1.进程:一个正在运行的程序(独立运行的程序)
一个进程中有一个线程(单线程)
一个进程中有多个线程(多线程)
2.线程:一个线程相当于一个CPU的执行路径(大大提升了处理效率)
3.标准的单线程程序绝对安全 但是程序由上至下执行 效率不高

1.1单线程

public class Demo01 {
    public static void main(String[] args) {
        /*
         * 标准的单线程程序
         * 绝对安全 程序由上至下依次执行 效率不高
         */
        //添加
         add();
        //删除    
         remove();
         System.out.println("程序执行完毕");
    }
    public static void add() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
    }
    public static void remove() {
        System.out.println("删除");
    }
}

1.1代码是如何开启线程

  代码是如何开启线程
  jvm调用main方法-->找操作系统(cpu)-->开启一个执行路径
  开启了一个叫main的执行路径 main就是一个线程 main是线程的名字
  又叫主线程

public class Demo02 {
   public static void main(String[] args) {
    System.out.println(10/0);
    //Exception in thread "main" 异常出现在 线程main中  

    add();
    System.out.println("程序完成");
}
    public static void add() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
    }
}

2.多线程

开启一个线程并开启
1.需要继承Thread
2.重写父类中的方法

线程默认名字:Thread - 0 Thread-1...

public class text {
    public static void main(String[] args) {
        //1.创建两个线程
        //2.线程命名的两忠方法
        SubThread subThread1 = new SubThread("线程1");
        SubThread subThread = new SubThread();
        subThread.setName("线程2");
        //subThread.run();
        //如果直接调用run方法不能开启线程 需要调用start方法开启线程
        //调用run是调用了一个普通的方法
        subThread.start();//3.开启线程
        subThread1.start();
        //4.获取当前执行的线程对象 静态方法
        Thread currentThread = Thread.currentThread();
        //5.获取主线程的名字
        System.out.println(currentThread);
        for (int i = 0; i < 50; i++) {
            System.out.println(currentThread.getName() + "--main--" + i);
        }
    }
}

//Thread(String name)该方法在创建线程时给线程起个名
//构造方法不能被继承 要想使用父类的构造方法 可以再子类中写带参数的构造方法
class SubThread extends Thread{
    public SubThread() {

    }
   public SubThread(String name) {
        //调用父类构造方法
       super(name);
    }
    //重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            //获取线程名的方法getName
            System.out.println(getName() + "--run方法--" + i);
        }
        super.run();
    }
}

3.接口Runnable

public class Demo05 {
      public static void main(String[] args) {
          //创建线程
        RunnableImpl rImpi = new RunnableImpl();
        Thread thread = new Thread(rImpi);
        //开启线程
        thread.start();
    }
}
//接口方法是个抽象方法
class RunnableImpl implements Runnable{
    @Override
    public void run() {
    for (int i = 0; i < 50; i++) {
        System.out.println(Thread.currentThread().getName() + "--" + i);
    }

    }
}

4.创建Thread 子类 NameThread1

Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。
类必须定义一个称为 run 的无参数方法。

public class text {
    public static void main(String[] args) {
      NameThread1 nt = new NameThread1();
      NameThread1 nt1 = new NameThread1();
      nt1.setMyName("线程2");
      nt.run();
      nt1.run();
    }
}
class NameThread1 extends Thread{
    private String name;
      public NameThread1() {

    }
    public NameThread1(String name,String myname) {
        //传递的是线程的名字 利用的是父类的构造方法
        super(name);
        this.name = myname;
        //给自己类name赋值
        //建议不要用name这个名字避免麻烦
    }

    // 父类中已经有了getName方法并且用final修饰 不能被重写 所以报错
    // 解决方法把get/set改名
    public String getMyName() {
        return name;
    }

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

    for (int i = 0; i < 50; i++) {
        System.out.println(getName() + name + "--" + i );
    }
    }
}