JAVASE基础+加强整合总结（2022版）

开发前言

1.1 Java语言概述

什么是java语言

Java语言是美国Sun公司（Stanford University Network），在1995年推出的高级的编程语言。所谓编程语言，是计算机的语言，人们可以使用编程语言对计算机下达命令，让计算机完成人们需要的功能。

语言历史

C& C++

1972年C诞生

• 贴近硬件，运行极快，效率极高。
• 操作系统，编译器，数据库，网络系统等
• 指针和内存管理

1982年C++诞生 难学

• 面向对象
• 兼容C
• 图形领域、游戏等

反抗

我们要建立一个新的语言：

• 语法有点像C
• 没有指针
• 没有内存管理
• 真正的可移植性，编写一次，到处运行
• 面向对象
• 类型安全
• 高质量的类库

为了实现跨平台，在每个操作系统之上增加了一个抽象层（Java的虚拟机）JVM，所有的平台上安装了虚拟机就可以跑java程序

用java写的程序 都跑在虚拟机上，除非个别情况

java初生

• 1995年的网页简单粗糙，缺乏互动性。

• 图形界面程序（Applet）

• BIll Gates说：这是即今为止设计的最好的语言

• Java 2标准版（J2SE）：去占领桌面

• Java 2移动版（J2ME）：去占领手机

• Java 2企业版（J2EE）: 去占领服务器

1.2计算机基础知识

二进制

计算机中的数据不同于人们生活中的数据，人们生活采用十进制数，而计算机中全部采用二进制数表示，它只包含

0、1两个数，逢二进一，1+1=10。每一个0或者每一个1，叫做一个bit（比特）。

下面了解一下十进制和二进制数据之间的转换计算。

• 十进制转换成二进制

• **二进制数据转成十进制数据：**使用8421编码的方式

  二进制数据1001011转成十进制

  1 0 0 1 0 1 1

  64 32 16 8 4 2 1

把有1位上的进制求和

64+8+2+1=75

二进制数系统中，每个0或1就是一个位，叫做bit(比特)

字节

字节是我们常见的计算机中最小存储单元。计算机存储任何的数据，都是以字节的形式存储，右键点击文件属性， 我们可以查看文件的字节大小。

8个bit（二进制位） 0000-0000表示为1个字节，写成1 byte或者1 B

8 bit = 1 B

1024 B =1 KB

1024 KB =1 MB

1024 MB =1 GB

1024 GB = 1 TB

Java特性和优势

• 简单性
• 面向对象
• 可移植性（跨平台性）
• 高性能
• 分布式
• 动态性（反射机制）
• 多线程
• 安全性
• 健壮性

Java三大版本

Write Once、Run Anywhere JVM

JavaSE:标准版（桌面程序，控制台开发） 基础

JavaME: 嵌入式开发（手机，小家电） 都没人学了

JavaEE：企业级开发（web端，服务器开发）以后的就业方向

JDK、JRE、JVM

• JDK:Java Development Kit java开发者工具
• JRE：Java Runtime Environment java运行时环境
• JVM：Java Virtual（虚拟的） Machine java虚拟机，是运行所有Java程序的假想计算机，是Java程序的 运行环境，是Java 最具吸引力的特性之一。我们编写的Java代码，都运行在 JVM 之上。

)]

有以下关系

JDK在JRE之上扩充了一些开发工具

只要安装了JRE就可以运行Java程序了，但是要学开发的话还是要安装JDK

跨平台：任何软件的运行，都必须要运行在操作系统之上，而我们用Java编写的软件可以运行在任何的操作系 统上，这个特性称为Java****语言的跨平台特性。该特性是由JVM实现的，我们编写的程序运行在JVM上，而JVM 运行在操作系统上

安装开发环境：略

Hello World入门程序

编译和运行是两回事

• 编译：是指将我们编写的Java源文件翻译成JVM认识的class文件，在这个过程中， javac 编译器会检查我们 所写的程序是否有错误，有错误就会提示出来，如果没有错误就会编译成功。

• 运行：是指将 class文件 交给JVM去运行，此时JVM就会去执行我们编写的程序了。

关于main方法

main方法：称为主方法。写法是固定格式不可以更改。main方法是程序的入口点或起始点，无论我们编写多 少程序，JVM在运行的时候，都会从main方法这里开始执行。

编译型和解释型

Java程序运行机制

• 编译型（compile）：类似于把一本中文书直接翻译为英文版
• 解释型：类似于要什么就翻译什么，就不用整本书翻译（用一下编译一下，性能会有所损失）

开发一个操作系统一般会用编译型 C/C++ 都是编译型的

网页对于速度要求没那么高 一般会用解释型 Java JS

Java先编译到操作系统的时候在解释，所以java既有编译型也有解释型特征

• 程序运行机制

都在java安装目录的bin目录下：

javac.exe:编译器

java.exe:解释器

Java基础语法

1. 注释、标识符、关键字
2. 数据类型
3. 类型转换
4. 变量、常量
5. 运算符
6. 包机制、JavaDoc

注释

单行注释 //

多行注释 /* */

JavaDoc：文档注释 /** */

标识符（关键字、方法名、类名、变量名）

关键字：Java中规定好的名字，每个关键字都有其固定的含义和作用

Java中所有的组成部分都需要名字。类名、变量名以及方法名都被成为标识符

标识符注意点：

• 标识符可以由0-9、字母（A-Z或者a-z），美元夫（$）、或者下划线(_)组成
• 首字符之后任意字符
• 不能使用关键字作为变量名或者方法名
• 标识符是大小写敏感的
• 可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼英，很Low

数据类型

• 强类型语言
  • 要求变量的使用严格符合规定，所有变量都必须先定义后才能使用

强类型语言的好处：安全性高，速度慢

• 弱类型语言

  ​

JS就是弱类型语言

Java就是强类型语言

• Java的数据类型分为两大类
  • 基本类型
  • 引用类型

byte 1个字节

short 2个字节

int 4个字节

long 8个字节 Long类型要在后面加一个L

float 4个字节 要在后面加一个f

double 8个字节

char 2个字节 字符类型代表一个字，不管是中文还是英文还是标点符号，都只能是一个

String 字符串

String不是关键字，是一个类，是一个引用类型

boolean类型 只有两个值 true和false

什么是字节

• 位（bit）：是计算机内部数据储存的最小单位，1100110是一个八位二进制数。

• 字节（byte）：是计算机中数据处理的基本单位，习惯上用大写B来表示

• 1B（byte字节） = 8bit（位）

• 字符：是指计算机中使用的字母、数字、字和符号

• 1bit表示1位

• 1Byte表示一个字节 1B=8b

• 1024B=1KB

• 1024KB=1M

• 1024M=1G

科普

电脑的32位和64位的区别是什么呢？

32位的CPU只能装32位的操作系统

64位的CPU32、64位的操作系统都能装

32位的能扩内存条4G

64 128G

整数扩展

进制

二进制 0b 十进制 八进制0 十六进制0x

​ 10 010 0x10

​ 10 8 16

浮点数扩展

float 能变现的字长有限 离散 舍入误差 大约 （很多数字无法精确表示） 接近但不等于

会产生下面这样的问题

float d1 = 2113131131311313f,

float d2 = d1+1;

会有舍入误差，可能都被舍掉了，加的部分

d1 == d2; 为true

所以最好完全避免使用浮点数进行比较

字符扩展

所有的字符本质还是数字

char c1 =‘a’;

char c2 = ‘中’;

c1.sout a

(int)c1.sout 07

c2.sout 中

(int)c2.sout 20013

char类型会涉及到编码问题

Unicode能处理各种语言的文字，占了2个字节 0-65536 2^16 = 65536

这个编码的依据是一张表

char类型再与int类型进行运算的时候，会向上转型成int类型

 char str = '我';
        System.out.println(str - 0);

转义字符

\t 制表符（tab）

\n 换行

类型转换

• 由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。

  低------------------------------------------------------------------------------------------------>高

  byte ， short ， char----->int-------->long-------->float--------->double

  为什么float在long后面，因为小数的优先级大于整数

• 运算中，不同类型的数据先转化为同一类型，然后进行运算。

例子

int i = 128;

byte b = (byte)i;

i.sout 128

b.sout -128 //内存溢出(其实是不能值是什么的) byte变量范围 -128~127

• 强制类型转换

  ​ （类型）变量名 高----低

• 自动类型转换

  ​ 低—高 这是自动的

如

int i = 111;

double b = i; 这个类型的转换是自动的

注意点：

1、不能对boolean值进行转换

2、不能把对象类型转换为不相干的类型

3、在强制转换的可能存在内存溢出，或者精度问题（在小数的时候遇到,会损失精度）

​ 如 (int)23.7.sout 23 (int)-45.89f.sout -45

操作比较大的数的时候，注意溢出问题

JDK7新特性，数字之间可以用下划线分割

如int money = 10_0000_0000; 下划线不会被输出

int years = 20;

int total = money*years ; //-1474232131, 计算的时候溢出了

用long接收会不会就不会溢出了？不

long total2 = money*years ; //-1474232131 发现还是溢出了，

两者相乘，默认都是int相乘，转换之前就已经存在问题了。到赋值给total2的时候，已经是有问题的值

解决办法

long total3 = money*((long)years );// 在计算前，先把一个数转换为long

ASCII编码表

在计算机的内部都是二进制的0、1数据，如何让计算机可以直接识别人类文字的问题呢？就产生出了编码表的概念

• 编码表：就是将人类的文字和一个十进制数进行对应起来组成一张表格

  人们就规定：

字符(人类的文字)	数值（10进制数）
0	48
9	57
A	65
Z	90
a	97
z	122

​ 将所有的英文字母，数字，符号都和十进制进行了对应，因此产生了世界上第一张编码表ASCII（ American Standard Code for Information Interchange 美国标准信息交换码）

小贴士：在char类型和int类型计算的过程中，char类型的字符先查询编码表，得到97，再和1求和，结果为98。char类型提升 为了int类型。char类型内存2个字节，int类型内存4个字节。

变量

• 变量是什么：就是可以变化的量！（变量指代的是内存中的一块空间，空间里面要放什么东西我们不确定，位置是确定的）

• Java是一种强类型语言，每个变量都必须声明其类型。

• Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

• 注意事项：

  • 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
  • 变量名必须是合法的标识符
  • 变量声明是一条完整的语句，因此每一个声明都必须以分号结束

变量作用域

• 类变量
• 实例变量
• 局部变量

public class Person{
	static int allClick=0;  //类变量
	String str = "Hello world";  //实例变量

	public void method(){
		int i =0; //局部变量
	}
}

局部变量

• 作用域 被{}包含的里面
• 必须声明和初始化值

实例变量

• 作用域：从属于对象（有对象就能用）
• 定义在类里面，方法的外面
• 可以不需要初始化值，有相应类型的默认值
  • 数值类型一般为0
  • 布尔值默认为false
  • 引用类型为null

类变量

• 加关键字 static
• 作用域：从属于类（有类就能用）
• 可以不需要初始化值，有默认值

类变量又被称为全局变量

成员变量就是在类{}中定义的变量

常量

• 常量（Constant）：初始化（initialize）后不能再改变值！不会变动的值（Java程序中固定不变的数据）。
• 所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变

final 变量名=值;
final double PI=3.14;

• 常量名一般使用大写字符

变量的命名规范

• 所有变量、方法、类没：见名知意
• 类成员变量：首字母小写和驼峰原则：monthSalary
• 局部变量：首字母小写和驼峰原则
• 常量：大写字母和下划线：MAX_VALUE
• 类名：首字母大写和驼峰原则：Man，GoodMan
• 方法名：首字母小写和驼峰原则

类成员变量：除了常量和局部变

访问修饰符

运算符

• Java语言支持如下运算符：

  • 算数运算符 + - * / %(模运算，就是取余) ++ –
    模运算，看%左边，左边是负数结果就是负数，左边为正结果就是正数

  • 赋值运算符 =

    • 扩展赋值运算符 += -= *= /=

  • 关系运算符 > < >= <= == != instanceof

  • 逻辑运算符 && （与） ||（或） ！（非）

  • 位运算符 & | ^ ~ >> << >>>(了解)

  • 条件运算符 ？ ：

int a =10

int b =20

int c = a/b

c.sout=0 因为a和b都是整数的所以小数部分被去掉了

结局方法 其中一个数值是小数就好了

a/(double)b

++ –

自增

自减

例如：int a= 3;

int b =a++; //a++ a=a+1 这句话的意思是：执行完这代码后，先给b赋值，在自增 此时b=3，a=4

int c =++a; //++a a=a+1 这句话的意思是：执行完这代码后，先自增，再给C赋值 此时 b=4，a=4

幂运算

Java中没有^这个运算符 所以2^3在java中只能借用一些工具类来使用

double pow = Math.pow(2, 3);

逻辑运算

短路运算

短路与：第一个位flase就不会往下判断了

a&&（b+c）

&&：两个为真才是真

短路或：第一个为true就不会往下判断了

||：一个为真即为真

！：取反

了

位运算

位运算是跟二进制有关的

A=0011 1100

B=0000 1101

A&B=上下两个都为1就是1，否则都是0 可得 0000 1100

A|B= 只要有1就是1，否则都是0 0011 1101

A^B=异或 相同为0，不相同为1 0011 0001

~B=取反 1111 0010

(>> 右移 /2) （<< 左移 *2）

二进制的八位数

0000 0000 代表0

0000 0001 代表1

0000 0010 代表2

…

0000 1000 8

0001 0000 16

扩展赋值运算+= -=

a+=b // a = a+b

a-=b //a = a-b

字符串连接

跟字符串连接都变成字符串

int a =10 ;

int b =20;

(“”+a+b).sout //1020

(a+b+“”).sout //30

三元运算符

x?y:z

如果x为true结果为y，否则为z

包机制

• 为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。

• 包语句的语法格式为

  • package …

• 一般利用公司域名倒置做为包名； 如 www.baidu.com 建包的时候就com.baidu.www

• 为了能够使用某一个包的成员。我们需要在Java程序中明确导入该包，完成此功能

  • import …

JavaDoc

• javadoc 命令是用来生成自己API文档的

• 参数信息

  • @author做作者名
  • @Version 版本号
  • @since指明需要最早使用的jdk版本
  • @param参数名
  • @return 返回值情况
  • @throws异常抛出情况

Java流程控制

顺序结构

• Java的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。

• 顺序结构是最简单的算法结构

• 语句语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。

if选择结构

if(){
    
}else if{
    
}else{
    
}

有时候if语句可以用三元运算符互换

int a = 10; 
int b = 20; 
//定义变量，保存a和b的较大值 
int c; 
if(a > b) {
    c = a; 
} else { 
    c = b; 
}
//可以上述功能改写为三元运算符形式
c = a > b ? a:b;

Switch选择

每一条选择语句都必须加break，没有加会穿透（从被选择到的语句往下一直执行），执行后面不匹配的标签内代码

switch(expression){//变量类型byte，short,int,char.
//JavaSE7后支持String。对应为s.hashCode()
//标签必须是字符串常量或字面量 ？
case value:
break;
default:
}

通过idea实习反编译 直接把字节码文件拷过来就好了

循环结构

while

while(布尔值){
	//循环内容
}

• ​ 只要布尔表达式为true，循环就会一直执行下去
• 我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环。
• 少部分情况需要循环一直执行，比如服务器的请求响应监听等。
• 循环条件一直为true就会造成无限循环【死循环】，我们正常的业务编程中应该尽量避免死循环。会影响程序性能或者造成程序卡死崩溃！

do…while

• 对于while语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次，
• do…while循环和while循环相似，不同的是，do…while循环至少会执行一次

do{
//代码语句
}while(布尔表达式);

• while和do…while的区别
  • while先判断后执行。do…while是先执行后判断！
  • do…while总是保证循环体会被至少执行一次！这是他们的主要差别

for循环

• 虽然所有循环结构都可以用while胡总和do…while表示，但Java提供了另外一种语句------for循环，使一些循环结构变得更加简单。

• for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。

• for循环执行的次数是在执行前就确定的。语法格式如下：

  for(初始化;布尔表达式;更新){
  	//代码语句
  }
  

九九乘法表

   for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <=i; j++) {
                System.out.print(i+"X"+j+"="+(i*j));
                System.out.print("\t");
            }
            System.out.println("");

        }


1X1=1	
2X1=2	2X2=4	
3X1=3	3X2=6	3X3=9	
4X1=4	4X2=8	4X3=12	4X4=16	
5X1=5	5X2=10	5X3=15	5X4=20	5X5=25	
6X1=6	6X2=12	6X3=18	6X4=24	6X5=30	6X6=36	
7X1=7	7X2=14	7X3=21	7X4=28	7X5=35	7X6=42	7X7=49	
8X1=8	8X2=16	8X3=24	8X4=32	8X5=40	8X6=48	8X7=56	8X8=64	
9X1=9	9X2=18	9X3=27	9X4=36	9X5=45	9X6=54	9X7=63	9X8=72	9X9=81	

增强for循环

Java5中引入了一种主要用于数组的增强型for循环

这里我们先只是见一面，做个了解，之后数组我们重点使用

Java5引入了一种主要用于数组或集合的增强for循环。

Java增强for循环语法格式如下：

for(声明语句：表达式){
//代码句子
}

• 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配(就是说该变量就是数组中的一个个的元素)，其作用域限定在循环语句块，其值与此时数组元素的值相等。
• 表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

跳出语句

• break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。（break语句也在switch语句中使用）
• continue语句再循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

 for (int i = 0; i < 5; i++) {
            if(i==3){
                continue;
            }
            System.out.println(i);
        }

0
1
2
4

• 关于goto关键字（知道就好，不需要去理解）
  • goto关键字很早就在程序设计语言中出现，尽管goto仍是Java的一个保留字，但并未在语言中得到正式使用；Java没有goto，然而，仔break和continue这两个关键字的身上，我们仍然能看出一些goto的影子—带标签的break和continue
  • “标签”是指后面跟一个冒号的标识符，例如：lable
  • 对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，他们就会中断到存在标签的地方

Java方法详解

• Java方法是语句的集合，它们在一起执行一个功能。
  • 方法是解决一类问题的步骤的有序组合
  • 方法包含于类或对象中
  • 方法仔程序中被创建，在其他地方被引用
• 设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成1个功能，这样利于我们后期的扩展方法

方法的定义

• Java的方法类似于其它语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法：

  • 方法包含一个方法头和方法体。下面是一个放法的所有部分：

    • 修饰符：修饰符，这是可选的，告诉编译器如何使用该方法定义了该方法的访问类型。
    • 返回值类型：方法可能会返回值。returnValueType释放发返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType是关键字void。
    • 方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
    • 参数类型：参数像是一个占位符。当方法被调用的时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数
      • 形式参数：在方法被调用时用于接收外界输入的数据。（一般在方法的定义中）
      • 实参：调用方法时实际传给方法的数据。（一般在调用方法的时候传递的参数）
    • 方法体：方法体包含具体的语句，定义该方法的功能。

    修饰符  返回值类型  方法名(参数类型 参数名){
    	...
    	方法体
    	...
    	return 返回值
    }
    //当返回值类型是void的时候 没有返回值
    

方法调用

• 调用方法：对象名.方法名(实参列表)
• Java支持两种调用方法的方式，根据方法是否返回值来选择
• 当方法返回一个值得时候，方法调用通常被当做一个值。例如

int larger = max(30,40);
//这里得max方法就通过引入实参，然后方法最后得返回值赋值给larger

• 如果方法返回值是void。方法调用一定是一条语句。

形参和实参之间的传递

课后扩展了解：值传递（Java）和引用传递

值传递：
在方法被调用时，实参通过形参把它的内容副本传入方法内部，此时形参接收到的内容是实参值的一个拷贝，因此在方法内对形参的任何操作，都仅仅是对这个副本的操作，不影响原始值的内容。

引用传递：
”引用”也就是指向真实内容的地址值，在方法调用时，实参的地址通过方法调用被传递给相应的形参，在方法体内，形参和实参指向通愉快内存地址，对形参的操作会影响的真实内容。

无论是基本类型和是引用类型，在实参传入形参时，都是值传递，也就是说传递的都是一个副本，而不是内容本身。

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Test1 {
    public static void main(String[] args) {
        Person p = new Person();
        p.setName("我是马化腾");
        p.setAge(45);
        PersonCrossTest(p);
        //原来实参的地址并不会被覆盖掉
        System.out.println("方法执行后的name："+p.getName());
    }

    public static void PersonCrossTest(Person person)
    {
        System.out.println("传入的person的name："+person.getName());
        person=new Person();//加多此行代码
        //这里的形参person已经有新的地址
        person.setName("我是张小龙");
        System.out.println("方法内重新赋值后的name："+person.getName());
    }


}


class Person{

    String name;
    int 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;
    }
}

输出
传入的person的name：我是马化腾
方法内重新赋值后的name：我是张小龙
方法执行后的name：我是马化腾

java都是值传递

多理解下 下面连接详细

https://blog.csdn.net/weixin_34174322/article/details/87956140?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.compare&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.compare

方法的重载

• 重载就在一个类中有相同的函数名称，但形参不同的函数。

• 方法的重载原则：

  • 方法名称必须相同
  • ==参数列表必须不同（==个数不同、或类型不同、参数排列顺序不同等）
  • 方法的返回类型可以相同也可以不相同。
  • 仅仅返回类型不同不足以成为方法的重载

• 实现理论：

  • ​ 方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，已选择对应的方法，如果匹配失败，则编译器会报错。

命令行传参

• 有时候你希望运行一个程序时再给他传递给他消息。这要靠传递命令行参数给main()函数实现

 public static void main(String[] args) {
       for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "]:" + args[i]);
        }
    }

手动传入this is huanggaotao

D:\JavaSE_test\JUC\src\main\java>java Test1 this is huanggaotao
args[0]:this
args[1]:is
args[2]:huanggaotao

可变参数

• JDK1.5开始，Java支持传递同类型的可变参数给一个方法
• 在方法声明中，在指定参数类型后加一个省略号（…）
• 一个方法中只能指定一个可变参数，他必须是方法的最后一个参数。任何普通的参数必须在它之 前声明。

修饰符  返回值类型  方法名(参数类型...形参名){}
//注意是3个.
//底层是一个数组

等价于

修饰符  返回值类型  方法名(参数类型[] 形参名){}

只是后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。

 public static void main(String[] args) {
        test(1,2,3,4,5);
     //等同于
     test(new int[]{1,2,3,4,5});

    }
    
    public static void test(int...i){
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
        System.out.println(i[3]);
        System.out.println(i[4]);
    }
1
2
3
4
5

可变参数的本质就是数组

递归

面试高频

• A方法调用B方法，我们很容易理解

• 递归就是：A方法调用A方法！就是自己调用自己

• 利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要多次重复计算，大大地减少了程序的代码量，递归的能力在于用有限的语句来定义对象的无限集合。

• 递归结构包含两个部分：

  • 递归头：什么时候不调用自身方法。如果没有头、将陷入死循环。
  • 递归体：什么时候需要调用自身方法

例子

public static void main(String[] args) {
        System.out.println(test1(5));//120
    }

public static int test1(int a){
    
        if(a==1){
            return 1;
        }else
        {
            return a*test1(a-1);
        }
    }

能不用递归就不用递归，用的情况下，尽可能地小计算

数组

1、数组概述

2、数组声明创建

3、数组使用

4、多维数组

5、Arrays类

6、稀疏数组

容器概念

**容器：**是将多个数据存储到一起，每个数据称为该容器的元素。

**生活中的容器：**水杯，衣柜，教室

数组概念

数组就是是存储数据长度固定的容器，保证多个数据的数据类型要一致。

数组的定义

• 数组是相同类型数据的有序集合
• 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
• 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问他们

数组声明创建

• 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法

数据类型[]  数组名    //首选
或
数据类型  数组名[]   //效果相同，但不是首选方法

• java语言使用new操作符来创建数组，语法如下：

  数据类型[] 数组名 = new 数据类型[数组大小]
  

• J数组的元素是通过索引访问的，数组索引从0开始

• 获取数组长度 arrays.length

数组赋值

两种方式

数组名[i]=数据;

//或者在创建的时候就赋值
数据类型[] 数组名 = new 数据类型[]{数据，数据....}

数组的四个基本特点

• 其长度是确定的。数组一旦被创建。它的大小就是不可以改变的
• 其元素必须是相同类型，不允许出现混合类型
• 数组中的元素可以是任何数据类型，包括基本类型和引用类型
• 数组变量属引用类型，数组可以看成是对象，数组中的每个元素相当于该对象的成员变量。

数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

内存分析

Java内存分析

数组三种初始化

• 静态初始化

  创建+赋值

  int[] a ={1,2,3};
  Man[] mans = {new Man(1,1),new Man(2,2)}
  

• 动态初始化：包含默认初始化

  初始化+后期赋值

初始化后的所有空间默认是0，引用类型默认为null

int[] a = new int[2];
a[0]=1;
a[1]=2;

• 数组的默认初始化
  • 数组是引用类型，它的天涯不属于相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

int[] a = new int[2];
b[0]每个元素都有默认值为0

常见数组异常

数组越界异常

• 下标的合法区间：[0,length-1],如果越界就会报错；

• ArrayIndexOutOfBoundsExeception:数组下标越界异常！

• 小结：（重要）

  • 数组是相同数据类型（数据类型可以为任意类型）的有序集合
  • 数组也是对象。数组元素相当于对象的成员变量
  • 数组长度是确定的，不可变的。如果越界，则报ArrayIndexOutOfBoundsExeception:数组下标越界异常！

数组空指针异常

public static void main(String[] args) {
    int[] arr = {1,2,3};
    arr = null;
    System.out.println(arr[0]);
    ｝

arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候 会抛出 NullPointerException 空指针异常。

空指针异常在内存图中的表现

数组使用

• For-Each循环

缺点：取不到数组的下标

		
int[] arrays={1,2,3,4,5};
//数组里的元素    数组			   
for (int array : arrays) {
            System.out.println(array);
        }

• 数组做方法入参
• 数组作返回值

数组原理内存图

内存概述

内存是计算机中的重要原件==，临时存储区域==，作用是运行程序。我们编写的程序是存放在硬盘中的，在硬盘中的程 序是不会运行的，必须放进内存中才能运行，运行完毕后会清空内存。

Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。

Java虚拟机的内存划分

为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式

JVM内存划分：

区域名称	作用
寄存器	给CPU使用，和我们开发无关
本地方法栈	JVM在使用操作系统功能的时候使用，和们开发无关
方法区	存储可以运行的class文件。
堆内存	存储对象或者数组，new来创建的，都存储在堆内存
方法栈	方法运行时使用的内存，比如main方法运行，进入方法栈中执行

数组在内存中的存储

public static void main(String[] args) {
    int[] arr = new int[3]; 			          System.out.println(arr);//[I@5f150435 
}

以上方法执行，输出的结果是[I@5f150435，这个是什么呢？是数组在内存中的地址。new出来的内容，都是在堆 内存中存储的，而方法中的变量arr保存的是数组的地址。

输arr[0]，就会输出arr保存的内存地址中数组中0索引上的元素

两个数组内存图

public static void main(String[] args) { 
    int[] arr = new int[3]; 
    int[] arr2 = new int[2];
    System.out.println(arr);
    System.out.println(arr2); 
}

两个变量指向一个数组

public static void main(String[] args) {
    // 定义数组，存储3个元素
    int[] arr = new int[3];
    //数组索引进行赋值
    arr[0] = 5; 
    arr[1] = 6; 
    arr[2] = 7; 
    //输出3个索引上的元素值
    System.out.println(arr[0]); System.out.println(arr[1]);
    System.out.println(arr[2]); 
    //定义数组变量arr2，将arr的地址赋值给arr2 
    int[] arr2 = arr; 
    arr2[1] = 9;
    System.out.println(arr[1]); 
}

多维数组

• 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。

• 二维数组

int a[][] = new int[2][5];

• 解析：以上二维数组a可以看成是一个两行五列的数组。
• 思考：多维数组的使用？

//遍历出二维数组中的每一个元素
int[][] num = {{1,2},{3,4},{5,6}};

        for (int i = 0; i < num.length; i++) {
            for (int j = 0; j < num[i].length; j++) {
                System.out.println(num[i][j]);
            }
        }

Arrays类

• 数组的工具类java.util.Arrays

• 由于数组对象本身并没有什么方法可以供我们调用，danAPI中提供了一个工具类Arrays供我们使用，从而可以对数据对像进行一些基本的操作。

• 查看JDK帮助文档

• Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（因为是静态方法）

• 具有以下常用功能：

  • 给数组赋值:通过fill方法

   int[] arryas = new int[5];
  
          Arrays.fill(arryas,0);
  //数组里面的每个值都变成0了
  
  int[] abc = {1,2,3,4,5};
  		//2以后和4之前的被填充   左开右闭区间
          Arrays.fill(abc,2,4,0);
  

  • 对数组排序：通过sort方法，按升序。
  • 比较数组：通过equals方法比较数组中元素值是否相等
  • 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。

数组反转

public static int[] reverse(int[] array){
    int temp = 0;
    for (int i = 0 ,j = var.length-1; j>=i;i++,j--) {
        temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
        return array;
}

冒泡排序

• 冒泡排序无疑是最为出名的排序算法之一，总共有八大排序！

• 冒泡的代码还是相当简单的，两层循环，外层冒泡轮数，里层次比较，江湖人人尽皆知

• 我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为O(n2).
  

  public static void main(String[] args) {
        int[] n = new int[]{1,6,3,8,33,27,66,9,7,88};
      //定义临时变量  
      int temp;
      
      //外层循环，判断我们要冒泡多少次（就是上面动图中绿色动从左至右这个过程多少次）
        for (int i = 0; i < n.length-1; i++) {
            //内层循环，比较两个数多少次，最右边的数就是逐渐筛选出来的数，就是冒泡出去的数
            //-i就是把排序出来的（在最右边的给舍去，不用再进行排序了）
            //-1以免j+1的时候发生越界异常
            for (int j = 0; j <n.length-1-i; j++) {
                if(n[j]>n[j+1]){
                    temp = n[j];
                    n[j] = n[j+1];
                    n[j+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(n));
    }

思考 ：如何优化？

假设进来循环的时候已经有序了，就不用再去比较一次了

int temp = 0;
for (int i = 0; i < n.length-1; i++) {
//通过flag标识位减少没有意义的比较
    booelan flag = flase;
            for (int j = 0; j <n.length-1; j++) {
                if(n[j]>n[j+1]){
                    temp = n[j];
                    n[j] = n[j+1];
                    n[j+1] = temp;
                    //如果这一趟没有交换元素
                    flag = true;
                }
            }
    if(flag == false){
        break;
    }
        }

理解

假设我们现在排序ar[]={1,2,3,4,5,6,7,8,10,9}这组数据，按照上面的排序方式，第一趟排序后将10和9交换已经有序，接下来的8趟排序就是多余的，什么也没做。所以我们可以在交换的地方加一个标记，如果那一趟排序没有交换元素，说明这组数据已经有序，不用再继续下去。

稀疏数组

是一种数据结构

介绍

• 当一个数组中大部分元素为0，或者为同一值得数组时，可以使用稀疏数组来保存该数组。

• 稀疏数组得处理方式是：

  • 记录数组一共有几行几列，有多少个不同值
  • 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

  如下图：左边是原始数组，右边是稀疏数组

[0] 6 7 8

6行7列 8个不同的数字

下面都是通过坐标的值来记录数字的位置

例子

public class Test1 {
    public static void main(String[] args) {
        int[][] array1 = new int[11][11];

        array1[1][2]=1;
        array1[2][3]=2;

        for (int[] ints : array1) {
            for (int anInt : ints) {

                System.out.print(anInt+"\t");
            }
            System.out.println();
        }


        System.out.println("====================================");


        //转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0;

        //计算稀疏数组第[0]的值
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(array1[i][j]!=0){
                    //记录有效值的个数
                    sum++;
                }
            }
        }

        System.out.println("有效值的个数："+sum);



        //2.创建一个稀疏数组的数组
        //行的话有效值的个数+1   列数固定为3
        int[][] array2 = new int[sum+1][3];

        //稀疏数组第[0]行的行、列、值
        array2[0][0]=11;
        array2[0][1]=11;
        array2[0][2]=sum;


        //遍历二维数组，将非零的值，存放到稀疏数组中
        int count = 0;
        //行
        for (int i = 0; i < array1.length; i++) {
            //列
            for (int j = 0; j < array1[i].length; j++) {
                //如果不等于0说明有具体的值
                if(array1[i][j] != 0){
                    //具体的值的计数器
                    count++;
                    //下面就是将行、列、和对应的具体的值赋值到稀疏数组对应的值中
                    
                    //下面的赋值是按照一个值得行、列和具体的值独占一行
                            
                    //存第几行
                    array2[count][0]=i;

                    //存第几列
                    array2[count][1]=j;

                    //存具体的值
                    array2[count][2]=array1[i][j];
                }
            }
        }

        //输出稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"
            +array2[i][1]+"\t"
            +array2[i][2]+"\t"
            );
        }

        System.out.println("======================");

        System.out.println("还原");

        
        //array2是稀疏数组
        
        
        //1、读取稀疏数组          array2[0][0]稀疏数组的行  array2[0][1]稀疏数组的列
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //这里是动态创建二维数组，其中包含默认创建 所以初始化值都为0
        
        

        //2.给其中的元素还原值   遍历出每个数组中的具体的值
        //第0行是头部信息，不用去读,(因为头部信息是来记录稀疏数组规格的)
        //发生越界异常的原因 ：从0开始读的话，array2[0][0]=11   array3[11][11]  超过了索引下标 发生越界异常
        for (int i = 1; i < array2.length; i++) {
            //稀疏数组的 （行 和列的值）来定位具体的值      具体的值
            //给二维数组赋具体的值
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
            
            
        }

        //打印
        System.out.println("输出还原的数组");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }


}

}

结果

0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
====================================
有效值的个数：2
稀疏数组
11	11	2	
1	2	1	
2	3	2	
======================
还原
输出还原的数组
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	

把稀疏数组总结成一句话，记录有效的坐标

面向对象编程

Java的核心思想就是OOP（Object Oriented（面向） Programming）面向对象编程

1、初识面向对象

2、方法回顾和加深

3、对象的创建分析

4、面向对象三大特性

5、抽象类和接口

6、内部类及OOP实战

面向过程 & 面向对象

• 面向过程思想 ：强调步骤

  • 步骤清晰简单，第一步做什么，第二部做什么。。。。
  • 面对过程适合处理一些较为简单的问题

• 面向对象思想：强调对象

  • 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的
  • 细节进行面向过程的思索。
  • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！

• 对于描述复杂的事务，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是没具体到微观操作，仍然需要面向过程的思路去处理。

所以说面向对象和面向过程是不可分割的，面向对象相当于一个框架，面向过程相当于一个具体的流程

什么是面向对象

• 面向对象编程OOP（Object Oriented（面向） Programming）面向对象编程

• 面向对象编程的本质就是：以类的方式组织代码，以对象的形式（封装）数据 要深刻理解这句话

• 抽象：编程思想

• 三大特性：

  • 封装
  • 继承
  • 多态

• 从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象

• 从代码运行角度来考虑是先有类后有对象。类是对象的模板。

回顾方法及加深

• 方法的定义
  • 修饰符
  • 返回类型
  • break和return的区别
  • 方法名
  • 参数列表
  • 异常抛出
• 方法的调用
  • 静态方法
  • 非静态方法
  • 形参和实参
  • 值传递和引用传递
  • this关键字

break和return的区别

break：跳出switch，结束循环

return：表示方法结束，返回一个结果

//在一个没有返回值的方法中 ，直接return 可以表示方法结束
public void aa(){
        return;
    }

静态方法

 public static void a(){
        b(); //这是错误调用
    }
    
    public void b(){
        
    }

静态方法无法调用非静态方法

原因：static标识的是和类一起加载的，所以说时间片特别早，类存在的时候，这个方法就存在了

这个方法是在类实例化之后才存在

所以一个存在的东西调用一个不存在的东西会报错

类与对象的关系

• 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物

• 属性：就是该事物的状态信息。

• 行为：就是该事物能够做什么。

  • 动物、植物、手机、电脑…
  • Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为

• 对象是抽象概念的具体实例

  • 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。
  • 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念

• 类是对一类事物的描述，是抽象的。

• 对象是一类事物的实例，是具体的。

• 类是对象的模板，对象是类的实体。

创建与初始化对象

• 使用new关键字创建对象

• 使用new关键字创建的时候（本质是调用构造器），除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用

• 类中的构造器也称为构造方法，是在进行创建对象的时候必须是要调用的。并且构造器有以下两个特点：

  1. 必须和类的名字相同
  2. 必须没有返回类型，也不能写void

• 构造器必须要掌握

注意：一旦定义了有参构造，无参就必须显示定义

创建对象内存分析

简单的内存分析（简单的内存图）

小结类与对象

属性：字段（Field） 成员变量

默认初始化：

数字： 0 0.0

boolean: false

char:u0000

引用：null

对象内存图

一个对象，调用一个方法内存图

通过上图，我们可以理解，在栈内存中运行的方法，遵循"先进后出，后进先出"的原则。变量p指向堆内存中 的空间，寻找方法信息，去执行该方法。

但是，这里依然有问题存在。创建多个对象时，如果每个对象内部都保存一份方法信息，这就非常浪费内存 了，因为所有对象的方法信息都是一样的。那么如何解决这个问题呢？请看如下图解

两个对象，调用同一方法内存图

对象调用方法时，根据对象中方法标记（地址值），去类中寻找方法信息。这样哪怕是多个对象，方法信息 只保存一份，节约内存空间。

一个引用，作为参数传递到方法中内存图

引用类型作为参数，传递的是地址值

成员变量和局部变量区别

变量根据定义位置的不同，我们给变量起了不同的名字。：

在类中的位置不同 重点

成员变量：类中，方法外

局部变量：方法中或者方法声明上(形式参数)

作用范围不一样 重点

成员变量：类中

局部变量：方法中

初始化值的不同 重点

成员变量：有默认值

局部变量：没有默认值。必须先定义，赋值，最后使用

在内存中的位置不同 了解

成员变量：堆内存

局部变量：栈内存

生命周期不同 了解

成员变量：随着对象的创建而存在，随着对象的消失而消失

局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

面向对象三大特性

封装

• 封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的 方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

原则

将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。

封装的步骤

1. 使用 private 关键字来修饰成员变量。

2. 对需要访问的成员变量，提供对应的一对 getXxx 方法 、 setXxx 方法。

封装的好处

1、提高程序的安全性，保护数据

2、隐藏代码的实现细节

3、统一接口（get/set）

4、系统可维护增加了

封装关键字——private关键字

private的含义

1. private是一个权限修饰符，代表最小权限。

2. 可以修饰成员变量和成员方法。

3. 被private修饰后的成员变量和成员方法，只在本类中才能访问。

标准代码–JavaBean

JavaBean 是 Java语言编写类的一种标准规范。符合 JavaBean 的类，要求类必须是具体的和公共的，并且具有无 参数的构造方法，建议有有参构造方法,提供用来操作成员变量的 set 和 get 方法。

继承

由来

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要 继承那一个类即可。

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

• extands的的意思是”扩展“。子类是父类的扩展。

• Java中类只有单继承，没有多继承

• 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。

• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。

• 子类和父类之间，从意义上讲应该具有” is a“的关系

继承后的特点

成员变量重名

如果子类父类中出现重名的成员变量，这时的访问是有影响的。

子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用 super 关键字，修饰

如：

super.变量

：Fu 类中的成员变量是非私有的，子类中可以直接访问。若Fu 类中的成员变量私有了，子类是不能 直接访问的。通常编码时，我们遵循封装的原则，使用private修饰成员变量，那么如何访问父类的私有成员 变量呢？对！可以在父类中提供公共的getXxx方法和setXxx方法。

继承后的特点——成员方法

super和this

在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空 间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构

造方法调用时，一定先调用父类的构造方法。理解图解如下：

spuer

super代表父类

继承后的构造方法的特点

在自类构造器中默认调用了super（）也就是父类无参的构造，而且这个父类的构造隐式的放在第一行

class Person {
    //各种字段
   public  Person(){
       System.out.println("父类初始化了");
   }
}



public son abc1 extends Person{

   public son(){
       //这个只能放在子类构造器的第一行
       //也可以不写，隐式写了
   		super()；
 	      System.out.println("子类初始化了");
    }

}


class  Test{
    public static void main(String[] args) {
        abc1 abc1 = new abc1();
    }
}


输出
父类初始化了
子类初始化了
说明子类初始化之前默认先初始化父类
    说明子类调用构造器初始化之前一定会先让父类初始化，无论是有参构造还是无参构造

当你父类没有无参构造的时候，子类也没法写无参构造（就必须自己显示写有参构造器在子类构造器中）

public son(){
       //这个只能放在第一行
       super("1","2",3);//父类的有参构造
        System.out.println("子类初始化了");
    }

//这里还出现一个问题，如果你想调用自己的构造器
//this()和super()都是调用构造方法不能共存，因为都要放在第一位

this

this代表所在类的当前对象的引用（地址值），即对象自己的引用。

记住 ：方法被哪个对象调用，方法中的this就代表那个对象。即谁在调用，this就代表谁。

class Person{
    String name ="123";
public void test(String name){
	this.name;//也等同于 name因为this可以省略
}
}


psvm{
    //这里调用test方法的时候，this指代的的就是当前的Person对象
    new Person().test();
    
}

super注意点：

1. super调用父类的构造方法，必须在构造方法的第一个
2. super必须只能出现在子类的方法或者构造方法中！
3. super和this不能同时调用构造方法

this注意点：

代表的对象不同：

​ this：本身调用者这个对象

​ super：代表父类对象的应用

前提：

​ this：没有继承也可以使用

​ super：只能在继承条件才可以使用

构造方法：

thi();本类的构造

super()：父类的构造

私有的东西（private修饰）无法被继承

继承是最核心的东西，封装是关于底层的，继承相当于整个宏观的把握，多态也必须具有继承的前提

方法重写

重写前提：需要有继承关系，子类重写父类的方法！

​ 1、方法名必须相同

​ 2、参数列表必须相同

​ 3、修饰符：范围可以扩大 （但是不可以缩小） 如父类是private子类可以是public

​ 4、抛出的异常：范围，可以被缩小，但不能扩大

总结：子类的方法和父类的方法必须一致；方法体不同

静态方法不能重写 @Override标志在子类方法上，用于判断该方法是否是被重写的方法

如果是静态方法的调用只和左边（类）有关 因为静态方法在类一创建的时候初始化了

 public static void main(String[] args) {

        A a = new A();
        a.test(); //A

     //父类引用指向子类对象
        B b =new A();
        b.test(); //B
    }


public class B{
    public static void test(){
        System.out.println("B==========");
    }

}


public class A extends B {
    public static void test(){
        System.out.println("A==========");
    }
}

私有方法也不能被重写

真正实现重写的案例

重写 只跟非静态方法有关 （一般idea都有提式旁边有o向下的箭头）

如果调用重写了的方法，看右边（具体实现（被实现覆盖了）

   public static void main(String[] args) {

        A a = new A();
        a.test(); //A

        //父类引用指向子类对象
        B b =new A();
        b.test(); //A  因为子类重写（覆盖）了父类的方法，所以执行子类的方法
    }


public class B{
    public  void test(){
        System.out.println("B==========");
    }

}


public class A extends B {


    public  void test(){
        System.out.println("A==========");
    }
}

为什么需要重写：

1、父类的功能，子类不一定需要，或者不一定满足！

重写的应用

子类可以根据需要，定义特定于自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从 而进行扩展增强。比如新的手机增加来电显示头像的功能，

多态

引入

多态是继封装、继承之后，面向对象的第三大特性

生活中，比如跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也

是不一样的。可见，==同一行为，通过不同的事物，可以体现出来的不同的形态。==多态，描述的就是这样的状态。

定义

多态： 是指同一行为，具有多个不同表现形式。

• 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

• 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

• 多态存在的条件

  • 有继承或者实现关系
  • 子类重写父类方法
  • 父类引用指向子类对象

• 注意：多态是方法的多态，属性没有多态性。

public class Person {
    
    public void run(){
        System.out.println("person");
    }
}


public class Stundet extends Person {

    @Override
    public void run() {
        System.out.println("son");
    }

    public void eat(){
        System.out.println("eat");
    }
}



public static void main(String[] args) {

        //一个对象的实际类型是确定的
        //new Stundet();
        //new Person();


        //可以指向的引用类型就不确定了：父类的引用指向子类对象

        //Student能调用的方法都是自己的或者继承父类的！
        Stundet s1 = new Stundet();

        //Person父类型，可以指向子类，但是不能调用子类独有的方法（不包括静态方法）
        Person s2= new Stundet();


        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
        s2.run(); //son  因为子类重写了父类的方法0，所以执行了子类的方法
        s1.eat();//son

    
    
    //但是s2却不能执行s1中的eat 

    }

多态的体现

父类引用指向子类对象

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写 后方法。

多态注意事项：

1、多态释是方法的多态，属性没有多态

2、父类和子类，有联系。可能会产生类型转换ClassCastException！类型转换异常

3、存在条件：继承关系，方法需要重写 父类引用指向子类对象

多态的好处

定义父类

public abstract class Animal { 
    public abstract void eat();
}

定义子类：

class Cat extends Animal {
    public void eat() { 
        System.out.println("吃鱼");
    } 
}
class Dog extends Animal { 
    public void eat() {
        System.out.println("吃骨头");
    } }

定义测试类：

public class Test {
    public static void main(String[] args) { 
        // 多态形式，创建对象
        Cat c = new Cat(); 
        Dog d = new Dog();
        // 调用showCatEat 
        showCatEat(c); 
        // 调用showDogEat
        showDogEat(d); 
        
        /*以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代 而执行效果一致 */
        showAnimalEat(c); 
        showAnimalEat(d); 
    }
    public static void showCatEat (Cat c){
        c.eat(); 
    }
    public static void showDogEat (Dog d){ 
        d.eat(); 
    }
    public static void showAnimalEat (Animal a){ a.eat();
                                               } }

由于多态特性的支持，showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当 然可以把Cat对象和Dog对象，传递给方法。

当eat方法执行时，多态规定，执行的是子类重写的方法，那么效果自然与showCatEat、showDogEat方法一致， 所以showAnimalEat完全可以替代以上两方法。

不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用 showAnimalEat都可以完成。

所以，多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。

instanceof

instanceof类型转换（引用类型之间的转换）

用来测试一个对象是否为一个类的实例

	boolean result = obj instanceof Class

其中 obj 为一个对象，Class 表示一个类或者一个接口，当 obj 为 Class 的对象，或者是其直接或间接子类，或者是其接口的实现类，结果result 都返回 true，否则返回false。

注意：编译器会检查 obj 是否能转换成右边的class类型，如果不能转换则直接报错，如果不能确定类型，则通过编译，具体看运行时定。

总结：****

1、父类引用指向子类对象

2、把子类转换为父类，向上转型

3、把父类转换为子类，向下转型：强制转换

4、方便方法的调用，减少重复的代码！简洁

static关键字详解

概述

关于static关键字的使用，它可以用来修饰成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属 于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。

定义和使用格式

类变量 ：使用static关键字修饰的成员变量

当 static 修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改 该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作

静态方法

当static修饰成员方法时，该方法称为类方法 。静态方法在声明中有 static ，建议使用类名来调用，而不需要 创建类的对象。调用方式非常简单。

静态方法调用的注意事项：

• 静态方法可以直接访问类变量和静态方法。

• 静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。

• 静态方法中，不能使用this关键字。

静态方法只能访问静态成员

被static修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员，原因即多个对象均属 于一个类，共享使用同一个静态成员，但是不建议，会出现警告信息。

静态原理图解

static 修饰的内容：

• 是随着类的加载而加载的，且只加载一次。

• 存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。

• 它优先于对象存在，所以，可以被所有对象共享。

[

静态代码块

• 静态代码块：定义在成员位置，使用static修饰的代码块{ }。
  • 位置：类中方法外。
  • 执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。

 {
        System.out.println("匿名代码块");
    }
    
    
    static {
        System.out.println("静态代码块");
    }
    
    public Main(){
        System.out.println("构造器");
    }
    

 public static void main(String[] args) {

        Main main = new Main();

    }

输出：

静态代码块
匿名代码块
构造器

发现：静态代码块最先执行，然后是匿名。最后是构造器

 public static void main(String[] args) {

        Main main = new Main();
        Main main1 = new Main();

    }

输出

静态代码块
匿名代码块
构造器
匿名代码块
构造器

发现静态代码块在类被加载的时候就只执行一次

匿名代码块一般可以用来赋初始值，因为是跟对象同时产生的，而且是在构造方法之前

新特性

静态导入包

import static java.lang.Math.random;

就可以直接使用random这个方法了

代码块

静态代码块在类被加载的时候执行，只执行一次。不管NEW多少次都执行一次！再创建新对象都不执行了！！！

java中的匿名代码块又称为构造代码块，构造代码块优先于构造方法（创建对象的时候执行）

类的加载顺序

1、有继承关系的加载顺序
关于关键字static，大家 都知道它是静态的，相当于一个全局变量，也就是这个属性或者方法是可以通过类来访问，当class文件被加载进内存，开始初始化的时候，被static修饰的变量或者方法即被分配了内存，而其他变量是在对象被创建后，才被分配了内存的。

所以在类中，加载顺序为：

1.首先加载父类的静态字段或者静态语句块

2.子类的静态字段或静态语句块

3.父类普通变量以及语句块

4.父类构造方法被加载

5.子类变量或者语句块被加载

6.子类构造方法被加载

代码如下
父类代码

public class FuLei {
static int num  = 5;//1.首先被加载
static{
    System.out.println("静态语句块已经被加载"+num); //2.被加载
}
int count = 0; //5.被加载
{
    System.out.println("普通语句块"+count++);//6.被加载
}
public FuLei(){
    System.out.println("父类的构造方法在这时候加载count="+count);//7.被加载
}
}

子类代码

public class ZiLei extends FuLei {
static{
    System.out.println("静态语句块和静态变量被初始化的顺序与代码先后顺序有关"); //3.被加载
}
static int num = 45;//4.被加载
int numre = 0; //8.被加载
{
    numre++;
    System.out.println("numre"+numre);//9.被加载

}
public ZiLei(){
    System.out.println("子类构造方法");//10.被加载
}
public static void main(String[] args){
    ZiLei ht = new ZiLei();
}
}

输出结果

静态语句块已经被加载5
静态语句块和静态变量被初始化的顺序与代码先后顺序有关
普通语句块0
父类的构造方法在这时候加载count=1
numre1
子类构造方法

静态语句块和静态变量被初始化的顺序与代码先后顺序有关

2、没有继承关系的加载顺序
代码如下

public class Test {
public static void main(String[] args) {
    new Test();                         //4.第四步，new一个类，但在new之前要处理匿名代码块
}

static int num = 4;                    //2.第二步，静态变量和静态代码块的加载顺序由编写先后决定

{
    num += 3;
    System.out.println("b");           //5.第五步，按照顺序加载匿名代码块，代码块中有打印
}

int a = 5;                             //6.第六步，按照顺序加载变量

{ // 成员变量第三个
    System.out.println("c");           //7.第七步，按照顺序打印c
}

Test() { // 类的构造函数，第四个加载
    System.out.println("d");           //8.第八步，最后加载构造函数，完成对象的建立
}

static {                              // 3.第三步，静态块，然后执行静态代码块，因为有输出，故打印a
    System.out.println("a");
}

static void run()                    // 静态方法，调用的时候才加载// 注意看，e没有加载
{
    System.out.println("e");
}
}

输出结果

a
b
c
d

静态代码块（只加载一次）
构造方法（创建一个实例就加载一次）
静态方法，调用的时候才会加载，不调用的时候不会加载
静态语句块和静态变量被初始化的顺序与代码先后顺序有关

抽象类

由来

父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有

意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法

的类就是抽象类。

1、不能new，只能由子类去实现

2、抽象类可以写普通的方法

3、抽象方法必须在抽象类中

思考题

抽象类存在构造器吗？

抽象类可以有构造方法，只是不能直接创建抽象类的实例对象而已。在继承了抽象类的子类中通过super()或super(参数列表)调用抽象类中的构造方法。

存在的意义？

将一个共用的东西抽象出来，每创建一个东西就去继承这个抽象类（改掉一些不必要的东西）。说白了就是为了提高开发效率

接口

• 普通类：只有具体实现
• 抽象类：具体实现和规范（抽象方法）都有！
• 接口：只有规范！

约束和实现接口分离：就以后开发，进公司都是面向接口编程

• 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是… 则必须能…”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。。。
• 接口的本质是契约，就像我们人间的法律一样，定制好后大家都能遵守
• oo（面向对象）的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能录的语言（比如C++、java、c#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象

接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法 （JDK 9）。

//抽象方法：使用 abstract 关键字修饰，可以省略，没有方法体。该方法供子类实现使用。
public interface InterFaceName { 
    public abstract void method();
}

//默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。 

public default void method() {
    // 执行语句 
    

}


//静态方法：使用 static 修饰，供接口直接调用。 代码如下：

public static void method2() {
    // 执行语句 
}


//私有方法：使用 private 修饰，供接口中的默认方法或者静态方法调用。
//如果一个接口中有多个默认方法，并且方法中有重复的内容，那么可以抽取出来，封装到私有方法中，供默认方法 去调用。
//私有方法是对默认方法和静态方法的辅助。
private void method() {
    // 执行语句
}
public default void method1() {
    //只有默认方法可以调用接口中的私有方法
     method()；
 	}

默认方法和静态方法可以调用私有静态方法

接口的定义

它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并 不是类，而是另外一种引用数据类型。

非抽象子类实现接口：

1、必须重写接口中所有抽象方法。

2继承了接口的默认方法，即可以直接调用，也可以重写

一个类可以实现多个接口

一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用 extends 关键字，子接口继

承父接口的方法。**如果父接口中的默认方法有重名的，那么子接口需要重写一次。**代码如下

interface A { 
    public default void method(){ System.out.println("AAAAAAAAAAAAAAAAAAA");
                                } 
}

interface B { 
    public default void method(){ System.out.println("BBBBBBBBBBBBBBBBBBB");
 } 
}

public interface  AbstractTest extends A,B{
		@Override 
    public default void method() { System.out.println("DDDDDDDDDDDDDD"); 
    }
}

然后AbstractTest的实现类就必须实现以上所有接口中的方法

子接口重写默认方法时，default关键字可以保留。

子类重写接口默认方法时，default关键字不可以保留。

final关键字

概述：

学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承 API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了 final 关键字， 用于修饰不可改变内容。

• final： 不可改变。可以用于修饰类、方法和变量。
  • 类：被修饰的类，不能被继承。
  • 方法：被修饰的方法，不能被重写。
  • 变量：被修饰的变量，不能被重新赋值。

修饰变量

局部变量–基本类型

基本类型的局部变量，被fifinal修饰后，只能赋值一次，不能再更改。

final int a;
// 第一次赋值 
a = 10; 
// 第二次赋值
a = 20; // 报错,不可重新赋值


// 声明变量，直接赋值，使用final修饰 
final int b = 10;
// 第二次赋值 
b = 20; // 报错,不可重新赋值

不要混淆喽

可以通过编译，并且不会报错

for (int i = 0; i < 10; i++) {
    final int c = i;
    System.out.println(c);
}

因为每次循环，都是一次新的变量c。

局部变量–引用类型

引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的 修改，

public class FinalDemo2 { 
    public static void main(String[] args) { 
        // 创建 User 对象 
        final User u = new User(); 
        // 创建 另一个 User对象
       // u = new User(); // 报错，指向了新的对象，地址值改变
        。 // 调用setName方法
            u.setName("张三"); //对象内部的成员变量值可以修改
    } }

成员变量

成员变量涉及到初始化的问题，初始化方式有两种，只能二选一：

• 显式初始化

  public class User { 
      final String USERNAME = "张三";
      private int age;
  }
  

• 构造方法初始化。

public class User { 
    final String USERNAME ;
    private int age; 
    public User(String username, int age) { 
        this.USERNAME = username; 
        this.age = age;
    } }

被final修饰的常量名称，一般都有书写规范，所有字母都大写

内部类

• 内部类就是在一个类的内部再定义一个类，

• 1、成员内部类

  public class Outer {
  
      //成员内部类
      public class inner{
          
      }
  }
  
  

  创建成员内部类对象

  外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
  
  //等同于
  Outer outer=new Outer(); //创建外部类对象
  Inner i = outer.new Inner();//创建内部类对象
  

  如果外部类和内部类具有相同的成员变量或方法，内部类可以直接访问内部类的成员变量或方法，但如果内部类访问外部类的成员变量或者方法时，需要使用·类名.this.变量名；

  public class Outer {
      String name = "123";
  
      public class Inner{
  
          String name = "321";
          public void show(){
              System.out.println(name);
              System.out.println(Outer.this.name);
          }
      }
  
  
      public static void main(String[] args) {
          Outer.Inner inner = new Outer().new Inner();
          inner.show();
  
      }
  }
  
  输出
  321
  123
  

• 2、静态内部类

静态内部类就是用static修饰的内部类，这种内部类的特点是：

1、静态内部类不能直接访问外部类的非静态成员，但，可以通过new 外部类().成员的方式访问；

public class Outer {
    String name = "123";

    public static class Inner{
        public void show(){

            System.out.println(new Outer().name);
        }
    }


    public static void main(String[] args) {

        //在这里静态类先于OUter执行
        Inner inner = new Inner();
        inner.show();
    }
}

输出
123

2、如果外部类的静态成员与内部类的静态成员相同， 可以通过"类名.静态成员"来访问外部类的静态成员；如果不同，可以直接调用外部类的静态成员名。

public class Outer {
   static String name = "123";
   static String name1 = "123";

    public static class Inner{
        static String name = "321";
        static String name2 = "321";


        public void show(){

            System.out.println(Outer.name);
            System.out.println(Inner.name);
            System.out.println(name);

            //如果不同，可以直接调用外部类的静态成员名
            System.out.println(name1);
            System.out.println(name2);
        }
    }


    public static void main(String[] args) {

        Inner inner = new Inner();
        inner.show();
    }
}


//输出
123
321
321
123
321

3、创建静态内部类的对象时，不需要外部类的对象，可以直接创建；

 public static void main(String[] args) {

     //不需要外部类对象，初始化顺序静态优先
        Inner inner = new Inner();
        inner.show();
    }

• 3、局部内部类（局部内部类）

1、方法内部类就是定义在外部类的方法中，方法内部类只在该方法内可以用

public class Outer {

        public void show(){
            final  int a = 25;
            
            //局部内部类
              class Inner{
                  int c = 2;
                  public void print(){
                      //访问外部类的方法中的常量a
                      System.out.println(a);
                      //访问内部类中的变量c
                      System.out.println(c);
                  }
              }
            Inner inner = new Inner();
            inner.print();
        }

    public static void main(String[] args) {

        Outer outer = new Outer();
        outer.show();
    }
}

2、由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。

• 4、匿名内部类==【重点】==

匿名内部类 ：是内部类的简化写法。它的本质是一个 带具体实现的 父类或者父接口的 匿名的 子类对象。

开发中，最常用到的内部类就是匿名内部类了

1. 定义子类

2. 重写接口中的方法

3. 创建子类对象

4. 调用重写后的方法

前提

匿名内部类必须继承一个父类或者实现一个父接口。

格式

new 父类名或者接口名(){ 
    // 方法重写 
    @Override
    public void method() { 
        // 执行语句 
    } };

以接口为例，匿名内部类的使用，代码如下：

定义接口

public interface FlyAble{ 
    void fly();
}

创建匿名内部类，并调用：

public class InnerDemo {
    public static void main(String[] args) {
        /*1.等号右边:是匿名内部类，定义并创建该接口的子类对象 2.等号左边:是多态赋值,接口类型引用指向子类对象 */
        FlyAble f = new FlyAble(){ 
            public void fly() {
                System.out.println("我飞了~~~");
            } };
        //调用 fly方法,执行重写后的方法
        f.fly();
    } }

通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。代码如下：

public class InnerDemo2 { 
    public static void main(String[] args) {
        /*1.等号右边:定义并创建该接口的子类对象 2.等号左边:是多态,接口类型引用指向子类对象 */
        FlyAble f = new FlyAble(){ 
            public void fly() { 
                System.out.println("我飞了~~~");
            }
        };
        
        
        // 将f传递给showFly方法中 
        showFly(f);
    }
    public static void showFly(FlyAble f) { 
        f.fly();
    }
}

以上两步，也可以简化为一步，代码如下：

public class InnerDemo3 { 
    public static void main(String[] args) {
        /*创建匿名内部类,直接传递给showFly(FlyAble f) */
        showFly( new FlyAble(){
            public void fly() { 
                System.out.println("我飞了~~~");
            } }); 
    }
    
    
    public static void showFly(FlyAble f) {
        f.fly();
    } }

一个java类中可以有多个class类，但是只能有一个public class

API

概述

API(Application Programming Interface)，应用程序编程接口。Java API是一本程序员的 字典 ，是JDK中提供给 我们使用的类的说明文档。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学 习这些类如何使用即可。所以我们可以通过查询API的方式，来学习Java提供的类，并得知如何使用它们

常用API

Object类

概述

java.lang.Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。

如果一个类没有特别指定父类， 那么默认则继承自Object类

根据JDK源代码及Object类的API文档，Object类当中包含的方法有11个。今天我们主要学习其中的2个：

• public String toString()：返回该对象的字符串表示。
• public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。（默认是比较两个对象的地址值是否相等）

toString方法

• public String toString()：返回该对象的字符串表示。

toString方法返回该对象的字符串表示，==其实该字符串内容就是对象的类型+@+内存地址值。==由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

equals方法

• public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。

调用成员方法equals并指定参数为另一个对象，则可以判断这两个对象是否是相同的。这里的“相同”有默认和自定义两种方式。

默认地址比较

如果没有覆盖重写equals方法，那么Object类中默认进行==运算符的对象地址比较，只要不是同一个对象，结果必然为false。

对象内容比较

如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以覆盖重写equals方法。例如：

Objects类

java.util.Objects类

在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。

在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题。方法如下：

• public static boolean equals(Object a, Object b):判断两个对象是否相等。

我们可以查看一下源码，学习一下：

public static boolean equals(Object a, Object b) {  
    return (a == b) || (a != null && a.equals(b));  
}

日期时间类

Date类

概述

java.util.Date类 表示特定的瞬间，精确到毫秒。

续查阅Date类的描述，发现Date拥有多个构造函数，只是部分已经过时，但是其中有未过时的构造函数可以把毫秒值转成日期对象。

• public Date()：分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。

		Date date = new Date();
        System.out.println(date);
		//Fri Aug 14 16:47:36 CST 2020

• public Date(long date)：分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00 GMT）以来的指定毫秒数。

		 Date date = new Date(0L);
        System.out.println(date);
		//Thu Jan 01 08:00:00 CST 1970

:在使用println方法时，会自动调用Date类中的toString方法。Date类对Object类中的toString方法进行了覆盖重写，所以结果为指定格式的字符串。

常用方法

Date类中的多数方法已经过时，常用的方法有：

• public long getTime() 把日期对象转换成对应的时间毫秒值。

DateFormat类

format（格式化）

java.text.DateFormat 是日期/时间格式化子类的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。

• 格式化：按照指定的格式，从Date对象转换为String对象。
• 解析：按照指定的格式，从String对象转换为Date对象。

构造方法

由于DateFormat为抽象类，不能直接使用，所以需要常用的子类java.text.SimpleDateFormat。这个类需要一个模式（格式）来指定格式化或解析的标准。构造方法为：

• public SimpleDateFormat(String pattern)：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。 pattern（模式）

参数pattern是一个字符串，代表日期时间的自定义格式。

格式规则

标识字母（区分大小写）	含义
y	年
M	月
d	日
H	时
m	分
s	秒

备注：更详细的格式规则，可以参考SimpleDateFormat类的API文档0。

常用方法

DateFormat类的常用方法有：

• public String format(Date date)：将Date对象格式化为字符串。
• public Date parse(String source)：将字符串解析为Date对象。

format方法

		Date date = new Date();
        DateFormat dateFormat = new 
        SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
        System.out.println(dateFormat.format(date));
//输出
2020-07-15 15:07:19

这个日期格式化类空参构造格式化日期类

20-8-15 下午3:11

parse方法

 			DateFormat dateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
        try {
            System.out.println(dateFormat.parse("2020-13-15 15:13:50"));
        } catch (ParseException e) {
            e.printStackTrace();
        }

Calendar类

概念

java.util.Calendar是日历类，在Date后出现，替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取。日历类就是方便获取各个时间属性的。

获取方式

Calendar为抽象类，由于语言敏感性，Calendar类在创建对象时并非直接创建，而是通过静态方法创建，返回子类对象，如下：

Calendar静态方法

• public static Calendar getInstance()：使用默认时区和语言环境获得一个日历

常用方法

根据Calendar类的API文档，常用方法有：

• public int get(int field)：返回给定日历字段的值。
• public void set(int field, int value)：将给定的日历字段设置为给定值。
• public abstract void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。
• public Date getTime()：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。

Calendar类中提供很多成员常量，代表给定的日历字段：

字段值	含义
YEAR	年
MONTH	月（从0开始，可以+1使用）
DAY_OF_MONTH	月中的天（几号）
HOUR	时（12小时制）
HOUR_OF_DAY	时（24小时制）
MINUTE	分
SECOND	秒
DAY_OF_WEEK	周中的天（周几，周日为1，可以-1使用）

get/set方法

get方法用来获取指定字段的值，set方法可以把日历设置到具体任何一个时间，代码使用演示：

set(int year ,int month,int date) 
set(int year ,int month,int date,int hour,int minute) 
set(int year ,int month,int date,int hour,int minute,int second) 

  		Calendar calendar = Calendar.getInstance();

        System.out.println(calendar.get(Calendar.YEAR));


        calendar.set(Calendar.YEAR,1997);
        System.out.println(calendar.get(Calendar.YEAR));
//输出
2020
1997

add方法

add方法可以对指定日历字段的值进行加减操作，如果第二个参数为正数则加上偏移量，如果为负数则减去偏移量。代码如：

calendar.add(Calendar.YEAR,-2); //给当前年减去2年
calendar.add(Calendar.YEAR,2);//给当前年加2年

getTime方法

Calendar中的getTime方法并不是获取毫秒时刻，而是拿到对应的Date对象。

	    Calendar calendar = Calendar.getInstance();
        Date time = calendar.getTime();
        System.out.println(time);//	Sat Aug 15 15:37:58 CST 2020

getTimeMillis()获得当前时间的毫秒表示

小贴士：

​ 西方星期的开始为周日，中国为周一。

​ 在Calendar类中，月份的表示是以0-11代表1-12月。//月份要减 1 才能得到正确的时间

​ 日期是有大小关系的，时间靠后，时间越大。

System类

java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中，常用的方法有：

• public static long currentTimeMillis()：返回以毫秒为单位的当前时间。（获取当前系统时间与1970年01月01日00:00点之间的毫秒差值）

• public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。（就是将原数组指定位置的元素跟目标数组中对应位置的元素给替换掉）

  数组的拷贝动作是系统级的，性能很高。System.arraycopy方法具有5个参数，含义分别为：

  参数序号	参数名称	参数类型	参数含义
  1	src	Object	源数组
  2	srcPos	int	源数组索引起始位置
  3	dest	Object	目标数组
  4	destPos	int	目标数组索引起始位置
  5	length	int	复制元素个数

  代码如下

  		int[] src = new int[]{1,2,3,4,5};
          int[] dest = new int[]{6,7,8,9,10};
          System.arraycopy( src, 0, dest, 0, 3);
          /*代码运行后：两个数组中的元素发生了变化
           src数组元素[1,2,3,4,5]
           dest数组元素[1,2,3,9,10]
          */
  

Scanner类

用户交互Scanner

通过Scanner 类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据

import java.util.Scanner;
Scanner s=new Scanner(System.in);//创建扫描器对象，用于接受键盘数据
if(s.hasNext()){
	String str=s.next();
	System.out.println(str);
}

s.close();//凡是属于IO流的类如果不关闭会一直占用资源，用完要关闭

next():

• 一定要读取到有效字符后才可以结束输入。
• 对输入有效字符之前遇到的空白，next()方法会自动将其去掉。
• 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
• next()不能得到带有空格的字符串

nextLine()

• 以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符
• 可以获得空白

Scanner进阶

s.hasNextInt(); //判断输入的是否是整数

Rabdom类

什么是Random类？

此类的实例用于生成伪随机数

例如，以下代码使用户能够得到一个随机数：

Random r = new Random(); 
int i = r.nextInt();

Random使用步骤

查看类

java.util.Random ：该类需要 import导入使后使用。

查看构造方法

public Random() ：创建一个新的随机数生成器。

查看成员方法

public int nextInt(int n) ：返回一个伪随机数，范围在 0 （包括==）==和 指定值 n （不包括）之间的

int 值。

使用Random类，生成10以内的随机数

 Random r = new Random();
int number = r.nextInt(10);
//生成10以内的随机数
int number = r.nextInt(100);
.....

ArrayList集合类

到目前为止，我们想存储对象数据，选择的容器，只有对象数组。而数组的长度是固定的，无法适应数据变化的需 求。为了解决这个问题，Java提供了另一个容器 java.util.ArrayList 集合类,让我们可以更便捷的存储和操作对 象数据。

什么是ArrayList类

java.util.ArrayList 是大小可变的数组的实现，存储在内的数据称为元素。此类提供一些方法来操作内部存储 的元素。 ArrayList 中可不断添加元素，其大小也自动增长

ArrayList使用步骤

查看类

java.util.ArrayList <E> ：该类需要 import导入使后使用。

，表示一种指定的数据类型，叫做泛型。 E ，取自Element（元素）的首字母。在出现 E 的地方，我们使 用一种引用数据类型将其替换即可，表示我们将存储哪种引用类型的元素。代码如下：

ArrayList<String>，ArrayList<Student>

查看构造方法

public ArrayList() ：构造一个内容为空的集合。

基本格式:

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

在JDK 7后,右侧泛型的尖括号之内可以留空，但是<>仍然要写。简化格式：

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

查看成员方法

public boolean add(E e) ： 将指定的元素添加到此集合的尾部。

参数 E e ，在构造ArrayList对象时， <E> 指定了什么数据类型，那么 add(E e) 方法中，只能添加什么数据 类型的对象。

使用ArrayList类，存储三个字符串元素，代码如下：

        ArrayList<String> arrayList = new ArrayList<>();

        System.out.println(arrayList);
        arrayList.add("123");
        arrayList.add("321");
        arrayList.add("1234567");

        System.out.println(arrayList);


//输出
[]
[123, 321, 1234567]

常用方法和遍历

对于元素的操作,基本体现在——增、删、查。常用的方法有：

public boolean add(E e) ：将指定的元素添加到此集合的尾部。

public E remove(int index) ：移除此集合中指定位置上的元素。返回被删除的元素。

public E get(int index) ：返回此集合中指定位置上的元素。返回获取的元素。

public int size() ：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。

如何存储基本数据类型

ArrayList对象不能存储基本类型，只能存储引用类型的数据。类似 不能写，但是存储基本数据类型对应的 包装类型是可以的。所以，想要存储基本类型数据， <> 中的数据类型，必须转换后才能编写，转换写法如下

基本类型	基本类型包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

我们发现，只有 Integer 和 Character 需要特殊记忆，其他基本类型只是首字母大写即可。那么存储基本类型数 据，

自动装箱与拆箱

 //自动装箱
 Integer total = 99;3
//自动拆箱
 int totalprim = total;

装箱就是自动将基本数据类型转换为包装器类型；拆箱就是自动将包装器类型转换为基本数据类型。

Arrays（操作数组类）

概述

java.util.Arrays 此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来 非常简单。

public static String toString(int[] a) ：返回指定数组内容的字符串表示形式。 (也就是用来打印数组的功能)

		 int[] array = {1,2,3,4,6};
		 String s = Arrays.toString(array);
         System.out.println(s);

public static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。

  int[] array = {5,4,7,6,9};

    Arrays.sort(array);
        
    System.out.println(Arrays.toString(array));

Math类

概述

java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具 类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单

基本运算

public static double abs(double a) ：返回 a的绝对值。

这个方法为重载方法，还可以对这些int/long/float/double类型返回绝对值

public static double ceil(double a) ：返回大于等于参数的最小的整数。

        System.out.println(Math.ceil(2.1));//3.0
		System.out.println(Math.ceil(-2.1));//-2.0

public static double floor(double a) ：返回小于等于参数最大的整数。

		System.out.println(Math.floor(2.1)); //2.0
        System.out.println(Math.floor(-2.1));//-3.0

public static long round(double a) ：返回最接近参数的 long。(相当于四舍五入方法)

		System.out.println(Math.round(2.1)); //2
        System.out.println(Math.round(2.5)); //3

String类

String类概述

java.lang.String 类代表字符串。Java程序中所有的字符串文字（例如 "abc" ）都可以被看作是实现此类的实

例。

类String中包括用于检查各个字符串的方法，比如用于比较字符串，搜索字符串，提取子字符串以及创建具有翻 译为大写或小写的所有字符的字符串的副本。

特点

1. 字符串不变：字符串的值在创建后不能被更改。

			String s1 = "abc";
            s1 += "d";
            System.out.println(s1);//abcd

内存中有"abc"，“abcd"两个对象，s1从指向"abc”，改变指向，指向了"abcd"。

2. 因为String对象是不可变的，所以它们可以被共享。

			String s1 = "abc";
            String s2 = "abc";
        System.out.println(s1==s2);//true

//内存只有一个“abc”对象被创建，同时被s1和s2共享

3. "abc" 等效于 char[] data={ 'a' , 'b' , 'c' } 。

			String str = "abc";

			//等效于
            char[] data = {'a','b','c'};
        	String string = new String(data);

String底层是靠字符数组实现的

字符串构造方式，以及其对象在堆内存中的图示

使用步骤

• 查看类

  • java.lang.String ：此类不需要导入。 （lang包下的类都不需要导入）

• 查看构造方法

  • public String() ：初始化新创建的 String对象，以使其表示空字符序列。
  • public String(char[] value) ：通过当前参数中的字符数组来构造新的String。
  • public String(byte[] bytes) ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的 String。
  • 构造举例，代码如下：

	//通过字节数组构造
		byte[] bytes = {97,98,99};
        String s = new String(bytes);

常用方法

判断功能的方法

• public boolean equals (Object anObject) ：比较字符串内容是否相同。

• public boolean equalsIgnoreCase (String anotherString) ：比较字符串内容是否相同，忽略大小 写。

获取功能的方法

• public int length () ：返回此字符串的长度。

• public String concat (String str) ：将指定的字符串连接到该字符串的末尾。

• public char charAt (int index) ：返回指定索引处的 char值。

• public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。

• public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符

串结尾。

• public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到 endIndex截取字符串。含beginIndex，不含endIndex。(是一个左闭右开区间)

转换功能的方法

• public char[] toCharArray () ：将此字符串转换为新的字符数组。

• public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。

• public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使 用replacement字符串替换。

这个方法注意一下，只要是里面存在target无论多少个都换成replacement

分割功能的办法

• public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。

		 String s = "a、bb、c、b";

		//使用字符串里面的  、 进行分割
		//分割之后返回一个字符串数组
        String[] split = s.split("、");

		//遍历数组
		for (String s1 : split) {
            System.out.println(s1);
        }

//输出
a
bb
c
b

StringBuilder类（字符串缓冲区）

字符串缓冲区，可以提高字符串的操作效率（看成一个长度可以变化的字符串）

字符串拼接问题

由于String类的对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象。例如：

 		String s = "Hello";
        s += "World";
        System.out.println(s);

在API中对String类有这样的描述：字符串是常量（String类被final修饰），它们的值在创建后不能被更改。

根据这句话分析我们的代码，其实总共产生了三个字符串，即"Hello"、"World"和"HelloWorld"。引用变量s首先指向Hello对象，最终指向拼接出来的新字符串对象，即HelloWord 。

由此可知，如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。为了解决这一问题，可以使用java.lang.StringBuilder类。

StringBuilder概述

查阅java.lang.StringBuilder的API，StringBuilder又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。

原来StringBuilder是个字符串的缓冲区，即它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。

它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。StringBuilder会自动维护数组的扩容。原理如下图所示：(默认16字符空间，超过自动扩充)

因为始终是一个数组，而正常的String对象，一个对象就一个数组

构造方法

根据StringBuilder的API文档，常用构造方法有2个：

• public StringBuilder()：构造一个空的StringBuilder容器。
• public StringBuilder(String str)：构造一个StringBuilder容器，并将字符串添加进去。

常用方法

StringBuilder常用的方法有2个：

• public StringBuilder append(...)：添加任意类型数据的字符串形式，并返回当前对象自身。
• public String toString()：将当前StringBuilder对象转换为String对象。

append方法

append方法具有多种重载形式，可以接收任意类型的参数。任何数据作为参数都会将对应的字符串内容添加到StringBuilder中。例如：

 StringBuilder stringBuilder = new StringBuilder();

        stringBuilder.append("大帅哥");
        stringBuilder.append(1);
        stringBuilder.append(true);
        stringBuilder.append(new char[]{'你','好','啊'});
        ......

备注：StringBuilder已经覆盖重写了Object当中的toString方法。

通过toString方法，StringBuilder对象将会转换为不可变的String对象。

包装类

概述

Java提供了两个类型系统，基本类型与引用类型，==使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，==如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，

我们可以使用包装类中的方法来操作这些基本类型的数据

如下：

基本类型	对应的包装类（位于java.lang包中）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

超级好记住：（除了int 和char其他都只要首字母大写就好了）

装箱与拆箱

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：

• 装箱：从基本类型转换为对应的包装类对象。

• 拆箱：从包装类对象转换为对应的基本类型。

用Integer与 int为例：（看懂代码即可）

基本数值---->包装对象

Integer i = new Integer(4);//使用构造函数函数
//将int类型转换为Integer
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法

包装对象---->基本数值

Integer i = new Integer(4);
int num = i.intValue();

自动装箱与自动拆箱

由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。例如：

Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后，再次装箱，把基本数值转成对象。

运算的时候要拆箱（基本数值类型才能运算）

基本类型与字符串之间的转换

基本类型转换为String

基本类型转换String总共有三种方式，查看课后资料可以得知，这里只讲最简单的一种方式：

基本类型直接与””相连接即可；如：34+""

String转换成对应的基本类型

除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：

除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：

• public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。
• public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。
• public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
• public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
• public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。
• public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。
• public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型。

代码使用（仅以Integer类的静态方法parseXxx为例）如：

注意:如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出java.lang.NumberFormatException异常。

Collection集合

集合概述

在前面基础班我们已经学习过并使用过集合ArrayList ,那么集合到底是什么呢?

• 集合：集合是java中提供的一种==容器，==可以用来存储多个数据。

集合和数组既然都是容器，它们有啥区别呢？

• 数组的长度是固定的。集合的长度是可变的。
• 数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。

集合框架

JAVASE提供了满足各种需求的API(就是一些类和接口)，在使用这些API前，先了解其继承与接口操作架构，才能了解何时采用哪个类，以及类之间如何彼此合作，从而达到灵活应用。

集合按照其存储结构可以分为两大类，分别是单列集合java.util.Collection和双列集合java.util.Map，今天我们主要学习Collection集合，在day04时讲解Map集合 。

• Collection：单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，分别是java.util.List和java.util.Set。其中，List的特点是元素有序、元素可重复。Set的特点是元素无序，而且不可重复。List接口的主要实现类有java.util.ArrayList和java.util.LinkedList，Set接口的主要实现类有java.util.HashSet和java.util.TreeSet。

从上面的描述可以看出JDK中提供了丰富的集合类库，为了便于初学者进行系统地学习，接下来通过一张图来描述整个集合类的继承体系。

其中，橙色框里填写的都是接口类型，而蓝色框里填写的都是具体的实现类。这几天将针对图中所列举的集合类进行逐一地讲解。

集合本身是一个工具，它存放在java.util包中。在Collection接口定义着单列集合框架中最最共性的内容。

Collection 常用功能

Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，这些方法可用于操作所有的单列集合。方法如下：

• public boolean add(E e)： 把给定的对象添加到当前集合中 。
• public void clear() :清空集合中所有的元素。
• public boolean remove(E e): 把给定的对象在当前集合中删除。
• public boolean contains(E e): 判断当前集合中是否包含给定的对象。
• public boolean isEmpty(): 判断当前集合是否为空。
• public int size(): 返回集合中元素的个数。
• public Object[] toArray(): 把集合中的元素，存储到数组中。
• public E get(int index)返回此列表下标对应的元素

Iterator迭代器

Iterator接口

在程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK专门提供了一个接口java.util.Iterator。Iterator接口也是Java集合中的一员，但它与Collection、Map接口有所不同，Collection接口与Map接口主要用于存储元素，而Iterator主要用于迭代访问（即遍历）Collection中的元素，因此Iterator对象也被称为迭代器。

想要遍历Collection集合，那么就要获取该集合迭代器完成迭代操作，下面介绍一下获取迭代器的方法：

• public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的。

下面介绍一下迭代的概念：

• 迭代：即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

Iterator接口的常用方法如下：

• public E next():返回迭代的下一个元素。
• public boolean hasNext():如果仍有元素可以迭代，则返回 true。

        ArrayList<Integer> list = new ArrayList<>();

        list.add(1);

        list.add(2);
        list.add(3);

        Iterator<Integer> iterator = list.iterator();

        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

tips:：在进行集合元素取出时，如果集合中已经没有元素了，还继续使用迭代器的next方法，将会发生java.util.NoSuchElementException没有集合元素的错误。

迭代器的实现原理

我们在之前案例已经完成了Iterator遍历集合的整个过程。当遍历集合时，首先通过调用集合的iterator()方法获得迭代器对象，然后使用hashNext()方法判断集合中是否存在下一个元素，如果存在，则调用next()方法将元素取出，否则说明已到达了集合末尾，停止遍历元素。

Iterator迭代器对象在遍历集合时，内部采用指针的方式来跟踪集合中的元素，为了让初学者能更好地理解迭代器的工作原理，接下来通过一个图例来演示Iterator对象迭代元素的过程：

1、获取迭代器的实现类对象，并且会把指针（索引指向集合的-1索引）

Iterator<Integer> iterator = list.iterator();

2、判断集合中还有没有下一个元素

while (iterator.hasNext()){
    Integer next = iterator.next();
}

3、iterator.next(); 做了两件事

1. 取出下一个元素
2. 会把指针向后移动一位

总结：

在调用Iterator的next方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当第一次调用迭代器的next方法后，迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用next方法时，迭代器的索引会指向第二个元素并将该元素返回，依此类推，直到hasNext方法返回false，表示到达了集合的末尾，终止对元素的遍历。

增强for

增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

for(元素的数据类型  变量 : Collection集合or数组){ 
  	//写操作代码
}

它用于遍历Collection和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。

tips: 新for循环必须有被遍历的目标。目标只能是Collection或者是数组。新式for仅仅作为遍历操作出现。

泛型

泛型与Javac

tip:- Java采用泛型擦除的机制来引入泛型，Java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和面取强制类型转换问题，但是，一旦编译完成，所有泛型和泛型有关的类型全部擦除

在前面学习集合时，我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。

 	Collection coll = new ArrayList();
		coll.add("abc");
		coll.add("itcast");
		coll.add(5);//由于集合没有做任何限定，任何类型都可以给其中存放
		Iterator it = coll.iterator();
		while(it.hasNext()){
			//需要打印每个字符串的长度,就要把迭代出来的对象转成String类型
			String str = (String) it.next();
			System.out.println(str.length());
		}

程序在运行时发生了问题java.lang.ClassCastException。 为什么会发生类型转换异常呢？ 我们来分析下：由于集合中什么类型的元素都可以存储。导致取出时强转引发运行时 ClassCastException。 怎么来解决这个问题呢？ Collection虽然可以存储各种对象，但实际上通常Collection只存储同一类型对象。例如都是存储字符串对象。因此在JDK5之后，新增了泛型(Generic)语法，让你在设计API时可以指定类或方法支持泛型，这样我们使用API的时候也变得更为简洁，并得到了编译时期的语法检查。

• 泛型：可以在类或方法中预知地使用未知的类型。

tips:一般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。

使用泛型的好处

上一节只是讲解了泛型的引入，那么泛型带来了哪些好处呢？

• 将运行时期的ClassCastException，转移到了编译时期变成了编译失败。
• 避免了类型强转的麻烦。

tips:泛型是数据类型的一部分，我们将类名与泛型合并一起看做数据类型

泛型的定义与使用

我们在集合中会大量使用到泛型，这里来完整地学习泛型知识。

泛型，用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。

定义和使用含有泛型的类

定义格式：

修饰符 class 类名<代表泛型的变量> {  }

例如，API中的ArrayList集合：

class ArrayList<E>{ 
    public boolean add(E e){ }

    public E get(int index){ }
   	....
}

使用泛型： 即什么时候确定泛型。

在创建对象的时候确定泛型

例如，ArrayList<String> list = new ArrayList<String>();

此时，变量E的值就是String类型,那么我们的类型就可以理解为：

class ArrayList<String>{ 
     public boolean add(String e){ }

     public String get(int index){  }
     ...
}

再例如，ArrayList<Integer> list = new ArrayList<Integer>();

此时，变量E的值就是Integer类型,那么我们的类型就可以理解为：

class ArrayList<Integer> { 
     public boolean add(Integer e) { }

     public Integer get(int index) {  }
     ...
}

举例自定义泛型类

public class MyGenericClass<MVP> {
	//没有MVP类型，在这里代表 未知的一种数据类型 未来传递什么就是什么类型
	private MVP mvp;
     
    public void setMVP(MVP mvp) {
        this.mvp = mvp;
    }
     
    public MVP getMVP() {
        return mvp;
    }
}

使用:

public class GenericClassDemo {
  	public static void main(String[] args) {		 
         // 创建一个泛型为String的类
         MyGenericClass<String> my = new MyGenericClass<String>();    	
         // 调用setMVP
         my.setMVP("大胡子登登");
         // 调用getMVP
         String mvp = my.getMVP();
         System.out.println(mvp);
         //创建一个泛型为Integer的类
         MyGenericClass<Integer> my2 = new MyGenericClass<Integer>(); 
         my2.setMVP(123);   	  
         Integer mvp2 = my2.getMVP();
    }
}

含有泛型的方法

定义格式：定义在方法的修饰符和返回值类型之间

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }

理解这句话:泛型是数据类型的一部分，我们将类名与泛型合并一起看做数据类型

例如，

public class MyGenericMethod {	  
    public <MVP> void show(MVP mvp) {
    	System.out.println(mvp.getClass());
    }
    
    public <MVP> MVP show2(MVP mvp) {	
    	return mvp;
    }
}

使用格式：在调用方法传值时，确定泛型的类型

传递什么类型的参数，泛型就是什么类型

public class GenericMethodDemo {
    public static void main(String[] args) {
        // 创建对象
        MyGenericMethod mm = new MyGenericMethod();
        // 演示看方法提示
        mm.show("aaa");
        mm.show(123);
        mm.show(12.45);
    }
}

含有泛型的接口

定义格式：

修饰符 interface接口名<代表泛型的变量> {  }

例如，

public interface MyGenericInterface<E>{
	public abstract void add(E e);
	
	public abstract E getE();  
}

使用格式：

1、定义类时确定泛型的类型

例如

public class MyImp1 implements MyGenericInterface<String> {
	@Override
    public void add(String e) {
        // 省略...
    }

	@Override
	public String getE() {
		return null;
	}
}

此时，泛型E的值就是String类型。

2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型

例如

public class MyImp2<E> implements MyGenericInterface<E> {
	@Override
	public void add(E e) {
       	 // 省略...
	}

	@Override
	public E getE() {
		return null;
	}
}

确定泛型：

/*
 * 使用
 */
public class GenericInterface {
    public static void main(String[] args) {
        MyImp2<String>  my = new MyImp2<String>();  
        my.add("aa");
    }
}

泛型通配符

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

通配符基本使用

泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。

此时只能接受数据,不能往该集合中存储数据。

举个例子大家理解使用即可：

public static void main(String[] args) {
    Collection<Intger> list1 = new ArrayList<Integer>();
    getElement(list1);
    Collection<String> list2 = new ArrayList<String>();
    getElement(list2);
}
public static void getElement(Collection<?> coll){}
//？代表可以接收任意类型

tips:泛型不存在继承关系 Collection list = new ArrayList();这种是错误的。

通配符高级使用----受限泛型

之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。

泛型的上限：

• 格式： 类型名称 <? extends 类 > 对象名称
• 意义： 只能接收该类型及其子类

泛型的下限：

• 格式： 类型名称 <? super 类 > 对象名称
• 意义： 只能接收该类型及其父类型

比如：现已知Object类，String 类，Number类，Integer类，其中Number是Integer的父类

public static void main(String[] args) {
    Collection<Integer> list1 = new ArrayList<Integer>();
    Collection<String> list2 = new ArrayList<String>();
    Collection<Number> list3 = new ArrayList<Number>();
    Collection<Object> list4 = new ArrayList<Object>();
    
    getElement(list1);
    getElement(list2);//报错  编译的时候就报错了
    getElement(list3);
    getElement(list4);//报错 编译的时候就报错了
  
    getElement2(list1);//报错 编译的时候就报错了
    getElement2(list2);//报错 编译的时候就报错了
    getElement2(list3);
    getElement2(list4);
  
}
// 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
public static void getElement(Collection<? extends Number> coll){}
// 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}

集合综合案例

案例介绍

按照斗地主的规则，完成洗牌发牌的动作。
具体规则：

使用54张牌打乱顺序,三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。

案例分析

• 准备牌：

  牌可以设计为一个ArrayList,每个字符串为一张牌。
  每张牌由花色数字两部分组成，我们可以使用花色集合与数字集合嵌套迭代完成每张牌的组装。
  牌由Collections类的shuffle方法进行随机排序。

• 发牌

  将每个人以及底牌设计为ArrayList,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。

• 看牌

  直接打印每个集合。

代码实现

import java.util.ArrayList;
import java.util.Collections;

public class Poker {
    public static void main(String[] args) {
        /*
        * 1: 准备牌操作
        */
        //1.1 创建牌盒 将来存储牌面的 
        ArrayList<String> pokerBox = new ArrayList<String>();
        //1.2 创建花色集合
        ArrayList<String> colors = new ArrayList<String>();

        //1.3 创建数字集合
        ArrayList<String> numbers = new ArrayList<String>();

        //1.4 分别给花色 以及 数字集合添加元素
        colors.add("♥");
        colors.add("♦");
        colors.add("♠");
        colors.add("♣");

        for(int i = 2;i<=10;i++){
            numbers.add(i+"");
        }
        numbers.add("J");
        numbers.add("Q");
        numbers.add("K");
        numbers.add("A");
        //1.5 创造牌  拼接牌操作
        // 拿出每一个花色  然后跟每一个数字 进行结合  存储到牌盒中
        for (String color : colors) {
            //color每一个花色 
            //遍历数字集合
            for(String number : numbers){
                //结合
                String card = color+number;
                //存储到牌盒中
                pokerBox.add(card);
            }
        }
        //1.6大王小王
        pokerBox.add("小☺");
        pokerBox.add("大☠");	  
        // System.out.println(pokerBox);
        //洗牌 是不是就是将  牌盒中 牌的索引打乱 
        // Collections类  工具类  都是 静态方法
        // shuffer方法   
        /*
         * static void shuffle(List<?> list) 
         *     使用默认随机源对指定列表进行置换。 
         */
        //2:洗牌
        Collections.shuffle(pokerBox);
        //3 发牌
        //3.1 创建 三个 玩家集合  创建一个底牌集合
        ArrayList<String> player1 = new ArrayList<String>();
        ArrayList<String> player2 = new ArrayList<String>();
        ArrayList<String> player3 = new ArrayList<String>();
        ArrayList<String> dipai = new ArrayList<String>();	  

        //遍历 牌盒  必须知道索引   
        for(int i = 0;i<pokerBox.size();i++){
            //获取 牌面
            String card = pokerBox.get(i);
            //留出三张底牌 存到 底牌集合中
            if(i>=51){//存到底牌集合中
                dipai.add(card);
            } else {
                //玩家1   %3  ==0
                if(i%3==0){
                  	player1.add(card);
                }else if(i%3==1){//玩家2
                  	player2.add(card);
                }else{//玩家3
                  	player3.add(card);
                }
            }
        }
        //看看
        System.out.println("令狐冲："+player1);
        System.out.println("田伯光："+player2);
        System.out.println("绿竹翁："+player3);
        System.out.println("底牌："+dipai);  
	}
}

数据结构

数据结构有什么用？

当你用着java里面的容器类很爽的时候，你有没有想过，怎么ArrayList就像一个无限扩充的数组，也好像链表之类的。好用吗？好用，这就是数据结构的用处，只不过你在不知不觉中使用了。

现实世界的存储，我们使用的工具和建模。每种数据结构有自己的优点和缺点，想想如果Google的数据用的是数组的存储，我们还能方便地查询到所需要的数据吗？而算法，在这么多的数据中如何做到最快的插入，查找，删除，也是在追求更快。

我们java是面向对象的语言，就好似自动档轿车，C语言好似手动档吉普。数据结构呢？是变速箱的工作原理。你完全可以不知道变速箱怎样工作，就把自动档的车子从 A点 开到 B点，而且未必就比懂得的人慢。写程序这件事，和开车一样，经验可以起到很大作用，但如果你不知道底层是怎么工作的，就永远只能开车，既不会修车，也不能造车。当然了，数据结构内容比较多，细细的学起来也是相对费功夫的，不可能达到一蹴而就。我们将常见的数据结构：堆栈、队列、数组、链表和红黑树 这几种给大家介绍一下，作为数据结构的入门，了解一下它们的特点即可。

常见的数据结构

数据存储的常用结构有：栈、队列、数组、链表和红黑树。

栈

• 栈：stack,又称堆栈，它是运算受限的线性表，其限制是仅允许在表的一端进行插入和删除操作，不允许在其他任何位置进行添加、查找、删除等操作。

简单的说：采用该结构的集合，对元素的存取有如下的特点

• 先进后出（即，存进去的元素，要在它后面的元素依次取出后，才能取出该元素）。例如，子弹压进弹夹，先压进去的子弹在下面，后压进去的子弹在上面，当开枪时，先弹出上面的子弹，然后才能弹出下面的子弹。

• 栈的入口、出口的都是栈的顶端位置。

这里两个名词需要注意：

• 压栈：就是存元素。即，把元素存储到栈的顶端位置，栈中已有元素依次向栈底方向移动一个位置。
• 弹栈：就是取元素。即，把栈的顶端位置元素取出，栈中已有元素依次向栈顶方向移动一个位置。

队列

• 队列：queue,简称队，它同堆栈一样，也是一种运算受限的线性表，其限制是仅允许在表的一端进行插入，而在表的另一端进行删除。

简单的说，采用该结构的集合，对元素的存取有如下的特点：

• 先进先出（即，存进去的元素，要在后它前面的元素依次取出后，才能取出该元素）。例如，小火车过山洞，车头先进去，车尾后进去；车头先出来，车尾后出来。
• 队列的入口、出口各占一侧。例如，下图中的左侧为入口，右侧为出口。

数组

• 数组:Array,是有序的元素序列，数组是在内存中开辟一段连续的空间，并在此空间存放元素。就像是一排出租屋，有100个房间，从001到100每个房间都有固定编号，通过编号就可以快速找到租房子的人。

简单的说,采用该结构的集合，对元素的存取有如下的特点：

• 查找元素快：通过索引，可以快速访问指定位置的元素

增删元素慢

• 指定索引位置增加元素：需要创建一个新数组，将指定新元素存储在指定索引位置，再把原数组元素根据索引，复制到新数组对应索引的位置。如下图

• **指定索引位置删除元素：**需要创建一个新数组，把原数组元素根据索引，复制到新数组对应索引的位置，原数组中指定索引位置元素不复制到新数组中。如下图

链表

链表是物理存储单元上非连续的、非顺序的存储结构，数据元素的逻辑顺序是通过链表的指针地址实现

• 链表:linked list,由一系列结点node（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分==：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域==，指针域有两个。

链表又分为单向链表和双向链表

单向链表：链表中有一条链子，不能保证元素的顺序（存储元素和取出元素的顺序有可能不一致）

双向链表：链表中有两条链子，有一条链子是准们记录元素的顺序，是一个有序的集合

双向链表可以保证元素的顺序（上一个节点能记住下一个节点的地址，下一个节点能记住上一个结点的地址）

简单的说，采用该结构的集合，对元素的存取有如下的特点：

• 查找元素慢：链表中的地址不是连续的，每次查询元素，都必须送头开始查询

• 增删元素快：链表结构，增加/删除一个元素，对链表的整体结构没有影响，所以增删快

  • 增加元素：只需要修改连接下个元素的地址即可。

删除元素：只需要修改连接下个元素的地址即可。

把300元素的链表给删了，然后把第一个元素的指向下一个元素的指针域改为0x99

添加元素
]

红黑树

• 二叉树：binary tree ,是每个结点不超过2的有序树（tree） 。

简单的理解，就是一种类似于我们生活中树的结构，只不过每个结点上都最多只能有两个子结点。

二叉树是每个节点最多有两个子树的树结构。顶上的叫根结点，两边被称作“左子树”和“右子树”。

先了解

排序树（查找树）：在二叉树的基础上，元素是有大小顺序的，左子树小，右子树大

平衡树：左孩子和右孩子相等

不平衡树：左孩子 != 右孩子

我们要说的是二叉树的一种比较有意思的叫做红黑树，红黑树本身就是一颗二叉查找树，将节点插入后，该树仍然是一颗二叉查找树。也就意味着，树的键值仍然是有序的。

红黑树的约束:

1. 节点可以是红色的或者黑色的

2. 根节点是黑色的

3. 叶子节点(特指空节点)是黑色的

4. 每个红色节点的子节点都是黑色的

5. 任何一个节点到其每一个叶子节点的所有路径上黑色节点数相同

红黑树的特点:

​ 查询速度特别快,趋近平衡树,查找叶子元素最少和最多次数不多于2倍

List集合

Collection接口的使用后，再来看看Collection接口中的子类，他们都具备那些特性呢？

接下来，我们一起学习Collection中的常用几个子类（java.util.List集合、java.util.Set集合）

List接口介绍

java.util.List接口继承自Collection接口，是单列集合的一个重要分支，习惯性地会将实现了List接口的对象称为List集合。在List集合中允许出现重复的元素，所有的元素是以一种线性方式进行存储的，在程序中可以通过索引来访问集合中的指定元素。另外==，List集合还有一个特点就是元素有序，即元素的存入顺序和取出顺序一致。==

看完API，我们总结一下：

List接口特点：

1. 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
2. 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
3. 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。

tips:我们在基础班的时候已经学习过List接口的子类java.util.ArrayList类，该类中的方法都是来自List中定义。

List接口中常用方法

List作为Collection集合的子接口，不但继承了Collection接口中的全部方法，而且还增加了一些根据元素索引来操作集合的特有方法，如下：

• public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。没有index是直接添加到集合末尾
• public E get(int index):返回集合中指定位置的元素。
• public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
• public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。

List集合特有的方法都是跟索引相关，我们在基础班都学习过，那么我们再来复习一遍吧：

List的子类

ArrayList集合

java.util.ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。

许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。

LinkedList集合

java.util.LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。

LinkedList是一个双向链表，那么双向链表是什么样子的呢，我们用个图了解下

实际开发中对一个集合元素的添加与删除经常涉及到首尾操作，而LinkedList提供了大量首尾操作的方法。这些方法我们作为了解即可：

• public void addFirst(E e):将指定元素插入此列表的开头。
• public void addLast(E e):将指定元素添加到此列表的结尾。
• public E getFirst():返回此列表的第一个元素。
• public E getLast():返回此列表的最后一个元素。
• public E removeFirst():移除并返回此列表的第一个元素。
• public E removeLast():移除并返回此列表的最后一个元素。
• public E pop():从此列表所表示的堆栈处弹出一个元素。
• public void push(E e):将元素推入此列表所表示的堆栈。
• public boolean isEmpty()：如果列表不包含元素，则返回true。

LinkedList是List的子类，List中的方法LinkedList都是可以使用，这里就不做详细介绍，我们只需要了解LinkedList的特有方法即可。在开发时，LinkedList集合也可以作为堆栈，队列的结构使用。（了解即可）

Vector集合（了解就好）

JDK1.0版本的时候用的单列集合

Collection接口下的所有集合都是1.2开始的

Set集合

java.util.Set接口和java.util.List接口一样，同样继承自Collection接口，它与Collection接口中的方法基本一致，并没有对Collection接口进行功能上的扩充，只是比Collection接口更加严格了。与List接口不同的是，Set接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。

Set集合有多个子类，这里我们介绍其中的java.util.HashSet、java.util.LinkedHashSet这两个集合。

tips:Set集合取出元素的方式可以采用：迭代器、增强for。

HashSet集合介绍

java.util.HashSet是Set接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存、取顺序不一致)。java.util.HashSet底层的实现其实是一个java.util.HashMap支持，由于我们暂时还未学习，先做了解。

HashSet是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能==。保证元素唯一性的方式依赖于==：hashCode与equals方法。

我们先来使用一下Set集合存储，看下现象，再进行原理的讲解:

  //创建 Set集合
        HashSet<String>  set = new HashSet<String>();

        //添加元素
        set.add(new String("cba"));
        set.add("abc");
        set.add("bac"); 
        set.add("cba");  
        //遍历
        for (String name : set) {
            System.out.println(name);
        }

输出结果如下，说明集合中不能存储重复元素：

cba
abc
bac

tips:根据结果我们发现字符串"cba"只存储了一个，也就是说重复的元素set集合不存储。

哈希值

哈希值：是一个十进制的整数，由系统随即给出（就是对象的地址值，是一个逻辑地址，是模拟出来的地址，不是数据实际存储的物理地址）

在Obeject类中有一个方法，可以获取对象的哈希值

public native int hashCode()返回该对象的哈希值

native：代表该方法调用的是本地操作系统的方法

Obejct 类 toString方法的源码

        return getClass().getName() + "@" + Integer.toHexString(hashCode());
        //如下面代码的
Person1@4554617c

在这里toHexString方法把十进制整数转换成16进制

Person1 person = new Person1();

//返回的是一个10进制整数，对象的地址值
int i = person.hashCode();
System.out.println(i); //1163157884

Person1 person2 = new Person1();

int i1 = person2.hashCode();

System.out.println(i1);//1956725890

System.out.println(person);//Person1@4554617c

System.out.println(person2);//Person1@74a14482

10进制 16进制

1163157884 4554617c

1956725890 74a14482

重写Object类的hashCode方法

class Person1{

    @Override
    public int hashCode() {
        return 1;
    }
}

再拿两个对象进行比较

person1 == person2 //false

虽然hashCode值相等，但是实际物理地址不相等所以返回false

String类的哈希值

String类重写了Obejct类得hashCode方法

public String(String original) {
        this.value = original.value;
        this.hash = original.hash;//字符串的hash值
    }

private int hash;
private final char value[];

public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

因为字符串的hashCode方法被重写了

String s1 = new String("abc");
String s2 = new String("abc");
s1.hashCode(); //96354
s2.hashCode(); //96354

"重地".hashCode()//1179395
"通话".hashCode()//1179395

没有重写hashCode方法，系统给你一个随机的10进制整数，你重写了之后，可以自己定制

HashSet集合存储数据的结构（哈希表）

什么是哈希表呢？

==在JDK1.8之前，哈希表底层采用数组+链表实现，==即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，哈希表存储采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。

简单的来说，哈希表是由数组+链表+红黑树==（JDK1.8增加了红黑树部分）==实现的，如下图所示。

看到这张图就有人要问了，这个是怎么存储的呢？

为了方便大家的理解我们结合一个存储流程图来说明一下：

总而言之，JDK1.8引入红黑树大程度优化了HashMap的性能，那么对于我们来讲保证HashSet集合元素的唯一，其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义的对象，那么保证其唯一，就必须复写hashCode和equals方法建立属于当前对象的比较方式。

例子：

HashSet集合存储元素不重复原理

前提：存储元素必须重写hashCode方法和equals方法

HashSet<String> set = new HashSet<>();

String s = new String("abc");
String s1 = new String("abc");

set.add(s);
set.add(s1);

set.add("重地");
set.add("通话");

set.add("abc");

System.out.println(set);

//输出
[重地, 通话, abc]

Set集合在调用add方法的时候，add方法会调用元素的HashCode方法和equals方法，判断元素是否重复

set.add(s);

add方法会调用s的hashCode方法，计算字符串"abc"的哈希值，哈希值是96354

在集合种找有没有96354这个哈希值的元素，发现没有

就会把s存储到集合中

set.add(s1)

add方法会调用s1的hashCode方法，计算字符串"abc"的哈希值，哈希值是96354

在集合中找有没有96354这个哈希值，发现有(哈希冲突)

s1会调用equals方法和哈希值相同元素进行比较 s1.equals(s)，返回true

两个元素的哈希值相同，equlas方法返回true，认定两个元素相同

就不会把s1存储到集合中

set.add(“重地”);

add方法会调用s的hashCode方法，计算字符串"abc"的哈希值，哈希值是1179395

在集合种找有没有1179395这个哈希值的元素，发现没

就会把"重地"存储到集合中

set.add(“通话”)

add方法会调用s1的hashCode方法，计算字符串"abc"的哈希值，哈希值是1179395

在集合中找有没有1179395这个哈希值，发现有(哈希冲突)

"通话"会调用equals方法和哈希值相同元素进行比较 “通话”.equals(“重地”)，返回false

两个元素的哈希值相同，equlas方法返回false，认定两个元素不同

就会把"通话"存储到集合中

HashSet存储自定义类型元素

像这种自定义类型的，可以使用idea快捷键生成hashCode和equals，这里面比较的是属性值

给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一

创建自定义Student类

要求：同名同年龄的人，视为同一个人，只能存储一次

public class Student {
    private String name;
    private 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;
    }

    //重写equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o)
            return true;
        if (o == null || getClass() != o.getClass())
            return false;
        Student student = (Student) o;
        return age == student.age &&
               Objects.equals(name, student.name);

    }

    //重些hashCode方法
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class HashSetDemo2 {
    public static void main(String[] args) {
        //创建集合对象   该集合中存储 Student类型对象
        HashSet<Student> stuSet = new HashSet<Student>();
        //存储 
        Student stu = new Student("于谦", 43);
        stuSet.add(stu);
        stuSet.add(new Student("郭德纲", 44));
        stuSet.add(new Student("于谦", 43));
        stuSet.add(new Student("郭麒麟", 23));
        stuSet.add(stu);

        for (Student stu2 : stuSet) {
            System.out.println(stu2);
        }
    }
}
执行结果：
Student [name=郭德纲, age=44]
Student [name=于谦, age=43]
Student [name=郭麒麟, age=23]

LinkedHashSet

我们知道HashSet保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序，怎么办呢？

在HashSet下面有一个子类java.util.LinkedHashSet，它是链表和哈希表组合的一个数据存储结构。

底层：哈希表(数组+链表/红黑树)+链表（记录元素的存储顺序，保证元素有序）

特点：有序，不允许重复

演示代码如下:

Set<String> set = new LinkedHashSet<String>();
        set.add("bbb");
        set.add("aaa");
        set.add("abc");
        set.add("bbc");

        for (String s : set) {
            System.out.println(s);
        }

//输出
bbb
aaa
abc
bbc

Collections（操作集合的工具类）

常用功能

• java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下：

• public static <T> boolean addAll(Collection<T> c, T... elements) :往集合中添加一些元素。

ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 5, 222, 1，2);
//结果
[5, 222, 1, 2]

• public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。

Collections.shuffle(list);
list.sout
//结果
[ 1,2,5, 222]
 发现跟原来的不一样顺序

• public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。（默认是升序）
• public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。

sort(List<T> list)使用前提：

被排序的集合里存储的元素，必须实现Comparable，重写接口中的方法，Integer、String等类就重写了Comparable接口里的排序方法

自定义类实现Comparable接口并重写排序方法

​ Comparable接口的排序规则:

​ 自己(this)-参数 :升序 反过来就是降序

class Person implements Comparable<Person>{
    String name;
    int 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 int compareTo(Person2 o) {
        //return o;//认为元素都是相同的
        //自定义比较的规则，比较两个人的年龄(this,参数Person)

        //按年龄升序排序
        return this.getAge()-o.getAge();

        //按年龄降序排序
       // return o.getAge()-this.getAge();
    }
}

Comparable和Comparable的区别：

​ Comparable：自己(this)和别人（参数）比较，自己需要实现Comparable接口，重写比较的规则

Comparator：相当于找一个第三方的裁判，比较两个

这个方法就相当于传一个集合，再传一个比较器（比较器中自己定义比较规则）

 ArrayList<Integer> list = new ArrayList<Integer>();
        Collections.addAll(list, 5, 222, 1,2);
        Collections.sort(list);


        Collections.sort(list, new Comparator<Integer>() {
          //重写比较的规则
            @Override
            public int compare(Integer o1, Integer o2) {
                //升序：前面参数-后面参数  降序：反过来
                return o1-o2;
            }
        });

对自定义类型进行比较

跟上面一样集合存入自定义类型元素，泛型改为自己定义类型

也可以进行组合排序，例如按年龄排序，当年龄一样的时候，就抽取名字的首字母转为char进行加减（因为char在进行运算的时候，会转换为int类型）

Map

概述

现实生活中，我们常会看到这样的一种集合：IP地址与主机名，身份证号与个人，系统用户名与系统用户对象等，这种一一对应的关系，就叫做映射。Java提供了专门的集合类用来存放这种对象关系的对象，即java.util.Map接口。

我们通过查看Map接口描述，发现Map接口下的集合与Collection接口下的集合，它们存储数据的形式不同，如下图。

• Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。
• Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找所对应的值。
• Collection中的集合称为单列集合，Map中的集合称为双列集合。
• 需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

Map常用子类

通过查看Map接口描述，看到Map有多个子类，这里我们主要讲解常用的HashMap集合、LinkedHashMap集合。

• HashMap<K,V>：存储数据采用的哈希表（数组+链表/红黑树）结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
• LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。==通过链表结构可以保证元素的存取顺序一致；==通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

tips：Map接口中的集合都有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同。

Map接口中的常用方法

Map接口中定义了很多方法，常用的如下：

• public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
• public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
• public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
• boolean containsKey(Object key) 判断集合中是否包含指定的键。
• public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
• public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。

tips:

使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中；

若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。

遍历Map集合有两种方式

Map集合遍历键找值方式

键找值方式：即通过元素中的键，获取键所对应的值

分析步骤：

1. 获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示:keyset()
2. 遍历键的Set集合，得到每一个键。
3. 根据键，获取键所对应的值。方法提示:get(K key)

 HashMap<String, String> map = new HashMap<>();

        map.put("1","1");
        map.put("2","2");
        map.put("3", "3");
        
        Set<String> strings = map.keySet();

        for (String key : strings) {
            String s = map.get(key);
            System.out.println(s);
        }

//输出
1
2
3

Entry键值对对象

我们已经知道，Map中存放的是两种对象，一种称为key(键)，一种称为value(值)，它们在在Map中是一一对应关系，这一对对象又称做Map中的一个Entry(项)。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

既然Entry表示了一对键和值，那么也同样提供了获取对应键和对应值得方法：

• public K getKey()：获取Entry对象中的键。
• public V getValue()：获取Entry对象中的值。

在Map集合中也提供了获取所有Entry对象的方法：

• public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。

Map集合遍历键值对方式

键值对方式：即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。

操作步骤与图解：

1. 获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。方法提示:entrySet()。

2. 遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象。

3. 通过键值对(Entry)对象，获取Entry对象中的键与值。 方法提示:getkey() getValue()

 Set<Map.Entry<String, String>> entries = map.entrySet();

        for (Map.Entry<String, String> entry : entries) {
            String value = entry.getValue();
            System.out.println(value);
        }

HashMap存储自定义类型键值

练习：每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。

注意，学生姓名相同并且年龄相同视为同一名学生。

编写学生类：重写hashCode和equals方法

public class Student {
    private String name;
    private 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 boolean equals(Object o) {
        if (this == o)
            return true;
        if (o == null || getClass() != o.getClass())
            return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

测试

public static void main(String[] args) {
        //1,创建Hashmap集合对象。
        Map<Student,String>map = new HashMap<Student,String>();
        //2,添加元素。
        map.put(newStudent("lisi",28), "上海");
        map.put(newStudent("wangwu",22), "北京");
        map.put(newStudent("zhaoliu",24), "成都");
        map.put(newStudent("zhouqi",25), "广州");
        map.put(newStudent("wangwu",22), "南京");
        
        //3,取出元素。键找值方式
        Set<Student>keySet = map.keySet();
        for(Student key: keySet){
            Stringvalue = map.get(key);
            System.out.println(key.toString()+"....."+value);
        }
    }

//输出

Student@aaac6e1d.....成都
Student@62365aa.....上海
Student@42ca5bd6.....南京
Student@ed8356ae.....广州
    

因为其中wangwu两个对象的做key重复了，所以不会再存入一个键，但是会把原来这个键中的值给替换掉 所以本来是北京的被换成了南京

• 当给HashMap中存放自定义对象时，==如果自定义对象作为key存在，这时要保证对象唯一，==必须复写对象的hashCode和equals方法(如果忘记，请回顾HashSet存放自定义对象)。
• 如果要保证map中存放的key和取出的顺序一致，可以使用java.util.LinkedHashMap集合来存放。

LinkedHashMap

我们知道HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办呢？

在HashMap下面有一个子类LinkedHashMap，它是链表和哈希表组合的一个数据存储结构。

  LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
        map.put("邓超", "孙俪");
        map.put("李晨", "范冰冰");
        map.put("刘德华", "朱丽倩");
        Set<Entry<String, String>> entrySet = map.entrySet();
        for (Entry<String, String> entry : entrySet) {
            System.out.println(entry.getKey() + "  " + entry.getValue());
        }
//输出
邓超  孙俪
李晨  范冰冰
刘德华  朱丽倩

HashTable

实现了Map接口

底层是一个哈希表

特点：

1、键和值都不能为空

2、最早的双列集合 Jdk1.0就有了

3、是线程安全的（同步，就意味着单线程）

HashTbale：是一个线程安全的集合，是单线程几个，速度慢

HashMap：底层是一个哈希表，是一个线程不安全的集合，是多线程的集合，速度快

HashMap集合（之前学的所有的集合）：可以存储null值，null键

HashTable集合，不能存储null值，null键

HashTable和Vector集合一样，在jdk1.2版本之后被更先进的集合（HashMap，ArrayList）取代了

HashTable的子类Properties依然活跃在历史舞台

Properties集合是一个唯一和IO流相结合的集合

补充知识点

JDK9对集合添加的优化

通常，我们在代码中创建一个集合（例如，List 或 Set ），并直接用一些元素填充它。 实例化集合，几个 add方法 调用，使得代码重复。

List<String> list = new ArrayList<>();
        list.add("abc");
        list.add("def");
        list.add("ghi");
        System.out.println(list);

Java 9，添加了几种集合工厂方法,更方便创建少量元素的集合、map实例。新的List、Set、Map的静态工厂方法可以更方便地创建集合的不可变实例。

例子：

 Set<String> str1=Set.of("a","b","c");  
        //str1.add("c");这里编译的时候不会错，但是执行的时候会报错，因为是不可变的集合  
        System.out.println(str1);  
        Map<String,Integer> str2=Map.of("a",1,"b",2);  
        System.out.println(str2);  
        List<String> str3=List.of("a","b");  
        System.out.println(str3);  

异常机制

1、什么是异常

2、异常体系结构

3、Java异常处理机制

4、处理异常

5、处理异常

6、总结

什么是异常

• 实际工作中，遇到的情况不可能是非常完美的，比如：你写的某个模块，用户输入不一定符合你的要求、你的程序要打开某个文件，这个文件可能不存在或者文件格式不对，你要读取数据库的数据，数据可能是空的等。我们的程序再跑着，内存或硬盘可能满了等等

• 软件程序在运行过程中，非常可能遇到刚刚提到的这些异常问题，我们叫异常，英文是Exception，意思是例外。这些，例外情况，或者叫异常，怎么让我们 写的程序作出合理的处理。而不至于程序崩溃。

• 异常之程序运行中出现的不期而至的各种状况，如：文件找不到、网络连接失败、非法参数等。

• 异常发生在程序运行起剪，它影响了正常的程序执行流程。

简单分类

• 要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常；
  • 检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这些是程序员无法预见的。 例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
  • 运行时异常：运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
  • 错误Error：错误不是异常，而脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，他们在编译也检查不到的。

异常处理框架

异常体系结构

• Java把异常当作对象来处理，并定一个积累java.lang.Throwable作为所有异常的超类。
• 在Java API中已经定义了许多异常类，这些异常类分类两大类，错误Error

和异常Exception

Error

• Error类对象由Java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。

• Java虚拟机运行错误（Virtual MachineError），当JVM不再有继续执行操作所需的内存资源将出现OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止；

• 还有发生在虚拟机视图执行应用时，如类定义错误（NoClassDefFoundError）、连接错误（LinkageError）。这些错误是不可查的，因为他们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。

Exception

• 在Exception分支中有一个重要的子类RuntimeException（运行时异常）

  • ArrayIndexOutOfBoundsException（数组下标越界）
  • NullPointerException（空指针异常）
  • ArithmeticException（算术异常）
  • MissingResourceException（丢失资源）
  • ClassNotFoundException（找不到类）等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。

• 这些异常一般都是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生；

小结

Error和Exception的区别：Error通常时灾难性的致命的错误，时程序无法控制和处理的，当出现这些异常时，Java虚拟机（JVM）一般会选择终止线程；Exception通常情况下是可以被程序处理的并且在程序中应该尽可能的去处理这些异常

异常处理机制

• 抛出异常

• 捕获异常

• 异常处理五个关键字

  • try、catch、finally、throw、throws(用在方法上)

try{
//异常监控区域
    
}catch(Exception e){ //想要捕获的异常类型！

}finally{
//处理善后工作，一定会执行的
    //假设处理IO，可以在这里面关闭资源
}

假设要捕获多个异常

try{
//异常监控区域
    
}catch(IOException e){ //想要捕获的异常类型！

}catch(Exception e){

}
catch(Throwable e){

}

注意异常大小要层层按大小顺序排列

e.printStackTrace();//打印错误的栈信息

主动抛出异常

throw new Exception(); //一般在方法中使用

假设方法中国处理不了这个异常，可以在方法上抛出异常

  public void test () throws Exception{
    }

自定义异常

• 使用Java内置的异常类可以描述在编程时出现的大部分异常情况。初期之外，用户还可以自定义异常。用户自定义异常类，子只需继承Exception类即可。

• 在程序中使用自定义异常类，大体可分为以下几个步骤：

  1. 创建进定义异常类
  2. 在方法中通过throw关键字抛出异常对象
  3. 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
  4. 在出现异常方法的调用者中捕获处理异常。

public class MyException extends Exception {


    //传递数字>10
    private int detail;

    public MyException(int a) {
        this.detail = a;

    }

    //这样别人直接输出异常就能打印出这个异常的具体信息了

//异常的打印信息
    @Override
    public String toString() {
        return "MyException{" +
                "detail=" + detail +
                '}';
    }
}

异常写了toString方法之后

在catch(Exception e){

​ //可以直接输出e打印异常信息

}

实际应用中的经验总结

• 处理运行时异常，采用逻辑去合理规避同时辅助try-catch处理
• 在多重catch块后面，可以在一个catch(Exception)来处理可能会被遗漏的异常
• 对于不确定的代码，也可以加上try-catch，处理潜在的异常
• 尽量去处理异常，切忌只是简单的调用printStackTrace()去打印输出
• 具体如何处理异常，要根据不同业务需求和异常类型去决定
  @Override
  public int hashCode() {
  return Objects.hash(name, age);
  }
  }

测试

```java
public static void main(String[] args) {
        //1,创建Hashmap集合对象。
        Map<Student,String>map = new HashMap<Student,String>();
        //2,添加元素。
        map.put(newStudent("lisi",28), "上海");
        map.put(newStudent("wangwu",22), "北京");
        map.put(newStudent("zhaoliu",24), "成都");
        map.put(newStudent("zhouqi",25), "广州");
        map.put(newStudent("wangwu",22), "南京");
        
        //3,取出元素。键找值方式
        Set<Student>keySet = map.keySet();
        for(Student key: keySet){
            Stringvalue = map.get(key);
            System.out.println(key.toString()+"....."+value);
        }
    }

//输出

Student@aaac6e1d.....成都
Student@62365aa.....上海
Student@42ca5bd6.....南京
Student@ed8356ae.....广州
    

因为其中wangwu两个对象的做key重复了，所以不会再存入一个键，但是会把原来这个键中的值给替换掉 所以本来是北京的被换成了南京

• 当给HashMap中存放自定义对象时，==如果自定义对象作为key存在，这时要保证对象唯一，==必须复写对象的hashCode和equals方法(如果忘记，请回顾HashSet存放自定义对象)。
• 如果要保证map中存放的key和取出的顺序一致，可以使用java.util.LinkedHashMap集合来存放。

LinkedHashMap

我们知道HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办呢？

在HashMap下面有一个子类LinkedHashMap，它是链表和哈希表组合的一个数据存储结构。

  LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
        map.put("邓超", "孙俪");
        map.put("李晨", "范冰冰");
        map.put("刘德华", "朱丽倩");
        Set<Entry<String, String>> entrySet = map.entrySet();
        for (Entry<String, String> entry : entrySet) {
            System.out.println(entry.getKey() + "  " + entry.getValue());
        }
//输出
邓超  孙俪
李晨  范冰冰
刘德华  朱丽倩

HashTable

实现了Map接口

底层是一个哈希表

特点：

1、键和值都不能为空

2、最早的双列集合 Jdk1.0就有了

3、是线程安全的（同步，就意味着单线程）

HashTbale：是一个线程安全的集合，是单线程几个，速度慢

HashMap：底层是一个哈希表，是一个线程不安全的集合，是多线程的集合，速度快

HashMap集合（之前学的所有的集合）：可以存储null值，null键

HashTable集合，不能存储null值，null键

HashTable和Vector集合一样，在jdk1.2版本之后被更先进的集合（HashMap，ArrayList）取代了

HashTable的子类Properties依然活跃在历史舞台

Properties集合是一个唯一和IO流相结合的集合

补充知识点

JDK9对集合添加的优化

前期准备

安装Jdk9以上版本

idea中配置新的jdk

打开ProjecStruck 检查Project language level:中jdk 版本是否是9以上

使用前提

当集合中存储的元素个数已经确定了，不在改变时使用

通常，我们在代码中创建一个集合（例如，List 或 Set ），并直接用一些元素填充它。 实例化集合，几个 add方法 调用，使得代码重复。

List<String> list = new ArrayList<>();
        list.add("abc");
        list.add("def");
        list.add("ghi");
        System.out.println(list);

Java 9，添加了几种集合工厂方法,更方便创建少量元素的集合、map实例。新的List、Set、Map的静态工厂方法可以更方便地创建集合的不可变实例。

例子：

 Set<String> str1=Set.of("a","b","c");  
        //str1.add("c");这里编译的时候不会错，但是执行的时候会报错，因为是不可变的集合  
        System.out.println(str1);  
        Map<String,Integer> str2=Map.of("a",1,"b",2);  
        System.out.println(str2);  
        List<String> str3=List.of("a","b");  
        System.out.println(str3);  

Debug追踪

Debug调试程序：可以让代码逐行执行，查看代码执行的过程，调试程序中出现的bug

使用方式：添加断点（哪里有bug添加到哪里）

程序就会停留在添加的第一个断点处

Debugger窗口

F8 （是一个直接向下的箭头） ：逐行执行程序

F7（拐了90度的箭头）：进入到方法中

shift+F8（直接向上的箭头）：跳出方法（当程序执行到方法中的时候）

F9（一个绿色的竖+绿色的三角形）：跳到下一个断点，如果没有下一个断点，那么就结束程序

异常概念

1、什么是异常

2、异常体系结构

3、Java异常处理机制

4、处理异常

5、处理异常

6、总结

什么是异常

异常，就是不正常的意思。在生活中:医生说,你的身体某个部位有异常,该部位和正常相比有点不同,该部位的功能将受影响.在程序中的意思就是：

• 异常 ：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。

在Java等面向对象的编程语言中，异常本身是一个类==，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。==

异常指的并不是语法错误,语法错了,编译不通过,不会产生字节码文件,根本不能运行.

简单分类

• 要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常；
  • 检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这些是程序员无法预见的。 例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
  • 运行时异常：运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
  • 错误Error：错误不是异常，而脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，他们在编译也检查不到的。

异常处理框架

异常体系结构

• Java把异常当作对象来处理，并定一个积累java.lang.Throwable作为所有异常的超类。
• 在Java API中已经定义了许多异常类，这些异常类分类两大类，错误Error

和异常Exception

java.lang.Throwable，其下有两个子类：java.lang.Error与java.lang.Exception，平常所说的异常指java.lang.Exception。

Error

• Error: 严重错误Error，无法通过处理的错误，只能事先避免，好比绝症。

• Java虚拟机运行错误（Virtual MachineError），当JVM不再有继续执行操作所需的内存资源将出现OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止；

• 还有发生在虚拟机视图执行应用时，如类定义错误（NoClassDefFoundError）、连接错误（LinkageError）。这些错误是不可查的，因为他们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。

Exception

**Exception：**表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。好比感冒、阑尾炎。

• 在Exception分支中有一个重要的子类RuntimeException（运行时异常）

  • ArrayIndexOutOfBoundsException（数组下标越界）
  • NullPointerException（空指针异常）
  • ArithmeticException（算术异常）
  • MissingResourceException（丢失资源）
  • ClassNotFoundException（找不到类）等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。

• 这些异常一般都是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生；

小结

Error和Exception的区别：Error通常时灾难性的致命的错误，时程序无法控制和处理的，当出现这些异常时，Java虚拟机（JVM）一般会选择终止线程；Exception通常情况下是可以被程序处理的并且在程序中应该尽可能的去处理这些异常

Throwable中的常用方法：(查看异常信息的方法)

• public void printStackTrace():打印异常的详细信息。

  包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。

• public String getMessage():获取发生异常的原因。

  提示给用户的时候,就提示错误原因。

• public String toString():获取异常的类型和异常描述信息(不用)。

出现异常,不要紧张,把异常的简单类名,拷贝到API中去查。

要勇敢地面对异常 欧里给

异常分类

我们平常说的异常就是指Exception，因为这类异常一旦出现，我们就要对代码进行更正，修复程序。

异常(Exception)的分类:根据在编译时期还是运行时期去检查异常?

• 编译时期异常:checked异常。在编译时期,就会检查,如果没有处理异常,则编译失败。(如日期格式化异常)
• 运行时期异常:runtime异常。在运行时期,检查异常.在编译时期,运行异常不会编译器检测(不报错)。(如数学异常)

异常的产生过程解析

先运行下面的程序，程序会产生一个数组索引越界异常ArrayIndexOfBoundsException。我们通过图解来解析下异常产生的过程。

工具类

public class ArrayTools {
    // 对给定的数组通过给定的角标获取元素。
    public static int getElement(int[] arr, int index) {
        int element = arr[index];
        return element;
    }
}

测试类

public class ExceptionDemo {
    public static void main(String[] args) {
        int[] arr = { 34, 12, 67 };
        intnum = ArrayTools.getElement(arr, 4)
        System.out.println("num=" + num);
        System.out.println("over");
    }
}

上述程序执行过程图解：

我觉得这样更好理解（异常的产生原理）

1、访问了数组中的4索引，而数组没有4索引的，这是哈，JVM就会检测出程序会出现异常

JVM会做两件事：

​ 1、JVM会根据异常产生的原因创建一个异常对象，这个异常对象包含了异常产生的（内容、原因、位置）创建一个异常对象

new ArrayIndexOutOfBoundsException（”4“）;

​ 2、在getElement方法中，没有异常的处理逻辑(try…catch),那么JVM就会把异常对象抛出给方法的调用者main方法来处理这个异常

2、main方法接收到了这个异常对象，main方法也没有异常的处理逻辑，继续把对象抛出给main方法的调用者JVM处理

3、JVM接收到了这个异常对象，做了两件事，

​ 1、把异常对象（内容、原因、位置）以红色的字体打印在控制台

​ 2、JVM会终止当前正在执行的java程序–>中断处理

异常处理机制

• 抛出异常

• 捕获异常

• 异常处理五个关键字

  • try、catch、finally、throw、throws(用在方法上)

e.printStackTrace();//打印错误的栈信息

主动抛出异常

throw new Exception(); //一般在方法中使用

假设方法中国处理不了这个异常，可以在方法上抛出异常

  public void test () throws Exception{
    }

抛出异常throw

throw关键字

作用：可以使用throw关键字在指定的方法中抛出指定的异常

注意：

​ 1、throw关键字必须写在方法的内部

​ 2、throw关键字后边new的对象必须事Exception或者Exception的子类对象

​ 3、throw关键字抛出指定的异常对象，我们就必须处理这个异常对象

throw关键字后边创建的是RuntimeException或者是RuntimeException的子类对象，我们可以不处理，默认交给JVM处理（处理方式为：打印异常对象，中断程序）

throw关键字后边创建的是编译异常（写代码的时候报错），我们就必须处理这个异常，要么throw,要么try…catch

在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。那么，抛出一个异常具体如何操作呢？

1. 创建一个异常对象。封装一些提示信息(信息可以自己编写)。

2. 需要将这个异常对象告知给调用者。怎么告知呢？怎么将这个异常对象传递到调用者处呢？通过关键字throw就可以完成。throw 异常对象。

   throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。

使用格式：

throw new 异常类名(参数);

如：

throw new NullPointerException("要访问的arr数组不存在");

throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");

注意：如果产生了问题，我们就会throw将问题描述类即异常进行抛出，也就是将问题返回给该方法的调用者。

那么对于调用者来说，该怎么处理呢？一种是进行捕获处理，另一种就是继续讲问题声明出去，使用throws声明处理。

Objects非空判断

还记得我们学习过一个类Objects吗，曾经提到过它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），那么在它的源码中，对对象为null的值进行了抛出异常操作。

• public static <T> T requireNonNull(T obj):查看指定引用对象不是null。

查看源码发现这里对为null的进行了抛出异常操作：

public static <T> T requireNonNull(T obj) {
    if (obj == null)
      	throw new NullPointerException();
    return obj;
}

声明异常throws

声明异常：将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理（稍后讲解该方式），那么必须通过throws进行声明，让调用者去处理。

关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).

声明异常格式：

修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{   }	

throws用于进行异常类的声明，若该方法可能有多种异常情况产生，那么在throws后面可以写多个异常类，用逗号隔开。

捕获异常try…catch

如果异常出现的话,会立刻终止程序,所以我们得处理异常:

1. 该方法不处理,而是声明抛出,由该方法的调用者来处理(throws)。
2. 在方法中使用try-catch的语句块来处理异常。

try-catch的方式就是捕获异常。

• 捕获异常：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。

捕获异常语法如下

try{
     编写可能会出现异常的代码
}catch(异常类型  e){
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}

**try：**该代码块中编写可能产生异常的代码。

**catch：**用来进行某种异常的捕获，实现对捕获到的异常进行处理。

注意:try和catch都不能单独使用,必须连用。

finally代码块

finally：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。

什么时候的代码必须最终执行？

当我们在try语句块中打开了一些物理资源(磁盘文件/网络连接/数据库连接等),我们都得在使用完之后,最终关闭打开的资源。

finally的语法:

try…catch…finally:自身需要处理异常,最终还得关闭资源。

注意:finally不能单独使用。

比如在我们之后学习的IO流中，当打开了一个关联文件的资源，最后程序不管结果如何，都需要把这个资源关闭掉。

当只有在try或者catch中调用退出JVM的相关方法,此时finally才不会执行,否则finally永远会执行。

异常注意事项

• 多个异常使用捕获又该如何处理呢？

  1. 多个异常分别处理。
  2. 多个异常一次捕获，多次处理。
  3. 多个异常一次捕获一次处理。

  一般我们是使用一次捕获多次处理方式，格式如下：

  try{
       编写可能会出现异常的代码
  }catch(异常类型A  e){  当try中出现A类型异常,就用该catch来捕获.
       处理异常的代码
       //记录日志/打印异常信息/继续抛出异常
  }catch(异常类型B  e){  当try中出现B类型异常,就用该catch来捕获.
       处理异常的代码
       //记录日志/打印异常信息/继续抛出异常
  }
  

  注意:这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。

  • 运行时异常被抛出可以不处理。即不捕获也不声明抛出。

  • 如果finally有return语句,永远返回finally中的结果,避免该情况.

  • 如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。

  • 父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出

自定义异常

异常类如何定义:

1. 自定义一个编译期异常: 自定义类 并继承于java.lang.Exception。
2. 自定义一个运行时期的异常类:自定义类 并继承于java.lang.RuntimeException。

都是Exception的子类

• 在程序中使用自定义异常类，大体可分为以下几个步骤：
  1. 创建进定义异常类
  2. 在方法中通过throw关键字抛出异常对象
  3. 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
  4. 在出现异常方法的调用者中捕获处理异常。

// 业务逻辑异常
public class RegisterException extends Exception {
    /**
     * 空参构造
     */
    public RegisterException() {
    }

    /**
     *
     * @param message 表示异常提示
     */
    public RegisterException(String message) {
        super(message);
    }
}

使用

throw new RegisterException("异常信息

3");

实际应用中的经验总结

• 处理运行时异常，采用逻辑去合理规避同时辅助try-catch处理
• 在多重catch块后面，可以在一个catch(Exception)来处理可能会被遗漏的异常
• 对于不确定的代码，也可以加上try-catch，处理潜在的异常
• 尽量去处理异常，切忌只是简单的调用printStackTrace()去打印输出
• 具体如何处理异常，要根据不同业务需求和异常类型去决定
• 尽量添加finally语句块去释放占用的资源

多线程

Process（进程）与Thread（线程）

• 说起进程，就不得不说程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
• 而进程则是执行程序的一次执行过程，他是一个动态的概念。是系统资源分配的单位
• 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。

注意：很多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错觉

线程调度:

• 分时调度

  所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

• 抢占式调度

  优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

  ​ 设置线程的优先级

抢占式调度详解

大部分操作系统都支持多进程并发运行，现在的操作系统几乎都支持同时运行多个程序。比如：现在我们上课一边使用编辑器，一边使用录屏软件，同时还开着画图板，dos窗口等软件。此时，这些程序是在同时运行，”感觉这些软件好像在同一时刻运行着“。

实际上，**CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。**对于CPU的一个核而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。
其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

并发与并行

并发：指两个或多个事件在同一个时间段内发生。

并行：指两个或多个事件在同一时刻发生（同时发生）。

在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU 系统中，每 一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分 时交替运行的时间是非常短的。

而在多个 CPU 系统中，则这些可以并发执行的程序便可以分配到多个处理器上（CPU），实现多任务并行执行， 即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行（并行）。目前电脑市场上说的多核 CPU，便是多核处理器，核 越多，并行处理的程序越多，能大大的提高电脑运行的效率。

下面的线程安全问题都是由并发引起的

注意：单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。同 理,线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个 线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为 线程调度。

多线程的核心概念

• 线程就是独立的执行路径
• 在程序运行时,即使没有自己创建线程,后台也会有多个线程,比如主线程,GC线程
• main()称之为主线程,为系统的入口,用于执行整个程序
• 在一个进程中,如果开辟了多个线程,线程的运行是由调度器（cpu）安排调度的,调度器是与操作系统紧密相关的,先后顺序是不能人为干预的
• 对同一份资源操作时会存在资源抢夺的问题,需要加入并发控制
• 线程会带来额外的开销,如CPU调度时间,并发控制开销
• 每个线程在自己的工作内存交互,内存控制不当会造成数据不一致

线程的执行是同时执行的，执行的时候在抢占cpu资源 ，谁抢到谁先执行

线程创建

Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。

三种创建方式

创建线程方式一

• 继承自Thread类，重写run方法，创建实例调用start方法

  1. 自定义线程类继承Thread类
  2. 重写run()方法，编写线程执行体
  3. 创建线程对象，调用start()方法启动线程

  不建议使用：避免OOP单继承局限性

• 自定义线程类

public class MyThread extends Thread {
	//定义指定线程名称的构造方法
	public MyThread(String name) {
		//调用父类的String参数的构造方法，指定线程的名称
		super(name);
	}
	/**
	 * 重写run方法，完成该线程执行的逻辑
	 */
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(getName()+"：正在执行！"+i);
		}
	}
}

测试类

public class Demo01 {
	public static void main(String[] args) {
		//创建自定义线程对象
		MyThread mt = new MyThread("新的线程！");
		//开启新线程
		mt.start();
		//在主方法中执行for循环
		for (int i = 0; i < 10; i++) {
			System.out.println("main线程！"+i);
		}
	}
}

[

多线程原理

z自定义线程类

public class MyThread extends Thread{ 
    /** 利用继承中的特点 * 将线程名称传递 进行设置 */ 
    public MyThread(String name){ 
        super(name);
    }
    /** 重写run方法 * 定义线程要执行的代码 */
    public void run(){ 
        for (int i = 0; i < 20; i++) {
            //getName()方法 来自父亲 
            System.out.println(getName()+i); 
        } } }

测试类：

public class Demo { 
    public static void main(String[] args) { 
        System.out.println("这里是main线程");
        MyThread mt = new MyThread("小强"); 
        mt.start();//开启了一个新的线程 
        for (int i = 0; i < 20; i++) { System.out.println("旺财:"+i); 
                                    } } }

流程图：

程序启动运行main时候，java虚拟机启动一个进程，主线程main在main()调用时候被创建。随着调用mt的对象的start方法，另外一个新的线程也启动了，这样，整个应用就在多线程下运行。

通过这张图我们可以很清晰的看到多线程的执行流程，那么为什么可以完成并发执行呢？我们再来讲一讲原理。

多线程执行时，到底在内存中是如何运行的呢？以上个程序为例，进行图解说明：

多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。进行方法的压栈和弹栈。

线程内存图图解

执行流程（重点理解）

1、main方法压栈执行，main方法中创建的MyThread对象在堆内存中

2、main方法中调用run方法，就会执行run方法（这样程序就是一个单线程程序，主线程执行）

3、main方法调用start()方法，会开辟一个新的栈空间执行run方法（run方法会在新的栈空间执行）（这样的程序就是一个多线程程序）

对于CPU而言：上图开辟了三个栈空间，就有了选择的权利，可以执行main方法，也可以执行run方法

多线程的好处：多个线程之间互不影响（因为在不同的栈空间中）

当执行线程的任务结束了，线程自动在栈内存中释放了。但是当所有的执行线程都结束了，那么进程就结束了。

Thread类

在上一天内容中我们已经可以完成最基本的线程开启，那么在我们完成操作过程中用到了 java.lang.Thread 类，

API中该类中定义了有关线程的一些方法，具体如下：

**构造方法：**北京市昌平区建材城西路金燕龙办公楼一层 电话：400-618-9090

public Thread() :分配一个新的线程对象。

``public Thread(String name)` :分配一个指定名字的新的线程对象。

public Thread(Runnable target) :分配一个带有指定目标新的线程对象。

public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

常用方法：

public String getName() :获取当前线程名称。

public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。

public void run() :此线程要执行的任务在此处定义代码。

public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。

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

翻阅API后得知创建线程的方式总共有两种，一种是继承Thread类方式，一种是实现Runnable接口方式，方式一我

们上一天已经完成，接下来讲解方式二实现的方式。

Thread和Runnable的区别

如果一个类继承Thread，==则不适合资源共享。==但是如果实现了Runable接口的话，则很容易的实现资源共享。

总结：

实现Runnable接口比继承Thread类所具有的优势：

1. 适合多个相同的程序代码的线程去共享同一个资源。

2. 可以避免java中的单继承的局限性。

3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。

4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

扩充：在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用 java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实在就是在操作系统中启动了一个进 程。

创建线程方式二

采用 java.lang.Runnable 也是非常常见的一种，我们只需要重写run方法即可。

步骤如下：

1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。

2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正

的线程对象。

3. 调用线程对象的start()方法来启动线程。

代码如下：

public class MyRunnable implements Runnable{ 
    @Override
    public void run() { 
        for (int i = 0; i < 20; i++) {
        System.out.println(Thread.currentThread().getName()+" "+i); } } }

测试类

public class Demo { 
    public static void main(String[] args) {
        //创建自定义类对象 线程任务对象
        MyRunnable mr = new MyRunnable(); 
        //创建线程对象 
        Thread t = new Thread(mr, "小强"); 
        t.start();
        for (int i = 0; i < 20; i++) { System.out.println("旺财 " + i); } } }

通过实现Runnable接口，使得该类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所有的多线程的执行 代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。

在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread 对象的start()方法来运行多线程代码。

实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现 Runnable接口来实现多线程，==最终还是通过Thread的对象的API来控制线程的，==熟悉Thread类的API是进行多线程

编程的基础。

tips:Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。

跟静态代理差不多 接下来了解一下静态代理

静态代理

总结：

1、真实对象和代理对象都要实现同一个接口

2、代理对象要代理真实角色（一般都是把真实对象当作参数传进代理对象的类中）

3、在实现接口的方法中通过参数调用真实对象的实现接口的方法

public class StaticProxy {
    public static void main(String[] args) {
        //创建代理对象，并传入真实对象
        WendingCompany wendingCompany = new WendingCompany(new You());
        wendingCompany.HappyMarry();
    }
}


interface Marry{
   void HappyMarry();


}

//真实角色
class You implements Marry{

    @Override
    public void HappyMarry() {
        System.out.println("秦老师要结婚了");
    }
}

//代理角色，帮助你结婚
class WendingCompany implements Marry{

    //代理谁-->真实目标角色
    private Marry target;
    public WendingCompany(Marry target){
        this.target = target;
    }

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();
        after();
    }


    private void after() {
        System.out.println("结婚之后，收尾款");
    }
    private void before() {
   
        System.out.println("结婚之钱，布置现场");
    }
}

所以可以理解为

Thread是个代理类，Runnable接口实现类是真实对象，（都实现了Runnable接口）

所以静态代理是线程底部的实现原理

创建线程方式三

实现Callable接口,重写call方法,

• 可以定义返回值
• 可以抛出异常

public class TestCallable implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        System.out.println("创建成功");
        return true;
    }

    public static void main(String[] args) {
        TestCallable callable = new TestCallable();

        //创建执行服务
        ExecutorService service = Executors.newFixedThreadPool(1);
        //提交执行
        Future<Boolean> result = service.submit(callable);

        boolean isTrue = result.get();
        service.shutdownNow();
    }
}

匿名内部类方式实现线程的创建

使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。

使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法：

new Runnable(){ 
    public void run(){ 
        for (int i = 0; i < 20; i++) { System.out.println("张宇:"+i); } } };

线程方法

停止线程

• 不推荐使用JDK提供的stop()、destory()方法【已废弃】

• 建议线程正常停止—>利用次数，不建议死循环（看上面线程状态的图） 正常执行完就死了（让该线程正常执行完线程中run方法中的代码来停止）

• 建议使用一个标志位进行终止变量当flag=false，则终止线程运行。

//测试stop
//1.建议线程正常停止-->利用次数，不建议死循环
//2.建议使用标志位-->设置一个标志位
//3.不要使用stop或者destory等过时或者JDK不建议使用的方法
public class TestStop implements Runnable{
    //1.设置一个标识位
    private boolean flag = true;
    @Override
    public void run() {
        int i =0;
        while (flag){
            System.out.println("run.....Thread"+i++);
        }
    }
    //.2设置一个公开的方法停止线程，转换标志位
    public void stop1(){
        this.flag =false;
    }
    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main"+i);
            if(i==900){
                //让线程停止
                testStop.stop1();
                System.out.println("线程该停止了");
            }
        }
    }
}

线程休眠

• sleep（时间）指定当前线程阻塞的毫秒数；
• sleep存在异常 InterruptedException；（中断异常）
• sleep时间达到后，线程进入就绪状态；
• sleep可以模拟网络延时，倒计时等。
• 每一个对象都有一个锁，sleep不会释放锁

sleep可以模拟网络延时的作用：放大问题的发生性

线程礼让(yeid)

• 礼让线程，让当前正在执行的线程暂停，但不阻塞
• 将线程从运行状态转为就绪状态
• 让CPU重新调度，礼让不一定成功！看CPU心情

原理是：

假设 有A 、B两个线程

A线程首先进入CPU

然后A进行了礼让，然后从CPU里面出来

又跟B一起（同时）抢占资源，所以礼让不一定成功

//测试礼让线程
//礼让不一定成功
public class TestYield {

    public static void main(String[] args) {

        MyYield myYield = new MyYield();
        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }
}
class MyYield implements Runnable{

    @Override
    public void run() {

        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();//礼让
        System.out.println(Thread.currentThread().getName()+"线程停止执行");
    }
}

如果没有进行礼让

一定会输出

a线程开始执行
a线程开始执行
b线程停止执行
b线程停止执行

礼让成功

a线程开始执行
b线程开始执行
b线程停止执行
a线程停止执行

也有可能礼让不成功

a线程开始执行
a线程开始执行
b线程停止执行
b线程停止执行

Join（插队）

• Join合并线程，待此线程执行完成后，在执行其他线程，其他线程阻塞
• 可以想象成插队

//测试join方法
//想象为插队
public class TestJoin implements Runnable{


    @Override
    public void run() {

        for (int i = 0; i < 100; i++) {
            System.out.println("线程VIP来了"+i);
        }
    }
    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin = new TestJoin();
        //启动线程的方法
        Thread thread = new Thread(testJoin);
        thread.start();

        //主线程
        for (int i = 0; i < 1000; i++) {
            if(i==200){
                thread.join();
            }
            System.out.println("main"+i);
        }
    }
}

在主线程for循环到第200的时候，vip线程进行插队，

线程中少用这个方法，会让线程阻塞

线程状态观测 (state)

• Thread.State

下面的状态都可以通过JDK帮助文档进行查看

线程状态。线程可以处于一下状态之一：

• NEW

  ​ 尚未启动的线程处于此状态。

• RUNNABLE

  ​ 在Java虚拟机中执行的线程处于此状态。

• BLOCKED

  ​ 被阻塞等待监视器锁定的线程处于此状态。

• WAITING

  ​ 正在等待另一个线程执行特定动作的线程处于此状态。

• TIMED WAITING

  ​ 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态

• TERMINATED

  ​ 已退出的线程处于此状态

一个线程可以在给定时间点处于一个状态。这些状态是 不反映任何操作系统线程状态的虚拟机状态。

//观察测试线程的状态
public class TestState {


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

      Thread thread=  new Thread(()->{
          for (int i = 0; i < 5; i++) {
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }

          System.out.println("");

        });

      //观察状态
        Thread.State state= thread.getState();
        System.out.println(state);//NEW



        //观察启动后
        thread.start();//启动线程

        state=thread.getState();

        System.out.println(state);//RUN

        while (state != Thread.State.TERMINATED){//只要线程不终止，就一直输出状态
            Thread.sleep(100);

            state = thread.getState();//跟新线程状态

            System.out.println(state);
        }
    }
}

死亡之后 的线程不能再start

线程优先级 (priority)

• Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行
• 现成的优先级用数字表示，范围从1~10
  • Thread.MIN_PRIORITY =1 ;
  • Thread.MAX_PRIORITY =10 ;
  • Thread.NORM_PRIORITY =5;
• 使用以下方式改变或获取优先级
  • getPriority() setPriority(int xxx)

就好比彩票 概率高的中奖率高 ，但是也不一定中奖

优先级的设定建议在start()调度前

优先级低只是意味着获得调度的概率低。并不是优先级低就不会被调用了。线程的执行，这都是看CPU的调度

守护（daemon）线程

• 线程分为用户线程和守护线程
• 虚拟机必须确保用户线程执行完毕 main()线程
• 虚拟机不用等待守护线程执行完毕 gc线程（垃圾回收线程）
• 如，后台记录操作日志，监控内存，垃圾回收等待

//测试守护线程
//上帝守护你
public class TestDaemon {

    public static void main(String[] args) {
        God god = new God();
        You1 you1 = new You1();

        Thread thread = new Thread(god);
        thread.setDaemon(true);//默认false表示是用户线程，正常的线程都是用户线程

        thread.start(); //上帝守护线程启动

        new Thread(you1).start();//用户线程启动

    }

}

//上帝

class God implements Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("上帝保佑着你 ");
        }
    }
}
//你
class You1 implements Runnable{

    @Override
    public void run() {

        for (int i = 0; i < 36500; i++) {
            System.out.println("你一生都开心的活着");
        }

        System.out.println("===========再见=============");
    }
}

线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样 的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

三大不安全案例

1、抢票案例

package syn;

//不安全的取钱
//两个人去银行取钱，账户

public class UnsafeBank {

    public static void main(String[] args) {
        //账户
        Account account = new Account(100,"结婚基金");

        Drawing you = new Drawing(account,50,"你");
        Drawing girlFriend = new Drawing(account,100,"girlFriend");

        you.start();
        girlFriend.start();
    }
}


//银行：模拟取款
class Drawing extends Thread{
    Account account;//账户

    //取了多少钱
    int drawingMoney;

    //现在手里多少钱
    int nowMoney;

    public Drawing(Account account,int drawingMoney,String name){
        //父类的构造方法
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;

    }

    //取钱
    @Override
    public void run() {

        //判断有没有钱
        if(account.money-drawingMoney<0){
            System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
            return;
        }

        //进到这里让程序等1秒钟，这样两个进程都会在这里

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //卡内余额 = 余额 -你取的钱
        account.money = account.money - drawingMoney;

        //你手里的钱
        nowMoney = nowMoney+drawingMoney;

        System.out.println(account.name+"余额为："+account.money);

        //Thread.currentThread().getName()等同于this.getName()
        System.out.println(this.getName()+"手里的钱:"+nowMoney);
    }
}


//账户
class Account{

    int money;//余额
    String name;//卡名

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

银行取钱案例

package syn;

//不安全的取钱
//两个人去银行取钱，账户

public class UnsafeBank {

    public static void main(String[] args) {
        //账户
        Account account = new Account(100,"结婚基金");

        Drawing you = new Drawing(account,50,"你");
        Drawing girlFriend = new Drawing(account,100,"girlFriend");

        you.start();
        girlFriend.start();
    }
}


//银行：模拟取款
class Drawing extends Thread{
    Account account;//账户

    //取了多少钱
    int drawingMoney;

    //现在手里多少钱
    int nowMoney;

    public Drawing(Account account,int drawingMoney,String name){
        //父类的构造方法
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;

    }

    //取钱
    @Override
    public void run() {

        //判断有没有钱
        if(account.money-drawingMoney<0){
            System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
            return;
        }

        //进到这里让程序等1秒钟，这样两个进程都会在这里

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //卡内余额 = 余额 -你取的钱
        account.money = account.money - drawingMoney;

        //你手里的钱
        nowMoney = nowMoney+drawingMoney;

        System.out.println(account.name+"余额为："+account.money);

        //Thread.currentThread().getName()等同于this.getName()
        System.out.println(this.getName()+"手里的钱:"+nowMoney);
    }
}


//账户
class Account{

    int money;//余额
    String name;//卡名

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

不安全集合案例

创建的线程有可能两个线程同一时间将两个数组添加到同一个位置，所以最后输出的数组大小没有10000

然后线程通过抢占资源运行集合的添加，就有可能同一时间内将两个数据添加到集合的同一个位置，就会产生覆盖效果

package syn;


import java.util.ArrayList;
import java.util.List;

//线程不安全的集合
public class UnsafeList {

    public static void main(String[] args) {

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

        for (int i = 0; i < 10000; i++) {

            //开启10000条线程
            //创建线程

            new Thread(()->{
                //创建的线程有可能两个线程同一时间将两个数组添加到同一个位置
                list.add(Thread.currentThread().getName());

            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写 操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步， 否则的话就可能影响线程安全。

要保证数据的同步性

线程同步

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。

要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制 (synchronized)来解决。

根据案例简述：

窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码 去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU 资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。

为了保证每个线程都能正常执行原子操作,Java引入了线程同步机制。

那么怎么去使用呢？有三种方式完成同步操作：

1. 同步代码块。

2. 同步方法。

3. 锁机制。

同步代码块

同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

锁对象作用：把同步代码块锁住，只让一个线程在同步代码块中执行

格式:

synchronized(obj){ 
    需要同步操作的代码
}

同步监视器:

对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.
保证唯一(就把它看成是一个唯一的一把锁就好，同步代码块，运行结束，就会释放该锁)

Obj称之为同步监视器

• Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
• 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this。

同步监视器的执行过程

1. 第一个线程访问，锁定同步监视器，执行其中代码
2. 第二个线程访问，发现同步监视器被锁定，无法访问
3. 第一个线程访问完毕，解锁同步监视器
4. 第二个线程访问，发现同步监视器没有锁。然后锁定并访问

注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着 (BLOCKED)。

代码示例：

public class Ticket implements Runnable{ 
    private int ticket = 100; 
   //创建一个锁对象
    Object lock = new Object();
    /** 执行卖票操作 */
    @Override 
    public void run() {
        //每个窗口卖票的操作 
        //窗口 永远开启 
        while(true){ synchronized (lock) {
            if(ticket>0){//有票 可以卖 
                //出票操作 
                //使用sleep模拟一下出票时间 
                try {
                    Thread.sleep(50); 
                } catch (InterruptedException e) { 
                    // TODO Auto‐generated catch block
                    e.printStackTrace();
                }//获取当前线程对象的名字 
                String name = Thread.currentThread().getName();
                System.out.println(name+"正在卖:"+ticket‐‐); } }} } }

当使用了同步代码块后，上述的线程的安全问题，解决了。

总结：同步代码块中的线程，没有执行完毕不会释放锁，同步外的线程没有锁进不去同步代码块，就会变成锁阻塞状态

同步方法

同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外 等着。

格式：

public synchronized void method(){
    可能会产生线程安全问题的代码 
}

同步锁是谁?

对于非static方法,同步锁就是this

对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。

使用同步方法代码如下：

public class Ticket implements Runnable{ 
private int ticket = 100; 
/** 执行卖票操作 */ 
    @Override
    public void run() { 
        //每个窗口卖票的操作 
        //窗口 永远开启 
        while(true){ 
            sellTicket();
        } }
    /** 锁对象 是 谁调用这个方法 就是谁 * 隐含 锁对象 就是 this **/
    public synchronized void sellTicket(){ 
        if(ticket>0){//有票 可以卖 
            //出票操作 
            //使用sleep模拟一下出票时间 
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto‐generated catch block 
                e.printStackTrace();
                }
            //获取当前线程对象的名字 
            String name = Thread.currentThread().getName(); System.out.println(name+"正在卖:"+ticket‐‐); } } }

同步方法执行完释放锁对象

Lock锁

从JDK5.0开始，Java提供了更强大的线程同步机制-----通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作, 同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

Lock锁也称同步锁，加锁与释放锁方法化了，如下：

• public void lock() :加同步锁。

• public void unlock() :释放同步锁

使用方法如下：

public class Ticket implements Runnable{ 
    private int ticket = 100; 
    Lock lock = new ReentrantLock(); 
    /** 执行卖票操作 */ 
    @Override 
    public void run() { 
        //每个窗口卖票的操作 
        //窗口 永远开启
        while(true){ 
            lock.lock(); 
            if(ticket>0){//有票 可以卖 
                //出票操作 
                //使用sleep模拟一下出票时间
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    // TODO Auto‐generated catch block 
                    e.printStackTrace(); 
                }
                //获取当前线程对象的名字 
                String name = Thread.currentThread().getName(); 
                System.out.println(name+"正在卖:"+ticket‐‐); }
            lock.unlock(); } } }

synchronized与Lock的对比

• Lock是显示锁（手动开启和关闭锁，别忘记关闭锁）synchronized是隐试锁，出了作用域自动释放
• Lock只有代码块锁，synchronized有代码块锁和方法锁
• 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
• 优先使用顺序：
  • Lock > 同步代码块（已经进入了方法体，分配了相应资源）> 同步方法（在方法体之外）

死锁

• 多个线程各自站有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形，某一个同步块同时拥有“两个以上对象的锁”时，就可能发生“死锁”的问题

死锁：多个线程互相拥抱着对方需要的资源，然后形成僵持

死锁避免方法

• 产生死锁的四个必要条件：
  1. 互斥条件：一个资源每次只能被一个进程使用。
  2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
  3. 不剥夺条件：进程已获得的资源,在末使用完之前,不能强行剥夺。
  4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

一开始产生死锁的时候

线程1代码块内先获得口红的锁 然后没有释放镜子的锁，就想获得口红的锁

线程2代码块内先获得镜子的锁 然后也没有释放口红的锁，就像获得镜子的锁

由于线程 1、2同时执行 就产生了死锁问题

 private void makeup(){
        if(choice == 0){                                                                       
            synchronized (lipstick){//获得口红的锁

                System.out.println(this.girName+"获得口红的锁");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (mirror){ //一秒钟后想获得镜子
                    System.out.println(this.girName+"获得镜子的锁");
                }    
           }                                           

        }else {
                                                                       
            synchronized (mirror){//获得镜子的锁

                System.out.println(this.girName+"获得镜子的锁");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (lipstick){ //2秒钟后想获得口红
                    System.out.println(this.girName+"获得口红的锁");

                }
            }      
       }
    }

解决

//死锁：多个线程互相拥抱着对方需要的资源，然后形成僵持
public class DeadLock {
    public static void main(String[] args) {

        Makeup g1 = new Makeup(0,"胡姑娘");
        Makeup g2 = new Makeup(1,"白雪公主");

        g1.start();
        g2.start();

    }
}

//口红
class Lipstick{

}
//镜子
class Mirror{
}
class Makeup extends Thread{
    //需要的资源只有一份，用static来保证只有一份
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;//选择
    String girName;//使用化妆品的人

    Makeup(int choice,String girName){
        this.choice = choice;
        this.girName = girName;
    }
    @Override
    public void run() {
        //化妆

        makeup();
    }

    //化妆，互相持有对方的锁，就是需要拿到对方的资源
    private void makeup(){
        if(choice == 0){
            synchronized (lipstick){//获得口红的锁

                System.out.println(this.girName+"获得口红的锁");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            synchronized (mirror){ //一秒钟后想获得镜子
                System.out.println(this.girName+"获得镜子的锁");
            }
        }else {
            synchronized (mirror){//获得镜子的锁

                System.out.println(this.girName+"获得镜子的锁");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            synchronized (lipstick){ //2秒钟后想获得口红
                System.out.println(this.girName+"获得口红的锁");
            }        }
    }
}

线程状态

线程状态概述

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中， 有几种状态呢？在API中 java.lang.Thread.State 这个枚举中给出了六种线程状态：

这里先列出各个线程状态发生的条件，下面将会对每种状态进行详细解析

线程状态	导致状态发生条件
NEW（新建）	线程刚被创建，但是并未启动，还没调用start方法
Runnable（可运行）	这个状态的线程，其正在JVM中执行，但是这个"执行"，不一定是真的在运行， 也有可能是在等待CPU资源。==把这个状态分为READY（就绪状态）和RUNNING（正在执行）==两个，一个表示的start了，资源一到位随时可以执行，另一个表示真正的执行中
Blocked（锁阻塞）	当一个线程试图获取一个锁对象，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程变成Runnable状态
Waiting(无线等待)	一个线程等待另一个线程执行（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的。必须等带另一个线程调用notify或者notifyAll方法才能够唤醒
Timed Waiting（计时等待）	在Waiting状态下，有几个方法有超时参数，调用他们将进入TImed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep、Object.wait
Teminated(被终止)	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡

Timed Waiting（计时等待）

Timed Waiting在API中的描述为：一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一状态。单独 的去理解这句话，真是玄之又玄，其实我们在之前的操作中已经接触过这个状态了，在哪里呢？

在我们写卖票的案例中，为了减少线程执行太快，现象不明显等问题，我们在run方法中添加了sleep语句，这样就 强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。

其实当我们调用了sleep方法之后，==当前执行的线程就进入到“休眠状态”，其实就是所谓的Timed Waiting(计时等 待)，==那么我们通过一个案例加深对该状态的一个理解。

注意：

1. 进入 TIMED_WAITING 状态的一种常见情形是调用的 sleep 方法，单独的线程也可以调用，不一定非要有协 作关系。

2. 为了让其他线程有机会执行，可以将Thread.sleep()的调用放线程run(之内。这样才能保证该线程执行过程 中会睡眠

3. sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable（可运行）状态

小提示：sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始立刻执行(可能会有其他线程抢占资源)。

Timed Waiting 线程状态图：

BLOCKED（锁阻塞）

Blocked状态在API中的介绍为：一个正在阻塞等待一个监视器锁（锁对象）的线程处于这一状态。

我们已经学完同步机制，那么这个状态是非常好理解的了。比如，线程A与线程B代码中使用同一锁，如果线程A获 取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。

这是由Runnable状态进入Blocked状态。除此Waiting以及Time Waiting状态也会在某种情况下进入阻塞状态，而

这部分内容作为扩充知识点带领大家了解一下。

Blocked 线程状态图

Waiting（无限等待）

Wating状态在API中介绍为：一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。

一个调用了某个对象的 wait 方法的线程会等待另一个线程调用此对象的

notify()方法 或 notifyAll()方法。

其实waiting状态并不是一个线程的操作，它体现的是多个线程间的通信，可以理解为多个线程之间的协作关系， 多个线程会争取锁，同时相互之间又存在协作关系。就好比在公司里你和你的同事们，你们可能存在晋升时的竞 争，但更多时候你们更多是一起合作以完成某些任务。

当多个线程协作时，比如A，B线程，如果A线程在Runnable（可运行）状态中调用了wait()方法那么A线程就进入 了Waiting（无限等待）状态，同时失去了同步锁。假如这个时候B线程获取到了同步锁，在运行状态中调用了 notify()方法，那么就会将无限等待的A线程唤醒。注意只是唤醒，如果获取到锁对象，那么A线程唤醒后就进入 Runnable（可运行）状态；如果没有获取锁对象，那么就进入到Blocked（锁阻塞状态）。

Waiting线程状态图：

总结图（重点理解）

一条有意思的tips:

我们在翻阅API的时候会发现Timed Waiting（计时等待） 与 Waiting（无限等待） 状态联系还是很紧密的， 比如Waiting（无限等待） 状态中wait方法是空参的，而timed waiting（计时等待） 中wait方法是带参的。 这种带参的方法，其实是一种倒计时操作，相当于我们生活中的小闹钟，我们设定好时间，到时通知，可是 如果提前得到（唤醒）通知，那么设定好时间在通知也就显得多此一举了，那么这种设计方案其实是一举两 得。如果没有得到（唤醒）通知，那么线程就处于Timed Waiting状态,直到倒计时完毕自动醒来；如果在倒 计时期间得到（唤醒）通知，那么线程从Timed Waiting状态立刻唤醒。

线程协作

怎么让线程之间进行通信，就产生了生产者消费者问题

线程间通信

为什么要处理线程间通信：

多个线程并发执行时, 在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们 希望他们有规律的执行, 那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。

如何保证线程间通信有效利用资源：

多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。 就 是多个线程在操作同一份数据时， 避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效 的利用资源。而这种手段即—— 等待唤醒机制。

什么是等待唤醒机制：

就是在一个线程进行了规定操作后，就进入等待状态（wait()）， 等待其他线程执行完他们的指定代码过后 再将 其唤醒（notify()）;在有多个线程进行等待时， 如果需要，可以使用 notifyAll()来唤醒所有的等待线程。 wait/notify 就是线程间的一种协作机制

等待唤醒中的方法

1. wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时 的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作，也即是“通知（notify）”在这个对象 上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中

2. notify：则选取所通知对象的 wait set 中的一个线程释放；例如，餐馆有空位置后，等候就餐最久的顾客最先 入座。

3. notifyAll：则释放所通知对象的 wait set 上的全部线程。

注意：

哪怕只通知了一个等待的线程，被通知线程也不能立即恢复执行，因为它当初中断的地方是在同步块内，而 此刻它已经不持有锁，所以她需要再次尝试去获取锁（很可能面临其它线程的竞争），成功后才能在当初调 用 wait 方法之后的地方恢复执行。

总结如下：

• 如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE 状态；

• 否则，从 wait set 出来，又进入 entry set，线程就从 WAITING 状态又变成 BLOCKED 状态

调用wait和notify方法需要注意的细节

1. wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对 象调用的wait方法后的线程。

2. wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继 承了Object类的。

3. wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方 法

生产者与消费者问题

等待唤醒机制其实就是经典的“生产者与消费者”的问题。

就拿生产包子消费包子来说等待唤醒机制如何有效利用资源：

包子铺线程生产包子，吃货线程消费包子。当包子没有时（包子状态为false），吃货线程等待，包子铺线程生产包子 （即包子状态为true），并通知吃货线程（解除吃货的等待状态）,因为已经有包子了，那么包子铺线程进入等待状态。 接下来，吃货线程能否进一步执行则取决于锁的获取情况。如果吃货获取到锁，那么就执行吃包子动作，包子吃完（包 子状态为false），并通知包子铺线程（解除包子铺的等待状态）,吃货线程进入等待。包子铺线程能否进一步执行则取 决于锁的获取情况。

代码演示：

包子资源类

public class BaoZi {
    String pier ; 
    String xianer ; 
    boolean flag = false ;//包子资源 是否存在 包子资源状态 
}

吃货线程类：

锁对象是主线程中传入的包子对象

public class ChiHuo extends Thread{
    private BaoZi bz; 
    public ChiHuo(String name,BaoZi bz){
        super(name); 
        this.bz = bz; 
    }
    @Override
    public void run() { 
        while(true){ 
            synchronized (bz){ 
                if(bz.flag == false){//没包子 
                    try {
                        bz.wait(); 
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } 
                }
                System.out.println("吃货正在吃"+bz.pier+bz.xianer+"包子"); 
                bz.flag = false; 
                bz.notify(); } } } }

包子铺线程类：

锁对象是主线程中传入的包子对象

public class BaoZiPu extends Thread { 
    private BaoZi bz; 
    public BaoZiPu(String name,BaoZi bz){ 
        super(name); 
        this.bz = bz; 
    }
    @Override
    public void run() {
        int count = 0;
        //造包子 
        while(true){
            //同步 
            synchronized (bz){ 
                if(bz.flag == true){//包子资源 存在 
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace(); } }
                
                // 没有包子 造包子 
                System.out.println("包子铺开始做包子"); 
                if(count%2 == 0){ 
                    // 冰皮 五仁 
                    bz.pier = "冰皮"; 
                    bz.xianer = "五仁"; }else{
                    // 薄皮 牛肉大葱 
                    bz.pier = "薄皮";
                    bz.xianer = "牛肉大葱"; }
                count++; 
                bz.flag=true; 
                System.out.println("包子造好了："+bz.pier+bz.xianer); 
                System.out.println("吃货来吃吧"); 
                //唤醒等待线程 （吃货） 
                bz.notify(); } } } }

测试类 包子铺线程和吃货线程共同对同一个包子对象进行操作

public class Demo {
    public static void main(String[] args) {
        //等待唤醒案例 
        BaoZi bz = new BaoZi(); 
        ChiHuo ch = new ChiHuo("吃货",bz);
        BaoZiPu bzp = new BaoZiPu("包子铺",bz);
        ch.start();
        bzp.start(); } }

执行效果：

包子铺开始做包子 
包子造好了：冰皮五仁 
吃货来吃吧 
吃货正在吃冰皮五仁包子
包子铺开始做包子 
包子造好了：薄皮牛肉大葱 
吃货来吃吧 
吃货正在吃薄皮牛肉大葱包子 
包子铺开始做包子
包子造好了：冰皮五仁
吃货来吃吧 
吃货正在吃冰皮五仁包子

解决线程通信的方式

解决方式一

并发协作模型“生产者/消费者模式”---->管程法

• 生产者：负责生产数据的模块（可能是方法，对象，线程，进程）；
• 消费者：负责处理数据的模块（可能是方法，对象，线程，进程）；
• 缓冲区：消费者不能直接使用生产者的数据，他们之间有个“缓冲区”

生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据

生产者、消费者通过缓冲区进行消费和生产

//测试：生产者消费者模型--->利用缓冲区解决：管程法

//生产者，消费者，产品，缓冲区
public class TestPC {

    public static void main(String[] args) {

        SynContainer synContainer = new SynContainer();

        new Productor(synContainer).start();
        new Consumer(synContainer).start();

    }


}

//成产者
class Productor extends Thread{
    
    //缓冲区
    SynContainer container;

    public Productor(SynContainer container){
        this.container = container;
    }


    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            container.push(new Chicken(i));
            System.out.println("生产了"+i+"只鸡");

        }
    }
}

//消费者
class Consumer extends Thread{
    //缓冲区
    SynContainer container;

    public Consumer(SynContainer container){
        this.container = container;
    }

    //消费
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了-->"+container.pop().id+"只鸡");
        }


    }
}

//产品
class Chicken{
    //产品编号
    int id;

    public Chicken(int id) {
        this.id = id;
    }
}

//缓冲区
class SynContainer{

    //需要一个容器大小
    Chicken[] chickens = new Chicken[10];

    //容器计数器
    int count =0;

    //生产者放入产品
    public synchronized void push(Chicken chicken){
        //如果容器满了，就需要等待消费者消费
        if(count == chickens.length){
            //通知消费者消费，生产等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //添加产品
        chickens[count] = chicken;
        count++;
        
        //可以通知消费者消费了
        //唤醒等待的线程
         this.notifyAll();
    }

    //消费者消费产品
    public synchronized Chicken pop(){
        //判断能否消费
        if(count == 0){
            //等待生产者生成，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //如果可以消费
        count--;
        Chicken chicken = chickens[count];

        this.notifyAll();
        //吃完了，通知生产者生产
        return chicken;
    }
}

缓冲区

创建一个对象数组
创建一个计数器

生产者把产品放入缓冲区 方法
先判断容器是不是10个
是的话（容器满了）让生产者线程等待，等待消费者消费，最后通知消费者消费
不是的话将产品放入容器，计数器自加1，最后通知消费者消费

消费者消费产品方法
判断计数器是否为0
为0，说明没有产品在容器中，消费者等待
如果不为0，计数器自减1，并取出当前计数器当作下标得对象数组里面的chicken，这里鸡的替换是通过赋值覆盖直接替换
并返回当钱消费的这只鸡

生产者
引入容器
通过容器的生产方法生产鸡

消费者
引入容器
通过容器的消费方法消费鸡

产品（鸡）
定义属性和构造方法

解决方式二

并发协作模型“生产者/消费者模式”----->信号灯法

//测试生产者消费者问题2：信号灯法，标志位解决
public class TestPC2 {

    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}


//生产者-->演员
class Player extends Thread{
        TV tv;
        public Player(TV tv){
            this.tv = tv;
        }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            //如果整除2就演垃圾片
            if(i%2==0){
                this.tv.play("快乐大本营");
            }else {
                this.tv.play("抖音：记录美好生化");
            }
        }
    }
}

//消费者-->观众
class Watcher extends Thread{
    TV tv;
    public Watcher(TV tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            this.tv.watch();
        }
    }
}


//产品-->节目
class TV{
    //演员表演，观众等待
    //观众观看，演员等待

    //表演的节目
    String voice;

    //设置一个标志位
    boolean flag = true;

    //表演
    public synchronized void play(String voice){

        if(!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了："+voice);

        //通知观众观看
        this.notifyAll();
        this.voice = voice;
        //因为表演了节目 给标志符换标志
        this.flag = !this.flag;
    }

    //观看
public synchronized void watch(){
        //如果为true 说明还没有节目 让观众这个线程等待
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
            System.out.println("观看了："+voice);
            //通知演员表演
            this.notifyAll();
            this.flag = !this.flag;
        }
}

线程池

• 背景：经常创建和销毁、使用量特别大得资源，比如并发情况下的线程，对性能影响很大。

• 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁，实现重复利用。类似生活中得公共交通工具。

• 好处：

  • 提高响应速度（减少了创建新线程的时间）
  • 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
  • 便于线程管理（。。。。。）
    • corePoolSize：核心池的大小
    • maximumPoolSize:最大线程数
    • keepAliveTime:线程没有任务时最多保持多长时间后会终止

• JDK5.0起提供了线程池相关API：ExecutorService和Executor

• 严格意义上讲 Executor 并不是一个线程 池，而只是一个执行线程的工具。

• ExecutorService：真正得线程池接口。常见子类ThreadPoolExecutor

  1. void execute(Runnable command):执行任务/命令，没有返回值，一般用来执行Runnable

     2.Future submit(Callable task):执行任务，有返回值，一般又来执行Callable

     3.void shutdown():关闭线程池

  Executors：工具类、线程池的工具类，用于创建并返回不同类型得线程池

  public static ExecutorService newFixedThreadPool(int nThreads) :返回线程池对象。(创建的是有界线 程池,也就是池中的线程个数可以指定最大数量)

获取到了一个线程池ExecutorService 对象，那么怎么使用呢，在这里定义了一个使用线程池对象的方法如下：

public Future<?> submit(Runnable task):获取线程池中的某一个线程对象，并执行

Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用。

线程池的使用

使用线程池中线程对象的步骤：

1. 创建线程池对象。

2. 创建Runnable接口子类对象。(task)

Runnable实现类代码

public class MyRunnable implements Runnable {
    @Override 
    public void run() {
        System.out.println("我要一个教练");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) { 
            e.printStackTrace();
        }
        System.out.println("教练来了： " + Thread.currentThread().getName());
        System.out.println("教我游泳,交完后，教练回到了游泳池"); } }

线程池测试类：

public class ThreadPoolDemo { 
    public static void main(String[] args) { 
        // 使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(2);
        //包含2个线程对象
        // 创建Runnable实例对象 
        MyRunnable r = new MyRunnable(); 
        
           //自己创建线程对象的方式 
            // Thread t = new Thread(r); 
        // t.start(); ‐‐‐> 调用MyRunnable中的run() 
        
        // 调用ExecutorService中的submit，传递线程任务(实现类)，开启线程，执行run方法
        service.submit(r); 
        // 再获取个线程对象，调用MyRunnable中的run() 
        service.submit(r); 
        service.submit(r); 
        // 注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。 
        // 将使用完的线程又归还到了线程池中 
        // 关闭线程池 
        service.shutdown(); } }

输出

我要一个教练
我要一个教练
教练来了： pool-1-thread-1
教练来了： pool-1-thread-2
教我游泳,交完后，教练回到了游泳池
教我游泳,交完后，教练回到了游泳池
我要一个教练
教练来了： pool-1-thread-1
教我游泳,交完后，教练回到了游泳池

可以看出只有2个线程对象，没有得到线程对象的只有等待其他人用完

Lamda表达式

函数式编程思想概述

在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿什么东西做什么事情”。相对而言，面向对象过 分强调“必须通过对象的形式来做事情”，而函数式思想则尽量忽略面向对象的复杂语法——强调做什么，而不是以 什么形式做

面向对象的思想:

做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情.

函数式编程思想:

只要能获取到结果,谁去做的,怎么做的都不重要,重视的是结果,不重视过程

• λ 希腊字母表中排序第十一位的字母，英语名称为Lambda
• 避免匿名内部类定义过多
• 其实质属于函数式编程的概念

（params） -> expression [表达式 ]

（params） -> statement [语句]

（params） -> {statements}

a -> System.out.println(“i like lambda–>”+a)

new Thread(()-> System.out.println(“—”)).satrt;

为什么要使用lambda表达式

• 避免匿名内部类定义过多

• 可以让你的代码看起来很简洁

• 去掉了一堆没有意义的代码，只留下核心的逻辑。

• 理解Function Interface（函数式接口）是学习Java8 lambda表达式的关键所在。

• 函数式接口的定义：

  • 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。
  • 对于函数式接口，我们可以通过lambda表达式来创建该接口的对象

为什么会要Lambda的过程 （有个慢慢发展的过程）

//推到lambda表达式
public class lambda {
    //3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println("22222222222");
        }
    }


    public static void main(String[] args) {

        ILike like = new Like();
        like.lambda();

        ILike  like2 = new Like2();
        like2.lambda();


        //4.局部内部类
        class Like3 implements ILike{

            @Override
            public void lambda() {
                System.out.println("局部内部类");
            }
        }

        ILike like3 = new Like3();
        like3.lambda();



        //5.匿名内部类，没有类的名称，必须借助接口或者父类
        ILike like4 = new ILike() {
          @Override
          public void lambda() {
              System.out.println("匿名内部类");
          }
      };
      like4.lambda();

        //6.用lambda简化
        ILike like5 = ()->{
            System.out.println("lambda表达式");
        };

        like.lambda();

    }

}

//1.定义一个函数式接口
interface ILike{
    void lambda();
}


//2.实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("11111111111111");
    }
}

简化代码

//接口
interface Lom{
    void tea(int i);
}



//1.lambda表示简化
        Lom lom1 =(int a)->{

            System.out.println(a+"11111111111111111");
        };

        lom1.tea(1);

        //简化1.参数类型
        Lom lom2 =(a)->{
            System.out.println(a+"2222222222222222");
        };
        lom2.tea(2);

        //简化2.简化括号
        Lom lom3 =a->{
            System.out.println(a+"3333333333333333333");
        };
        lom3.tea(3);

        //简化3：去掉花括号
        Lom lom4 = a -> System.out.println(a+"4444444444444");
        lom4.tea(4);

总结：要写到最简的模式
lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹。
前提是接口为函数式接口
多个参数也可以去掉参数类型，要去掉就都去掉 ，必须加上括号（多个参数的时候）

线程的 Runnable接口也是函数式接口

里面只有一个 run方法

File类

概述

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

绝对路径和相对路径 (重点)

绝对路径：从盘符开始的路径，这是一个完整的路径。

相对路径：相对于项目目录的路径，这是一个便捷的路径，开发中经常使用

构造方法

public File(String pathname) ：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。

public File(String parent, String child) ：从父路径名字符串和子路径名字符串创建新的 File实例。

public File(File parent, String child) ：从父抽象路径名和子路径名字符串创建新的 File实例。

构造举例，代码如下：

// 文件路径名
String pathname = "D:\\aaa.txt"; 
File file1 = new File(pathname); 

// 文件路径名 
String pathname2 = "D:\\aaa\\bbb.txt"; 
File file2 = new File(pathname2);

// 通过父路径和子路径字符串 
String parent = "d:\\aaa";
String child = "bbb.txt"; 
File file3 = new File(parent, child); 

// 通过父级File对象和子路径字符串 
File parentDir = new File("d:\\aaa");
String child = "bbb.txt";
File file4 = new File(parentDir, child);

小贴士：

1. 一个File对象代表硬盘中实际存在的一个文件或者目录。

2. 无论该路径下是否存在文件或者目录，都不影响File对象的创建。

常用方法

获取功能的方法

public String getAbsolutePath() ：返回此File的绝对路径名字符串。

public String getPath() ：将此File转换为路径名字符串。

public String getName() ：返回由此File表示的文件或目录的名称。

public long length() ：返回由此File表示的文件的长度。

方法演示，代码如下

public class FileGet {
    public static void main(String[] args) {
        File f = new File("d:/aaa/bbb.java"); 
        System.out.println("文件绝对路径:"+f.getAbsolutePath()); 
        System.out.println("文件构造路径:"+f.getPath());
        System.out.println("文件名称:"+f.getName()); 
        System.out.println("文件长度:"+f.length()+"字节"); 
        File f2 = new File("d:/aaa"); 
        System.out.println("目录绝对路径:"+f2.getAbsolutePath()); 
        System.out.println("目录构造路径:"+f2.getPath());
        System.out.println("目录名称:"+f2.getName()); 
        System.out.println("目录长度:"+f2.length()); } }

输出结果： 
    文件绝对路径:d:\aaa\bbb.java 
        文件构造路径:d:\aaa\bbb.java 
            文件名称:bbb.java 
                文件长度:636字节 
                    
                    
               目录绝对路径:d:\aaa 
                   目录构造路径:d:\aaa 
                       目录名称:aaa
                           目录长度:4096

API中说明：length()，表示文件的长度。但是File对象表示目录，则返回值未指定。

判断功能的方法

public boolean exists() ：此File表示的文件或目录是否实际存在。

public boolean isDirectory() ：此File表示的是否为目录。

public boolean isFile() ：此File表示的是否为文件。

创建删除功能的方法

public boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。

public boolean delete() ：删除由此File表示的文件或目录。

public boolean mkdir() ：创建由此File表示的目录。

public boolean mkdirs() ：创建由此File表示的目录，包括任何必需但不存在的父目录。

API中说明：delete方法，如果此File表示目录，则目录必须为空才能删除。

目录遍历

public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。 (只返回子中的东西)

public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。 （这里的File数组是从根路径开车的）

如果创建File类得时候引入的是绝对路径，则listFiles返回的是绝对路径，相对路径则只返回相对路径

调用listFiles方法的File对象，表示的必须是实际存在的目录，否则返回null，无法进行遍历。

递归

概述

• 递归：指在当前方法内调用自己的这种现象。

• 递归的分类**😗*

  • 递归分为两种，直接递归和间接递归。
  • 直接递归称为方法自身调用自己。
  • 间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。

• 注意事项：

  • 递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。
  • 在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
  • 构造方法,禁止递归 （编译报错:构造方法是创建对象使用的,不能让对象一直创建下去）

递归累加求和

public class DiGuiDemo { 
    public static void main(String[] args) { 
        //计算1~num的和，使用递归完成 
        int num = 5; 
        // 调用求和的方法 
        int sum = getSum(num); 
        // 输出结果 
        System.out.println(sum); }
    /*通过递归算法实现.
    参数列表:int 返
    回值类型: int */
    public static int getSum(int num) {
        /* num为1时,方法返回1, 相当于是方法的出口,num总有是1的情况 */
        if(num == 1){
            return 1;
        }/*num不为1时,方法返回 num +(num‐1)的累和 递归调用getSum方法 */
        return num + getSum(num‐1);}
}

小贴士：递归一定要有条件限定，保证递归能够停止下来，次数不要太多，否则会发生栈内存溢出。

递归打印多级目录

public class DiGuiDemo2 { 
    public static void main(String[] args) {
        // 创建File对象 
        File dir = new File("D:\\aaa"); 
        // 调用打印目录方法 
        printDir(dir);
    }
    //打印目录方法
    public static void printDir(File dir) {
        // 获取子文件和目录
        File[] files = dir.listFiles(); 
        // 循环打印
        /*判断: 当是文件时,打印绝对路径.
        当是目录时,继续调用打印目录的方法,形成递归调用.
        */
        for (File file : files) { 
            // 判断
            if (file.isFile()) { 
                // 是文件,输出文件绝对路径
                System.out.println("文件名:"+ file.getAbsolutePath());
            } else { 
                // 是目录,输出目录绝对路径 
                System.out.println("目录:"+file.getAbsolutePath());
                // 继续遍历,调用printDir,形成递归 
                printDir(file); }
        } 
    } 
}

文件搜索案例

搜索 D:\aaa 目录中的 .java 文件。

分析：

1. 目录搜索，无法判断多少级目录，所以使用递归，遍历所有目录。

2. 遍历目录时，获取的子文件，通过文件名称，判断是否符合条件。

代码实现

public class DiGuiDemo3 { 
    public static void main(String[] args) { 
        // 创建File对象
        File dir = new File("D:\\aaa"); 
        // 调用打印目录方法
        printDir(dir); 
    }
    public static void printDir(File dir) { 
        // 获取子文件和目录 
        File[] files = dir.listFiles(); 
        // 循环打印 
        for (File file : files) { 
            if (file.isFile()) { 
                // 是文件，判断文件名并输出文件绝对路径
                if (file.getName().endsWith(".java")) {
                    System.out.println("文件名:" + file.getAbsolutePath()); 
                }
            } else { 
                // 是目录，继续遍历,形成递归
                printDir(file); } } } }

字节流、字符流

什么是IO

生活中，你肯定经历过这样的场景。当你编辑一个文本文件，忘记了ctrl+s ，可能文件就白白编辑了。当你电脑上插入一个U盘，可以把一个视频，拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢？键盘、内存、硬盘、外接设备等等。

我们把这种数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为输入input 和输出output ，即流向内存是输入流，流出内存的输出流。

Java中I/O操作主要是指使用java.io包下的内容，进行输入、输出操作。输入也叫做读取数据，输出也叫做作写出数据。

IO的分类

根据数据的流向分为：输入流和输出流。

• 输入流 ：把数据从其他设备上读取到内存中的流。
• 输出流 ：把数据从内存 中写出到其他设备上的流。

格局数据的类型分为：字节流和字符流。

• 字节流 ：以字节为单位，读写数据的流。
• 字符流 ：以字符为单位，读写数据的流。

IO的流向说明图解

顶级父类们

	输入流	输出流
字节流	字节输入流 InputStream	字节输出流 OutputStream
字符流	字符输入流 Reader	字符输出流 Writer

字节流

一切皆为字节

一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，==字节流可以传输任意文件数据。==在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。

字节输出流【OutputStream】

java.io.OutputStream 抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。

• public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
• public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
• public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。（将byte[]类型的参数里面的所有元素都写入此输出流）
• public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
• public abstract void write(int b) ：将指定的字节输出流。

小贴士：

close方法，当完成流的操作时，必须调用此方法，释放系统资源。

FileOutputStream类

OutputStream有很多子类，我们从最简单的一个子类开始。

java.io.FileOutputStream 类是文件输出流，把内存中的数据写入到硬盘的文件中

写入数据的原理（内存–>硬盘）

​ java程序–>JVM(java虚拟机)–>OS(操作系统)–>OS调用写数据的方法–>把数据写入到文件中

构造方法

• public FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件。
• public FileOutputStream(String name)： 创建文件输出流以指定的名称写入文件。

构造方法的作用：

1、创建一个FileOutPutStream对象

2、会根据构造方法中传递的文件/文件路径，创建一个空的文件

3、会把FileOutPutStream对象指向创建好的文件

例如：

写数据的时候，会把10进制的整数97，转换为二进制数97

97—>1100001 (硬盘中存储的数据都是字节) 1个字节=8个比特位(11000001)

文件存储的原理和记事本打开文件

任意的文本编辑器（记事本，notepad++）

再打开文件的时候，都会查询编码表，把字节转换为字符表示

0-127值 查询ASCII 表 (所以当你写97的时候打开记事本是a)

其他值：查询系统默认码表（中文系统查询GBK）

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。

utf-8 一个中文占3个字节

Jdk 一个中文占两个字节

如

byte[] bytes = "你好".getBytes();
Arrays.toString(bytes);//控制台打印 [-28,-67,-96,-27-91-67]
//idea使用utf-8编码、解码

构造举例，代码如下：

public class FileOutputStreamConstructor throws IOException {
    public static void main(String[] args) {
   	 	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileOutputStream fos = new FileOutputStream(file);
      
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("b.txt");
    }
}

写出字节数据

写出字节：write(int b) 方法，每次可以写出一个字节数据，代码使用演示：

一次写多个字节：

​ 如果写的第一个字节是正数(0-127)，那么显示的时候会查询ASCII表

​ 如果写的第一个字节是负数，那么第一个字节会和第二个字节，两个字节组成一个中文显示，查询系统默认码表(GBK)

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
      	// 写出数据
      	fos.write(97); // 写出第1个字节
      	fos.write(98); // 写出第2个字节
      	fos.write(99); // 写出第3个字节
      	// 关闭资源
        fos.close();
    }
}
输出结果：
abc

小贴士：

1. 虽然参数为int类型四个字节，但是只会保留一个字节的信息写出。
2. 流操作完毕后，必须释放系统资源，调用close方法，千万记得。

写出字节数组：write(byte[] b)，每次可以写出数组中的数据，代码使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
      	// 字符串转换为字节数组
      	byte[] b = "黑马程序员".getBytes();
      	// 写出字节数组数据
      	fos.write(b);
      	// 关闭资源
        fos.close();
    }
}
输出结果：
黑马程序员

写出指定长度字节数组：write(byte[] b, int off, int len) ,每次写出从off索引开始，len个字节，代码使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
      	// 字符串转换为字节数组
      	byte[] b = "abcde".getBytes();
		// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
        fos.write(b,2,2);
      	// 关闭资源
        fos.close();
    }
}
输出结果：
cd

数据追加续写

经过以上的演示，每次程序运行，创建输出流对象，都会清空目标文件中的数据。如何保留目标文件中数据，还能继续添加新数据呢？

• public FileOutputStream(File file, boolean append)： 创建文件输出流以写入由指定的 File对象表示的文件。
• public FileOutputStream(String name, boolean append)： 创建文件输出流以指定的名称写入文件。

这两个构造方法，参数中都需要传入一个boolean类型的值，==true 表示追加数据，false 表示清空原有数据。==这样创建的输出流对象，就可以指定是否追加续写了，代码使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt"，true);     
      	// 字符串转换为字节数组
      	byte[] b = "abcde".getBytes();
		// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
        fos.write(b);
      	// 关闭资源
        fos.close();
    }
}
文件操作前：cd
文件操作后：cdabcde

写出换行

Windows系统里，换行符号是\r\n 。把

以指定是否追加续写了，代码使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");  
      	// 定义字节数组
      	byte[] words = {97,98,99,100,101};
      	// 遍历数组
        for (int i = 0; i < words.length; i++) {
          	// 写出一个字节
            fos.write(words[i]);
          	// 写出一个换行, 换行符号转成数组写出
            fos.write("\r\n".getBytes());
        }
      	// 关闭资源
        fos.close();
    }
}

输出结果：
a
b
c
d
e

• 回车符\r和换行符\n ：
  • 回车符：回到一行的开头（return）。
  • 换行符：下一行（newline）。
• 系统中的换行：
  • Windows系统里，每行结尾是 回车+换行 ，即\r\n；
  • Unix系统里，每行结尾只有 换行 ，即\n；
  • Mac系统里，每行结尾是 回车 ，即\r。从 Mac OS X开始与Linux统一。

字节输入流【InputStream】

java.io.InputStream 抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。

• public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。
• public abstract int read()： 从输入流读取数据的下一个字节。
• public int read(byte[] b)： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。

小贴士：

close方法，当完成流的操作时，必须调用此方法，释放系统资源。

FileInputStream类

java.io.FileInputStream 类是文件输入流，从文件中读取字节。

构造方法

• FileInputStream(File file)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
• FileInputStream(String name)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件,会抛出FileNotFoundException 。

• 构造举例，代码如下：

public class FileInputStreamConstructor throws IOException{
    public static void main(String[] args) {
   	 	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileInputStream fos = new FileInputStream(file);
      
        // 使用文件名称创建流对象
        FileInputStream fos = new FileInputStream("b.txt");
    }
}

读取字节数据

1. 读取字节：read方法==，每次可以读取一个字节的数据==，提升为int类型，读取到文件末尾，返回-1，代码使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException{
      	// 使用文件名称创建流对象
       	FileInputStream fis = new FileInputStream("read.txt");
      	// 读取数据，返回一个字节
        int read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
      	// 读取到末尾,返回-1
       	read = fis.read();
        System.out.println( read);
		// 关闭资源
        fis.close();
    }
}
输出结果：
a
b
c
d
e
-1

循环改进读取方式，代码使用演示

public class FISRead {
    public static void main(String[] args) throws IOException{
      	// 使用文件名称创建流对象
       	FileInputStream fis = new FileInputStream("read.txt");
      	// 定义变量，保存数据
        int b ；
        // 循环读取
        while ((b = fis.read())!=-1) {
            System.out.println((char)b);
        }
		// 关闭资源
        fis.close();
    }
}
输出结果：
a
b
c
d
e

小贴士：

1. 虽然读取了一个字节，但是会自动提升为int类型。
2. 流操作完毕后，必须释放系统资源，调用close方法，千万记得。

使用字节数组读取：read(byte[] b)，每次读取b的长度==(参数的数组长度)==个字节到数组中，==返回读取到的有效字节个数，==读取到末尾时，返回-1 ，代码使用演示：（建议开发中使用）

public class FISRead {
    public static void main(String[] args) throws IOException{
      	// 使用文件名称创建流对象.
       	FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
      	// 定义变量，作为有效个数
        int len ；
        // 定义字节数组，作为装字节数据的容器   
        byte[] b = new byte[2];
        // 循环读取
        while (( len= fis.read(b))!=-1) {
           	// 每次读取后,把数组变成字符串打印
            System.out.println(new String(b));
        }
		// 关闭资源
        fis.close();
    }
}

输出结果：
ab
cd
ed

错误数据d，是由于最后一次读取时，只读取一个字节e，==数组中，上次读取的数据没有被完全替换，==所以要通过len ，获取有效的字节，代码使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException{
      	// 使用文件名称创建流对象.
       	FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
      	// 定义变量，作为有效个数
        int len ；
        // 定义字节数组，作为装字节数据的容器   
        byte[] b = new byte[2];
        // 循环读取
        while (( len= fis.read(b))!=-1) {
           	// 每次读取后,把数组的有效字节部分，变成字符串打印
            System.out.println(new String(b，0，len));//  len 每次读取的有效字节个数
        }
		// 关闭资源
        fis.close();
    }
}

输出结果：
ab
cd
e

小贴士：

使用数组读取，每次读取多个字节，减少了系统间的IO操作次数，从而提高了读写的效率，建议开发中使用。

字节流练习：图片复制

public class Copy {
    public static void main(String[] args) throws IOException {
        // 1.创建流对象
        // 1.1 指定数据源
        FileInputStream fis = new FileInputStream("D:\\test.jpg");
        // 1.2 指定目的地
        FileOutputStream fos = new FileOutputStream("test_copy.jpg");

        // 2.读写数据
        // 2.1 定义数组
        byte[] b = new byte[1024];
        // 2.2 定义长度
        int len;
        // 2.3 循环读取
        while ((len = fis.read(b))!=-1) {
            // 2.4 写出数据
            fos.write(b, 0 , len);
        }

        // 3.关闭资源
        fos.close();
        fis.close();
    }
}

字符流

当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。

字符输入流【Reader】

java.io.Reader抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。

• public void close() ：关闭此流并释放与此流相关联的任何系统资源。
• public int read()： 从输入流读取一个字符。
• public int read(char[] cbuf)： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。

FileReader类

java.io.FileReader 类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

小贴士：

1. 字符编码：字节与字符的对应规则。Windows系统的中文编码默认是GBK编码表。

   idea中UTF-8

2. 字节缓冲区：一个字节数组，用来临时存储字节数据。

构造方法

• FileReader(File file)： 创建一个新的 FileReader ，给定要读取的File对象。
• FileReader(String fileName)： 创建一个新的 FileReader ，给定要读取的文件的名称。

当你创建一个流对象时，必须传入一个文件路径。类似于FileInputStream 。
构造举例，代码如下：

public class FileReaderConstructor throws IOException{
    public static void main(String[] args) {
   	 	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileReader fr = new FileReader(file);
      
        // 使用文件名称创建流对象
        FileReader fr = new FileReader("b.txt");
    }
}

读取字符数据

1. 读取字符：read方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回-1，循环读取，代码使用演示：

public class FRRead {
    public static void main(String[] args) throws IOException {
      	// 使用文件名称创建流对象
       	FileReader fr = new FileReader("read.txt");
      	// 定义变量，保存数据
        int b ；
        // 循环读取
        while ((b = fr.read())!=-1) {
            System.out.println((char)b);
        }
		// 关闭资源
        fr.close();
    }
}
输出结果：
黑
马
程
序
员

小贴士：虽然读取了一个字符，但是会自动提升为int类型。

2. 使用字符数组读取：read(char[] cbuf)，每次读取b的长度个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回-1 ，代码使用演示：

public class FRRead {
    public static void main(String[] args) throws IOException {
      	// 使用文件名称创建流对象
       	FileReader fr = new FileReader("read.txt");
      	// 定义变量，保存有效字符个数
        int len ；
        // 定义字符数组，作为装字符数据的容器
         char[] cbuf = new char[2];
        // 循环读取
        while ((len = fr.read(cbuf))!=-1) {
            System.out.println(new String(cbuf,0,len));
        }
		// 关闭资源
        fr.close();
    }
}
输出结果：
黑马
程序
员

如果不截取有效字符的字符串会出现跟上面读取数组一样的，是由于最后一次读取时，只读取一个字节e，==数组中，上次读取的数据没有被完全替换，==所以要通过len ，获取有效的字节

字符输出流【Writer】

java.io.Writer 抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。

• void write(int c) 写入单个字符。
• void write(char[] cbuf) 写入字符数组。
• abstract void write(char[] cbuf, int off, int len) 写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
• void write(String str) 写入字符串。
• void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
• void flush() 刷新该流的缓冲。
• void close() 关闭此流，但要先刷新它。

FileWriter类

java.io.FileWriter 类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

构造方法

• FileWriter(File file)： 创建一个新的 FileWriter，给定要读取的File对象。
• FileWriter(String fileName)： 创建一个新的 FileWriter，给定要读取的文件的名称。

当你创建一个流对象时，必须传入一个文件路径，类似于FileOutputStream。

• 构造举例，代码如下：

public class FileWriterConstructor {
    public static void main(String[] args) throws IOException {
   	 	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileWriter fw = new FileWriter(file);
      
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("b.txt");
    }
}

基本写出数据

写出字符：write(int b) 方法，每次可以写出一个字符数据，代码使用演示：

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");     
      	// 写出数据
      	fw.write(97); // 写出第1个字符
      	fw.write('b'); // 写出第2个字符
      	fw.write('C'); // 写出第3个字符
      	fw.write(30000); // 写出第4个字符，中文编码表中30000对应一个汉字。
      
      	/*
        【注意】关闭资源时,与FileOutputStream不同。
      	 如果不关闭,数据只是保存到缓冲区，并未保存到文件。
        */
        // fw.close();
    }
}
输出结果：
abC田

小贴士：

1. 虽然参数为int类型四个字节，但是只会保留一个字符的信息写出。
2. 未调用close方法，数据只是保存到了缓冲区，并未写出到文件中。

关闭和刷新

因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据的。如果我们既想写出数据，又想继续使用流，就需要flush 方法了。

• flush ：刷新缓冲区，流对象可以继续使用。
• close :先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

小贴士：即便是flush方法写出了数据，操作的最后还是要调用close方法，释放系统资源。

写出其他数据

写出字符数组 ：write(char[] cbuf) 和 write(char[] cbuf, int off, int len) ，每次可以写出字符数组中的数据，用法类似FileOutputStream，代码使用演示：

写出字符串：write(String str) 和 write(String str, int off, int len) ，每次可以写出字符串中的数据，更为方便，

续写和换行：操作类似于FileOutputStream。

    	// 使用文件名称创建流对象，可以续写数据  为true可以追加数据
        FileWriter fw = new FileWriter("fw.txt"，true); 
		// 写出换行
      	fw.write("\r\n");

小贴士：字符流，只能操作文本文件，不能操作图片，视频等非文本文件。

当我们单纯读或者写文本文件时 使用字符流 其他情况使用字节流

IO异常的处理

JDK7前处理

之前的入门练习，我们一直把异常抛出，而实际开发中并不能这样处理，建议使用try...catch...finally 代码块，处理异常部分

JDK7的处理(扩展知识点了解内容)

还可以使用JDK7优化后的try-with-resource 语句，该语句确保了每个资源在语句结束时关闭。所谓的资源（resource）是指在程序完成后，必须关闭的对象。

格式：

try (创建流对象语句，如果多个,使用';'隔开) {
	// 读写数据
} catch (IOException e) {
	e.printStackTrace();
}

代码使用演示：

public class HandleException2 {
    public static void main(String[] args) {
      	// 创建流对象
        try ( FileWriter fw = new FileWriter("fw.txt"); ) {
            // 写出数据
            fw.write("黑马程序员"); //黑马程序员
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

JDK9的改进(扩展知识点了解内容)

JDK9中try-with-resource 的改进，对于引入对象的方式，支持的更加简洁。被引入的对象，同样可以自动关闭，无需手动close，我们来了解一下格式。

改进前格式：

// 被final修饰的对象
final Resource resource1 = new Resource("resource1");
// 普通对象
Resource resource2 = new Resource("resource2");
// 引入方式：创建新的变量保存
try (Resource r1 = resource1;
     Resource r2 = resource2) {
     // 使用对象
}

改进后格式：

// 被final修饰的对象
final Resource resource1 = new Resource("resource1");
// 普通对象
Resource resource2 = new Resource("resource2");

// 引入方式：直接引入
try (resource1; resource2) {
     // 使用对象
}

改进后，代码使用演示：

public class TryDemo {
    public static void main(String[] args) throws IOException {
       	// 创建流对象
        final  FileReader fr  = new FileReader("in.txt");
        FileWriter fw = new FileWriter("out.txt");
       	// 引入到try中
        try (fr; fw) {
          	// 定义变量
            int b;
          	// 读取数据
          	while ((b = fr.read())!=-1) {
            	// 写出数据
            	fw.write(b);
          	}
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

属性集

概述

java.util.Properties 继承于 Hashtable ，来表示一个持久的属性集。它使用键值结构存储数据，每个键及其对应值都是一个字符串。该类也被许多Java类使用，比如获取系统属性时，System.getProperties 方法就是返回一个Properties对象。
Properties集合是一个唯一和IO流相结合的集合

Properties类

构造方法

• public Properties() :创建一个空的属性列表。

基本的存储方法

• public Object setProperty(String key, String value) ： 保存一对属性。
• public String getProperty(String key) ：使用此属性列表中指定的键搜索属性值。
• public Set<String> stringPropertyNames() ：获取所有键的名称的集合。

与流相关的方法

• public void load(InputStream inStream)： ==从字节输入流中读取键值对。 ==

参数中使用了字节输入流，通过流对象，可以关联到某文件上，这样就能够加载文本中的数据了。文本数据格式:

filename=a.txt
length=209385038
location=D:\a.txt

加载代码演示：

public class ProDemo2 {
    public static void main(String[] args) throws FileNotFoundException {
        // 创建属性集对象
        Properties pro = new Properties();
        // 加载文本中信息到属性集
        pro.load(new FileInputStream("read.txt"));
        // 遍历集合并打印
        Set<String> strings = pro.stringPropertyNames();
        for (String key : strings ) {
          	System.out.println(key+" -- "+pro.getProperty(key));
        }
     }
}
输出结果：
filename -- a.txt
length -- 209385038
location -- D:\a.txt

小贴士：文本中的数据，必须是键值对形式，可以使用空格、等号、冒号等符号分隔。

四种流

昨天学习了基本的一些流，作为IO流的入门，今天我们要见识一些更强大的流。比如能够高效读写的缓冲流，能够转换编码的转换流，能够持久化存储对象的序列化流等等。这些功能更为强大的流，都是在基本的流对象基础之上创建而来的，就像穿上铠甲的武士一样，相当于是对基本流对象的一种增强。

缓冲流

1.1 概述

缓冲流,也叫高效流，是对4个基本的FileXxx 流的增强，所以也是4个流，按照数据类型分类：

• 字节缓冲流：BufferedInputStream，BufferedOutputStream
• 字符缓冲流：BufferedReader，BufferedWriter

缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。

1.2 字节缓冲流

构造方法

• public BufferedInputStream(InputStream in) ：创建一个 新的缓冲输入流。
• public BufferedOutputStream(OutputStream out)： 创建一个新的缓冲输出流。

构造举例，代码如下：

// 创建字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
// 创建字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));

效率测试

查询API，缓冲流读写方法与基本的流是一致的，我们通过复制大文件（375MB），测试它的效率。

1. 基本流，代码如下： 这里使用了JDK7的新特性try-with-resources

public class BufferedDemo {
    public static void main(String[] args) throws FileNotFoundException {
        // 记录开始时间
      	long start = System.currentTimeMillis();
		// 创建流对象
        try (
        	FileInputStream fis = new FileInputStream("jdk9.exe");
        	FileOutputStream fos = new FileOutputStream("copy.exe")
        ){
        	// 读写数据
            int b;
            while ((b = fis.read()) != -1) {
                fos.write(b);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
		// 记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("普通流复制时间:"+(end - start)+" 毫秒");
    }
}

十几分钟过去了...

2. 缓冲流，代码如下：

public class BufferedDemo {
    public static void main(String[] args) throws FileNotFoundException {
        // 记录开始时间
      	long start = System.currentTimeMillis();
		// 创建流对象
        try (
        	BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk9.exe"));
	     BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));
        ){
        // 读写数据
            int b;
            while ((b = bis.read()) != -1) {
                bos.write(b);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
		// 记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("缓冲流复制时间:"+(end - start)+" 毫秒");
    }
}

缓冲流复制时间:8016 毫秒

如何更快呢？

使用数组的方式，代码如下：

public class BufferedDemo {
    public static void main(String[] args) throws FileNotFoundException {
      	// 记录开始时间
        long start = System.currentTimeMillis();
		// 创建流对象
        try (
			BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk9.exe"));
		 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));
        ){
          	// 读写数据
            int len;
            byte[] bytes = new byte[8*1024];
            while ((len = bis.read(bytes)) != -1) {
                bos.write(bytes, 0 , len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
		// 记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("缓冲流使用数组复制时间:"+(end - start)+" 毫秒");
    }
}
缓冲流使用数组复制时间:666 毫秒

1.3 字符缓冲流

构造方法

• public BufferedReader(Reader in) ：创建一个 新的缓冲输入流。
• public BufferedWriter(Writer out)： 创建一个新的缓冲输出流。

构造举例，代码如下：

// 创建字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("br.txt"));
// 创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

特有方法

字符缓冲流的基本方法与普通字符流调用方式一致，不再阐述，我们来看它们具备的特有方法。

• BufferedReader：public String readLine(): 读一行文字。
• BufferedWriter：public void newLine(): 写一行行分隔符,由系统属性定义符号。

readLine方法演示，代码如下：

public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
      	 // 创建流对象
        BufferedReader br = new BufferedReader(new FileReader("in.txt"));
		// 定义字符串,保存读取的一行文字
        String line  = null;
      	// 循环读取,读取到最后返回null
        while ((line = br.readLine())!=null) {
            System.out.print(line);
            System.out.println("------");
        }
		// 释放资源
        br.close();
    }
}

newLine方法演示，代码如下：

public class BufferedWriterDemo throws IOException {
  public static void main(String[] args) throws IOException  {
    	// 创建流对象
  	BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
    	// 写出数据
      bw.write("黑马");
    	// 写出换行
      bw.newLine();
      bw.write("程序");
      bw.newLine();
      bw.write("员");
      bw.newLine();
  	// 释放资源
      bw.close();
  }
}
输出效果:
黑马
程序
员

1.4 练习:文本排序

1.4 练习:文本排序

请将文本信息恢复顺序。

3.侍中、侍郎郭攸之、费祎、董允等，此皆良实，志虑忠纯，是以先帝简拔以遗陛下。愚以为宫中之事，事无大小，悉以咨之，然后施行，必得裨补阙漏，有所广益。
8.愿陛下托臣以讨贼兴复之效，不效，则治臣之罪，以告先帝之灵。若无兴德之言，则责攸之、祎、允等之慢，以彰其咎；陛下亦宜自谋，以咨诹善道，察纳雅言，深追先帝遗诏，臣不胜受恩感激。
4.将军向宠，性行淑均，晓畅军事，试用之于昔日，先帝称之曰能，是以众议举宠为督。愚以为营中之事，悉以咨之，必能使行阵和睦，优劣得所。
2.宫中府中，俱为一体，陟罚臧否，不宜异同。若有作奸犯科及为忠善者，宜付有司论其刑赏，以昭陛下平明之理，不宜偏私，使内外异法也。
1.先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。然侍卫之臣不懈于内，忠志之士忘身于外者，盖追先帝之殊遇，欲报之于陛下也。诚宜开张圣听，以光先帝遗德，恢弘志士之气，不宜妄自菲薄，引喻失义，以塞忠谏之路也。
9.今当远离，临表涕零，不知所言。
6.臣本布衣，躬耕于南阳，苟全性命于乱世，不求闻达于诸侯。先帝不以臣卑鄙，猥自枉屈，三顾臣于草庐之中，咨臣以当世之事，由是感激，遂许先帝以驱驰。后值倾覆，受任于败军之际，奉命于危难之间，尔来二十有一年矣。
7.先帝知臣谨慎，故临崩寄臣以大事也。受命以来，夙夜忧叹，恐付托不效，以伤先帝之明，故五月渡泸，深入不毛。今南方已定，兵甲已足，当奖率三军，北定中原，庶竭驽钝，攘除奸凶，兴复汉室，还于旧都。此臣所以报先帝而忠陛下之职分也。至于斟酌损益，进尽忠言，则攸之、祎、允之任也。
5.亲贤臣，远小人，此先汉所以兴隆也；亲小人，远贤臣，此后汉所以倾颓也。先帝在时，每与臣论此事，未尝不叹息痛恨于桓、灵也。侍中、尚书、长史、参军，此悉贞良死节之臣，愿陛下亲之信之，则汉室之隆，可计日而待也。

案例分析

1. 逐行读取文本信息。
2. 解析文本信息到集合中。
3. 遍历集合，按顺序，写出文本信息。

案例实现

public class BufferedTest {
    public static void main(String[] args) throws IOException {
        // 创建map集合,保存文本数据,键为序号,值为文字
        HashMap<String, String> lineMap = new HashMap<>();

        // 创建流对象
        BufferedReader br = new BufferedReader(new FileReader("in.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));

        // 读取数据
        String line  = null;
        while ((line = br.readLine())!=null) {
            // 解析文本
            String[] split = line.split("\\.");
            // 保存到集合
            lineMap.put(split[0],split[1]);
        }
        // 释放资源
        br.close();

        // 遍历map集合
        for (int i = 1; i <= lineMap.size(); i++) {
            String key = String.valueOf(i);
            // 获取map中文本
            String value = lineMap.get(key);
          	// 写出拼接文本
            bw.write(key+"."+value);
          	// 写出换行
            bw.newLine();
        }
		// 释放资源
        bw.close();
    }
}

转换流

字符编码和字符集

字符编码

计算机中储存的信息都是用二进制数表示的，而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制数转换之后的结果。按照某种规则，将字符存储到计算机中，称为编码 。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码 。比如说，按照A规则存储，同样按照A规则解析，那么就能显示正确的文本符号。反之，按照A规则存储，再按照B规则解析，就会导致乱码现象。

编码:字符(能看懂的)–字节(看不懂的)

解码:字节(看不懂的)–>字符(能看懂的)

• 字符编码Character Encoding : 就是一套自然语言的字符与二进制数之间的对应规则。

  编码表:生活中文字和计算机中二进制的对应规则

字符集

• 字符集 Charset：也叫编码表。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。

计算机要准确的存储和识别各种字符集符号，需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBK字符集、Unicode字符集等。

可见，当指定了编码，它所对应的字符集自然就指定了，所以编码才是我们最终要关心的。

• ASCII字符集 ：
  • ASCII（American Standard Code for Information Interchange，美国信息交换标准代码）是基于拉丁字母的一套电脑编码系统，用于显示现代英语，主要包括控制字符（回车键、退格、换行键等）和可显示字符（英文大小写字符、阿拉伯数字和西文符号）。
  • 基本的ASCII字符集，使用7位（bits）表示一个字符，共128字符。ASCII的扩展字符集使用8位（bits）表示一个字符，共256字符，方便支持欧洲常用字符。
• ISO-8859-1字符集：
  • 拉丁码表，别名Latin-1，用于显示欧洲使用的语言，包括荷兰、丹麦、德语、意大利语、西班牙语等。
  • ISO-8859-1使用单字节编码，兼容ASCII编码。
• GBxxx字符集：
  • GB就是国标的意思，是为了显示中文而设计的一套字符集。
  • GB2312：简体中文码表。一个小于127的字符的意义与原来相同。但两个大于127的字符连在一起时，就表示一个汉字，这样大约可以组合了包含7000多个简体汉字，此外数学符号、罗马希腊的字母、日文的假名们都编进去了，连在ASCII里本来就有的数字、标点、字母都统统重新编了两个字节长的编码，这就是常说的"全角"字符，而原来在127号以下的那些就叫"半角"字符了。
  • GBK：最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案，共收录了21003个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等。
  • GB18030：最新的中文码表。收录汉字70244个，采用多字节编码，每个字可以由1个、2个或4个字节组成。支持中国国内少数民族的文字，同时支持繁体汉字以及日韩汉字等。
• Unicode字符集 ：
  • Unicode编码系统为表达任意语言的任意字符而设计，是业界的一种标准，也称为统一码、标准万国码。
  • 它最多使用4个字节的数字来表达每个字母、符号，或者文字。有三种编码方案，UTF-8、UTF-16和UTF-32。最为常用的UTF-8编码。
  • UTF-8编码，可以用来表示Unicode标准中任何字符，它是电子邮件、网页及其他存储或传送文字的应用中，优先采用的编码。互联网工程工作小组（IETF）要求所有互联网协议都必须支持UTF-8编码。所以，我们开发Web应用，也要使用UTF-8编码。它使用一至四个字节为每个字符编码，编码规则：
    1. 128个US-ASCII字符，只需一个字节编码。
    2. 拉丁文等字符，需要二个字节编码。
    3. 大部分常用字（含中文），使用三个字节编码。
    4. 其他极少使用的Unicode辅助字符，使用四字节编码。

编码引出的问题

在IDEA中，使用FileReader 读取项目中的文本文件。由于IDEA的设置，都是默认的UTF-8编码，所以没有任何问题。但是，当读取Windows系统中创建的文本文件时，由于Windows系统的默认是GBK编码，就会出现乱码。

public class ReaderDemo {
    public static void main(String[] args) throws IOException {
        FileReader fileReader = new FileReader("E:\\File_GBK.txt");
        int read;
        while ((read = fileReader.read()) != -1) {
            System.out.print((char)read);
        }
        fileReader.close();
    }
}
输出结果：
���

那么如何读取GBK编码的文件呢？

InputStreamReader类

转换流java.io.InputStreamReader，是Reader的子类，是从字节流到字符流的桥梁（因为是从硬盘读取到内存中）。它读取字节，并使用指定的字符集将其解码为字符。它的字符集可以由名称指定，也可以接受平台的默认字符集。

构造方法

• InputStreamReader(InputStream in): 创建一个使用默认字符集的字符流。
• InputStreamReader(InputStream in, String charsetName): 创建一个指定字符集的字符流。

构造举例，代码如下：

InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");

指定编码读取

public class ReaderDemo2 {
    public static void main(String[] args) throws IOException {
      	// 定义文件路径,文件为gbk编码
        String FileName = "E:\\file_gbk.txt";
      	// 创建流对象,默认UTF8编码
        InputStreamReader isr = new InputStreamReader(new FileInputStream(FileName));
      	// 创建流对象,指定GBK编码
        InputStreamReader isr2 = new InputStreamReader(new FileInputStream(FileName) , "GBK");
		// 定义变量,保存字符
        int read;
      	// 使用默认编码字符流读取,乱码
        while ((read = isr.read()) != -1) {
            System.out.print((char)read); // ��Һ�
        }
        isr.close();
      
      	// 使用指定编码字符流读取,正常解析
        while ((read = isr2.read()) != -1) {
            System.out.print((char)read);// 大家好
        }
        isr2.close();
    }
}

2.4 OutputStreamWriter类

转换流java.io.OutputStreamWriter ，是Writer的子类，是从字符流到字节流的桥梁。使用指定的字符集将字符编码为字节。它的字符集可以由名称指定，也可以接受平台的默认字符集。

构造方法

• OutputStreamWriter(OutputStream in): 创建一个使用默认字符集的字符流。
• OutputStreamWriter(OutputStream in, String charsetName): 创建一个指定字符集的字符流。

构造举例，代码如下：

OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");

指定编码写出

public class OutputDemo {
    public static void main(String[] args) throws IOException {
      	// 定义文件路径
        String FileName = "E:\\out.txt";
      	// 创建流对象,默认UTF8编码
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(FileName));
        // 写出数据
      	osw.write("你好"); // 保存为6个字节
        osw.close();
      	
		// 定义文件路径
		String FileName2 = "E:\\out2.txt";
     	// 创建流对象,指定GBK编码
        OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream(FileName2),"GBK");
        // 写出数据
      	osw2.write("你好");// 保存为4个字节
        osw2.close();
    }
}

转换流理解图解

转换流是字节与字符间的桥梁！

2.5 练习：转换文件编码

将GBK编码的文本文件，转换为UTF-8编码的文本文件。

案例分析

1. 指定GBK编码的转换流，读取文本文件。
2. 使用UTF-8编码的转换流，写出文本文件。

案例实现

public class TransDemo {
   public static void main(String[] args) {      
    	// 1.定义文件路径
     	String srcFile = "file_gbk.txt";
        String destFile = "file_utf8.txt";
		// 2.创建流对象
    	// 2.1 转换输入流,指定GBK编码
        InputStreamReader isr = new InputStreamReader(new FileInputStream(srcFile) , "GBK");
    	// 2.2 转换输出流,默认utf8编码
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(destFile));
		// 3.读写数据
    	// 3.1 定义数组
        char[] cbuf = new char[1024];
    	// 3.2 定义长度
        int len;
    	// 3.3 循环读取
        while ((len = isr.read(cbuf))!=-1) {
            // 循环写出
          	osw.write(cbuf,0,len);
        }
    	// 4.释放资源
        osw.close();
        isr.close();
  	}
}

序列化流

3.1 概述

Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该对象的数据、对象的类型和对象中存储的属性等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。

反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。对象的数据、对象的类型和对象中存储的数据信息，都可以用来在内存中创建对象。看图理解序列化：

3.2 ObjectOutputStream类

java.io.ObjectOutputStream 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。

构造方法

• public ObjectOutputStream(OutputStream out) ： 创建一个指定OutputStream的ObjectOutputStream。

构造举例，代码如下：

FileOutputStream fileOut = new FileOutputStream("employee.txt");
ObjectOutputStream out = new ObjectOutputStream(fileOut);

序列化操作（重点）

1. 一个对象要想序列化，必须满足两个条件:

• 该类必须实现java.io.Serializable 接口，Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出NotSerializableException 。
• 该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。

public class Employee implements java.io.Serializable {
    public String name;
    public String address;
    public transient int age; // transient瞬态修饰成员,不会被序列化
    public void addressCheck() {
      	System.out.println("Address  check : " + name + " -- " + address);
    }
}

2.写出对象方法

• public final void writeObject (Object obj) : 将指定的对象写出。

public class SerializeDemo{
   	public static void main(String [] args)   {
    	Employee e = new Employee();
    	e.name = "zhangsan";
    	e.address = "beiqinglu";
    	e.age = 20; 
    	try {
      		// 创建序列化流对象
          ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("employee.txt"));
        	// 写出对象
        	out.writeObject(e);
        	// 释放资源
        	out.close();
        	fileOut.close();
        	System.out.println("Serialized data is saved"); // 姓名，地址被序列化，年龄没有被序列化。
        } catch(IOException i)   {
            i.printStackTrace();
        }
   	}
}
输出结果：
Serialized data is saved

3.3 ObjectInputStream类

ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象。

构造方法

• public ObjectInputStream(InputStream in) ： 创建一个指定InputStream的ObjectInputStream。

反序列化操作1

如果能找到一个对象的class文件，我们可以进行反序列化操作，调用ObjectInputStream读取对象的方法：

• public final Object readObject () : 读取一个对象。

public class DeserializeDemo {
   public static void main(String [] args)   {
        Employee e = null;
        try {		
             // 创建反序列化流
             FileInputStream fileIn = new FileInputStream("employee.txt");
             ObjectInputStream in = new ObjectInputStream(fileIn);
             // 读取一个对象
             e = (Employee) in.readObject();
             // 释放资源
             in.close();
             fileIn.close();
        }catch(IOException i) {
             // 捕获其他异常
             i.printStackTrace();
             return;
        }catch(ClassNotFoundException c)  {
        	// 捕获类找不到异常
             System.out.println("Employee class not found");
             c.printStackTrace();
             return;
        }
        // 无异常,直接打印输出
        System.out.println("Name: " + e.name);	// zhangsan
        System.out.println("Address: " + e.address); // beiqinglu
        System.out.println("age: " + e.age); // 0
    }
}

对于JVM可以反序列化对象，它必须是能够找到class文件的类。如果找不到该类的class文件，则抛出一个 ClassNotFoundException 异常。

反序列化操作2

另外，当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操作也会失败，抛出一个InvalidClassException（不承认的、无效的类）异常。发生这个异常的原因如下：

• 该类的序列版本号与从流中读取的类描述符的版本号不匹配
• 该类包含未知数据类型
• 该类没有可访问的无参数构造方法

Serializable 接口给需要序列化的类，提供了一个序列版本号。serialVersionUID 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。

public class Employee implements java.io.Serializable {
     // 加入序列版本号
     private static final long serialVersionUID = 1L;
     public String name;
     public String address;
     // 添加新的属性 ,重新编译, 可以反序列化,该属性赋为默认值.
     public int eid; 

     public void addressCheck() {
         System.out.println("Address  check : " + name + " -- " + address);
     }
}

3.4 练习：序列化集合

1. 将存有多个自定义对象的集合序列化操作，保存到list.txt文件中。
2. 反序列化list.txt ，并遍历集合，打印对象信息。

案例分析

1. 把若干学生对象 ，保存到集合中。
2. 把集合序列化。
3. 反序列化读取时，只需要读取一次，转换为集合类型。
4. 遍历集合，可以打印所有的学生信息

案例实现

public class SerTest {
	public static void main(String[] args) throws Exception {
		// 创建 学生对象
		Student student = new Student("老王", "laow");
		Student student2 = new Student("老张", "laoz");
		Student student3 = new Student("老李", "laol");

		ArrayList<Student> arrayList = new ArrayList<>();
		arrayList.add(student);
		arrayList.add(student2);
		arrayList.add(student3);
		// 序列化操作
		// serializ(arrayList);
		
		// 反序列化  
		ObjectInputStream ois  = new ObjectInputStream(new FileInputStream("list.txt"));
		// 读取对象,强转为ArrayList类型
		ArrayList<Student> list  = (ArrayList<Student>)ois.readObject();
		
      	for (int i = 0; i < list.size(); i++ ){
          	Student s = list.get(i);
        	System.out.println(s.getName()+"--"+ s.getPwd());
      	}
	}

	private static void serializ(ArrayList<Student> arrayList) throws Exception {
		// 创建 序列化流 
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("list.txt"));
		// 写出对象
		oos.writeObject(arrayList);
		// 释放资源
		oos.close();
	}
}

打印流

4.1 概述

平时我们在控制台打印输出，是调用print方法和println方法完成的，这两个方法都来自于java.io.PrintStream类，该类能够方便地打印各种数据类型的值，是一种便捷的输出方式。

4.2 PrintStream类

构造方法

• public PrintStream(String fileName) ： 使用指定的文件名创建一个新的打印流。
  System.out（也就是PrintStream类的一个实例）的println方法

构造举例，代码如下：

PrintStream ps = new PrintStream("ps.txt")；

改变打印流向

System.out就是PrintStream类型的，只不过它的流向是系统规定的，打印在控制台上。不过，既然是流对象，我们就可以玩一个"小把戏"，改变它的流向。

public class PrintDemo {
    public static void main(String[] args) throws IOException {
		// 调用系统的打印流,控制台直接输出97
        System.out.println(97);
      
		// 创建打印流,指定文件的名称
        PrintStream ps = new PrintStream("ps.txt");
      	
      	// 设置系统的打印流流向,输出到ps.txt
        System.setOut(ps);
      	// 调用系统的打印流,ps.txt中输出97
        System.out.println(97);
    }
}

函数式接口

概念 函数式接口在Java中是指：有且仅有一个抽象方法的接口。

函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可 以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

备注：“语法糖”是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实 底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部 类的“语法糖”，但是二者在原理上是不同的。

可以看到匿名内部类生成了.class文件，而lambda是没有生成.class文件的，少一个class文件，以后内存中就少加载一个文件，所以lambda效率要比匿名内部类高

1.2 格式 只要确保接口中有且仅有一个抽象方法即可：

 修饰符 interface 接口名称 { 
 	public abstract 返回值类型 方法名称(可选参数信息);
 	 // 其他非抽象方法内容
 	  }

由于接口当中抽象方法的 public abstract 是可以省略的，所以定义一个函数式接口很简单：

public interface MyFunctionalInterface { 
void myMethod();
 }

@FunctionalInterface注解

与 @Override 注解的作用类似，Java 8中专门为函数式接口引入了一个新的注解： @FunctionalInterface 。该注解可用于一个接口的定义上：

@FunctionalInterface 
public interface MyFunctionalInterface { 
void myMethod(); 
}

一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注 意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。

自定义函数式接口

对于刚刚定义好的 MyFunctionalInterface 函数式接口，典型使用场景就是作为方法的参数：

public class Demo09FunctionalInterface { 
// 使用自定义的函数式接口作为方法参数 
private static void doSomething(MyFunctionalInterface inter) {
 inter.myMethod(); // 调用自定义的函数式接口方法
  }
public static void main(String[] args) {
 // 调用使用函数式接口的方法 
 doSomething(() ‐> System.out.println("Lambda执行啦！")); } }

函数式编程

在兼顾面向对象特性的基础上，Java语言通过Lambda表达式与方法引用等，为开发者打开了函数式编程的大门。 下面我们做一个初探。

Lambda的延迟执行

有些场景的代码执行后，结果不一定会被使用，从而造成性能浪费。而Lambda表达式是延迟执行的，这正好可以 作为解决方案，提升性能。

性能浪费的日志案例

注:日志可以帮助我们快速的定位问题，记录程序运行过程中的情况，以便项目的监控和优化。 一种典型的场景就是对参数进行有条件使用，例如对日志消息进行拼接后，在满足条件的情况下进行打印输出：

public class Demo01Logger { 
private static void log(int level, String msg) { 
		if (level == 1) {
 			System.out.println(msg); 
 } }
public static void main(String[] args) { 
		String msgA = "Hello"; 
		String msgB = "World";
	    String msgC = "Java"; 
	    log(1, msgA + msgB + msgC); } }

这段代码存在问题：无论级别是否满足要求（传1满足，其他不满足），作为 log 方法的第二个参数，三个字符串一定会首先被拼接并传入方 法内，然后才会进行级别判断（先把字符串拼接好，然后再调用showLog方法）。如果级别不符合要求，那么字符串的拼接操作就白做了，存在性能浪费。

备注：SLF4J是应用非常广泛的日志框架，它在记录日志时为了解决这种性能浪费的问题，并不推荐首先进行 字符串的拼接，而是将字符串的若干部分作为可变参数传入方法中，仅在日志级别满足要求的情况下才会进 行字符串拼接。例如： LOGGER.debug(“变量{}的取值为{}。”, “os”, “macOS”) ，其中的大括号 {} 为占位 符。如果满足日志级别要求，则会将“os”和“macOS”两个字符串依次拼接到大括号的位置；否则不会进行字 符串拼接。这也是一种可行解决方案，但Lambda可以做到更好。

体验Lambda的更优写法

使用Lambda必然需要一个函数式接口：

@FunctionalInterface 
public interface MessageBuilder {
 String buildMessage();
  }

然后对 log 方法进行改造：

public class Demo02LoggerLambda {
 private static void log(int level, MessageBuilder builder) { 
 if (level == 1) {
  System.out.println(builder.buildMessage()); 
  } }

public static void main(String[] args) { 
String msgA = "Hello"; 
String msgB = "World"; 
String msgC = "Java";
 log(1, () ‐> msgA + msgB + msgC );
  } }

使用lambda表达式作为参数传递，仅仅是把参数传递到showLog方法中，只有满足条件，日志等级是1级，才会调用接口中的方法拼接字符串。如果日志的等级不是1级，接口中的方法也不会执行，所以不会造成性能浪费。

这样一来，只有当级别满足要求的时候，才会进行三个字符串的拼接；否则三个字符串将不会进行拼接。

证明Lambda的延迟

下面的代码可以通过结果进行验证：

public class Demo03LoggerDelay {
 private static void log(int level, MessageBuilder builder) {
  if (level == 1) { 
  System.out.println(builder.buildMessage()); } }
  public static void main(String[] args) { 
  String msgA = "Hello"; 
  String msgB = "World"; 
  String msgC = "Java"; 
  log(2, () ‐> { 
  System.out.println("Lambda执行！");
   return msgA + msgB + msgC; }); 
   } }

从结果中可以看出，在不符合级别要求的情况下，Lambda将不会执行。从而达到节省性能的效果。

扩展：实际上使用内部类也可以达到同样的效果，只是将代码操作延迟到了另外一个对象当中通过调用方法 来完成。而是否调用其所在方法是在条件判断之后才执行的

使用Lambda作为参数和返回值

如果抛开实现原理不说，Java中的Lambda表达式可以被当作是匿名内部类的替代品。如果方法的参数是一个函数 式接口类型，那么就可以使用Lambda表达式进行替代。使用Lambda表达式作为方法参数，其实就是使用函数式 接口作为方法参数。
例如 java.lang.Runnable 接口就是一个函数式接口，假设有一个 startThread 方法使用该接口作为参数，那么就 可以使用Lambda进行传参。这种情况其实和 Thread 类的构造方法参数为Runnable没有本质区别。

public class Demo04Runnable { 
private static void startThread(Runnable task) {
 new Thread(task).start(); 
 }
 public static void main(String[] args) { 
 startThread(() ‐> System.out.println("线程任务执行！")); 
 } }

类似地，如果一个方法的返回值类型是一个函数式接口，那么就可以直接返回一个Lambda表达式。当需要通过一 个方法来获取一个 java.util.Comparator 接口类型的对象作为排序器时,就可以调该方法获取。

 private static Comparator<String> newComparator() {
        return (a, b)->b.length() - a.length();
    }

    public static void main(String[] args) {
        String[] array = { "abc", "ab", "abcd" };
        System.out.println(Arrays.toString(array));
        Arrays.sort(array, newComparator());
        System.out.println(Arrays.toString(array)); 
    }
}

其中直接return一个Lambda表达式即可。

常用函数式接口(重点)

JDK提供了大量常用的函数式接口以丰富Lambda的典型使用场景，它们主要在 java.util.function 包中被提供。 下面是最简单的几个接口及使用示例。

Function函数型接口

Function函数型接口： 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件， 后者称为后置条件

Interface Function<T,R>{
//传入参数T返回类型R
R apply(T t) 
}

import java.util.function.Function; 

public class Demo11FunctionApply { 
	private static void method(Function<String, Integer> function) { 
		int num = function.apply("10"); 
		System.out.println(num + 20); 
		}
	public static void main(String[] args) { 
	method(s ‐> Integer.parseInt(s)); 
	} }

当然，最好是通过方法引用的写法。

默认方法：andThen Function

接口中有一个默认的 andThen 方法，用来进行组合操作。JDK源代码如：

default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
 Objects.requireNonNull(after);
  return (T t) ‐> after.apply(apply(t)); 
  }

该方法同样用于“先做什么，再做什么”的场景，和 Consumer 中的 andThen 差不多：

import java.util.function.Function; 

public class Demo12FunctionAndThen { 
	private static void method(Function<String, Integer> one, Function<Integer, Integer> two) {
		 int num = one.andThen(two).apply("10"); 
		 System.out.println(num + 20); 
		 }
	public static void main(String[] args) { 
	method(str‐>Integer.parseInt(str)+10, i ‐> i *= 10);
	 } }

第一个操作是将字符串解析成为int数字，第二个操作是乘以10。两个操作通过 andThen 按照前后顺序组合到了一 起

请注意，Function的前置条件泛型和后置条件泛型可以相同。

练习：自定义函数模型拼接

题目
请使用 Function 进行函数模型的拼接，按照顺序需要执行的多个函数操作为：
String str = “赵丽颖,20”;

1. 将字符串截取数字年龄部分，得到字符串；
2. 将上一步的字符串转换成为int类型的数字；
3. 将上一步的int数字累加100，得到结果int数字。

解答

import java.util.function.Function;

 public class DemoFunction {
  public static void main(String[] args) { 
  	String str = "赵丽颖,20"; 
  	int age = getAgeNum(str, 
  						s ‐> s.split(",")[1],
  					 	s ‐>Integer.parseInt(s), 
  					 	n ‐> n += 100); 
  	System.out.println(age);
  	 }

	private static int getAgeNum(String str,
								 Function<String, String> one, 
								 Function<String, Integer> two, 
								 Function<Integer, Integer> three) { 
								 return one.andThen(two).andThen(three).apply(str); 
								 } }

Supplier 供给型接口

Supplier 供给型接口：没有参数 只有返回值

抽象方法：get

public interface Supplier<T> {
    T get();

 Supplier<String> supplier = ()->"123";

        System.out.println(supplier.get());

Consumer 消费型接口

只有输入 ，没有返回值

抽象方法：accept

public interface Consumer<T> {
    void accept(T t);

Consumer<String> consumer = str-> System.out.println(str);

        consumer.accept("123");

//输出
123

默认方法：andThen

如果一个方法的参数和返回值全都是 Consumer 类型，那么就可以实现效果：消费数据的时候，首先做一个操作， 然后再做一个操作，实现组合。而这个方法就是Consumer接口中的default方法 andThen 。下面是JDK的源代码：

default Consumer<T> andThen(Consumer<? super T> after) { Objects.requireNonNull(after); 
return (T t) ‐> { accept(t); after.accept(t); };
 }

备注： java.util.Objects 的 requireNonNull 静态方法将会在参数为null时主动抛出 NullPointerException 异常。这省去了重复编写if语句和抛出空指针异常的麻烦

要想实现组合，需要两个或多个Lambda表达式即可，而 andThen 的语义正是“一步接一步”操作。例如两个步骤组 合的情况：

import java.util.function.Consumer;

 public class Demo10ConsumerAndThen {
  private static void consumeString(Consumer<String> one, Consumer<String> two) {
//先执行one再执行two
   one.andThen(two).accept("Hello"); 
   }
   public static void main(String[] args) { 
   consumeString( s ‐> System.out.println(s.toUpperCase()), s ‐> System.out.println(s.toLowerCase())); 
   } }

运行结果将会首先打印完全大写的HELLO，然后打印完全小写的hello。当然，通过链式写法可以实现更多步骤的 组合。

格式化打印信息

下面的字符串数组当中存有多条信息，请按照格式“ 姓名：XX。性别：XX。 ”的格式将信息打印出来。要求将打印姓 名的动作作为第一个 Consumer 接口的Lambda实例，将打印性别的动作作为第二个 Consumer 接口的Lambda实 例，将两个Consumer接口按照顺序“拼接”到一起。

public static void main(String[] args) { 
String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男" };
 }

解答

import java.util.function.Consumer;

 public class DemoConsumer { 
 public static void main(String[] args) { 
 		String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男" };
  		printInfo(s ‐> System.out.print("姓名：" + s.split(",")[0]), 
  				  s ‐> System.out.println("。性别：" + s.split(",")[1] + "。"), 
  				  array); 
  }
  private static void printInfo(Consumer<String> one, Consumer<String> two, String[] array) { 
  //每遍历到一个数组就分隔开并打印
  for (String info : array) { 
  one.andThen(two).accept(info); // 姓名：迪丽热巴。性别：女。 
  } } }

Predicate 断定型接口

有一个输入参数，返回值只能是 boolean

抽象方法：test

用于条件判断的场景

public interface Predicate<T> {
   boolean test(T t);
    }

 import java.util.function.Predicate; 

public class Demo15PredicateTest { 
private static void method(Predicate<String> predicate) { 
boolean veryLong = predicate.test("HelloWorld"); 
System.out.println("字符串很长吗：" + veryLong); 
}
public static void main(String[] args) {
 method(s ‐> s.length() > 5);
  } }

条件判断的标准是传入的Lambda表达式逻辑，只要字符串长度大于5则认为很长。

默认方法：and

既然是条件判断，就会存在与、或、非三种常见的逻辑关系。其中将两个 Predicate 条件使用“与”逻辑连接起来实 现“并且”的效果时，可以使用default方法 and 。其JDK源码为：

default Predicate<T> and(Predicate<? super T> other) { 
Objects.requireNonNull(other); 
return (t) ‐> test(t) && other.test(t);
 }

如果要判断一个字符串既要包含大写“H”，又要包含大写“W”，那么：

import java.util.function.Predicate;

 public class Demo16PredicateAnd {
  private static void method(Predicate<String> one, Predicate<String> two) { 
  boolean isValid = one.and(two).test("Helloworld"); 
  System.out.println("字符串符合要求吗：" + isValid); 
  }
  public static void main(String[] args) { 
  method(s ‐> s.contains("H"), s ‐> s.contains("W")); 
  } }

默认方法：or

与 and 的“与”类似，默认方法 or 实现逻辑关系中的“或”。JDK源码为

default Predicate<T> or(Predicate<? super T> other) { 
Objects.requireNonNull(other);
 return (t) ‐> test(t) || other.test(t); 
 }

如果希望实现逻辑“字符串包含大写H或者包含大写W”，那么代码只需要将“and”修改为“or”名称即可，其他都不 变

import java.util.function.Predicate; 

public class Demo16PredicateAnd { 
	private static void method(Predicate<String> one, Predicate<String> two) { 
		boolean isValid = one.or(two).test("Helloworld"); 
		System.out.println("字符串符合要求吗：" + isValid); 
		}
	
	public static void main(String[] args) { 
	method(s ‐> s.contains("H"), s ‐> s.contains("W")); 
	} }

默认方法：negate

“与”、“或”已经了解了，剩下的“非”（取反）也hen简单。默认方法 negate 的JDK源代码为：

default Predicate<T> negate() { 
return (t) ‐> !test(t);
 }

从实现中很容易看出，它是执行了test方法之后，对结果boolean值进行“!”取反而已。一定要在 test 方法调用之前 调用 negate 方法，正如 and 和 or 方法一样：

import java.util.function.Predicate;

 public class Demo17PredicateNegate { 
 private static void method(Predicate<String> predicate) {
  boolean veryLong = predicate.negate().test("HelloWorld"); 
  System.out.println("字符串很长吗：" + veryLong);
   }
   public static void main(String[] args) { 
   method(s ‐> s.length() < 5);
    } }

练习：集合信息筛选

题目
数组当中有多条“姓名+性别”的信息如下，请通过 Predicate 接口的拼装将符合要求的字符串筛选到集合 ArrayList 中，需要同时满足两个条件：

1. 必须为女生；
2. 姓名为4个字。

public class DemoPredicate { 
	public static void main(String[] args) { 
		String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" };
		 }

解答

import java.util.ArrayList; import java.util.List;
 import java.util.function.Predicate; 

public class DemoPredicate { 
	public static void main(String[] args) { 
		String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" }; 
		List<String> list = filter(array, s ‐> "女".equals(s.split(",")[1]), s ‐> s.split(",")[0].length() == 4); 
		System.out.println(list);
		 }
	private static List<String> filter(String[] array, Predicate<String> one, Predicate<String> two) {
		 List<String> list = new ArrayList<>(); 
		 for (String info : array) { 
		 	if (one.and(two).test(info)) { 
		 	list.add(info); 
		 	}
		 	 }
		 	 return list; } }

Stream流

说到Stream便容易想到I/O Stream，而实际上，谁规定“流”就一定是“IO流”呢？在Java 8中，得益于Lambda所带 来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。

引言

传统集合的多步遍历代码 几乎所有的集合（如 Collection 接口或 Map 接口等）都支持直接或间接的遍历操作。而当我们需要对集合中的元 素进行操作的时候，除了必需的添加、删除、获取外，最典型的就是集合遍历。例如

import java.util.ArrayList; 
import java.util.List; 

public class Demo01ForEach { 
	public static void main(String[] args) { 
		List<String> list = new ArrayList<>();
		 list.add("张无忌"); 
		 list.add("周芷若"); 
		 list.add("赵敏"); 
		 list.add("张强"); 
		 list.add("张三丰");
		  for (String name : list) { 
		  	System.out.println(name); } }

这是一段非常简单的集合遍历操作：对集合中的每一个字符串都进行打印输出操作。

循环遍历的弊端

Java 8的Lambda让我们可以更加专注于做什么（What），而不是怎么做（How），这点此前已经结合内部类进行 了对比说明。现在，我们仔细体会一下上例代码，可以发现：

• for循环的语法就是“怎么做”
• for循环的循环体才是“做什么”

为什么使用循环？因为要进行遍历。但循环是遍历的唯一方式吗？遍历是指每一个元素逐一进行处理，而并不是从 第一个到最后一个顺次处理的循环。前者是目的，后者是方式。
试想一下，如果希望对集合中的元素进行筛选过滤：
1. 将集合A根据条件一过滤为子集B；
2. 然后再根据条件二过滤为子集C。

那怎么办？在Java 8之前的做法可能为：

import java.util.ArrayList; 
import java.util.List; 

public class Demo02NormalFilter { 
	public static void main(String[] args) { 
		List<String> list = new ArrayList<>(); 
		list.add("张无忌"); 
		list.add("周芷若"); 
		list.add("赵敏"); 
		list.add("张强"); 
		list.add("张三丰"); 
		List<String> zhangList = new ArrayList<>(); 
		for (String name : list) { 
			if (name.startsWith("张")) { 
				zhangList.add(name); 
				} }
				
		List<String> shortList = new ArrayList<>();
		 for (String name : zhangList) { 
		 if (name.length() == 3) { 
		 	shortList.add(name); 
		 	} }
		 for (String name : shortList) { 
		 	System.out.println(name); } } }

这段代码中含有三个循环，每一个作用不同：

1. 首先筛选所有姓张的人；
2. 然后筛选名字有三个字的人；
3. 最后进行对结果进行打印输出。

每当我们需要对集合中的元素进行操作的时候，总是需要进行循环、循环、再循环。这是理所当然的么？不是。==循 环是做事情的方式，而不是目的。==另一方面，使用线性循环就意味着只能遍历一次。如果希望再次遍历，只能再使 用另一个循环从头开始。 那，Lambda的衍生物Stream能给我们带来怎样更加优雅的写法呢？

Stream的更优写法

下面来看一下借助Java 8的Stream API，什么才叫优雅：

import java.util.ArrayList; 
import java.util.List; 

public class Demo03StreamFilter {
	 public static void main(String[] args) { 
	 	List<String> list = new ArrayList<>(); 
	 		list.add("张无忌"); 
	 		list.add("周芷若"); 
	 		list.add("赵敏"); 
	 		list.add("张强"); 
	 		list.add("张三丰"); 
	 		
	 		list.stream() 
	 			.filter(s ‐> s.startsWith("张")) 
	 			.filter(s ‐> s.length() == 3) 
	 			.forEach(System.out::println);
	 			 } }

直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：获取流、过滤姓张、过滤长度为3、逐一打印。代码 中并没有体现使用线性循环或是其他任何算法进行遍历，我们真正要做的事情内容被更好地体现在代码中。

流式思想概述

注意：请暂时忘记对传统IO流的固有印象！ 整体来看，流式思想类似于工厂车间的“生产流水线”

当需要对多个元素进行操作（特别是多步操作）的时候，考虑到性能及便利性，我们应该首先拼好一个“模型”步骤 方案，然后再按照方案去执行它

这张图中展示了过滤、映射、跳过、计数等多步操作，这是一种集合元素的处理方案，而方案就是一种“函数模 型”。图中的每一个方框都是一个“流”，调用指定的方法，可以从一个流模型转换为另一个流模型。而最右侧的数字 3是最终结果

这里的 filter 、 map 、 skip 都是在对函数模型进行操作，集合元素并没有真正被处理。只有当终结方法 count 执行的时候，整个模型才会按照指定策略执行操作。而这得益于Lambda的延迟执行特性。

备注：“Stream流”其实是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何 元素（或其地址值）。

Stream（流）是一个来自数据源的元素队列

• 元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
• 数据源 流的来源。 可以是集合，数组 等

和以前的Collection操作不同， Stream操作还有两个基础的特征：

• Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluent style）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。
• 内部迭代： 以前对集合遍历都是通过Iterator或者增强for的方式, 显式的在集合外部进行迭代， 这叫做外部迭 代。 Stream提供了内部迭代的方式，流可以直接调用遍历方法。

当使用一个流的时候，通常包括三个基本步骤：获取一个数据源（source）→ 数据转换→执行操作获取想要的结 果，每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以 像链条一样排列，变成一个管道。

获取流

java.util.stream.Stream<T>是Java 8新加入的最常用的流接口。（这并不是一个函数式接口。） 获取一个流非常简单，有以下几种常用的方式：

• 所有的Collection集合都可以通过 stream 默认方法获取流；
• Stream 接口的静态方法of可以获取数组对应的流。

根据Collection获取流

首先， java.util.Collection 接口中加入了default方法 stream 用来获取流，所以其所有实现类均可获取流。

List<String> list = new ArrayList<>(); 
// ... 
Stream<String> stream1 = list.stream(); 

Set<String> set = new HashSet<>(); 

// ...
 Stream<String> stream2 = set.stream(); 
Vector<String> vector = new Vector<>();

//,,
Stream<String> stream3 = vector.stream();

根据Map获取流

java.util.Map 接口不是 Collection 的子接口，且其K-V数据结构不符合流元素的单一特征，所以获取对应的流 需要分key、value或entry等情况：

import java.util.HashMap;
 import java.util.Map;
  import java.util.stream.Stream; 
public class Demo05GetStream {
	 public static void main(String[] args) { 
	 	Map<String, String> map = new HashMap<>();
	 	 // ...
	 	 	 Stream<String> keyStream = map.keySet().stream(); 	
			Stream<String> valueStream = map.values().stream();
	 	 	  
	 	 	 Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream();
	 	 	  } }

根据数组获取流

如果使用的不是集合或映射而是数组，由于数组对象不可能添加默认方法，所以 Stream 接口中提供了静态方法 of ，使用很简单：

import java.util.stream.Stream; 

public class Demo06GetStream { 
	public static void main(String[] args) { 
		String[] array = { "张无忌", "张翠山", "张三丰", "张一元" };
		 Stream<String> stream = Stream.of(array); 
		 } }

备注： of 方法的参数其实是一个可变参数，所以支持数组。

常用方法

流模型的操作很丰富，这里介绍一些常用的API。这些方法可以被分成两种：

• 延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方 法均为延迟方法。）
• 终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调 用。本小节中，终结方法包括 count 和 forEach 方法。

备注：本小节之外的更多方法，请自行参考API文档。

逐一处理：forEach

虽然方法名字叫 forEach ，但是与for循环中的“for-each”昵称不同。

void forEach(Consumer<? super T> action);

该方法接收一个 Consumer 接口函数，会将每一个流元素交给该函数进行处理(相当于将每一个流元素都当作参数放入该消费型接口)。
基本使用：

import java.util.stream.Stream;

 public class Demo12StreamForEach {
 	 public static void main(String[] args) { 
 	 	Stream<String> stream = Stream.of("张无忌", "张三丰", "周芷若"); 
 	 	stream.forEach(name‐> System.out.println(name)); } }

过滤：filter

可以通过 filter 方法将一个流转换成另一个子集流。方法签名：

Stream<T> filter(Predicate<? super T> predicate);

该接口接收一个 Predicate 函数式接口参数（可以是一个Lambda或方法引用）作为筛选条件。

基本使用
Stream流中的 filter 方法基本使用的代码如：

import java.util.stream.Stream; 

public class Demo07StreamFilter {
	 public static void main(String[] args) {
	 	 Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若"); 
	 	 Stream<String> result = original.filter(s ‐> s.startsWith("张")); } }

在这里通过Lambda表达式来指定了筛选的条件：必须姓张。

映射：map

如果需要将流中的元素映射到另一个流中，可以使用 map 方法。方法签名：

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

该接口需要一个 Function 函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流

复习Function接口
此前我们已经学习过 java.util.stream.Function 函数式接口，其中唯一的抽象方法为：

R apply(T t);

这可以将一种T类型转换成为R类型，而这种转换的动作，就称为“映射”

基本使用
Stream流中的 map 方法基本使用的代码如：

import java.util.stream.Stream;

 public class Demo08StreamMap { 
 	public static void main(String[] args) { 
 		Stream<String> original = Stream.of("10", "12", "18");
 		 Stream<Integer> result = original.map(str‐>Integer.parseInt(str)); } }

这段代码中， map 方法的参数通过方法引用，将字符串类型转换成为了int类型（并自动装箱为 Integer 类对 象）。

统计个数：count

正如旧集合 Collection 当中的 size 方法一样，流提供count方法来数一数其中的元素个数：

long count();

该方法返回一个long值代表元素个数（不再像旧集合那样是int值）。基本使用：

import java.util.stream.Stream; 

public class Demo09StreamCount { 
	public static void main(String[] args) { 
		Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
		 Stream<String> result = original.filter(s ‐> s.startsWith("张")); 
		 System.out.println(result.count()); // 2
		  } }

取用前几个：limit

limit 方法可以对流进行截取，只取用前n个。方法签名：

Stream<T> limit(long maxSize);

参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作。基本使用：

import java.util.stream.Stream;

 public class Demo10StreamLimit { 
 	public static void main(String[] args) { 
 		Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若"); 
 		Stream<String> result = original.limit(2); 
 		System.out.println(result.count()); // 2
 		 } }

跳过前几个：skip

如果希望跳过前几个元素，可以使用 skip 方法获取一个截取之后的新流：

Stream<T> skip(long n);

如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。基本使用

import java.util.stream.Stream; 

public class Demo11StreamSkip { 
	public static void main(String[] args) { 
		Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
		 Stream<String> result = original.skip(2); 
		 System.out.println(result.count()); // 1 
		 } }

组合：concat

如果有两个流，希望合并成为一个流，那么可以使用 Stream 接口的静态方法 concat ：

static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)

备注：这是一个静态方法，与 java.lang.String 当中的 concat 方法是不同的。

该方法的基本使用代码如：

import java.util.stream.Stream; 

public class Demo12StreamConcat { 
	public static void main(String[] args) { 
		Stream<String> streamA = Stream.of("张无忌"); 
		Stream<String> streamB = Stream.of("张翠山"); 
		Stream<String> result = Stream.concat(streamA, streamB); 
		} }

练习：集合元素处理（传统方式）

题目
现在有两个 ArrayList 集合存储队伍当中的多个成员姓名，要求使用传统的for循环（或增强for循环）依次进行以 下若干操作步骤：

1. 第一个队伍只要名字为3个字的成员姓名；存储到一个新集合中。
2. 第一个队伍筛选之后只要前3个人；存储到一个新集合中。
3. 第二个队伍只要姓张的成员姓名；存储到一个新集合中。
4. 第二个队伍筛选之后不要前2个人；存储到一个新集合中。
5. 将两个队伍合并为一个队伍；存储到一个新集合中。
6. 根据姓名创建 Person 对象；存储到一个新集合中。
7. 打印整个队伍的Person对象信息。

两个队伍（集合）的代码如下
而 Person 类的代码为：

public class Person { 
	private String name; 
	public Person() {
	} 
	public Person(String name) { 
		this.name = name; }
	@Override 
	public String toString() {
	 return "Person{name='" + name + "'}"; 
	 }
	 public String getName() { return name; }
	 public void setName(String name) { this.name = name; }

//第一支队伍
 ArrayList<String> one = new ArrayList<>();
  one.add("迪丽热巴");
   one.add("宋远桥"); 
   one.add("苏星河"); 
   one.add("石破天");
    one.add("石中玉"); 
    one.add("老子");
	 one.add("庄子"); 
	 one.add("洪七公");
	 
	  //第二支队伍
	   ArrayList<String> two = new ArrayList<>(); 
	   two.add("古力娜扎"); 
	   two.add("张无忌"); 
	   two.add("赵丽颖");
	    two.add("张三丰"); 
	    two.add("尼古拉斯赵四");
	     two.add("张天爱");
	      two.add("张二狗");

// 第一个队伍只要名字为3个字的成员姓名；
 List<String> oneA = new ArrayList<>();
  for (String name : one) {
   if (name.length() == 3) { oneA.add(name); } }

// 第一个队伍筛选之后只要前3个人； 
List<String> oneB = new ArrayList<>(); 
for (int i = 0; i < 3; i++) { oneB.add(oneA.get(i)); }

// 第二个队伍只要姓张的成员姓名； 
List<String> twoA = new ArrayList<>(); 
for (String name : two) { if (name.startsWith("张")) { twoA.add(name); } }

// 第二个队伍筛选之后不要前2个人； 
List<String> twoB = new ArrayList<>(); 
for (int i = 2; i < twoA.size(); i++) { twoB.add(twoA.get(i)); }

// 将两个队伍合并为一个队伍； 
List<String> totalNames = new ArrayList<>();
 totalNames.addAll(oneB);
  totalNames.addAll(twoB);
  
   // 根据姓名创建Person对象；
    List<Person> totalPersonList = new ArrayList<>(); 
    for (String name : totalNames) { 
    	totalPersonList.add(new Person(name)); }

// 打印整个队伍的Person对象信息。
 for (Person person : totalPersonList) { System.out.println(person); } } }

运行结果为：

Person{name='宋远桥'} 
Person{name='苏星河'}
 Person{name='石破天'} 
 Person{name='张天爱'} 
 Person{name='张二狗'}

练习：集合元素处理（Stream方式）

题目将上一题当中的传统for循环写法更换为Stream流式处理方式。两个集合的初始内容不变， Person 类的定义也不 变。解答等效的Stream流式处理代码为：

List<String> one = new ArrayList<>(); 
// ...
 List<String> two = new ArrayList<>(); 
 // ... 
 // 第一个队伍只要名字为3个字的成员姓名；
  // 第一个队伍筛选之后只要前3个人； 
  Stream<String> streamOne = one.stream().filter(s ‐> s.length() == 3).limit(3); 

// 第二个队伍只要姓张的成员姓名；
 // 第二个队伍筛选之后不要前2个人；
  Stream<String> streamTwo = two.stream().filter(s ‐> s.startsWith("张")).skip(2); 

// 将两个队伍合并为一个队伍；
 // 根据姓名创建Person对象；
  // 打印整个队伍的Person对象信息。 
  Stream.concat(streamOne, streamTwo).map(Person::new).forEach(System.out::println);

运行效果完全一样：