所需类型：

匿名内部类：可以是接口 也可以是抽象类 还可以是具体类只要重写方法就行！

Lambda表达式：只能是接口

使用限制：

如果接口中有仅只有一个抽象方法，可以使用lambda表达式，也可以使用匿名内部类
如果接口中多于一个抽象方法，只能使用匿名内部类 而不能使用lambda表达式！

实现原理:
匿名内部类：编译之后，产生一个单独的.class字节码文件
Lamdba表达式：编译之后，没有单独的.class字节码文件，对应的字节码会在运行的时候动态生成

1.一个子类只能继承一个抽象类，但能实现多个接口

2.抽象类中可以不全是抽象方法，而接口中全是抽象方法

3.抽象类中可以有构造方法，而接口中没有

4.抽象类中可以有普通成员变量，而接口中没有

5.抽象类和接口都可以有静态成员变量，抽象类中静态成员变量访问类型任意，但接口只能public static final（默认情况）；抽象类中可以有静态方法，而接口不能有

6.抽象类中的方法可以是public protected，而接口只有public

生成流：

通过数据源（集合，数组）生成流
List . steam（）

中间操作：

一个流后面可以跟随零个或多个中间操作，其目的主要是为了打开流，做出某种程度的数据过滤/映射，然后返回一个新的流，交给下一个使用
Filter（）

终结操作：

一个流只能有一个终结操作，当这个操作执行后，流就被使用光了，无法再被操作，所以这必定是流的最后一个操作
ForEach（）
并发和并行
并行：在同一时刻，有多个任务在多个CPU上同时执行。
并发：在同一时刻，有多个任务在单个CPU上交替执行。
1 进程和线程

进程
进程简单地说就是在多任务操作系统中，每个独立执行的程序，所以进程也就是“正在进行的程序”。（Windows系统中,我们可以在任务管理器中看到进程）

线程
线程是程序运行的基本执行单元。当操作系统执行一个程序时，会在系统中建立一个进程，该进程必须至少建立一个线程（这个线程被称为主线程）作为这个程序运行的入口点。因此，在操作系统中运行的任何程序都至少有一个线程。
进程和线程
进程：就是操作系统中正在运行的一个应用程序。
线程：就是应用程序中做的事情。比如：360软件中的杀毒，扫描木马，清理垃圾。
什么是多线程 ?
是指从软件或者硬件上实现多个线程并发执行的技术。
具有多线程能力的计算机因有硬件支持而能够在同一时间执行多个线程，提升性能。

1 线程类概述
java.lang.Thread 是线程类，可以用来给进程创建线程处理任务使用。要使用线程先介绍两个比较重要的方法：- public void run() : 线程执行任务的方法，是线程启动后第一个执行的方法- public void start() : 启动线程的方法, 线程对象调用该方法后,Java虚拟机就会调用此线程的run方法。

2 线程的创建方式1：继承Thread方式
我们启动一个Java程序，其实默认就存在一个主线程（main方法所在线程）
接下来，我们在主线程启动一个线程，打印1到100的数字，主线程启动完线程后又打印1到100的数字。此时主线程和启动的线程在并发执行，观察控制台打印的结果。
基本步骤：
创建一个类继承Thread类。
在类中重写run方法（线程执行的任务放在这里）
创建线程对象，调用线程的start方法开启线程。
执行程序，观察控制台的打印数据的现象
线程的创建
第二种创建方式使用如下构造方法，指定任务给线程执行
public Thread(Runnable target) public Thread(Runnalbe target , String name)
参数中的Runnable是一个接口，用来定义线程要执行的任务
实现步骤如下：
定义任务类实现Runnable，并重写run方法
创建任务对象
使用含有Runnable参数的构造方法，创建线程对象并指定任务。
调用线程的start方法，开启线程。
public interface Runnable { public abstract void run();}**

线程启动后就会执行该run方法了
两种创建线程方式对比:


优点 缺点
实现Runnable 扩展性强，实现该接口的同时还可以继承其他的类。 编程相对复杂，不能直接使用Thread类中的方法
继承Thread 编程比较简单，可以直接使用Thread类中的方法 可扩展性较差，
不能再继承其他的类

获取和设置线程名称
获取线程的名字
String getName()：返回此线程的名称

Thread类中设置线程的名字
void setName(String name)：将此线程的名称更改为等于参数 name
通过构造方法也可以设置线程名称

获得当前线程的对象
public static Thread currentThread() ：返回对当前正在执行的线程对象的引用

线程休眠
public static void sleep(long time)：让线程休眠指定的时间，单位为毫秒。

public void join() : 具备阻塞作用 , 等待这个线程死亡,才会执行其他线程

线程的优先级
public final void setPriority(int newPriority) 设置线程的优先级
public final int getPriority() 获取线程的优先级

函数式接口有什么特点？
接口中只有一个抽象方法是需要被实现的。

函数式接口有一个特殊标志性注解，是什么？
@FunctionalInterface

接口定义
package com.itheima.Lamand;

public interface Falyble {
void fly(String s);
}

测试类实现
public static void main(_String[] args) { //匿名内部类实现 useFlayble(new Falyble() { @Override
public void fly(_String s) { _System._out.println(_s);
System._out.println(“输出了”);
} });
System._out.println(“===========”);
//Lambda表达式 useFlayble((String s)->{ _System._out.println(“有参数的lambda表达式”);
System.out.println(“直接写！”);
});
}public static void useFlayble(Falyble s){ _s.fly(“风和日丽！”);
}_
有参数Lambda表达式有参数方法！

public class Test01 { public static void main(String[] args) { useRomunHand((int a,int b)->{ return a+b; }); System.out.println(“==========”); useRom((int a,int b)->{ return a+b; }); ** } public static void useRomunHand(Randoum randoum) { int getnumber = randoum.getnumber(100,20); System.out.println(“getnumber = “ + getnumber); } public static void useRom(Randoum randoum){ int Divat = randoum.getnumber(40,40 ); System.out.println(“Divat = “ + Divat); }}@FunctionalInterfaceinterface Randoum{ int getnumber(int a,int b);}

public class StreamDemo6 { public static void main(String[] args) { ArrayList list = new ArrayList<>(List.of(“曹操”, “曹孟德”, “曹阿瞒”, “曹阿瞒”, “刘备”, “刘玄德”, “刘皇叔”));** // 使用stream流 , 过滤性 曹 三个字的 // R collect(Collector collector) : 此方法只负责收集流中的数据 , 创建集合添加数据动作需要依赖于参数 list.stream().filter(name -> name.startsWith(“曹”)).filter(name -> name.length() == 3).forEach(System.out::println);** // collect负责收集元素 , 不负责创建List集合对象 // 如果需要创建List集合对象需要依赖于Collectors.toList() List cao = list.stream().filter(name -> name.startsWith(“曹”)).filter(name -> name.length() == 3) .collect(Collectors.toList()); System.out.println(“曹 = “ + cao);//曹 = [曹孟德, 曹阿瞒, 曹阿瞒] // public static Collector toSet()：把元素收集到Set集合中 Set cao2 = list.stream().filter(name -> name.startsWith(“曹”)).filter(name -> name.length() == 3) .collect(Collectors.toSet()); System.out.println(“曹 = “ + cao2);//曹 = [曹阿瞒, 曹孟德]** }**}
package com.itheima.stream_demo;**import java.util.ArrayList;import java.util.Collections;import java.util.Map;import java.util.stream.Collectors;**/ Stream流的收集操作 : 第三部分* 1 创建一个ArrayList集合，并添加以下字符串。字符串中前面是姓名，后面是年龄 “zhangsan,23” “lisi,24” “wangwu,25” 2 保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值 需求1 : 保留年龄大于等于24岁的人 需求2 : 并将结果收集到Map集合中，姓名为键，年龄为值 收集方法 : public static Collector toMap(Function keyMapper , Function valueMapper)：把元素收集到Map集合中 */public class StreamDemo7 { public static void main(String[] args) { ArrayList list = new ArrayList<>(); list.add(“zhangsan,23”); list.add(“lisi,24”); list.add(“wangwu,25”); // 需求1 : 保留年龄大于等于24岁的人
** Mapmap=list.stream() .filter(str -> Integer.parseInt(str.split(“,”)[1]) >= 24) .collect(Collectors.toMap( //键的Funtion str->str.split(“,”)[0], //值的Funtion str->str.split(“,”)[1])); System.out.println(map); }}
package com.itheima.stream_demo;**import java.util.ArrayList;import java.util.Comparator;import java.util.List;import java.util.stream.Stream;**/ Stream流中三类方法之一 : 中间方法* 1 Stream filter(Predicate predicate)：用于对流中的数据进行过滤 Predicate接口中的方法 : boolean test(T t)：对给定的参数进行判断，返回一个布尔值 2 Stream limit(long maxSize)：截取指定参数个数的数据 3 Stream skip(long n)：跳过指定参数个数的数据 4 static Stream concat(Stream a, Stream b)：合并a和b两个流为一个流 5 Stream distinct()：去除流中重复的元素。依赖(hashCode和equals方法) 6 Stream sorted () : 将流中元素按照自然排序的规则排序 7 Stream sorted (Comparator<? super T> comparator) : 将流中元素按照自定义比较器规则排序 /public class StreamDemo3 { public static void main(String[] args) { ArrayList list = new ArrayList<>(List.of(“曹操”, “曹孟德”, “曹阿瞒”, “曹阿瞒”, “曹阿瞒”, “刘备”, “刘玄德”, “刘皇叔”));** //1, Stream limit(long maxSize)：截取指定参数个数的数据 list.stream().filter(s -> s.startsWith(“曹”)).forEach(System.out::print); //曹操曹孟德曹阿瞒曹阿瞒曹阿瞒 System.out.println(); System.out.println(“===================”); //2, Stream skip(long n)：跳过指定参数个数的数据 list.stream().skip(1).forEach(System.out::print); //曹孟德曹阿瞒曹阿瞒曹阿瞒刘备刘玄德刘皇叔 System.out.println(); System.out.println(“===================”); //3, static Stream concat(Stream a, Stream b)：合并a和b两个流为一个流 Stream S1 = Stream.of(“A”, “B”, “C”); Stream S2 = Stream.of(“X”, “Y”, “Z”); Stream.concat(S1, S2).forEach(System.out::print); System.out.println(); System.out.println(“===================”); //4, Stream distinct()：去除流中重复的元素。依赖(hashCode和equals方法) Stream.of(“X”, “Y”, “Z”, “Y”, “Z”).distinct().forEach(System.out::print);// list.stream().distinct().forEach(System.out::print); //曹操曹孟德曹阿瞒刘备刘玄德刘皇叔 System.out.println(); System.out.println(“===================”); //5 Stream sorted () : 将流中元素按照自然排序的规则排序 list.stream().sorted().forEach(System.out::print); //刘备刘玄德刘皇叔曹孟德曹操曹阿瞒曹阿瞒曹阿瞒 System.out.println(); System.out.println(“===================”); //6, Stream sorted (Comparator<? super T> comparator) : 将流中元素按照自定义比较器规则排序** Stream.of(“A”,”B”,”C”,”D”,”F”).sorted(((o2, o1) -> o1.compareTo(o2))).forEach(System.out::print); System.out.println(); System.out.println(“===================”); //7 Stream limit(long maxSize)：截取指定参数个数的数据 //取了前5个然后跳过前俩个输出！ list.stream().limit(5).skip(2).forEach(s -> System.out.print(s));// 曹操 曹孟德 曹阿瞒 //8 Map数据的转换 映射方法 streammap(Function< T,R>mapper) //Function函数式接口在存在抽象方法： // R apply（T t）将T（流中原有数据类型）类型转换为R类型(将要转换得类型) System.out.println(); System.out.println(“===================”); Stream.of(“张三-18”, “王五-26”, “李四-20”) .map((String str)->{ String[]arr=str.split(“-“); return new Student(arr[0],Integer.parseInt(arr[1])); }).forEach(System.out::println);** }}*

class Student{ String name; int age;** public Student() { }** public Student(String name, int age) { this.name = name; this.age = age; }** public String getName() { return name; }** public void setName(String name) { this.name = name; }** public int getAge() { return age; }** public void setAge(int age) { this.age = age; }** @Override public String toString() { return “Student{“ + “name=’” + name + ‘\’’ + “, age=” + age + ‘}’; }}**

匿名Runnable”子类的方式实现线程
Public static void main(String[]args){

new Thread(new Runnable() { @Override public void run() {
实现的方法体！ 需要定义变量写在@声明上面 } }).start();

计算器 Calculator 接口
public class Demo05 { public static void main(String[] args) { INTPL(140,110,(int a,int b)->{return a+b;}); INTPL(130, 120, (a, b) -> a - b); } public static void INTPL(int a, int b, Calculator calculator) { int result = calculator.calc(130, 120); System.out.println(“结果” + result); } interface Calculator { int calc(int a, int b); }}

Lambda表达式的基础创建！
public class LambdaDemo {
_public static void main(String[] args) {
//将集合要以降序排序
List<_Integer_> list = new ArrayList<>();
list.add(100);
list.add(300);
list.add(200);
//集合以降序排序（以前的做法：匿名对象）
// 最简化 Collections.sort(list, (o1, o2) -> o2 - o1);
Collections._sort(_list, new Comparator<_Integer_>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
//集合以降序排序（新做法：Lambda表达式）
Collections._sort(_list, (Integer o1, Integer o2) -> {
return o2 - o1;
});
System._out.println(“list = “ + list);
Collections.sort(_list, (Integer o1, Integer o2) -> {
return o1 - o2;
});
System._out.println(“list = “ + list);
Collections.sort(_list, (o1, o2) -> o2 - o1);
}
}_

String 类型 使用lambda表达式 实现降序！

public class Demo04 {
_public static void main(String[] args) {
List<_String_> list = new ArrayList<>();
Collections._addAll(_list, “cab”, “bac”, “acb”, “cba”, “bca”, “abc”)_;

  1.     Collections._sort(_list, new Comparator_<_String_>() {<br />            _@Override<br />            public int compare_(_String o1, String o2_) {<br />                _return o2.compareTo_(_o1_)_;<br />            _}<br />        })_;<br />        System._out_.println_(_"list = " + list_)_;<br />    _}_<br /> 需求 :<br />        定义一个集合，并添加一些整数1，2，3，4，5，6，7，8，9，10<br />        将集合中的奇数删除，只保留偶数。<br />        遍历集合得到2，4，6，8，10<br /> */<br />public class StreamDemo6 {<br />    public static void main(String[] args) {<br />        ArrayList<Integer> list = new ArrayList<>();<br />        for (int i = 1; i <= 10; i++) {<br />            list.add(i);<br />        }<br />        list.add(10);<br />        list.add(10);<br />        list.add(10);<br />        list.add(10);<br />        list.add(10);
  3.     // collect只负责收集流中的数据<br />        // Collectors.toList()会负责在底层创建list集合 ,并把数据添加到集合中 , 返回集合对象<br />        List<Integer> list2 = list.stream().filter(num -> num % 2 == 0 ).collect(Collectors.toList());<br />        System.out.println(list2);
  5.     Set<Integer> set = list.stream().filter(num -> num % 2 == 0 ).collect(Collectors.toSet());<br />        System.out.println(set);
  7. }<br />}

day10 - Lambda,Stream,File,递归

今日目标

  • Lambda表达式

  • Stream流

  • File类

  • 递归

1 Lambda表达式

1.1 体验Lambda表达式

  • ``` package com.itheima.lambda_demo;

/ Lambda表达式体验 : / public class LambdaDemo { public static void main(String[] args) { // 匿名内部类方式完成 goSwimming(new Swimming() { @Override public void swim() { System.out.println(“铁汁 , 我们去游泳吧….”); } });

  1.     // lambda表达式的方式完成
  2.     goSwimming(() -> System.out.println("铁汁 , 我们去游泳吧...."));
  4. }
  6. public static void goSwimming(Swimming swimming) {
  7.     swimming.swim();
  8. }

}

interface Swimming { public abstract void swim(); }

  2. -  lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的 
  3. -  面向对象思想 : 
  4.    - 强调的是用对象去完成某些功能
  5. -  函数式编程思想 : 
  6.    - 强调的是结果 , 而不是怎么去做
  8. <a name="a739aefc"></a>
  9. ### 1.2 函数式接口
  11. - 只有一个抽象方法需要重写的接口，函数式接口。函数式接口是允许有其他的非抽象方法的存在例如静态方法，默认方法，私有方法。
  12. - 为了标识接口是一个函数式接口，可以在接口之上加上一个注解： [@FunctionalInterface ](/FunctionalInterface ) 以示区别 
  13. - 在JDK中 java.util.function 包中的所有接口都是函数式接口。我们之前学习线程时学习的Runnable也是函数式接口
  14. - <br />
  16. <a name="a7861ee2"></a>
  17. ### 1.3 Lambda表达式的使用
  19. -   
  20. <a name="e5a85d6c"></a>
  21. ##### 使用前提
  23.    - 必须存在一个接口
  24.    - 接口中有且只有一个抽象方法
  25. -   
  26. <a name="b2152aa4"></a>
  27. ##### 格式 : ( 形式参数 )  -> { 代码块 }
  29.    - 形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可
  30.    - ->：由英文中画线和大于符号组成，固定写法。代表指向动作
  31.    - 代码块：是我们具体要做的事情，也就是以前我们写的方法体内容
  33. <a name="ceb8a348"></a>
  34. ### 1.4 Lambda表达式的案例
  36. ```java
  37. package com.itheima.lambda_test;
  39. /*
  40.     练习1：
  41.         1 编写一个接口（ShowHandler）
  42.         2 在该接口中存在一个抽象方法（show），该方法是无参数无返回值
  43.         3 在测试类（ShowHandlerDemo）中存在一个方法（useShowHandler）
  44.             方法的的参数是ShowHandler类型的，在方法内部调用了ShowHandler的show方法
  45.  */
  46. public class LambdaTest1 {
  47.     public static void main(String[] args) {
  48.         useShowHandler(() -> {
  49.             System.out.println("我是一个lambda表达式....");
  50.         });
  51.     }
  53.     public static void useShowHandler(ShowHandler showHandler) {
  54.         showHandler.show();
  55.     }
  56. }
  58. interface ShowHandler {
  59.     public abstract void show();
  60. }
  1. package com.itheima.lambda_test;
  3. /*
  4.     1 首先存在一个接口（StringHandler）
  5.     2 在该接口中存在一个抽象方法（printMessage），该方法是有参数无返回值
  6.     3 在测试类（StringHandlerDemo）中存在一个方法（useStringHandler），
  7.         方法的的参数是StringHandler类型的，
  8.         在方法内部调用了StringHandler的printMessage方法
  9.  */
  10. public class LambdaTest2 {
  11.     public static void main(String[] args) {
  12.         useStringHandler((String msg) -> {
  13.             System.out.println(msg);
  14.         });
  15.     }
  17.     public static void useStringHandler(StringHandler stringHandler){
  18.         stringHandler.printMessage("今天天气不错 , 挺风和日丽的...");
  19.     }
  20. }
  22. @FunctionalInterface
  23. interface StringHandler {
  24.     public abstract void printMessage(String msg);
  25. }
  1. package com.itheima.lambda_test;
  3. import java.util.Random;
  5. /*
  6.     1 首先存在一个接口（RandomNumHandler）
  7.     2 在该接口中存在一个抽象方法（getNumber），该方法是无参数但是有返回值
  8.     3 在测试类（RandomNumHandlerDemo）中存在一个方法（useRandomNumHandler），方法的的参数是RandomNumHandler类型的
  9.         在方法内部调用了RandomNumHandler的getNumber方法
  11.  */
  12. public class LambdaTest3 {
  13.     public static void main(String[] args) {
  14.         useRandomNumHandler(() -> {
  15.             return new Random().nextInt(10) + 1;
  16.         });
  17.     }
  19.     public static void useRandomNumHandler(RandomNumHandler randomNumHandler) {
  20.         int number = randomNumHandler.getNumber();
  21.         System.out.println(number);
  22.     }
  23. }
  25. interface RandomNumHandler {
  26.     public abstract int getNumber();
  27. }
  1. package com.itheima.lambda_test;
  3. /*
  4.     1 首先存在一个接口（Calculator）
  5.     2 在该接口中存在一个抽象方法（calc），该方法是有参数也有返回值
  6.     3 在测试类（CalculatorDemo）中存在一个方法（useCalculator）
  7.         方法的的参数是Calculator类型的
  8.         在方法内部调用了Calculator的calc方法
  10.  */
  11. public class LambdaTest4 {
  12.     public static void main(String[] args) {
  13.         useCalculator((int a , int b) -> { return a + b;});
  14.     }
  16.     public static void useCalculator(Calculator calculator) {
  17.         int calc = calculator.calc(10, 20);
  18.         System.out.println(calc);
  19.     }
  20. }
  22. @FunctionalInterface
  23. interface Calculator {
  24.     public abstract int calc(int a, int b);
  25. }

2 Stream流

2.1 Stream的体验

  1. package com.itheima.stream_demo;
  3. import java.util.ArrayList;
  5. /*
  6.     体验Stream流的好处
  8.     需求：按照下面的要求完成集合的创建和遍历
  10.         1 创建一个集合，存储多个字符串元素
  11.             "张无忌" , "张翠山" , "张三丰" , "谢广坤" , "赵四" , "刘能" , "小沈阳" , "张良"
  12.         2 把集合中所有以"张"开头的元素存储到一个新的集合
  13.         3 把"张"开头的集合中的长度为3的元素存储到一个新的集合
  14.         4 遍历上一步得到的集合
  16.  */
  17. public class StreamDemo {
  18.     public static void main(String[] args) {
  19.         // 传统方式完成
  20.         ArrayList<String> list = new ArrayList<>();
  21.         list.add("张无忌");
  22.         list.add("张翠山");
  23.         list.add("张三丰");
  24.         list.add("谢广坤");
  25.         list.add("赵四");
  26.         list.add("刘能");
  27.         list.add("小沈阳");
  28.         list.add("张良");
  30.         // 把集合中所有以"张"开头的元素存储到一个新的集合
  31.         ArrayList<String> list2 = new ArrayList<>();
  32.         for (String s : list) {
  33.             if (s.startsWith("张")) {
  34.                 list2.add(s);
  35.             }
  36.         }
  38.         // 把"张"开头的集合中的长度为3的元素存储到一个新的集合
  39.         ArrayList<String> list3 = new ArrayList<>();
  40.         for (String s : list2) {
  41.             if (s.length() == 3) {
  42.                 list3.add(s);
  43.             }
  44.         }
  45.         // 遍历list3集合
  46.         for (String s : list3) {
  47.             System.out.println(s);
  48.         }
  50.         System.out.println("================================");
  52.         // Stream流的方式
  53.         list.stream().filter(s -> s.startsWith("张") && s.length() == 3).forEach(s -> System.out.println(s));
  54.     }
  55. }

2.2 Stream流的三类方法

  • 获取Stream流
    • 创建一条流水线，并把数据放到流水线上准备进行操作
  • 中间方法
    • 流水线上的操作。
    • 一次操作完毕之后，还可以继续进行其他操作
  • 终结方法
    • 一个Stream流只能有一个终结方法
    • 是流水线上的最后一个操作

2.3 第一类 : 获取方法

  1. package com.itheima.stream_demo;
  3. import java.util.ArrayList;
  4. import java.util.Arrays;
  5. import java.util.HashMap;
  7. /*
  8.     Stream流中三类方法之一 :  获取方法
  10.     1 单列集合
  11.        可以使用Collection接口中的默认方法stream()生成流
  12.        default Stream<E> stream()
  13.     2 双列集合
  14.         双列集合不能直接获取 , 需要间接的生成流
  15.         可以先通过keySet或者entrySet获取一个Set集合，再获取Stream流
  16.     3 数组
  17.        Arrays中的静态方法stream生成流
  18.  */
  19. public class StreamDemo2 {
  20.     public static void main(String[] args) {
  21.         // 单列集合的获取
  22.         // method1();
  24.         // 双列集合的获取
  25.         // method2();
  27.         // 数组获取
  28.         // method3();
  30.     }
  32.     private static void method3() {
  33.         int[] arr = {1, 2, 3, 4, 5, 6};
  34.         Arrays.stream(arr).forEach(s -> System.out.println(s));
  35.     }
  37.     private static void method2() {
  38.         HashMap<String, String> hm = new HashMap<>();
  39.         hm.put("it001", "曹植");
  40.         hm.put("it002", "曹丕");
  41.         hm.put("it003", "曹熊");
  42.         hm.put("it004", "曹冲");
  43.         hm.put("it005", "曹昂");
  45.         // 获取map集合的健集合 , 在进行输出打印
  46.         hm.keySet().stream().forEach(s -> System.out.println(s));
  47.         // 获取map集合的entry对象 , 在输出打印
  48.         hm.entrySet().stream().forEach(s -> System.out.println(s));
  49.     }
  51.     private static void method1() {
  52.         // 可以使用Collection接口中的默认方法stream()生成流
  53.         ArrayList<String> list = new ArrayList<>();
  54.         list.add("迪丽热巴");
  55.         list.add("古力娜扎");
  56.         list.add("马尔扎哈");
  57.         list.add("欧阳娜娜");
  58.         list.stream().forEach(s -> System.out.println(s));
  59.     }
  60. }

2.4 第二类 : 中间方法

  1. package com.itheima.stream_demo;
  3. import java.util.ArrayList;
  4. import java.util.Comparator;
  5. import java.util.function.Predicate;
  6. import java.util.stream.Stream;
  8. /*
  9.     Stream流中三类方法之一 :  中间方法
  11.     1 Stream<T> filter(Predicate predicate)：用于对流中的数据进行过滤
  12.         Predicate接口中的方法 : boolean test(T t)：对给定的参数进行判断，返回一个布尔值
  13.     2 Stream<T> limit(long maxSize)：截取指定参数个数的数据
  14.     3 Stream<T> skip(long n)：跳过指定参数个数的数据
  15.     4 static <T> Stream<T> concat(Stream a, Stream b)：合并a和b两个流为一个流
  16.     5 Stream<T> distinct()：去除流中重复的元素。依赖(hashCode和equals方法)
  17.     6 Stream<T> sorted () : 将流中元素按照自然排序的规则排序
  18.     7 Stream<T> sorted (Comparator<? super T> comparator) : 将流中元素按照自定义比较器规则排序
  20.  */
  21. public class StreamDemo3 {
  22.     public static void main(String[] args) {
  23.         ArrayList<String> list = new ArrayList<>();
  24.         list.add("张无忌");
  25.         list.add("张翠山");
  26.         list.add("张三丰");
  27.         list.add("谢广坤");
  28.         list.add("赵四");
  29.         list.add("刘能");
  30.         list.add("小沈阳");
  31.         list.add("张良");
  32.         list.add("张良");
  33.         list.add("张良");
  34.         list.add("张良");
  36.         // Stream<T> limit(long maxSize)：截取指定参数个数的数据
  37.         // list.stream().limit(3).forEach(s -> System.out.println(s));
  39.         // Stream<T> skip(long n)：跳过指定参数个数的数据
  40.         // list.stream().skip(3).forEach(s-> System.out.println(s));
  42.         // Stream<T> distinct()：去除流中重复的元素。依赖(hashCode和equals方法)
  43.         // list.stream().distinct().forEach(s->{System.out.println(s);});
  45.     }
  47.     // // Stream<T> sorted (Comparator<? super T> comparator) : 将流中元素按照自定义比较器规则排序
  48.     private static void method3(ArrayList<String> list) {
  49.         list.stream().sorted(new Comparator<String>() {
  50.             @Override
  51.             public int compare(String o1, String o2) {
  52.                 return o1.length() - o2.length();
  53.             }
  54.         }).forEach(s->{
  55.             System.out.println(s);
  56.         });
  57.     }
  59.     // Stream<T> sorted () : 将流中元素按照自然排序的规则排序
  60.     private static void method3() {
  61.         ArrayList<Integer> list2 = new ArrayList<>();
  62.         list2.add(3);
  63.         list2.add(1);
  64.         list2.add(2);
  65.         list2.stream().sorted().forEach(s->{
  66.             System.out.println(s);
  67.         });
  68.     }
  70.     // // static <T> Stream<T> concat(Stream a, Stream b)：合并a和b两个流为一个流
  71.     private static void method2(ArrayList<String> list) {
  72.         ArrayList<String> list2 = new ArrayList<>();
  73.         list2.add("迪丽热巴");
  74.         list2.add("古力娜扎");
  75.         list2.add("欧阳娜娜");
  76.         list2.add("马尔扎哈");
  78.         Stream.concat(list.stream(), list2.stream()).forEach(s -> {
  79.             System.out.println(s);
  80.         });
  81.     }
  83.     // Stream<T> filter(Predicate predicate)：用于对流中的数据进行过滤
  84.     private static void method1(ArrayList<String> list) {
  85.         // filter方法会获取流中的每一个数据
  86.         // s就代表的是流中的每一个数据
  87.         // 如果返回值为true , 那么代表的是数据留下来
  88.         // 如果返回值的是false , 那么代表的是数据过滤掉
  89. //        list.stream().filter(new Predicate<String>() {
  90. //            @Override
  91. //            public boolean test(String s) {
  92. //                boolean result = s.startsWith("张");
  93. //                return result;
  94. //            }
  95. //        }).forEach(s -> System.out.println(s));
  97.         list.stream().filter(s ->
  98.                 s.startsWith("张")
  99.         ).forEach(s -> System.out.println(s));
  100.     }
  101. }

2.5 第三类 : 终结方法

  1. package com.itheima.stream_demo;
  3. import java.util.ArrayList;
  4. import java.util.function.Consumer;
  6. /*
  7.     Stream流中三类方法之一 :  终结方法
  8.     1 void forEach(Consumer action)：对此流的每个元素执行操作
  9.         Consumer接口中的方法 void accept(T t)：对给定的参数执行此操作
  10.     2 long count()：返回此流中的元素数
  12.  */
  13. public class StreamDemo4 {
  14.     public static void main(String[] args) {
  15.         ArrayList<String> list = new ArrayList<>();
  16.         list.add("张无忌");
  17.         list.add("张翠山");
  18.         list.add("张三丰");
  19.         list.add("谢广坤");
  21.         // long count()：返回此流中的元素数
  22.         long count = list.stream().count();
  23.         System.out.println(count);
  24.     }
  25.     // void forEach(Consumer action)：对此流的每个元素执行操作
  26.     private static void method1(ArrayList<String> list) {
  27.         // 把list集合中的元素放在stream流中
  28.         // forEach方法会循环遍历流中的数据
  29.         // 并循环调用accept方法 , 把数据传给s
  30.         // 所以s就代表的是流中的每一个数据
  31.         // 我们只要在accept方法中对数据做业务逻辑处理即可
  32.         list.stream().forEach(new Consumer<String>() {
  33.             @Override
  34.             public void accept(String s) {
  35.                 System.out.println(s);
  36.             }
  37.         });
  39.         System.out.println("=====================");
  41.         list.stream().forEach( (String s) -> {
  42.             System.out.println(s);
  43.         });
  45.         System.out.println("=====================");
  47.         list.stream().forEach(  s -> { System.out.println(s); });
  48.     }
  50. }

2.6 Stream流中的收集方法

  1. package com.itheima.stream_demo;
  3. import java.util.ArrayList;
  5. /*
  6.     Stream流的收集操作 : 第一部分
  8.     需求：过滤元素并遍历集合
  9.         定义一个集合，并添加一些整数1，2，3，4，5，6，7，8，9，10
  10.         将集合中的奇数删除，只保留偶数。
  11.         遍历集合得到2，4，6，8，10
  13.     结论：在Stream流中无法直接修改集合,数组等数据源中的数据。
  14.  */
  15. public class StreamDemo5 {
  16.     public static void main(String[] args) {
  17.         ArrayList<Integer> list = new ArrayList<>();
  19.         for (int i = 1; i <= 10; i++) {
  20.             list.add(i);
  21.         }
  23.         list.stream().filter(num -> num % 2 == 0).forEach(num -> System.out.println(num));
  25.         System.out.println("=============");
  27.         // 结论：在Stream流中无法直接修改集合,数组中的数据。
  28.         System.out.println(list);
  29.     }
  30. }
  • 结论：在Stream流中无法直接修改集合,数组中的数据
  1. package com.itheima.stream_demo;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.Set;
  6. import java.util.stream.Collectors;
  8. /*
  10.     Stream流的收集操作 : 第二部分
  12.     使用Stream流的方式操作完毕之后，我想把流中的数据起来，该怎么办呢？
  14.     Stream流的收集方法
  15.     R collect(Collector collector) : 此方法只负责收集流中的数据 , 创建集合添加数据动作需要依赖于参数
  17.     工具类Collectors提供了具体的收集方式
  18.     public static <T> Collector toList()：把元素收集到List集合中
  19.     public static <T> Collector toSet()：把元素收集到Set集合中
  20.     public static  Collector toMap(Function keyMapper,Function valueMapper)：把元素收集到Map集合中
  23.     需求 :
  24.         定义一个集合，并添加一些整数1，2，3，4，5，6，7，8，9，10
  25.         将集合中的奇数删除，只保留偶数。
  26.         遍历集合得到2，4，6，8，10
  27.  */
  28. public class StreamDemo6 {
  29.     public static void main(String[] args) {
  30.         ArrayList<Integer> list = new ArrayList<>();
  31.         for (int i = 1; i <= 10; i++) {
  32.             list.add(i);
  33.         }
  34.         list.add(10);
  35.         list.add(10);
  36.         list.add(10);
  37.         list.add(10);
  38.         list.add(10);
  40.         // collect只负责收集流中的数据
  41.         // Collectors.toList()会负责在底层创建list集合 ,并把数据添加到集合中 , 返回集合对象
  42.         List<Integer> list2 = list.stream().filter(num -> num % 2 == 0 ).collect(Collectors.toList());
  43.         System.out.println(list2);
  45.         Set<Integer> set = list.stream().filter(num -> num % 2 == 0 ).collect(Collectors.toSet());
  46.         System.out.println(set);
  48.     }
  49. }
  1. package com.itheima.stream_demo;
  3. import java.util.ArrayList;
  4. import java.util.Map;
  5. import java.util.stream.Collectors;
  7. /*
  8.     Stream流的收集操作 : 第三部分
  10.     1 创建一个ArrayList集合，并添加以下字符串。字符串中前面是姓名，后面是年龄
  11.         "zhangsan,23"
  12.         "lisi,24"
  13.         "wangwu,25"
  14.     2 保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值
  16.     收集方法 :
  17.     public static  Collector toMap(Function keyMapper  ,   Function valueMapper)：把元素收集到Map集合中
  18.  */
  19. public class StreamDemo7 {
  20.     public static void main(String[] args) {
  21.         ArrayList<String> list = new ArrayList<>();
  22.         list.add("zhangsan,23");
  23.         list.add("lisi,24");
  24.         list.add("wangwu,25");
  26.         // collect 只负责收集数据
  27.         // Collectors.toMap负责在底层创建集合对象 , 添加元素
  28.         // toMap方法中的s就是代表的是集合中的每一个元素
  29.         // 第一个参数 : 如何获取map集合中的键
  30.         // 第二个参数 : 如何获取map集合中的值
  31.         Map<String, String> map = list.stream().filter(s -> Integer.parseInt(s.split(",")[1]) > 23).collect(
  32.                 Collectors.toMap(
  33.                         (String s) -> {
  34.                             return s.split(",")[0];
  35.                         }
  36.                         ,
  37.                         (String s) -> {
  38.                             return s.split(",")[1];
  39.                         }
  40.                 )
  41.         );
  42.         System.out.println(map);
  43.     }
  44. }

3 File类

3.1 File类的介绍

  • java.io.File 类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作

3.2 构造方法

  1. package com.itheima.file_demo;
  3. import java.io.File;
  5. /*
  6.     File：它是文件和目录路径名的抽象表示
  7.         文件和目录可以通过File封装成对象
  8.         File封装的对象仅仅是一个路径名。它可以是存在的，也可以是不存在的。
  9.     构造方法 :
  10.         1 File(String pathname)   通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
  11.         2 File(String parent, String child)   从父路径名字符串和子路径名字符串创建新的 File实例
  12.         3 File(File parent, String child) 从父抽象路径名和子路径名字符串创建新的 File实例
  13.  */
  14. public class FileDemo1 {
  15.     public static void main(String[] args) {
  16. //        1 File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
  17.         File f1 = new File("D:\\abc.txt");
  18.         System.out.println(f1);
  19. //        2 File(String parent, String child) 从父路径名字符串和子路径名字符串创建新的 File实例
  20.         File f2 = new File("D:\\aaa", "bbb.txt");
  21.         System.out.println(f2);
  23. //        3 File(File parent, String child)   从父抽象路径名和子路径名字符串创建新的 File实例
  24.         File f3 = new File(new File("D:\\aaa"), "bbb.txt");
  25.         System.out.println(f3);
  26.     }
  27. }

3.3 File类的创建功能

  1. package com.itheima.file_demo;
  4. import java.io.File;
  5. import java.io.IOException;
  7. /*
  8.     File类的创建功能 :
  9.         1 public boolean createNewFile()    : 创建一个新的空的文件
  10.         2 public boolean mkdir()   : 创建一个单级文件夹
  11.         3 public boolean mkdirs() : 创建一个多级文件夹
  12.  */
  13. public class FileDemo2 {
  14.     public static void main(String[] args) throws IOException {
  15.         File f1 = new File("D:\\a.txt");
  16.         // 1 public boolean createNewFile()     : 创建一个新的空的文件
  17.         System.out.println(f1.createNewFile());
  19.         File f2 = new File("day10_demo\\aaa");
  20.         //  2 public boolean mkdir()   : 创建一个单级文件夹
  21.         System.out.println(f2.mkdir());
  23.         File f3 = new File("day10_demo\\bbb\\ccc");
  24.         // 3 public boolean mkdirs() : 创建一个多级文件夹
  25.         System.out.println(f3.mkdirs());
  26.     }
  27. }

3.4 File类的删除功能

  1. package com.itheima.file_demo;
  3. import java.io.File;
  4. import java.io.IOException;
  6. /*
  7.     File类删除功能 :
  8.         public boolean delete()    删除由此抽象路径名表示的文件或目录
  10.         注意 : 
  11.             1 delete方法直接删除不走回收站。
  12.             2 如果删除的是一个文件，直接删除。
  13.             3 如果删除的是一个文件夹，需要先删除文件夹中的内容，最后才能删除文件夹
  14.  */
  15. public class FileDemo3 {
  17.     public static void main(String[] args) throws IOException {
  18.         File f1 = new File("D:\\a.txt");
  19.         // 1 public boolean createNewFile()     : 创建一个新的空的文件
  20.         System.out.println(f1.delete());
  22.         File f2 = new File("day10_demo\\aaa");
  23.         //  2 public boolean mkdir()   : 创建一个单级文件夹
  24.         System.out.println(f2.delete());
  26.         File f3 = new File("day10_demo\\bbb");
  27.         // 3 public boolean mkdirs() : 创建一个多级文件夹
  28.         System.out.println(f3.delete());
  29.     }
  30. }

3.5 File类的判断和获取功能

  1. package com.itheima.file_demo;
  3. import java.io.File;
  5. /*
  6.     File类判断和获取功能
  7.         public boolean isDirectory()   测试此抽象路径名表示的File是否为目录
  8.         public boolean isFile()    测试此抽象路径名表示的File是否为文件
  9.         public boolean exists()    测试此抽象路径名表示的File是否存在
  10.         public String getAbsolutePath()    返回此抽象路径名的绝对路径名字符串
  11.         public String getPath()    将此抽象路径名转换为路径名字符串
  12.         public String getName()    返回由此抽象路径名表示的文件或目录的名称
  13.  */
  14. public class FileDemo4 {
  15.     public static void main(String[] args) {
  16.         File f1 = new File("day10_demo\\aaa");
  17.         File f2 = new File("day10_demo\\a.txt");
  19. //        public boolean isDirectory() 测试此抽象路径名表示的File是否为目录
  20.         System.out.println(f1.isDirectory());
  21.         System.out.println(f2.isDirectory());
  23. //        public boolean isFile()  测试此抽象路径名表示的File是否为文件
  24.         System.out.println(f1.isFile());
  25.         System.out.println(f2.isFile());
  27. //        public boolean exists()  测试此抽象路径名表示的File是否存在
  28.         System.out.println(f1.exists());
  30. //        public String getAbsolutePath()  返回此抽象路径名的绝对路径名字符串
  31.         System.out.println(f1.getAbsolutePath());
  33. //        public String getPath()  将此抽象路径名转换为路径名字符串
  34.         System.out.println(f1.getPath());
  36. //        public String getName()  返回由此抽象路径名表示的文件或目录的名称
  37.         System.out.println(f2.getName());
  38.     }
  39. }

3.6 File类高级获取功能

  1. package com.itheima.file_demo;
  3. import java.io.File;
  5. /*
  6.     File类高级获取功能
  7.         public File[] listFiles()  返回此抽象路径名表示的目录中的文件和目录的File对象数组
  9.     listFiles方法注意事项：
  10.         1 当调用者不存在时，返回null
  11.         2 当调用者是一个文件时，返回null
  12.         3 当调用者是一个空文件夹时，返回一个长度为0的数组
  13.         4 当调用者是一个有内容的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回
  14.         5 当调用者是一个有隐藏文件的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回，包含隐藏内容
  15.  */
  16. public class FileDemo5 {
  17.     public static void main(String[] args) {
  18.         File file = new File("day10_demo\\bbb\\ccc");
  20.         // 返回此抽象路径名表示的目录中的文件和目录的File对象数组
  21.         File[] files = file.listFiles();
  23.         // 遍历File类的数组
  24.         for (File f : files) {
  25.             // 拿到每一个文件的文字
  26.             System.out.println(f.getName());
  27.         }
  28.     }
  29. }

练习 :
  1. package com.itheima.file_demo;
  3. import java.io.File;
  4. import java.util.HashMap;
  6. /*
  7.     练习二 ：统计一个文件夹中每种文件的个数并打印。
  9.    打印格式如下：
  10.       txt:3个
  11.       doc:4个
  12.       jpg:6个
  13.       …
  14.  */
  15. public class FileTest2 {
  16.     public static void main(String[] args) {
  17.         File file = new File("day10_demo\\统计文件个数文件夹");
  19.         getFileCount(file);
  20.     }
  22.     public static void getFileCount(File f) {
  24.         HashMap<String, Integer> hm = new HashMap<>();
  26.         // 是文件夹在获取所有的子文件
  27.         if (f.isDirectory()) {
  28.             File[] files = f.listFiles();
  29.             // 遍历数组
  30.             for (File file : files) {
  31.                 String fileName = file.getName();
  32.                 String name = fileName.split("\\.")[1];
  33.                 if (hm.containsKey(name)) {
  34.                     hm.put(name, hm.get(name));
  35.                 } else {
  36.                     hm.put(name, 1);
  37.                 }
  38.             }
  39.         }
  41.         System.out.println(hm);
  42.     }
  43. }

4 递归

  • 概述
    • 递归概述：以编程的角度来看，递归指的是方法定义中调用方法本身的现象

  • 好处
    • 把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解
      小的问题解决 , 大的问题也会逐一进行解决

  • 注意
    • 递归出口：否则会出现内存溢出
    • 递归规则：需要找到与原问题相似的规模较小的问题

  • 案例
    • ``` package com.itheima.recursion_demo;

/* 需求：用递归求5的阶乘，并把结果在控制台输出

  1.     思路：
  2.         1 定义一个方法，用于递归求阶乘，参数为一个int类型的变量
  3.         2 在方法内部判断该变量的值是否是1
  4.             是：返回1
  5.             不是：返回n*(n-1)!
  6.         3 调用方法
  7.         4 输出结果

*/ public class Demo1 { public static void main(String[] args) { int result = jc(5); System.out.println(“5的阶乘是:” + result); }

  1. private static int jc(int n) {
  2.     if (n == 1) {
  3.         return 1;
  4.     }
  5.     return n * jc(n - 1);
  6. }

}

  2.    -

package com.itheima.recursion_demo;

import java.io.File;

/* 需求 : 使用递归删除计算机中指定的文件夹

  1. 删除D盘中的aaa文件夹!

*/ public class Demo2 { public static void main(String[] args) { File f = new File(“D:\aaa”); deleteFiles(f); }

  1. private static void deleteFiles(File f) {
  3.     File[] files = f.listFiles();
  5.     for (File file : files) {
  6.         if (file.isDirectory()) {
  7.             // 递归
  8.             deleteFiles(file);
  9.         } else {
  10.             // 删除文件
  11.             file.delete();
  12.         }
  13.     }
  14.     // 删除当前文件夹
  15.     f.delete();
  16. }

}

  2. <a name="4e99e578"></a>
  3. # day08-异常,多线程
  5. <a name="26537096"></a>
  6. ## 今日目标 :
  8. - 异常的概述
  9. - 异常的分类
  10. - 异常的处理方式
  11. - 自定义异常
  12. - 多线程入门
  14. <a name="58c65ffb"></a>
  15. ## 1 异常的概述
  17. <a name="2131ec86"></a>
  18. ### 1.1 什么是异常?
  20. - 异常就是程序出现了不正常情况 , 程序在执行过程中 , 数据导致程序不正常 , 最终导致了JVM的非正常停止
  21. - 注意 : 语句错误不算在异常体系中
  23. <a name="9347c077"></a>
  24. ### 1.2 异常的存在的形式
  26. - 异常有类型之分，比如我们之前有接触过的比较熟悉的数组越界异常（ArrayIndexOutOfBoundsException），空指针异常（NullPointerException），类型转换异常（ClassCastException）。当程序中产生异常时，其实就是在异常的位置创建了一个该异常的对象，该对象携带了相关的异常信息。 
  27.    - 简单来说 : 异常就是Java中提供的类的对象
  29. <a name="ea3f79f9"></a>
  30. ### 1.3 程序中异常产生后，是如何处理的
  32. - 程序中一旦产生异常，首先会中断向下执行。异常的传递要根据处理方式（后面章节会讲到）而定，如果没有处理，默认是将异常传递给本方法的调用者。不断往回传递，直到JVM收到该异常，此时程序终止执行
  34. <a name="d395cb7b"></a>
  35. ## 2 异常的分类
  37. - 编译时期异常 
  38.    - 非RuntimeException及其子类 :  编译时异常就是在编译的时候可能出现的异常,  编译时期必须处理,否则程序无法执行
  39. - 运行时期异常 
  40.    - RuntimeException及其子类 : 运行时异常就是在运行时可能出现的异常,  在编译时期不需要处理
  42. <a name="9f5112ff"></a>
  43. ## 3 异常的处理方式
  45. <a name="a98f7810"></a>
  46. ### 3.1 JVM处理异常的方式
  48. -  如果程序出现了问题，我们没有做任何处理，最终JVM会做默认的处理 , 那么JVM是如何处理的呢 ? 
  49.    - 把异常的类型 , 原因 , 位置打印在控制台
  50.    - 程序停止执行
  51. -  注意 : 程序中出现了异常 , 会在当前位置创建此异常的对象 , 对象中包含了异常的信息 , 并把此异常交给本方法的调用者处理 
  52. -  缺点 : 用户体验不好 
  54. <a name="299e39b6"></a>
  55. ### 3.2 手动处理异常方式
  57. <a name="a4bddcbb"></a>
  58. #### 3.2.1 声明异常
  60. -  声明异常—— throws 
  61.    - 修饰符   返回值类型  方法名(参数列表)  throws 异常类型1 , 异常的类型2...   {  ...  }
  62.    - 举例 : public void show() throws NullPointerException , ArrayIndexOutOfBoundsException  { .... }
  63. -  作用 : 
  64.    - 表示调用当前的方法可能会出现某些异常,使用时需要注意哦!
  65.    - 如果当前方法没有出现任何异常, 那么代码会正常执行
  66.    - 如果当前方法中出现了异常 , 会把异常交给本方法调用者处理(甩锅)
  67. -   
  68. ```java
  69. package com.itheima.exception_demo;
  71. import sun.java2d.pipe.SpanShapeRenderer;
  73. import java.text.ParseException;
  74. import java.text.SimpleDateFormat;
  75. import java.util.Date;
  77. /*
  78.     声明异常—— throws
  79.         格式 : 修饰符   返回值类型  方法名(参数列表) throws 异常类型1 , 异常的类型2...   {  ...  }
  80.         举例 : public void show() throws NullPointerException , ArrayIndexOutOfBoundsException  { .... }
  81.         作用 :
  82.             1 表示告知调用者当前的方法可能会出现某些异常,使用时需要注意哦!
  83.             2 如果当前方法没有出现任何异常, 那么代码会正常执行
  84.             3 如果当前方法中出现了异常 , 会把异常交给本方法调用者处理(甩锅)
  86.     需求 :
  87.         练习 : 定义两个方法一个运行时期异常 , 一个声明编译时期异常 !
  89.     注意 :
  90.         1 编译时异常因为在编译时就会检查，所以必须要写在方法后面进行显示声明
  91.         2 运行时异常因为在运行时才会发生，所以在方法后面可以不写
  92.         3 如果声明多个异常有子父类关系 , 那么只要声明一个父类即可(多态)
  93.  */
  94. public class Exception_Throws {
  95.     public static void main(String[] args) throws ParseException{
  96.         printArr();// 如果此方法出现了异常 , 会交给jvm进行处理
  97.         StringToDate();// 如果此方法出现了异常 , 会交给jvm进行处理
  98.     }
  100.     // 1 告诉调用者 , 此方法可能会出现异常哦
  101.     // 2 如果此方法没有出现异常 , 那么会正常执行
  102.     // 3 如果此方法中出现了异常 , 会把此异常交给调用者处理
  103.     // 注意 : 如果声明的异常是一个运行时期异常 , 那么此声明可以省略
  104.     public static void printArr() /*throws NullPointerException*/ {
  105.         int[] arr = null;
  106.         for (int i = 0; i < arr.length; i++) {
  107.             System.out.println(arr[i]);
  108.         }
  109.     }
  111.     // 1 告诉调用者 , 此方法可能会出现异常哦
  112.     // 2 如果此方法没有出现异常 , 那么会正常执行
  113.     // 3 如果此方法中出现了异常 , 会把此异常交给调用者处理
  114.     // 注意 : 如果声明的异常 是一个编译时期异常 , 那么在编译时期必须处理 , 要么程序无法执行
  115.     public static void StringToDate() throws ParseException {
  116.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  117.         Date date = sdf.parse("2000-03-11 12:12:12");
  118.     }
  119. }

3.2.2 抛出异常

  • 思考：
    • 以前出现了异常，虚拟机帮我们创建一个异常对象，抛给调用者。但是如果我们需要自己手动创建一个异常对象该如何写？

  • 格式 :
      1. 修饰符    返回值类型    方法名(参数列表)  {
      2. throw new 异常对象();
      3. }

  • 注意 :
    • 抛出异常的格式必须在方法的内部完成
    • 如果手动抛出一个异常，下面的代码无法执行
  • ```java package com.itheima.exception_demo;

/* 抛出异常演示 : 格式 : 修饰符 返回值类型 方法名(参数列表) { throw new 异常对象(); }

  1.     注意 :
  2.         1 抛出异常的格式必须在方法的内部完成
  3.         2 如果手动抛出一个异常，下面的代码无法执行

*/ public class Exception_Throw { public static void main(String[] args) { System.out.println(“家里有一个貌美如花的老婆”); System.out.println(“还有一个当官的兄弟”); System.out.println(“自己还有一个买卖”); System.out.println(“这样的生活你要不要?”);

  1.     // 程序不想往下执行了 ,怎么做 ???
  2.     // 1 自己手动制造出一个异常
  3.     // 2 当前异常也是交给了方法的调用者处理 , 也就是jvm处理
  4.     // 3 下面代码无法执行
  5.     throw new RuntimeException();
  7.     // System.out.println("武大郎的标准生活!");
  8. }

}

  2. -   
  3. <a name="02c501bb"></a>
  4. ##### 作用 :
  6.    - 在方法中，当传递的参数有误，没有继续运行下去的意义了，则采取抛出处理，表示让该方法结束运行。
  7.    - 告诉调用者方法中出现的问题原因
  8. ```java
  9. package com.itheima.exception_demo;
  11. /*
  12.     抛出异常存在的意义所在 :
  13.         1 在方法中，当传递的参数有误，没有继续运行下去的意义了，则采取抛出处理，表示让该方法结束运行。
  14.         2 告诉调用者方法中出现了问题
  16.     练习   : 定义一个方法 , 方法的参数接收一个数组 , 在方法中遍历数组 .
  17.     需求1  : 如果方法接收的数组为null  , 使用输出语句提示
  18.     需求2  : 如果方法接收的数组为null  , 使用抛出异常解决
  19.     思考   : 两种方式的区别在哪里 ?
  20.  */
  21. public class Exception_Throw2 {
  22.     public static void main(String[] args) {
  23.         int[] arr = {1, 2, 3, 4, 5};
  24.         arr = null;
  25.         // printArr1(arr);
  26.         printArr2(arr);// 接收方法返回的异常 , 但是此异常有jvm进行处理
  27.     }
  29.     // 需求1  : 如果方法接收的数组为null  , 使用输出语句提示
  30.     public static void printArr1(int[] arr) {
  31.         if (arr == null) {
  32.             System.out.println("数组为null");
  33.         } else {
  34.             for (int i = 0; i < arr.length; i++) {
  35.                 System.out.println(arr[i]);
  36.             }
  37.         }
  38.     }
  40.     // 需求2  : 如果方法接收的数组为null  , 使用抛出异常解决
  41.     public static void printArr2(int[] arr) {
  42.         if (arr == null) {
  43.             throw new RuntimeException();
  44.         } else {
  45.             for (int i = 0; i < arr.length; i++) {
  46.                 System.out.println(arr[i]);
  47.             }
  48.         }
  49.     }
  50. }

3.2.3 throws和throw的区别

  • throws :
    • 用在方法声明后面，跟的是异常类名
    • 表示声明异常，告知调用者调用该方法有可能会出现这样的异常
  • throw :
    • 用在方法体内，跟的是异常对象名
    • 表示手动抛出异常对象，告知调用者数据传入有误

3.2.4 捕获异常

  • 捕获处理异常介绍 : try, catch
    • 之前的声明或者抛出都是将异常传递出去,让调用者知道异常信息。
      而捕获处理是本方法内部进行处理 , 能够阻止异常的传递，从而保证程序能够继续往下执行。

  • 捕获异常的格式 

      1. try {
      2. try中存放可能会出现问题的代码
      3.  1.代码...
      4.  2.代码...
      5.  3.代码...
      6. } catch (异常类型 变量名) {
      7.  4.处理异常方案
      8. 打印异常，获取异常原因记录日志......）
      9. }
      10. 5.其他代码...

  • 执行方式

    • 如果 try 中没有遇到问题，怎么执行？
      • 从上往下依次执行 , catch中不执行
    • 如果 try 中代码2遇到了问题，问题下面的代码还会执行吗？
      • 不会执行,会拿当前异常对象和异常类型匹配,匹配成功执行处理异常代码
    • 如果出现的问题没有被捕获，那么程序如何运行？
      • 如果异常没有捕获到 , 虚拟机会帮助我们处理
  • 多异常捕获处理方案
    • 多个异常，每个异常单独处理
      • ```java try{ 异常1 }catch(异常1){

} try{ 异常2 }catch(异常2){

}

  2.    -  多个异常，一次捕获，多次处理 
  3.       -   
  4. ```java
  5. try{
  6.     异常1
  7.     异常2
  8. }catch(异常1){
  9. }catch(异常2){
  10. }
  • 多个异常，异常一次捕获，一次处理 
      1. try{
      2. 异常1
      3. 异常2
      4. }catch(Exception e){
      5. }

3.3 Throwable 的成员方法

方法名 说明
public String getMessage() 返回此 throwable 的详细消息字符串
public String toString() 返回此可抛出的简短描述
public void printStackTrace() 把异常的错误信息输出在控制台

3.4 异常练习

  1. package com.itheima.exception_demo;
  3. import java.text.ParseException;
  4. import java.text.SimpleDateFormat;
  5. import java.util.Date;
  6. import java.util.Scanner;
  8. /*
  9.     定义一个方法接收一个生日日期字符串(xxxx年xx月xx)
  10.     main方法中让用户输入一个生日日期字符串，调用设计好的方法计算在地球上活了多少天。
  12.     要求：如果解析发生异常，捕获异常，提示用户要重新输入生日日期字符串，直到输入正确的日期为止。
  13.     思考：设计代此码的过程中想想什么时候捕获异常，什么时候声明异常？
  15.  */
  16. public class ExceptionTest {
  17.     public static void main(String[] args) {
  18.         Scanner sc = new Scanner(System.in);
  19.         System.out.println("请输入生日(xxxx-xx-xx):");
  21.         while (true) {
  22.             String birthday = sc.nextLine();
  23.             try {
  24.                 method(birthday);
  25.                 break;// 如果生日没有问题结束死循环
  26.             } catch (ParseException e) {
  27.                 System.out.println("录入生日格式有误!");
  28.             }
  29.         }
  30.     }
  32.     public static void method(String strDate) throws ParseException {
  33.         // 创建日期模板对象
  34.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  36.         // 解析字符串
  37.         Date date = sdf.parse(strDate);
  39.         // 获取生日到1970/1/1 经历的毫秒值
  40.         long time1 = date.getTime();
  42.         // 当前系统时间到1970/1/1 经历的毫秒值
  43.         Date d2 = new Date();
  44.         long time2 = d2.getTime();
  47.         System.out.println("活了" + (time2 - time1) / (1000L * 60 * 60 * 24) + "天");
  48.     }
  49. }

4 自定义异常

4.1 概述

  • 当JDK中的异常类型，不满足实际的业务需要时。就可以自己定义异常。例如，学生的年龄数据，如果是负数或者数据 超过了150认为是不合法的，就需要抛出异常。JDK中就没有表示年龄的异常，就需要自己定义异常了

4.2 实现步骤

  • 定义异常类
  • 写继承关系
  • 空参构造
  • 带参构造

4.3 自定义异常注意

  • 如果要自定义编译时异常，就继承Exception
  • 如果要自定义运行时异常，就继承RuntimeException

5 多线程入门

5.1 多线程相关的概念

  • 并发与并行
    • 并行：在同一时刻，有多个任务在多个CPU上同时执行。
    • 并发：在同一时刻，有多个任务在单个CPU上交替执行。
  • 进程与线程
    • 进程：就是操作系统中正在运行的一个应用程序。
    • 线程：就是应用程序中做的事情。比如：360软件中的杀毒，扫描木马，清理垃圾。

5.2 什么是多线程

  • 是指从软件或者硬件上实现多个线程并发执行的技术。
    具有多线程能力的计算机因有硬件支持而能够在同一时间执行多个线程，提升性能。
  • 好处 : 提高任务的执行性能

5.3 多线程的创建方式

5.3.1 继承Thread方式

  • 基本步骤：
    • 创建一个类继承Thread类。
    • 在类中重写run方法（线程执行的任务放在这里）
    • 创建线程对象，调用线程的start方法开启线程。
    • 执行程序，观察控制台的打印数据的现象 ```java package com.itheima.thread_demo;

/* 线程的创建方式1：继承Thread方式

  1. 基本步骤 :
  2.     1 创建一个类继承Thread类。
  3.     2 在类中重写run方法（线程执行的任务放在这里）
  4.     3 创建线程对象，调用线程的start方法开启线程。
  6. 需求 :
  7.     我们启动一个Java程序，其实默认就存在一个主线程（main方法所在线程）
  8.     接下来，我们在主线程启动一个线程，打印1到100的数字，主线程启动完线程后又打印1到100的数字。
  9.     此时主线程和启动的线程在并发执行，观察控制台打印的结果。

*/ public class MyThread01 { public static void main(String[] args) { // 创建线程对象，调用线程的start方法开启线程。 MyThread mt = new MyThread(); mt.start();

  1.     // main方法中的任务
  2.     for (int i = 1; i <= 100; i++) {
  3.         System.out.println("i:" + i);
  4.     }
  5. }

} // 创建一个类继承Thread类。 class MyThread extends Thread { // 在类中重写run方法（线程执行的任务放在这里） @Override public void run() { for (int i = 1; i <= 100; i++) { System.out.println(“i:” + i); } } }

  2. <a name="7e24284a"></a>
  3. #### 5.3.2 实现Runable方式
  5. -  构造方法 
  6.    - public Thread(Runnable target)
  7.    - public Thread(Runnalbe target , String name)
  8. -  实现步骤 
  9.    - 定义任务类实现Runnable，并重写run方法
  10.    - 创建任务对象
  11.    - 使用含有Runnable参数的构造方法，创建线程对象并指定任务。
  12.    - 调用线程的start方法，开启线程
  13. ```java
  14. package com.itheima.thread_demo;
  16. /*
  17.      线程的创建方式2：实现Runnable方式
  19.     基本步骤 :
  20.         1 定义任务类实现Runnable，并重写run方法
  21.         2 创建任务对象
  22.         3 使用含有Runnable参数的构造方法，创建线程对象并指定任务。
  23.         4 调用线程的start方法，开启线程
  25.     需求 :
  26.         我们启动一个Java程序，其实默认就存在一个主线程（main方法所在线程）
  27.         接下来，我们在主线程启动一个线程，打印1到100的数字，主线程启动完线程后又打印1到100的数字。
  28.         此时主线程和启动的线程在并发执行，观察控制台打印的结果。
  29.  */
  30. public class MyThread02 {
  31.     public static void main(String[] args) {
  32.         // 创建线程对象，调用线程的start方法开启线程。
  33.         MyRunnable mr = new MyRunnable();
  34.         Thread thread= new Thread(mr);
  35.         thread.start();
  37.         // main方法中的任务
  38.         for (int i = 1; i <= 100; i++) {
  39.             System.out.println("i:" + i);
  40.         }
  41.     }
  43. }
  45. // 1 定义任务类实现Runnable，并重写run方法
  46. class MyRunnable implements Runnable {
  47.     // 在类中重写run方法（线程执行的任务放在这里）
  48.     @Override
  49.     public void run() {
  50.         for (int i = 1; i <= 100; i++) {
  51.             System.out.println("i:" + i);
  52.         }
  53.     }
  54. }

5.3.3 Thread类中常用方法

  • String getName()：返回此线程的名称
  • Thread类中设置线程的名字
    • void setName(String name)：将此线程的名称更改为等于参数 name
    • 通过构造方法也可以设置线程名称
  • public static Thread currentThread()：返回对当前正在执行的线程对象的引用
  • public static void sleep(long time)：让线程休眠指定的时间，单位为毫秒
  • 线程有两种调度模型
    • 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
      抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程
    • 获取的 CPU 时间片相对多一些 ```java package com.itheima.thread_demo.thread_method;

/* 线程有两种调度模型 1 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片 2 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程 获取的 CPU 时间片相对多一些

  1.     注意 : Java使用的是抢占式调度模型
  4.     优先级高 , 只是抢夺到cpu执行的概率高而已 , 只是一种概率问题

*/ public class PriorityDemo { public static void main(String[] args) { Thread thread1 = new Thread(new Runnable() { @Override public void run() { for (int i = 0; i < 1000; i++) { System.out.println(Thread.currentThread().getName() + “:” + i); } } }); // 优先级最低 thread1.setPriority(1); thread1.start();

  1.     Thread thread2 = new Thread(new Runnable() {
  2.         @Override
  3.         public void run() {
  4.             for (int i = 0; i < 1000; i++) {
  5.                 System.out.println(Thread.currentThread().getName() + ":" + i);
  6.             }
  7.         }
  8.     });
  9.     // 优先级最高
  10.     thread2.setPriority(10);
  11.     thread2.start();
  12. }

} ```

package com.itheima.thread_demo.thread_method;

/*
线程有两种调度模型
1 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
2 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程
获取的 CPU 时间片相对多一些

  1.     注意 : Java使用的是抢占式调度模型
  4.     优先级高 , 只是抢夺到cpu执行的概率高而已 , 只是一种概率问题<br /> */<br />public class PriorityDemo {<br />    public static void main(String[] args) {<br />        Thread thread1 = new Thread(new Runnable() {<br />            @Override<br />            public void run() {<br />                for (int i = 0; i < 1000; i++) {<br />                    System.out.println(Thread.currentThread().getName() + ":" + i);<br />                }<br />            }<br />        });<br />        // 优先级最低<br />        thread1.setPriority(1);<br />        thread1.start();
  6.     Thread thread2 = new Thread(new Runnable() {<br />            @Override<br />            public void run() {<br />                for (int i = 0; i < 1000; i++) {<br />                    System.out.println(Thread.currentThread().getName() + ":" + i);<br />                }<br />            }<br />        });<br />        // 优先级最高<br />        thread2.setPriority(10);<br />        thread2.start();<br />    }