四库全书总目(经部共3册)/蛾术丛书 pdf mobi txt 2024 电子版 下载

《四库全书》是清·乾隆年间纂修的一部丛书，收书三千四百余种。为了纂修四库全书，当时在北京设立了一个专门机构，称为“四库全书馆”。在纂修《四库全书》的过程中，馆臣每校定一部书，即写一篇提要，“将各书大旨及著作源流，详细考证，铨疏厓略”，这些提要汇集起来，加上存目提要，按照经、史、子、集四部类次，由纪昀加以整齐划一，进呈乾隆皇帝御览后，就成为《四库全书总目》。《四库全书总目》成书后得到广泛的流传。《四库全书总目》，都是由皇六子永瑢领衔纂修的，但据江藩《国朝汉学师承记》所言，实际工作是由纪昀完成的。本书为经部3册，由蛾术丛书编委会整理完成，以浙江杭州刻本为底本。繁体竖排，使用全式标点。

卷首一

圣谕

卷首二

进表

职名

卷首三

凡例

卷一

经部总叙

经部一

易类一

卷二

经部二

易类二

卷三

经部三

易类享

卷四

经部四

易类四

卷五

卷六

卷七

卷八

卷九

卷十

卷十一

卷十二

卷十三

卷十四

卷十五

卷十六

卷十七

卷十八

卷十九

卷二十

卷二十一

卷二十二

卷二十三

卷二十四

卷二十五

卷二十六

卷二十七

卷二十八

卷二十九

卷三十

卷三十一

卷三十二

卷三十三

卷三十四

暂无相关内容，正在全力查找中

暂无出版社相关信息，正在全力查找中！

暂无相关书籍摘录，正在全力查找中！

在线阅读地址：四库全书总目(经部共3册)/蛾术丛书在线阅读

在线听书地址：四库全书总目(经部共3册)/蛾术丛书在线收听

在线购买地址：四库全书总目(经部共3册)/蛾术丛书在线购买

暂无原文赏析，正在全力查找中！

书籍介绍

整理本，繁体竖排，全式标点。

• 作者：启玄子 发布时间：2020-12-29 18:23:04

  作业读

• 作者：宋冰倚 发布时间：2019-07-15 11:12:33

  精美

• 作者：逸轩博雅 发布时间：2020-10-21 16:37:27

  用了四个月的晚间读完。这本是目前见过最适宜用来阅读的四库总目（台湾艺文出版社的似乎也还好，国家图书馆出版社影印的60册本也好，但这两部都是影印无标点），其他的不是部头太大 就是影印字太小，适合查阅，不适合阅读。魏小虎的《汇订》吸收最新成果，可备查阅。

• 作者：田季琰 发布时间：2023-06-06 00:43:30

  很适合读，可惜没有集部

• 作者：seasonj 发布时间：2014-08-29 10:28:52

  后面对于积累的建议还是相当不错滴

• 作者：第五元先 发布时间：2024-03-05 16:10:50

  拼版影印的字实在太费眼睛了，这个正常点，不那么反人类

• 一个教你1分钟读60页书的方法

  作者：锦溪读书 发布时间：2017-12-06 00:01:49

  看到这个题目，你是不是觉得我疯了：“吹牛皮也要先打草稿吧？1分钟读60页书，那绝对是骗人的！”

  恭喜你，第一反应跟我一样，我当时看到这本书的介绍的时候，也是怀着这样极度怀疑的心情，忐忑翻开这本书的啊。翻书的时候，还担心是什么“邪教”之类的，万一给我洗脑了怎么办？

  不过冲着要提高阅读速度和阅读效率，我还是小心翼翼地翻开了这本《高倍速阅读法》的目录，总得先看看它“邪门”在哪里才好做出评价。

  翻开目录首页，咦，是一本正经的书，翻开目录第二页，嗯，原来是一本教人如何用“影像阅读·全脑思维系统”方法去摆脱传统的一字一句的默读方式，以1秒阅读1页的速度迅速看完一本书的“神奇”的方法。

  作者保罗·R·席列，当然也就是影像阅读·全脑思维系统的创始者，以自身和他众多学员的实践，来告诉每个人，只要我们认真学习其中的方法，每个人都有可能做到1秒读1页。保罗·席列不但是这个方法的创始人，还是美国明尼苏达大学理工学院生物学学士，美国圣托马斯大学研究生院人文学院的人类发展硕士。据他在书中说，正是用了自己发明的阅读方法，他在研究生学习中不但轻松拿A，论文100分，还在课余时间一天读好几本书。

  太燃了，单是想到一天可以读好几本就让人兴奋啊。我之前可是好几天才能看完一本书，并且看完后感觉什么都没学到！典型的浪费时间白读书，还得了颈椎病！真是祸不单行。

  看保罗·席列的神奇阅读法之前，我们先来看看为什么我们的阅读效率如此低下。

  奥野宣之的《如何有效阅读一本书》、尼基·斯坦顿的《沟通圣经》、保罗·席列的《高倍速阅读法》、原尻淳一的《高效能阅读》这类由阅读达人写出的高效阅读法中不约而同提到“默读、从头读到尾、音读、一个字一个字看”这些传统的阅读法都是阻碍我们快速阅读的致命方法。

  “默读、音读、一个字一个字看”这些其实属于一个阅读类型，都是你我平常都在用的逐字逐句法，而“从头读到尾”就是小学时候，老师要求的“不能落下任何一个重点”的心理影响，导致在我们长大后，拿到一本书，一本杂志，一篇文章，都要认认真真从第一个字到最后一个字读完才安心。

  事实呢？真是如此吗？保罗·席列在《高倍速阅读法》告诉我们：NO，这样的读法不但耗时，并且在你合上书那一刻，你会发现你连书的主要内容都说不出来。

  这不就是在说我吗？师太的书，我几乎全看遍了，可是《玫瑰的故事》我现在只记得女主叫玫瑰，《我的前半生》里罗子君被离婚了，《香雪海》里面的香雪海是个特立独行的人，《喜宝》讲了个要有爱又要钱的故事，《开到荼靡》、《圆舞》、《人淡如菊》、《烈火》、《我们不是天使》、《迷迭香》、《镜子》这些都说了啥来着？这些朗朗上口的小说尚没掌握，更不用说《红楼梦》之类的大部头了。

  哎，说多了都是泪。那么保罗·席列的《高倍速阅读法》中的影像阅读·全脑四位系统究竟怎么做到1分钟读60页的？其实不是邪门歪道，也不需要哈利波特般的神奇魔法，按照他说的方法去练习、实践即可就有希望啦。

  1.阅读前，先做好准备

  准备阶段包括明确阅读目的和进入集中精神状态。

  每个人的时间都是宝贵的，生命都是有限的，所以还是带着目的去做一件事吧。即使你的读书是为了消遣，你在消遣的过程获得快乐和新的认知，按照目的论来说，也是目的，只是你不自知而已。我很认同作者在书中的一句话：强烈的目的意识能够让你做成很多事。

  设立目标的时候，可以问问自己“读完这本书后，你期待最后有什么样的成效？”、“这本书究竟对自己有多么重要？”、“这本书需要理解到什么程度？”、“打算花多少时间来达成目标？”然后在打开目录的时候，确定这本书是不是你想要花时间去读的。

  这跟我们人生规划同理，一开始知道自己要怎么走，走向哪里，然后再朝着这个方向去努力，总比那些走到一半的人才发现自己的方向错了，然后重新开始的人要快得多到达目的地。

  开始阅读时，相信大多数人都会有这样的困扰，眼睛在书中扫，大脑在天马行空思绪乱飞，或者是一会上个厕所，一会喝口水，一会吃零食，一会翻一下手机，一会被窗外的声音打断思路……总之，你觉得你天生不适合看书，因为根本看不进去！

  而事实却是因为你没集中精神。书中作者介绍的集中精神的方法叫橘子法。就是安静下来后，把手掌伸出来摊开，想象上面有个橘子，你盯着它30秒，放松身体，调整呼吸，然后进入状态。

  我是个只要一看书脑袋思绪乱飞的那种人，除了作者的橘子法，我最常用的是闭眼睛深呼吸1分钟，或者安静抄书5分钟（抄什么都行），心安静下来后，也就慢慢进入状态了。

  2.做好预习工作，掌握整体结构

  读书的时候，老师都会苦口婆心劝我们：“同学们，回去预习第xx课，明日评讲，不然你明日不知道我在说什么。”那时我们当然不当一回事，结果每节课都是干瞪着眼睛听天书。读书时代的预习在于我们熟悉章节脉络，提出问题。现在讲的预习则是让我们在读一本书之前，通过浏览目录，了解书本大概情况，然后根据自己的阅读目标确定是否进行阅读。

  3.影像翻阅，1秒钟1页

  重头戏终于到了。先别高兴，因为真的很难做得到。可是不要灰心，作者建议，等你学知道这个方法后，请每时每刻都用这个方法去阅读，如此反复练3个月，你的阅读速度就突飞猛进了又或者，一点进步都没有。

  为啥啊？因为保罗·席列的影像阅读法“旨在灵活运用大脑与生俱来的、潜意识层面的信息处理能力”，要“摆脱传统观念的束缚，相信大脑蕴藏着无限的潜力”，“不要追求完美，不要过于努力”才做有可能提高速度。

  跟读书时候情况一样，相同的老师，不同的学生成绩。

  好了，我们开始练习吧。首先在做好了以上2点准备后，我们再来进行阅读前的自我肯定。例如“我的精神已经集中”，“我能从书中获取我需要的信息”，“翻完书我能了解书本大致内容”……积极的心态才会产生积极的效果。

  其次，进入影像阅读。像我们平时拍照那样，把一整页看进眼里，不要定焦在某个字，或者某一行，尽量看到书的四个空白角。

  就像我们画画那样，“如果要画大拇指，就去画大拇指周边的空间”，利用拓宽视野的方法，防止眼睛只盯着一个点看的狭隘。我们看书只聚焦在某一点其实跟我们想在抽屉找东西是一样的，明明要找的东西就在桌面，可是因为我们只盯着抽屉看，所以对桌面的东西自然视而不见。

  做不到一眼一整页是吧？不要紧，不要否定，不要怀疑，不要心存杂念，继续保持这个一眼一页的方法和速度把书翻下去就可以了。

  4.影像翻阅完毕，立刻复习

  完成第3步，合上书，你觉得自己什么都没学到吗？伍迪·艾伦曾经有个玩笑：“我刚刚读完了《战争与和平》，讲的是关于俄国的故事。”是的，在影像翻阅法过程，主观层面可以说没有吸收到任何信息，但是它就是绕过主观意识，在大脑的潜意识中收集信息的过程。事实上，我们的潜意识已经收集到了信息，只是你不知道。

  要想激活它，让它变成主管层面的就要进行复习。复习步骤为：调查，找触发词，提问。

  调查是指浏览书的题目、目录、黑体字，再次让文章结构清晰起来。还要去看介绍报道、摘要、他人评论，以帮助自己理解主要内容。

  触发词是指书中反复出现的，可以帮你理解内容的词语。根据直觉找，不要在浏览的过程停顿。

  提问。有问题的学生往往知道自己不懂的在哪里，带着多个“为什么”去翻书，便于自己在寻找答案的过程更加集中精神。

  要提醒的是，复习全过程，我们依然不能停下来细读。

  所以在完成第3步后，隔5到20分钟，就马上进行复习吧。没时间的话，可以隔天再复习。如果时间隔得太久，那就先重复第3步，接着进行第4步。

  5.知识要有意识去激活

  在前面所有步骤做完后，我们得到了自己想要的信息，激活是从中挑选一些必要的信息，进行深阅读，从“有点印象”上升到“熟悉理解”，再到“掌握”的程度。

  在完成第4步复习之后，我们最好休息10-20分钟，如果时间允许，最好过一晚。等大脑充分生养休息好，再进行激活。

  激活第一步，重新审视在复习中提出的问题，然后去找答案。

  找答案过程，用到的方法是超读+摘读和跳读，然后绘制思维导图。

  要深入理解文章内容，最好的方法是反复加深理解。超读时，分章节进行，从文章第一行到最后一行，快速滑动视线，俗称一目十行，在引起你注意的地方停下来摘读，理解后再以超读方式继续进行。不用担心错过精彩，罗素·斯托夫在他的《视阅读为思考的过程的教学》中列出的统计数据是：一篇文章的重点，大概只占整体的4%-11%。

  是的，你看到的大多数是废话，包括为了例证论点而存在的“废话”。

  跳读适用于逻辑思维较强的人，对阅读教科书材料特别有效。跳读也是迅速浏览文章，跟一目十行差不多，但是要求在阅读过程中抓首尾句，和与主题相关的词语，把相关词语连接起来组成主要内容。

  读完后，用简洁的关键词把主要内容制成思维导图。传统的笔记法帮助我们记住细节，但是思维导图可以帮助我们掌握整体架构，在以后想要回忆书本内容的时候，一看到这个思维导图就能想起主要内容。

  到此，“1分钟读60页书的方法”结束，我们还要来一次自我肯定，表扬自己在三个小时内读完了一本200页的书，并且写出了读书笔记。

  颠覆传统的方法如果学得会，那将受益无穷。它可以应用到我们生活的任何方面。考试、读书、考证、工作报告、学术论文……任何方面都可以帮助我们快速理解文章主要内容，像作者保罗·席列那样，用影像阅读法在研究生考试轻松拿A，论文100分！

  我用影像阅读法练习了半个月，虽然还是没有做到作者说的1分钟读60页，但是在这个阅读过程中，我改掉了一字一句的默读，学会了其它步骤的方法。

  在练习过程，我发现我跳读的效率更高。方法有千千万万种，对别人来说最好的未必适合自己。我们要学会在众多方法中找到合适自己那个。

  只有合适自己的，才是最好的。

• 我的全部读书笔记+思想

  作者：黑鸟 发布时间：2017-05-25 10:15:47

  Java 8的新特性可以帮助你：

  1.使用Java 8可以减少冗长的代码，让代码更易于理解

  2.通过方法引用和Stream API，代码会更加直观

  使用 Java 8 重构现在代码 ：

  1.使用 Lambda 表达式取代匿名类

  2.使用方法引用重构 Lambda 表达式

  3.使用 Stream API 重构指令式的数据处理

  Java 8 新特性总结：

    ● Lambda 表达式

    ● 行为化参数（Lambda 以及方法引用）

    ● Stream API (流) 高效率的集合操作

    ● CompletableFuture 优化并发接口

    ● Optional<T> 解决null指针异常

    ● Default 接口默认方法

    ● LocalDate 等..新的时间类

  ⭐️书本最末的一些总结

  命令式编程（编写代码，设计实现过程，处理不同的情况（异常，NULL，循环），获取结果）

  函数式编程（通过代码告诉程序，我想要什么，然后拿到结果）

  ⭐️ Java 8 的大方向和主要功能对现有代码的影响

  方法引用就是让你根据已有的方法实现来创建Lambda表达式，当你需要使用方法引用时，目标引用放在分隔符 ::前，方法的名称放在后面，例如Apple :: getWeight就是引用了Apple类中定义的方法 getWeight，请记住，不需要括号，因为你没有实际调用这个方法，方法引用就是Lambda表达式 (Apple apple) -> apple.getWeight() 的快捷写法

  ⭐️对于Lambda表达式参数，尽量使用方法引用的写法（官方推荐）

  //Lambda 写法

  Function<String, Integer> stringToInteger = (String s) -> Integer.parseInt(s);

  BiPredicate<List<String>, String> contains = (list, element) -> list.contains(element);

  // --> 方法引用

  Function<String, Integer> stringToInteger2 = Integer::parseInt;

  BiPredicate<List<String>, String> contains2 = List::contains;

  ⭐️ Lambda 表达式等效的方法引用写法栗子（练习题）

  lambda编程就是方法参数化：让方法接受多种行为作为参数，并在内部使用，来完成不同的行为

  ⭐️lambda的核心思想

  3.10小结：

  lambda表达式可以理解为一种匿名函数

  lambda表达式可以让你简洁地传递代码

  函数式接口，就是声明了一个抽象方法的接口

  只有在接受函数式接口的地方才可以使用 lambda 表达式

  java8自带常用函数式接口：java.util.function包，包括Predicate<T>，Function<T,R>...等

  为了避免装箱操作，Predicate<T>和Function<T,R> 等通用函数式接口的原始类型

  ⭐️Lambda表达式，就是针对面向函数式接口方法作为参数的时候将方法体作为参数输入

  StreamAPI 允许以声明性方式处理数据集合，可以把它看成遍历数据集的高级迭代器。

  此外流还可以透明睇并行处理，无需写任何多线程代码：

  声明性---更简洁、更易读，可复合---更灵活，可并行--性能更好

  流的使用一般包括三件事：

  1、数据源（如集合）来执行

  2、中间操作链，形成一条流的流水线

  3、一个终端操作、执行流水线、并能生成结果

  ⭐️StreamAPI的基本用户、基本概念

  集合讲的是数据，Stream流讲的是计算

  Stream 所有操作都会返回另一个流，这样他们就形成一条流水线，最后通过collect，返回list结束

  stream api 常用方法

  anyMatch 接受 lambda，返回布尔值，用于判断集合

  filter -- 接受lambda，从流中排除某些元素

  map -- 接受lambda，讲元素转换为其他形式或提取信息

  sorted -- 接受Comparator 函数接口

  limit -- 接受Int，截断流，限制返回条数

  distinct -- 不显示重复

  collect -- 将流转换为其他形式，通过 toList() 转为 list

  //集合是生产生，流是消费者，流只能消费一次

  ⭐️筛选集合、数组的好工具

  stream库可以自动选择一种适合你硬件的数据表示和并行实现

  而集合的迭代需要自己管理所有问题，还有和synchronized的艰苦斗争

  ⭐️stream迭代可以最大化利用硬件，集合就有点过时

  连接stream流的操作称为中间操作，关闭流的操作称为终端操作（中间操作一般都可以合并起来，在终端操作时一次性全部处理）

  ⭐️stream自行选择最优的方法执行并行操作

  Stream API通过allMatch、 anyMatch、 noneMatch、findFirst和findAny方法提供这样的工具

  ⭐️stream api对于数据的查找和匹配提供的一套API工具，和filter函数不一样，以上API工具都是提供boolean返回值用于判断，filter用于过滤集合

  java.util.optional是一个容器类，用于表示一个值存在或不存在，用户避免和null相关的Bug

  isPresent() 将在Optional包含值得时候返回true，否则返回false

  ifPresent(Consumer<T> block) 会在值存在的时候执行给定的代码块

  get() 会在值存在的时返回值，否则抛出一个NoSuchElement异常

  orElse(T other) 会在值存在的时返回值，否则返回一个默认值

  ⭐️新的容器类和一些新的调用方法

  用Stream流8道题解答方法：

  //交易员

  Trader raoul = new Trader("Raoul", "Cambridge");

  Trader mario = new Trader("Mario","Milan");

  Trader alan = new Trader("Alan","Cambridge");

  Trader brian = new Trader("Brian","Cambridge");

  //交易

  List<Transaction> transactions = Arrays.asList(

          new Transaction(brian, 2011, 300),

          new Transaction(raoul, 2012, 1000),

          new Transaction(raoul, 2011, 400),

          new Transaction(mario, 2012, 710),

          new Transaction(mario, 2012, 700),

          new Transaction(alan, 2012, 950)

  );

  //1.找出2011年发生的所有交易，并按交易额排序

  transactions.stream().filter(t -> t.getYear() == 2011).sorted(Comparator.comparing(Transaction::getValue)).forEach(System.out::println);

  //2.交易员都在哪些不同的城市工作过？distinct不显示重复数据

  transactions.stream().map(t -> t.getTrader().getName() + ":" + t.getTrader().getCity()).distinct().forEach(System.out::println);

  //3.查找所有来自剑桥的交易员，并且按照姓名排序

  transactions.stream().filter(t -> t.getTrader().getCity().equals("Cambridge")).sorted((o1, o2) -> o1.getTrader().getName().compareTo(o2.getTrader().getName())).map(t -> t.getTrader().getName() + "=" + t.getTrader().getCity()).distinct().forEach(System.out::println);

  //返回所有交易员的姓名字符创，按照字母排序

  String nameString = transactions.stream() .map(t -> t.getTrader().getName()).distinct().sorted().reduce("", (n1, n2) -> n1 + n2);

  //有没有交易员是在Milan工作的 ?

  // 查找 // 判断

  // transactions.stream().filter(t -> t.getTrader().getCity().equals("Milan")).map(t -> t.getTrader().getName()).distinct().forEach(System.out::println);

  boolean isMilan = transactions.stream().anyMatch(t -> t.getTrader().getCity().equals("Milan"));

  //打印在剑桥的交易员的所有交易额

  transactions.stream().filter(t -> t.getTrader().getCity().equals("Cambridge")).map(t -> t.getValue()).forEach(System.out::println);

  //所有交易中，交易额最高的是多少

  transactions.stream().map(t -> t.getValue()).reduce(0, Integer::max);

  transactions.stream().mapToInt(Transaction::getValue).max();

  //所有交易中，交易额最小的是多少

  transactions.stream().reduce((t1, t2) -> t1.getValue() < t2.getValue() ? t1 : t2); //通过反复比较，找出最小的交易

  transactions.stream().min(Comparator.comparing(Transaction::getValue));

  transactions.stream().mapToInt(Transaction::getValue).min();

  ⭐️使用stream流来操作集合真是得心应手，想要什么都能找到

  Stream流的创建不单针对集合，还可以从值序列，数组，文件来创建流，例如：

  //由字符串创建流，转为大写循环输出

  Stream<String> stream = Stream.of("java8","lambdas","a","in","action");

  stream.map(String::toUpperCase).forEach(System.out::println);

  //由数组创建流，统计数组合计

  int[] streamArray = {2,5,7,11,22,33};

  Arrays.stream(streamArray).sum();

  ⭐️stream api 可能改变所有java程序的写法

  Streams API可以表达复杂的数据处理查询。常用的流操作总结在表5-1中

  可以使用filter、distinct、skip和limit对流做筛选和切片

  可以使用map和flatMap提取或转换流中的元素

  可以使用findFirst和findAny方法查找流中的元素，你可以用allMatch、noneMatch和anyMatch方法让流匹配给定的谓词

  这些方法都利用了短路:找到结果就立即停止计算;没有必要处理整个流

  你可以利用reduce方法将流中所有的元素迭代合并成一个结果，例如求和或查找最大元素

  流不仅可以从集合创建，也可从值、数组、文件以及iterate与generate等特定方法创建

  ⭐️第二章节 Stream流的总结，大概了解，还需要时间去练习和消化其中内容，熟悉Stream流对Java编码方式都会有很大的改变，感觉Java8的函数式编程已经完全颠覆的以前的编码方式

  函数式编程相对于指令式编程（Java 7前）的一个主要优势：你只需要指出希望的结果“做什么”，而不用操心执行的步骤，“如何做”，例如针对的集合，根据对象某个属性讲集合分组，函数编程代码如下：

  Transaction是交易对象，根据Currency货币针对所有交易进行分组 （开发中很常见）：

  Map<Currency, List<Transaction>> mapCurrency = list.stream().collect(groupingBy(Transaction :: getCurrency))

  还可以自定义逻辑，把逻辑作为Lambda参数，进行分组

  public enum CaloricLevel { DIET, NORMAL, FAT }

  Map<CaloricLevel, List<Dish>> dishesByCaloricLevel = menu.stream().collect( groupingBy(dish -> {

                 if (dish.getCalories() <= 400) return CaloricLevel.DIET;

                 else if (dish.getCalories() <= 700) return

      CaloricLevel.NORMAL;

          else return CaloricLevel.FAT;

  } ));

  要实现多级分组，可以使用双参数版本Collectors.groupingBy工厂方法创建收集器

  ⭐️如果不是应用比较广，自身对Java语言一直不是很有兴趣，因为语言太繁琐，很简单的功能要写很多的代码，函数式编程，让我开始对Java有些兴趣了，SQL也是函数式编程，终于开始觉得Java有点酷了

  分区是分组的特殊情况，有一个布尔值作为分类函数，意味着分组Map的主键为Boolean，于是也最多可以分为2组，true是一组，false是一组

  ⭐️分区有点像分组的简化，对于逻辑不是很复杂的分组，可以用分区

  stream可以通过对收集源调用prarllelStream方法来把集合转换为并行流，并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流，这样一来，你就可以自动把给定操作的工作负荷分配给多核处理器的所有内核，让他们都忙起来

  ⭐️stream 自带多线程处理方法，并且根据硬件自动优化，不需要自己实现复杂的多线程，对于CPU核心越来越多的现在，相比以前Java的单核处理效率有很大的提高

  把顺序流转成并行流，从而让前面的函数归约过程（也就是求和）并行运行，对顺序流调用parallel()方法

  并行编程很复杂，有时候甚至有点违反直觉，如果用的不对（比如采用了一个不易并行化的操作，如iterate），它甚至可能让程序的整体性能更差，所以在调用看似神器的 parallel 操作时，了解背后发生

  （使用正确的数据结构然后使其并行工作能够保证最佳的性能）

  ⭐️顺序流转并行流就是调用 parallel() 方法，多线程方法也不能乱用，使用不当会影响性能

  建议将所有迭代器数据处理模式处理集合的代码都转换为Stream API的方法，因为Stream API能更清晰地表达数据处理管道的意图，通过短路和延迟载入以及利用现代计算机的多核架构，我们可以对Stream进行优化

  ⭐️重构现有代码的建议

  使用 default （默认方法）重新定义接口 ===================》

  Java 8中接口方法可以包含实现类，类可以从多个接口中继承它们的默认方法（默认方法包含实现），充分利用这些功能为我们服务，保持接口的精致性和正交性，能帮助我们在现有的代码基础上最大程序的实现代码复用和行为模式

  ⭐️灵活利用 Java 8 接口的默认方法，可以实现多继承，最大程序的复用代码

  如果一个类使用相同的函数签名从多个地方（比如另一个类或接口）继承了方法，通过三条规则可以进行判断

  1.类中的方法优先级最高，类或父类中声明的方法的优先级高于任何声明为默认方法的优先级

  2.如果无法依据第一条进行判断，那么子接口的优先级更高，函数签名相同时，优先选择拥有最具体实现的默认方法的接口，即如果B继承了A，那么B就比A更加具体

  3.最后如果还是无法判断，继承了多个接口的类必须通过显示覆盖的调用期望的方法

  ⭐️虽然这种冲突可能极少的发生，但是一单发生这样的状况，必须要有一套规则来确定

  使用 optional 取代 null ===================》

  null 带来的种种问题：

  1.它是错误之源 -- NullPoninterException 是目前Java程序开发中最典型的异常

  2.它使你的代码彭章 -- 它让你的代码充斥着深度嵌套的null检查，代码可读性糟糕透顶

  3.它自身毫无意义 -- null自身没有任何语义，尤其是，它代表的是静态类型语言中以一种错误的方式对缺失变量值的建模

  4.它破坏Java哲学 -- Java 一直试图避免让程序员意识到指针的存在，唯一的例外是：null指针

  5.导致大量问题 -- null并不属于任何类型，这意味着它可以被复制给人以引用类型的变量

  ⭐️万恶之源 ----- null

  通过类型系统让你的域模型中隐藏的知识显式地体现在你的代码中，换句话说，你永远不应该忘记语言的首要功能就是沟通，即使对程序设计语言而言也没什么不同声明方法接受一个 optional 参数，或者将结果作为 optional 类型返回，让你的同事或者未来你方法的使用者，很清楚的知道它是可以接受空值，或者可能返回一个空值

  ⭐️ opational 如果只是声明空值，设置默认值，那么出现空值该如何处理？？

  使用Optional从文件中读取属性：

  ⭐️

      public int readDuration(Properties properties, String name){

  // 1.0 不用Optional 封装类的写法

  // String value = properties.getProperty(name);

  // if(value != null){

  // try{

  // int i = Integer.parseInt(value);

  // if(i > 0){

  // return i;

  // }

  // }catch (NumberFormatException e){

  //

  // }

  // return 0;

  // }

          // optional 封装类

          return Optional

                  .ofNullable(properties.getProperty(name)) //获取 property 然后将结果封装到 optional , optional 使用ofNullable创建

                  .flatMap(OptionalUtility :: stringToInt) //Lambda 将 string 转为 Integer ，

                  .filter(i -> i > 0) //过滤 value > 0

                  .orElse(0); //如果为null， 就返回0

      }

  Java 8 之前的Date和Calendar类的缺陷和糟糕的设计，导致用户转投第三方时间库，比如joda-time，所以在Java 8提供了高质量的时间和日期支持，在java.time包中整合了很多 Joda-time 的特性，常用的包邮LocalDate、LocalTime、Instant、Duration、Period

  ⭐️ 改进历史问题

  LocalDate类是一个不可变对象，它只提供简单的日子，并不包含当天的时间信息，也不附带任何和时区相关的信息。

  ⭐️Java 8 中简单的日期类

  LocalTime用来表示当天时间的对象，并不包含日期信息，也不附带任何和时区相关的信息

  ⭐️Java 8 中简单的时间类

  LocalDateTime 合并时间和日期，它是 LocalDate和LocalTime的合体，它同时表示日期和时间，但不带有市区信息

  ⭐️Java 8 中简单的时间和日期对象的合体类

  TemporalAdjuster提供了大量对于常见的用力，日期和时间的API，例如将日期调整到下周日，下个工作日，或者本月的最后一天

  ⭐主要用于修改时间

  DateTimeFormatter 用于解析日期时间对象，打印已急输出，对于老的java.util.DateFormat相比较，所有的DateTimeFormatter实例都是线程安全的

  ⭐️获取本地时间字符串可以写成：

  LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss"))

  感觉Java 8所有的特性，都变成了链式变成，或者说是函数式编程

  Java 8新增的java.time.ZoneId类是老版java.util.TimeZone的替代品，新版的日期和时间API的时区的处理被极大的简化了，它的设计目标就是要让你无需为时区处理的复杂和繁琐而操心，跟其他日期和时间类一样，ZoneId类也是无法修改的

  ⭐️记录就好，时区这章太无聊，看的想睡觉