Java入门到精通的学习笔记：零基础如何快速学会Java开发？

背景知识

java 相关概念

1. javase (java standard edition): 基础版，用于开发桌面应用程序。
2. javaee (java enterprise edition): 企业版，用于开发企业级应用程序。
3. javame (java micro edition): 微型版，用于开发嵌入式系统和移动设备应用程序。

编译与运行

1. 编译阶段:

   • 源文件: .java 文件。
   • 字节码文件: .class 文件。
   • 编译工具: javac.exe，用于将 .java 文件编译为 .class 文件。
     • 命令: javac 文件名.java
     • 编译包: javac -d 编译后存放路径 java源文件路径

2. 运行阶段:

   • 运行工具: java.exe，用于运行 .class 文件。
     • 命令: java 类名（不带 .class 后缀）
   • jvm (java virtual machine): java 虚拟机，负责执行字节码文件。

开发环境

1. jdk (java development kit): java 开发工具包，包含编译器、调试器等开发工具。
2. jre (java runtime environment): java 运行环境，包含 jvm 和运行 java 程序所需的库。
3. jvm (java virtual machine): java 虚拟机，负责执行字节码文件。

工具与格式

1. native2ascii: 用于将 unicode 字符转换为 \u 表示的 ascii 格式。
2. uml (unified modeling language): 面向对象设计图，用于表示类、接口、继承、实现等关系。
   • 空心箭头: 指向父类（继承）。
   • 空心虚线箭头: 指向接口（实现）。
   • 实心实线箭头: 表示关联关系。

注释

1. 单行注释: //
2. 多行注释: /* */
3. 文档注释: /** */，用于生成帮助文档。

类与方法结构

类体 {
    方法体 {
        java语句;
    }
}

总结

• javase 是基础版，javaee 是企业版，javame 是微型版。
• 编译 使用 javac，运行 使用 java。
• jdk 是开发工具包，jre 是运行环境，jvm 是虚拟机。
• uml 用于面向对象设计，注释 用于代码说明。
• 类与方法 的基本结构如上所示。

java se api 和文档

一、集成开发环境（idea）

以下是用户提供的快捷键和组织方式的总结：

组织方式

1. project（工程）: 最高层级，包含多个模块。
2. module（模块）: 工程下的子模块，包含多个包。
3. package（包）: 模块下的子包，用于组织类和资源。

字体设置

• 路径: file -> settings -> font
  用于调整编辑器的字体样式和大小。

快捷键分类总结

导航与操作

1. 展开/移动列表:

   • 左右箭头: 展开或折叠列表。
   • 上下箭头: 在列表中移动。

2. 切换与定位:

   • alt+左右箭头: 切换 java 程序。
   • alt+上下箭头: 在方法间快速移动。
   • alt+标号: 打开标号窗口。
   • ctrl+g: 定位到文件的某一行。
   • ctrl+点击: 切换源码。
   • ctrl+h: 查看实现类。

3. 查找与搜索:

   • ctrl+shift+n: 查找文件。
   • ctrl+n: 查找类文件。
   • ctrl+f12: 在当前类中查找一个方法。

编辑与格式化

1. 代码编辑:

   • ctrl+y: 删除一行。
   • shift+f6: 重命名。
   • alt+拖动: 一次编辑多行。
   • ctrl+alt+t: 将选中的代码放在 try{}、if{}、else{} 中。

2. 代码提示与自动补全:

   • ctrl+空格: 代码提示。
   • ctrl+p: 方法参数提示。
   • ctrl+j: 自动代码。
   • ctrl+alt+space: 类名或接口名提示。

3. 格式化与优化:

   • ctrl+alt+l: 格式化代码。
   • ctrl+alt+i: 自动缩进。
   • ctrl+alt+o: 优化导入的类和包。

运行与纠错

1. 运行程序:

   • ctrl+shift+f10: 运行当前程序。

2. 纠错与提示:

   • alt+回车: 纠错提示。

窗口操作

1. 全屏模式:
   • ctrl+shift+f12: 切换全屏模式。

总结

• 组织方式: 工程 -> 模块 -> 包，层级清晰，便于管理。
• 快捷键:
  • 导航与查找：快速定位文件、类、方法。
  • 编辑与格式化：提高代码编写效率。
  • 运行与纠错：快速运行程序并修复错误。
  • 窗口操作：优化开发环境布局。

二、jvm内存划分

局部变量在方法体中声明，运行阶段内存在栈中分配

方法区内存：字节码文件在加载 的时候将其放在方法区之中（最先有数据，调用方法时在栈内分配空间）

堆内存（heap）：new对象（成员变量中的实例变量（一个对象一份）在java对象内部存储），只能通过引用调用操作

栈（stack）内存：栈帧永远指向栈顶元素，栈顶元素处于活跃状态，先进后出，后进先出（存储局部变量）

内存区域与数据存储

1. 堆内存（heap）:

   • 存储实例变量（对象属性）。
   • 每个 jvm 实例只有一个堆内存，所有线程共享。
   • 垃圾回收器（gc）主要针对堆内存进行回收。

2. 方法区（method area）:

   • 存储静态变量（类变量）和类元数据（如类信息、常量池等）。
   • 每个 jvm 实例只有一个方法区，所有线程共享。
   • 方法区是最先有数据的内存区域，因为类加载时静态变量和类信息会初始化。

3. 栈内存（stack）:

   • 存储局部变量和方法调用栈帧。
   • 每个线程有一个独立的栈内存，线程私有。
   • 栈内存是使用最频繁的内存区域，因为方法调用和局部变量的生命周期较短。

变量存储位置

1. 局部变量:

   • 存储在栈内存中。
   • 生命周期与方法调用一致，方法结束时局部变量会被销毁。

2. 实例变量:

   • 存储在堆内存中。
   • 生命周期与对象一致，对象被垃圾回收时实例变量会被销毁。

3. 静态变量:

   • 存储在方法区中。
   • 生命周期与类一致，类卸载时静态变量会被销毁。

垃圾回收器（gc）

1. 主要目标:

   • 垃圾回收器主要针对堆内存进行回收，清理不再使用的对象。
   • 栈内存和方法区的垃圾回收机制与堆内存不同。

2. 特点:

   • 堆内存是垃圾回收的主要区域，因为对象生命周期较长且占用内存较大。
   • 栈内存和方法区的垃圾回收效率较高，因为它们的生命周期较短且数据量相对较小。

三、关键字：

类与关键字

1. public:

   • 表示公开的类，类名必须与文件名一致，且一个文件中只能有一个 public 类。

2. class:

   • 用于定义一个类。

3. static:

   • 表示静态的，修饰的成员变量或方法属于类级别，不依赖于对象。
   • 静态变量在类加载时初始化，存储在方法区内存中。
   • 静态方法不能访问实例变量或实例方法，需要通过对象访问。

4. break:

   • 用于跳出循环或 switch 语句。

5. continue:

   • 用于跳过当前循环的剩余部分，直接进入下一次循环。
   • 语法：continue 循环名称; 或 循环名称:。

6. this:

   • 表示当前对象的引用。
   • 用于区分局部变量和实例变量，或在构造方法中调用其他构造方法（this(实参)）。
   • 不能用于静态方法中。

7. native:

   • 用于调用 jvm 本地程序。

输入与输出

1. system.out.println():

   • 控制台输出，println 表示输出并换行。

2. 键盘输入:

   • 创建键盘扫描器对象：java.util.scanner s = new java.util.scanner(system.in);
   • 字符串输入：string user = s.next();
   • 整数输入：int num = s.nextint();

final关键字

1. 修饰类:

   • 类不能被继承。

2. 修饰方法:

   • 方法不能被重写。

3. 修饰变量:

   • 变量不能被修改。
   • 修饰的成员变量必须手动赋值。
   • 修饰的引用一旦指向一个对象，就不能指向其他对象，但所指向的内存可以修改。

4. 常量:

   • 定义常量：public static final 类型 常量名 = 值;
   • 命名规则：全部大写，用下划线分隔。

super关键字

1. 作用:

   • 代表当前对象的父类型特征。
   • 用于访问父类的属性、方法或调用父类的构造方法。

2. 语法:

   • 访问父类属性或方法：super.
   • 调用父类构造方法：super()

3. 规则:

   • 不能用于静态方法中。
   • 如果父类和子类有同名属性，访问父类属性时不能省略 super。
   • 构造方法的第一行如果没有 this() 或 super()，默认会调用 super()。

static关键字

1. 静态变量:

   • 属于类级别，不依赖于对象，类加载时初始化。

2. 静态方法:

   • 类级别的方法，不能访问实例变量或实例方法。

3. 静态代码块:

   • 在类加载时执行，只执行一次。
   • 语法：static {}

4. 实例代码块:

   • 在构造方法执行之前执行，用于对象初始化。

包与导入

1. package:

   • 用于管理类，命名规则：公司域名倒序.项目名.模块名.功能名。
   • 语法：package 包名;

2. import:

   • 用于导入包中的类。
   • 语法：import 包名.类名; 或 import 包名.*;
   • java.lang.* 是核心语言包，无需导入。

3. 快捷键:

   • ctrl+shift+o：自动导入。

访问控制权限修饰符

1. private:

   • 私有访问权限，只能在本类中访问。

2. default:

   • 默认访问权限，可以被本包中的其他类访问。

3. protected:

   • 受保护的访问权限，可以被本包及不同包的子类访问。

4. public:

   • 公共访问权限，可以在任何地方访问。

5. 类的修饰符:

   • 类只能使用 public 或默认修饰符（缺省），内部类除外。

总结

• 类与关键字：public、class、static、this、super 等关键字的作用与用法。
• 输入与输出：控制台输出与键盘输入的基本操作。
• final：用于修饰类、方法、变量，表示不可修改。
• static：修饰类级别的成员，与对象无关。
• 包与导入：package 和 import 的使用及命名规则。
• 访问控制权限：private、default、protected、public 的访问范围。

四、java基础

以下是用户提供的内容的总结：

标识符

1. 定义:

   • 用户有权命名的单词，包括类名、方法名、常量名、变量名、接口名等。

2. 命名规则:

   • 类名、接口名: 首字母大写，后面每个单词首字母大写（大驼峰命名法）。
   • 方法名、变量名: 首字母小写，后面每个单词首字母大写（小驼峰命名法）。
   • 常量名: 全部大写，单词间用下划线分隔。

字面值

• 定义: 数据本身，如数字、字符串等，通常以紫色显示。

变量

1. 局部变量:

   • 定义在方法体内，没有默认值，必须手动初始化。
   • 生命周期与方法调用一致。

2. 成员变量:

   • 定义在类体内，有默认值（数值类型为 0，布尔类型为 false，引用类型为 null）。
   • 分为实例变量和静态变量。

3. 实例变量:

   • 不带 static 关键字，属于对象级别。
   • 必须通过对象引用访问（引用.变量名）。
   • 存储在堆内存中。

4. 静态变量:

   • 带 static 关键字，属于类级别。
   • 在类加载时初始化，存储在方法区内存中。
   • 通过类名访问（类名.变量名）。

引用

• 定义: 是一个变量，可以是实例变量或局部变量。
  • 实例变量: 类名 引用 = new 类名();
  • 局部变量: 引用 变量名 = new 引用();

数据类型

1. 基本数据类型:

   • 整数型: byte（1 字节）、short（2 字节）、int（4 字节）、long（8 字节，后缀 l）。
   • 浮点型: float（4 字节）、double（8 字节）。
   • 布尔型: boolean（1 字节）。
   • 字符型: char（2 字节）。

2. 引用数据类型:

   • 字符串: string，不可变，存储在方法区字符串池中。

3. 比较:

   • 基本数据类型使用 == 判断相等。
   • 引用数据类型（包括 string）使用 equals 判断相等。

字符编码

• 发展顺序: ascii < iso-8859-1 < gb2312 < gbk < gb18030 < big5 < unicode（统一全球编码）。

位运算符

1. 逻辑异或（^）: 两边不一样为真。
2. 短路与（&&）: 左边为假时直接返回假。
3. 按位与（&）: 将操作数转换为二进制后按位与。
4. 短路或（||）: 左边为真时直接返回真。
5. 左移（<<）: 二进制数据左移，相当于乘以 2 的 n 次方。
6. 右移:
   • 带符号右移（>>）: 正数用 0 填充，负数用 1 填充。
   • 无符号右移（>>>）: 无论正负都用 0 填充。
7. 按位取反（~）: 将二进制每一位取反，结果为 -(n+1)。

方法（函数）

1. 定义:

   [修饰符列表] 返回值类型 方法名(形参列表) {
       方法体;
       return; // return 后不能跟语句
   }
   

2. 调用: 类名.方法名(实参列表);

3. 实例方法: 不带 static，需要对象参与。

4. 静态方法: 带 static，与对象无关。

方法重载（overload）

• 定义: 在同一类中，方法名相同但参数列表不同。
• 特点: 与返回值类型和修饰符列表无关。

方法递归

• 定义: 方法调用自身，每次递归都会分配新的内存空间（压栈）。

• 示例:

  public static int sum(int n) {
      if (n == 1) {
          return 1;
      }
      return n + sum(n - 1);
  }
  

方法覆盖（override）

1. 定义: 发生在继承关系中，子类重写父类的方法。
2. 规则:
   • 方法名、返回值类型、形参列表必须与父类一致。
   • 访问权限不能比父类更低，抛出异常不能更多。
3. 限制:
   • 私有方法、构造方法不能覆盖。
   • 静态方法不存在覆盖。

总结

• 标识符: 命名规则与用途。
• 变量: 局部变量、实例变量、静态变量的定义与存储位置。
• 数据类型: 基本数据类型与引用数据类型的区别。
• 位运算符: 各种位运算符的作用与用法。
• 方法: 定义、调用、重载、递归与覆盖的规则与特点。

五、java 控制流与 lambda 表达式

1.控制流语句

• if-else 语句：

  if (条件) {
      // 语句
  } else if (表达式) {
      // 语句
  } else {
      // 语句
  }
  

• switch 语句：

  switch (关键词) {
      case 关键词:
          // java语句
          break;
      default:
          // 默认语句
  }
  

• for 循环：

  for (初始表达式; 布尔表达式; 更新循环体) {
      // 循环体
  }
  

• 增强 for 循环（for each）：

  for (元素类型 变量名 : 数组或集合) {
      system.out.println(变量名);
  }
  

• while 循环：

  while (表达式) {
      // 循环体
  }
  

• do-while 循环：

  do {
      // 循环体
  } while (布尔表达式);
  

2.java 标签

• 标签用于控制嵌套循环的跳转和中断。
• 语法：label:
• 用法：
  • continue label;：跳过当前循环，继续执行标签处的循环。
  • break label;：结束标签处的循环，执行循环后的代码。

3.lambda 表达式

• 实现 runnable：

  // java 8 之前
  new thread(new runnable() {
      @override
      public void run() {
          system.out.println("before java8, too much code for too little to do");
      }
  }).start();
  
  // java 8 方式
  new thread(() -> system.out.println("in java8, lambda expression rocks !!")).start();
  

• 事件处理：

  // java 8 之前
  jbutton show = new jbutton("show");
  show.addactionlistener(new actionlistener() {
      @override
      public void actionperformed(actionevent e) {
          system.out.println("event handling without lambda expression is boring");
      }
  });
  
  // java 8 方式
  show.addactionlistener((e) -> {
      system.out.println("light, camera, action !! lambda expressions rocks");
  });
  

• 列表迭代：

  // java 8 之前
  list<string> features = arrays.aslist("lambdas", "default method", "stream api", "date and time api");
  for (string feature : features) {
      system.out.println(feature);
  }
  
  // java 8 之后
  features.foreach(n -> system.out.println(n));
  // 使用方法引用
  features.foreach(system.out::println);
  

• map 和 reduce：

  // 不使用 lambda 表达式
  list<integer> costbeforetax = arrays.aslist(100, 200, 300, 400, 500);
  for (integer cost : costbeforetax) {
      double price = cost + .12 * cost;
      system.out.println(price);
  }
  
  // 使用 lambda 表达式
  costbeforetax.stream().map((cost) -> cost + .12 * cost).foreach(system.out::println);
  
  // 使用 reduce 计算总和
  double bill = costbeforetax.stream().map((cost) -> cost + .12 * cost).reduce((sum, cost) -> sum + cost).get();
  system.out.println("total : " + bill);
  

• 对列表的每个元素应用函数：

  list<string> g7 = arrays.aslist("usa", "japan", "france", "germany", "italy", "u.k.", "canada");
  string g7countries = g7.stream().map(x -> x.touppercase()).collect(collectors.joining(", "));
  system.out.println(g7countries);
  

• 计算集合元素的最大值、最小值、总和以及平均值：

  list<integer> primes = arrays.aslist(2, 3, 5, 7, 11, 13, 17, 19, 23, 29);
  intsummarystatistics stats = primes.stream().maptoint((x) -> x).summarystatistics();
  system.out.println("highest prime number in list : " + stats.getmax());
  system.out.println("lowest prime number in list : " + stats.getmin());
  system.out.println("sum of all prime numbers : " + stats.getsum());
  system.out.println("average of all prime numbers : " + stats.getaverage());
  

总结

• 控制流语句：用于控制程序的执行流程，包括条件判断、循环等。
• java 标签：用于控制嵌套循环的跳转和中断。
• lambda 表达式：简化了匿名类的使用，使代码更简洁，特别是在实现函数式接口（如 runnable、actionlistener）时非常有用。
• stream api：提供了强大的集合操作功能，如 map、reduce、foreach 等，使得对集合的处理更加高效和简洁。

六、面向对象

面向过程与面向对象的对比

1. 面向过程：

   • 因果关系：关注问题的具体步骤和流程。
   • 具体过程：强调如何一步步解决问题。
   • 耦合度高：各个模块之间依赖性强，修改一个模块可能会影响其他模块。
   • 软件拓展性差：由于耦合度高，系统的扩展和维护较为困难。

2. 面向对象：

   • 分类对象：将问题分解为多个对象，每个对象负责特定的功能。
   • 关系层度低：对象之间的依赖关系较弱，耦合度低。
   • 关注对象功能：关注对象能完成哪些功能，而不是具体的实现步骤。
   • 三大特征：
     • 封装性：将复杂的事务封装起来，只保留简单的操作入口。封装后形成独立的对象，提高了代码的复用性、适应性和安全性。
     • 继承性：实现代码复用，最重要的是支持多态和方法覆盖。
     • 多态性：父类型的引用可以指向子类型对象，降低程序耦合度，提高扩展力。

面向对象的分析与设计

• 面向对象的分析（ooa）：分析问题域，识别对象及其关系。
• 面向对象的设计（ood）：设计对象的结构和行为，定义类及其关系。
• 面向对象的编程（oop）：使用编程语言实现设计，创建对象并实现其功能。

类与对象

• 类：高度抽象的对象的集合，是一个模板。
  • 静态代码块：类加载时执行。
  • 实例代码块：实例化时执行。
  • 静态变量：类级别的变量。
  • 实例变量：对象级别的变量，存储在堆内存中。
  • 构造方法：创建对象时调用，用于初始化实例变量。
  • 静态方法：类级别的方法。
  • 实例方法：对象级别的方法。
  • 成员变量：对象的属性，描述对象的状态。
  • 成员方法：对象的行为，描述对象的动作。
• 对象：类的具体实例。
  • 创建对象：类名 对象名称 = new 类名();
  • 使用对象：对象名称.属性名 或 对象名称.方法名()
  • 修改对象：引用.变量名 = 值
  • 引用与对象：引用保存了对象的地址，指向堆内存中的对象。多个引用可以指向同一个对象，但一个引用只能指向一个对象。

user u=new user（）;
address a=new address();
u.addr=a；
print(u.addr.city);
a.city=”天津”；
print(u.addr.city);                                      

封装

• 私有化属性：使用private关键字将属性私有化。
• 提供操作入口：通过getter和setter方法提供对属性的访问和修改。
  • 读取属性：public 数据类型 get属性名() { return 属性; }
  • 修改属性：public void set属性名(数据类型 属性) { this.属性 = 属性; }
• 业务逻辑控制：在setter方法中添加业务逻辑进行安全控制。

构造方法

• 作用：创建对象并初始化实例变量。
• 语法：修饰符 构造方法名(形参) { 构造方法体; this.实例变量 = 形参; }
• 特点：没有返回值类型，方法名与类名一致，不能使用return返回值，但可以使用return结束方法。
• 调用：new 构造方法名(实参)
• 缺省构造器：如果没有定义构造方法，编译器会自动生成一个无参的缺省构造器。

继承

• 语法：[修饰符列表] class 子类名 extends 父类名 { 类体 = 属性 + 方法 }
• 单继承：java中类只能继承一个父类。
• 继承关系：
  • 父类：也称为基类、超类、superclass。
  • 子类：也称为派生类、subclass。
• 不可继承：私有的属性和方法、构造方法。
• 间接继承：通过继承链，子类可以间接继承父类的父类。
• 默认继承：如果没有显式继承任何类，默认继承java.lang.object类。
• super关键字：用于调用父类的属性、方法和构造方法。

多态

• 向上转型（upcasting）：子类转换为父类型，自动类型转换。
  • 语法：父类 引用 = new 子类();
  • 特点：编译通过，运行没有问题。
• 向下转型（downcasting）：父类转换为子类，强制类型转换。
  • 语法：子类 引用 = (子类) 父类引用;
  • 特点：存在隐患，可能导致classcastexception异常。
• 动态绑定：父类型引用指向子类型对象，调用方法时实际执行的是子类的方法。
• instanceof运算符：用于在强制转换前检查对象的类型，避免classcastexception异常。
  • 语法：引用 instanceof 数据类型名
  • 返回值：布尔类型，true表示引用指向的对象是后面的数据类型，false表示不是。

以下是关于 抽象类 和 接口 的总结：

抽象类

1. 定义:

   • 使用 abstract 关键字修饰的类，是类的进一步抽象。
   • 属于引用数据类型。

2. 语法:

   [修饰符列表] abstract class 类名 {}
   

3. 特点:

   • 不能使用 private 或 final 修饰。
   • 抽象类可以包含抽象方法和非抽象方法。
   • 抽象类的子类可以是抽象类或非抽象类。
   • 不能实例化（不能创建对象），但可以有构造方法，供子类使用。

4. 抽象方法:

   • 使用 abstract 关键字修饰，无方法体。
   • 语法：[修饰符列表] abstract 返回值类型 方法名();
   • 包含抽象方法的类一定是抽象类。

5. 规则:

   • 抽象类不一定有抽象方法，但抽象方法必须出现在抽象类中。
   • 非抽象类继承抽象类时，必须实现所有抽象方法。

接口

1. 定义:

   • 使用 interface 关键字定义，是完全抽象的（特殊的抽象类）。
   • 属于引用数据类型。

2. 语法:

   [修饰符列表] interface 接口名 {}
   

3. 特点:

   • 接口中只能包含常量和抽象方法（默认 public static final 和 public abstract，修饰符可省略）。
   • 支持多继承，一个接口可以继承多个接口。
   • 接口不能继承抽象类。

4. 方法类型:

   • 抽象方法: abstract 修饰（可省略）。
   • 默认方法: default 修饰，提供默认实现。
   • 静态方法: static 修饰，通过接口名调用。

5. 实现:

   • 类通过 implements 关键字实现接口。
   • 非抽象类实现接口时，必须重写所有抽象方法。
   • 一个类可以实现多个接口。

6. 多态:

   • 接口支持多态：父类型引用指向子类对象。
   • 示例：接口名 引用 = new 实现类();

7. 作用:

   • 解耦合：调用者面向接口调用，实现者面向接口编写实现。
   • 扩展性强：接口+多态可以降低程序耦合度。

抽象类与接口的区别

开发中的选择

1. 抽象类:

   • 当多个类有共同的属性和行为，且需要部分具体实现时使用。
   • 适合定义“是什么”（is-a 关系）。

2. 接口:

   • 当需要定义一组行为规范，且不关心具体实现时使用。
   • 适合定义“能做什么”（like-a 关系）。

示例

1. 抽象类:

   abstract class animal {
       abstract void sound();
       void sleep() {
           system.out.println("sleeping...");
       }
   }
   

2. 接口:

   interface flyable {
       void fly();
   }
   

3. 实现与继承:

   class bird extends animal implements flyable {
       @override
       void sound() {
           system.out.println("chirp...");
       }
       @override
       public void fly() {
           system.out.println("flying...");
       }
   }
   

总结

• 面向对象编程通过封装、继承和多态三大特征，提高了代码的复用性、扩展性和维护性。

• 类与对象是面向对象编程的基础，类是对对象的抽象，对象是类的实例。

• 封装通过私有化属性和提供操作入口，增强了代码的安全性和可控性。

• 继承实现了代码的复用，并支持多态和方法覆盖。

• 多态通过向上转型和向下转型，降低了程序的耦合度，提高了扩展力。

• 面向抽象编程，而不是面向具体，可以进一步降低耦合度，提高系统的灵活性和可扩展性。

• 抽象类 用于定义类的共有特征，支持部分具体实现。

• 接口 用于定义行为规范，支持多继承和解耦合。

• 在实际开发中，根据需求选择抽象类或接口，合理使用可以提高代码的扩展性和可维护性。

七、类库

源码、字节码与帮助文档

1. 源码：

   • 理解程序：源码是程序员编写的原始代码，用于理解程序的逻辑和功能。

2. 字节码：

   • 程序开发使用：字节码是源码编译后的中间代码，由jvm执行。它是跨平台的，可以在任何支持jvm的系统上运行。

3. 帮助文档：

   • 对开发提供帮助：帮助文档是开发者的参考指南，通常通过javadoc生成。
   • 注意使用版本同一：确保使用的帮助文档与代码版本一致，避免因版本差异导致的错误。

object类（根类）

object是java中所有类的根类，提供了一些核心方法：

1. protected object clone()：

   • 负责对象克隆，返回对象的副本。

2. boolean equals(object obj)：

   • 判断两个对象是否相等。默认比较引用地址，通常需要重写以比较对象内容。

3. int hashcode()：

   • 返回对象的哈希代码值，用于哈希表等数据结构。

4. string tostring()：

   • 返回对象的字符串表示形式。默认返回类名@哈希值，通常需要重写以提供更有意义的信息。

5. protected void finalize() throws throwable：

   • 垃圾回收器负责调用，用于对象销毁前的清理工作。

6. system.gc()：

   • 建议启动垃圾回收器，但不保证立即执行。

system类

system类提供了一些系统级别的操作：

1. system.gc()：

   • 建议启动垃圾回收器。

2. system.out：

   • 静态变量，用于控制台输出。

3. system.out.print()：

   • 输出打印不换行。

4. system.out.println()：

   • 换行输出。

5. system.currenttimemillis()：

   • 获取自1970年1月1日00:00:00到当前系统时间的总毫秒数。

6. system.exit(0)：

   • 退出jvm。

arrays类

arrays是数组工具类，提供了一些常用方法：

1. arrays.sort(arr)：

   • 对数组进行排序。

2. arrays.binarysearch(arr, key)：

   • 使用二分法查找元素，不存在时返回-1。

string类

string类用于操作字符串，提供了丰富的构造方法和方法：

1. 构造方法：

   • string(byte[] byte)：将字节数组转换为字符串。
   • string(char[] char)：将字符数组转换为字符串。
   • string(string string)：复制字符串。

2. 常用方法：

   • char charat(int index)：返回指定索引的字符。
   • int compareto(string string)：字典比较大小。
   • boolean contains(string string)：判断是否包含指定字符串。
   • boolean endswith(string string)：判断是否以指定字符串结尾。
   • boolean startswith(string prefix)：判断是否以指定前缀开头。
   • boolean equals(object anobject)：比较字符串内容。
   • boolean equalsignorecase(string anotherstring)：忽略大小写比较。
   • byte[] getbytes()：将字符串转换为字节数组。
   • int indexof(string str)：返回子字符串第一次出现的索引。
   • int lastindexof(string str)：返回子字符串最后一次出现的索引。
   • boolean isempty()：判断字符串是否为空。
   • string replace(charsequence target, charsequence replacement)：替换字符串。
   • string substring(int beginindex)：截取字符串。
   • char[] tochararray()：将字符串转换为字符数组。
   • string tolowercase()：将字符串转换为小写。
   • string touppercase()：将字符串转换为大写。
   • string[] split(string regex)：按正则表达式拆分字符串。
   • string trim()：去除前后空白。
   • static string valueof()：将其他类型转换为字符串。

stringbuffer与stringbuilder

1. stringbuffer：

   • 线程安全，适用于多线程环境。
   • 常用方法：append()、reverse()。

2. stringbuilder：

   • 非线程安全，性能优于stringbuffer。

包装类

包装类用于将基本数据类型转换为对象：

1. 常用包装类：
   • integer、character等。
2. 常用方法：
   • int intvalue()：拆箱，将包装类转换为基本类型。
   • static int parseint(string s)：将字符串转换为整数。

日期相关类

1. java.util.date：

   • 表示日期和时间。

2. simpledateformat：

   • 用于格式化日期。
   • 常用方法：format()、parse()。

数字相关类

1. decimalformat：

   • 用于格式化数字。

2. bigdecimal：

   • 用于高精度计算，适用于财务数据。

3. random：

   • 用于生成随机数。

枚举（enum）

枚举是一种特殊的类，用于定义一组常量：

enum season {
    spring, summer, autumn, winter
}

内部类

1. 成员内部类：

   • 定义在类中，可以访问外部类的所有成员。

2. 局部内部类：

   • 定义在方法中，只能在该方法内访问。

3. 静态内部类：

   • 使用static修饰，只能访问外部类的静态成员。

4. 匿名内部类：

   • 没有名称的内部类，通常用于实现接口或抽象类。

总结

• 源码是理解程序的基础，字节码是程序运行的关键，帮助文档是开发的指南。
• object是java的根类，提供了对象的基本操作。
• system类提供了系统级别的操作，如垃圾回收、时间获取等。
• string类用于操作字符串，提供了丰富的构造方法和方法。
• stringbuffer和stringbuilder用于字符串的拼接和修改，前者线程安全，后者性能更优。
• 包装类用于将基本数据类型转换为对象。
• 日期相关类用于处理日期和时间。
• 内部类提供了更灵活的代码组织方式。

八、数组

一维数组

1. 定义:

   • 数组是引用数据类型，存储在堆内存中。
   • 可以存储各种数据类型，但不能直接存储对象，存储的是对象的引用（内存地址）。

2. 特点:

   • 数组元素类型统一，最后一个下标为 length - 1。
   • 带有 length 属性，用于获取数组长度。

3. 优点:

   • 查询、查找、检索某个下标元素效率极高（内存连续，类型相同）。

4. 缺点:

   • 随机增删元素效率较低。
   • 不能存储大数据量。

5. 定义与初始化:

   • 静态初始化:

     数据类型[] 数组名 = {元素1, 元素2, ...};
     

   • 动态初始化:

     数据类型[] 数组名 = new 数据类型[长度];
     

6. 赋值:

   数组名[下标] = 值;
   

7. 遍历:

   • 使用 for 循环或增强 for 循环：

     for (int i = 0; i < 数组名.length; i++) {
         system.out.println(数组名[i]);
     }
     

8. 方法参数:

   • 数组可以作为方法的参数：

     void 方法名(数据类型[] 数组名) {}
     

9. main 方法的数组参数:

   • main 方法的参数是一个字符串数组，用于接收命令行参数：

     public static void main(string[] args) {}
     

10. 存储对象:

    • 数组可以存储对象的引用：

      类名[] 数组名 = new 类名[长度];
      数组名[0] = new 类名();
      

11. 数组扩容:

    • 新建一个大数组，然后将原数组拷贝过去：

      int[] newarray = new int[原数组.length * 2];
      system.arraycopy(原数组, 0, newarray, 0, 原数组.length);
      

12. 数组拷贝:

    • 使用 system.arraycopy 方法：

      system.arraycopy(原数组, 原起点, 目标数组, 目标下标, 长度);
      

二维数组

1. 定义:

   • 二维数组是数组的数组，可以看作是一个表格。

2. 语法:

   数据类型[][] 数组名 = new 数据类型[行数][列数];
   

3. 初始化:

   • 静态初始化:

     数据类型[][] 数组名 = {{元素1, 元素2}, {元素3, 元素4}};
     

   • 动态初始化:

     数据类型[][] 数组名 = new 数据类型[行数][列数];
     

4. 遍历:

   • 使用嵌套 for 循环：

     for (int i = 0; i < 数组名.length; i++) {
         for (int j = 0; j < 数组名[i].length; j++) {
             system.out.println(数组名[i][j]);
         }
     }
     

总结

1. 一维数组:

   • 适用于存储一组相同类型的数据。
   • 查询效率高，增删效率低。
   • 可以通过 length 属性获取长度。
   • 支持静态初始化和动态初始化。

2. 二维数组:

   • 适用于存储表格型数据。
   • 可以看作是一维数组的数组。
   • 支持静态初始化和动态初始化。

3. 数组的优缺点:

   • 优点：查询效率高，内存连续。
   • 缺点：增删效率低，不能存储大数据量。

4. 数组的应用场景:

   • 存储一组固定长度的数据。
   • 存储对象引用。
   • 存储表格型数据（二维数组）。

示例

1. 一维数组:

   int[] arr = {1, 2, 3, 4, 5};
   for (int i = 0; i < arr.length; i++) {
       system.out.println(arr[i]);
   }
   

2. 二维数组:

   int[][] arr = {{1, 2}, {3, 4}};
   for (int i = 0; i < arr.length; i++) {
       for (int j = 0; j < arr[i].length; j++) {
           system.out.println(arr[i][j]);
       }
   }
   

3. 数组存储对象:

   animal[] animals = new animal[2];
   animals[0] = new cat();
   animals[1] = new dog();
   

4. 数组扩容:

   int[] src = {1, 2, 3};
   int[] dest = new int[src.length * 2];
   system.arraycopy(src, 0, dest, 0, src.length);
   

通过合理使用数组，可以高效地存储和操作数据，但需要注意其增删效率较低的缺点。

九、算法

以下是常见 排序算法 和 查找算法 的思想总结，并附带 java 实例：

排序算法

1. 冒泡排序（bubble sort）:

   • 思想：重复遍历数组，每次比较相邻元素，如果顺序错误则交换，直到没有需要交换的元素。

   • 时间复杂度：o(n²)。

   • java 实现:

     public static void bubblesort(int[] arr) {
         for (int i = 0; i < arr.length - 1; i++) {
             for (int j = 0; j < arr.length - 1 - i; j++) {
                 if (arr[j] > arr[j + 1]) {
                     int temp = arr[j];
                     arr[j] = arr[j + 1];
                     arr[j + 1] = temp;
                 }
             }
         }
     }
     

2. 选择排序（selection sort）:

   • 思想：每次从未排序部分选择最小元素，放到已排序部分的末尾。

   • 时间复杂度：o(n²)。

   • java 实现:

     public static void selectionsort(int[] arr) {
         for (int i = 0; i < arr.length - 1; i++) {
             int minindex = i;
             for (int j = i + 1; j < arr.length; j++) {
                 if (arr[j] < arr[minindex]) {
                     minindex = j;
                 }
             }
             int temp = arr[i];
             arr[i] = arr[minindex];
             arr[minindex] = temp;
         }
     }
     

3. 插入排序（insertion sort）:

   • 思想：将未排序部分的元素逐个插入到已排序部分的正确位置。

   • 时间复杂度：o(n²)。

   • java 实现:

     public static void insertionsort(int[] arr) {
         for (int i = 1; i < arr.length; i++) {
             int key = arr[i];
             int j = i - 1;
             while (j >= 0 && arr[j] > key) {
                 arr[j + 1] = arr[j];
                 j--;
             }
             arr[j + 1] = key;
         }
     }
     

4. 快速排序（quick sort）:

   • 思想：选择一个基准元素，将数组分为两部分，左边小于基准，右边大于基准，递归排序。

   • 时间复杂度：o(n log n)。

   • java 实现:

     public static void quicksort(int[] arr, int low, int high) {
         if (low < high) {
             int pivot = partition(arr, low, high);
             quicksort(arr, low, pivot - 1);
             quicksort(arr, pivot + 1, high);
         }
     }
     
     private static int partition(int[] arr, int low, int high) {
         int pivot = arr[high];
         int i = low - 1;
         for (int j = low; j < high; j++) {
             if (arr[j] < pivot) {
                 i++;
                 int temp = arr[i];
                 arr[i] = arr[j];
                 arr[j] = temp;
             }
         }
         int temp = arr[i + 1];
         arr[i + 1] = arr[high];
         arr[high] = temp;
         return i + 1;
     }
     

5. 归并排序（merge sort）:

   • 思想：将数组分成两半，分别排序，然后合并。

   • 时间复杂度：o(n log n)。

   • java 实现:

     public static void mergesort(int[] arr, int left, int right) {
         if (left < right) {
             int mid = (left + right) / 2;
             mergesort(arr, left, mid);
             mergesort(arr, mid + 1, right);
             merge(arr, left, mid, right);
         }
     }
     
     private static void merge(int[] arr, int left, int mid, int right) {
         int[] temp = new int[right - left + 1];
         int i = left, j = mid + 1, k = 0;
         while (i <= mid && j <= right) {
             if (arr[i] <= arr[j]) {
                 temp[k++] = arr[i++];
             } else {
                 temp[k++] = arr[j++];
             }
         }
         while (i <= mid) {
             temp[k++] = arr[i++];
         }
         while (j <= right) {
             temp[k++] = arr[j++];
         }
         for (int p = 0; p < temp.length; p++) {
             arr[left + p] = temp[p];
         }
     }
     

查找算法

1. 线性查找（linear search）:

   • 思想：从头到尾遍历数组，逐个比较，找到目标元素。

   • 时间复杂度：o(n)。

   • java 实现:

     public static int linearsearch(int[] arr, int target) {
         for (int i = 0; i < arr.length; i++) {
             if (arr[i] == target) {
                 return i;
             }
         }
         return -1;
     }
     

2. 二分查找（binary search）:

   • 思想：在有序数组中，每次取中间元素与目标比较，缩小查找范围。

   • 时间复杂度：o(log n)。

   • java 实现:

     public static int binarysearch(int[] arr, int target) {
         int left = 0, right = arr.length - 1;
         while (left <= right) {
             int mid = (left + right) / 2;
             if (arr[mid] == target) {
                 return mid;
             } else if (arr[mid] < target) {
                 left = mid + 1;
             } else {
                 right = mid - 1;
             }
         }
         return -1;
     }
     

总结

1. 排序算法:

   • 冒泡排序：简单但效率低，适合小规模数据。
   • 选择排序：每次选择最小元素，适合小规模数据。
   • 插入排序：适合部分有序的数据。
   • 快速排序：高效，适合大规模数据。
   • 归并排序：稳定且高效，适合大规模数据。

2. 查找算法:

   • 线性查找：适合无序数据。
   • 二分查找：适合有序数据，效率高。

3. 选择依据:

   • 数据规模、是否有序、稳定性要求等。

示例

public class main {
    public static void main(string[] args) {
        int[] arr = {5, 3, 8, 4, 2};
        bubblesort(arr);
        system.out.println("冒泡排序结果: " + arrays.tostring(arr));

        int[] arr2 = {5, 3, 8, 4, 2};
        quicksort(arr2, 0, arr2.length - 1);
        system.out.println("快速排序结果: " + arrays.tostring(arr2));

        int target = 4;
        int index = binarysearch(arr2, target);
        system.out.println("二分查找结果: " + (index != -1 ? "找到，下标为 " + index : "未找到"));
    }
}

输出：

冒泡排序结果: [2, 3, 4, 5, 8]
快速排序结果: [2, 3, 4, 5, 8]
二分查找结果: 找到，下标为 2

通过合理选择排序和查找算法，可以高效地处理数据。

十、异常

1. 异常的基本概念

• 异常在 java 中以类的方式存在，每个异常类都可以创建异常对象。
• 方法覆盖规则：子类重写父类方法时，不能抛出比父类方法更高的异常（运行时异常 runtimeexception 除外）。
• 异常的分类：
  • java.lang.throwable：异常的父类，有两个子类：
    • error：错误，通常是系统级错误（如 outofmemoryerror），不可处理，只能退出程序。
    • exception：异常，所有异常都是在运行阶段发生的。
      • exception 的直接子类：编译时异常（受检异常 checkedexception），需要在编写程序时预处理。
      • runtimeexception：运行时异常，通常由程序逻辑错误引起，不需要显式处理。

2. 常见运行时异常

• nullpointerexception：空指针异常，尝试访问 null 对象的成员。
• arrayindexoutofboundsexception：数组下标越界异常。
• classcastexception：类型转换异常，尝试将对象强制转换为不兼容的类型。
• numberformatexception：数字转换异常，尝试将非数字字符串转换为数字。

3. 异常处理方式

1. throws 关键字：

   • 在方法声明位置使用，将异常抛给调用者处理。

   • 示例：

     public void readfile() throws ioexception {
         // 可能抛出 ioexception 的代码
     }
     

2. try-catch-finally 语句：

   • 捕获并处理异常。

   • 示例：

     try {
         // 可能抛出异常的代码
     } catch (nullpointerexception e) {
         system.out.println("空指针异常: " + e.getmessage());
     } catch (arrayindexoutofboundsexception e) {
         system.out.println("数组下标越界: " + e.getmessage());
     } finally {
         // 无论是否发生异常，都会执行的代码
         system.out.println("finally 块执行");
     }
     

4. 常用异常方法

• getmessage()：获取异常的简单描述信息（通常是构造方法的参数）。
• printstacktrace()：打印异常的堆栈追踪信息（异步线程中常用）。

5. 自定义异常

• 步骤：

  1. 编写一个类继承 exception（受检异常）或 runtimeexception（运行时异常）。
  2. 提供两个构造方法：一个无参，一个有参。
  3. 使用 throw 手动抛出异常。

• 示例：

  // 自定义异常类
  public class myexception extends exception {
      public myexception() {
          super();
      }
  
      public myexception(string message) {
          super(message);
      }
  }
  
  // 使用自定义异常
  public class test {
      public static void main(string[] args) {
          try {
              throw new myexception("自定义异常发生");
          } catch (myexception e) {
              system.out.println(e.getmessage());
          }
      }
  }
  

6. 异常处理的最佳实践

• 明确异常类型：捕获具体异常，而不是直接捕获 exception。
• 合理使用 finally：用于释放资源（如关闭文件、数据库连接等）。
• 避免空指针异常：在使用对象前进行 null 检查。
• 日志记录：使用日志框架（如 log4j 或 slf4j）记录异常信息，便于排查问题。

总结

• 异常分类：error 和 exception，其中 exception 分为编译时异常和运行时异常。
• 处理方式：throws 抛给调用者，try-catch-finally 捕获并处理。
• 自定义异常：继承 exception 或 runtimeexception，提供构造方法，使用 throw 抛出。
• 最佳实践：明确异常类型，合理使用 finally，避免空指针异常，记录日志。

十一、i/o

i/o（输入/输出）概述

i/o（input/output）是指应用程序与外部设备（如磁盘、网络、键盘、显示器等）之间的数据交互。java通过java.io包提供了丰富的i/o类库，支持文件操作、字节流、字符流等功能。

file类

file类是java.io包中唯一代表磁盘文件本身的对象，用于操作文件和目录。

构造方法

1. file(string path)：

   • 根据路径创建file对象。

2. file(string parent, string child)：

   • 根据父路径和子路径（包括文件名）创建file对象。

3. file(file parent, string child)：

   • 根据file对象表示的父路径和子路径创建file对象。

注意：路径分隔符可以使用\\（windows）或/（unix/linux）。

常用方法

1. boolean exists()：

   • 判断文件或目录是否存在。

2. boolean delete()：

   • 删除文件或目录。

3. boolean createnewfile()：

   • 如果文件不存在，则创建一个新文件。

4. string getname()：

   • 返回文件或目录的名称。

5. string getpath()：

   • 返回文件或目录的路径。

6. string getabsolutepath()：

   • 返回文件或目录的绝对路径。

7. boolean canread()：

   • 判断文件是否可读。

8. boolean canwrite()：

   • 判断文件是否可写。

9. boolean isfile()：

   • 判断是否为文件。

10. boolean isdirectory()：

    • 判断是否为目录。

11. long length()：

    • 返回文件内容的长度（字节数）。

12. string[] list()：

    • 返回目录内所有文件和子目录的名称。

13. file[] listfiles()：

    • 返回目录内所有文件和子目录的file对象。

14. createtempfile(string prefix, string suffix)：

    • 创建临时文件。

15. deleteonexit()：

    • jvm退出时自动删除文件。

字节流

字节流用于处理二进制数据（如图片、音频、视频等），以字节为单位进行读写操作。

字节输入流（inputstream）

inputstream是字节输入流的抽象类，用于从源（如文件、网络等）读取数据。

常用方法：

1. int read()：

   • 逐个字节读取，返回读取的字节值（0-255），如果到达流末尾则返回-1。

2. int read(byte[] b)：

   • 将数据读取到字节数组b中，返回实际读取的字节数。

3. int read(byte[] b, int off, int len)：

   • 从偏移量off开始，读取len个字节到数组b中，返回实际读取的字节数。

4. void close()：

   • 关闭流，释放资源。

字节输出流（outputstream）

outputstream是字节输出流的抽象类，用于将数据写入目标（如文件、网络等）。

常用方法：

1. void write(int b)：

   • 逐个字节写入。

2. void write(byte[] b)：

   • 将字节数组b中的数据写入。

3. void write(byte[] b, int off, int len)：

   • 从偏移量off开始，写入len个字节。

4. void flush()：

   • 强制将缓冲区中的数据写入目标。

5. void close()：

   • 关闭流，释放资源。

具体实现类

1. fileinputstream：

   • 用于从文件中读取字节数据。

2. fileoutputstream：

   • 用于将字节数据写入文件。

拓展总结

1. 文件操作：

   • 使用file类可以创建、删除、重命名文件，判断文件是否存在，查询文件属性等。

2. 字节流：

   • 字节流适用于处理二进制数据，inputstream和outputstream是字节流的抽象基类。
   • fileinputstream和fileoutputstream是常用的字节流实现类，用于文件的读写操作。

3. 流的使用注意事项：

   • 使用流时，务必在操作完成后调用close()方法关闭流，释放系统资源。
   • 对于输出流，可以调用flush()方法强制将缓冲区中的数据写入目标。

4. 临时文件：

   • 使用createtempfile()方法可以创建临时文件，deleteonexit()方法可以确保jvm退出时自动删除临时文件。

5. 路径处理：

   • 路径分隔符可以使用\\（windows）或/（unix/linux），java会自动处理。

6. 性能优化：

   • 对于大文件的读写，建议使用缓冲区（如bufferedinputstream和bufferedoutputstream）来提高性能。

示例代码

文件操作

file file = new file("test.txt");
if (!file.exists()) {
    file.createnewfile(); // 创建文件
}
system.out.println("文件名称: " + file.getname());
system.out.println("文件路径: " + file.getabsolutepath());
file.delete(); // 删除文件

字节流读写

// 写入文件
try (fileoutputstream fos = new fileoutputstream("output.txt")) {
    fos.write("hello, world!".getbytes());
    fos.flush();
}

// 读取文件
try (fileinputstream fis = new fileinputstream("output.txt")) {
    byte[] buffer = new byte[1024];
    int len;
    while ((len = fis.read(buffer)) != -1) {
        system.out.println(new string(buffer, 0, len));
    }
}

通过掌握这些核心概念和类库，可以高效地处理文件操作和字节流读写。

字符流总结

字符流是java i/o中用于处理文本数据的流，它以字符为单位进行读写操作。与字节流不同，字符流专门用于处理字符数据（如文本文件），并且支持字符编码（如utf-8、gbk等），能够正确处理多字节字符。

字符流概述

字符流的核心类是reader和writer，它们分别是字符输入流和字符输出流的抽象基类。字符流的主要特点包括：

1. 以字符为单位：
   • 字符流以字符为单位读写数据，适合处理文本文件。
2. 支持字符编码：
   • 字符流可以正确处理字符编码，避免乱码问题。
3. 高效读写：
   • 字符流通常与缓冲区结合使用（如bufferedreader和bufferedwriter），提高读写效率。

字符输入流（reader）

reader是字符输入流的抽象类，用于从源（如文件、字符串等）读取字符数据。

常用方法

1. int read()：

   • 读取单个字符，返回字符的unicode值（0-65535），如果到达流末尾则返回-1。

2. int read(char[] cbuf)：

   • 将字符数据读取到字符数组cbuf中，返回实际读取的字符数。

3. int read(char[] cbuf, int off, int len)：

   • 从偏移量off开始，读取len个字符到数组cbuf中，返回实际读取的字符数。

4. void close()：

   • 关闭流，释放资源。

具体实现类

1. filereader：

   • 用于从文件中读取字符数据。

2. bufferedreader：

   • 带有缓冲区的字符输入流，提供readline()方法逐行读取文本。

3. inputstreamreader：

   • 将字节流转换为字符流，支持指定字符编码。

字符输出流（writer）

writer是字符输出流的抽象类，用于将字符数据写入目标（如文件、控制台等）。

常用方法

1. void write(int c)：

   • 写入单个字符。

2. void write(char[] cbuf)：

   • 写入字符数组cbuf中的数据。

3. void write(char[] cbuf, int off, int len)：

   • 从偏移量off开始，写入len个字符。

4. void write(string str)：

   • 写入字符串str。

5. void write(string str, int off, int len)：

   • 从偏移量off开始，写入len个字符。

6. void flush()：

   • 强制将缓冲区中的数据写入目标。

7. void close()：

   • 关闭流，释放资源。

具体实现类

1. filewriter：

   • 用于将字符数据写入文件。

2. bufferedwriter：

   • 带有缓冲区的字符输出流，提供newline()方法写入换行符。

3. outputstreamwriter：

   • 将字节流转换为字符流，支持指定字符编码。

字符流与字节流的区别

1. 单位不同：

   • 字节流以字节为单位，适合处理二进制数据。
   • 字符流以字符为单位，适合处理文本数据。

2. 编码支持：

   • 字节流不涉及字符编码，直接处理字节数据。
   • 字符流支持字符编码，能够正确处理多字节字符。

3. 性能优化：

   • 字符流通常与缓冲区结合使用，提高读写效率。

示例代码

字符流读写文件

// 写入文件
try (filewriter fw = new filewriter("output.txt");
     bufferedwriter bw = new bufferedwriter(fw)) {
    bw.write("hello, world!");
    bw.newline(); // 写入换行符
    bw.write("this is a test.");
}

// 读取文件
try (filereader fr = new filereader("output.txt");
     bufferedreader br = new bufferedreader(fr)) {
    string line;
    while ((line = br.readline()) != null) {
        system.out.println(line);
    }
}

使用指定编码读写文件

// 写入文件（指定编码为utf-8）
try (outputstreamwriter osw = new outputstreamwriter(new fileoutputstream("output.txt"), "utf-8");
     bufferedwriter bw = new bufferedwriter(osw)) {
    bw.write("你好，世界！");
}

// 读取文件（指定编码为utf-8）
try (inputstreamreader isr = new inputstreamreader(new fileinputstream("output.txt"), "utf-8");
     bufferedreader br = new bufferedreader(isr)) {
    string line;
    while ((line = br.readline()) != null) {
        system.out.println(line);
    }
}

总结

1. 字符流适用场景：

   • 处理文本文件、字符串等字符数据。

2. 核心类：

   • reader和writer是字符流的抽象基类。
   • filereader、bufferedreader、filewriter、bufferedwriter是常用的实现类。

3. 字符编码：

   • 使用inputstreamreader和outputstreamwriter可以指定字符编码，避免乱码问题。

4. 性能优化：

   • 使用bufferedreader和bufferedwriter可以提高读写效率。

5. 流关闭：

   • 使用try-with-resources语法确保流被正确关闭，释放资源。

通过掌握字符流的核心概念和类库，可以高效地处理文本数据的读写操作。

十二、集合

集合是java中用于存储和管理一组对象的容器。它提供了一种更灵活、更高效的方式来操作数据集合。以下是集合的核心概念和总结：

集合的特点

1. 容器性质：

   • 集合是一个容器，可以容纳其他类型的数据。
   • 集合不能直接存储基本数据类型（如int、char等），也不能直接存储对象，存储的是java对象的内存地址（引用）。

2. 数据结构：

   • 不同的集合对应不同的数据结构（如数组、链表、哈希表、二叉树等）。
   • 使用不同的集合等同于使用了不同的数据结构。

3. 包位置：

   • 所有的集合类都位于java.util包中。

集合的层次结构

1. 超级父接口：iterable<t>：

   • 所有集合都是可迭代的，即可以通过迭代器遍历集合中的元素。
   • 方法：iterator<t> iterator()：返回集合的迭代器。

2. 单个元素集合的父接口：collection<e>：

   • 表示存储单个元素的集合的超级接口。
   • 子接口包括：list、set、queue等。

3. 键值对集合的父接口：map<k,v>：

   • 表示存储键值对的集合，独立于collection体系。

集合的实现类总结

1.list接口的实现类：

• arraylist：
  • 底层是数组，查询快，增删慢。
  • 非线程安全。
• linkedlist：
  • 底层是双向链表，增删快，查询慢。
  • 非线程安全。
• vector：
  • 底层是数组，线程安全，但效率较低，使用较少。

2.set接口的实现类：

• hashset：
  • 底层是hashmap，元素存储在hashmap的key部分。
  • 无序且不允许重复。
• treeset：
  • 底层是treemap，元素存储在treemap的key部分。
  • 元素自动按大小顺序排序。

3.map接口的实现类：

• hashmap：
  • 底层是哈希表，非线程安全。
  • 允许null键和null值。
• hashtable：
  • 底层是哈希表，线程安全，但效率较低，使用较少。
  • 不允许null键和null值。
• properties：
  • 底层是哈希表，线程安全。
  • key和value只能存储字符串（string）。
• treemap：
  • 底层是二叉树。
  • key自动按照大小顺序排序。

集合的选择

1. 需要存储单个元素：

   • 如果需要有序且允许重复，使用list：
     • 查询多，增删少：arraylist。
     • 增删多，查询少：linkedlist。
   • 如果不需要重复元素，使用set：
     • 无序：hashset。
     • 有序：treeset。

2. 需要存储键值对：

   • 非线程安全：hashmap。
   • 线程安全：hashtable或properties。
   • 需要排序：treemap。

3. 线程安全：

   • 如果需要线程安全，可以使用vector、hashtable或properties，但效率较低。
   • 推荐使用collections.synchronizedlist()或concurrenthashmap等并发集合。

总结

1. 集合的核心：

   • 集合是存储和管理一组对象的容器，存储的是对象的内存地址。
   • 不同的集合对应不同的数据结构，选择合适的集合可以提高程序效率。

2. 常用集合：

   • list：有序且允许重复，常用arraylist和linkedlist。
   • set：无序且不允许重复，常用hashset和treeset。
   • map：存储键值对，常用hashmap、treemap和properties。

3. 线程安全：

   • 线程安全的集合有vector、hashtable和properties，但效率较低。
   • 推荐使用并发集合（如concurrenthashmap）来实现线程安全。

通过掌握集合的核心概念和常用实现类，可以更高效地处理数据集合，并根据需求选择合适的集合类型。

list 集合存储元素的特点：

有序可重复

有序：存进去的顺序和取出的顺序相同，每一个元素都有下标

可重复：存进去1，可以再存储一个1

set 集合存储元素的特点（map的key）：

无序不可重复

无序：存进去的顺序和取出的顺序不一定相同，另外 set 集合中元素没有下标（哈希表的存储）

不可重复：存进去1，不能再存储1了（哈希表的覆盖）

sortedset( sortedmap ）集合存储元素特点：

首先是无序不可重复的，但是 sortedset 集合中的元素是可排序的

无序：存进去的顺序和取出的顺序不一定相同，另外 set 集合中元素没有下标

不可重复：存进去1，不能再存储1了

可排序：可以按照大小顺序排列。

map 集合的 key ，就是一个 set 集合。

往 set 集合中放数据，实际上放到了 map 集合的 key 部分。

interfacecollection

没有使用泛型前可以存储object的所有子类型

• boolean add(e e) 添加元素
• object[] toarray() 转化成数组（使用不多）
• int size() 返回此集合中元素的数目。
• boolean contains(object o) 如果此集合包含指定的元素（存放在集合中的类型，需要重写equals方法）
• void clear() 从此集合中删除所有元素
• boolean equals(object o) 将指定的对象与此集合进行比较以实现相等性（内存地址）
• boolean remove(object o) 从此集合中删除指定元素的单个实例
• boolean isempty() 如果此集合不包含任何元素（判空）则返回。true

iterator<e> iterator() ***：**不管存进去什么，拿出来都是object，取出来还是原类型

返回此集合中元素的迭代器**，collection通用，map集合不能用**

只要集合结构发生改变迭代器一定要重新获取

• default void foreachremaining(consumer<? super e> action) 对每个剩余元素执行给定的操作，直到所有元素都已处理完毕或该操作引发异常。
• boolean hasnext() 如果迭代具有更多元素，则返回。true
• object next() 返回迭代中的下一个元素。（返回object）
• default void remove() 从基础集合中删除此迭代器返回的最后一个元素（可选操作）。

interface list有序可重复，collection子接口

• void add(int index, e element) 在此列表中的指定位置插入指定的元素
• e get(int index) 返回此列表中指定位置处的元素
• e set(int index, e element) 将此列表中指定位置的元素替换为指定的元素
• int indexof(object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含该元素，则返回 -1
• int lastindexof(object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含该元素，则返回 -1。
• e remove(int index) 删除此列表中指定位置的元素

class arraylist 非线程安全数组，初始化容量10，底层object数组

构造方法：

• arraylist() 构造初始容量为 10 的空列表（底层先创建了一个长度为0的数组，添加元素是初始化为10，自动扩容1.5倍）
• arraylist(int initialcapacity) 构造具有指定初始容量的空列表（建议提前估计，减少扩容）
• arraylist(collection<? extends e> c) 构造一个列表，其中包含指定集合的元素，并按集合的迭代器返回这些元素的顺序排列。

方法：同list方法

class linkedlist 双向链表，随机增删效率高，检索效率低

class vector 线程安全数组，默认10，扩容翻倍**（不经常使用）**

转换：使用集合工具类：java.util.collections.synchronizedlist(集合)

interface set无序不可重复存储map的key

class hashset 哈希表（底层hashmap）

需要重写hashcode和equals方法，其他方法参见hashmap

interface sortedset无序不可重复可排序

class treeset 二叉树（底层treemap key部分）无序不可重复可排序

key值自定义类需要实现java.long.comparable接口或者创建比较器对象

class user implements comparable<user>{      //自定义类需要实现接口
  int age;

  public user(int age) {
    this.age = age;
  }


 @override
  public string tostring() {
    return "user{" + "age=" + age + '}';
  }
  @override         //重写比较规则
  public int compareto(user o) {
    return this.age-o.age;    //返回==0，value覆盖，返回大于0 到右子树，返回小于0到左子树
  }
}

interface map<k,v>map主接口（和collection没有继承关系）

以key和value存储数据都是引用数据类型，都存储内存地址，key是主导

• v put(k key, v value) 添加键值对（key元素需要重新hashcode和equals方法）（key可以为空，只有一个）
• void clear() 清空map集合
• v get(object key) 通过key获取value（key元素需要重新hashcode和equals方法）
• boolean containskey(object key) 判断map是否包含某个key（底层equals）
• boolean containsvalue(object value) 判断map是否包含某个value（底层equals）
• boolean isempty() 判断map集合元素个数是否为零
• set<k> keyset() 获取map集合所有的key（是个set集合）
• v remove(object key) 通过key删除键值对
• collection<v> values() 获取map集合中键值对所有value（返回collection）
• int size() 获取map集合所有的键值对个数

set<map.entry<integer,string>>set1=m.entryset();       //使用方法
iterator<map.entry<integer,string>> it=set1.iterator(); //获取迭代器
while (it.hasnext()) {
  map.entry<integer, string> entry = it.next();
  system.out.println(entry);     //直接遍历
  integer key = entry.getkey();    //获取键
  string value = entry.getvalue();    //获取值
  system.out.println(key + "=" + value);   //分开遍历

for(map.entry<integer,string> node:set1)   //效率较高，适合大数据，直接获取
  system.out.println(node);     //组合遍历

class hashmap<k,v> 哈希表 非线程安全（初始化容量16[必须是2的倍数]，默认加载因子0.75）

key元素类型需要重新hashcode和equals方法

jdk8新特性：当单向链表长度超过8后数据结构会变成红黑树数据结构，当红黑树小于6，会变回链表

构造 函数 描述

• hashmap() 使用默认初始容量 （16） ，默认负载系数 （0.75）
• hashmap(int initialcapacity) 指定的初始容量，默认负载系数 初始容量必须是2的倍数：达到散列均匀，提高存取效率
• hashmap(int initialcapacity, float loadfactor) 指定初始容量和负载系数
• hashmap(map<? extends k,? extends v> m)

class hashtable<k,v> 哈希表 线程安全（synchronized） key不可以为空*（不常用）**

初始化容量11，默认加载因子0.75f，扩容：原容量*2+1

class properties 属性类 继承hashtable类 仅支持string

• object setproperty(string key, string value) 存
• string getproperty(string key) 取
• string getproperty(string key, string defaultvalue) 当key值为null时,返回def的值；当key值不为null时,返回key的值

interface sortedmap<k,v>

class treemap<k,v> 二叉树 可排序集合（中序遍历）

key值自定义类需要实现java.long.comparable接口或者创建比较器对象（类或者匿名内部类）

class collections 集合工具类

• synchronizedmap(map<k,v> m) 返回由指定映射支持的同步（线程安全）映射。
• synchronizedlist(list list) 返回由指定列表支持的同步（线程安全）列表。**
  **synchronizedcollection(collection c) 返回由指定集合支持的同步（线程安全）集合
• sort(list list, comparator<? super t> c) 根据指定比较器引发的顺序对指定列表进行排序。

十三、泛型

1. 泛型概述

• 引入时间：jdk 5.0 之后的新特性。

• 作用：

  • 统一集合中元素的类型，避免类型转换错误。
  • 只在程序编译阶段起作用，编译后会进行类型擦除（type erasure）。

• 语法：

  • 在创建对象时，前后两段添加泛型类型。

  • 示例：

    list<string> list = new arraylist<string>();
    

2. 泛型的优点

• 类型安全：编译时检查类型，避免运行时类型转换错误。
• 代码复用：可以编写通用的类和方法，适用于多种类型。
• 代码简洁：减少强制类型转换的代码。

3. 泛型的缺点

• 导致集合存储缺少多样性：泛型限制了集合中元素的类型，无法存储多种类型的对象。
• 类型擦除：泛型信息在编译后会被擦除，运行时无法获取泛型的具体类型。

4. 自动推断机制（钻石表达式）

• 引入时间：jdk 7 新特性。

• 作用：自动推断泛型类型，简化代码。

• 语法：只写前面的泛型类型，后面的泛型类型可以省略。

• 示例：

  list<string> list = new arraylist<>();
  

5. 自定义泛型

• 泛型类：

  • 在定义类时添加 <t>，t 是类型参数。

  • 示例：

    public class box<t> {
        private t value;
    
        public void setvalue(t value) {
            this.value = value;
        }
    
        public t getvalue() {
            return value;
        }
    }
    

  • 使用：

    box<string> box = new box<>();
    box.setvalue("hello");
    string value = box.getvalue();
    

• 泛型方法：

  • 在定义方法时添加 <t>，t 是类型参数。

  • 示例：

    public <t> void printarray(t[] array) {
        for (t element : array) {
            system.out.println(element);
        }
    }
    

  • 使用：

    integer[] intarray = {1, 2, 3};
    printarray(intarray);
    

6. 泛型的通配符

• <?>：表示任意类型。

• <? extends t>：表示 t 或其子类型（上界通配符）。

• <? super t>：表示 t 或其父类型（下界通配符）。

• 示例：

  public void printlist(list<?> list) {
      for (object element : list) {
          system.out.println(element);
      }
  }
  

7. 泛型的限制

• 不能使用基本类型：泛型类型必须是引用类型（如 integer 而不是 int）。
• 不能创建泛型数组：例如 new t[10] 是非法的。
• 不能实例化泛型类型：例如 new t() 是非法的。

8. 泛型的应用场景

• 集合框架：如 list<t>、map<k, v> 等。
• 工具类：如 comparator<t>、comparable<t> 等。
• 自定义数据结构：如栈、队列、链表等。

总结与拓展

• 泛型的作用：统一集合中元素的类型，提高代码的安全性和复用性。
• 自动推断机制：jdk 7 引入的钻石表达式简化了泛型代码。
• 自定义泛型：通过泛型类和泛型方法实现通用代码。
• 通配符：<?>、<? extends t>、<? super t> 提供了更灵活的类型约束。
• 限制：泛型不能使用基本类型、不能创建泛型数组、不能实例化泛型类型。

十四、多线程

进程是:一个应用程序（1个进程是一个软件）

独立性：系统分配资源和调度资源的独立单位

动态性：进程实质是程序的一次执行过程，进程是动态产生，动态消亡的

并发性：任何进程都可以同其他进程一起并发执行

线程是：一个进程中的执行场景/执行单元，是进程中单个顺序控制流，是一条执行路径。

并行：同一时刻，多个指令在多个cpu上同时执行

并发：同一时刻，多个指令在单个cpu交替执行

线程状态转换

1、新建状态（new）：新创建了一个线程对象。

2、就绪状态（runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取cpu的使用权。

3、运行状态（running）：就绪状态的线程获取了cpu，执行程序代码。

4、阻塞状态（blocked）：阻塞状态是线程因为某种原因放弃cpu使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

（一）、等待阻塞：运行的线程执行wait()方法，jvm会把该线程放入等待池中。(wait会释放持有的锁)

（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则jvm会把该线程放入锁池中。

（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了i/o请求时，jvm会把该线程置为阻塞状态

当sleep()状态超时、join()等待线程终止或者超时、或者i/o处理完毕时，线程重新转入就绪状态。（注意,sleep是不会释放持有的锁）

5、死亡状态（dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

线程构造方法：

java 中实现线程的三种方式总结

1. 继承thread类

• 实现方式：

  • 编写一个类，直接继承 java.lang.thread。
  • 重写 run() 方法，定义线程执行的任务。

• 创建线程对象：

  mythread thread = new mythread();
  

• 启动线程：

  thread.start();
  

• 特点：

  • 简单易用，但 java 是单继承，继承 thread 类后无法继承其他类。

2. 实现runnable接口

• 实现方式：

  • 编写一个类，实现 java.lang.runnable 接口。
  • 实现 run() 方法，定义线程执行的任务。
  • 通常使用匿名内部类创建。

• 创建线程对象：

  runnable task = new myrunnable();
  thread thread = new thread(task);
  

• 启动线程：

  thread.start();
  

• 特点：

  • 更灵活，可以避免单继承的限制。
  • 适合多个线程共享同一个任务。

3. 使用callable和future接口

• 实现方式：

  • 编写一个类，实现 java.util.concurrent.callable 接口。
  • 实现 call() 方法，定义线程执行的任务，并返回结果。

• 创建线程对象：

  1. 创建 callable 实现类的实例：

     callable<integer> task = new mycallable();
     

  2. 使用 futuretask 包装 callable 对象：

     futuretask<integer> futuretask = new futuretask<>(task);
     

  3. 使用 futuretask 对象作为 thread 的 target 创建线程：

     thread thread = new thread(futuretask);
     

• 启动线程：

  thread.start();
  

• 获取结果：

  integer result = futuretask.get(); // 阻塞直到获取结果
  

• 特点：

  • call() 方法可以有返回值和抛出异常。
  • 适合需要获取线程执行结果的场景。

future接口的常用方法

• cancel(boolean mayinterruptifrunning)：尝试取消任务。
• get()：获取任务结果，阻塞直到任务完成。
• get(long timeout, timeunit unit)：在指定时间内获取任务结果，超时抛出 timeoutexception。
• iscancelled()：判断任务是否被取消。
• isdone()：判断任务是否完成。

三种方式的对比

总结

• 继承 thread 类：适合简单的线程任务，但受限于单继承。
• 实现 runnable 接口：更灵活，适合多线程共享任务。
• 使用 callable 和 future：适合需要获取线程执行结果或处理异常的场景。

根据具体需求选择合适的方式实现多线程编程。

获取当前线程对象、获取线程对象名字、修改线程对象名字

关于线程的sleep方法

关于线程中断sleep()的方法

java进程的优先级

方法：

多线程并发环境下，数据的安全问题（重点）

1.为什么这个是重点？

以后在开发中，我们的项目都是运行在服务器当中，而服务器已经将线程的定义，线程对象的创建，线程的启动等，都已经实现完了。这些代码我们都不需要编写。

最重要的是： 你要知道，你编写的程序需要放到一个多线程的环境下运行，你更需要关注的是这些数据在多线程并发的环境下是否是安全的。（重点：★★★★★）

2.什么时候数据在多线程并发的环境下会存在安全问题呢？★★★★★

满足三个条件：

条件1：多线程并发。

条件2：有共享数据。

条件3：共享数据有修改的行为。

满足以上3个条件之后，就会存在线程安全问题。

3.怎么解决线程安全问题呢？

当多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在线程安全问题，怎么解决这个问题？

线程排队执行。（不能并发）。用排队执行解决线程安全问题。

这种机制被称为：线程同步机制。专业术语叫做：线程同步，实际上就是线程不能并发了，线程必须排队执行。

线程同步就是线程排队了，线程排队了就会 牺牲一部分效率 ，数据安全第一位，只有数据安全了，我们才可以谈效率。数据不安全，没有效率的事儿。

死锁（deadlock）

死锁（deadlock）是多线程编程中的一种常见问题，指的是两个或多个线程在执行过程中，因为争夺资源而造成的一种互相等待的现象，导致这些线程都无法继续执行下去。

死锁代码要会写。一般面试官要求你会写。只有会写的，才会在以后的开发中注意这个事儿。因为死锁很难调试。

死锁的四个必要条件

死锁的发生必须同时满足以下四个条件：

1. 互斥条件（mutual exclusion）：

   • 资源一次只能被一个线程占用。

2. 占有并等待（hold and wait）：

   • 线程已经占有了至少一个资源，但又申请新的资源，而新的资源被其他线程占用。

3. 不可抢占（no preemption）：

   • 线程已占有的资源不能被其他线程强行抢占，必须由线程自己释放。

4. 循环等待（circular wait）：

   • 存在一个线程的等待循环链，每个线程都在等待下一个线程所占用的资源。

java 中的死锁示例

以下是一个经典的死锁代码示例，展示了两个线程互相等待对方释放锁的情况：

public class deadlockexample {
    private static final object lock1 = new object();
    private static final object lock2 = new object();

    public static void main(string[] args) {
        thread thread1 = new thread(() -> {
            synchronized (lock1) {
                system.out.println("thread 1: holding lock 1...");
                try {
                    thread.sleep(100); // 模拟操作
                } catch (interruptedexception e) {
                    e.printstacktrace();
                }
                system.out.println("thread 1: waiting for lock 2...");
                synchronized (lock2) {
                    system.out.println("thread 1: acquired lock 2!");
                }
            }
        });

        thread thread2 = new thread(() -> {
            synchronized (lock2) {
                system.out.println("thread 2: holding lock 2...");
                try {
                    thread.sleep(100); // 模拟操作
                } catch (interruptedexception e) {
                    e.printstacktrace();
                }
                system.out.println("thread 2: waiting for lock 1...");
                synchronized (lock1) {
                    system.out.println("thread 2: acquired lock 1!");
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

代码分析

1. 线程1：

   • 先获取lock1，然后尝试获取lock2。
   • 在获取lock2之前，线程1会休眠100毫秒。

2. 线程2：

   • 先获取lock2，然后尝试获取lock1。
   • 在获取lock1之前，线程2会休眠100毫秒。

3. 死锁发生：

   • 线程1持有lock1并等待lock2。
   • 线程2持有lock2并等待lock1。
   • 两个线程互相等待，导致死锁。

如何避免死锁

1. 避免嵌套锁：

   • 尽量不要在持有一个锁的同时去申请另一个锁。

2. 按顺序获取锁：

   • 如果多个线程需要获取多个锁，确保它们以相同的顺序获取锁。

3. 使用超时机制：

   • 在获取锁时设置超时时间，如果超时则释放已持有的锁并重试。

4. 使用工具检测：

   • 使用工具（如jstack）检测死锁。

死锁的调试与检测

1. 使用jstack：

   • 运行程序后，使用jstack命令查看线程状态，可以检测到死锁。

2. 日志输出：

   • 在代码中添加日志，记录锁的获取和释放情况。

3. 使用工具：

   • 使用ide（如intellij idea）或第三方工具（如visualvm）检测死锁。

守护线程

在java中，线程分为两大类：用户线程和守护线程。守护线程（daemon thread）是一种特殊的线程，它的生命周期依赖于用户线程。当所有的用户线程结束时，守护线程会自动退出。

守护线程的特点

1. 依赖用户线程：

   • 守护线程是为用户线程提供服务的线程。
   • 当所有的用户线程结束时，守护线程会自动退出。

2. 典型代表：

   • 垃圾回收线程（gc）是java中最典型的守护线程。

3. 主线程是用户线程：

   • main方法所在的线程是用户线程。

4. 死循环：

   • 守护线程通常是一个死循环，持续执行某些后台任务。

守护线程的应用场景

1. 定时任务：

   • 例如，每天00:00自动备份系统数据。
   • 可以使用定时器（如timer或scheduledexecutorservice），并将定时任务设置为守护线程。

2. 后台监控：

   • 例如，监控系统资源使用情况、日志清理等。

3. 垃圾回收：

   • java的垃圾回收线程就是一个守护线程。

守护线程的设置

在java中，可以通过setdaemon(boolean on)方法将一个线程设置为守护线程：

注意：

• 必须在调用start()方法之前设置守护线程，否则会抛出illegalthreadstateexception。
• 守护线程中创建的子线程默认也是守护线程。

代码示例

以下是一个守护线程的示例，展示了如何设置守护线程以及它的行为：

public class daemonthreadexample {
    public static void main(string[] args) {
        thread daemonthread = new thread(() -> {
            while (true) {
                system.out.println("守护线程正在运行...");
                try {
                    thread.sleep(1000); // 模拟任务执行
                } catch (interruptedexception e) {
                    e.printstacktrace();
                }
            }
        });

        // 设置为守护线程
        daemonthread.setdaemon(true);

        // 启动守护线程
        daemonthread.start();

        // 主线程（用户线程）执行任务
        system.out.println("主线程开始执行...");
        try {
            thread.sleep(5000); // 模拟主线程执行任务
        } catch (interruptedexception e) {
            e.printstacktrace();
        }
        system.out.println("主线程执行完毕，程序退出。");
    }
}

代码分析

1. 守护线程：

   • 守护线程是一个死循环，每隔1秒输出一条消息。
   • 设置为守护线程后，当主线程结束时，守护线程会自动退出。

2. 主线程：

   • 主线程执行5秒后结束。
   • 主线程结束后，守护线程也会自动退出。

守护线程的注意事项

1. 资源释放：

   • 守护线程中不要执行关键任务（如文件写入、数据库操作等），因为它的退出是不可控的。

2. 线程优先级：

   • 守护线程的优先级通常较低，适合执行后台任务。

3. 生命周期：

   • 守护线程的生命周期依赖于用户线程，不能独立存在。

定时器的作用：

间隔特定的时间，执行特定的程序。在实际的开发中，每隔多久执行一段特定的程序，这种需求是很常见的，那么在java中其实可以采用多种方式实现：

可以使用sleep方法，睡眠，设置睡眠时间，没到这个时间点醒来，执行任务。这种方式是最原始的定时器。（比较low）

在java的类库中已经写好了一个定时器：java.util.timer，可以直接拿来用。

不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时任务的。

在实际的开发中，目前使用较多的是spring框架中提供的springtask框架，这个框架只要进行简单的配置，就可以完成定时器的任务。

关于object类的wait()、notify()、notifyall()方法

wait和notify方法不是线程对象的方法，是java中任何一个java对象都有的方法，因为这两个方法是 object类中自带 的。

wait方法和notify方法不是通过线程对象调用

调用：

object o = new object();

o.wait();

总结 ★★★★★（呼应生产者消费者模式）

1、wait和notify方法不是线程对象的方法，是普通java对象都有的方法。

2、wait方法和notify方法建立在 线程同步 的基础之上。因为多线程要同时操作一个仓库。有线程安全问题。

3、wait方法作用：o.wait() 让正在o对象上活动的线程t进入等待状态，并且释放掉t线程之前占有的o对象的锁

4、notify方法作用：o.notify() 让正在o对象上等待的线程唤醒，只是通知，不会释放o对象上之前占有的锁。

生产者消费者模式（wait()和notify()）

什么是“生产者和消费者模式”？

生产线程负责生产，消费线程负责消费。

生产线程和消费线程要达到均衡。

这是一种特殊的业务需求，在这种特殊的情况下需要使用wait方法和notify方法。

模拟一个业务需求

仓库我们采用list集合。

list集合中假设只能存储1个元素。

1个元素就表示仓库满了。

如果list集合中元素个数是0，就表示仓库空了。

保证list集合中永远都是最多存储1个元素。

必须做到这种效果：生产1个消费1个。

十五、反射

1. class 对象概述

• class 对象：在 java 中，每个类在加载到内存时都会生成一个 class 对象，该对象存储了类的所有信息（如方法、构造函数、字段等）。
• 反射：通过 class 对象，可以在运行时动态获取类的信息并操作类的成员（如调用方法、访问字段等）。

2. class 对象的生成方式

1. 类名.class：

   • jvm 将类加载到内存中，但不进行初始化。

   • 返回该类的 class 对象。

   • 示例：

     class<?> clazz = string.class;
     

2. class.forname("包名.类名")：

   • 加载类并默认进行静态初始化。

   • 返回该类的 class 对象。

   • 示例：

     class<?> clazz = class.forname("java.lang.string");
     

3. class.forname("包名.类名", false, 类加载器)：

   • 第二个参数为 false 时，不进行初始化；为 true 时，进行初始化。

   • 示例：

     class<?> clazz = class.forname("java.lang.string", false, classloader.getsystemclassloader());
     

4. 实例对象.getclass()：

   • 对类进行静态初始化和非静态初始化。

   • 返回运行时实际对象所属类的 class 对象。

   • 示例：

     string str = "hello";
     class<?> clazz = str.getclass();
     

3. class 对象的特性

• 父子类 class 对象不一致：
  • 如果 a 是 b 的子类，则 a.class 和 b.class 返回的 class 对象不同。
  • 如果 a 是 a 的实例，则 a.class 和 a.getclass() 返回的 class 对象一致。

4. class 类的常用方法

• getname()：返回类的全限定名（包名 + 类名）。
• getsuperclass()：返回类的直接父类的 class 对象。
• getinterfaces()：返回类实现的所有接口的 class 数组。
• isarray()：判断该类是否是数组类型。
• isenum()：判断该类是否是枚举类型。
• isinterface()：判断该类是否是接口。
• isprimitive()：判断该类是否是基本类型（如 int、boolean 等）。
• isassignablefrom(class cls)：判断该类是否是 cls 的父类或父接口。
• getcomponenttype()：如果该类是数组类型，返回数组的组件类型。
• assubclass(class clazz)：将当前 class 对象转换为 clazz 的子类类型。

5.assubclass方法的使用

• 作用：将当前 class 对象转换为指定类的子类类型。

• 示例：

  list<string> strlist = new arraylist<>();
  class<? extends list> strlistcast = strlist.getclass().assubclass(list.class);
  

• 动态加载时的应用：

  class.forname("xxx.xxx.xxx").assubclass(list.class).newinstance();
  

  • 如果 xxx.xxx.xxx 是 list 的子类，则正常执行；否则抛出 classcastexception。

6. 静态加载与动态加载

• 静态加载：通过 new classname() 加载类，编译时必须提供类的定义。
• 动态加载：通过 class.forname("classname") 加载类，编译时可以缺席，运行时按需提供。

总结

• class 对象：存储类的所有信息，是反射机制的核心。
• 生成方式：类名.class、class.forname()、实例对象.getclass()。
• 常用方法：getname()、getsuperclass()、getinterfaces()、assubclass() 等。
• assubclass：用于将 class 对象转换为指定类的子类类型。
• 静态加载与动态加载：静态加载在编译时提供类定义，动态加载在运行时按需提供。

通过掌握 class 对象和反射机制，可以在运行时动态操作类的成员，实现灵活的编程。

十六、小游戏（进击的小鸟）

public class startgame {           //游戏开始类
  public static void main(string[] args) throws interruptedexception {
    jframe jframe = new jframe("进击の小鸟");  //创建窗口对象
    jframe.setsize(400,600);//窗口大小
    jframe.setlocationrelativeto(null); //窗口相对位置
    jframe.setdefaultcloseoperation(jframe.exit_on_close);//设定点击关闭结束程序

​    birdgame birdgame = new birdgame();  //初始化游戏对象类
​    jframe.add(birdgame);         //把创建好的对象加进来
​    jframe.setvisible(true);       //让窗口可视化
​    birdgame.action();          //地面运动方法

  }
}

public class bird {
  public bufferedimage images[];
  public bufferedimage image;   //存放小鸟图片
  public int x;
  public int y;
  public int width;
  public int height;
  public int index=0;
  public double speed=0;    //小鸟初始速度
  public double upspeed=30;  //初始上抛速度
  public double s=0;      //经过t，发生的位移
  public double t=0.2;     //发生位移时间
  public double g=9.8;     //重力加速度
  public bird() throws ioexception {
    x=120;
    y=120;
    images=new bufferedimage[8];
    image= imageio.read(getclass().getresource("0.png"));
    width=image.getwidth();
    height=image.getheight();
    for (int i=0;i<images.length;i++) {
      images[i] = imageio.read(getclass().getresource(i+".png"));
    }
  }


  public void fly(){      //小鸟飞飞
    index++;
    image=images[index/2%8];
  }
  public void upspeed(){    //鼠标点击游戏屏幕，给小鸟一个初始上抛速度
    speed=upspeed;
  }
  public void distancechange(){  //实现小鸟速度，位移，纵坐标变化
    double v=speed; //初始速度
    s=v*t-g*t*t/2;  //经过t小鸟的位移
    speed=v-g*t;   //小鸟经过时间t的末速度
    y=y-(int)s;      //经过时间t后，小鸟的y

  }
}

public class column {    //管道类
  public bufferedimage cimage;
  public int x;
  public  int y;
  public int width;
  public int height;
  public  int distance=270;  //两根管道之间的距离
  public static  int count=0;
  random random = new random();
  public column() throws ioexception {
    cimage= imageio.read(getclass().getresource("column.png"));
    x=450+distance*count;
    width=cimage.getwidth();   //获得管道的宽
    height=cimage.getheight();  //高
    y=-( height/2-random.nextint(300)-50);


    count++;
  }
  public void step(){
    x-=5; //让地面往左运动
    if (x<=-width/2){
      x=x+distance*2;
      y=-(height/2-random.nextint(300)-50) ;
      //x=400;
    }
  }
}

public class ground {  //地面类
  public bufferedimage image; //存放地面图片
  public int x;
  public int y;

  public ground() {

​    try {
​      x=0;
​      y=500;
​      image= imageio.read(getclass().getresource("ground.png"));
​    } catch (ioexception e) {
​      e.printstacktrace();
​    }
  }
  public void step(){
​    x-=1; //让地面往左运动
​    if (x==-100){
​      x=0;
​    }
  }
}

public class music implements runnable {    //音乐类
  player player=null;
  @override
  public void run() {
    inputstream resourceasstream = this.getclass().getresourceasstream("2.mp3");
    try {
      player=new player(resourceasstream);
      player.play();
    } catch (javalayerexception e) {
      e.printstacktrace();
    }

  }
  public void stopbgm(){
  if (player!=null)
      player.close();

  }
}

public class score {  //连接对象
  private string sid;
  private int score;
  private string time;

  public string getsid() {
    return sid;
  }

  public void setsid(string sid) {
    this.sid = sid;
  }

  public int getscore() {
    return score;
  }

  public void setscore(int score) {
    this.score = score;
  }

  public string gettime() {
    return time;
  }

  public void settime(string time) {
    this.time = time;
  }
}

public class scoremanager {   //jdbc连接
  static{
    try {
      class.forname("com.mysql.cj.jdbc.driver");
    } catch (classnotfoundexception e) {
      e.printstacktrace();
    }
  }
  public list<score> selectallscore(){     //查询方法
    list<score> list = new arraylist<>();

​    try {
​      string sql="select * from score order by time";
​      connection conn = drivermanager.getconnection("jdbc:mysql://cdb-kthncrwi.bj.tencentcdb.com:10159/flybird?useunicode=true", "student", "521qianfeng");
​      preparedstatement pst = conn.preparestatement(sql);
​      resultset resultset = pst.executequery();
​      while (resultset.next()){
​        score score = new score();
​        score.setsid(resultset.getstring("sid"));
​        score.setscore(resultset.getint("score"));
​        score.settime(resultset.getstring("time"));
​        list.add(score);
​      }
​    } catch (sqlexception e) {
​      e.printstacktrace();
​    }

​    return list;
  }
  public int insertscore(int score) {     //插入方法
​    int num = 0;
​    string sql = "insert into score(sid,score,time) value(?,?,?)";
​    try {
​      connection conn = drivermanager.getconnection("jdbc:mysql://cdb-kthncrwi.bj.tencentcdb.com:10159/flybird?useunicode=true", "student", "521qianfeng");
​      preparedstatement pst = conn.preparestatement(sql);
​      string sid= uuid.randomuuid().tostring();     //随机生成id
​      pst.setstring(1,sid);
​      pst.setint(2,score);
​      date date = new date();
​      simpledateformat simpledateformat = new simpledateformat("yyyy-mm-dd hh:mm:ss");     //创建时间类型对象
​      string time=simpledateformat.format(date);
​      pst.setstring(3,time);
​      num=pst.executeupdate();
​    } catch (sqlexception e) {
​      e.printstacktrace();
​    }
​    return num;

  }
}

public class birdgame extends jpanel {   //自定义面板类继承面板类
  scoremanager sc=new scoremanager();
  public jpanel jp=new jpanel();
  public bufferedimage bg;         //图片缓冲区（在显示图片前对图片进行操作 eg：.getwidth()宽，.getheight()高）
  public bufferedimage startbg;
  public bufferedimage overbg;
  public ground ground;
  public bird bird;
  public column columns[];
  public music music;

  string file="h:\\java程序\\小程序\\src\\小鸟\\png\\bg.png";

  public int state; //表示游戏状态
  public static final int start=0;   //开始
  public static final int running=1;  //运行
  public static final int gameover=2; //结束
  public static int score=0;      //初始积分

  public birdgame(){
    try {
      state=start;         //游戏初始为游戏开始状态
      ground=new ground();     //创建地面类对象，调用地面类构造方法
      bird = new bird();
      columns=new column[2];
      music = new music();
      for (int i=0;i<columns.length;i++){
        columns[i]=new column();
      }
      bg= imageio.read(getclass().getresource("bg.png")); //读取这张图片并把图片值赋给变量
      //bg=imageio.read(new file(file));
      //bg=imageio.read(new file("src/小鸟/png/bg.png"));
      startbg=imageio.read(getclass().getresource("start.png"));
      overbg=imageio.read(getclass().getresource("gameover.png"));
    } catch (ioexception e) {
      e.printstacktrace();
    }
   }



  @override
  public void paint(graphics g) {         //绘制一次的画画方法
    super.paint(g);               //调用画笔
    g.drawimage(bg,0,0,null);            //绘制背景（最后一个参数为观察者
    switch (state){
      case start:
        //绘制游戏开始图片
        settishi(g);
        g.drawimage(startbg,0,0,null);

​        break;
​      case running:
​        for (int i=0;i<columns.length;i++) {
​          g.drawimage(columns[i].cimage, columns[i].x, columns[i].y, null);
​        }
​        break;
​      case gameover:
​        //绘制游戏结束图片
​        settishi2(g);
​        g.drawimage(overbg,0,0,null);

​        break;

​    }
​    g.drawimage(ground.image,ground.x,ground.y,null);  //绘制地面
​    g.drawimage(bird.image,bird.x, bird.y,null);     //绘制小鸟

​    setscore(g);
  }
  public boolean ishitground(){      //撞击地面
​    if (bird.y+bird.height>500){
​      return true;
​    }else {
​      return false;
​    }
  }
  public boolean ishitsky(){      //撞击天空
​    if (bird.y<0){
​      return true;
​    }else {
​      return false;
​    }
  }
  public boolean isguandao(column c) {
​    if (bird.x + bird.width >= c.x && c.x + c.width >= bird.x) {   //撞击管道左右
​      if (bird.y <= c.height / 2 + c.y - 72 || bird.y + bird.height >= c.height / 2 + c.y + 72) {
​        return true;
​      } else {
​        return false;
​      }

​    } else {
​      return false;
​    }
  }

  public void setscore(graphics g){               //绘制分数方法
    font font = new font(font.serif, font.italic, 40);  //罗马字体，斜体，40号
    g.setfont(font);     //获取字体
    g.setcolor(color.white);//获取颜色
    g.drawstring(score+"分",40,60);    //画字符串
  }
  public void settishi(graphics g){               //绘制分数方法
    font font1 = new font(font.serif, font.bold, 25);  //罗马字体，斜体，40号
    g.setfont(font1);     //获取字体
    g.setcolor(color.black);//获取颜色
    g.drawstring("点击屏幕开始运行",110,400);    //画字符串
    g.drawstring("   制作人---赵嘉盟",120,430);
  }
  public void settishi2(graphics g){               //绘制分数方法
    font font2 = new font(font.sans_serif, font.bold, 30);  //罗马字体，斜体，40号
    g.setfont(font2);     //获取字体
    g.setcolor(color.red);//获取颜色
    g.drawstring("点击屏幕重新开始",100,500);    //画字符串
  }
  public void action() throws interruptedexception {    //游戏对象运动方法
    this.addmouselistener(new birdmouselistener());   //添加鼠标监听器

​    while (true){
​      switch (state){     //状态不同，对象运动效果不同
​        case start:
​          ground.step();  //调用地面运动方法
​          bird.fly();


          break;
        case running:

​          bird.distancechange();
​          ground.step();  //调用地面运动方法
​          bird.fly();

​          if (ishitground()||ishitsky()){
​            state=gameover;
​            break;
​          }
​          for (int i=0;i<columns.length;i++){
​            column cl=columns[i];
​            cl.step();
​            if (isguandao(cl)){
​              state=gameover;
​              break;
​            }
​            if (bird.x==cl.x){
​              score++;
​            }
​          }

​          break;
​        case gameover:
​          music.stopbgm();
​          break;
​      }
​      repaint();  //刷新方法（重新绘制）
​      thread.sleep(50);  //线程睡眠
​    }
  }
  class birdmouselistener extends mouseadapter{      //小鸟飞行鼠标控制监听内部类
​    @override
​    public void mousepressed(mouseevent e) {
​      super.mousepressed(e);

​      switch (state){
​        case start:
​          state=running;  //鼠标点击开始运行
​          thread thread = new thread(music);
​          thread.start();
​          break;
​        case running:
​          bird.upspeed(); //鼠标点击屏幕给小鸟一个初始上抛速度
​          break;
​        case gameover:
​          sc.insertscore(score);  //向数据库插入分数
​          list<score> scores = sc.selectallscore();//查询数据库所有分数
​          string message="";
​          for (score score1 : scores) {
​            message=message+"时间："+score1.gettime()+"\n分数："+score1.getscore()+"\n";
​          }
​          joptionpane.showconfirmdialog(jp,message,"实时分数",joptionpane.warning_message);
​          state=start;   //鼠标点击游戏恢复开始状态

​          bird.x=120;
​          bird.y=220;
​          bird.speed=0;
​          column.count=0;
​          try {
​            columns[0] = new column();
​          } catch (ioexception ex) {
​            ex.printstacktrace();
​          }
​          try {
​            columns[1] = new column();
​          } catch (ioexception ex) {
​            ex.printstacktrace();
​          }
​          score = 0;//给积分初始化
​          for (int i=0;i<columns.length;i++){
​            try {
​              columns[i]=new column();
​            } catch (ioexception ex) {
​              ex.printstacktrace();
​            }
​          }

​          break;

​      }
​    }
  }
}

十七、stream

stream简介

java 8 中的 stream 是对（collection）集合对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作

或大批量数据操作。stream api 借助于同样新出现的 lambda 表达式，极大的提高编程效率和程序可读性。

stream原理

这种编程风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选，排序，聚合等。

元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的

结果。

stream优点

（1）速度更快

（2）代码更少（增加了新的语法lambda表达式）

（3）强大的stream api

（4）便于并行

（5）最大化减少了空指针异常optional

stream的操作三个步骤：

（1）创建stream，一个数据源（如：集合、数组），获取一个流；

（2）中间操作，一个中间操作链，对数据源的数据进行处理；

（3）终止操作，一个终止操作，执行中间操作链，并产生结果。

集合有两种方式生成流：

stream() − 为集合创建串行流。

parallelstream() − 为集合创建并行流

-stream的的中间操作（intermediate）和最终操作（terminal）都包含的方法:

中间操作（intermediate）

1.filter : 通过设置条件来过滤元素。

list<string> list = arrays.aslist("aaa","ddd","bbb","ccc","a2a","d2d","b2b","c2c","a3a","d3d","b3b","c3c");

list.stream().filter((s)->s.contains("a")).foreach(s -> system.out.println(s));

以上代码使用filter方法过滤出只包含”a”的元素，然后通过foreach将满足条件的元素遍历出来。

map : 就是将对应的元素使用给定方法进行转换。

list<string> list = arrays.aslist("aaa","ddd","bbb","ccc","a2a","d2d","b2b","c2c","a3a","d3d","b3b","c3c");

list.stream().filter((s)->s.contains("a")).map((s)-> s + "---map").foreach(s -> system.out.println(s));

在filter的基础上，给每个元素后面添加字符串”—map”

flatmap：如果流的元素为数组或者collection，flatmap就是将每个object[]元素或collection元素都转换为object元素。

list<string[]> setlist = new arraylist<>();

setlist.add(new string[]{"aa","bb"});

setlist.add(new string[]{"cc","dd"});

setlist.add(new string[]{"ee","ff"});//使用map方法

setlist.stream().map(s->arrays.stream(s)).foreach(s-> system.out.println("map==" + s));//使用flatmap方法

setlist.stream().flatmap(s->arrays.stream(s)).foreach(s-> system.out.println("flatmap==" + s));

map就是将数组流直接返回，flatmap是将数组流中的每个元素都返回。

.distinct：将集合中的元素去重。

list<string> dislist = arrays.aslist("aaa","ddd","bbb","ddd","aaa");

dislist.stream().distinct().foreach(s-> system.out.println(s));

sorted：将集合中的元素排序。

list<integer> integerlist = arrays.aslist(2,4,1,3);

integerlist.stream().sorted().foreach(s-> system.out.println(s));

可以按照自定义排序：

list<integer> integerlist = arrays.aslist(2,4,1,3);

integerlist.stream().sorted((s1,s2)->s2.compareto(s1)).foreach(s-> system.out.println(s));

peek：生成一个包含原stream的所有元素的新stream，同时会提供一个消费函数即引用的方法a，当stream每个元素被消费的时候都会先
执行新stream给定的方法a。peek是中间操作，如果peek后没有最终操作，则peek不会执行。

list<integer> integerlist = arrays.aslist(1,2,3,4);

integerlist.stream().peek(s-> system.out.println("peek = "+s)).foreach(s-> system.out.println("foreach = "+s));

limit：返回stream的前n个元素。

list<integer> integerlist = arrays.aslist(1,2,3,4);

integerlist.stream().limit(2).foreach(s-> system.out.println(s));

skip：删除stream的前n个元素。

list<integer> integerlist = arrays.aslist(1,2,3,4);

integerlist.stream().skip(2).foreach(s-> system.out.println(s));

终端操作（terminal）

1.foreach：遍历stream中的每个元素，前面每个例子都有使用，此处不再演示。

list<integer> integerlist = arrays.aslist(1,2,3,4);

integerlist.stream().skip(2).foreach(s-> system.out.println(s));

foreachordered:遍历stream中的每个元素。
区别： 在串行流（stream）中没有区别，在并行流（parallelstream）中如果数据源是有序集合，foreachordered输出顺序与数据源中顺序
一致，foreach则是乱序。

list<integer> integerlist = arrays.aslist(1,2,3,4);

integerlist.parallelstream().foreachordered(s-> system.out.println(s));

toarray：将流转换为object[]或者指定类型的数组。

list<integer> integerlist = arrays.aslist(1,2,3,4);

object[] array = integerlist.stream().toarray();

string[] strarr = integerlist.stream().toarray(string[]::new);

stream中的toarray普通情况下和集合中的toarray没什么区别,但是stream中的toarray转换为指定类型的数组。

reduce：将集合中的每个元素聚合成一条数据。有三种情况：

reduce(binaryoperator accumulator)：此处需要一个参数，返回optional对象：

optional reduce = integerlist.stream().reduce((a, b) -> a + b);

reduce(t identity, binaryoperator accumulator)：此处需要两个参数，第一个参数为起始值，第二个参数为引用的方法

从起始值开始，每个元素执行一次引用的方法（方法引用的中的两个参数：第一个参数为上个元素执行方法引用的结果，第二个参数为当前元素）。

  list<integer> integerlist = arrays.aslist(1,2,3,4);

  int integer = integerlist.stream().reduce(5,(a, b) -> a + b);

  system.out.println(integer);

此例中使用起始值为5，对集合中每个元素求和，可以理解为：5+1+2+3+4=15。

**reduce：**此处需要三个参数。此方法用在并发流（parallelstream）中，启动多个子线程使用accumulator进行并行计算，最终使用combiner对子线程结果进行合并，返回identity类型的数据。

collect：将流转换成集合或聚合元素。有两种情况。接受一个参数和接受三个参数（三个参数在并发流parallelstream中使用），此处介绍一个参数的情况，单个参数接受的参数类型为collector，collectors 类实现了很多归约操作

list<integer> integerlist = arrays.aslist(2,4,1,3);list<integer> integers = integerlist.stream().filter(s -> s > 1).collect(collectors.tolist());system.out.println(integers.tostring());

此处统计集合中大于1的元素并最终返回list。

min:获取集合中最小值。

list<integer> integerlist = arrays.aslist(2,4,1,3);integer min = integerlist.stream().min(integer::compareto).get();system.out.println(min);

max：获取集合中最大值。

list<integer> integerlist = arrays.aslist(2,4,1,3);integer max = integerlist.stream().max(integer::compareto).get();system.out.println(max);

count：获取集合中元素个数

list<integer> integerlist = arrays.aslist(2,4,1,3);

long count = integerlist.stream().count();system.out.println(count);

到此这篇关于java入门到精通的学习笔记：零基础如何快速学会java开发的文章就介绍到这了,更多相关java实用学习笔记内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！