Repository navigation
Expand file tree
/
Copy pathatom.xml
More file actions
99 lines (53 loc) · 28.2 KB
/
Copy pathatom.xml
File metadata and controls
99 lines (53 loc) · 28.2 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
<title>LunaticNote</title>
<subtitle>想写点啥又不知道该写啥，暂时就这样吧</subtitle>
<link href="/atom.xml" rel="self"/>
<link href="http://yoursite.com/"/>
<updated>2020-05-10T16:09:57.744Z</updated>
<id>http://yoursite.com/</id>
<author>
<name>LunaticNote</name>
</author>
<generator uri="https://hexo.io/">Hexo</generator>
<entry>
<title>悲观锁和乐观锁</title>
<link href="http://yoursite.com/2020/05/10/%E6%82%B2%E8%A7%82%E9%94%81%E5%92%8C%E4%B9%90%E8%A7%82%E9%94%81/"/>
<id>http://yoursite.com/2020/05/10/%E6%82%B2%E8%A7%82%E9%94%81%E5%92%8C%E4%B9%90%E8%A7%82%E9%94%81/</id>
<published>2020-05-10T14:56:00.000Z</published>
<updated>2020-05-10T16:09:57.744Z</updated>
<content type="html"><![CDATA[<h2 id="悲观锁和乐观锁"><a href="#悲观锁和乐观锁" class="headerlink" title="悲观锁和乐观锁"></a>悲观锁和乐观锁</h2><h3 id="并发："><a href="#并发：" class="headerlink" title="并发："></a>并发：</h3><blockquote><p>        首先你要理解并发和多线程不是一个概念，多线程指的是单个程序中同时运行多个线程完成不同的工作，称为多线程，并发指的是一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行，但任意一个时刻点上只有一个程序在处理机上运行，此外还有一个并行，他指的是两个或者多个事件在同一时刻发生 ，并发强调的时间段，更准确的来说并发是不断的互相抢占；</p></blockquote><h3 id="悲观锁（-Pessimistic-Concurrency-Control-PCC）"><a href="#悲观锁（-Pessimistic-Concurrency-Control-PCC）" class="headerlink" title="悲观锁（ Pessimistic Concurrency Control PCC）"></a>悲观锁（ Pessimistic Concurrency Control PCC）</h3><blockquote><p>       嗯你可以认为他有被害妄想症，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁 ,悲观的并发控制实际上是先锁在访问的保守策略，因而它的效率有些不尽人意，这种加锁会产生额外的开销，同时降低了并行性，Java中synchronized（内置）和ReentrantLock（重入锁）等独占锁就是悲观锁思想的实现， AQS框架下的锁则是先尝试CAS乐观锁去获取锁，获取不到，才会转换为悲观锁 ；</p><p>synchronized和Lock的异同]<a href="https://www.cnblogs.com/gejuncheng/p/10777691.html" target="_blank" rel="noopener">https://www.cnblogs.com/gejuncheng/p/10777691.html</a> </p></blockquote><h3 id="乐观锁（Optimistic-Lock-）"><a href="#乐观锁（Optimistic-Lock-）" class="headerlink" title="乐观锁（Optimistic Lock ）"></a>乐观锁（Optimistic Lock ）</h3><blockquote><p>       即认为读多写少，遇到并发写的可能性低，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，采取在写时先读出当前版本号，然后加锁操作（比较跟拿数据时的版本号，如果一样则更新，版本号+1），乐观锁基本都是通过CAS操作实现的这在之前的java8（1）中有介绍，JDK1.5 中新增java.util.concurrent(J.U.C)就是建立在CAS之上。相比较于synchronized这种阻塞算法，CAS是非阻塞算法的一种常见实现。所以J.U.C在性能上有了很大的提升但是这种锁也有问题。</p><p>ABA:</p><p>如果一开始位置V得到的旧值是A，赋值时再次读取仍然是A，并不能说明变量没有被其它线程改变过。有可能是其它线程将变量改为了B，后来又改回了A，大部分情况下不会影响并发的正确性，如果要解决这种问题，用传统的互斥同步可能比原子类更高效；</p><p>自旋时间长开销大：</p><p>自旋CAS（也就是不成功就一直循环直到成功）但是长时间不成功会给CPU带来非常大的执行开销，如果JVM支持处理器提供的pause指令那么效率会有一定的提升，pause指令有两个作用，第一它可以延迟流水线执行指令，使CPU不会消耗过多的执行资源，延迟的时间取决于具体实现的版本，在一些处理器上延迟时间是0.第二他可以避免在退出循环时因内存顺序冲突引起CPU流水线被清空，从而提高CPU执行效率;</p><p>只保证单个共享变量：</p><p> CAS只对单个共享变量有效，当操作涉及跨多个共享变量时CAS无效，但是从JDK1.5开始，提供了AtomicReference类来保证引用对象之间的原子性，你可以把多个变量放在一个对象里来进行CAS操作。所以我们可以使用锁或者利用AtomicReference类把多个共享变量合并成一个共享变量来操作 ：</p></blockquote><h3 id="Mysql（分布式）"><a href="#Mysql（分布式）" class="headerlink" title="Mysql（分布式）"></a>Mysql（分布式）</h3><blockquote><p>悲观锁主要是共享锁和排他锁， 适合写操作多的场景 ；<br>乐观锁适合读操作多的场景，不加锁的特点能够使其读操作的性能大幅提升。 </p><p>表级锁（ MyISAM 支持）：开销小，加锁快，不会出现死锁，锁定粒度大，发生锁冲突的概率最高，并发度最低。<br>行级锁（ InnoDB 支持）：开销大，加锁慢，会出现死锁，锁定粒度最小，发生锁冲突的概率最低，并发度也最高。<br>页面锁：开销和加锁时间界于表锁和行锁之间，会出现死锁，锁定粒度界于表锁和行锁之间，并发度一般</p><p> <strong>行级锁：</strong> </p><p>       共享锁(s)：又称为读锁，简称S锁。顾名思义，共享锁就是多个事务对于同一数据可以共享一把锁，都能访问到数据，但是只能读不能修改</p><p>       排他锁(x)：又称为写锁，简称X锁。顾名思义，排他锁就是不能与其他锁并存，如果一个事务获取了一个数据行的排他锁，其他事务就不能再获取该行的其他锁，包括共享锁和排他锁，但是获取排他锁的事务是可以对数据行读取和修改</p><p>数据库的事务隔离越严格，并发副作用越小，但付出的代价也就越大，“串行化”与“并发”是矛盾的</p></blockquote><h3 id="总结："><a href="#总结：" class="headerlink" title="总结："></a>总结：</h3><blockquote><p>       对于资源竞争较少（线程冲突较轻）的情况，使用synchronized同步锁进行线程阻塞和唤醒切换以及用户内核态间的切换操作额外浪费消耗cpu资源；而CAS基于硬件实现，不需要进入内核，不需要切换线程，操作自旋几率较少，因此可以获得更高的性能 </p><p>       对于资源竞争严重（线程冲突严重）的情况，CAS自旋的概率会比较大，从而浪费更多的CPU资源，效率低于synchronized </p><p>       synchronized 在JDK1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入了偏向锁和轻量级锁以及其他各种优化之后变得在某些情况下并不是那么重了,底层实现主要依靠lock-Free队列，基本思路是自旋后阻塞，竞争切换后继续竞争锁，稍微牺牲了公平性，但获得了高吞吐量。在线程冲突较少的情况下，可以获得和CAS类似的性能,而线程冲突严重的情况下性能远高于CAS</p></blockquote>]]></content>
<summary type="html">
<h2 id="悲观锁和乐观锁"><a href="#悲观锁和乐观锁" class="headerlink" title="悲观锁和乐观锁"></a>悲观锁和乐观锁</h2><h3 id="并发："><a href="#并发：" class="headerlink" title=
</summary>
<category term="并发" scheme="http://yoursite.com/categories/%E5%B9%B6%E5%8F%91/"/>
<category term="java" scheme="http://yoursite.com/tags/java/"/>
<category term="锁" scheme="http://yoursite.com/tags/%E9%94%81/"/>
</entry>
<entry>
<title>JAVA8_2</title>
<link href="http://yoursite.com/2020/05/09/JAVA8-2/"/>
<id>http://yoursite.com/2020/05/09/JAVA8-2/</id>
<published>2020-05-09T11:57:50.000Z</published>
<updated>2020-05-10T16:06:01.388Z</updated>
<content type="html"><</code></pre><p>计算事件运行的时间：</p><figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br><span class="line">53</span><br><span class="line">54</span><br><span class="line">55</span><br><span class="line">56</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">//旧时间</span></span><br><span class="line"><span class="keyword">long</span> start =System.currentTimeMillis();</span><br><span class="line"> <span class="comment">//事件</span></span><br><span class="line"> <span class="keyword">long</span> end =System.currentTimeMillis();</span><br><span class="line"> System.out.println(start-end);</span><br><span class="line"> <span class="comment">//java8中</span></span><br><span class="line"> Instant start = Instant.now();</span><br><span class="line"> <span class="comment">//事件</span></span><br><span class="line"> Instant end = Instant.now();</span><br><span class="line"> Duration time = Duration.between(start, end);</span><br><span class="line"> <span class="comment">//毫秒</span></span><br><span class="line"><span class="keyword">long</span> s=time.getSeconds();</span><br><span class="line"><span class="comment">//秒</span></span><br><span class="line"><span class="keyword">long</span> ms = time.toMillis();</span><br><span class="line"></span><br><span class="line"><span class="comment">/*比较两个时间的间隔*/</span></span><br><span class="line"><span class="comment">//第一个时间</span></span><br><span class="line">Instant start = Instant.now();</span><br><span class="line">Instant end = Instant.now();</span><br><span class="line">Duration time = Duration.between(start, end);</span><br><span class="line"><span class="comment">//第二个时间</span></span><br><span class="line">Instant start1 = Instant.now();</span><br><span class="line">Instant end1 = Instant.now();</span><br><span class="line">Duration time1 = Duration.between(start1, end1);</span><br><span class="line"><span class="comment">//public boolean isNegative() 持续时间的总长度小于零，则为true，大于零false </span></span><br><span class="line">System.out.println(time.minus(time1).isNegative());</span><br><span class="line"></span><br><span class="line"><span class="comment">//获取本地的时间和日期</span></span><br><span class="line">LocalDate dateNow = LocalDate.now();</span><br><span class="line"><span class="comment">//根据年月日取日期：</span></span><br><span class="line">LocalDate dateStr = LocalDate.of(<span class="number">2019</span>, <span class="number">1</span>, <span class="number">1</span>); <span class="comment">// -> 2019-01-01</span></span><br><span class="line"><span class="comment">//根据字符串取：</span></span><br><span class="line">LocalDate endOfFeb = LocalDate.parse(<span class="string">"2020-01-01"</span>); <span class="comment">// 严格按照ISO8601 yyyy-MM-dd验证</span></span><br><span class="line">LocalTime timeNow = LocalTime.now();</span><br><span class="line">LocalTime time = LocalTime.of(<span class="number">22</span>, <span class="number">50</span>, <span class="number">56</span>);</span><br><span class="line"><span class="comment">//时间加算 HOURS可替换为年 月 周 日 时 分 秒 毫秒。。。 </span></span><br><span class="line">LocalTime.now().plus(<span class="number">1</span>, ChronoUnit.HOURS);<span class="comment">//等效于 plusHours(1)</span></span><br><span class="line"><span class="comment">//时间格式化</span></span><br><span class="line">String data1 = dateNow.format(DateTimeFormatter.BASIC_ISO_DATE); <span class="comment">// yyyMMdd</span></span><br><span class="line">String data2 = dateNow.format(DateTimeFormatter.ISO_LOCAL_DATE); <span class="comment">// yyyy-MM-dd</span></span><br><span class="line">String data3 = dateNow.format(DateTimeFormatter.ISO_LOCAL_TIME); <span class="comment">// HH-mm-ss-ms</span></span><br><span class="line">String data4 = dateNow.format(DateTimeFormatter.ofPattern(<span class="string">"yyyy-MM-dd"</span>)); <span class="comment">// 指定格式（yyyy-MM-dd）</span></span><br><span class="line">String data5 = dateNow.format(DateTimeFormatter.ofPattern(<span class="string">"今天是：YYYY年 MMMM dd日 E"</span>, Locale.CHINESE)); <span class="comment">// 今天是：yyyy年 MM月 dd日 星期</span></span><br><span class="line"><span class="comment">//标准格式化</span></span><br><span class="line">DateTimeFormatter formatter = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL);</span><br><span class="line">String data6 = formatter.format(LocalDateTime.now());</span><br><span class="line"></span><br><span class="line"><span class="comment">//查看当前的时区 Asia/Shanghai</span></span><br><span class="line">ZoneId defaultZone = ZoneId.systemDefault();</span><br><span class="line"><span class="comment">//查看美国纽约当前的时间</span></span><br><span class="line">ZoneId usa = ZoneId.of(<span class="string">"America/New_York"</span>);</span><br><span class="line">LocalDateTime shanghai = LocalDateTime.now();</span><br><span class="line">LocalDateTime usaTime = LocalDateTime.now(usa);</span><br><span class="line"><span class="comment">//带有时区的时间</span></span><br><span class="line">ZonedDateTime tiemZone = ZonedDateTime.now(defaultZone);</span><br><span class="line">System.out.println(tiemZone); <span class="comment">//2020-01-01T11:03:05.926+08:00[Asia/Shanghai]</span></span><br></pre></td></tr></table></figure><table><thead><tr><th>方法</th><th>说明</th><th>返回</th></tr></thead><tbody><tr><td>date.isBefore（date1）</td><td>是否在之前</td><td>Boolean</td></tr><tr><td>date.isAfter（date1）</td><td>是否在之后</td><td>Boolean</td></tr><tr><td>date.until(today, ChronoUnit.DAYS)</td><td>计算时间差，单位可替换</td><td>时间差</td></tr></tbody></table><p>       转换中需要注意，java8之前Date是包含日期和时间的，而LocalDate只包含日期，LocalTime只包含时间，所以与Date在互转中，必定会丢失日期或者时间，或者会使用起始时间。如果转LocalDateTime ,详细的可以看这篇文档 <a href="https://iowiki.com/javatime/javatime_index.html" target="_blank" rel="noopener">https://iowiki.com/javatime/javatime_index.html</a> </p><p>优秀的你今天别忘记分享奥！！！</p></blockquote>]]></content>
<summary type="html">
<h2 id="JAVA8（2）"><a href="#JAVA8（2）" class="headerlink" title="JAVA8（2）"></a>JAVA8（2）</h2><h3 id="函数式接口"><a href="#函数式接口" class="headerlink
</summary>
<category term="java8" scheme="http://yoursite.com/categories/java8/"/>
<category term="java" scheme="http://yoursite.com/tags/java/"/>
</entry>
<entry>
<title>JAVA 8</title>
<link href="http://yoursite.com/2020/05/08/JAVA-8/"/>
<id>http://yoursite.com/2020/05/08/JAVA-8/</id>
<published>2020-05-08T15:37:37.000Z</published>
<updated>2020-05-08T15:51:54.952Z</updated>
<content type="html"><![CDATA[<h2 id="JAVA8-1"><a href="#JAVA8-1" class="headerlink" title="JAVA8(1)"></a>JAVA8(1)</h2><h3 id="概述："><a href="#概述：" class="headerlink" title="概述："></a>概述：</h3><blockquote><p>         是什么让我选择了java8，是命运吗？是爱吗？🤮，好吧我自己也编不下去了，其实最先关注java8是因为Lambda和stream API，然后才了解到了他的一系列的数据结构和底层的优化，而且还是长期支持的版本,so你懂的！</p></blockquote><h3 id="更快的速度："><a href="#更快的速度：" class="headerlink" title="更快的速度："></a>更快的速度：</h3><blockquote><p>         效率和速度这是一个永远无法避免的问题，以前的底层结构z中方法区（堆中永久区的一部分，用于存放核心类库的信息，几乎不会被GC回收）总是被单独拎出来，因为一些厂商像sun公司的Hostpot他的JVM存在永久区而另外像IBM等一些公司已经移除了这一区域，在java8之后他统一取消了这一区域，出现<strong>Metaspace</strong>(元空间)，他和方法区的不同是他直接用的是物理内存发生内存溢出(out of memory error OOM)的异常发生的机率降低，同时永久区的改变使得JVM调优中的PremGenSize 、MaxPremGenSize 无效 ,取而代之的是MetaspaceSize和MaxMetaspaceSize；</p></blockquote><h3 id="数据结构的改变"><a href="#数据结构的改变" class="headerlink" title="数据结构的改变"></a>数据结构的改变</h3><blockquote><p>         可能对于你来说这些不足以打动你但是，同时java8也对一些数据结构进行了改编，例如常用的HashMap,哈希算法因为碰撞会导致效率变低，在java8中他在原有的数组+链表的结构上引入了红黑树，这是一种自平衡的二叉查找树( symmetric binary B-trees )，除了添加都非常快。</p><p>         Java7的ConcurrentHashMap中通过Segment引入了分段加锁机制用来解决并发中HashMap可能导致的死循环问题。而Java8又对ConcurrentHashMap进行了改动，除了引入红黑树外，还去除了Segment，那么在ava8是如何保证线程安全的呢？</p><p>         其实他内部采用了CAS( compare and swap )+ Synchronized ，锁的粒度： 原来是对需要进行数据操作的Segment加锁，现调整为对每个数组元素加锁（Node） </p><p>         CAS这是一种基于锁的操作，而且是乐观锁，在java中锁分为乐观锁和悲观锁。悲观锁是将资源锁住，等一个之前获得锁的线程释放锁之后，下一个线程才可以访问。而乐观锁采取了一种宽泛的态度，通过某种方式不加锁来处理资源，比如通过给记录加version来获取数据，性能较悲观锁有很大的提高。操作包含三个操作数 内存位置（V）、预期原值（A）和新值(B)。如果内存地址里面的值和A的值是一样的，那么就将内存里面的值更新成B。CAS是通过无限循环来获取数据的，若果在第一轮循环中，a线程获取地址里面的值被b线程修改了，那么a线程需要自旋，到下次循环才有可能机会执行</p></blockquote><h3 id="lambda表达式"><a href="#lambda表达式" class="headerlink" title="lambda表达式"></a>lambda表达式</h3><blockquote><p>         他是一个匿名的函数，可以理解为一段可以传递的代码（将代码像数据一样进行传递）。可以写出跟简洁、灵活的代码。作为一种更紧凑的代码风格，使java的语言表达能力得到了提升。</p><figure class="highlight java"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line">List<User> list=Arrays.asList(<span class="keyword">new</span> User(<span class="number">1L</span>,<span class="string">"zs"</span>,<span class="string">"male"</span>),</span><br><span class="line"> <span class="keyword">new</span> User(<span class="number">2L</span>,<span class="string">"ls"</span>,<span class="string">"male"</span>),</span><br><span class="line"> <span class="keyword">new</span> User(<span class="number">2L</span>,<span class="string">"ls"</span>,<span class="string">"female"</span>)</span><br><span class="line"> );</span><br><span class="line"> <span class="keyword">for</span> (Object obj:list){</span><br><span class="line"> System.out.println(obj.toString());</span><br><span class="line"> }</span><br><span class="line"> list.parallelStream().forEach(ls-> System.out.println(ls));</span><br></pre></td></tr></table></figure></blockquote><h3 id="stream-API"><a href="#stream-API" class="headerlink" title="stream API"></a>stream API</h3><blockquote><p>         上面同时展现了一个stream，什么是stream（流）?他其实是对于集合的计算，stream本身不会存储数据，改变源数据,他的操作是延迟的，也就是需要的时候才会执行。</p><p>         他其实是java7的Fork/Join，是一个并行执行任务框架 ，这一个框架会将任务拆分成若干小任务，然后连接结合，进行结果汇总。 ForkJoin采用了工作窃取（work-stealing）算法，若一个工作线程的任务队列为空没有任务执行时，便从其他工作线程中获取任务主动执行。为了实现工作窃取，在工作线程中维护了双端队列，窃取任务线程从队尾获取任务，被窃取任务线程从队头获取任务。这种机制充分利用线程进行并行计算，减少了线程竞争。但是当队列中只存在一个任务了时，两个线程去取反而会造成资源浪费。 </p><p>常用的一些方法：</p><table><thead><tr><th>方法</th><th align="left">说明</th></tr></thead><tbody><tr><td>parallelStream()</td><td align="left">并行流</td></tr><tr><td>stream()</td><td align="left">串行流</td></tr></tbody></table><p>中间操作</p><table><thead><tr><th>方法</th><th>说明</th></tr></thead><tbody><tr><td>fileter (Predicate p)</td><td>过滤</td></tr><tr><td>distinct（）</td><td>通过流元素产生的hashcode和equals去除重复元素</td></tr><tr><td>limit（long maxSize）</td><td>截断，使其不超过最大值</td></tr><tr><td>skip（long n）</td><td>跳过元素</td></tr><tr><td>map（Function f）</td><td>接收一个函数作为参数，该函数会被应用到每个元素，并映射成新的元素</td></tr><tr><td>mapToDouble(ToDoubleFunction f)</td><td>接收一个函数作为参数，该函数会被应用到每个元素，并产生一个新的DoubleStream</td></tr><tr><td>sort（）</td><td>按自然顺序排序（字典顺序）</td></tr><tr><td>sorted（Comparator c）</td><td>按照比较器排序</td></tr></tbody></table><p>终止操作</p><table><thead><tr><th>方法</th><th>说明</th></tr></thead><tbody><tr><td>allMatch（Predicate p）</td><td>检查是否匹配所有元素</td></tr><tr><td>anyMatch（Predicate p）</td><td>检查是否至少匹配一个元素</td></tr><tr><td>noneMatch（Predicate p）</td><td>检查是否没有匹配的元素</td></tr><tr><td>findFirst（）</td><td>返回第一个元素</td></tr><tr><td>findAny（）</td><td>返回任意当前流中的元素</td></tr><tr><td>count（）</td><td>返回流中数据的元素个数</td></tr><tr><td>max（Comparator c）</td><td>返回流中最大的值</td></tr><tr><td>min（Comparator c）</td><td>返回流中最小的值</td></tr><tr><td>forEach（Consumer c）</td><td>内部迭代</td></tr><tr><td>reduce（T iden , BinaryOperator b）</td><td>可以将流中元素反复结合起来，得到一个值，返回T</td></tr><tr><td>reduce（BianaryOperator b）</td><td>可以将流中元素反复结合起来，得到一个值。返回</td></tr><tr><td>collect(Collector c)</td><td>结果转换</td></tr></tbody></table></blockquote><h3 id="Optional-类型"><a href="#Optional-类型" class="headerlink" title="Optional 类型"></a>Optional 类型</h3><blockquote><p>         这是一个允许结果为空值的对象，从而减少了空指针的发生，例如对数据进行过滤的时候常常没有满足条件的数据这个时候就可以使用Optional </p></blockquote>]]></content>
<summary type="html">
<h2 id="JAVA8-1"><a href="#JAVA8-1" class="headerlink" title="JAVA8(1)"></a>JAVA8(1)</h2><h3 id="概述："><a href="#概述：" class="headerlink" titl
</summary>
<category term="java8" scheme="http://yoursite.com/categories/java8/"/>
<category term="java" scheme="http://yoursite.com/tags/java/"/>
</entry>
</feed>