IndexJavaSE

IndexJavaSE

API

• 基本使用：

1. 索引目录输入类名回车两下
2. 查看此类所属包
3. 查看此类的构造方法
4. 查看此类的方法
   
   

Scanner类

• 实现键盘输入数据
  
• eg:

1. import java.util.Scanner;
2. Scanner sc=new Scanner(System.in);//System.in代表从键盘输入
3. Int num&#Int();//获取从键盘输入的一个int数字—String–>int
   String str&#();//获取从键盘输入的一个String字符串

eg:三个数字比较最大值

匿名对象

• new 类名称();
  
• 匿名对象作为方法参数和返回值：
  eg：new Scanner(System.in).nextInt();
  

Random随机数

ArrayList类

• 中E为泛型（即装在集合中的元素统一是什么类型），泛型类型只能是引用类型
  
  

• 常用方法：
  

• eg：对象数组
  

• ArrayList存储基本类型，使用包装类：
  eg: ArrayList list=new ArrayList<>();
  

字符串

• eg：内容不可变
  
• 创建字符串
  
  eg：
  
• 字符串的常量池
  
  
  eg：
  

常用方法

• equals方法
  
  eg：equals方法
  

• 字符串的获取相关方法：
  

• 字符串的截取方法：
  

• 字符串的转换方法：
  
  eg：
  

• 字符串的分割
  

• eg：
  
  

• static关键字：用以修饰共有变量
  
  
  eg：
  

• 学号计数器
  

• 静态代码块
  
  eg：
  

Arrays工具类

• Array：类提供静态方法来动态创建和访问Java数组。
• ArrayList：可调整大小的数组的实现List接口。 实现所有可选列表操作，并允许所有元素，包括null
• Arrays：该类包含用于操作数组的各种方法（如排序和搜索）。 该类还包含一个静态工厂，可以将数组视为列表
  

Math工具类

继承

• 共性抽取(代码复用)
• 继承特点：

1. java语言是单继承的–>一个类的直接父类只能有唯一一个
2. java语言可以多级继承
3. 一个父类可以 拥有很多个子类
   图解：
   
   

• 继承的格式
  
• 变量重名访问规则：
  
• 变量访问规则(super)
  可以用于使用父类变量和方法(父类中的已有方法)
  
  eg：
• 方法访问规则：
  创建的对象是谁，就优先用谁，如果没有则向上找
  
• 方法的重写：(覆盖，覆写)方法名称一样，参数列表也一样

5. 特点：创建的是子类对象，就优先用子类方法
6. 注意事项：
   
   • 构造方法访问特点
     

super关键字用法

eg：

• super关键字用来访问父类内容，this关键字用来访问本类内容

this关键字用法:

eg：

this和super的图解

抽象类

抽象出共有的行为作为抽象方法
eg：(动物 吃—>狗 吃骨头)
引例：

• 抽象类和抽象方法格式
  
• 注意事项
  

接口

一种公共的规范标准

• 定义格式
  
  
• 接口使用步骤
  
• 默认方法—接口升级
  
  
• 静态方法
  不允许接口的实现类对象使用
  
  注意事项
  
• 私有方法
  Java9及以后才有
  解决两个方法重复代码太多问题
  
• 成员变量：(常量)
  通过接口名称.变量名—去使用
  
  *接口小结：
  
• 注意事项
  
• 接口之间的多继承
  interface interFace extend interFaceA,interFaceB
  

多态

一个对象拥有多种形态，这就是对象的多态性
eg：小明是一个学生，小明也是人—人是学生的父类

• 多态的格式：
  eg：Fu fu=new Zi();
  
• 成员变量使用特点：
  
• 成员方法使用特点：
  
• 总结：

1. 成员变量:编译看左边，运行看左边–没有则向上找–>
   直接访问时不会使用到子类变量值
   方法访问变量时看方法属于谁
2. 成员方法：编译看左边，运行看右边–没有则向上找

• 多态的好处:
  
• 对象的向上转型：
• 对象一旦向上转型为父类，那么就无法调用子类特有的内容----->使用对象的向下转型还原回去
  eg:动物是父类，猫是子类，猫是动物就是向上转型，动物–>猫就是向下转型
  
• 对象的向下转型：
  
  
• 安全向下转型：
• 对象 instanceof 类名----boolean判断对象能否作为后边类型的实例
  
• final关键字：
  

1. 修饰一个类：
   
   2.修饰成员方法：
   
   3修饰局部变量：
   方法的参数也时局部变量
   
   eg：
   
   4.修饰成员变量;
   
   eg:构造方法赋值

/*final关键字修饰成员变量--必须直接赋值和构造赋值二选一
* 且值不能变*/
public class Final {//手动赋值final private int age=15;final private String name;//构造方法赋值public Final() {name="不可变";// age=16;值不可变}public Final(String name) {this.name = name;}}

• 四种权限修饰符
  

内部类

• 成员内部类的使用方法
  
• 访问重名的外部类对象：外部类名.this.变量名
  
• 局部内部类
  
  eg：
  
• 注意事项
• 匿名内部类：
  
• 注意事项：
  
  eg：
  
• *成员变量类型：

1. 类作为成员变量类型：
2. 接口作为成员变量类型
3. 接口作为方法参数或返回值
   

Object类

• toString方法：将对象已字符串形式打印出来
• 每个类都可以重写ALT+INSERT
• equals方法：对象a.equals(对象b)
• 每个类都可以重写进行比较ALT+INSERT

Objects类

Objects.equals(对象1,对象2)–>String的equals方法的改良。防止空指针异常eg：null.equals(string)

Date类

时间日期类
毫秒：1秒=1000毫秒

• 构造方法：

1. Date()显示系统当前时间
2. Date(long date) —>传递的为毫秒
   使用给定的毫秒时间值构造一个 Date对象。

• 成员方法：
  Long getTime()把日期转换为毫秒
  String toLocaleString()将Date对象转换为本地格式的字符串

DafeFormat类

日期时间格式化（日期–>文本）,解析（文本—>日期）类
DateFormat-----抽象类

• DafeFormat是抽象类，想要使用就得使用他的子类SimpleDafeFormat

SimpleDafeFormat (DafeFormat的子类)

• 构造方法的参数中传入的是格式
• 成员方法：
  

1. format方法使用—格式化
2. parse方法使用—解析
   

Calendar类

• 抽象类，提供了很多操作日历字段的方法
• static Calendar getInstance()使用默认时区和语言环境获得一个日历
  eg：获取对象Calendar calendar&#Instance()
• 常用方法：
  

        Calendar c&#Instance();c.set(2016,12,30);c.add(Calendar.YEAR,4);c.get(Calendar.YEAR);Date time = c.getTime();System.out.println(time);

System类

• 常用方法----静态方法–通过类名调用
  

1. public static long currentTimeMillis()---->用来测试程序效率（执行前后相减）
2. public static void arraycopy(…)
   

StringBuilder类

• 字符串缓冲区，可以提高字符串的操作效率
  可看作是一个长度可以变化的字符串
• 和String的比较
  
• 构造方法：

1. StringBuilder()
   构造一个没有字符的字符串构建器，初始容量为16个字符。
2. StringBuilder(String str)
   构造一个初始化为指定字符串内容的字符串构建器

• 常用方法：

1. StringBuilder append(…) ----重写了多个，参数可以是各种类型
2. StringBuilder reverse()-----将内容反转
   
3. String toString() 返回表示此顺序中的数据的字符串。 --将StringBuilder对象 变为String对象

包装类

概念:

• 装箱拆箱
  eg：Integer
  
• 自动装箱和拆箱
  JDK1.5以后
  eg：ArrayList—不能为整数int类ing，可以为其包装类
  list.add(1)----自动装箱liat.add(new Integer(1))
  (1)----自动拆箱()–intValue()
• 基本类型与字符串之间的转换
  
  eg：

1. 基本类型转String
   eg：34+" "
2. String 转基本类型
   

Collection集合(接口)

• 备注：集合重写了toString方法可直接输出，数组需要循环遍历或者使用Arrays的toString方法输出
  使用多态创建对象()即new实现类
• 概念以及区别：
  
• 集合框架
  
• Collection常用功能
  
• 常用方法
  

Iterator迭代器(接口)

完成Collection集合的遍历
多态完成创建对象
Collection coll=new 实现类();
Iterator i=coll.iterator();

• 迭代
  
  
• 迭代器的使用：
  
• 增强for循环
  
  使用：
  
  注意事项：
  
  eg:
  

可变参数

方法参数类型确定，参数个数不确定时使用

eg：

Collections

此类仅由静态方法组合或返回集合—类名调用
Collection工具类


eg：


eg：

泛型

是一种未知的数据类型，当我们不知道使用什么类型的数据，可以使用泛型

• 对比：

1. 使用泛型：
   
2. 不使用泛型–默认为object
   

• 定义包含泛型的类
  泛型定义在类后
  
  eg：
  
• 定义包含泛型的方法
  泛型定义在修饰符和返回类型之间
  
  eg：
  
• 含有泛型的接口：
  使用方法

1. 实现类实现接口，制定接口的泛型
   

interface A<E>{viod method(E e){sout(e)}}
public class B implements A<String>{public void method(String e){sout(e)}
}

2. 实现类也使用和接口一样的泛型

interface A<E>{viod method(E e){sout(e)}}
public class B<E> implements A<String>{public void method(E e){sout(e)}
}
mian(){B<String> b=new B<>();b.method("字符串");
}

泛型通配符

传递参数时可以用
定义时不可以用
使用泛型通配后，只能使用Object类中的共性方法

eg：

• 泛型通配符的高级使用：
  
  eg：
  

数据结构

• 栈：先进后出
  –出入口是一个
• 队列：先进先出
  –出入口在两侧
• 数组：查询快，增删慢
  –数组长度不可变增删都要创建新数组复制增删后的数组
  
• 链表：查询慢，增删快
  
• 红黑树：查询速度非常快

Collection接口(集合)的实现

List接口

public interface List
extends Collection
Collection的子类

• 特点：

1. 有序–存取顺序一致
2. 有索引
3. 元素可重复

• 方法：
  
• 注意事项-- 越界异常即使用超过List长度的索引
• List集合的遍历–3中
  

List的实现类

1. ArrayList—数组实现
2. LinkedList–链表实现
   创建对象 LinkedList l=new LinkedList<>();
   3.Vector --数组–单线程慢–枚举遍历

Set接口

public interface Set
extends Collection

• 特点：和Collection方法一样

1. 元素不重复—重写equals和hashCode方法
2. 无索引–不能使用带索引的方法，不能使用for循环白遍历

Set实现类

多态创建对象

HashSet类

public class HashSet
extends AbstractSet
implements Set
特点：

1. 元素不重复—必须重写hashCode和equals方法
   
2. 无索引–不能使用带索引的方法，不能使用for循环白遍历
3. 无序集合
4. 底层是一个哈希表结构（查询速度快啊）

• 元素不重复的原理
• 哈希值
• 哈希表-HashSet集合存储数据的结构
  
  哈希表
• HashSet存储自定义类型的元素：例如对象—重写equals和hashCode方法
  eg：

LinkedHashSet集合

有序—哈希表+链表
public class LinkedHashSet
extends HashSet
implements Set
继承HashSet类实现了Set接口

Map<K,V>接口(集合)

两个泛型

• 特点:

1. Map集合时一个双列集合，一个元素包含两个值(一个key，一个value)
2. Map集合中的元素，key和value的数据类型可以相同，也可以不同
3. Map集合中的元素，key是不允许重复的，value是可以重复的
4. Map集合中的元素，key和value是一一对应的

• 常用方法：
  
  
• Map集合的遍历
  

1. 键找值：
   eg：
2. 键值遍历-----Set<Map.Entry<K,V>> entrySet()
   返回此地图中包含的映射的Set视图。
   
   eg：

Entry接口

图解：

• Map集合存储自定义类型的键值—key类型为 自定义类时要重写equals和hashCode方法来保证key的唯一
  set集合存储自定义类型时也需要重写

Map的实现类

无序

Hashtable

key和value不能为空
单线程，速度慢

HashMap

LinkedHashMap

有序—哈希表+链表
HashMap的子类-----extends HashMap<k,v>

JDK9新特性

eg:

异常

概念

异常体系
Exception：举例
1.DafeFormat中的parse方法导致的异常
2.索引越界异常
Error：
内存溢出异常
int[] a=new int(102410241024);创建数组空间超出了虚拟机的空间

• 异常产生过程的解析
  

异常的处理

• 提示
• throw关键字
  用在方法内–抛出一个指定的异常对象
  
• Objects非空判断–用来检测参数是否异常
  
• throwable定义的三个处理异常的方法
  

异常处理方式

• throws关键字
  跟在方法名后—后续代码不会执行–中断处理
  
• 捕获异常try_catch语句
  后续代码 继续执行
  
• finally代码块
  
• 异常处理注意事项

1. 多个异常分别处理—多个try_catch
   
2. 多个异常一次捕获，多次处理—一个try多个catch
   注意事项：
   
   
3. 多个异常一次捕获一次处理
   
   
   eg：
   

• 运行时异常可以不处理或抛出，直接给JVM虚拟机处理

自定义异常类

多线程

• 并发与并行
  
• 线程和进程：
  1.进程：一个内存中运行的应用程序------进入到内存的程序叫进程
  2.线程：是进程中的一个执行单元
  一个程序运行后至少有一个进程，一个进程中可以包含多个线程
• 线程调度
  
• 主线程
  
• 创建线程类：
  java.lang.Thread
• 创建线程的方式
  1.创建Thread类的子类
  **多次启动一个线程是非法的
  eg：

public class MyThread extends Thread {@Overridepublic void run() {for (int i = 0; i < 20; i++) {System.out.println("run"+i);}}
}
public class Demo1 {public static void main(String[] args) {//创建多线程MyThread myThread=new MyThread();myThread.start();for (int i = 0; i < 2; i++) {System.out.println("main"+i);}}
}

2.实现Runnable接口：好

public class MyThread2 implements Runnable {@Overridepublic void run() {for (int i = 0; i < 20; i++) {System.out.println(Thread.currentThread().getName()+" "+i);}}
}
public class Demo2 {public static void main(String[] args) {//创建多线程MyThread2 myThread=new MyThread2();Thread thread=new Thread(myThread);thread.start();for (int i = 0; i < 20; i++) {System.out.println(Thread.currentThread().getName()+" "+i);}}
}

• 继承Thread和实现Runnable的区别

线程

Thead类

• 多线程原理
• 多线程内存图
• Thread类的常用方法：
  1.获取线程名称：
  A使用Thread类中的方法getName()
  String getName() --返回此线程的名称。
  B可以先获取到当前正在执行的线程，使用线程中的方法getName()获取线程的名称
  static Thread currentThread()-- 返回对当前正在执行的线程对象的引用。
  即String name=Thread.currentThread().getName()
  2.设置线程名称（了解）
  Avoid setName(String name) —将此线程的名称更改为等于参数 name 。
  B构造方法Thread(String name) --分配一个新的 Thread对象。
  3.sleep方法：
  static void sleep(long millis) --使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性。
  eg：模拟秒表
• 匿名内部类实现线程的创建：
  eg：

//匿名内部类创建线程
public class Demo3 {public static void main(String[] args) {//实现Thread类new Thread(){@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().getName()+" "+i);}}}.start();//实现Runnable接口new Thread(new Runnable(){@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().getName()+" "+i);}}}).start();}
}

线程安全

多线程访问共享数据，就会产生线程安全问题

代码实现

package Thread.demo2;
/*idea：模拟电影院买票，三个窗口共卖100张票
* 分析：
* 3个线程为三个窗口进行买票
* 一个Runnable实现类对象产生100张票*/
public class MyThread1 implements Runnable {//定义100张票private int ticket=100;@Overridepublic void run() {while(true){if(ticket>0){//为了提高出现问题的概率，让线程睡眠一下try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"在卖第"+ticket+"张票");ticket--;}}}
}
public class Demo1 {public static void main(String[] args) {//创建Runnable实现类的对象MyThread1 mt=new MyThread1();//创建Thread类对象构造方法中传递Runnable实现类的对象Thread t1=new Thread(mt);Thread t2=new Thread(mt);Thread t3=new Thread(mt);//调用Thread类的start方法开启多线程t1.start();t2.start();t3.start();}
}

运行结果
Thread-0在卖第100张票
Thread-2在卖第100张票
Thread-1在卖第100张票
分析产生原理：

• 线程同步
  1.同步代码块
  
  原理
  2.同步方法
  
  同步方法的锁对象就是实现类对象也就是this
  静态同步方法：(了解）
  锁对象是Runnable.class
  3.Lock锁
  接口urrent.locks

Lock l = new ReentrantLock();
l.lock();
try { // access the resource protected by this lock }
finally { l.unlock(); }

线程状态

• 线程之间的通信：
  等待唤醒案例分析：
  
  等待唤醒案例实现：

/*idea:模仿用户买包子和老板做包子（5秒）* 分析：* 顾客和老板进程放在同步代码synchronized(锁对象)块中* 两者只能有一个执行，不能同时执行* 1创建顾客线程-告知老板买包子后-锁对象调用wait方法等待* 2创建并执行老板线程--sleep(5000)花费5秒做包子--然后告知顾客做好了-锁对象调用notify()唤醒顾客线程* 3顾客开始吃包子*/
public class demo {public static void main(String[] args) {//创建锁对象Object o = new Object();//创建顾客线程new Thread() {@Overridepublic void run() {synchronized (o) {System.out.println("老板，我要买包子");try {o.wait();//被唤醒后执行后边代码} catch (InterruptedException e) {e.printStackTrace();}//唤醒后执行的代码System.out.println("包子来了，开吃！");}}}.start();//创建老板线程new Thread() {@Overridepublic void run() {//睡眠5秒做包子try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}synchronized (o) {System.out.println("包子做好了！");o.notify();}}}.start();//}
}

等待和唤醒方法：

等待唤醒机制

1.1线程间通信：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同
1.2等待唤醒机制：

• E:IdeaProjectsBase_CodesrcThreaddemo3demo1

线程池

底层原理

• 线程池的使用
  1.Executors：线程池的工厂类，用来生成线程池
  urrent.Executors
  Executors类中的静态方法：
  static ExecutorService newFixedThreadPool(int nThreads)
  创建一个线程池，该线程池重用固定数量的从共享无界队列中运行的线程。
  参数：
  int nThreads 创建线程池中包含的线程数量
  返回值：
  ExecutorService接口，返回的是ExecutorService接口的实现类对象，我们可以使用ExecutorService接受(面向接口编程)

2.ExecutorService接口:线程池接口
urrent ExecutorService

ExecutorService接口方法：
用来从线程池中获取线程，调用start方法，执行线程程任务
submit(Runnable task) 提交一个可运行的任务Runnable去执行
关闭销毁线程池的方法(不建议使用)：
shutdown() 启动有序关闭，其中先前提交的任务将被执行，但不会接受任何新任务。

• 线程池的使用步骤：

1. 使用线程池的工厂类Executors里边的静态方法newFixedThreadPool创建包含一定线程数量的线程池
2. 创建一个类实现Runnable接口，重写run方法，设置线程任务
3. 调用ExecutorService接口中的submit(Runnable task) 方法，传递线程任务(Runnable实现类)，开启线程
4. 调用ExecutorService接口中的shutdown方法销毁线程池(不建议执行)
   eg：

/*线程池的使用*/
public class MyThread implements Runnable {@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+"    执行此任务！");}
}
public class main {public static void main(String[] args) {//1. 使用线程池的工厂类Executors里边的静态方法newFixedThreadPool创建包含一定线程数量的线程池ExecutorService pool = wFixedThreadPool(2);//2. 创建一个类实现Runnable接口，重写run方法，设置线程任务MyThread mt=new MyThread();//3. 调用ExecutorService接口中的submit(Runnable task) 方法，传递线程任务(Runnable实现类)，开启线程pool.submit(mt);pool.submit(new MyThread());pool.submit(new MyThread());//4. 调用ExecutorService接口中的shutdown方法销毁线程池(不建议执行)pool.shutdown();//当执行shutdown操作后使用线程池会异常// pool.submit(new MyThread());//RejectedExecutionException}

## Lambda表达式

• 函数式编程思想

1. 面向对象的思想：做一件事，找一个能解决这个事情的对象，调用对象的方法，完成事情
2. 函数式编程思想：只要能获取到结果，谁去做的，怎么做的都不重要，重视的是结果，不重视过程

• 冗余的Runnable代码
  
• 编程思想转换：

public class Demo1 {public static void main(String[] args) {//匿名内部类实现创建线程new Thread(new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+"创建了这个线程！");}}).start();//使用Lambda表达式创建线程new Thread(()->{System.out.println(Thread.currentThread().getName()+"创建了这个线程！");}).start();}
}

• Lambda表达式更优写法
  
• Lambda表达式标准格式：
  
  eg：

public interface Cook {void cooking();
}
public class cookMain {public static void main(String[] args) {//匿名内部类实现makeCook(new Cook(){@Overridepublic void cooking() {System.out.println("做饭啦！");}});//Lambda实现makeCook(()->{System.out.println("做饭啦！");});}static void makeCook(Cook cook){king();}
}

• Lambda省略
  1.省略规则
  
• Lambda表达式使用前提：
  

File类

java.io.File

• 静态成员变量
  
• 绝对路径和相对路径
  
• 构造方法
  1.
  2.
  3.
• 常用方法：
  1.获取方法：
  
  2.判断功能的方法：
  
  3.创建删除功能的方法：路径由File对象构造方法的参数传入
  
  
  
  
• 目录的遍历
  

递归

递归求1-n的和
文件搜索

/*文件过滤器+匿名内部类+Lambda表达式
idea：递归打印多级目录且只打印.java文件
* 分析：
* 使用递归需要创建方法来遍历文件
* 1打印指定路径下的目录需要创建一个File对象
* 2使用listFiles方法将目录下所有子目录以及文件存入File数组
* 3进行判断
* AFile数组中的元素是文件夹则继续调用方法本身进行遍历
* BFile数组中的元素是文件则直接打印
* */public class fileSearchFilter2 {public static void main(String[] args) {File f=new File("E:\IdeaProjects\Base_Code\src\FileP");printAllFile(f);}
//创建打印方法private static void printAllFile(File dir) {//匿名内部类/*    File[] files = dir.listFiles(new FileFilter(){    @Overridepublic boolean accept(File pathname) {if (pathname.isDirectory()){return true;}Name().toLowerCase().endsWith(".java");}});*///Lambda简化
/*        File[] files = dir.listFiles((File pathname)->{if (pathname.isDirectory()){return true;}Name().toLowerCase().endsWith(".java");});*///FilenameFilter过滤器+匿名内部类/*      File[] files = dir.listFiles(new FilenameFilter(){@Overridepublic boolean accept(File dir, String name) {return new File(dir,name).isDirectory()||LowerCase().endsWith(".java");}});*/FilenameFilter过滤器+Lambda表达式File[] files = dir.listFiles(( d,name)->new File(d,name).isDirectory()||LowerCase().endsWith(".java"));for (File fi : files) {//System.out.println(fi);//不想打印根目录可直接使用这个if(fi.isDirectory()){printAllFile(fi);}else{System.out.println(fi);}}}
}

Lambda表达式

• 函数式编程思想

1. 面向对象的思想：做一件事，找一个能解决这个事情的对象，调用对象的方法，完成事情
2. 函数式编程思想：只要能获取到结果，谁去做的，怎么做的都不重要，重视的是结果，不重视过程

• 冗余的Runnable代码
  
• 编程思想转换：

public class Demo1 {public static void main(String[] args) {//匿名内部类实现创建线程new Thread(new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+"创建了这个线程！");}}).start();//使用Lambda表达式创建线程new Thread(()->{System.out.println(Thread.currentThread().getName()+"创建了这个线程！");}).start();}
}

• Lambda表达式更优写法
  
• Lambda表达式标准格式：
  
  eg：

public interface Cook {void cooking();
}
public class cookMain {public static void main(String[] args) {//匿名内部类实现makeCook(new Cook(){@Overridepublic void cooking() {System.out.println("做饭啦！");}});//Lambda实现makeCook(()->{System.out.println("做饭啦！");});}static void makeCook(Cook cook){king();}
}

• Lambda省略
  1.省略规则
  
• Lambda表达式使用前提：
  

File类

java.io.File

• 静态成员变量
  
• 绝对路径和相对路径
  
• 构造方法
  1.
  2.
  3.
• 常用方法：
  1.获取方法：
  
  2.判断功能的方法：
  
  3.创建删除功能的方法：路径由File对象构造方法的参数传入
  
  
  
  
• 目录的遍历
  

递归

递归求1-n的和
文件搜索

/*文件过滤器+匿名内部类+Lambda表达式
idea：递归打印多级目录且只打印.java文件
* 分析：
* 使用递归需要创建方法来遍历文件
* 1打印指定路径下的目录需要创建一个File对象
* 2使用listFiles方法将目录下所有子目录以及文件存入File数组
* 3进行判断
* AFile数组中的元素是文件夹则继续调用方法本身进行遍历
* BFile数组中的元素是文件则直接打印
* */public class fileSearchFilter2 {public static void main(String[] args) {File f=new File("E:\IdeaProjects\Base_Code\src\FileP");printAllFile(f);}
//创建打印方法private static void printAllFile(File dir) {//匿名内部类/*    File[] files = dir.listFiles(new FileFilter(){    @Overridepublic boolean accept(File pathname) {if (pathname.isDirectory()){return true;}Name().toLowerCase().endsWith(".java");}});*///Lambda简化
/*        File[] files = dir.listFiles((File pathname)->{if (pathname.isDirectory()){return true;}Name().toLowerCase().endsWith(".java");});*///FilenameFilter过滤器+匿名内部类/*      File[] files = dir.listFiles(new FilenameFilter(){@Overridepublic boolean accept(File dir, String name) {return new File(dir,name).isDirectory()||LowerCase().endsWith(".java");}});*/FilenameFilter过滤器+Lambda表达式File[] files = dir.listFiles(( d,name)->new File(d,name).isDirectory()||LowerCase().endsWith(".java"));for (File fi : files) {//System.out.println(fi);//不想打印根目录可直接使用这个if(fi.isDirectory()){printAllFile(fi);}else{System.out.println(fi);}}}
}

缓冲区

在原来基本的流的基础上添加了缓冲区，增加了读取和写入的效率

字节缓冲流

• BufferOutputStream字节缓冲输出流
  extends OutputStream
  
  使用步骤：
  eg：
  

• BufferInputStream字节缓冲输入流
  extends InputStream
  构造方法
  使用步骤
  eg：

• 测试效率
  eg：用缓冲流实现文件复制
  

字符缓冲流

• BufferWriter字符缓冲输出流
  构造方法：
  特有成员方法：
  使用步骤：
  eg：

• BufferReader字符缓冲输入流
  构造方法:
  
  特有的成员方法：
  读取一行数据
  使用步骤：
  eg：

• 文本排序练习
  
  分析：
  实现：

  转换流

• 字符编码
  

• 字符集
  

• 问题

• 转换流的原理
  

• OutputStreamWriter
  java.io.OutputStreamWriter extends Writer
  构造方法：
  使用步骤：
  eg：
  写utf_8格式：写gbk格式：
  

• InputStreamReader
  java.io. InputStreamReader extends InputStream
  构造方法
  使用步骤
  注意事项
  eg

• 转换文件编码练习

序列化

• ObjectOutputStream：对象的序列化流
• 注意事项—就是一个标记
  
  把对象以流的方式写入到文件中保存
  java.io.ObjectOutputStream extends OutputStream
  构造方法
  特有成员方法：
  
  使用步骤
  eg：
• ObjectInputStream对象的反序列化流
• 注意事项
  把文件中保存的对象，以流的方式读取出来使用
  java.io.ObjectInputStream extends InputStream
  构造方法：
  特有成员方法：
  使用步骤：
  eg：
• transient关键字：
  
  
• 序列号
  当序列化后class文件进行修改后会报错InvalidClassException异常
  
  
  eg：

public class Person implements Serializable {//手动添加序列号，防止更改Person后反序列化报错private static final long serialVersionUID=1L;private String name;private Integer age;//使用transient关键字修饰的成员变量不会被序列化，static修饰的也不会transient private String aclass;static int i;public Person() {this.i=++i;}//静态代码块比构造方法先执行，常用于对静态变量的赋值static {i=0;}public Person(String name, Integer age) {this.name = name;this.age = age;}// Testpublic void Test(){//对象的序列化操作ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:\IdeaProjects\"));oos.writeObject(new Person("yh",12));oos.close();ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:\IdeaProjects\"));Object o = adObject();System.out.println(o);Person p=(Person)o;System.out.Name()+"   "&#Age());if(o instanceof Person){System.out.println("1");}}ois.close();

• 序列化集合练习：

打印流

*注意：

网络编程入门

java包

• 软件结构：
  Client Server—客户端 服务器–QQ，迅雷…
  Brower Server—浏览器 服务器 --谷歌，火狐…
• 网络通信协议
  TCP/IP协议
• 协议分类:
  
  UDP：特点数据被限制在64kb以内，超出这个范围就不能发送了
  数据报Datagram： 网络传输的基本单位
  TCP协议：
  
  
• 网络编程三要素：
  1协议
  2IP地址：唯一标识
  3端口号

TCP通信程序

• Socket类–客户端类
  
  构造方法
  成员方法
  使用步骤
  注意事项
  eg
• ServerScoket类–服务器端类
  构造方法
  成员方法
  使用步骤
  eg
• 文件上传案例：
  需求分析：
  客户端实现
  服务器端实现
  
  
  文件上传阻塞问题解决
  优化
  1文件名
  2循环接收
  给服务器端一个死循环，且不要关闭客户端即可实现多次上传
  3多客户端上传–给服务器端设置多线程
  有一个客户端上传就开启一个服务器端线程
  多线程的实际应用：
  （1）一个浏览器必须能同时下载多个图片
  （2）一个web服务器必须能同时相应多个用户请求
  （3）Java虚拟机本身就在后台提供了一个超级线程来进行垃圾回收
  模拟BS服务器分析：
  
  
  图片不显示问题

函数式接口

概述

格式
函数式接口作为方法的参数的使用

函数式编程

函数式接口作为方法的返回类型的使用

常用函数式接口

1.Supplier–获取数据

eg
练习：获取数组中的最大值

/*idea：求出数组中最大的元素值
* 使用函数式编程，使用supplier接口*/
public class DemoSupplier {/*定义一个方法将supplier接口作为方法的参数*/public static Integer getArrayMax(Supplier<Integer> sup){();}public static void main(String[] args) {int[] a={1,3,-8,100,80};Integer max = getArrayMax(()->{int m=a[0];for (int i : a) {if (m<i) m=i;}return m;});System.out.println(max);}
}

2.Consumer接口–（使用）消费数据
eg：
默认方法：andThen
eg：
练习：
3.Predicate接口：对数据进行判断

eg：

默认方法and：与
默认方法or：或
默认方法negate：非（取反）
eg：
Predicate接口练习：集合信息筛选

public class DemoPredicate {/*定义筛选方法*/public static ArrayList<String> checkString(String[] arr, Predicate<String> pre1,Predicate<String> pre2){ArrayList<String> data=new ArrayList<>();for (String s : arr) {//两个判断的条件boolean test = pre1.and(pre2).test(s);//成立则向集合中添加元素if(test) data.add(s);}return data;}public static void main(String[] args) {String[] s={"迪丽热巴,女","古力娜扎,女","赵丽颖,女","马儿扎哈,男"};ArrayList<String> d = checkString(s, (String b) -> {return b.split(",")[1].equals("女");}, (String b) -> {return b.split(",")[0].length() == 4;});for (String s1 : d) {System.out.println(s1);}}
}

4.Function<T,R>接口：类型转换T–>R

apply方法进行转换
R apply(T t)
将此函数应用于给定的参数
eg：
默认方法andThen：进行组合操作
eg：

/*idea：使用Function<R,T>实现将一个字符串转为Integer+10，然后在转为Integer类型打印输出
* 分析：两次转换操作，可以使用andThen方法
* */
public class FunctionDemo {/*定义方法实现需求*/public static void BufferType(String s, Function<String,Integer> f1,Function<Integer,String> f2){/*Integer i=f1.apply(s);* String str=f2.apply(i);*/String str = f1.andThen(f2).apply(s);System.out.println("转换后的字符串是"+str);}public static void main(String[] args) {String a="125";BufferType(a,s->Integer.parseInt(s)+10,r->r+"");}
}

Stream流

用于解决已有集合类库中的弊端
eg：不用在遍历多次

/*过滤出集合中以张开头，且长度为3的数据并打印*/
public class Demo1 {public static void main(String[] args) {ArrayList<String> a=new ArrayList<>();a.add("张无忌");a.add("张三丰");a.add("张大头鬼");a.add("无忌");//过滤操作+过滤操作a.stream().filter(n->n.startsWith("张")).filter(n->n.length()==3).forEach(name-> System.out.println(name));}
}

流式思想：

• 获取流：
  
  静态of方法返回类型是一个流
  static Stream of(T… values)
  返回其元素是指定值的顺序排序流
  
• 常用方法：
  只要不是终结方法，返回的都是新的流
  终结方法后不能在调用Stream流中的其他方法(流关闭了)

1. forEachlambda有参数Consumer接口中的-void accept(T t) 对给定的参数执行此操作。有参数故Lambda表式也要有参数
2. filterlambda有参数* Stream流的特点
3. map映射-类型转换lambda有参数
4. count 统计个数-类似于Collection中的size方法不同在于返回值类型不同Stream<Integer> s = Stream.of(1, 2, 3, 4, 5, 6, 7); long count = s.count(); System.out.println(count);
5. limit-取用前几个(截取)Stream limit(long maxSize)
   返回由此流的元素组成的流，截短长度不能超过 maxSize
6. skip 跳过前几个Stream skip(long n)
   
7. concat(静态) 组合
   static Stream concat(Stream<? extends T> a, Stream<? extends T> b)
   创建一个懒惰连接的流，其元素是第一个流的所有元素，后跟第二个流的所有元素。
   

方法引用

对lambda表达式的优化

• 通过对象名引用成员方法
  
• 通过类名引用静态成员方法
  
  
• 通过super引用父类的成员方法
  
  
  
  
• 通过this引用成员方法
  
  
  
• 类的构造器引用
  创建一个Person类（name）
  
  
• 数组的构造器引用

方法引用eg
eg：

/*传递两个整数，计算乘积*/
@FunctionalInterface
public interface Multiply {int multiply(int x,int y);
}/*输入数组长度new一个int[]数组*/
@FunctionalInterface
public interface ArrayNew {int[] method(int a);
}/*传递一个字符串，计算其长度String类中的length方法 */
@FunctionalInterface
public interface StringLen {int len(String s);
}/*使用new构建一个字符串*/
public interface StringNew {String m(String n);
}/**/
public class Demo1 {public static void main(String[] args) {//1.静态方法引用//static int multiplyExact(int x, int y)//返回参数的乘积，如果结果溢出int，则抛出 int 。Multiply m=Math::multiplyExact;int result = m.multiply(2, 6);System.out.println(result);System.out.println("-------------------");//2.实例方法引用StringLen s=String::length;int len = s.len("12345");System.out.println(len);System.out.println("-------------------");//3.构造方法引用ArrayNew a= int[]::new;int[] x = a.method(10);System.out.String(x));System.out.println(x);StringNew n=String::new;String c = n.m("aaa");System.out.println(c);System.out.println("----------------------");}
}