Java多线程

最新推荐文章于 2023-09-21 14:38:34 发布

成神之路.java

最新推荐文章于 2023-09-21 14:38:34 发布

阅读量312

点赞数 2

分类专栏： 2.Java SE 文章标签： java

本文链接：https://blog.csdn.net/qq_38135680/article/details/116572503

版权

2.Java SE 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

多线程：

1.进程与线程

1).进程：

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。在操作系统的概念中，每一个独立运行的程序就是一个"进程"。

2).线程：在百度百科中给的解释如下：

线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。

线程是独立调度和分派的基本单位。线程可以为操作系统内核调度的内核线程，如Win32线程；由用户进程自行调度的用户线程，如Linux平台的POSIX Thread；或者由内核与用户进程，如Windows 7的线程，进行混合调度。

同一进程中的多条线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等等。但同一进程中的多个线程有各自的调用栈（call stack），自己的寄存器环境（register context），自己的线程本地存储（thread-local storage）。

一个进程可以有很多线程，每条线程并行执行不同的任务。

在多核或多CPU，或支持Hyper-threading的CPU上使用多线程程序设计的好处是显而易见，即提高了程序的执行吞吐率。在单CPU单核的计算机上，使用多线程技术，也可以把进程中负责I/O处理、人机交互而常被阻塞的部分与密集计算的部分分开来执行，编写专门的workhorse线程执行密集计算，从而提高了程序的执行效率。

线程是由一个"进程"创建的——进程中，可以将一段代码分离出来，与"主进程"同时运行。

我们通俗一点的理解为：线程的组成计算机进程的最小单位，一个进程可以有多个线程，同一个进程多个线程之间是可以共享进程的虚拟地址空间，文件描述符和信号处理等资源的

意义：让程序可以同时做多件事。可以提高程序的执行效率，也可以提高硬件的使用效率。

2.并发与并行

并发(concurrency):是指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。
并行(parallel)：是指多个处理器或者是多核的处理器同时处理多个不同的任务。

【区别】并发是逻辑上的同时发生（simultaneous），而并行是物理上的同时发生。

简单的举个例子帮助理解：并发就是一个同学，在某一时间点里只能做一件事，比如，敲十分钟代码，玩半个小时手机，再打水五分钟。而并行主要讲的是，再同一时间里，不同的同学再玩手机，有的同学再敲代码，有的同学再打水。

3.多线程的制作方法

1).制作线程方式一：自定义线程类，并且继承自Thread，重写run()方法——线程中做的事情，写在这里。启动线程：创建自定义线程类对象，调用对象的start()方法。

自定义线程类：

public class MyThread extends Thread {//MyThread继承Thread类
    public static int ticket = 100;

    @Override
    public void run() {//重写run方法
        while (true) {
            int t = getTicket();
            if (t > 0) {
                System.out.println(this.getName() + "拿到一张票" + ticket);
            } else {

                System.out.println(this.getName() + "结束抢票，票被抢完了！！！" + ticket);
                break;
            }

        }


    }

主方法调用start（）方法


public class daqiang1 {
    public static void main(String[] args) {

        MyThead mt1=new MyThead();//创建MyThead对象
        
        mt1.setName("窗口1");
        
        mt1.start();//调用start方法
       
    }
}

注意事项：

a).重写的是run()，但启动线程调用的是start(). 如果new MyThread().run();也可以，但不是多线程。

b).一个线程对象只能start()一次。

c).一个线程类，可以创建多个对象，每个对象都可以以一个独立的线程的方式运行；

2).制作线程的方式二：我们需要自定义一个类，在类中实现Runnable接口，在类中重写run()方法。在主方法中启动线程时需要首先创建自定义类对象，然后再创建一个Thread对象，将自定义对象传个Thread的构造方法，最后通过调用Thread的start()完成线程的启动。

实现runnable接口

public class MyThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println("线程结束！！！");
        }
    }


}

 public static void main(String[] args) throws InterruptedException {

        //创建一个自定义对象
        MyThread mt=new MyThread();
        //创建一个Thread对象，将mt对象传参到Thread对象t
        Thread t=new Thread(mt);
        //使用Thread的start对象
        t.start();
       
    }

3).两种方式的对比：

a).第一种方式需要子类继承Thread——由于Java是单继承的，所以对于子类形成了限制。

b).第二种方式需要子类实现Runnable接口——对于子类来说，比较灵活【重点】

4.Thread类及类中常用的方法：【重点掌握】

【Thread类】

【Thread常用方法】

1).public String getName()：获取线程名称。任何一个线程默认都有线程名称——Thread-[索引值]

2).public void setName(String name)：设置线程名称。

3).public static Thread currentThread()：获取当前的线程对象。

4).public static void sleep(long m)：让当前线程暂停指定的毫秒值。

 public static void main(String[] args) throws InterruptedException {

        //创建一个自定义对象
        MyThread mt = new MyThread();
        //创建一个Thread对象，将mt对象传参到Thread对象t
        Thread t = new Thread(mt);
        //使用Thread的start对象

        t.start();
        t.setName("线程1");//设置线程名称
        System.out.println(t.currentThread());
        t.sleep(1000);

    }

5.匿名内部类的方式实现线程：

匿名内部类的使用：匿名内部类就相当于是创建了一个子类对象：编译时看父类，即Thread类，运行时看子类，及重写的run(){}方法

1、继承Thread

public class demon1 {
    public static void main(String[] args) {
        Thread t1 = new Thread(){         //  t1是一个线程对象，  暂时没有线程名。  可以通过t1.setName(name)设置线程名   
            @Override
            public void run() {
                System.out.println(this.getName() + ".......aaaaaa");
                super.run();
            }
            
        };
        new Thread(){       //   可以在构造方法里传入一个值，这个值就是线程名
            @Override
            public void run() {
                this.setName("lisoi");   // 在方法里  设置线程名
                System.out.println(this.getName() + "......bb");
                super.run();
            }
            
        }.start();
        t1.setName("zhangsan");
        t1.start();
    }
}

2、实现Runnable接口

public class demon2_currentThread {

    public static void main(String[] args) {
        new Thread("t1"){    //  直接传入 线程名字

            @Override
            public void run() {
                System.out.println(getName() + "......aaaa");    //  getName() 获取线程名
                
            }
            
        }.start();   //  start 直接开启线程        
        new Thread(new Runnable(){
            public void run() {
                System.out.println(Thread.currentThread().getName()+ "......bb"); 
               //  Runnable接口方式的多线程，不能直接调用Thread 的方法 ， 需要通过Thread.currentThread()   返回对当前正在执行的线程的对象的引用。  再来调用Thread的方法
            }
        }).start();
        System.out.println(Thread.currentThread().getName());       
    }

}

一、线程安全性问题：
   1).当多个线程共同访问同一个资源(变量、数组、集合对象、文件、数据库...)，由于Java内部线程工作的机制问题，可能会导致：
   多个线程访问同一个资源，最终的结果是错误的。
   2).多线程内存运行机制：
       每个线程在"栈"中都会有一个独立的"栈区"，每个线程在各自栈区中独立运行，互不干扰。
       见图2
   3).当多个线程访问同一个资源时，可能产生的安全性问题主要有以下三种：
       1).对一个变量访问的：可见性问题:见demo01，图03
       2).对一个变量访问的：有序性问题:见：图04
           当"编译器"编译代码时，为了提高效率，在不更改最终结果的前提下，可能会对代码进行"重排"——打乱了代码的原顺序
           例如：
               我们源码：                   编译时：
                   int a = 10;                   int b = 20;
                   int b = 20;                   int a = 10;
                   int c = a + b;               int c = a + b;
           但是在"多线程"情况下，如果两个线程，一样的执行过程，由于代码重排，就会导致两次的结果不同。

       3).对一个变量访问的：原子性问题:见demo02，图05
二、volatile关键字：
   1.volatile关键字用于修饰"变量"，可以保证变量的：可见性、有序性。但不能解决"原子性"问题。
       例如：解决：可见性
           public static volatile boolean flag = false;

       例如：解决：有序性：见图4
           public volatile int a = 0;
           public volatile boolean b = false;
           ...
           public void show1(){
               a = 1;
               b = true;//此两行代码不会进行代码重排
           }
           ...
三、原子类：之前的volatile关键字只能解决变量的：可见性、有序性，但不能解决"原子性"，怎么解决"原子性"？可以使用"原子类"。
   1.java.util.concurrent.automic.AutomicInteger(类)：对int类型变量操作的原子类：【重点，见Demo03】
   java.util.concurrent.automic.AutomicBoolean(类)：
   java.util.concurrent.automic.AutomicLong(类)：
   java.util.concurrent.automic.AtomicReference(类)：

   2.AutomicInteger内部的工作原理：CAS + 自旋
       1).单线程下基本流程：见图06
       2).多线程下的工作机制：见图07
   3).对基本类型数组并发访问的工具类：
       java.util.concurrent.automic.AtomicIntegerArray：对int数组操作的并发工具类。【见Demo04】
       java.util.concurrent.automic.AtomicLongArray：
       java.util.concurrent.automic.AtomicReferenceArray:对引用类型数组操作的并发工具类。

四、synchronized锁：
   1).它是一个关键字，是一种"重量级"的锁，也叫"悲观锁"。
   2).它通常用于：将多行代码进行"原子操作"——两个线程执行同一段代码，一个线程执行完这段代码，其它线程才可以进入执行。
   3).使用方式，有两种：
       1).同步代码块：见Demo05
           语法：synchronized(锁对象){
                   //同步的代码
           }
           "锁对象"：可以是"任意对象"，但必须保证多个线程"共享同一个对象"，这个对象做"锁"。
       2).同步方法：将整个方法加锁
           public synchronized int getTicket(){//锁对象：本对象——this
               //同步代码
           }
           注意：由于锁是本对象，所以必须保证本类只能有一个对象：
               MyThread mt1 = new MyThread();

               Thread t1 = new Thread(mt);
               Thread t2 = new Thread(mt);
               Thread t3 = new Thread(mt);

               t1.setName("窗口1");
               t2.setName("窗口2");
               t3.setName("窗口3");

               //启动线程
               t1.start();
               t2.start();
               t3.start();
           ---------------------------------------------------------------------------------------------------------------------------------------------------------------------
           public static sychronized int getTicket(){//锁对象：本类的Class对象——任何一个类在使用时，JVM都会在方法区中创建一个此类的Class文件，里面存储这个类的信息。
               //同步代码
           }
           注意：由于锁对象是本类的Class，一个类无论创建多少个对象，在方法区中都只有一个本类的Class对象，
           所以，这个类可以创建任意多的对象。
           //getTicket()是静态同步方法，可以这样写

           MyThread mt1 = new MyThread();
           MyThread mt2 = new MyThread();
           MyThread mt3 = new MyThread();

           mt1.setName("窗口1");
           mt2.setName("窗口2");
           mt3.setName("窗口3");

           mt1.start();
           mt2.start();
           mt3.start();

   4).Lock锁：
       API中建议的代码：
           Lock l = new 子类对象();
           l.lock();//加锁
           try {

           // 同步代码

           } finally {

           l.unlock();//解锁

           }
       注意：
       1).Lock在加锁后，如果执行的线程出现异常，不会自动释放锁。
       2).sychronized在加锁有，如果执行的线程出现异常，会自动释放锁。


五、对集合并发访问的工具类：
       1).List集合：CopyOnWriteArrayList【见Demo08】
               它内部采用的Lock锁实现(悲观锁)，效率很低。
                   Java类库中还有一个线程安全的List集合——Vector

                   Vector：使用的synchronized锁，而且：添加、删除、查询等所有方法都加锁。
                   CopyOnWriteArrayList：使用Lock锁，但只有：添加、删除加锁，查询不加锁。

       2).Set集合：CopyOnWriteArraySet
       3).Map集合：ConcurrentHashMap
                   它内部采用了CAS机制实现(乐观锁)——效率高。

============================================================================================================
一、线程的安全性问题：
   1).可见性；
   2).有序性；
   3).原子性；
二、volatile关键字：
   可以解决：可见性、有序性。
   不能解决原子性；
三、原子类：
   1).对int类型进行线程安全的操作的原子类：AtomicInteger
   2).对int[]数组进行线程安全操作的原子类：AtomicIntegerArray
   3).对List集合线程安全操作的原子类：CopyOnWriteArrayList
   4).对Set集合线程安全操作的原子类：CopyOnWriteArraySet
   5).对Map集合线程安全操作的原子类：ConcurrentHashMap
四、synchronized关键字：
   1).同步代码块：
       synchronized(锁对象){
           //同步代码
       }
   2).同步方法：
       1).普通同步方法：锁对象是本对象——this
           public void show(){
               synchronized(锁对象){
                   ...
               }

           }
       2).静态同步方法：锁对象是本类的Class对象。
           public static synchronized void show2(){
           }
   3).Lock锁：比synchronized更灵活。
       Lock lock = new 子类对象();//被多个线程共享，它本身就是锁对象
       lock.lock();//加锁
       try{
           //同步代码
       }catch(...){
       }finally{
           lock.unlock();
       }

一、线程池：
   1).什么是线程池：它是一个容器，可以缓存大量的"线程对象"。
   一个线程对象只能被start一次，然后就变为垃圾，等待被销毁，如果想再次的使用这个线程，只能再次创建它的对象，然后
                   再start()。创建一个线程是比较消耗系统资源的，如果反复多次创建这个线程对象，会降低系统性能。

                   线程池的作用：
                   1).可以缓存很多的线程对象，并且可以让这些线程对象多次反复执行。
                   2).可以控制多个线程的并发数量。
                   3).可以启动Callable线程(第三种实现线程的方式)


   2).怎么使用线程池：
       1).获取一个线程池对象；
       2).然后让线程池对象执行线程；
       示例：
           //使用线程池

//1.获取一个线程池对象
ExecutorService service = Executors.newFixedThreadPool(2);//获取一个可以包含2个核心线程的线程池对象

//2.创建一个我们的线程对象
MyThread t = new MyThread();//需要5秒

           //3.使用线程池对象，来执行我们的线程
           service.submit(t);
           service.submit(t);
           service.submit(t);
           service.submit(t);

           //4.关闭线程池对象
           service.shutdown();

   3).实现线程的第三种方式：实现Callable接口：
       之前我们学过两种实现线程的方式：
           1).第一种：继承Thread类，重写run()
           2).第二种：实现Runnable接口，重写run()
           有两个弊端：
           a).run()方法不能返回值；
           b).run()方法不能抛出"编译期"异常；

       所以从JDK1.4开始，Java提供了第三种实现异常的方式：继承Callable，重写call()，此方法有返回值，而且可以抛出任何异常。
       第一步：自定义类，实现Callable接口：
           public class MyCall implements Callable<Integer> {
               @Override
               public Integer call() throws Exception {
                       int sum = 0;
                       for (int i = 0; i <= 100; i++) {
                           sum += i;
                           Thread.sleep(50);

                       }
                       return sum;
               }
           }
       第二步：测试类：
           public static void main(String[] args) throws InterruptedException {
               //1.获取一个线程池对象
               ExecutorService service = Executors.newFixedThreadPool(2);

//2.创建自定义类对象
MyCall myCall = new MyCall();

               //3.使用线程池对象执行我们的自定义对象
               System.out.println("a");
               Future<Integer> future = service.submit(myCall);
               System.out.println("b");

               //判断这个线程是否结束
               while (!future.isDone()){
                   System.out.println("线程还没有计算完毕，做点其它事情....");
                   Thread.sleep(1000);
               }
               //获取返回值
               try {
                   Integer result = future.get();
                   System.out.println("线程的返回值是：" + result);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               } catch (ExecutionException e) {
                   e.printStackTrace();
               }

               //结束线程池
               service.shutdown();
           }


二、线程状态：
   1).一个线程，从创建对象开始，到执行完毕，中间会经历多种状态。
       1).新建
       2).可运行
       3).计时等待
       4).锁阻塞
       5).无限等待
       6).被终止
   2).等待和唤醒：
       1).指一个线程先开始工作，在工作过程中发现一些问题，这时会主动wait()方法，释放锁。然后
       另一个线程会拿到锁，开始解决之前的问题，解决问题后，会notify()唤醒之前等待的线程，继续工作。
       2).示例：白雪公主与白马王子

           public static void main(String[] args) throws InterruptedException {

               //1.定义一个对象，做"锁"
               Object obj = new Object();
               //2.有两个线程
               //白雪公主
               new Thread(new Runnable() {
                   @Override
                   public void run() {
                       //1.先拿到锁
                       synchronized (obj) {
                           //2.循环100次，表示：100岁
                           for (int i = 0; i <= 100; i++) {
                               System.out.println("白雪公主 " + i + " 岁");
                               try {
                                   Thread.sleep(1000);
                               } catch (InterruptedException e) {
                                   e.printStackTrace();
                               }
                               //判断是否到20岁
                               if (i == 20) {
                                   System.out.println("白雪公主到20了，唤醒白马王子线程...");
                                   try {
                                       obj.wait();//1.释放锁；2.本线程进入到无限等待
                                   } catch (InterruptedException e) {
                                       e.printStackTrace();
                                   }
                                   System.out.println("白雪公主被唤醒，与白马王子继续幸福生活下去......");
                               }
                           }
                       }
                   }
               }).start();

               Thread.sleep(1000);
               //白马王子
               new Thread(new Runnable() {
                   @Override
                   public void run() {
                       System.out.println("【白马王子】开始抢锁..");
                       synchronized (obj) {
                           System.out.println("【白马王子】拿到锁，可以迎娶白雪公主了，需要5秒.....");
                           try {
                               Thread.sleep(1000 * 5);
                           } catch (InterruptedException e) {
                               e.printStackTrace();
                           }
                           System.out.println("【白马王子】与白雪公主的婚礼举行完毕，唤醒白雪公主线程...");
                           obj.notifyAll();//不会释放锁。会将等待的线程由无限等待状态转到可运行状态。
                       }//代码块执行完毕，才会释放锁

                   }
               }).start();
           }
三、定义时：
   1).java.util.Timer(类)：定时器类。可以设置在指定的延迟日期/时间后，执行一次任务/间隔指定的时间，反复做一项任务。
   2).构造方法：
       1).Timer()：
   3).成员方法：
       1).void schedule(TimerTask task, long delay)：指定delay毫秒后，执行task任务，只执行一次
       2).void schedule(TimerTask task, long delay, long period)：指定delay毫秒后，执行task任务，每隔period周期性执行一次
       3).void schedule(TimerTask task, Date time)：从指定时间开始，执行task任务，只执行一次
       4).void schedule(TimerTask task, , Date time, long period)：从指定时间开始，执行task任务，每隔period周期性执行一次

四、Lambda表达式：
   1).它是JDK1.8开始的一个新语法，它是一种"替代语法"——当面向接口时，而且这个接口中有、且只有一个必须被子类重写的方法，当我们面向这种
   接口编程时，可以使用Lambda表达式。
   2).效果演示：
           public static void main(String[] args) {
               //1.传入子类对象
               new Thread(new MyRun()).start();

               //2.传入匿名内部类对象
               new Thread(new Runnable() {
                   @Override
                   public void run() {
                       for (int i = 0; i < 30; i++) {
                           System.out.println("敌人开枪：" + i);
                       }
                   }
               }).start();

               //3.使用Lambda代替之前的子类、匿名内部类
               //Lambda表达式实际上就是一个：重写了某个方法的没有名字的方法体。
               //实际传给Thread构造方法的就是一个"方法体"，没有定义类，没有产生对象——从这点上说，效率会高一些。
               new Thread(()-> {
                       for (int i = 0; i < 30; i++) {
                           System.out.println("敌人开枪：" + i);

                       }
               }).start();

           }
   3).Lambda表达式的标准语法和使用前提：
       1).标准语法：
           1).一对小括号：()——形参
           2).一个右箭头：->
           3).一对大括号：{}——方法体
       2).使用前提：
           1).面向接口
           2).接口中有、且只有一个必须被子类重写的抽象方法。
               public interface Animal{
                   public String toString();//错误的，子类可以不重写。

               }
           这种接口叫：函数式接口
           可以使用@FunctionalInterface注解进行约束检查。

       3).小结：凡是面向"函数是接口"的时候，都可以使用Lambda表达式：
   4).写两个例子：
       1).函数式接口中的抽象方法：无参、无返回值：Runnable接口
       2).函数式接口中的抽象方法：带参、带返回值：Comaprator接口

   5).Lambda的简化形式：
       1).形参：形参的类型都可以省略
       2).形参：如果形参只有一个，可以同时省略：形参类型，一对小括号
                   如果要省略小括号，必须省略数据类型。
                   如果只省略数据类型，可以不省略小括号。
       3).方法体：如果方法体中只有一句话，可以同时省略：一对大括号，语句后的分号，return语句(如果有)。
                   要省全省，要用就全用。

五、Stream流：
   1).java.util.stream.Stream(接口)：它类似于"迭代器"，可以把它看做高级的迭代器，它可以对大量的元素进行过滤、筛选、汇总...
   使用它再结合Lambda表达式，可以很方便的进行操作。
   2).效果演示：
       List<String> list = new ArrayList<>();

list.add("张三");
list.add("章子怡");
list.add("郭德纲");
list.add("张无忌");
list.add("张学友");

//使用Stream流来筛选和遍历
list.stream().filter(s -> s.startsWith("张"))
.skip(1)
.forEach(s -> System.out.println(s));


   3).获取流：
       1).通过Collection集合获取流：【重点掌握】
           Collection接口中的默认方法：stream()获取一个Stream流对象
           例如：
               List<String> list = new ArrayList<>();
               ...
               Stream<String> s = list.stream();
               ===============================================
               Set<String> set = new HashSet<>();
               ...
               Stream<String> s = set.stream();

       2).通过Map集合获取流：
           Map不能直接获取流。
               Map<Integer,String> map = new HashMap<>();
               ...
           A).获取"键"的流：
               Stream<Integer> keyStream = map.keySet().stream();

           B).获取"键值对"的流：
               Stream<Map.Entry<Integer,String>> entryStream = map.entrySet().stream();

       3).通过引用类型数组获取流：
           Integer[] arr = {10,20,30};
           Stream<Integer> intStream = Stream.of(arr);

       4).通过基本类型数组获取流：
           int[] arr = {10,20,30};
           IntStream intStream = IntStream.of(arr);
           int max = intStream.max();

       5).通过零散的数据获取流：
           Stream<Integer> intStream = Stream.of(10,20,30);

   4).操作流：
       1).forEach()方法：用于遍历元素。【终结】

           List<String> list = new ArrayList<>();

           list.add("张三");
           list.add("章子怡");
           list.add("郭德纲");
           list.add("张无忌");
           list.add("张学友");
           list.add("刘德华");

           //Lambda的省略格式
           list.stream().forEach(a -> System.out.println(a));
       2).filter()方法：用于过滤；【非终结】
           注意：
           1).Stream流是一次性的只能用一次；
           2).Stream流中的方法，如果是返回的Stream流，这样的方法叫：非终结方法——惰性的。
           如果是返回的非Stream流，这样的方法叫：终结方法

           示例代码：
           list.stream().filter(s -> s.startsWith("张"))
.forEach(s -> System.out.println(s));
       3).count()方法：求流中元素的数量【终结】
           示例：
           long count = list.stream().filter(s -> s.startsWith("张"))
.count();
           System.out.println("张姓学员共：" + count + " 人");

       4).limit()方法：获取前几个【非终结】
           示例：
           //获取张姓的前2人，并打印
           list.stream().filter(s -> s.startsWith("张"))
.limit(2)
.forEach(s -> System.out.println(s));

       5).skip()：跳过前几个【非终结】
           示例：
           //取出张姓学员，跳过前2个，打印剩余的
           list.stream().filter(s -> s.startsWith("张"))
.skip(2)
.forEach(s -> System.out.println(s));

       6).concat()：合并两个流为一个流。【非终结】
           示例：
           //将两个流合并成一个流
           Stream.concat(list.stream(),list2.stream())
.forEach(s -> System.out.println(s));

       7).map()：将一种泛型的流转换为另一种泛型的流。【非终结】
           示例：
           //将集合中的每个姓名构造一个Student对象，并打印
           namesList.stream().map(s -> new Student(s))
.forEach(stu -> System.out.println(stu));
       8).collect()：将流中的元素收集到集合【终结】
           List<String> zhangList = list.stream().filter(s -> s.startsWith("张"))
.collect(Collectors.toList());
           System.out.println(zhangList);
           System.out.println("----------------------------------");

           //提取到：Set集合
           Set<String> zhangSet = list.stream().filter(s -> s.startsWith("张"))
                   .collect(Collectors.toSet());
           System.out.println(zhangSet);
           System.out.println("----------------------------------");
9).toArray()：将流中的元素提取到数组【终结】
           //提取到：数组
           Object[] zhangArray = list.stream().filter(s -> s.startsWith("张"))
                   .toArray();
           for (Object o : zhangArray) {
               System.out.println(o);
           }

成神之路.java

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java多线程

二、多线程： 1).先讲两个概念： 1).进程：操作系统的概念，每一个独立运行的程序就是一个"进程"。 2).线程：线程是由一个"进程"创建的——进程中，可以将一段代码分离出来，与"主进程"同时运行。意义：让程序可以同时做多件事。可以提高程序的执行效率，也可以提高硬件的使用效率。 ...
复制链接

扫一扫