Java基础 进阶



备注：本人建议把这些代码自己打一遍，会增加记忆，建议收藏。

面向对象思想

类和对象

简单例子

对象内存图

封装

Scanner类

引用类型使用步骤

Random类

ArrayList类

常用方法和遍历

String类

static关键字

栈和堆，需要注意一下：在类加载，会加载到堆里面，静态标记。而对象会加入到栈，入栈和出栈操作。

代码块概述

代码块是类的5大成分之一（成员变量、构造器，方法，代码块，内部类），定义在类中方法外。
在Java类下，使用 { } 括起来的代码被称为代码块 。
静态代码块:
格式：static{}
特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发、只执行一次
使用场景：在类加载的时候做一些静态数据初始化的操作，以便后续使用。
静态代码块的作用是什么?
如果要在启动系统时对静态资源进行初始化，则建议使用静态代码块完成数据的初始化操作。

单例模式

饿汉单例设计模式

在用类获取对象的时候，对象已经提前为你创建好了。
设计步骤：
定义一个类，把构造器私有。
定义一个静态变量存储一个对象。

主要思想是先创建好，在加载的时候。

懒汉单例设计模式

在真正需要该对象的时候，才去创建一个对象(延迟加载对象)。
设计步骤：
定义一个类，把构造器私有。
定义一个静态变量存储一个对象。
提供一个返回单例对象的方法。

Arrays类

设置Comparator接口对应的比较器对象，来定制比较规则。如果认为左边数据 大于 右边数据 返回正整数。如果认为左边数据 小于 右边数据 ，返回负整数

Math类

继承

抽象类

发红包案例

java继承实现发红包简单实现

接口

多态

接口多态的综合案例

java利用接口实现USB，鼠标，键盘，电脑之间的关系

final关键字

权限修饰符

抽象类和抽象方法

抽象的使用场景
抽象类可以理解成不完整的设计图，一般作为父类，让子类来继承。
当父类知道子类一定要完成某些行为，但是每个子类该行为的实现又不同，于是该父类就把该行为定义成抽象方法的形式，具体实现交给子类去完成。此时这个类就可以声明成抽象类。
最重要的特征：得到了抽象方法，失去了创建对象的能力（有得有失）

匿名内部类

本质上是一个没有名字的局部内部类。
作用：方便创建子类对象，最终目的是为了简化代码编写。
匿名内部类的特点？
匿名内部类是一个没有名字的内部类，同时也代表一个对象。
匿名内部类的对象类型，相当于是当前new的那个类型的子类类型。

以上完成了初级的学习，下面是进阶内容，务必上面的内容掌握

下面由于代码比较多，我会贴出代码，建议初学还是自己打一遍。

Object类

日期时间类

概述

类 表示特定的瞬间，精确到毫秒。

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

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

tips: 由于我们处于东八区，所以我们的基准时间为1970年1月1日8时0分0秒。

简单来说：使用无参构造，可以自动设置当前系统时间的毫秒时刻；指定long类型的构造参数，可以自定义毫秒时刻。例如：

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

常用方法

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

• 把日期对象转换成对应的时间毫秒值。

2.2 DateFormat类

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

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

构造方法

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

• ：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。

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

格式规则

常用的格式规则为：

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

创建SimpleDateFormat对象的代码如：

常用方法

DateFormat类的常用方法有：

• ：将Date对象格式化为字符串。
• ：将字符串解析为Date对象。

format方法

使用format方法的代码为：

parse方法

使用parse方法的代码为：

2.3 练习

请使用日期时间相关的API，计算出一个人已经出生了多少天。

思路：

1.获取当前时间对应的毫秒值

2.获取自己出生日期对应的毫秒值

3.两个时间相减（当前时间– 出生日期）

代码实现：

2.4 Calendar类

概念

日历我们都见过

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

获取方式

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

Calendar静态方法

• ：使用默认时区和语言环境获得一个日历

例如：

常用方法

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

• ：返回给定日历字段的值。
• ：将给定的日历字段设置为给定值。
• ：根据日历的规则，为给定的日历字段添加或减去指定的时间量。
• ：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。

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

get/set方法

get方法用来获取指定字段的值，set方法用来设置指定字段的值，代码使用演示：

add方法

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

getTime方法

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

小贴士：

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

​ 在Calendar类中，月份的表示是以0-11代表1-12月。

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

System类

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

• ：返回以毫秒为单位的当前时间。
• ：将数组中指定的数据拷贝到另一个数组中。

3.1 currentTimeMillis方法

实际上，currentTimeMillis方法就是 获取当前系统时间与1970年01月01日00:00点之间的毫秒差值

练习

验证for循环打印数字1-9999所需要使用的时间（毫秒）

3.2 arraycopy方法

• ：将数组中指定的数据拷贝到另一个数组中。

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

练习

将src数组中前3个元素，复制到dest数组的前3个位置上复制元素前：src数组元素[1,2,3,4,5]，dest数组元素[6,7,8,9,10]复制元素后：src数组元素[1,2,3,4,5]，dest数组元素[1,2,3,9,10]

StringBuilder类

4.1 字符串拼接问题

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

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

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

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

4.2 StringBuilder概述

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

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

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

4.3 构造方法

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

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

4.4 常用方法

StringBuilder常用的方法有2个：

• ：添加任意类型数据的字符串形式，并返回当前对象自身。支持链式
• ：将当前StringBuilder对象转换为String对象。

append方法

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

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

toString方法

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

第五章 包装类

5.1 概述

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

5.2 装箱与拆箱

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

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

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

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

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

5.3自动装箱与自动拆箱

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

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

基本类型转换为String

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

String转换成对应的基本类型

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

• ：将字符串参数转换为对应的byte基本类型。
• ：将字符串参数转换为对应的short基本类型。
• ：将字符串参数转换为对应的int基本类型。
• ：将字符串参数转换为对应的long基本类型。
• ：将字符串参数转换为对应的float基本类型。
• ：将字符串参数转换为对应的double基本类型。
• ：将字符串参数转换为对应的boolean基本类型。

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

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

Collection集合

1.1 集合概述

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

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

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

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

1.2 集合框架

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

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

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nQRyUTKY-59)(imgCollection集合体系图.png)]

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

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

1.3 Collection 常用功能

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

• ： 把给定的对象添加到当前集合中 。
• :清空集合中所有的元素。
• : 把给定的对象在当前集合中删除。
• : 判断当前集合中是否包含给定的对象。
• : 判断当前集合是否为空。
• : 返回集合中元素的个数。
• : 把集合中的元素，存储到数组中。

方法演示：

tips: 有关Collection中的方法可不止上面这些，其他方法可以自行查看API学习。

Iterator迭代器

2.1 Iterator接口

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

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

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

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

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

Iterator接口的常用方法如下：

• :返回迭代的下一个元素。
• :如果仍有元素可以迭代，则返回 true。

接下来我们通过案例学习如何使用Iterator迭代集合中元素：

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

2.2 迭代器的实现原理

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Xsjgp49q-60)(img迭代器原理图.bmp)]

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

2.3 增强for

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

格式：

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

练习1：遍历数组

练习2:遍历集合

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

泛型

3.1 泛型概述

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

大家观察下面代码：

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

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

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

3.2 使用泛型的好处

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

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

通过我们如下代码体验一下：

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

3.3 泛型的定义与使用

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

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

定义和使用含有泛型的类

定义格式：

例如，API中的ArrayList集合：

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

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

例如，

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

再例如，

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

举例自定义泛型类

使用:

含有泛型的方法

定义格式：

例如，

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

含有泛型的接口

定义格式：

例如，

使用格式：

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

例如

此时，泛型E的值就是String类型。

2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型

例如

确定泛型：

3.4 泛型通配符

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

通配符基本使用

泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。

此时只能接受数据,不能往该集合中存储数据。

举个例子大家理解使用即可：

tips:泛型不存在继承关系 Collection list = new ArrayList();这种是错误的。

通配符高级使用----受限泛型

之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。

泛型的上限：

• 格式：
• 意义：

泛型的下限：

• 格式：
• 意义：

比如：现已知Object类，String 类，Number类，Integer类，其中Number是Integer的父类

集合综合案例

4.1 案例介绍

使用54张牌打乱顺序,三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。

4.2 案例分析

• 准备牌：

  牌可以设计为一个ArrayList,每个字符串为一张牌。
  每张牌由花色数字两部分组成，我们可以使用花色集合与数字集合嵌套迭代完成每张牌的组装。
  牌由Collections类的shuffle方法进行随机排序。

• 发牌

  将每个人以及底牌设计为ArrayList,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。

• 看牌

  直接打印每个集合。

4.3 代码实现

数据结构

2.1 数据结构有什么用？

当你用着java里面的容器类很爽的时候，你有没有想过，怎么ArrayList就像一个无限扩充的数组，也好像链表之类的。好用吗？好用，这就是数据结构的用处，只不过你在不知不觉中使用了。

现实世界的存储，我们使用的工具和建模。每种数据结构有自己的优点和缺点，想想如果Google的数据用的是数组的存储，我们还能方便地查询到所需要的数据吗？而算法，在这么多的数据中如何做到最快的插入，查找，删除，也是在追求更快。

我们java是面向对象的语言，就好似自动档轿车，C语言好似手动档吉普。数据结构呢？是变速箱的工作原理。你完全可以不知道变速箱怎样工作，就把自动档的车子从 A点 开到 B点，而且未必就比懂得的人慢。写程序这件事，和开车一样，经验可以起到很大作用，但如果你不知道底层是怎么工作的，就永远只能开车，既不会修车，也不能造车。当然了，数据结构内容比较多，细细的学起来也是相对费功夫的，不可能达到一蹴而就。我们将常见的数据结构：堆栈、队列、数组、链表和红黑树 这几种给大家介绍一下，作为数据结构的入门，了解一下它们的特点即可。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NuHxgk7r-77)(img数据结构比喻.png)]

2.2 常见的数据结构

数据存储的常用结构有：栈、队列、数组、链表和红黑树。我们分别来了解一下：

栈

• 栈：stack,又称堆栈，它是运算受限的线性表，其限制是仅允许在标的一端进行插入和删除操作，不允许在其他任何位置进行添加、查找、删除等操作。

简单的说：采用该结构的集合，对元素的存取有如下的特点

• 先进后出（即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元素）。例如，子弹压进弹夹，先压进去的子弹在下面，后压进去的子弹在上面，当开枪时，先弹出上面的子弹，然后才能弹出下面的子弹。
• 栈的入口、出口的都是栈的顶端位置。

这里两个名词需要注意：

• 压栈：就是存元素。即，把元素存储到栈的顶端位置，栈中已有元素依次向栈底方向移动一个位置。
• 弹栈：就是取元素。即，把栈的顶端位置元素取出，栈中已有元素依次向栈顶方向移动一个位置。

队列

• 队列：queue,简称队，它同堆栈一样，也是一种运算受限的线性表，其限制是仅允许在表的一端进行插入，而在表的另一端进行删除。

简单的说，采用该结构的集合，对元素的存取有如下的特点：

• 先进先出（即，存进去的元素，要在后它前面的元素依次取出后，才能取出该元素）。例如，小火车过山洞，车头先进去，车尾后进去；车头先出来，车尾后出来。
• 队列的入口、出口各占一侧。例如，下图中的左侧为入口，右侧为出口。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zZIIA251-79)(img队列图.bmp)]

数组

• 数组:Array,是有序的元素序列，数组是在内存中开辟一段连续的空间，并在此空间存放元素。就像是一排出租屋，有100个房间，从001到100每个房间都有固定编号，通过编号就可以快速找到租房子的人。

简单的说,采用该结构的集合，对元素的存取有如下的特点：

• 查找元素快：通过索引，可以快速访问指定位置的元素

• 增删元素慢
  • 指定索引位置增加元素：需要创建一个新数组，将指定新元素存储在指定索引位置，再把原数组元素根据索引，复制到新数组对应索引的位置。如下图
    
  • 指定索引位置删除元素：需要创建一个新数组，把原数组元素根据索引，复制到新数组对应索引的位置，原数组中指定索引位置元素不复制到新数组中。如下图
    

链表

• 链表:linked list,由一系列结点node（链表中每一个元素称为结点）组成，结点可以在运行时i动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。我们常说的链表结构有单向链表与双向链表，那么这里给大家介绍的是单向链表。

• 查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素
• 增删元素快：
  • 增加元素：只需要修改连接下个元素的地址即可。
    
  • 删除元素：只需要修改连接下个元素的地址即可。

  

红黑树

• 二叉树：binary tree ,是每个结点不超过2的有序树（tree） 。

简单的理解，就是一种类似于我们生活中树的结构，只不过每个结点上都最多只能有两个子结点。

二叉树是每个节点最多有两个子树的树结构。顶上的叫根结点，两边被称作“左子树”和“右子树”。

如图：

我们要说的是二叉树的一种比较有意思的叫做红黑树，红黑树本身就是一颗二叉查找树，将节点插入后，该树仍然是一颗二叉查找树。也就意味着，树的键值仍然是有序的。

红黑树的约束:

1. 节点可以是红色的或者黑色的
2. 根节点是黑色的
3. 叶子节点(特指空节点)是黑色的
4. 每个红色节点的子节点都是黑色的
5. 任何一个节点到其每一个叶子节点的所有路径上黑色节点数相同

红黑树的特点:

​ 速度特别快,趋近平衡树,查找叶子元素最少和最多次数不多于二倍

List集合

我们掌握了Collection接口的使用后，再来看看Collection接口中的子类，他们都具备那些特性呢？

接下来，我们一起学习Collection中的常用几个子类（集合、集合）。

1.1 List接口介绍

接口继承自接口，是单列集合的一个重要分支，习惯性地会将实现了接口的对象称为List集合。在List集合中允许出现重复的元素，所有的元素是以一种线性方式进行存储的，在程序中可以通过索引来访问集合中的指定元素。另外，List集合还有一个特点就是元素有序，即元素的存入顺序和取出顺序一致。

看完API，我们总结一下：

List接口特点：

1. 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
2. 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
3. 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。

Java基础 进阶

tips:我们在基础班的时候已经学习过List接口的子类java.util.ArrayList类，该类中的方法都是来自List中定义。

1.2 List接口中常用方法

List作为Collection集合的子接口，不但继承了Collection接口中的全部方法，而且还增加了一些根据元素索引来操作集合的特有方法，如下：

• : 将指定的元素，添加到该集合中的指定位置上。
• :返回集合中指定位置的元素。
• : 移除列表中指定位置的元素, 返回的是被移除的元素。
• :用指定元素替换集合中指定位置的元素,返回值的更新前的元素。

List集合特有的方法都是跟索引相关，我们在基础班都学习过，那么我们再来复习一遍吧：

List的子类

3.1 ArrayList集合

集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以是最常用的集合。

许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。

3.2 LinkedList集合

集合数据存储的结构是链表结构。方便元素添加、删除的集合。

LinkedList是一个双向链表，那么双向链表是什么样子的呢，我们用个图了解下

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-opRVlOMr-90)(img双向链表.png)]

实际开发中对一个集合元素的添加与删除经常涉及到首尾操作，而LinkedList提供了大量首尾操作的方法。这些方法我们作为了解即可：

• :将指定元素插入此列表的开头。
• :将指定元素添加到此列表的结尾。
• :返回此列表的第一个元素。
• :返回此列表的最后一个元素。
• :移除并返回此列表的第一个元素。
• :移除并返回此列表的最后一个元素。
• :从此列表所表示的堆栈处弹出一个元素。
• :将元素推入此列表所表示的堆栈。
• ：如果列表不包含元素，则返回true。

LinkedList是List的子类，List中的方法LinkedList都是可以使用，这里就不做详细介绍，我们只需要了解LinkedList的特有方法即可。在开发时，LinkedList集合也可以作为堆栈，队列的结构使用。（了解即可）

方法演示：

Set接口

接口和接口一样，同样继承自接口，它与接口中的方法基本一致，并没有对接口进行功能上的扩充，只是比接口更加严格了。与接口不同的是，接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。

集合有多个子类，这里我们介绍其中的、这两个集合。

tips:Set集合取出元素的方式可以采用：迭代器、增强for。

3.1 HashSet集合介绍

是接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不一致)。底层的实现其实是一个支持，由于我们暂时还未学习，先做了解。

是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。保证元素唯一性的方式依赖于：与方法。

我们先来使用一下Set集合存储，看下现象，再进行原理的讲解:

输出结果如下，说明集合中不能存储重复元素：

tips:根据结果我们发现字符串"cba"只存储了一个，也就是说重复的元素set集合不存储。

2.2 HashSet集合存储数据的结构（哈希表）

什么是哈希表呢？

在JDK1.8之前，哈希表底层采用数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，哈希表存储采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。

简单的来说，哈希表是由数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的，如下图所示。

看到这张图就有人要问了，这个是怎么存储的呢？

为了方便大家的理解我们结合一个存储流程图来说明一下：

总而言之，JDK1.8引入红黑树大程度优化了HashMap的性能，那么对于我们来讲保证HashSet集合元素的唯一，其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义的对象，那么保证其唯一，就必须复写hashCode和equals方法建立属于当前对象的比较方式。

2.3 HashSet存储自定义类型元素

给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一

创建自定义Student类

2.3 LinkedHashSet

我们知道HashSet保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序，怎么办呢？

在HashSet下面有一个子类，它是链表和哈希表组合的一个数据存储结构。

演示代码如下:

1.9 可变参数

在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化成如下格式：

其实这个书写完全等价与

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

JDK1.5以后。出现了简化操作。… 用在参数上，称之为可变参数。

同样是代表数组，但是在调用这个带有可变参数的方法时，不用创建数组(这就是简单之处)，直接将数组中的元素作为实际参数进行传递，其实编译成的class文件，将这些元素先封装到一个数组中，在进行传递。这些动作都在编译.class文件时，自动完成了。

代码演示：

tips: 上述add方法在同一个类中，只能存在一个。因为会发生调用的不确定性

注意：如果在方法书写时，这个方法拥有多参数，参数中包含可变参数，可变参数一定要写在参数列表的末尾位置。

Collections

2.1 常用功能

• 是集合工具类，用来对集合进行操作。部分方法如下：
• :往集合中添加一些元素。
• :打乱集合顺序。
• :将集合中元素按照默认规则排序。
• :将集合中元素按照指定规则排序。

代码演示：

代码演示之后 ，发现我们的集合按照顺序进行了排列，可是这样的顺序是采用默认的顺序，如果想要指定顺序那该怎么办呢？

我们发现还有个方法没有讲，:将集合中元素按照指定规则排序。接下来讲解一下指定规则的排列。

2.2 Comparator比较器

我们还是先研究这个方法

:将集合中元素按照默认规则排序。

不过这次存储的是字符串类型。

结果：

我们使用的是默认的规则完成字符串的排序，那么默认规则是怎么定义出来的呢？

说到排序了，简单的说就是两个对象之间比较大小，那么在JAVA中提供了两种比较实现的方式，一种是比较死板的采用接口去实现，一种是灵活的当我需要做排序的时候在去选择的接口完成。

那么我们采用的这个方法完成的排序，实际上要求了被排序的类型需要实现Comparable接口完成比较的功能，在String类型上如下：

String类实现了这个接口，并完成了比较规则的定义，但是这样就把这种规则写死了，那比如我想要字符串按照第一个字符降序排列，那么这样就要修改String的源代码，这是不可能的了，那么这个时候我们可以使用

方法灵活的完成，这个里面就涉及到了Comparator这个接口，位于位于java.util包下，排序是comparator能实现的功能之一,该接口代表一个比较器，比较器具有可比性！顾名思义就是做排序的，通俗地讲需要比较两个对象谁排在前谁排在后，那么比较的方法就是：

• ：比较其两个参数的顺序。

  两个对象比较的结果有三种：大于，等于，小于。

  如果要按照升序排序，
  则o1 小于o2，返回（负数），相等返回0，01大于02返回（正数）
  如果要按照降序排序
  则o1 小于o2，返回（正数），相等返回0，01大于02返回（负数）

操作如下:

结果如下：

2.3 简述Comparable和Comparator两个接口的区别。

Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

2.4 练习

创建一个学生类，存储到ArrayList集合中完成指定排序操作。

Student 初始类

测试类：

发现，当我们调用Collections.sort()方法的时候 程序报错了。

原因：如果想要集合中的元素完成排序，那么必须要实现比较器Comparable接口。

于是我们就完成了Student类的一个实现，如下：

再次测试，代码就OK 了效果如下：

2.5 扩展

如果在使用的时候，想要独立的定义规则去使用 可以采用Collections.sort(List list,Comparetor c)方式，自己定义规则：

效果：

如果想要规则更多一些，可以参考下面代码：

效果如下：

Map集合

1.1 概述

现实生活中，我们常会看到这样的一种集合：IP地址与主机名，身份证号与个人，系统用户名与系统用户对象等，这种一一对应的关系，就叫做映射。Java提供了专门的集合类用来存放这种对象关系的对象，即接口。

我们通过查看接口描述，发现接口下的集合与接口下的集合，它们存储数据的形式不同，如下图。

• 中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。
• 中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。
• 中的集合称为单列集合，中的集合称为双列集合。
• 需要注意的是，中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

1.2 Map常用子类

通过查看Map接口描述，看到Map有多个子类，这里我们主要讲解常用的HashMap集合、LinkedHashMap集合。

• HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
• LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

tips：Map接口中的集合都有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同。

1.3 Map接口中的常用方法

Map接口中定义了很多方法，常用的如下：

• : 把指定的键与指定的值添加到Map集合中。
• : 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
• 根据指定的键，在Map集合中获取对应的值。
• 判断集合中是否包含指定的键。
• : 获取Map集合中所有的键，存储到Set集合中。
• : 获取到Map集合中所有的键值对对象的集合(Set集合)。

Map接口的方法演示

tips:

使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中；

若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。

1.4 Map集合遍历键找值方式

键找值方式：即通过元素中的键，获取键所对应的值

分析步骤：

1. 获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示:
2. 遍历键的Set集合，得到每一个键。
3. 根据键，获取键所对应的值。方法提示:

代码演示：

遍历图解：

1.5 Entry键值对对象

我们已经知道，中存放的是两种对象，一种称为key(键)，一种称为value(值)，它们在在中是一一对应关系，这一对对象又称做中的一个。将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历集合时，就可以从每一个键值对（）对象中获取对应的键与对应的值。

既然Entry表示了一对键和值，那么也同样提供了获取对应键和对应值得方法：

• ：获取Entry对象中的键。
• ：获取Entry对象中的值。

在Map集合中也提供了获取所有Entry对象的方法：

• : 获取到Map集合中所有的键值对对象的集合(Set集合)。

1.6 Map集合遍历键值对方式

键值对方式：即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。

操作步骤与图解：

1. 获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。方法提示:。
2. 遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象。
3. 通过键值对(Entry)对象，获取Entry对象中的键与值。 方法提示:

遍历图解：

tips：Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。

1.7 HashMap存储自定义类型键值

练习：每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。

注意，学生姓名相同并且年龄相同视为同一名学生。

编写学生类：

编写测试类：

• 当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法(如果忘记，请回顾HashSet存放自定义对象)。
• 如果要保证map中存放的key和取出的顺序一致，可以使用集合来存放。

1.8 LinkedHashMap

我们知道HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办呢？

在HashMap下面有一个子类LinkedHashMap，它是链表和哈希表组合的一个数据存储结构。

结果:

1.9 Map集合练习

需求：

计算一个字符串中每个字符出现次数。

分析：

1. 获取一个字符串对象
2. 创建一个Map集合，键代表字符，值代表次数。
3. 遍历字符串得到每个字符。
4. 判断Map中是否有该键。
5. 如果没有，第一次出现，存储次数为1；如果有，则说明已经出现过，获取到对应的值进行++，再次存储。
6. 打印最终结果

代码：

模拟斗地主洗牌发牌

3.1 案例介绍

按照斗地主的规则，完成洗牌发牌的动作。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9fiEniTu-89)(img斗地主.png)]

具体规则：

1. 组装54张扑克牌将
2. 54张牌顺序打乱
3. 三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。
4. 查看三人各自手中的牌（按照牌的大小排序）、底牌

规则：手中扑克牌从大到小的摆放顺序：大王,小王,2,A,K,Q,J,10,9,8,7,6,5,4,3

3.2 案例需求分析

1. 准备牌：

完成数字与纸牌的映射关系：

使用双列Map(HashMap)集合，完成一个数字与字符串纸牌的对应关系(相当于一个字典)。

2. 洗牌：

通过数字完成洗牌发牌

3. 发牌：

将每个人以及底牌设计为ArrayList,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。

存放的过程中要求数字大小与斗地主规则的大小对应。

将代表不同纸牌的数字分配给不同的玩家与底牌。

4. 看牌：

通过Map集合找到对应字符展示。

通过查询纸牌与数字的对应关系，由数字转成纸牌字符串再进行展示。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YIwsFlwR-89)(img斗地主分析.png)]

3.3 实现代码步骤

异常

1.1 异常概念

异常，就是不正常的意思。在生活中:医生说,你的身体某个部位有异常,该部位和正常相比有点不同,该部位的功能将受影响.在程序中的意思就是：

• 异常 ：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。

在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。

异常指的并不是语法错误,语法错了,编译不通过,不会产生字节码文件,根本不能运行.

1.2 异常体系

异常机制其实是帮助我们找到程序中的问题，异常的根类是，其下有两个子类：与，平常所说的异常指。

1.4 异常的产生过程解析

先运行下面的程序，程序会产生一个数组索引越界异常ArrayIndexOfBoundsException。我们通过图解来解析下异常产生的过程。

工具类

测试类

上述程序执行过程图解：

异常的处理

Java异常处理的五个关键字：try、catch、finally、throw、throws

2.1 抛出异常throw

在编写程序时，我们必须要考虑程序出现问题的情况。比如，在定义方法时，方法需要接受参数。那么，当调用方法使用接受到的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。

在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。那么，抛出一个异常具体如何操作呢？

1. 创建一个异常对象。封装一些提示信息(信息可以自己编写)。
2. 需要将这个异常对象告知给调用者。怎么告知呢？怎么将这个异常对象传递到调用者处呢？通过关键字throw就可以完成。throw 异常对象。

   throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。

使用格式：

例如：

学习完抛出异常的格式后，我们通过下面程序演示下throw的使用。

注意：如果产生了问题，我们就会throw将问题描述类即异常进行抛出，也就是将问题返回给该方法的调用者。

那么对于调用者来说，该怎么处理呢？一种是进行捕获处理，另一种就是继续讲问题声明出去，使用throws声明处理。

2.2 Objects非空判断

还记得我们学习过一个类Objects吗，曾经提到过它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），那么在它的源码中，对对象为null的值进行了抛出异常操作。

• :查看指定引用对象不是null。

查看源码发现这里对为null的进行了抛出异常操作：

2.3 声明异常throws

声明异常：将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理（稍后讲解该方式），那么必须通过throws进行声明，让调用者去处理。

关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).

声明异常格式：

声明异常的代码演示：

throws用于进行异常类的声明，若该方法可能有多种异常情况产生，那么在throws后面可以写多个异常类，用逗号隔开。

2.4 捕获异常try…catch

如果异常出现的话,会立刻终止程序,所以我们得处理异常:

1. 该方法不处理,而是声明抛出,由该方法的调用者来处理(throws)。
2. 在方法中使用try-catch的语句块来处理异常。

try-catch的方式就是捕获异常。

• 捕获异常：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。

捕获异常语法如下：

try：该代码块中编写可能产生异常的代码。

catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。

注意:try和catch都不能单独使用,必须连用。

演示如下：

如何获取异常信息：

Throwable类中定义了一些查看方法:

• :获取异常的描述信息,原因(提示给用户的时候,就提示错误原因。
• :获取异常的类型和异常描述信息(不用)。
• :打印异常的跟踪栈信息并输出到控制台。

​ 包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。

2.4 finally 代码块

finally：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。

什么时候的代码必须最终执行？

当我们在try语句块中打开了一些物理资源(磁盘文件/网络连接/数据库连接等),我们都得在使用完之后,最终关闭打开的资源。

finally的语法:

try…catch…finally:自身需要处理异常,最终还得关闭资源。

注意:finally不能单独使用。

比如在我们之后学习的IO流中，当打开了一个关联文件的资源，最后程序不管结果如何，都需要把这个资源关闭掉。

finally代码参考如下：

当只有在try或者catch中调用退出JVM的相关方法,此时finally才不会执行,否则finally永远会执行。

2.5 异常注意事项

• 多个异常使用捕获又该如何处理呢？
  1. 多个异常分别处理。
  2. 多个异常一次捕获，多次处理。
  3. 多个异常一次捕获一次处理。

  一般我们是使用一次捕获多次处理方式，格式如下：

  注意:这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。

• 运行时异常被抛出可以不处理。即不捕获也不声明抛出。
• 如果finally有return语句,永远返回finally中的结果,避免该情况.
• 如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。
• 父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出

自定义异常

3.1 概述

为什么需要自定义异常类:

我们说了Java中不同的异常类,分别表示着某一种具体的异常情况,那么在开发中总是有些异常情况是SUN没有定义好的,此时我们根据自己业务的异常情况来定义异常类。例如年龄负数问题,考试成绩负数问题等等。

在上述代码中，发现这些异常都是JDK内部定义好的，但是实际开发中也会出现很多异常,这些异常很可能在JDK中没有定义过,例如年龄负数问题,考试成绩负数问题.那么能不能自己定义异常呢？

什么是自定义异常类:

在开发中根据自己业务的异常情况来定义异常类.

自定义一个业务逻辑异常: RegisterException。一个注册异常类。

异常类如何定义:

1. 自定义一个编译期异常: 自定义类 并继承于。
2. 自定义一个运行时期的异常类:自定义类 并继承于。

3.2 自定义异常的练习

要求：我们模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。

首先定义一个登陆异常类RegisterException：

模拟登陆操作，使用数组模拟数据库中存储的数据，并提供当前注册账号是否存在方法用于判断。

多线程

我们在之前，学习的程序在没有跳转语句的前提下，都是由上至下依次执行，那现在想要设计一个程序，边打游戏边听歌，怎么设计？

要解决上述问题,咱们得使用多进程或者多线程来解决.

4.1 并发与并行

• 并发：指两个或多个事件在同一个时间段内发生。
• 并行：指两个或多个事件在同一时刻发生（同时发生）。

在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU 系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。

而在多个 CPU 系统中，则这些可以并发执行的程序便可以分配到多个处理器上（CPU），实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU，便是多核处理器，核 越多，并行处理的程序越多，能大大的提高电脑运行的效率。

注意：单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。同理,线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。

4.2 线程与进程

• 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
• 线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

  简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

我们可以再电脑底部任务栏，右键----->打开任务管理器,可以查看当前任务的进程：

进程

线程

线程调度:

• 分时调度

  所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

• 抢占式调度

  优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

  • 设置线程的优先级

  

  • 抢占式调度详解

    大部分操作系统都支持多进程并发运行，现在的操作系统几乎都支持同时运行多个程序。比如：现在我们上课一边使用编辑器，一边使用录屏软件，同时还开着画图板，dos窗口等软件。此时，这些程序是在同时运行，”感觉这些软件好像在同一时刻运行着“。

4.3 创建线程类

Java使用类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。Java中通过继承Thread类来创建并启动多线程的步骤如下：

1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
2. 创建Thread子类的实例，即创建了线程对象
3. 调用线程对象的start()方法来启动该线程

代码如下：

测试类：

自定义线程类：

线程

线程安全

线程状态

线程池、Lambda表达式

java等待与唤醒案例、线程池、Lambda表达式(附代码)

File类

1.1 概述

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

1.2 构造方法

• ：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
• ：从父路径名字符串和子路径名字符串创建新的 File实例。
• ：从父抽象路径名和子路径名字符串创建新的 File实例。
• 构造举例，代码如下：

小贴士：

1. 一个File对象代表硬盘中实际存在的一个文件或者目录。
2. 无论该路径下是否存在文件或者目录，都不影响File对象的创建。

1.3 常用方法

获取功能的方法

• ：返回此File的绝对路径名字符串。
• ：将此File转换为路径名字符串。
• ：返回由此File表示的文件或目录的名称。
• ：返回由此File表示的文件的长度。

  方法演示，代码如下：

API中说明：length()，表示文件的长度。但是File对象表示目录，则返回值未指定。

绝对路径和相对路径

• 绝对路径：从盘符开始的路径，这是一个完整的路径。
• 相对路径：相对于项目目录的路径，这是一个便捷的路径，开发中经常使用。

判断功能的方法

• ：此File表示的文件或目录是否实际存在。
• ：此File表示的是否为目录。
• ：此File表示的是否为文件。

方法演示，代码如下：

创建删除功能的方法

• ：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。
• ：删除由此File表示的文件或目录。
• ：创建由此File表示的目录。
• ：创建由此File表示的目录，包括任何必需但不存在的父目录。

方法演示，代码如下：

API中说明：delete方法，如果此File表示目录，则目录必须为空才能删除。

1.4 目录的遍历

• ：返回一个String数组，表示该File目录中的所有子文件或目录。
• ：返回一个File数组，表示该File目录中的所有的子文件或目录。

小贴士：

调用listFiles方法的File对象，表示的必须是实际存在的目录，否则返回null，无法进行遍历。

递归

2.1 概述

• 递归：指在当前方法内调用自己的这种现象。
• 递归的分类:
  • 递归分为两种，直接递归和间接递归。
  • 直接递归称为方法自身调用自己。
  • 间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。
• 注意事项：
  • 递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。
  • 在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
  • 构造方法,禁止递归

2.2 递归累加求和

计算1 ~ n的和

分析：num的累和 = num + (num-1)的累和，所以可以把累和的操作定义成一个方法，递归调用。

实现代码：

代码执行图解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mbcOhduQ-24)(img/day08_01_递归累和.jpg)]

小贴士：递归一定要有条件限定，保证递归能够停止下来，次数不要太多，否则会发生栈内存溢出。

2.3 递归求阶乘

• 阶乘：所有小于及等于该数的正整数的积。

分析：这与累和类似,只不过换成了乘法运算，学员可以自己练习，需要注意阶乘值符合int类型的范围。

代码实现：

2.4 递归打印多级目录

分析：多级目录的打印，就是当目录的嵌套。遍历之前，无从知道到底有多少级目录，所以我们还是要使用递归实现。

代码实现：

综合案例

3.1 文件搜索

搜索 目录中的 文件。

分析：

1. 目录搜索，无法判断多少级目录，所以使用递归，遍历所有目录。
2. 遍历目录时，获取的子文件，通过文件名称，判断是否符合条件。

代码实现：

3.2 文件过滤器优化

是一个接口，是File的过滤器。 该接口的对象可以传递给File类的 作为参数， 接口中只有一个方法。

：测试pathname是否应该包含在当前File目录中，符合则返回true。

分析：

1. 接口作为参数，需要传递子类对象，重写其中方法。我们选择匿名内部类方式，比较简单。
2. 方法，参数为File，表示当前File下所有的子文件和子目录。保留住则返回true，过滤掉则返回false。保留规则：
   1. 要么是.java文件。
   2. 要么是目录，用于继续遍历。
3. 通过过滤器的作用，返回的数组元素中，子文件对象都是符合条件的，可以直接打印。

代码实现：

3.3 Lambda优化

分析：是只有一个方法的接口，因此可以用lambda表达式简写。

lambda格式：

代码实现：

IO概述

1.1 什么是IO

生活中，你肯定经历过这样的场景。当你编辑一个文本文件，忘记了 ，可能文件就白白编辑了。当你电脑上插入一个U盘，可以把一个视频，拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢？键盘、内存、硬盘、外接设备等等。

我们把这种数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为 和 ，即流向内存是输入流，流出内存的输出流。

Java中I/O操作主要是指使用包下的内容，进行输入、输出操作。输入也叫做读取数据，输出也叫做作写出数据。

1.2 IO的分类

根据数据的流向分为：输入流和输出流。

• 输入流 ：把数据从上读取到中的流。
• 输出流 ：把数据从 中写出到上的流。

格局数据的类型分为：字节流和字符流。

• 字节流 ：以字节为单位，读写数据的流。
• 字符流 ：以字符为单位，读写数据的流。

1.3 IO的流向说明图解

1.4 顶级父类们

字节流

2.1 一切皆为字节

一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。

2.2 字节输出流【OutputStream】

抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。

• ：关闭此输出流并释放与此流相关联的任何系统资源。
• ：刷新此输出流并强制任何缓冲的输出字节被写出。
• ：将 b.length字节从指定的字节数组写入此输出流。
• ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
• ：将指定的字节输出流。

小贴士：

close方法，当完成流的操作时，必须调用此方法，释放系统资源。

2.3 FileOutputStream类

有很多子类，我们从最简单的一个子类开始。

类是文件输出流，用于将数据写出到文件。

构造方法

• ：创建文件输出流以写入由指定的 File对象表示的文件。
• ： 创建文件输出流以指定的名称写入文件。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。

• 构造举例，代码如下：

写出字节数据

1. 写出字节： 方法，每次可以写出一个字节数据，代码使用演示：

小贴士：

1. 虽然参数为int类型四个字节，但是只会保留一个字节的信息写出。
2. 流操作完毕后，必须释放系统资源，调用close方法，千万记得。

2. 写出字节数组：，每次可以写出数组中的数据，代码使用演示：

3. 写出指定长度字节数组： ,每次写出从off索引开始，len个字节，代码使用演示：

数据追加续写

经过以上的演示，每次程序运行，创建输出流对象，都会清空目标文件中的数据。如何保留目标文件中数据，还能继续添加新数据呢？

• ： 创建文件输出流以写入由指定的 File对象表示的文件。
• ： 创建文件输出流以指定的名称写入文件。

这两个构造方法，参数中都需要传入一个boolean类型的值， 表示追加数据， 表示清空原有数据。这样创建的输出流对象，就可以指定是否追加续写了，代码使用演示：

写出换行

Windows系统里，换行符号是 。把

以指定是否追加续写了，代码使用演示：

• 回车符和换行符 ：
  • 回车符：回到一行的开头（return）。
  • 换行符：下一行（newline）。
• 系统中的换行：
  • Windows系统里，每行结尾是 ，即；
  • Unix系统里，每行结尾只有 ，即；
  • Mac系统里，每行结尾是 ，即。从 Mac OS X开始与Linux统一。

2.4 字节输入流【InputStream】

抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。

• ：关闭此输入流并释放与此流相关联的任何系统资源。
• ： 从输入流读取数据的下一个字节。
• ： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。

小贴士：

close方法，当完成流的操作时，必须调用此方法，释放系统资源。

2.5 FileInputStream类

类是文件输入流，从文件中读取字节。

构造方法

• ： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
• ： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件,会抛出 。

• 构造举例，代码如下：

读取字节数据

1. 读取字节：方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回，代码使用演示：

循环改进读取方式，代码使用演示：

小贴士：

1. 虽然读取了一个字节，但是会自动提升为int类型。
2. 流操作完毕后，必须释放系统资源，调用close方法，千万记得。

2. 使用字节数组读取：，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回 ，代码使用演示：

错误数据，是由于最后一次读取时，只读取一个字节，数组中，上次读取的数据没有被完全替换，所以要通过 ，获取有效的字节，代码使用演示：

小贴士：

使用数组读取，每次读取多个字节，减少了系统间的IO操作次数，从而提高了读写的效率，建议开发中使用。

2.6 字节流练习：图片复制

复制原理图解

案例实现

复制图片文件，代码使用演示：

小贴士：

流的关闭原则：先开后关，后开先关。

字符流

当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。

3.1 字符输入流【Reader】

抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。

• ：关闭此流并释放与此流相关联的任何系统资源。
• ： 从输入流读取一个字符。
• ： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。

3.2 FileReader类

类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

小贴士：

1. 字符编码：字节与字符的对应规则。Windows系统的中文编码默认是GBK编码表。

idea中UTF-8

2. 字节缓冲区：一个字节数组，用来临时存储字节数据。

构造方法

• ： 创建一个新的 FileReader ，给定要读取的File对象。
• ： 创建一个新的 FileReader ，给定要读取的文件的名称。

当你创建一个流对象时，必须传入一个文件路径。类似于FileInputStream 。

• 构造举例，代码如下：

读取字符数据

1. 读取字符：方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回，循环读取，代码使用演示：

小贴士：虽然读取了一个字符，但是会自动提升为int类型。

2. 使用字符数组读取：，每次读取b的长度个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回 ，代码使用演示：

获取有效的字符改进，代码使用演示：

3.3 字符输出流【Writer】

抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。

• 写入单个字符。
• 写入字符数组。
• 写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
• 写入字符串。
• 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
• 刷新该流的缓冲。
• 关闭此流，但要先刷新它。

3.4 FileWriter类

类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

构造方法

• ： 创建一个新的 FileWriter，给定要读取的File对象。
• ： 创建一个新的 FileWriter，给定要读取的文件的名称。

当你创建一个流对象时，必须传入一个文件路径，类似于FileOutputStream。

• 构造举例，代码如下：

基本写出数据

写出字符： 方法，每次可以写出一个字符数据，代码使用演示：

小贴士：

1. 虽然参数为int类型四个字节，但是只会保留一个字符的信息写出。
2. 未调用close方法，数据只是保存到了缓冲区，并未写出到文件中。

关闭和刷新

因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据的。如果我们既想写出数据，又想继续使用流，就需要 方法了。

• ：刷新缓冲区，流对象可以继续使用。
• :先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

代码使用演示：

小贴士：即便是flush方法写出了数据，操作的最后还是要调用close方法，释放系统资源。

写出其他数据

1. 写出字符数组 ： 和 ，每次可以写出字符数组中的数据，用法类似FileOutputStream，代码使用演示：

2. 写出字符串： 和 ，每次可以写出字符串中的数据，更为方便，代码使用演示：

3. 续写和换行：操作类似于FileOutputStream。

小贴士：字符流，只能操作文本文件，不能操作图片，视频等非文本文件。

当我们单纯读或者写文本文件时 使用字符流 其他情况使用字节流

IO异常的处理

JDK7前处理

之前的入门练习，我们一直把异常抛出，而实际开发中并不能这样处理，建议使用 代码块，处理异常部分，代码使用演示：

JDK7的处理(扩展知识点了解内容)

还可以使用JDK7优化后的 语句，该语句确保了每个资源在语句结束时关闭。所谓的资源（resource）是指在程序完成后，必须关闭的对象。

格式：

代码使用演示：

JDK9的改进(扩展知识点了解内容)

JDK9中 的改进，对于引入对象的方式，支持的更加简洁。被引入的对象，同样可以自动关闭，无需手动close，我们来了解一下格式。

改进前格式：

改进后格式：

改进后，代码使用演示：

属性集

5.1 概述

继承于 ，来表示一个持久的属性集。它使用键值结构存储数据，每个键及其对应值都是一个字符串。该类也被许多Java类使用，比如获取系统属性时， 方法就是返回一个对象。

5.2 Properties类

构造方法

• :创建一个空的属性列表。

基本的存储方法

• ： 保存一对属性。
• ：使用此属性列表中指定的键搜索属性值。
• ：所有键的名称的集合。

与流相关的方法

• ： 从字节输入流中读取键值对。

参数中使用了字节输入流，通过流对象，可以关联到某文件上，这样就能够加载文本中的数据了。文本数据格式:

加载代码演示：

小贴士：文本中的数据，必须是键值对形式，可以使用空格、等号、冒号等符号分隔。

缓冲流

昨天学习了基本的一些流，作为IO流的入门，今天我们要见识一些更强大的流。比如能够高效读写的缓冲流，能够转换编码的转换流，能够持久化存储对象的序列化流等等。这些功能更为强大的流，都是在基本的流对象基础之上创建而来的，就像穿上铠甲的武士一样，相当于是对基本流对象的一种增强。

1.1 概述

缓冲流,也叫高效流，是对4个基本的 流的增强，所以也是4个流，按照数据类型分类：

• 字节缓冲流：，
• 字符缓冲流：，

缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。

1.2 字节缓冲流

构造方法

• ：创建一个 新的缓冲输入流。
• ： 创建一个新的缓冲输出流。

构造举例，代码如下：

效率测试

查询API，缓冲流读写方法与基本的流是一致的，我们通过复制大文件（375MB），测试它的效率。

1. 基本流，代码如下：

2. 缓冲流，代码如下：

如何更快呢？

使用数组的方式，代码如下：

1.3 字符缓冲流

构造方法

• ：创建一个 新的缓冲输入流。
• ： 创建一个新的缓冲输出流。

构造举例，代码如下：

特有方法

字符缓冲流的基本方法与普通字符流调用方式一致，不再阐述，我们来看它们具备的特有方法。

• BufferedReader：: 读一行文字。
• BufferedWriter：: 写一行行分隔符,由系统属性定义符号。

方法演示，代码如下：

方法演示，代码如下：

1.4 练习:文本排序

请将文本信息恢复顺序。

案例分析

1. 逐行读取文本信息。
2. 解析文本信息到集合中。
3. 遍历集合，按顺序，写出文本信息。

案例实现

转换流

2.1 字符编码和字符集

字符编码

计算机中储存的信息都是用二进制数表示的，而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制数转换之后的结果。按照某种规则，将字符存储到计算机中，称为编码 。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码 。比如说，按照A规则存储，同样按照A规则解析，那么就能显示正确的文本符号。反之，按照A规则存储，再按照B规则解析，就会导致乱码现象。

编码:字符(能看懂的)–字节(看不懂的)

解码:字节(看不懂的)–>字符(能看懂的)

• 字符编码 : 就是一套自然语言的字符与二进制数之间的对应规则。

  编码表:生活中文字和计算机中二进制的对应规则

字符集

• 字符集 ：也叫编码表。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。

计算机要准确的存储和识别各种字符集符号，需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBK字符集、Unicode字符集等。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HdukzVrG-12)(img/1_charset.jpg)]

可见，当指定了编码，它所对应的字符集自然就指定了，所以编码才是我们最终要关心的。

• 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辅助字符，使用四字节编码。

2.2 编码引出的问题

在IDEA中，使用 读取项目中的文本文件。由于IDEA的设置，都是默认的编码，所以没有任何问题。但是，当读取Windows系统中创建的文本文件时，由于Windows系统的默认是GBK编码，就会出现乱码。

那么如何读取GBK编码的文件呢？

2.3 InputStreamReader类

转换流，是Reader的子类，是从字节流到字符流的桥梁。它读取字节，并使用指定的字符集将其解码为字符。它的字符集可以由名称指定，也可以接受平台的默认字符集。

构造方法

• : 创建一个使用默认字符集的字符流。
• : 创建一个指定字符集的字符流。

构造举例，代码如下：

指定编码读取

2.4 OutputStreamWriter类

转换流 ，是Writer的子类，是从字符流到字节流的桥梁。使用指定的字符集将字符编码为字节。它的字符集可以由名称指定，也可以接受平台的默认字符集。

构造方法

• : 创建一个使用默认字符集的字符流。
• : 创建一个指定字符集的字符流。

构造举例，代码如下：

指定编码写出

转换流理解图解

转换流是字节与字符间的桥梁！[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MF765ORu-14)(img/2_zhuanhuan.jpg)]

2.5 练习：转换文件编码

将GBK编码的文本文件，转换为UTF-8编码的文本文件。

案例分析

1. 指定GBK编码的转换流，读取文本文件。
2. 使用UTF-8编码的转换流，写出文本文件。

案例实现

序列化

3.1 概述

Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该、和等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。

反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。、和信息，都可以用来在内存中创建对象。看图理解序列化：

3.2 ObjectOutputStream类

类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。

构造方法

• ： 创建一个指定OutputStream的ObjectOutputStream。

构造举例，代码如下：

序列化操作

1. 一个对象要想序列化，必须满足两个条件:

• 该类必须实现 接口， 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出 。
• 该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用 关键字修饰。

2.写出对象方法

• : 将指定的对象写出。

3.3 ObjectInputStream类

ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象。

构造方法

• ： 创建一个指定InputStream的ObjectInputStream。

反序列化操作1

如果能找到一个对象的class文件，我们可以进行反序列化操作，调用读取对象的方法：

• : 读取一个对象。

对于JVM可以反序列化对象，它必须是能够找到class文件的类。如果找不到该类的class文件，则抛出一个 异常。

反序列化操作2

另外，当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操作也会失败，抛出一个异常。发生这个异常的原因如下：

• 该类的序列版本号与从流中读取的类描述符的版本号不匹配
• 该类包含未知数据类型
• 该类没有可访问的无参数构造方法

接口给需要序列化的类，提供了一个序列版本号。 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。

3.4 练习：序列化集合

1. 将存有多个自定义对象的集合序列化操作，保存到文件中。
2. 反序列化 ，并遍历集合，打印对象信息。

案例分析

1. 把若干学生对象 ，保存到集合中。
2. 把集合序列化。
3. 反序列化读取时，只需要读取一次，转换为集合类型。
4. 遍历集合，可以打印所有的学生信息

案例实现

打印流

4.1 概述

平时我们在控制台打印输出，是调用方法和方法完成的，这两个方法都来自于类，该类能够方便地打印各种数据类型的值，是一种便捷的输出方式。

4.2 PrintStream类

构造方法

• ： 使用指定的文件名创建一个新的打印流。

构造举例，代码如下：

改变打印流向

就是类型的，只不过它的流向是系统规定的，打印在控制台上。不过，既然是流对象，我们就可以玩一个"小把戏"，改变它的流向。

网络编程入门

1.1软件结构

• C/S结构 ：全称为Client/Server结构，是指客户端和服务器结构。常见程序有ＱＱ、迅雷等软件。

B/S结构 ：全称为Browser/Server结构，是指浏览器和服务器结构。常见浏览器有谷歌、火狐等。

两种架构各有优势，但是无论哪种架构，都离不开网络的支持。网络编程，就是在一定的协议下，实现两台计算机的通信的程序。

1.2 网络通信协议

• 网络通信协议：通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则，这就好比在道路中行驶的汽车一定要遵守交通规则一样。在计算机网络中，这些连接和通信的规则被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守才能完成数据交换。
• TCP/IP协议： 传输控制协议/因特网互联协议( Transmission Control Protocol/Internet Protocol)，是Internet最基本、最广泛的协议。它定义了计算机如何连入因特网，以及数据如何在它们之间传输的标准。它的内部包含一系列的用于处理数据通信的协议，并采用了4层的分层模型，每一层都呼叫它的下一层所提供的协议来完成自己的需求。

上图中，TCP/IP协议中的四层分别是应用层、传输层、网络层和链路层，每层分别负责不同的通信功能。
链路层：链路层是用于定义物理传输通道，通常是对某些网络连接设备的驱动协议，例如针对光纤、网线提供的驱动。
网络层：网络层是整个TCP/IP协议的核心，它主要用于将传输的数据进行分组，将分组数据发送到目标计算机或者网络。
运输层：主要使网络程序进行通信，在进行网络通信时，可以采用TCP协议，也可以采用UDP协议。
应用层：主要负责应用程序的协议，例如HTTP协议、FTP协议等。

1.3 协议分类

通信的协议还是比较复杂的， 包中包含的类和接口，它们提供低层次的通信细节。我们可以直接使用这些类和接口，来专注于网络程序开发，而不用考虑通信的细节。

包中提供了两种常见的网络协议的支持：

• UDP：用户数据报协议(User Datagram Protocol)。UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。

  由于使用UDP协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输例如视频会议都使用UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。

  但是在使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议。UDP的交换过程如下图所示。

特点:数据被限制在64kb以内，超出这个范围就不能发送了。

数据报(Datagram):网络传输的基本单位

• TCP：传输控制协议 (Transmission Control Protocol)。TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。

  在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过“三次握手”。

  • 三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。
    • 第一次握手，客户端向服务器端发出连接请求，等待服务器确认。
    • 第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求。
    • 第三次握手，客户端再次向服务器端发送确认信息，确认连接。整个交互过程如下图所示。

​ 完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性，TCP协议可以保证传输数据的安全，所以应用十分广泛，例如下载文件、浏览网页等。

1.4 网络编程三要素

协议

• 协议：计算机网络通信必须遵守的规则，已经介绍过了，不再赘述。

IP地址

• IP地址：指互联网协议地址（Internet Protocol Address），俗称IP。IP地址用来给一个网络中的计算机设备做唯一的编号。假如我们把“个人电脑”比作“一台电话”的话，那么“IP地址”就相当于“电话号码”。

IP地址分类

• IPv4：是一个32位的二进制数，通常被分为4个字节，表示成 的形式，例如 。其中a、b、c、d都是0~255之间的十进制整数，那么最多可以表示42亿个。
• IPv6：由于互联网的蓬勃发展，IP地址的需求量愈来愈大，但是网络地址资源有限，使得IP的分配越发紧张。

  为了扩大地址空间，拟通过IPv6重新定义地址空间，采用128位地址长度，每16个字节一组，分成8组十六进制数，表示成，号称可以为全世界的每一粒沙子编上一个网址，这样就解决了网络地址资源数量不够的问题。

常用命令

• 查看本机IP地址，在控制台输入：

• 检查网络是否连通，在控制台输入：

特殊的IP地址

• 本机IP地址：、 。

端口号

网络的通信，本质上是两个进程（应用程序）的通信。每台计算机都有很多的进程，那么在网络通信时，如何区分这些进程呢？

如果说IP地址可以唯一标识网络中的设备，那么端口号就可以唯一标识设备中的进程（应用程序）了。

• 端口号：用两个字节表示的整数，它的取值范围是0_{65535。其中，0}1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败。

利用++ 三元组合，就可以标识网络中的进程了，那么进程间的通信就可以利用这个标识与其它进程进行交互。

TCP通信程序

2.1 概述

TCP通信能实现两台计算机之间的数据交互，通信的两端，要严格区分为客户端（Client）与服务端（Server）。

两端通信时步骤：

1. 服务端程序，需要事先启动，等待客户端的连接。
2. 客户端主动连接服务器端，连接成功才能通信。服务端不可以主动连接客户端。

在Java中，提供了两个类用于实现TCP通信程序：

1. 客户端： 类表示。创建对象，向服务端发出连接请求，服务端响应请求，两者建立连接开始通信。
2. 服务端： 类表示。创建对象，相当于开启一个服务，并等待客户端的连接。

2.2 Socket类

类：该类实现客户端套接字，套接字指的是两台设备之间通讯的端点。

构造方法

• :创建套接字对象并将其连接到指定主机上的指定端口号。如果指定的host是null ，则相当于指定地址为回送地址。

  小贴士：回送地址(127.x.x.x) 是本机回送地址（Loopback Address），主要用于网络软件测试以及本地机进程间通信，无论什么程序，一旦使用回送地址发送数据，立即返回，不进行任何网络传输。

构造举例，代码如下：

成员方法

• ： 返回此套接字的输入流。
  • 如果此Scoket具有相关联的通道，则生成的InputStream 的所有操作也关联该通道。
  • 关闭生成的InputStream也将关闭相关的Socket。
• ： 返回此套接字的输出流。
  • 如果此Scoket具有相关联的通道，则生成的OutputStream 的所有操作也关联该通道。
  • 关闭生成的OutputStream也将关闭相关的Socket。
• ：关闭此套接字。
  • 一旦一个socket被关闭，它不可再使用。
  • 关闭此socket也将关闭相关的InputStream和OutputStream 。
• ： 禁用此套接字的输出流。
  • 任何先前写出的数据将被发送，随后终止输出流。

  2.3 ServerSocket类

类：这个类实现了服务器套接字，该对象等待通过网络的请求。

构造方法

• ：使用该构造方法在创建ServerSocket对象时，就可以将其绑定到一个指定的端口号上，参数port就是端口号。

构造举例，代码如下：

成员方法

• ：侦听并接受连接，返回一个新的Socket对象，用于和客户端实现通信。该方法会一直阻塞直到建立连接。

2.4 简单的TCP网络程序

TCP通信分析图解

1. 【服务端】启动,创建ServerSocket对象，等待连接。
2. 【客户端】启动,创建Socket对象，请求连接。
3. 【服务端】接收连接,调用accept方法，并返回一个Socket对象。
4. 【客户端】Socket对象，获取OutputStream，向服务端写出数据。
5. 【服务端】Scoket对象，获取InputStream，读取客户端发送的数据。

到此，客户端向服务端发送数据成功。

自此，服务端向客户端回写数据。

6. 【服务端】Socket对象，获取OutputStream，向客户端回写数据。
7. 【客户端】Scoket对象，获取InputStream，解析回写数据。
8. 【客户端】释放资源，断开连接。

客户端向服务器发送数据

服务端实现：

客户端实现：

服务器向客户端回写数据

服务端实现：

客户端实现：

综合案例

3.1 文件上传案例

文件上传分析图解

1. 【客户端】输入流，从硬盘读取文件数据到程序中。
2. 【客户端】输出流，写出文件数据到服务端。
3. 【服务端】输入流，读取文件数据到服务端程序。
4. 【服务端】输出流，写出文件数据到服务器硬盘中。

基本实现

服务端实现：

客户端实现：

文件上传优化分析

1. 文件名称写死的问题

   服务端，保存文件的名称如果写死，那么最终导致服务器硬盘，只会保留一个文件，建议使用系统时间优化，保证文件名称唯一，代码如下：

2. 循环接收的问题

   服务端，指保存一个文件就关闭了，之后的用户无法再上传，这是不符合实际的，使用循环改进，可以不断的接收不同用户的文件，代码如下：

3. 效率问题

   服务端，在接收大文件时，可能耗费几秒钟的时间，此时不能接收其他用户上传，所以，使用多线程技术优化，代码如下：

优化实现

信息回写分析图解

前四步与基本文件上传一致.

5. 【服务端】获取输出流，回写数据。
6. 【客户端】获取输入流，解析回写数据。

回写实现

客户端实现：

3.2 模拟BS服务器(扩展知识点)

模拟网站服务器，使用浏览器访问自己编写的服务端程序，查看网页效果。

案例分析

1. 准备页面数据，web文件夹。

   复制到我们Module中，比如复制到day08中

   

2. 我们模拟服务器端，ServerSocket类监听端口，使用浏览器访问

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XQGK98ge-11)(img无法访问.jpg)]

3. 服务器程序中字节输入流可以读取到浏览器发来的请求信息

GET/web/index.html HTTP/1.1是浏览器的请求消息。/web/index.html为浏览器想要请求的服务器端的资源,使用字符串切割方式获取到请求的资源。

案例实现

服务端实现：

访问效果

• 火狐

小贴士：不同的浏览器，内核不一样，解析效果有可能不一样。

发现浏览器中出现很多的叉子,说明浏览器没有读取到图片信息导致。

浏览器工作原理是遇到图片会开启一个线程进行单独的访问,因此在服务器端加入线程技术。

访问效果：

函数式接口

函数式编程

常用函数式接口

获取资料

版权声明：

本文来源网络，所有图片文章版权属于原作者，如有侵权，联系删除。

本文网址：https://www.bianchenghao6.com/h6javajc/1780.html