RECENT POSTS

Windows 10 Creators Update インストールエラー 0x8007042B-0x4000D

Computer Windows

Windows 10 Creators Update を適用しようとしてドツボにはまった。(>_<。)

そろそろインストールが終わることだろうと思ったら 0x8007042B-0x4000D というエラーコードが出て元の状態にロールバックされてました。

error

なんだこれは!と思いながら思考停止でもう一度アップデートを試みました。

が、結果は同じ・・・

しかたないからエラーコードを調べてみたら 0x800xxxxx から始まるエラーコードは一般的なオペレーティングシステムエラーを表しているそうです。

Windows アップグレードプロセスに特有なものではないということなので私のシステムに問題が潜んでいるようです。

さらに調べていくと 0x8007042B-0x4000D というエラーコードはファイルシステム、アプリケーション、ドライバーに問題があるそうです。

必要のないサービスを全て止めてインストールができたという記事も見ましたし、ユーザープロファイルの移行が上手くいかなかった例もありました。

ここで冷静になり、このシステムで問題になりそうなところはと考えたところ・・・ ありました!

個人情報ファイルを詰め込んだフォルダに思いっきりセキュリティロックをかけていたのを忘れていました。

一時的にこのフォルダのセキュリティロックを外し Creators Update を適用したところすんなりとアップデートできました。

こんなミスをして大切な時間を無駄にしたかと思うと目から汗がでてきます。

そういうことで、もう寝ます。D’Night! Zzz…

Hatena タグ:

東京西川 エンジェルフロートを買ってみた。

General

私は今まで枕を選ばないタイプだったのですが先日まで愛用していたそば殻枕が痛んできたので枕を買い換えました。

買い換えた枕は睡眠の研究をしているところのお勧めタイプのもので有名なメーカーのものでした。

詰め物はパイプと綿となっており真ん中がへこんで横向きになったときの為に両サイドが高くなっているよくあるような製品でした。

枕の高さも低め、普通、高めと選べるようになっていて私は低めか普通が好みなので普通を選択しました。

このようなタイプの枕は初めてで今までのそば殻枕より快適に眠れるだろうと期待しておりました。

しかし、普通の高さを選んだのにもかかわらず沈み込みが少なく高く感じました。

この手の枕は気道を確保し熟睡できることが売りになっているのですが私には合いませんでした。

朝起きたときに首に違和感があり、慣れてないからだろうと使い続けていると首のこりが酷くなってきました。

そして一週間ほど使った朝に衝撃の事態が発生しました。

なんと、朝起きたら目がぼやけてよく見えなくなりました。

はじめは目やにかゴミでも入ったのかと安易に思ったのですがどうもおかしい・・・

そしてとんでもないことに気付きました。

左目の視界の上半分と左2割くらいがグレーアウトして見えない!

なんだこれは!

私の目は機械で接触不良でも起こしてしまったか? なんてパニックに陥りました。

何度瞬きをしても、目をこすってみてもグレーアウトしてます。

どうしたらいいんだろう・・・と不安になりながら今日は会社を休んで目医者に診てもらいに行こうと思い、とりあえず朝食食べてから連絡をいれようと冷静になり落ち着こうとしました。

早朝から目医者は開いてないからゆっくり見えにくくなった目を酷使するようだけどネットでこのような症状を調べてみることにしました。

調べだして暫くしたらグレーアウトしていた部分がモザイクがかかったように見えだしてやがて正常に見えるようになりました。

時間にして20分くらいの出来事でした。

少し、ほっとしましたが気になるので調べたところ黒内障と症状が似ているようです。

会社を休んで目医者に診てもらいに行こうかと思ったけど休日になるまで様子をみることにしました。

それから一度もこのような症状は出なかったのですが念の為に目医者にいってきました。

検査をいろいろしてもらった結果何も異常は無しということで安心しました。

このような症状は首の血流が悪くなると起こる場合があるそうです。

私の場合思い当たるのは枕を変えて首のこりが酷くなっていたのが原因かもしれません。

あと、ストレスや睡眠不足でもなる場合があるそうです。

とりあえず恐ろしい病でなくてよかった!

さて、買ったばかりの枕なのですがこんなことがあるともう使いたくなくなります。

前に使っていたそば殻の枕と同じようなものを購入しようかと思ったのですが、なんか負けた感が漂うのでここは人気と評価の高い枕を調べて購入することにしました。

いろいろ調べたところ「東京西川 エンジェルフロート」という低反発っぽい柔らかそうな枕があることを知りました。

低反発枕が話題になった頃に購入して使ったことがあるのですが冬は良かったのですが夏は蒸れて暑くて駄目でした。

エンジェルフロートはたくさんの空気孔を設けることにより通気性を向上させ蒸れ対策をされてます。

高さの調節も4分割のウレタンシートで調節できます。

とは言え、低め、ふつう、高めと3種類はじめからラインナップされているので至れり尽くせりです。

「天使のほっぺの、やさしいタッチ。」

「表面はやさしいタッチ、ベースはしっかりサポート」

このうたい文句が枕なんてどうでもいいと思っていた私に「この枕で寝てみたい」と思わせてくれました。

ただ、お値段が・・・高い たかが枕にこんなにお金を使いたくないなぁな・・なんて思ったりもしましたが今回のような怖い思いは二度としたくないので購入しました。

1

2

このような綺麗な化粧箱にはいってます。

実物はこのように見た目はごくありふれた感じです。

3

だけど触ってみると「おおっ!」と感動します。

天使のほっぺと表現するだけのことはあって上品な柔らかさです。

また肌触りが良い!

枕カバーを付けずにこのまま使いたいくらいです。

ただ、この枕のサイズが特殊で 33 X 60 X10 センチです。

奥行きが狭いので頭のサイズが大きめの人は不向きかもしれません。

それよりもこの枕に合う枕カバーが見当たらない。

専用側地と対応枕カバーがあるのですがどちらも高価です。

 

枕カバーは少しだけ安価なものもあります。

私は専用側地と対応枕カバーも購入することにしましたがこれらは届くまで時間がかかるようなのでニトリの「ピッタリニットまくらカバー」というリーズナブルな商品を使うことにしました。

4

やっぱり専用品でないのでピッタリとまではいきませんね。

肌触りは悪くないのですが安っぽいTシャツを巻いたような感じになってしまいました。

専用枕カバーが届くまではこれでいきます。

肝心の枕の使い心地は良好です。(^_^)

枕の高さは普通を選んだので10センチですが沈み込みがちょうど良い具合で満足です。

やはり凝った作りのまくらはそれだけの価値がありますね。

それでは、 G’night!

Zzz…


Java SE 9 の予習 その2

Java

Java SE 9 の予習 その2です。

Java SE 8 でインタフェースにデフォルトメソッドと静的メソッドが実装できるようになりました。

しかし、使い勝手はお世辞にも良いとは言えませんでした。

Java でプログラムを組む上で重要なのはインタフェースの設計にあるからです。

デフォルトメソッドが実装された理由は Java SE 8 でインタフェースにメソッドを追加すると実装クラスに与える影響が大きく既存のプログラムに破綻を生じるケースも考えられたからです。

そんな事情からインタフェースにデフォルトメソッドが追加され実装がインタフェースにされるようになりました。

Java SE 9 からはさらにプライベートメソッドが実装できるようになります。

これでデフォルトメソッドの実装内容の非公開にしたい所をインタフェース経由で公開してしまうようなことは無くなります。

とりあえずプログラムを組んで動作確認をしてみました。

 

このプログラムの実行結果は次のようになります。

I ate strawberry cake. It was very delicious.
I ate tiramisu cake.
I will eat another TiramisuCake.
I ate cheese cake.
I will eat another cheese cake.
I ate chocolate cake.

Java SE 9 ではこのような小さな改良がたくさんあるようです。(^_^)

Java SE 9 の予習

Hatena タグ:

Java SE 9 の予習

Java

今日は私の○X回目の誕生日です。

今年は忘れられずにお祝いのプレゼントまでいただきました。(^_^)

いくつになっても誕生日を祝ってもらえるのは嬉しいものです。

と言うわけでお誕生日記念として今年の夏にリリース予定の Java SE 9 の予習をはじめます。

Java SE 9 と言えば Project Jigsaw, Project Kulla (JShell) が目玉となっています。

これらはこれから日本語での情報もたくさん出てくると思うので後回しとします。(既に最新Java情報局で記事があります。)

故に Java SE 9 を使うのであれば必要最低限これだけは覚えておきたいことを自分用メモとして載せておきます。

完全に自分用のメモです!

static <E> List<E> of()

Returns an immutable list containing zero elements. See Immutable List Static Factory Methods for details.

Type Parameters:
E – the List’s element type

Returns:
an empty List
 

public Stream<T> stream()

If a value is present, returns a sequential Stream containing only that value, otherwise returns an empty Stream.

API Note:
This method can be used to transform a Stream of optional elements to a Stream of present value elements:
 
     Stream<Optional<T>> os = ..
     Stream<T> s = os.flatMap(Optional::stream)
 
Returns:
the optional value as a Stream

 

static <T> Stream<T> ofNullable(T t)

Returns a sequential Stream containing a single element, if non-null, otherwise returns an empty Stream.

Type Parameters:
T – the type of stream elements

Parameters:
t – the single element

Returns:
a stream with a single element if the specified element is non-null, otherwise an empty stream

 

public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction)

If a value is present, performs the given action with the value, otherwise performs the given empty-based action.

Parameters:
action – the action to be performed, if a value is presentemptyAction – the empty-based action to be performed, if no value is present

Throws:
NullPointerException – if a value is present and the given action is null, or no value is present and the given empty-based action is null.

 

public Optional<T> or(Supplier<? extends Optional<? extends T>> supplier)

If a value is present, returns an Optional describing the value, otherwise returns an Optional produced by the supplying function.

Parameters:
supplier – the supplying function that produces an Optional to be returned

Returns:
returns an Optional describing the value of this Optional, if a value is present, otherwise an Optional produced by the supplying function.

Throws:
NullPointerException – if the supplying function is null or produces a null result

 

public static <T,A,R> Collector<T,?,R> filtering(Predicate<? super T> predicate, Collector<? super T,A,R> downstream)

Adapts a Collector to one accepting elements of the same type T by applying the predicate to each input element and only accumulating if the predicate returns true.

API Note:
The filtering() collectors are most useful when used in a multi-level reduction, such as downstream of a groupingBy or partitioningBy. For example, given a stream of Employee, to accumulate the employees in each department that have a salary above a certain threshold:
 
Map<Department, Set<Employee>> wellPaidEmployeesByDepartment
   = employees.stream().collect(
     groupingBy(Employee::getDepartment,
                filtering(e -> e.getSalary() > 2000,
                          toSet())));
 
A filtering collector differs from a stream’s filter() operation. In this example, suppose there are no employees whose salary is above the threshold in some department. Using a filtering collector as shown above would result in a mapping from that department to an empty Set. If a stream filter() operation were done instead, there would be no mapping for that department at all.

Type Parameters:
T – the type of the input elements
A – intermediate accumulation type of the downstream collector
R – result type of collector

Parameters:
predicate – a predicate to be applied to the input elements
downstream – a collector which will accept values that match the predicate

Returns:
a collector which applies the predicate to the input elements and provides matching elements to the downstream collector

 

public static <T,U,A,R> Collector<T,?,R> flatMapping(Function<? super T,? extends Stream<? extends U>> mapper, Collector<? super U,A,R> downstream)

Adapts a Collector accepting elements of type U to one accepting elements of type T by applying a flat mapping function to each input element before accumulation. The flat mapping function maps an input element to a stream covering zero or more output elements that are then accumulated downstream. Each mapped stream is closed after its contents have been placed downstream. (If a mapped stream is null an empty stream is used, instead.)

API Note:
The flatMapping() collectors are most useful when used in a multi-level reduction, such as downstream of a groupingBy or partitioningBy. For example, given a stream of Order, to accumulate the set of line items for each customer:
 
Map<String, Set<LineItem>> itemsByCustomerName
   = orders.stream().collect(
     groupingBy(Order::getCustomerName,
                flatMapping(order -> order.getLineItems().stream(),
                            toSet())));
 
Type Parameters:
T – the type of the input elements
U – type of elements accepted by downstream collector
A – intermediate accumulation type of the downstream collector
R – result type of collector

Parameters:
mapper – a function to be applied to the input elements, which returns a stream of results
downstream – a collector which will receive the elements of the stream returned by mapper

Returns:
a collector which applies the mapping function to the input elements and provides the flat mapped results to the downstream collector

 

default Stream<T> takeWhile(Predicate<? super T> predicate)

Returns, if this stream is ordered, a stream consisting of the longest prefix of elements taken from this stream that match the given predicate. Otherwise returns, if this stream is unordered, a stream consisting of a subset of elements taken from this stream that match the given predicate.
 
If this stream is ordered then the longest prefix is a contiguous sequence of elements of this stream that match the given predicate. The first element of the sequence is the first element of this stream, and the element immediately following the last element of the sequence does not match the given predicate.

If this stream is unordered, and some (but not all) elements of this stream match the given predicate, then the behavior of this operation is nondeterministic; it is free to take any subset of matching elements (which includes the empty set).

Independent of whether this stream is ordered or unordered if all elements of this stream match the given predicate then this operation takes all elements (the result is the same as the input), or if no elements of the stream match the given predicate then no elements are taken (the result is an empty stream).

This is a short-circuiting stateful intermediate operation.

API Note:
While takeWhile() is generally a cheap operation on sequential stream pipelines, it can be quite expensive on ordered parallel pipelines, since the operation is constrained to return not just any valid prefix, but the longest prefix of elements in the encounter order. Using an unordered stream source (such as generate(Supplier)) or removing the ordering constraint with BaseStream.unordered() may result in significant speedups of takeWhile() in parallel pipelines, if the semantics of your situation permit. If consistency with encounter order is required, and you are experiencing poor performance or memory utilization with takeWhile() in parallel pipelines, switching to sequential execution with BaseStream.sequential() may improve performance.

Implementation Requirements:
The default implementation obtains the spliterator of this stream, wraps that spliterator so as to support the semantics of this operation on traversal, and returns a new stream associated with the wrapped spliterator. The returned stream preserves the execution characteristics of this stream (namely parallel or sequential execution as per BaseStream.isParallel()) but the wrapped spliterator may choose to not support splitting. When the returned stream is closed, the close handlers for both the returned and this stream are invoked.

Parameters:
predicate – a non-interfering, stateless predicate to apply to elements to determine the longest prefix of elements.

Returns:
the new stream

 

default Stream<T> dropWhile(Predicate<? super T> predicate)

Returns, if this stream is ordered, a stream consisting of the remaining elements of this stream after dropping the longest prefix of elements that match the given predicate. Otherwise returns, if this stream is unordered, a stream consisting of the remaining elements of this stream after dropping a subset of elements that match the given predicate.
 
If this stream is ordered then the longest prefix is a contiguous sequence of elements of this stream that match the given predicate. The first element of the sequence is the first element of this stream, and the element immediately following the last element of the sequence does not match the given predicate.

If this stream is unordered, and some (but not all) elements of this stream match the given predicate, then the behavior of this operation is nondeterministic; it is free to drop any subset of matching elements (which includes the empty set).

Independent of whether this stream is ordered or unordered if all elements of this stream match the given predicate then this operation drops all elements (the result is an empty stream), or if no elements of the stream match the given predicate then no elements are dropped (the result is the same as the input).

This is a stateful intermediate operation.

API Note:
While dropWhile() is generally a cheap operation on sequential stream pipelines, it can be quite expensive on ordered parallel pipelines, since the operation is constrained to return not just any valid prefix, but the longest prefix of elements in the encounter order. Using an unordered stream source (such as generate(Supplier)) or removing the ordering constraint with BaseStream.unordered() may result in significant speedups of dropWhile() in parallel pipelines, if the semantics of your situation permit. If consistency with encounter order is required, and you are experiencing poor performance or memory utilization with dropWhile() in parallel pipelines, switching to sequential execution with BaseStream.sequential() may improve performance.

Implementation Requirements:
The default implementation obtains the spliterator of this stream, wraps that spliterator so as to support the semantics of this operation on traversal, and returns a new stream associated with the wrapped spliterator. The returned stream preserves the execution characteristics of this stream (namely parallel or sequential execution as per BaseStream.isParallel()) but the wrapped spliterator may choose to not support splitting. When the returned stream is closed, the close handlers for both the returned and this stream are invoked.

Parameters:
predicate – a non-interfering, stateless predicate to apply to elements to determine the longest prefix of elements.

Returns:
the new stream

 

static IntStream iterate(int seed, IntPredicate hasNext, IntUnaryOperator next)

Returns a sequential ordered IntStream produced by iterative application of the given next function to an initial element, conditioned on satisfying the given hasNext predicate. The stream terminates as soon as the hasNext predicate returns false.
 
IntStream.iterate should produce the same sequence of elements as produced by the corresponding for-loop:

     for (int index=seed; hasNext.test(index); index = next.applyAsInt(index)) {
         …
     }
 

The resulting sequence may be empty if the hasNext predicate does not hold on the seed value. Otherwise the first element will be the supplied seed value, the next element (if present) will be the result of applying the next function to the seed value, and so on iteratively until the hasNext predicate indicates that the stream should terminate.

The action of applying the hasNext predicate to an element happens-before the action of applying the next function to that element. The action of applying the next function for one element happens-before the action of applying the hasNext predicate for subsequent elements. For any given element an action may be performed in whatever thread the library chooses.

Parameters:
seed – the initial element
hasNext – a predicate to apply to elements to determine when the stream must terminate.
next – a function to be applied to the previous element to produce a new element

Returns:
a new sequential IntStream

 

static <T> Stream<T> iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next)

Returns a sequential ordered Stream produced by iterative application of the given next function to an initial element, conditioned on satisfying the given hasNext predicate. The stream terminates as soon as the hasNext predicate returns false.
 
Stream.iterate should produce the same sequence of elements as produced by the corresponding for-loop:

     for (T index=seed; hasNext.test(index); index = next.apply(index)) {
         …
     }
 

The resulting sequence may be empty if the hasNext predicate does not hold on the seed value. Otherwise the first element will be the supplied seed value, the next element (if present) will be the result of applying the next function to the seed value, and so on iteratively until the hasNext predicate indicates that the stream should terminate.

The action of applying the hasNext predicate to an element happens-before the action of applying the next function to that element. The action of applying the next function for one element happens-before the action of applying the hasNext predicate for subsequent elements. For any given element an action may be performed in whatever thread the library chooses.

Type Parameters:
T – the type of stream elements

Parameters:
seed – the initial element
hasNext – a predicate to apply to elements to determine when the stream must terminate.
next – a function to be applied to the previous element to produce a new element

Returns:
a new sequential Stream

 

API ドキュメントが英語しかないのが残念(>_<)

正式リリースされる頃には日本語版が出ることを祈ろう!

Java SE 8 からの痒いところに手が届いたようなアップデートだけどかなり便利になる。

なぜ初めからこうしなかったんだろうと思うほどに。

でも zip, pair はまだ無いまま・・・

Java SE 10 まで待つことになるのか必要ないと判断されたのか?

他にもいろいろ細かいところが良くなっているようだから正式リリースが楽しみですね!

Hatena タグ:

A-2 フライトジャケット 買っちまったぜ!

General

私はミリオタではないのですがフライトジャケットは好きでいつか買おうと思っていました。

もちろんレプリカですが数多くのブランドからリリースされていて一部の愛好者から未だに絶大な人気があります。

なので慌てて購入しなくても無くなるような代物じゃ無いと思いずっと購入せずにいました。

個人的な事情から私の趣味であるバイクに乗ることができなくなり、ガレージで愛車 DUCATI は眠ったままとなっています。

バイクに乗っているときは革製品のツナギやジャンパー、パンツ、ブーツなどを購入していて革製品の独特の質感に酔いしれていました。

そこで、清水の舞台から飛び降りたつもりでついにトイズマッコイの A-2フライトジャケットを買っちゃいました!

a-2

身長 172cm 体重 69kg の私はサイズ 38 でジャストフィットでした。

すいません。嘘です。昨年の春から約8kg 体重が増えてしまってお腹がかなり出てしまいました。

せっかく格好いい A-2 を着るのにお腹ががが…

つまりウエストを細くすればジャストフィットです!

まぁ、一サイズ大きな 40 を選んでもお腹が細くなることはなくフライトジャケットなのにユルユルになってしまって格好悪くなってしまいます。

これは何が何でも 8kg の原料を達成せよとの神様からのお告げかもしれません。

ちなみに私が購入したモデルは映画「大脱走」でスティーブマックイーンが演じるV.ヒルツ大尉が着用していた A-2 モデルです。

ノーマルモデルでも良かったのですがサイズ 38 が売り切れていました。

このモデルはライニングにヒルツ大尉の認識証番号とネームが押印されています。

ネームプレートもついてます。もちろん V.HILTS と打刻文字が入ってます。このネームプレートは表の革から裏のライニングにまで縫い付けてあります。

ちょっと恥ずかしいですね。(*^_^*) こうなったら田舎のプレスリーじゃなく、田舎のスティーブマックイーンを目指そうかな (^_^;

左肩のAAFマークは初めからビンテージ感を出すためか所々擦れて剥げたように加工されています。

ジッパーも特別でベル型TALONでひし形スライダーを採用しています。これレプリカでは珍しい懲り方らしいです。

しかしスチーブマックイーンモデルとは言え、A-2 には変わりありません。

着心地は馬革は堅くて良くないと聞きますがこのモデルはそこまで堅くはないようです。

新品なのに結構動きやすい。1.1mm という革の厚さの効果なんだろうか。と言っても良質の牛革製品と比べると(過去に着たバイク用製品)若干堅いかなってくらい。

これは着込むことによって体に馴染んでくるであろうから問題はない。

日本で売られている冬用のジャケットなんかのリブと比べると袖と裾のリブは薄めとなっています。

これはちょっと驚きでフライトジャケットなんだから厚めで丈夫そうなリブだろうとずっと思い込んでいました。

AVIREX の MA-1 のリブと比べるとやはり薄めの作りになっています。

全体的な作りは価格相応のしっかりした丁寧な作りで上質な馬革が贅沢に使われています。

ジッパーの動きが滑らかでないのとリブの耐久性がどれくらいなのか不安要素もありますが、これらは消耗品なので購入したお店がリペアしてくれるそうなので心配はないでしょう。

ちなみに肌着の上に長袖 T シャツでジャストフィットでした。(スウェット着てもなんとかいけそうです。)

タイトなジャケットなので厚着した上に羽織るのはちょっときつそうですね。

そもそもライトゾーン用のフライトジャケットですから割り切りは必要です。

幸い私が住んでいるところは年に一,二回雪が降るか降らないかというような温暖(?)なところなのでよっぽど寒い日以外は活躍してくれるかもしれません。

最後に重要なお知らせ

家族の見解は着丈が短くておかしい。ポケットが機能的で無い。なんで牛革じゃなく馬革なの?税抜き価格が 20万円なんて信じられない。などなど…

説明しても納得いかないうえに「せっかくのジャケットもそのお腹では猫に小判、豚に真珠だよ。」と言われた。

MA-1 買ったときも同じようなこと言われたがお腹のことは言われなかった。(もう、あきらめたよ)

おまえらに A-2 の良さを理解しろとは言わない。

ただ、  ただ、   お腹をせめるな!

以上、今年一発目の散財記録でした。