代码拉取完成，页面将自动刷新
<?xml version="1.0" encoding="utf-8"?>
<search>
<entry>
<title>Linux简单指令入门</title>
<link href="/hexo-blog/2019/10/20/Linux%E5%9F%BA%E7%A1%80%E5%91%BD%E4%BB%A4%E5%85%A5%E9%97%A8/"/>
<url>/hexo-blog/2019/10/20/Linux%E5%9F%BA%E7%A1%80%E5%91%BD%E4%BB%A4%E5%85%A5%E9%97%A8/</url>
<content type="html"><![CDATA[<pre><code class="hljs Bash"><span class="hljs-built_in">pwd</span> <span class="hljs-comment">#查看当前目录位置</span></code></pre><pre><code class="hljs Bash">who am i <span class="hljs-comment">#查看当前登录用户名</span></code></pre><pre><code class="hljs Bash"><span class="hljs-built_in">cd</span> /root/doc/java <span class="hljs-comment">#切换到/root/doc/java目录</span><span class="hljs-built_in">cd</span> ./java <span class="hljs-comment">#切换到当前目录下的java目录中, '.'表示当前目录</span><span class="hljs-built_in">cd</span> ../php <span class="hljs-comment">#切换到上层目录下的php目录, '..'表示上层目录</span></code></pre><pre><code class="hljs Bash">ls或者ll <span class="hljs-comment">#查看当前目录下文件列表, 可选参数 -a:显示隐藏文件, -r:将排序结果反向输出, -R:列出子目录文件</span></code></pre><pre><code class="hljs Bash">tree 目录 <span class="hljs-comment">#显示竖型文件层级结构</span></code></pre><pre><code class="hljs Bash">find /root -name Test.java <span class="hljs-comment">#查找/root目录下, 名称为Test.java的文件</span>find /root -perm 0755 <span class="hljs-comment">#查找/root目录下, 权限为0755的文件</span>find . -size 12k <span class="hljs-comment">#查找/root目录下, 大小为12K的文件</span></code></pre><pre><code class="hljs Bash">cp /root/test1 test2 <span class="hljs-comment">#复制文件test1到test2中去</span></code></pre><pre><code class="hljs Bash">mv /home/adha.txt /home/<span class="hljs-built_in">local</span>/daha.txt <span class="hljs-comment">#剪切当前文件并重命名, 可选参数 -f:强制覆盖, -i: 询问是否覆盖</span></code></pre><pre><code class="hljs Bash">rm -rf <span class="hljs-comment">#删除文件, 可选参数 -r:递归删除, 谨慎使用, 如果是根目录则删除全部, -f:强制删除</span></code></pre><pre><code class="hljs Bash">tar -jcv -f filename.tar.bz2 <span class="hljs-comment">#要被压缩的文件或目录名称, -c: 压缩</span>tar -jtv -f filename.tar.bz2 <span class="hljs-comment">#查询</span>tar -jxv -f filename.tar.bz2 -C <span class="hljs-comment">#欲解压缩的目录, -v: 解压</span> <span class="hljs-comment">#可选参数 -j: 采用bzip2的方式来解压或压缩, -v将执行文件名显示出来</span></code></pre><pre><code class="hljs Bash">mkdir -m 755 /root/<span class="hljs-built_in">test</span> <span class="hljs-comment">#新建文件或文件夹, -m: 模式-赋予权限</span></code></pre><pre><code class="hljs Bash">ps <span class="hljs-comment">#查看所有运行内存, 可选参数: -A: 显示所有参数, -l: 显示详细信息</span></code></pre><pre><code class="hljs Bash"><span class="hljs-built_in">kill</span> -9 3131 <span class="hljs-comment">#杀死进程, -9: 强制杀死进程, 3131: 进程ID</span></code></pre><pre><code class="hljs Bash">top <span class="hljs-comment">#查看系统资源占用情况, 类似于Win的资源管理器</span></code></pre><pre><code class="hljs Bash">chmod -755 hadoop.sh <span class="hljs-comment">#把hadoop.sh文件的访问权限改为-rwxr-rx-rx</span></code></pre><pre><code class="hljs Bash">vim/vi <span class="hljs-comment">#文件编辑</span>cat <span class="hljs-comment">#文件查看</span>more <span class="hljs-comment">#翻页查看</span>tail <span class="hljs-comment">#行数预览查看</span>head <span class="hljs-comment">#头部预览查看</span></code></pre><pre><code class="hljs Bash">键: i <span class="hljs-comment">#进入编辑模式中编辑内容</span>键: Esc <span class="hljs-comment">#退出到尾行模式</span>:wq <span class="hljs-comment">#从尾行模式退出并保存</span></code></pre><blockquote><p>更多命令请翻阅Linux相关文档</p></blockquote>]]></content>
<categories>
<category>Linux</category>
</categories>
<tags>
<tag>指令</tag>
</tags>
</entry>
<entry>
<title>ThreadLocal入门</title>
<link href="/hexo-blog/2019/10/17/ThreadLocal%E5%85%A5%E9%97%A8/"/>
<url>/hexo-blog/2019/10/17/ThreadLocal%E5%85%A5%E9%97%A8/</url>
<content type="html"><![CDATA[<h2 id="ThreaLocal概念"><a href="#ThreaLocal概念" class="headerlink" title="ThreaLocal概念"></a>ThreaLocal概念</h2><blockquote><p>这个单词很多人理解为本地线程, 其实你可以把它理解为一个变量, 一个为所有线程创建变量副本的类, 并且副本相互独立, 也可以理解为每个线程创建了一个静态的ConcurrentHashMap, 其实ThreadLocal本身内部存储的结构就是一个ThreadLocalMap.</p></blockquote><p>为什么说为每个线程创建的一个独立的变量呢?, 咱们来一步步解析</p><h3 id="使用ThreadLocal"><a href="#使用ThreadLocal" class="headerlink" title="使用ThreadLocal"></a>使用ThreadLocal</h3><pre><code class="hljs livescript">public <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyThreadLocal</span> {</span> public static <span class="hljs-literal">void</span> main(String[] args) { ThreadLocal<Object> threadLocal = <span class="hljs-keyword">new</span> ThreadLocal<>(); Thread thread1 = <span class="hljs-keyword">new</span> Thread<span class="hljs-function"><span class="hljs-params">(() -> {</span></span><span class="hljs-function"><span class="hljs-params"> System.out.println(Thread.currentThread().getName() + <span class="hljs-string">"开始"</span>);</span></span><span class="hljs-function"><span class="hljs-params"> threadLocal.set(Thread.currentThread().getName() + <span class="hljs-string">""</span>);</span></span><span class="hljs-function"><span class="hljs-params"> System.out.println(threadLocal.get());</span></span><span class="hljs-function"><span class="hljs-params"> })</span>;</span><span class="hljs-function"> <span class="hljs-title">thread1</span>.<span class="hljs-title">start</span><span class="hljs-params">()</span>;</span><span class="hljs-function"></span><span class="hljs-function"> <span class="hljs-title">Thread</span> <span class="hljs-title">thread2</span> = <span class="hljs-title">new</span> <span class="hljs-title">Thread</span><span class="hljs-params">(() -> {</span></span><span class="hljs-function"><span class="hljs-params"> System.out.println(Thread.currentThread().getName() + <span class="hljs-string">"开始"</span>);</span></span><span class="hljs-function"><span class="hljs-params"> System.out.println(threadLocal.get());</span></span><span class="hljs-function"><span class="hljs-params"> })</span>;</span><span class="hljs-function"> <span class="hljs-title">thread2</span>.<span class="hljs-title">start</span><span class="hljs-params">()</span>;</span><span class="hljs-function"> }</span><span class="hljs-function">}</span></code></pre><blockquote><p>大致解释一下: 首先是创建两个独立线程, 然后创建一个ThreadLocal对象, 然后在某个线程内部往这个threadLocal里面set值, 使用就这么简单..</p></blockquote><h3 id="为啥这样来使用"><a href="#为啥这样来使用" class="headerlink" title="为啥这样来使用?"></a>为啥这样来使用?</h3><blockquote><p>首先是new一个ThreadLocal对象, 它为我们线程干了啥? 当你new一个ThreadLocal的时候, 就相当于你new了一个变量管理器, 而ThreadLocal这个变量管理器内部有啥呢?<br>首先, 最重要的就是它内部类ThreadLocalMap, 而这个Map就是我们整个内容的关键, 你所有通过ThreadLocal存储也就是set进来的值, 都是存储在他的内部, 而这个Map的内部其实就是类似于集合内部的一些东西, 一个静态Entry容器继承弱引用<ThreadLocal>类型, 至于为啥要继承这个弱类型, 这你就不继续深究了, 你只需要知道它是把key设为这个ThreadLocal实例, value是传入的值.</p></blockquote><pre><code class="hljs scala">static <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Entry</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">WeakReference<ThreadLocal<?>></span> </span>{ <span class="hljs-comment">/** The value associated with this ThreadLocal. */</span> <span class="hljs-type">Object</span> value; <span class="hljs-type">Entry</span>(<span class="hljs-type">ThreadLocal</span><?> k, <span class="hljs-type">Object</span> v) { <span class="hljs-keyword">super</span>(k); value = v; }}</code></pre><blockquote><p>那为啥说ThreadLocal为每个线程创建了变量副本呢? 首先线程A操作ThreadLoca对象, 并储存一个值到ThreadLocal上去, 储存的时候ThreadLocal会去get当前线程A的threadLocals属性, 这个属性为ThreadLocal.ThreadLocalMap类型, 就是上面ThreadLocal的静态内部类, 所以你应该猜到为啥这个Map是这个ThreadLocal的核心, 一般第一次set的时候线程A的这个属性为空, ThreadLocal就会为他new一个ThreadLocalMap 并将赋值内容存入这个Map, key为当前ThreadLocal实例, value为存储的变量, 线程A的内容就到此为止, 这个时候线程B能不能从这个ThreadLocal中get到这个变量呢? 答案是不能的, 当你线程B调用threadLocal的get方法时, 首先调用getMap方法找线程B的threadLocals, 这个明显是null, 只有线程A在set的时候线程A的threadLocals才被赋值的, 而B是没有被赋值的, 所以这也是为什么ThreadLocal为每个线程创建了独立的副本, 每次新的线程进来调用set方法, ThreadLocal实例就会为它new一个能被ThreadLocal管理的ThreadLocalMap, 而这个Map又与线程的属性字段threadLocals关联, 每次某个线程get的时候, 又会在ThreadLocal这个管理器中get到该线程对应的threadLocals中的value变量.</p></blockquote><p>*<em>总的来说一句话, ThreadLocal为每个线程创建了一个能够存储变量的不同的ThreadLocalMap实例, 而ThreadLocal是用来管理这个ThreadLocalMap实例的储存内容的. 这个ThreadLocal可以应用于在多线程的操作一个实例的这样的场景, 当多线程操作同一实例的时候, 你如果不给每一个线程new一个局部变量(类似于ThreadLocal), 那你会遇到同步的问题, 你可以用一些能够并发的修改类ConcurentHashMap来设置这个同一实例, 你也可以用锁来解决这种问题…. *</em></p>]]></content>
<categories>
<category>Java</category>
</categories>
<tags>
<tag>JUC</tag>
</tags>
</entry>
<entry>
<title>线程的定义</title>
<link href="/hexo-blog/2019/10/16/%E7%BA%BF%E7%A8%8B%E7%9A%84%E5%AE%9A%E4%B9%89/"/>
<url>/hexo-blog/2019/10/16/%E7%BA%BF%E7%A8%8B%E7%9A%84%E5%AE%9A%E4%B9%89/</url>
<content type="html"><![CDATA[<h2 id="创建"><a href="#创建" class="headerlink" title="创建"></a>创建</h2><blockquote><p>概念: 很多同学应该跟我之前一样不明白线程的具体用处与含义, 其实把你可以把线程分为两部分, 一部分我们很容易理解叫做线程任务, 什么叫线程任务呢?<br>指的是这个线程需要执行或者操作的东西, 体现在Java代码里就是run()里面做的事情, 你可以在任务里做IO操作, 网络操作等等一些任务, 而这个任务怎么执行呢?<br>直接run或者start吗? 都不对, 你需要新建一个线程对象来执行这个任务, 体现在代码里就是new Thread(task); 把任务当做参数传递给线程对象,<br>当这个对象调用start()方法时, 相当于该线程对象被放到一个队列里等待CPU的执行, 而它真正执行的内容便是线程任务.<br>我们这里把实现Runnable, Callable接口的对象叫做任务,<br>而继承Thread, 你可以把他的对象叫做线程, 由于Thread既是线程对象能够执行任务本身又是一个线程任务, 所以相当于把两种内容耦合到一块, 推荐不使用该方式.</p></blockquote><ul><li><h4 id="实现Runnable"><a href="#实现Runnable" class="headerlink" title="实现Runnable"></a>实现Runnable</h4><pre><code class="hljs Java"><span class="hljs-keyword">public</span> <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyRunnable</span> <span class="hljs-keyword">implements</span> <span class="hljs-title">Runnable</span> </span>{ <span class="hljs-meta">@Override</span> <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">run</span><span class="hljs-params">()</span> </span>{ System.out.println(<span class="hljs-string">"线程执行>>>>>>"</span>); } <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">main</span><span class="hljs-params">(String[] args)</span> </span>{ MyRunnable runnable = <span class="hljs-keyword">new</span> MyRunnable(); Thread thread = <span class="hljs-keyword">new</span> Thread(runnable); thread.start(); }}</code></pre></li><li><h4 id="实现Callable-拥有返回值"><a href="#实现Callable-拥有返回值" class="headerlink" title="实现Callable, 拥有返回值."></a>实现Callable, 拥有返回值.</h4><pre><code class="hljs Java"><span class="hljs-keyword">public</span> <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyCallable</span> <span class="hljs-keyword">implements</span> <span class="hljs-title">Callable</span><<span class="hljs-title">String</span>> </span>{ <span class="hljs-meta">@Override</span> <span class="hljs-function"><span class="hljs-keyword">public</span> String <span class="hljs-title">call</span><span class="hljs-params">()</span> <span class="hljs-keyword">throws</span> Exception </span>{ System.out.println(<span class="hljs-string">"实现Callable来创建一个线程"</span>); <span class="hljs-keyword">return</span> <span class="hljs-string">"MyCallable is start"</span>; } <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">main</span><span class="hljs-params">(String[] args)</span> <span class="hljs-keyword">throws</span> ExecutionException, InterruptedException </span>{ MyCallable callable = <span class="hljs-keyword">new</span> MyCallable(); FutureTask<String> futureTask = <span class="hljs-keyword">new</span> FutureTask(callable); futureTask.run(); System.out.println(futureTask.get()); }}</code></pre></li></ul><h2 id="线程机制"><a href="#线程机制" class="headerlink" title="线程机制"></a>线程机制</h2><ul><li><h4 id="Executor线程池"><a href="#Executor线程池" class="headerlink" title="Executor线程池"></a>Executor线程池</h4><blockquote><p>为什么需要线程池框架? 线程池具体有什么用呢? 大家都知道我们在使用JDBC时有连接池的概念, 其实线程池也有同样的作用, 提高执行效率,<br>你比如你一个任务可能需要几个线程来执行, 当你重新new Thread一个或者或者多个线程对象时, 创建线程对象是需要耗费时间的,<br>而且你创建出来的多个线程对象是无法被重复使用或者灵活调度的, 所以当有多个任务进来执行时, 他是低效的.<br>线程池框架会在你执行任务之前帮你创建好线程对象, 且在执行完任务后手动或自动关闭, 同样它是能根据不同场景new 不同的线程对象,<br>比如你new CacheThreadPool()缓存线程适合那些执行时间多且任务量多的异步任务.<br/></p></blockquote></li></ul><p>常用线程池如下:</p><ol><li>newFixedThreadPool(int nThreads) ：指定工作线程数量的线程池。</li><li>newCachedThreadPool() ：一个任务创建一个线程；常用于处理大量短时间工作任务的线程池。<br>(1) 试图缓存线程并重用，当无缓存线程可用时，就会创建新的工作线程。<br>(2) 如果线程闲置的时间超过阈值，则会被终止并移除缓存。<br>(3) 系统长时间闲置的时候，不会消耗什么资源。</li><li>newSingleThreadExecutor() ：相当于大小为 1 的 FixedThreadPool，创建唯一的工作者线程来执行任务，如果线程异常结束，会有另外一个线程取代它。</li><li>newSingleThreadScheduledExecutor() 和newScheduledThreadPool(int corePoolSize)：定时或者周期性的工作调度，两者的区别在于单一工作线程还是多个线程。</li><li>newWorkStealingPool() ：内部会构建ForkJoinPool，利用working-stealing算法，并行的处理任务，不保证处理顺序。</li></ol><pre><code class="hljs Java"><span class="hljs-keyword">public</span> <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MyExecutor</span> </span>{ <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">main</span><span class="hljs-params">(String[] args)</span> </span>{ ExecutorService executorService = Executors.newFixedThreadPool(<span class="hljs-number">10</span>); executorService.execute(() -> { System.out.println(<span class="hljs-string">"execute my task"</span>); }); }}</code></pre><ul><li><h4 id="Daemon守护线程"><a href="#Daemon守护线程" class="headerlink" title="Daemon守护线程"></a>Daemon守护线程</h4><blockquote><p>守护线程是程序运行时在后台提供服务的线程，不属于程序中不可或缺的部分。当所有非守护线程结束时，程序也就终止，同时会杀死所有守护线程。main() 属于非守护线程。使用 setDaemon() 方法将一个线程设置为守护线程。</p></blockquote></li></ul><pre><code class="hljs Java"><span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">main</span><span class="hljs-params">(String[] args)</span> </span>{ Thread thread = <span class="hljs-keyword">new</span> Thread(<span class="hljs-keyword">new</span> MyRunnable()); thread.setDaeon(<span class="hljs-keyword">true</span>);}</code></pre><h2 id="线程的状态转换"><a href="#线程的状态转换" class="headerlink" title="线程的状态转换"></a>线程的状态转换</h2><ul><li><h4 id="新建"><a href="#新建" class="headerlink" title="新建"></a>新建</h4>当一个线程刚被new出来的时候.</li><li><h4 id="可运行"><a href="#可运行" class="headerlink" title="可运行"></a>可运行</h4>线程start()之后, 该线程处于可运行状态, 但是还没有运行, 它得拿到CPU时间片才能运行</li><li><h4 id="运行"><a href="#运行" class="headerlink" title="运行"></a>运行</h4>拿到CPU时间片后, 线程开始运行.</li><li><h4 id="阻塞"><a href="#阻塞" class="headerlink" title="阻塞"></a>阻塞</h4>但是在运行的时候会进入阻塞状态, 有几种情况.</li></ul><ol><li>一般阻塞: 当在run()里面执行Thread.sleep(long mills) 或者 t.join() 以及I/O操作时, 线程会阻塞.但是时间结束后线程还是会进入到可运行状态等待CPU时间片.</li><li>等待阻塞: 当在run()里面执行o.wait()时候, 放弃对象锁, 会直接进入等待队列, 需要其他线程调用notify()或者notifyAll()来唤醒进入锁池对象争夺对象锁, 这里需要提一脚, 如果wait(long mills)里面有参数的话, 就是另外一种状态啦,<br>当你使用wait(long mills)时候, 线程会临时释放对象锁, 然后等待, 如果等待时间mills到啦的话就直接进入可运行状态等待时间片而不会进入等待队列或者锁池队列.</li><li>同步阻塞: 当你在线程中遇到同步对象代码快的时候, 如果没有拿到对象锁该线程就进入锁池队列, 等待其他线程释放对象锁.</li></ol><ul><li><h4 id="死亡"><a href="#死亡" class="headerlink" title="死亡"></a>死亡</h4>线程执行完毕又或者线程执行过程遇到异常都会导致线程死亡.</li></ul><h2 id="线程的并发同步问题"><a href="#线程的并发同步问题" class="headerlink" title="线程的并发同步问题"></a>线程的并发同步问题</h2><blockquote><p>概念: 当两个或以上线程对同一共享对象执行操作时会使用锁来进行互斥访问,不然会出现同步问题.在Java中提供啦两种锁, 第一个是 JVM 实现的 synchronized，而另一个是 JDK 实现的 ReentrantLock。</p></blockquote><p>对于synchronized和ReentrantLock的具体用法就不介绍啦(会有一篇详细的文章来介绍synchronized和ReentrantLock), 接下来介绍他们两的对比.</p><ol><li><p><strong>锁的实现</strong>:<br>synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。</p></li><li><p><strong>性能</strong>:<br>新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等，synchronized 与 ReentrantLock 大致相同。</p></li><li><p><strong>等待可中断</strong>:<br>当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情。<br>ReentrantLock 可中断，而 synchronized 不行。</p></li><li><p><strong>公平锁</strong>:<br>公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁。<br>synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但是也可以是公平的。</p></li><li><p><strong>锁绑定多个条件</strong>:<br>一个 ReentrantLock 可以同时绑定多个 Condition 对象。</p></li></ol><h5 id="使用选择"><a href="#使用选择" class="headerlink" title="使用选择"></a>使用选择</h5><blockquote><p>除非需要使用 ReentrantLock 的高级功能，否则优先使用 synchronized。这是因为 synchronized 是 JVM 实现的一种锁机制，JVM 原生地支持它，而 ReentrantLock 不是所有的 JDK 版本都支持。并且使用 synchronized 不用担心没有释放锁而导致死锁问题，因为 JVM 会确保锁的释放。</p></blockquote><h2 id="线程的协调"><a href="#线程的协调" class="headerlink" title="线程的协调"></a>线程的协调</h2><blockquote><p>要处理好线程的调度问题就要用好线程类的各种方法, 使得线程正常运行.</p></blockquote>]]></content>
<categories>
<category>Java</category>
</categories>
<tags>
<tag>JUC</tag>
</tags>
</entry>
<entry>
<title>熟悉Java8新特性</title>
<link href="/hexo-blog/2019/10/15/Java8%E6%96%B0%E7%89%B9%E6%80%A7%E6%95%B4%E7%90%86/"/>
<url>/hexo-blog/2019/10/15/Java8%E6%96%B0%E7%89%B9%E6%80%A7%E6%95%B4%E7%90%86/</url>
<content type="html"><![CDATA[<div class="note note-warning"> <p>该文章部分参考自<a href="https://snailclimb.gitee.io/javaguide/#/" target="_blank" rel="noopener">JavaGuide</a>, <a href="https://www.jianshu.com/p/117b2ec70d8f" target="_blank" rel="noopener">Java8新工具</a> 详细内容请参考作者原文.<br>转载请标明出处, 谢谢! </p> </div><p>鉴于目前主要学习的Java版本为1.8版本, 所以一些新特性需要了解, 这是我们工作上会很大程度忽略的, 所以特在这里写一个专题来熟悉一些我们会忽略的内容.</p><h3 id="新特性"><a href="#新特性" class="headerlink" title="新特性"></a>新特性</h3><blockquote><p>依赖于<code>JDK1.8</code></p></blockquote><h4 id="默认方法"><a href="#默认方法" class="headerlink" title="默认方法"></a>默认方法</h4><p>Java8允许我们向接口中添加默认方法, 也就是<code>default</code>修饰的方法.</p><pre><code class="hljs java"><span class="hljs-class"><span class="hljs-keyword">interface</span> <span class="hljs-title">Formula</span></span>{ <span class="hljs-function"><span class="hljs-keyword">double</span> <span class="hljs-title">calculate</span><span class="hljs-params">(<span class="hljs-keyword">int</span> a)</span></span>; <span class="hljs-function"><span class="hljs-keyword">default</span> <span class="hljs-keyword">double</span> <span class="hljs-title">sqrt</span><span class="hljs-params">(<span class="hljs-keyword">int</span> a)</span> </span>{ <span class="hljs-keyword">return</span> Math.sqrt(a); }}</code></pre><p>上述接口中, 我们添加了一个默认方法, 和接口内的抽象方法不太一样, 它是有函数实现体, 并且你可以在抽象方法实现内部调用它, 还可以用实例调用.</p><pre><code class="hljs java"><span class="hljs-keyword">public</span> <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Main</span> </span>{ <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">main</span><span class="hljs-params">(String[] args)</span> </span>{ <span class="hljs-comment">// 通过匿名内部类方式访问接口</span> Formula formula = <span class="hljs-keyword">new</span> Formula() { <span class="hljs-meta">@Override</span> <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">double</span> <span class="hljs-title">calculate</span><span class="hljs-params">(<span class="hljs-keyword">int</span> a)</span> </span>{ <span class="hljs-keyword">return</span> sqrt(a * <span class="hljs-number">100</span>); } }; System.out.println(formula.calculate(<span class="hljs-number">100</span>)); <span class="hljs-comment">// 100.0</span> System.out.println(formula.sqrt(<span class="hljs-number">16</span>)); <span class="hljs-comment">// 4.0</span> }}</code></pre><blockquote><p>注意内部类的实现, 大家应该都明白接口或者抽象类是无法直接new的, 我们可以通过内部类的实现方法, 生成一个内部类对象, 并让接口引用指向它即可.</p></blockquote><h4 id="函数式接口"><a href="#函数式接口" class="headerlink" title="函数式接口"></a>函数式接口</h4><p>函数式接口<code>@FunctionalInterface</code>, 是指只包含一个抽象方法和其他非抽象方法的接口类, 函数式接口是Java语言设计者用来支持lambda表达式的, 像<code>java.lang.Runnable</code> 与 <code>java.util.concurrent.Callable</code>是经典的函数式接口, 而这个新的注解<code>@FunctionalInterface</code>是用来标注那些只有一个抽象方法的接口的, 不过你这个类只要符合一个抽象方法的要求, java都会把它认识为一个函数式接口也能解析为lambda表达式, 并不需要注解<code>@FunctionalInterface</code>来规定, 你可以用这个注解来做约束, 当你加上这个注解, 又接着往该接口的内部添加两个以上的抽象方法, 编译器会提示你报错..</p><pre><code class="hljs java"><span class="hljs-meta">@FunctionalInterface</span><span class="hljs-keyword">public</span> <span class="hljs-class"><span class="hljs-keyword">interface</span> <span class="hljs-title">Converter</span><<span class="hljs-title">F</span>, <span class="hljs-title">T</span>> </span>{ <span class="hljs-function">T <span class="hljs-title">convert</span><span class="hljs-params">(F from)</span></span>;}</code></pre><p>上述接口就是一个函数式接口</p><pre><code class="hljs java"><span class="hljs-comment">// TODO 将数字字符串转换为整数类型</span>Converter<String, Integer> converter = (from) -> Integer.valueOf(from);Integer converted = converter.convert(<span class="hljs-string">"123"</span>);System.out.println(converted.getClass()); <span class="hljs-comment">//class java.lang.Integer</span></code></pre><p>可以用lambda表达式来解析</p><blockquote><p>Java8中大部分函数式接口都处在<code>java.util.function</code>中, 并不用我们来定义. 像<code>Predicates</code>, <code>Functions</code></p></blockquote><h4 id="lambda表达式"><a href="#lambda表达式" class="headerlink" title="lambda表达式"></a>lambda表达式</h4><p>你应该学习了怎么使用匿名内部类来创建内部类实例来实现抽象类和接口, 不过现在你可以用更简洁的语法来实现它了.</p><ul><li>Java7之前</li></ul><pre><code class="hljs java"><span class="hljs-keyword">new</span> Thread(<span class="hljs-keyword">new</span> Runable(){ <span class="hljs-meta">@Override</span> <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">run</span><span class="hljs-params">()</span> </span>{ System.out.println(<span class="hljs-string">"adasdja"</span>); }}).start();</code></pre><ul><li>Java8之后</li></ul><pre><code class="hljs java"><span class="hljs-keyword">new</span> Thread(() -> System.out.println(<span class="hljs-string">"adasdja"</span>)).start();</code></pre><p>解释一下, 为啥它缩写成这样子了, 首先它将内部类的结构体缩掉, 然后内部实现的方法缩成<code>()</code>这样来表示, <code>()</code>内可以写方法参数, 参数可以不标明类型, 同时如果<br>你的重写方法{}内部只有一行语句, 那你也可以把这个{}省掉, 而<code>-></code>就是参数与方法体的连接符号.至于为啥它能缩写这么多而代码还起作用, 就是函数式接口的功劳,<br>首先函数式接口<code>@FunctionalInterface</code>是用来支持lambda表达式的, 其实每次Java在内部都会把lambda表达式通过函数式接口的结构把它转成可以编译的内部类方式, 包括内部的一些参数类型, 都可以通过接口反射拿到..</p><h4 id="方法引用"><a href="#方法引用" class="headerlink" title="方法引用"></a>方法引用</h4><p>在函数式接口那一节, 我们定义的lambda可以用方法引用来表示</p><pre><code class="hljs java">Converter<String, Integer> converter = Integer::valueOf;Integer converted = converter.convert(<span class="hljs-string">"123"</span>);System.out.println(converted.getClass()); <span class="hljs-comment">//class java.lang.Integer</span></code></pre><p><code>::</code>关键字用来表示方法引用, 上述是用来表示静态方法的方法引用, 当然我们也可以引用对象方法, 或者用来引用构造函数.</p><pre><code class="hljs java"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Person</span> </span>{ String firstName; String lastName; Person() {} Person(String firstName, String lastName) { <span class="hljs-keyword">this</span>.firstName = firstName; <span class="hljs-keyword">this</span>.lastName = lastName; }}<span class="hljs-class"><span class="hljs-keyword">interface</span> <span class="hljs-title">PersonFactory</span><<span class="hljs-title">P</span> <span class="hljs-keyword">extends</span> <span class="hljs-title">Person</span>> </span>{ <span class="hljs-function">P <span class="hljs-title">create</span><span class="hljs-params">(String firstName, String lastName)</span></span>;}PersonFactory<Person> personFactory = Person::<span class="hljs-keyword">new</span>;Person person = personFactory.create(<span class="hljs-string">"Peter"</span>, <span class="hljs-string">"Parker"</span>);</code></pre><p>上述代码中, <code>PersonFactory</code>是一个用来创建Person对象的工厂类, 而我们并不用实现该工厂接口, 我们用构造函数的引用关联工厂类, Java编译器会自动根据PersonFactory.create方法的参数类型来选择合适的构造函数。</p><h4 id="stream-api"><a href="#stream-api" class="headerlink" title="stream api"></a>stream api</h4><p><code>java.util.Stream</code>表示应用在一组元素上的流式操作, 通常一些继承来自<code>java.util.Collection</code>的子类 <code>set</code>, <code>list</code>,还有一些数组,注意<code>map</code>不支持流式操作.<br><code>stream</code>支持串行和并行操作, 同时分为中间操作和最终操作, 最终操作返回一特定类型的计算结果，而中间操作返回Stream本身，这样你就可以将多个操作依次串起来.<br>具体用法如下: </p><pre><code class="hljs Java">String[] strArr = {<span class="hljs-string">"31"</span>, <span class="hljs-string">"321"</span>, <span class="hljs-string">"4"</span>, <span class="hljs-string">"3131"</span>, <span class="hljs-string">"4242"</span>, <span class="hljs-string">"132"</span>, <span class="hljs-string">"212"</span>};Stream<String> stream = Arrays.stream(strArr); <span class="hljs-comment">//另一种方法Stream.of(strArr)</span>stream.distinct() .filter((a) -> !a.startsWith(<span class="hljs-string">"4"</span>) && !a.startsWith(<span class="hljs-string">"2"</span>)) .sorted((x, y) -> Integer.compare(Integer.parseInt(y), Integer.parseInt(x))) .forEach(System.out::println);</code></pre><ol><li>首先是创建流, 可以用Stream.of()的方法来创建流, 也可以用<code>Collection</code>接口提供的<code>.stream()</code>或者<code>.parallelStream()</code>来创建</li><li>然后看<code>Stream</code>提供的一些操作, 包括<code>filter</code>, <code>sorted</code>, <code>distinct</code>, <code>skip</code>, <code>limit</code>, <code>collect</code>等等, 其中像collect属于最终操作用来生成最后的结果, 而其他剩下的都是一些中间操作, 返回的是stream. 具体用处请看下面的Stream操作实例.</li><li>具体中间的一些操作可以接收函数式接口支持的<code>lambada</code>表达式的, 所以流式语法天然支持<code>lambada</code>表达式. </li></ol><h5 id="Stream操作实例"><a href="#Stream操作实例" class="headerlink" title="Stream操作实例"></a>Stream操作实例</h5><ul><li><p><strong>filter</strong><br><code>filter</code>是用来通过一个<code>predicate</code>接口来过滤流的元素的, 就比如上面的例子就是过滤元素不以’4’和’2’开头的, 属于中间操作.</p></li><li><p><strong>sorted</strong><br><code>sorted</code>是用来接受一个指定的<code>comparetor</code>来做元素排序的, 上述代码调用的就是Integer的compare方法来排序的</p></li><li><p><strong>limit</strong><br><code>limit</code>可以接受一个<code>longsize</code>来限制取流中的元素.</p></li><li><p><strong>skip</strong><br><code>skip</code>用来跳过流中元素的, <code>skip(1)</code>就表示从第二个元素开始取</p></li><li><p><strong>map</strong><br><code>map</code>是用来映射元素的, 就比如下面的, 会把流中的元素字符串映射为大写字符</p><pre><code class="hljs java"><span class="hljs-comment">// 测试 Map 操作</span>stringList .stream() .map(String::toUpperCase) .sorted((a, b) -> b.compareTo(a)) .forEach(System.out::println);<span class="hljs-comment">// "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "AAA2", "AAA1"</span></code></pre></li><li><p><strong>forEach</strong><br><code>forEach</code>是不同于上面的最终操作, 它会将流转化为特定的运算结果.比如foreach会遍历流中每个元素, 然后输出</p></li><li><p><strong>collect</strong><br><code>collect</code>是将流转为熟悉的集合元素, 例如List</p></li><li><p><strong>count</strong><br><code>count</code>统计流中元素个数.</p></li></ul><blockquote><p>这里只是列举一部分, 更多操作可以自己查阅相关文档 </p></blockquote><h4 id="date-api-时间日期有关API"><a href="#date-api-时间日期有关API" class="headerlink" title="date api(时间日期有关API)"></a>date api(时间日期有关API)</h4><p>java8中新增的一些日期有关的内容在<code>java.time</code>下, 有一些新的类, 比如<code>Clock</code>, <code>Instant</code>, <code>ZoneId</code></p><ul><li><p><strong>Clock和TimeZone</strong></p><pre><code class="hljs java">Clock clock = Clock.systemDefaultZone();<span class="hljs-keyword">long</span> millis = clock.millis(); <span class="hljs-comment">//等同于 System.currentTimeMills()</span>System.out.println(millis); <span class="hljs-comment">//1552379579043</span>Instant instant = clock.instant();System.out.println(instant);Date legacyDate = Date.from(instant); <span class="hljs-comment">//2019-03-12T08:46:42.588Z</span>System.out.println(legacyDate);<span class="hljs-comment">//Tue Mar 12 16:32:59 CST 2019</span><span class="hljs-comment">//输出所有区域标识符</span>System.out.println(ZoneId.getAvailableZoneIds());ZoneId zone1 = ZoneId.of(<span class="hljs-string">"Europe/Berlin"</span>);ZoneId zone2 = ZoneId.of(<span class="hljs-string">"Brazil/East"</span>);System.out.println(zone1.getRules());<span class="hljs-comment">// ZoneRules[currentStandardOffset=+01:00]</span>System.out.println(zone2.getRules());<span class="hljs-comment">// ZoneRules[currentStandardOffset=-03:00]</span></code></pre></li><li><p><strong>LocalDateTime</strong></p><pre><code class="hljs java">LocalDateTime sylvester = LocalDateTime.of(<span class="hljs-number">2014</span>, Month.DECEMBER, <span class="hljs-number">31</span>, <span class="hljs-number">23</span>, <span class="hljs-number">59</span>, <span class="hljs-number">59</span>);DayOfWeek dayOfWeek = sylvester.getDayOfWeek();System.out.println(dayOfWeek); <span class="hljs-comment">// WEDNESDAY</span>Month month = sylvester.getMonth();System.out.println(month); <span class="hljs-comment">// DECEMBER</span><span class="hljs-keyword">long</span> minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY);System.out.println(minuteOfDay); <span class="hljs-comment">// 1439</span></code></pre><p>localDateTime是没有时区概念的, 包括<code>locateDate</code>, <code>locateTime</code>都是如此, 你可以给他赋个时区, 然后转为Instant实例.</p></li></ul><h4 id="Optional类"><a href="#Optional类" class="headerlink" title="Optional类"></a>Optional类</h4><p>Optional类不是函数式接口, 而是用来防止<code>NullPointerException</code>的一个工具类, Java8之前方法返回值可以为<code>Null</code>,或者具体的值, 但是我们是不确定的, 所以有时会出现空异常, Java8之后直接可以返回<code>Optional</code>, 具体使用如下:</p><pre><code class="hljs Java"><span class="hljs-comment">//ofNullable() : 为null的值创建一个Optional</span>Optional<String> optional1 = Optional.ofNullable(<span class="hljs-keyword">null</span>); <span class="hljs-comment">//of（）：为非null的值创建一个Optional</span>Optional<String> optional = Optional.of(<span class="hljs-string">"bam"</span>);<span class="hljs-comment">// isPresent（）： 如果值存在返回true，否则返回false</span>optional.isPresent(); <span class="hljs-comment">// true</span><span class="hljs-comment">//get()：如果Optional有值则将其返回，否则抛出NoSuchElementException</span>optional.get(); <span class="hljs-comment">// "bam"</span><span class="hljs-comment">//orElse（）：如果有值则将其返回，否则返回指定的其它值</span>optional.orElse(<span class="hljs-string">"fallback"</span>); <span class="hljs-comment">// "bam"</span><span class="hljs-comment">//ifPresent（）：如果Optional实例有值则为其调用consumer，否则不做处理</span>optional.ifPresent((s) -> System.out.println(s.charAt(<span class="hljs-number">0</span>))); <span class="hljs-comment">// "b"</span></code></pre><h4 id="新工具与引擎"><a href="#新工具与引擎" class="headerlink" title="新工具与引擎"></a>新工具与引擎</h4><ul><li><p><strong>Nashorn引擎：jjs</strong><br>jjs是一个基于标准Nashorn引擎的命令行工具，可以接受js源码并执行。例如，我们写一个func.js文件，内容如下：</p><pre><code class="hljs javascript"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">f</span>(<span class="hljs-params"></span>) </span>{ <span class="hljs-keyword">return</span> <span class="hljs-number">1</span>; }; print( f() + <span class="hljs-number">1</span> );</code></pre><p>可以在命令行中执行jjs func.js来执行该JS</p></li><li><p><strong>类依赖分析器：jdeps</strong><br>jdeps是一个相当棒的命令行工具，它可以展示包层级和类层级的Java类依赖关系，它以.class文件、目录或者Jar文件为输入，然后会把依赖关系输出到控制台。<br>我们可以利用jedps分析下Spring Framework库，来分析<code>org.springframework.core-3.0.5.RELEASE.jar</code>.<br><code>jdeps org.springframework.core-3.0.5.RELEASE.jar</code>这个命令会输出很多结果，我们仅看下其中的一部分：依赖关系按照包分组，如果在classpath上找不到依赖，则显示”not found”.</p><pre><code class="hljs java">org.springframework.core-<span class="hljs-number">3.0</span><span class="hljs-number">.5</span>.RELEASE.jar -> C:\Program Files\Java\jdk1<span class="hljs-number">.8</span><span class="hljs-number">.0</span>\jre\lib\rt.jarorg.springframework.core (org.springframework.core-<span class="hljs-number">3.0</span><span class="hljs-number">.5</span>.RELEASE.jar) -> java.io -> java.lang -> java.lang.annotation -> java.lang.ref -> java.lang.reflect -> java.util -> java.util.concurrent -> org.apache.commons.logging not found -> org.springframework.asm not found -> org.springframework.asm.commons not foundorg.springframework.core.annotation (org.springframework.core-<span class="hljs-number">3.0</span><span class="hljs-number">.5</span>.RELEASE.jar) -> java.lang -> java.lang.annotation -> java.lang.reflect -> java.util</code></pre></li></ul><blockquote><p>关于新特性就先整理到这里, Java8还有很多新的内容没有写进来, 可以在空余时间自己慢慢琢磨.</p></blockquote>]]></content>
<categories>
<category>Java</category>
</categories>
<tags>
<tag>JDK1.8</tag>
</tags>
</entry>
<entry>
<title>搭建Hexo站点并部署GitHub Page/Gitee Page</title>
<link href="/hexo-blog/2019/10/11/Hello-Hexo/"/>
<url>/hexo-blog/2019/10/11/Hello-Hexo/</url>
<content type="html"><">hexo-fluid官方文档</a>, 当然后续也可能出这样的文章来协助整合.</p></blockquote></li></ol>]]></content>
<categories>
<category>博客</category>
</categories>
<tags>
<tag>Hexo</tag>
</tags>
</entry>
</search>
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。
马建仓 AI 助手
