JDK1.8中的Stream详解 2018-07-13|开发总结|Java-Stream

别处看到的文章，对其再次进行了整理。收获很多。

Stream简介

Stream 作为 Java 8 的一大亮点，它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念。它也不同于 StAX 对 XML 解析的 Stream，也不是 Amazon Kinesis 对大数据实时处理的 Stream。Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation)。Stream API 借助于同样新出现的 Lambda 表达式，极大的提高编程效率和程序可读性。同时它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用 fork/join 并行方式来拆分任务和加速处理过程。通常编写并行代码很难而且容易出错, 但使用 Stream API 无需编写一行多线程的代码，就可以很方便地写出高性能的并发程序。所以说，Java 8 中首次出现的 java.util.stream 是一个函数式语言+多核时代综合影响的产物。

什么是聚合操作

在传统的J2EE应用中，Java代码经常不得不依赖于关系型数据库的聚合操作来完成某些操作，诸如：

客户每月平均消费金额
最昂贵的在售商品
本周完成的有效订单（排除了无效的）
取十个数据样本作为首页推荐

但在当今这个数据大爆炸的时代，在数据来源多样化、数据海量化的今天，很多时候不得不脱离RDBMS,或者以底层返回的数据为基础进行更上层的数据统计。而Java的集合API中，仅仅有极少量的辅助性方法，更多的时候是程序员需要用Iterator来遍历集合，完成相关的聚合应用逻辑。这是一种远不够高效、笨拙的方法。在Java7中，如果要发现type为grocery的所有交易，然后返回以交易值降序排序好的交易ID集合，我们需要这样写：

Java7的排序、取值实现

List<Transaction> groceryTransactions = new Arraylist<>();

for(Transaction t: transactions){

 if(t.getType() == Transaction.GROCERY){

 groceryTransactions.add(t);

 }

}

Collections.sort(groceryTransactions, new Comparator(){

 public int compare(Transaction t1, Transaction t2){

 return t2.getValue().compareTo(t1.getValue());

 }

});

List<Integer> transactionIds = new ArrayList<>();

for(Transaction t: groceryTransactions){

 transactionsIds.add(t.getId());

}

Java8的排序、取值实现

Java8中使用Stream，代码更加简洁易读，而且使用并发模式，程序执行速度更快。

List<Integer> transactionsIds = transactions.parallelStream().

 filter(t -> t.getType() == Transaction.GROCERY).

 sorted(comparing(Transaction::getValue).reversed()).

 map(Transaction::getId).

 collect(toList());

Stream总览

什么是流

Stream不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算的，它更像一个高级版本的Iterator。原始版本的Iterator，用户只能显式地一个一个遍历元素并对其执行某些操作；高级版本的Stream，用户只要给出需要对其包含的元素执行什么操作，比如“过滤掉长度大于10的字符串”、“获取每个字符串的首字母”等，Stream会隐式地在内部进行遍历，做出相应的数据转换。

Stream就如同一个迭代器（Iterator），单向，不可往复，数据只能遍历一次，遍历过一次后即用尽了，就好比流水从面前流过，一去不复返。

而和迭代器又不同的是，Stream可以并行化操作，迭代器只能命令式地、串行化操作。顾名思义，当使用串行方法去遍历时，每个item读完后再读下一个item。而使用并行去遍历时，数据会被分成多段，其中每一个都在不同的线程中处理，然后将结果一起输出。Stream的并行操作依赖于Java7中引入的Fork/Join框架（JSR166y）来拆分任务和加速处理过程。Java的并行API演变历程基本如下：

1.0-1.4中的java.lang.Thread
5.0中的java.util.concurrent
6.0中的Phasers等
7.0中的Fork/Join框架
8.0中的Lambda

Stream的另外一大特点是，数据源本身可以是无限的。*

流的构成

当我们使用一个流的时候，通常包括三个基本步骤：

获取一个数据源（source） → 数据转换 → 执行操作获取想要的结果，每次转换原有Stream对象不改变，返回一个新的Stream对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道，如下图所示：

流管道（Stream Pipeline）的构成

有多种方式生成 Stream Source：

从Collection和数组
- Collection.stream()
- Collection.parallelStream()
- Arrays.stream(T array) or Stream.of()
从BufferedReader
- java.io.BufferedReader.lines()\
静态工厂
- java.util.stream.IntStream.range()
- java.nio.file.Files.walk()
自己构建
- java.util.Spliterator
其它
- Random.ints()
- BitSet.stream()
- Pattern.splitAsStream(java.lang.CharSequence)
- JarFile.stream()

流的操作类型分为两种：

Intermediate：一个流可以后面跟随零个或多个intermediate操作。其目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。这类操作都是惰性化的（lazy），就是说，仅仅调用到这类方法，并没有真正开始流的遍历。
Terminal：一个流只能有一个terminal操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作。Terminal操作的执行，才会真正开始流的遍历，并且会生成一个结果，或者一个side effect。

在对于一个Stream进行多次转换操作（Intermediate操作），每次都对Stream的每个元素进行转换，而且是执行多次，这样时间复杂度就是N（转换次数）个for循环里把所有操作都做掉的总和么？其实不是这样的，转换操作都是lazy的，多个转换操作只会在Terminal操作的时候融合起来，一次循环完成。我们可以这样简单的理解，Stream里有个操作函数的集合，每次转换操作就是把转换函数放入这个集合中，在Terminal操作的时候循环Stream对应的集合，然后对每个元素执行所有的函数。

还有一种操作被称为short-circuiting。用以指：

对于一个intermediate操作，如果它接收的是一个无限大（infinite/unbounded）的Stream，但返回一个有限的新Stream。
对于一个terminal操作，如果它接受的是一个无限大的Stream，但能在有限的时间计算出结果。

当操作一个无限大的Stream，而又希望在有限时间内完成操作，则在管道内拥有一个short-circuiting操作是必要非充分条件。

一个流操作的示例

int sum = widgets.stream()

.filter(w -> w.getColor() == RED)

.mapToInt(w -> w.getWeight())

.sum();

stream()获取当前小物件的source,filter和mapToInt为intermediate操作，进行数据筛选和转换，最后一个sum()为terminal操作，对符合条件的全部小物件作重量求和。

流的使用详解

简单说，对Stream的使用就是实现一个filter-map-reduce过程，产生一个最终结果，或者导致一个副作用（side effect）。

流的构造与转换

下面提供最常见的几种构造Stream的样例。

构造流的几种常见方法

// 1. Individual values

Stream stream = Stream.of("a", "b", "c");

// 2. Arrays

String [] strArray = new String[] {"a", "b", "c"};

stream = Stream.of(strArray);

stream = Arrays.stream(strArray);

// 3. Collections

List<String> list = Arrays.asList(strArray);

stream = list.stream();

需要注意的是，对于基本数值型，目前有三种对应的包装类型Stream：

IntStream、LongStream、DoubleStream。当然我们也可以用Stream、Stream、Stream，但是boxing和unboxing会很耗时，所以特别为这三种基本数值型提供了对应的Stream。

Java8中还没有提供其它数值型Stream，因为这将导致扩增的内容较多。而常规的数值型聚合运算可以通过上面三种Stream进行。

数据流的构造

IntStream.of(new int[]{1, 2, 3}).forEach(System.out::println);

IntStream.range(1, 3).forEach(System.out::println);

IntStream.rangeClosed(1, 3).forEach(System.out::println);

流转换为其它数据结构

// 1. Array

String[] strArray1 = stream.toArray(String[]::new);

// 2. Collection

List<String> list1 = stream.collect(Collectors.toList());

List<String> list2 = stream.collect(Collectors.toCollection(ArrayList::new));

Set set1 = stream.collect(Collectors.toSet());

Stack stack1 = stream.collect(Collectors.toCollection(Stack::new));

// 3. String

String str = stream.collect(Collectors.joining()).toString();

注：一个Stream只可以使用一个，以上示例只是为了代码简洁而重复使用数次。

流的操作

接下来，当把一个数据结构包装成Stream后，就要开始对里面的元素进行各类操作了。常见的操作可以归类如下：

Intermediate：map(mapToint，flatMap等)、filter、distinct、sorted、peek、limit、skip、parallel、sequential、unordered
Terminal：forEach、forEachOrdered、toArray、reduce、collect、min、max、count、anyMatch、allMatch、noneMatch、findFirst、findAny、iterator
Short-circuiting：anyMatch、allMatch、noneMatch、findFirst、findAny、limit

接下来下面看一下Stream的比较典型用法。

map/flatMap

先来看map。如果熟悉scala这类函数式语言，对这个方法应该很了解，它的作用就是把input Stream的每一个元素，映射成output Stream的另外一个元素。

转换大写

List<String> output = wordList.stream().

map(String::toUpperCase).

collect(Collectors.toList());

平方数

List<Integer> nums = Arrays.asList(1, 2, 3, 4);

List<Integer> squareNums = nums.stream().

map(n -> n * n).

collect(Collectors.toList());

从上面例子可以看出，map生成的是个1:1映射，每个输入元素，都按照规则转换成为另外一个元素。还有一些场景，是一对多映射关系的，这时需要flatMap。

一对多

Stream<List<Integer>> inputStream = Stream.of(

 Arrays.asList(1),

 Arrays.asList(2, 3),

 Arrays.asList(4, 5, 6)

 );

Stream<Integer> outputStream = inputStream.

flatMap((childList) -> childList.stream());

flatMap把input Stream中的层级结构扁平化，就是将最底层元素抽出来放到一起，最终output的新Stream里面已经没有List了，都是直接的数字。

filter

filter对原始Stream进行某项测试，通过测试的元素被留下来生成一个新Stream。

留下偶数

Integer[] sixNums = {1, 2, 3, 4, 5, 6};

Integer[] evens =

Stream.of(sixNums).filter(n -> n%2 == 0).toArray(Integer[]::new);

经过条件“被2整除”的filter，剩下的数字为{2,4,6}。

把单词挑出来

List<String> output = reader.lines().

flatMap(line -> Stream.of(line.split(REGEXP))).

filter(word -> word.length() > 0).

collect(Collectors.toList());

这段代码首先把每行的单词用flatMap整理到新的Stream，然后保留长度不为0的，就是整篇文章中的所有单词了。

forEach

forEach方法接收一个Lambda表达式，然后在Stream的每一个元素上执行该表达式。

打印姓名（forEach和pre-java8的对比）

// Java 8

roster.stream()

 .filter(p -> p.getGender() == Person.Sex.MALE)

 .forEach(p -> System.out.println(p.getName()));

// Pre-Java 8

for (Person p : roster) {

 if (p.getGender() == Person.Sex.MALE) {

 System.out.println(p.getName());

 }

}

对一个人员集合遍历，找出男性并打印姓名。可以看出来，forEach是为Lambda而设计的，保持了最紧凑的风格。而且lambda表达式本身是可以重用的，非常方便。当需要为多核系统优化时，可以parallelStream().forEach()，只是此时原有元素的次序没法保证，并行的情况下将改变串行时操作的行为，此时forEach本身的实现不需要调整，而Java8以前的for循环code可能需要加入额外的多线程逻辑。

但一般认为，forEach和常规for循环的差异不涉及到性能，它们仅仅是函数式风格与传统Java风格的差别。

另外一点需要注意，forEach是terminal操作，因此它执行后，Stream的元素就被“消费”掉了，你无法对一个Stream进行两次terminal运算。下面的代码是错误的：

1
2
3

stream.forEach(element -> doOneThing(element));

stream.forEach(element -> doAnotherThing(element));

相反，具有相似功能的intermediate操作peek可以达到上述目的。如下是出现在该api javadoc上的一个示例。

peek 对每个元素执行操作并返回一个新的 Stream

Stream.of("one", "two", "three", "four")

.filter(e -> e.length() > 3)

.peek(e -> System.out.println("Filtered value: " + e))

.map(String::toUpperCase)

.peek(e -> System.out.println("Mapped value: " + e))

.collect(Collectors.toList());

forEach不能修改自己包含的本地变量值，也不能用break/return之类的关键字提前结束循环。

findFirst

这是一个terminal兼short-circuiting操作，它总是返回Stream的第一个元素，或者空。

这里比较重点的是它的返回值类型：Optional。这也是一个模仿Scala语言中的概念，作为一个容器，它可能含有某值，或者不包含。使用它的目的是尽可能避免NullPointerException。

Optional的两个用例

String strA = " abcd ", strB = null;

print(strA);

print("");

print(strB);

getLength(strA);

getLength("");

getLength(strB);

public static void print(String text) {

 // Java 8

 Optional.ofNullable(text).ifPresent(System.out::println);

 // Pre-Java 8

 if (text != null) {

 System.out.println(text);

 }

 }

public static int getLength(String text) {

 // Java 8

return Optional.ofNullable(text).map(String::length).orElse(-1);

 // Pre-Java 8

// return if (text != null) ? text.length() : -1;

 };

在更复杂的if(xx != null)的情况中，使用Optional代码的可读性更好，而且它提供的是编译时检查，能极大的降低NPE这种Runtime Exception对程序的影响，或者迫使程序员更早的在编码阶段处理空值问题，而不是留到运行时再发现和调试。

Stream中的findAny、max/min、reduce等方法返回Optional值。还有例如IntStream.average()返回Optional Double等等。

reduce

这个方法的主要作用是把Stream元素组合起来。它提供一个起始值（种子），然后依照运算规则（BinaryOperator），和前面Stream的第一个、第二个、第n个元素组合。从这个意义上说，字符串拼接、数值的sum、min、max、average都是特殊的reduce。例如Stream的sum就相当于

1	Integer sum = integers.reduce(0,(a,b) -> a+b);

或

1	Integer sum = integers.reduce(0,Integer::sum);

也有没有起始值的情况，这时会把Stream的前面两个元素组合起来，返回的是Optional。

reduce的用例

// 字符串连接，concat = "ABCD"

String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat);

// 求最小值，minValue = -3.0

double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min);

// 求和，sumValue = 10, 有起始值

int sumValue = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);

// 求和，sumValue = 10, 无起始值

sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();

// 过滤，字符串连接，concat = "ace"

concat = Stream.of("a", "B", "c", "D", "e", "F").

 filter(x -> x.compareTo("Z") > 0).

 reduce("", String::concat);

上面代码例如第一个示例的reduce(),第一个参数（空白字符）即为起始值，第二个参数（String::concat）为BinaryOperator。这类有起始值的reduce()都返回具体的对象。而对于第四个示例没有起始值的reduce(),由于可能没有足够的元素，返回的是Optional，请留意这个区间。

limit/skip

limit返回Stream的前面n个元素；skip则是扔掉前n个元素（它是由一个叫subStream的方法改名而来）。

limit和skip对运行次数的影响

public void testLimitAndSkip() {

 List<Person> persons = new ArrayList();

 for (int i = 1; i <= 10000; i++) {

 Person person = new Person(i, "name" + i);

 persons.add(person);

 }

List<String> personList2 = persons.stream().

map(Person::getName).limit(10).skip(3).collect(Collectors.toList());

System.out.println(personList2);

}

private class Person {

 public int no;

 private String name;

 public Person (int no, String name) {

 this.no = no;

 this.name = name;

 }

 public String getName() {

 System.out.println(name);

 return name;

 }

}

结果为：

name1

name2

name3

name4

name5

name6

name7

name8

name9

name10

[name4, name5, name6, name7, name8, name9, name10]

这是一个有10000个元素的Stream，但在short-circuiting操作limit和skip的作用下，管道中map操作指定的getName()方法的执行次数为limit所限定的10次，而最终返回结果在跳过前3个元素后只有后面7个返回。

还有一种情况是limit/skip无法达到short-circuiting目的地，就是把它们放在Stream的排序操作后，原因跟sorted这个intermediate操作有关：此时系统并不知道Stream排序后的次序如何，所以sorted中的操作看上去就像完全没有被limit或者skip一样。

limit和skip对sorted后的运行次数无影响

List<Person> persons = new ArrayList();

 for (int i = 1; i <= 5; i++) {

 Person person = new Person(i, "name" + i);

 persons.add(person);

 }

List<Person> personList2 = persons.stream().sorted((p1, p2) ->

p1.getName().compareTo(p2.getName())).limit(2).collect(Collectors.toList());

System.out.println(personList2);

首先对5个元素的Stream排序，然后进行limit操作。输出结果为：

name2

name1

name3

name2

name4

name3

name5

name4

[stream.StreamDW$Person@816f27d, stream.StreamDW$Person@87aac27]

即虽然最后的返回元素数量是2，但整个管道中的sorted表达式执行次数没有像之前示例一样相应减少。

最后有一种需要注意的是，对一个parallel的Stream管道来说，如果其元素是有序的，那么limit操作的成本会比较大，因为它的返回对象必须是前n个也有一样次序的元素。取而代之的策略是取消元素间的次序，或者不要用parallel Stream。

sorted

对Stream的排序通过sorted进行，它比数组的排序更强之处在于你可以首先对Stream进行各类map、filter、limit、skip甚至distinct来减少元素数量后，再排序，这能帮助程序明显缩短执行时间。对之前示例可进行优化：

排序前进行 limit 和 skip

List<Person> persons = new ArrayList();

 for (int i = 1; i <= 5; i++) {

 Person person = new Person(i, "name" + i);

 persons.add(person);

 }

List<Person> personList2 = persons.stream().limit(2).sorted((p1, p2) -> p1.getName().compareTo(p2.getName())).collect(Collectors.toList());

System.out.println(personList2);

结果为：

name2

name1

[stream.StreamDW$Person@6ce253f1, stream.StreamDW$Person@53d8d10a]

当然这种优化是有business logic上的局限性的：即不要求排序后再取值

min/max/distinct

min和max的功能也可以通过对Stream元素先排序，再findFirst来实现，但前者的性能会更好，为O(n)，而sorted的成本是O(n log n)。同时它们作为特殊的reduce方法被独立出来也是因为求最大最小值是很常见的操作。

找出最长一行的长度

BufferedReader br = new BufferedReader(new FileReader("c:\\SUService.log"));

int longest = br.lines().

 mapToInt(String::length).

 max().

 getAsInt();

br.close();

System.out.println(longest);

找出全文的单词，转小写，并排序

List<String> words = br.lines().

 flatMap(line -> Stream.of(line.split(" "))).

 filter(word -> word.length() > 0).

 map(String::toLowerCase).

 distinct().

 sorted().

 collect(Collectors.toList());

br.close();

System.out.println(words);

Match

Stream有三个match方法，从语义上说：

allMatch：Stream中全部元素符合传入的predicate，返回true
anyMatch：Stream中只要有一个元素符合传入的predicate，返回true
noneMatch：Stream中没有一个元素符合传入的predicate，返回true

它们都不是要遍历全部元素才能返回结果。例如allMatch只要一个元素不满足条件，就skip剩下的所有元素，返回false。

使用Match

List<Person> persons = new ArrayList();

persons.add(new Person(1, "name" + 1, 10));

persons.add(new Person(2, "name" + 2, 21));

persons.add(new Person(3, "name" + 3, 34));

persons.add(new Person(4, "name" + 4, 6));

persons.add(new Person(5, "name" + 5, 55));

boolean isAllAdult = persons.stream().

 allMatch(p -> p.getAge() > 18);

System.out.println("All are adult? " + isAllAdult);

boolean isThereAnyChild = persons.stream().

 anyMatch(p -> p.getAge() < 12);

System.out.println("Any child? " + isThereAnyChild);

输出结果：

1
2
3

All are adult? false

Any child? true

进阶：自己生成流

Stream.generate

通过实现Supplier接口，你可以自己来控制流的生成。这种情形通常用于随机数、常量的Stream，或者需要前后元素间维持着某种状态信息的Stream。把Supplier实例传递给Stream.generate()生成的Stream，默认是串行（相对parallel而言）但无序的（相对ordered而言）。由于它是无限的，在管道中，必须利用limit之类的操作限制Stream大小。

生成10个随机整数

Random seed = new Random();

Supplier<Integer> random = seed::nextInt;

Stream.generate(random).limit(10).forEach(System.out::println);

//Another way

IntStream.generate(() -> (int) (System.nanoTime() % 100)).

limit(10).forEach(System.out::println);

Stream.generate()还接受自己实现的Supplier。例如在构造海量测试数据的时候，用某种自动的规则给每一个变量赋值；或者依据公式计算Stream的每个元素值。这些都是维持状态信息的情形。

自实现Supplier

Stream.generate(new PersonSupplier()).

limit(10).

forEach(p -> System.out.println(p.getName() + ", " + p.getAge()));

private class PersonSupplier implements Supplier<Person> {

 private int index = 0;

 private Random random = new Random();

 @Override

 public Person get() {

 return new Person(index++, "StormTestUser" + index, random.nextInt(100));

 }

}

输出结果：

StormTestUser1, 9

StormTestUser2, 12

StormTestUser3, 88

StormTestUser4, 51

StormTestUser5, 22

StormTestUser6, 28

StormTestUser7, 81

StormTestUser8, 51

StormTestUser9, 4

StormTestUser10, 76

Stream.iterate

iterate跟reduce操作很像，接受一个种子值，和一个UnaryOperator（例如f）。然后种子值成为Stream的第一个元素，f(seed)为第二个，f(f(seed))第三个，以此类推。

生成一个等差数列

1	Stream.iterate(0, n -> n + 3).limit(10). forEach(x -> System.out.print(x + " "));

输出结果：

1	0 3 6 9 12 15 18 21 24 27

与Stream.generate相仿，在iterate时候管道必须有limit这样的操作来限制Stream大小。

进阶：用Collectors来进行reduction操作

java.util.stream.Collectors类的主要作用就是辅助进行各类有用的reduction操作，例如转变输出为Collection，把Stream元素进行归组，

groupingBy/partitioningBy

按照年龄归组

Map<Integer, List<Person>> personGroups = Stream.generate(new PersonSupplier()).

 limit(100).

 collect(Collectors.groupingBy(Person::getAge));

Iterator it = personGroups.entrySet().iterator();

while (it.hasNext()) {

 Map.Entry<Integer, List<Person>> persons = (Map.Entry) it.next();

 System.out.println("Age " + persons.getKey() + " = " + persons.getValue().size());

}

上面的示例，首先生成100人的信息，然后按照年龄归组，相同年龄的人放到同一个list中，可以看到如下的输出：

Age 0 = 2

Age 1 = 2

Age 5 = 2

Age 8 = 1

Age 9 = 1

Age 11 = 2

……

按照未成年人和成年人归组

Map<Boolean, List<Person>> children = Stream.generate(new PersonSupplier()).

 limit(100).

 collect(Collectors.partitioningBy(p -> p.getAge() < 18));

System.out.println("Children number: " + children.get(true).size());

System.out.println("Adult number: " + children.get(false).size());

输出结果：

1
2
3

Children number: 23

Adult number: 77

在使用条件“年龄小于18”进行分组后可以看到，不到18岁的未成年人是一组，成年人是另外一组。partitioningBy其实是一种特殊的groupingBy，它依照条件测试的是否两种结果来构造返回的数据结构，get(true)和get(false)能即为全部的元素对象。

结束语

总之，Stream的特性可以归纳为：

不是数据结构
它没有内部存储，它只是用操作管道从source（数据结构、数组、generator function、IO channel）抓取数据
它也绝不修改自己所封装的底层数据结构的数据。例如Stream的filter操作会产生一个不包含被过滤元素的新Stream，而不是从source删除那些元素
所有Stream的操作必须以lambda表达式为参数
不支持索引访问
你可以请求第一个元素，但无法请求第二个，第三个或者最后一个。不过请参阅下一项
很容易生成数组或者List
惰性化
很多Stream操作是向后延迟的，一直到它弄清楚了最后需要多少数据才会开始
Intermediate操作永远是惰性化的
并行能力
当一个Stream是并行化的，就不需要再写多线程代码，所有对它的操作会自动并行进行的
可以是无限的
集合有固定大小，Stream则不必。limit(n)和findFirst()这类的short-circuiting操作可以对无限的Stream进行运算并很快完成

再怎么样也不能废了自己 2018-07-11|生活杂侃|自律

拥有一个自律的生活

身边有太多的人都因为身体健康而发愁。等到病魔来找你，那就真的晚了，什么都抵不过健康二字。

把自己的身体精神养好，也是对自己的一种负责，更是对父母的负责。

这里我就记录一下最近自己的生活状态，再怎么样也不能废了自己。

早上
- 七点一个闹钟，往往过个十分钟才动身起床，也就是七点十分左右（工作日）
- 起床烧一壶开水，泡一杯燕麦，拉几个拉力绳
- 上厕所，洗脸，刷牙
- 偶尔做个手抓饼（自己网上买的食材）
- 打开电脑，编辑一篇情爱的诗词丢上公众号（自娱自乐）
- 给龟崽子喂点吃的（鱼干、虾干、面包虫…）
- 自己吃个面包，喝了那杯燕麦，再拉几个拉力绳，准备出门上班
- 周末的话早上可能起得迟一点，起床后就打开电脑看看电影玩玩游戏
上班
- 上班找小黄车，距离上班地点6公里左右，骑车半小时
- 由于地铁站距离比较远，加上最近需要减脂就还是骑车最舒服了（常年坐工位体脂率高）
- 中午公司包餐，伙食一般般，吃的也不多，所以有时候需要下午自己补给一下
- 朝九晚六，基本上七点能回家，当然也是骑车回去
晚上
- 下班骑车回去，基本上两三天要去菜市场补点货
- 鸡胸肉、黄瓜、胡萝卜、西红柿、生菜…
- 周二、四、六晚上我会选择去跑步，一般都是环形，一起算上5公里吧也不多
- 不跑步的时候会躺床上先看个电影，练练口琴或者练练pop
- 运动回去缓一缓，拉几个拉力绳，准备动手自己做鸡胸晚餐了
- 基本上全部弄完要将近九点了，再休息休息洗个澡
- 最近晚上有球赛的话我会用投影看球赛，没有的话就趴在床上自己看看书，犯困就睡觉
- 睡眠质量不太好，所以基本睡觉都比较晚，我知道这对身体很不利，最近也在慢慢改
周末
- 周末的话稍微就自由放松一点，平时没睡够的觉可以补一补
- 上周发现附近有个学校，去那边操场跑了跑
- 准备周末带着书去那边的图书馆泡着，晚上还可以顺带跑跑步

总是在你回头的时候才会感慨时间流逝得快。

有一句话我一直忘不了：
学习和健身是两种最便宜而有效的改变人的方式。

再怎么样，我们也不能废了自己。保持自律。

indexedDB数据库使用总结 2018-07-10|开发总结|indexedDB

indexedDB简介

indexedDB是一个前端存储数据库，之前也没有什么了解，这次项目中需要用到，然后就去找了相关资料。数据库有两种，一种是关系型数据库，另一种是非关系型数据库。indexedDB是第二种，它是非关系型数据库，它不需要你去写一些特定的sql语句来对数据库进行操作，数据形式使用的是json。

与其他前端存储方式对比

也许熟悉前端存储的会说，不是有了LocalStorage和Cookies吗？为什么还要推出indexedDB呢？其实对于在浏览器里存储数据，你可以使用cookies或local storage，但它们都是比较简单的技术，而IndexedDB提供了类似数据库风格的数据存储和使用方式。

首先说说Cookies，英文直接翻译过来就是小甜点，听起来很好吃，实际上并不是，每次HTTP接受和发送都会传递Cookies数据，它会占用额外的流量。例如，如果你有一个10KB的Cookies数据，发送10次请求，那么，总计就会有100KB的数据在网络上传输。Cookies只能是字符串。浏览器里存储Cookies的空间有限，很多用户禁止浏览器使用Cookies。所以，Cookies只能用来存储小量的非关键的数据。

其次说说LocalStorage，LocalStorage是用key-value键值模式存储数据，但跟IndexedDB不一样的是，它的数据并不是按对象形式存储。它存储的数据都是字符串形式。如果你想让LocalStorage存储对象，你需要借助JSON.stringify()能将对象变成字符串形式，再用JSON.parse()将字符串还原成对象。但如果要存储大量的复杂的数据，这并不是一种很好的方案。毕竟，localstorage就是专门为小数量数据设计的，所以它的api设计为同步的。而IndexedDB很适合存储大量数据，它的API是异步调用的。IndexedDB使用索引存储数据，各种数据库操作放在事务中执行。IndexedDB甚至还支持简单的数据类型。IndexedDB比localstorage强大得多，但它的API也相对复杂。对于简单的数据，你应该继续使用localstorage，但当你希望存储大量数据时，IndexedDB会明显的更适合，IndexedDB能提供你更为复杂的查询数据的方式。

indexedDB特性

对象仓库
indexedDB中没有表的概念，而是objectStore，一个数据库中可以包含多个objectStore，objectStore是一个灵活的数据结构，可以存放多种类型数据。也就是说一个objectStore相当于一张表，里面存储的每条数据和一个键相关联。我们可以使用每条记录中的某个指定字段作为键值（keyPath），也可以使用自动生成的递增数字作为键值（keyGenerator），也可以不指定。选择键的类型不同，objectStore可以存储的数据结构也有差异。

键类型	存储数据
不使用	任意值，但是每添加一条数据的时候，需指定键参数
keyPath	对象，eg: {keyPath: 'id'}
keyGenerator	任意值 eg: {autoincrement: true}
keyPath and KeyGenerator 都使用	对象，如果对象中有keyPath指定的属性则不生成新的键值，如果没有自动生成递增键值，填充keyPath指定的属性

事务性
在indexedDB中，每一个对数据库操作是在一个事务的上下文中执行的。事务范围一次影响一个或多个object stores，你通过传入一个object store名字的数组到创建事务范围的函数来定义。例如：db.transaction(storeName, ‘readwrite’)，创建事务的第二个参数是事务模式。当请求一个事务时,必须决定是按照只读还是读写模式请求访问。
基于请求
对indexedDB数据库的每次操作，描述为通过一个请求打开数据库,访问一个object store，再继续。IndexedDB API天生是基于请求的,这也是API异步本性指示。对于你在数据库执行的每次操作,你必须首先为这个操作创建一个请求。当请求完成,你可以响应由请求结果产生的事件和错误。
异步
在IndexedDB大部分操作并不是我们常用的调用方法，返回结果的模式，而是请求—响应的模式，所谓异步API是指并不是这条指令执行完毕，我们就可以使用request.result来获取indexedDB对象了，就像使用ajax一样，语句执行完并不代表已经获取到了对象，所以我们一般在其回调函数中处理。

使用示例

打开数据库

判断浏览器是否支持indexedDB数据库

var indexedDB = window.indexedDB || window.webkitIndexedDB || window.mozIndexedDB || window.msIndexedDB;
if(!indexedDB)
{
    console.log("你的浏览器不支持IndexedDB");
}

创建请求打开indexedDB,IndexedDB需要你创建一个请求来打开它。

1	var request = indexedDB.open(name, version);

第一个参数是数据库的名称，第二个参数是数据库的版本号。版本号可以在升级数据库时用来调整数据库结构和数据。但你增加数据库版本号时，会触发onupgradeneeded事件，这时可能会出现成功、失败和阻止事件三种情况：

request.onerror = function(e) { // 失败
        console.log(e.currentTarget.error.message);
    };

    request.onsuccess = function(e) {   // 成功
        myDB.db = e.target.result;
        console.log('成功打开DB');
    };

    request.onupgradeneeded = function(e) {
        var db = e.target.result;
        if (!db.objectStoreNames.contains('person')) {
            console.log("我需要创建一个新的存储对象");
            //如果表格不存在，创建一个新的表格（keyPath，主键 ； autoIncrement,是否自增），会返回一个对象（objectStore）
            var objectStore = db.createObjectStore('person', {
                keyPath: "id",
                autoIncrement: true
            });

            //指定可以被索引的字段，unique字段是否唯一

            objectStore.createIndex("name", "name", {
                unique: false
            });

            objectStore.createIndex("phone", "phone", {
                unique: false
            });

        }
        console.log('数据库版本更改为： ' + version);
};

onupgradeneeded事件在第一次打开页面初始化数据库时会被调用，或在当有版本号变化时。所以，你应该在onupgradeneeded函数里创建你的存储数据。如果没有版本号变化，而且页面之前被打开过，你会获得一个onsuccess事件。

添加数据

创建一个事务，并要求具有读写权限

1	var transaction = db.transaction(storeName, 'readwrite');

获取objectStore，调用add方法添加数据

var store = transaction.objectStore(storeName); //访问事务中的objectStore
        data.forEach(function (item) {
            store.add(item);//保存数据
        });

删除数据

创建事务，然后调用删除接口，通过key删除对象

var transaction = db.transaction(storeName, 'readwrite');

var store = transaction.objectStore(storeName);

store.delete(key);

查找数据

按key查找开启事务，获取objectStore，调用往get()方法，往方法里传入对象的key值，取出相应的对象

var transaction = db.transaction(storeName, 'readwrite');

    var store = transaction.objectStore(storeName);

    var request = store.get(key);

    request.onsuccess = function(e) {

        data = e.target.result;

        console.log(student.name);

};

使用索引查找

var transaction = db.transaction(storeName);

    var store = transaction.objectStore(storeName);

    var index = store.index(search_index);

    index.get(value).onsuccess = function(e) {

        data = e.target.result;

        console.log(student.id);

}

游标遍历数据

var transaction = db.transaction(storeName);

    var store = transaction.objectStore(storeName);

    var request = store.openCursor();//打开游标

    var dataList = new Array();

    var i = 0;

    request.onsuccess = function(e) {

        var cursor = e.target.result;

        if (cursor) {

            console.log(cursor.key);

            dataList[i] = cursor.value;

            console.log(dataList[i].name);

            i++;

            cursor.continue();

        }

        data = dataList;

};

更新对象

更新对象，首先要把它取出来，修改，然后再放回去。

var transaction = db.transaction(storeName, 'readwrite');

    var store = transaction.objectStore(storeName);

    var request = store.get(key);

    request.onsuccess = function(e) {

        var data = e.target.result;

        for (a in newData) {

            //除了keypath之外

 

            data.a = newData.a;

        }

        store.put(data);

};

关闭与删除数据库

关闭数据库可以直接调用数据库对象的close方法

function closeDB(db) {

    db.close();

}

删除数据库使用数据库对象的deleteDatabase方法

function deleteDB(name) {

    indexedDB.deleteDatabase(name);

}

参考资料

黑色六月（2018） 2018-07-06|生活杂侃

对于我来说的黑色六月 2018

上个月发生了很多事情，很多事情。今年最丧的一个月！借着上班空余时间也算是记录生活吧。

股市大震荡

其实今年股市都不理想，震荡不稳。然而被美国一加息操作，刷刷往下滑，千股跌停，真是一片绿油油。我虽然没有时间去炒股，不过我也买了基金，至今也是跌了15个点啊，能不心疼么。之前是国外在割韭菜，现在是国内国外联手割韭菜了，还好我本金不大不然也是血亏。

阳光总在风雨后不是么？
保持不浮躁，不要追涨杀跌就行了，还是要相信国运的。

世界杯

四年一度世界杯来了。不会踢足球的人却能在这段时光看赛事不觉得枯燥。足球虽然全场到处跑，进球又少，但是真的很令人着迷，一点都不会觉得无趣。

有球赛的时候我就自己待在出租屋中，放着我心爱的投影，瘫在床上看比赛。

没有球赛那我就找找电影看，玩玩游戏。乏了就关了大灯开启我的小台灯，趴在床上看看书，直到眼皮打架，关灯入眠，被第二日的刺光射醒。

有点遗憾，今年也是爆了很多冷门。德国回家了，葡萄牙回家了。

因为世界杯最近也出现了不少事情，赌球是自然不用说了。本人好青年，不沾赌。

还有因为支持球队不同吵架，甚至分手的、离婚的，真不知道是怎么想的，我想是本来感情就出现了问题借此顺势触发的吧。

分手了

难以相信这段感情只维持了10个月，以前我还不信，说离开了校园步入社会，你将要面对的都是现实。

曾经天真以为遇到了对的人，能携手同老。

有些问题终究不可避免，即使你明白，不尽量让它浮现，但终是拦不住。

情这个东西，不负彼此就行，不负此生，真的太难了。

也许我就会这样一直单着吧。

那一天，我还是去超市买了一听雪花，一袋花生，半只烤鸭。

转正了

人人都有一颗创业的心，谁说不是呢。可是蠢蠢欲动并不能代表你就可以。苦有谁吃不得，要是只要能吃得了苦就能创业成功，谁还会甘愿给别人打工。

一没财，二没势，创业如今也是高门槛了。

不像以前，近十年的世界翻天覆地，互联网技术层层迭代。近些年来的风口都是什么，大数据，云计算，直播，短视频APP…要是没有前沿的眼光，没有能跟上这个时代的眼界思维，没有一定的技术支持，就算站在风口你飞起来了，也会摔得很惨。

雷军，我真的很敬佩。之前看了他的博客写的自己的心得。他是天才，大学就实现了财务自由，年纪轻轻成为了天使投资人，而且眼光很独到。更重要的是，雷军的为人，就是有人愿意相信他跟着他的步伐一起走，这又岂能是用钱财能换来的，用的都是真心。

天才都在努力奋进，我们又怎么能安于现状，止步于前。自己都觉得废了，那就真的是废了。

活到老，学到老。充实自己，不要再空虚了。

胡乱写一点

眼看又是一年了，去年的五月六月也是我最难受的两个月。我虽然不怕苦，但是我也会痛。一些辛酸无人能说也无人可说，亦或是不想去说。我还是保持那个观点，人活世上，平安喜乐。有些事，该来的时候终会到来。

我有很多喜欢的东西啊，兴趣爱好特别多。可是呢，鱼跟熊掌二者都不能兼得，何况是多者呢。今年换了家公司，虽然钱不多，但是好歹加班没有之前严重了，目前为止最晚也能九点回去。我喜欢popping、健身、口琴、看电影、玩游戏，可是我却安排不好自己的时间，晚上回去一晃就到了12点。有时候也会想，我内心到底在追求什么。我不求大富大贵，只求健康平安，一家和睦。可是这些都不是我现在这个年纪该去思考的问题，凡事都要讲资本，更何况如今需要的资本更是我们这种平凡人所不能轻易承受的。

我怕空虚，所以我不想闲下来。身边有人陪伴的时间久了，突然变成了孑然一人。

很多事情我都会选择自己来扛，我不愿去麻烦别人，不愿再去让别人尝一遍我尝过的辛酸无奈。自己苦点累点无所谓，只要我觉得值得。生而为人，人各有命，命不在你，命在于天。

踏实走好每一步，但愿往后回味不会懊恼此刻的我。

愿你健康快乐平安幸福过好每一天。

Java小知识点整理（二） 2018-07-04|开发总结|Java

有一段时间没有整理了，今天整理一下最近看JDK1.8源码发现的几个不错的function。For Java.

Base64加解密

/**
 * Base64加解密
 * 
 * @throws UnsupportedEncodingException
 */
static void Base64Test() throws UnsupportedEncodingException {
    String str = "Base64加密测试";
    byte[] enByt = Base64.getEncoder().encode(str.getBytes());
    String enStr = new String(enByt, "utf-8");
    System.out.println("加密后 ：" + enStr);

    byte[] decByt = Base64.getDecoder().decode(enStr);
    String decStr = new String(decByt, "utf-8");
    System.out.println("解密后 ：" + decStr);
}

JDK1.8中util里新增了Base64文件，给我们提供了便捷。上述代码结果为：

1 2	加密后：QmFzZTY05Yqg5a+G5rWL6K+V 解密后：Base64加密测试

rotate

在看Collections源码时发现的，觉得很妙就记录了下来。

private static <T> void rotate1(List<T> list, int distance) {
        int size = list.size();     // 获取集合大小
        if (size == 0)      // 数量为0直接返回
            return;
        distance = distance % size;     // 取模
        if (distance < 0)
            distance += size;       // 保证不为负数
        if (distance == 0)
            return;
        for (int cycleStart = 0, nMoved = 0; nMoved != size; cycleStart++) {
            T displaced = list.get(cycleStart);
            int i = cycleStart;
            do {
                i += distance;      // 依次往后递推
                if (i >= size)
                    i -= size;      // 一轮赋值后回到原处
                displaced = list.set(i, displaced);     // 赋值并返回旧值
                nMoved ++;      // 重新赋值一个数加一
            } while (i != cycleStart);      // 直到回到初值
        }
    }

看到这个rotate1那肯定其中还有个2咯。

private static void rotate2(List<?> list, int distance) {       // {1，2，3，4}  2
    int size = list.size();     // 4
    if (size == 0)
        return;
    int mid =  -distance % size;
    if (mid < 0)
        mid += size;        // 2
    if (mid == 0)
        return;

    reverse(list.subList(0, mid));      // {2，1，3，4}
    reverse(list.subList(mid, size));       // {2，1，4，3}
    reverse(list);      // {3，4，1，2}
}

这两个方法效果一样，妙不可言啊，一起分享。

tableSizeFor

这个是HashMap源码中的一个方法，用来获取一个大于等于该数的二次幂数同时要小于等于给定的最小的二次幂数。

/**
 * 返回给定目标容量的2大小的幂
 */
static final int tableSizeFor(int cap) {
    int n = cap - 1;
    n |= n >>> 1;       // 无符号右移，忽略符号位，空位都以0补齐
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

插入排序 insertion sort

这个是在DualPivotQuicksort源码中看到抽取出来的，写法很简洁，精炼。

int[] arr = {5,1,7,2,4};
for(int i = 0,j = i; i < arr.length - 1; j = ++i) {
    // 保持i 和 j 相等
    int a = arr[i + 1];
    while(a < arr[j]) { // 直到找到没有比它还小的值
        // 如果小于前一个数则将前一个数赋值给它
        arr[j + 1] = arr[j];
        if(j-- == 0) {
            // 执行j-- 若j=0则退出循环
            break;
        }
    }
    arr[j + 1] = a; // 将较小的值赋值
}
System.out.println(Arrays.toString(arr));

输出结果为：

1	[1,2,4,5,7]

End.

试用期总结 2018-06-25|开发总结|Java-js

三个月的试用时间一晃就要到了，我在2018年3月28日有幸来到了公司的系统集成部任职软件开发工程师这一岗位。入职当天同事们的热情我至今都没有忘记，当时我就感觉到了这个肯定是一个很有爱的大家庭，我的选择没有错。事实也证明确实如此。老师们十分和蔼，一点都没有架子，我有不理解的地方也会时常去问老师。在公司领导的关心和指导下，在同事们的热情帮助下，我较快熟悉了公司环境，适应了新的工作岗位，现将我试用期的工作情况作简要小结如下：

严格遵守公司各项规章制度。做到了无迟到、早退、违规现象。
主动学习、尽快适应，迅速熟悉环境，了解工作内容。主动、虚心向领导、同事们请教、学习，基本掌握了相关的工作内容，工作流程和工作方法。
工作积极、认真、负责，通过不断学习、请教，定期自我总结，较好地完成了领导安排的各项工作任务。
- 在领导安排下将健康监测项目的源码进行了反编译，并成功运行部署在服务器上
- 帮助编写了同济大学土木实验室偏振仪的指令控制代码
- 对之前的健康监测项目进行了重构，使其变得精简，可读性大幅提升，并成功接入了倾角仪的数据监测服务
虽然之前也是从事物联网相关，但在这短短试用期间深刻认识到自己的涉猎还不够广，之前的NodeJs也只是初步接触，所以希望自己能在这方面加强一些。尤其是当看到身边的许多研究生同学时，在学历上的不足就更需要用不断的学习来弥补了。
存在的问题及解决方法：
- 我自己可能是比较慢热的人，所以外表看上去感觉好像不太好相处，会让别人感觉很冷漠。其实只要稍稍了解点就不会这么认为了。也可能我在外面的工位上，再加之大家岗位都比较忙，使得同事间的交流就没有那么多了。这还是需要时间的累积吧。
- 由于我是计算机专业，所以对于建筑这方面缺少了解，一些专业名词更是之前都没听过。后来在老师的指导下，我自己也上网买了相关的书籍。毕竟经常会跟建筑打交道，所以决定在这方面也要下点心思学习学习。
总之，在短短的三个月时间里我接触到了之前未曾接触过的技术，也更加磨炼了自己的构思能力。之后我将进一步严格要求自己，克服不足，加强学习，认真地完成好每一项工作。

My97DatePicker时间日期插件使用示例 2018-06-25|开发Web|js

前言

My97DatePicker目录是一个整体,不可破坏里面的目录结构,也不可对里面的文件改名,可以改目录名
My97DatePicker.htm是必须文件,不可删除

各目录及文件的用途

WdatePicker.js配置文件,在调用的地方仅需使用该文件,可多个共存,以xx_WdatePicker.js方式命名
config.js 语言和皮肤配置文件,无需引入
calendar.js 日期库主文件,无需引入
My97DatePicker.htm 临时页面文件,不可删除
目录lang 存放语言文件,你可以根据需要清理或添加语言文件
目录skin 存放皮肤的相关文件,你可以根据需要清理或添加皮肤文件包
当WdatePicker.js里的属性:$wdate=true时,在input里加上class=”Wdate”就会在选择框右边出现日期图标,如果您不喜欢这个样式,可以把class=”Wdate”去掉,另外也可以通过修改skin目录下的WdatePicker.css文件来修改样式

示例

没有对控件进行设置

<input class="Wdate" type="text" onfocus="WdatePicker()"/>

限制日期的范围是 2006-09-10到2008-12-20

1	<input id="d411" class="Wdate" type="text" onfocus="WdatePicker({skin:'whyGreen',minDate: '2006-09-10', maxDate: '2008-12-20' })"/>

限制日期的范围是 2008-3-8 11:30:00 到 2008-3-10 20:59:30

1
2
3

<input type="text" class="Wdate" id="d412"
onfocus="WdatePicker({skin:'whyGreen',dateFmt: 'yyyy-MM-dd HH:mm:ss',
minDate: '2008-03-08 11:30:00', maxDate: '2008-03-10 20:59:30' })" value="2008-03-09 11:00:00"/>

限制日期的范围是 2008年2月到 2008年10月

1	<input type="text" class="Wdate" id="d413" onfocus="WdatePicker({dateFmt: 'yyyy年M月', minDate: '2008-2', maxDate: '2008-10' })"/>

限制日期的范围是 8:00:00 到 11:30:00

1	<input type="text" class="Wdate" id="d414" onfocus="WdatePicker({dateFmt: 'H:mm:ss', minDate: '8:00:00', maxDate: '11:30:00' })"/>

只能选择今天以前的日期(包括今天)

1	<input id="d421" class="Wdate" type="text" onfocus="WdatePicker({skin:'whyGreen',maxDate: '%y-%M-%d' })"/>

使用了运算表达式只能选择今天以后的日期(不包括今天)

1	<input id="d422" class="Wdate" type="text" onfocus="WdatePicker({minDate: '%y-%M-#{%d+1}' })"/>

只能选择本月的日期1号至本月最后一天

1	<input id="d423" class="Wdate" type="text" onfocus="WdatePicker({minDate: '%y-%M-01', maxDate: '%y-%M-%ld' })"/>

只能选择今天7:00:00至明天21:00:00的日期

1	<input id="d424" class="Wdate" type="text" onfocus="WdatePicker({dateFmt:'yyyy-M-d H:mm:ss',minDate: '%y-%M-%d 7:00:00', maxDate: '%y-%M-#{%d+1} 21:00:00' })"/>

使用了运算表达式只能选择 20小时前至 30小时后的日期

1 2	<input id="d425" class="Wdate" type="text" onClick="WdatePicker({dateFmt:'yyyy-MM-dd HH:mm',minDate: '%y-%M-%d #{%H-20}:%m:%s' ,maxDate: '%y-%M-%d #{%H+30}:%m:%s' })"/>

前面的日期不能大于后面的日期且两个日期都不能大于 2020-10-01

合同有效期从到

[注意: 两个日期的日期格式必须相同.
dp. 相当于 document.getElementByIdx_x 函数.
那么为什么里面的 ’ 使用 \’ 呢? 那是因为 ” 和 ’ 都被外围的函数使用了,故使用转义符 \ ,否则会提示JS语法错误.所以您在其他地方使用时注意把 \’ 改成 ” 或者 ’ 来使用。
#F{$dp.$D(\'d4312\')||\'2020-10-01\'} 表示当 d4312 为空时, 采用 2020-10-01 的值作为最大值]

1
2

<input id="d4311" class="Wdate" type="text" onFocus="WdatePicker({maxDate: '#F{$dp.$D(\'d4312\')||\'2020-10-01\'}' })"/>
<input id="d4312" class="Wdate" type="text" onFocus="WdatePicker({minDate: '#F{$dp.$D(\'d4311\')}' ,maxDate:'2020-10-01' })"/>

取值和赋值

html:

1 2	<input class="p-Wdate" type="text" onfocus="WdatePicker()"/> <p><button class="tijiaoBtn">提交</button></p>

js:

//赋值
$(".p-Wdate").val("2019-01-01");
//取值
$(".tijiaoBtn").on("click",function(){
  console.log($(".p-Wdate").val());
});

参考

Spring Data JPA 初次使用心得 2018-06-21|开发总结|Java-Spring Data JPA

前言

最近在给公司的老项目换个架构，之前的架构太繁琐古老了些，用的是SSH，还是老版的Hibernate3，配置文件看花眼还有Struts2确实看着不习惯，感觉有点费眼，不过在改的过程我觉得它能共享参数有时候还是挺便捷的。
因为之前用的是Hibernate所以我决定用Spring Data JPA,对了，今天我要说下有关于JPA的一些注意点，也是我亲自踩完后发现的，因为之前没有接触过它。

Entity实体类与Hibernate没有多大区别@Entity定义实体 @Table定义表明 @Id定义主键 @Column定义数据库中字段映射

@Entity
@Table(name = "alarmtable")
public class AlarmEntity {
    private String channelNumber;
    private double alarmValue;

    @Id
    @Column(name = "channelNumber", length = 20, nullable = false)
    public String getChannelNumber() {
        return this.channelNumber;
    }

    public void setChannelNumber(String channelNumber) {
        this.channelNumber = channelNumber;
    }

    @Column(name = "alarmValue", nullable = false)
    public double getAlarmValue() {
        return this.alarmValue;
    }

    public void setAlarmValue(double alarmValue) {
        this.alarmValue = alarmValue;
    }
}

这里注意的是当你用驼峰命名字段时会自动用下划线分割，如alarmValue会变成alarm_value

JPA优点

很多人喜欢用JPA的原因是什么，不就是它能省事么，一些基本的CRUD都能替你完成只需要调其方法即可。不过JPA它有特定的命名规则，不能瞎写，写之前还是要去网上看看，这里就不贴示例了。

首先需要先添加依赖，我用的是maven：

<!-- JPA依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

如果你要自定义方法SQL查询，直接使用@Query注解即可，示例：

/**
 * 查询所有的端口号
 * 
 * @return
 */
@Query(value = "select distinct port from relationtable order by port", nativeQuery = true)
List<Integer> getAllPort();

/**
 * 根据设备号删除数据
 * 
 * @param instru_serial
 */
@Transactional
@Modifying
@Query(value = "delete from relationTable where instru_serial = :instru_serial", nativeQuery = true)
void deleteByInstru_serial(@Param("instru_serial") String instru_serial);

nativeQuery = true说明该sql为原生sql，本地sql查询。

所谓本地查询，就是使用原生的sql语句（根据数据库的不同，在sql的语法或结构方面可能有所区别）进行查询数据库的操作。

做删除操作时记得加上这两个注解 @Transactional @Modifying

Query的写法有很多种，我这只是其中一种个人认为较为不错的写法，其余可以自行搜索。

Dao层

这里我还是习惯称之为Dao，也就是Repository。如果要使用JPA来操作实体映射类的方法时，你需要继承JpaRepository。JpaRepository有两个参数，第一个是相对于的Entity类即映射实体类，第二个为主键类。

JpaRepository<RelationEntity, Integer> 第一个参数好理解，第二个参数就是对应Entity中用@Id注解表示的字段的类型，若是int则为Integer，String则为String等等。

不过这里我要说的是复合主键，就是当你一个表中存在多个主键的时候。通过查找许多资料后得出方法。@IdClass可以解决我们的问题。把Entity中用@Id定义的字段重新建一个class来制定。请看示例：

Entity Class :

package com.tonglei.aiot.entity;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.IdClass;
import javax.persistence.Table;

import com.tonglei.aiot.entity.idclass.DVWIdClass;
/**
 * 应变映射实体类
 * 
 * @author ffj
 *
 */
@Entity
@IdClass(DVWIdClass.class)
@Table(name = "dvw16_instrument_Info")
public class DVWInstrumentInfoEntity implements Serializable {
    private static final long serialVersionUID = 1L;
    private String instruSerial;
    /**
     * 通道
     */
    private int channel;
    /**
     * 采样率
     */
    private String ratio;
    private String channelNumber;

    @Id
    @Column(name = "Instru_serial", length = 8, nullable = false)
    public String getInstruSerial() {
        return this.instruSerial;
    }

    public void setInstruSerial(String instru_serial) {
        this.instruSerial = instru_serial;
    }

    @Id
    @Column(name = "channel", length = 11, nullable = false)
    public int getChannel() {
        return this.channel;
    }

    public void setChannel(int channel) {
        this.channel = channel;
    }

    @Column(name = "ratio", length = 30, nullable = false)
    public String getRatio() {
        return this.ratio;
    }

    public void setRatio(String ratio) {
        this.ratio = ratio;
    }

    @Column(name = "number", length = 20, nullable = false)
    public String getChannelNumber() {
        return this.channelNumber;
    }

    public void setChannelNumber(String channelNumber) {
        this.channelNumber = channelNumber;
    }
}

Id Class :

package com.tonglei.aiot.entity.idclass;

import java.io.Serializable;
/**
 * 应变复合主键类
 * 
 * @author ffj
 *
 */
public class DVWIdClass implements Serializable {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    String instruSerial;
    int channel;

    public String getInstruSerial() {
        return instruSerial;
    }

    public void setInstruSerial(String instruSerial) {
        this.instruSerial = instruSerial;
    }

    public int getChannel() {
        return channel;
    }

    public void setChannel(int channel) {
        this.channel = channel;
    }

}

Dao ：

package com.tonglei.aiot.dao;

import org.springframework.data.jpa.repository.JpaRepository;

import com.tonglei.aiot.entity.DVWInstrumentInfoEntity;
import com.tonglei.aiot.entity.idclass.DVWIdClass;
/**
 * 应变Dao层接口
 * 
 * @author ffj
 *
 */
public interface DVWInstrumentInfoDao extends JpaRepository<DVWInstrumentInfoEntity, DVWIdClass> {

    DVWInstrumentInfoEntity findByInstruSerialAndChannel(String instruSerial, int channel);
}

需要注意的是，复合主键类必须实现Serializable接口不然启动会报错。

总结

由于也是第一次使用Spring Data JPA，之前都是用Mybatis的比较多。通过这次的使用发现如果业务上都是一些不太复杂的增删改的话确实能提高不少的效率的。
相对于Mybatis节省了许多配置，懒人首选。
现在还没有用到它的一些复杂的操作，比如多表联查，多表关联什么的，后面用到再详细说明。
通过这次框架的重构也使得我对于其内部方法的调用更加熟悉，虽然还有好多方法我觉得可以更加简单，这个慢慢再优化吧。
终于不用看那一大堆配置文件了。

参考资料

Windows/CMD/Linux/Git常用命令整理 2018-06-06|开发总结|Windows-CMD-Linux-Git

Windows/CMD/Linux/Git常用命令整理，由于平常经常会使用故趁热把这些都一起整理下。

Windows Win+R 快捷操作

有时候不用去挨个点开什么控制面板啊再计算机什么的直接命令快速打开，列举平常使用率较高的几个

打开本地服务

services.msc这个对于开发人员是经常需要操作的

打开注册表

regedit有时候卸载或者重装软件的时候会需要操作注册表

打开CMD界面

cmd这个就不用说了，用管理员方式打开则需要右击操作

打开组策略

gpedit.msc可以查看计算机配置和用户配置

打开记事本

notepad

磁盘清理

cleanmgr可以快速清理一些回收垃圾

查看win版本

winver

打开画图板

mspaint

远程连接

mstsc

shutdown

shutdown -r表示重启
shutdown -s -t 60表示60秒后正常关机
shutdown -s -t 60 -c 关机则多了个提示消息

常用参数有："-s"正常关机、"-f"强制关机、"-r"重启、"-t"定时关机、"-c" 设置提示信息、"-a" 是取消定时关机

CMD常用命令

由于本人使用的都是Windows系统，平时难免会需要经常接触CMD来方便一些操作，列举平常使用率较高的几个(cd/dir/切换磁盘什么的这些就不说了…)

查看IP信息

ipconfig

修改本机IP

netsh interface ip set address "以太网" static 192.168.30.100 255.255.255.0 192.168.30.1

注：这里以太网是网络名称，192.168.30.100是你要修改的IP255.255.255.0为子网掩码192.168.30.1为网关

网络诊断

ping putop.top就是给putop.top发送数据包看有没有返回

无线WLAN操作

只要你输入netsh wlan就会出现许多提示，只要能看懂字就会操作了

如netsh wlan connect wuxian就是连接无线名为wuxian的无线网络了，netsh wlan disconnect就是断开无线连接

查看端口状态

netstat -ano查看所有端口占用情况
netstat -aon|findstr "8080"查看指定端口占用情况8080为端口号
tasklist|findstr "2018"查看指定PID对应的进程2018为PID

taskkill /f /t /im java.exe删除指定进程

完整语法为：

TASKKILL [/S system [/U username [/P [password]]]]
         { [/FI filter] [/PID processid | /IM imagename] } [/T] [/F]

    /S    system           指定要连接的远程系统。
    /U    [domain\]user    指定应该在哪个用户上下文执行这个命令。
    /P    [password]       为提供的用户上下文指定密码。如果忽略，提示输入。
    /FI   filter           应用筛选器以选择一组任务。允许使用 "*"。例如，映像名称 eq acme*
    /PID  processid        指定要终止的进程的 PID。使用 TaskList 取得 PID。
    /IM   imagename        指定要终止的进程的映像名称。通配符 '*'可用来指定所有任务或映像名称。
    /T                     终止指定的进程和由它启用的子进程。
    /F                     指定强制终止进程。
    /?                     显示帮助消息。

Linux常用命令

平时部署项目也会用到Linux系统，整理下平时常用的几个(cd/ls/ll这些也不说了…)说来惭愧，经常用ftp操作感觉还挺方便还是Windows用多了啊

系统显示

date显示系统时间
cal 2018显示2018年的日历表
date 060610502018.00设置日期和时间月日时分年.秒
clock -w将时间修改保存到BIOS中
cat /proc/cpuinfo显示CPU info的信息
lsusb -tv显示USB设备

关机、重启

shutdown -h now关闭系统
shutdown -h hours:minutes &按预定时间关闭系统
shutdown -c取消按预定时间关闭系统
shutdown -r now重启
logout注销

文件和目录

mkdir dir创建名为dir的目录
rmdir dir删除名为dir的目录
rm -rf dir删除名为dir的目录并同时删除其内容
rm -f file删除名为file的文件
mv dir new_dir重命名/移动名为dir的目录
cp file same_file复制一个名为file的文件叫做same_file
cp -a dir same_dir复制一个名为dir的目录叫做same_dir
cp dir/* .复制一个目录下的所有文件到当前工作目录
cp -a /tmp/dir复制一个目录到当前工作目录

磁盘空间

df -h显示已经挂载的分区列表
du -sh dir估算目录dir已经使用的磁盘空间

文件权限

ls -lh显示权限
chmod ugo+rwx dir设置目录的所有人(u)、群组(g)以及其他人(o)以读（r）、写(w)和执行(x)的权限，使用 “+” 设置权限，使用 “-“ 用于取消
chattr +a file只允许以追加方式读写文件
chattr +i file1设置成不可变的文件，不能被删除、修改、重命名或者链接
chattr +S file一旦应用程序对这个文件执行了写操作，使系统立刻把修改的结果写到磁盘
chattr +u file若文件被删除，系统会允许你在以后恢复这个被删除的文件
lsattr显示特殊的属性

解压/压缩文件

压缩
- tar –cvf jpg.tar *.jpg将目录里所有jpg文件打包成tar.jpg
- tar –czf jpg.tar.gz *.jpg将目录里所有jpg文件打包成jpg.tar后，并且将其用gzip压缩，生成一个gzip压缩过的包，命名为jpg.tar.gz
- tar –cjf jpg.tar.bz2 *.jpg将目录里所有jpg文件打包成jpg.tar后，并且将其用bzip2压缩，生成一个bzip2压缩过的包，命名为jpg.tar.bz2
- tar –cZf jpg.tar.Z *.jpg将目录里所有jpg文件打包成jpg.tar后，并且将其用compress压缩，生成一个umcompress压缩过的包，命名为jpg.tar.Z
- rar a jpg.rar *.jpgrar格式的压缩，需要先下载rar for linux
- zip jpg.zip *.jpgzip格式的压缩，需要先下载zip for linux
解压
- tar –xvf file.tar解压 tar包
- tar -xzvf file.tar.gz解压tar.gz
- tar -xjvf file.tar.bz2解压 tar.bz2
- tar –xZvf file.tar.Z解压tar.Z
- unrar e file.rar解压rar
- unzip file.zip解压zip

查看文件内容

cat file从第一个字节开始正向查看文件file的内容
tac file从最后一行开始反向查看文件file的内容
more file查看一个长文件的内容
head -2 file查看一个文件的前两行
tail -2 file查看一个文件的最后两行
tail -f /var/log/messages实时查看被添加到一个文件中的内容，这个平时查看日志经常会用到

进程

ps -ef查看所有运行进程
ps -ef|grep java指定查看java进程，java开发人员经常使用，比如鄙人
kill PID停止该PID表示进程，必要时加上- 9强制

部署

nohup java -jar xx.jar >/dev/null &这是jar包的后台部署，加上&就是后台运行

top视图

top进入top视图

视图数据详解：

第一行：
10:01:23 — 当前系统时间
126 days, 14:29 — 系统已经运行了126天14小时29分钟（在这期间没有重启过）
2 users — 当前有2个用户登录系统
load average: 1.15, 1.42, 1.44 — load average后面的三个数分别是1分钟、5分钟、15分钟的负载情况。

第二行：
Tasks — 任务（进程），系统现在共有183个进程，其中处于运行中的有1个，182个在休眠（sleep），stoped状态的有0个，zombie状态（僵尸）的有0个。

第三行：cpu状态
6.7% us — 用户空间占用CPU的百分比。
0.4% sy — 内核空间占用CPU的百分比。
0.0% ni — 改变过优先级的进程占用CPU的百分比
92.9% id — 空闲CPU百分比
0.0% wa — IO等待占用CPU的百分比
0.0% hi — 硬中断（Hardware IRQ）占用CPU的百分比
0.0% si — 软中断（Software Interrupts）占用CPU的百分比

第四行：内存状态
8306544k total — 物理内存总量（8GB）
7775876k used — 使用中的内存总量（7.7GB）
530668k free — 空闲内存总量（530M）
79236k buffers — 缓存的内存量 （79M）

第五行：swap交换分区
2031608k total — 交换区总量（2GB）
2556k used — 使用的交换区总量（2.5M）
2029052k free — 空闲交换区总量（2GB）
4231276k cached — 缓冲的交换区总量（4GB）

第六行是空行

第七行以下：各进程（任务）的状态监控
PID — 进程id
USER — 进程所有者
PR — 进程优先级
NI — nice值。负值表示高优先级，正值表示低优先级
VIRT — 进程使用的虚拟内存总量，单位kb。VIRT=SWAP+RES
RES — 进程使用的、未被换出的物理内存大小，单位kb。RES=CODE+DATA
SHR — 共享内存大小，单位kb
S — 进程状态。D=不可中断的睡眠状态 R=运行 S=睡眠 T=跟踪/停止 Z=僵尸进程
%CPU — 上次更新到现在的CPU时间占用百分比
%MEM — 进程使用的物理内存百分比
TIME+ — 进程使用的CPU时间总计，单位1/100秒
COMMAND — 进程名称（命令名/命令行）

Git常用命令

不免要使用git来版本管理

git init创建版本库
git clone克隆仓库
git add添加文件到暂存区
git commit提交更改,加上- m增加提交说明
git status查看状态
git rm删除文件
git diff文件对比
git log日志显示
git push上传
git merge合并
git branch -d删除分支
git fetch获取分支
git pull更新

参考资料

Java中一些小知识点 2018-05-31|开发总结|Java

今天来总结一些平时不起眼的东西。For Java.

for循环进行遍历删除元素

ArrayList<String> list = new ArrayList(Arrays.asList("a", "b", "c", "d"));
        System.out.println("before :" + list);
        // 在这个方法中有一个严重的错误。当一个元素被删除时，列表的大小缩小并且下标变化，
        // 所以当你想要在一个循环中用下标删除多个元素的时候，它并不会正常的生效。
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            System.out.println("s :" + s);
            if ("a".equals(s)) {
                list.remove(s);
            }
            if ("b".equals(s)) {
                list.remove(s);
            }
        }
        System.out.println("after :" + list);

上述代码结果不尽人意：

before :[a, b, c, d]
s :a
s :c
s :d
after :[b, c, d]

这正是因为注释中说的那样，list.remove()操作完的时候list就已经改变了大小以及下标，故当”a”删除后list变成了["b","c","d"],然而下标变成了1，这时候取值就是变成了”c”,所以”b”这个元素就自然跳过了。
故我们在进行遍历删除list中元素时要使用Iterator迭代器来操作

变量声明

今天自己写了几行简单测试了下：

1.

System.out.println("----------------start------------------");
        int num = 100000;
        long start = System.currentTimeMillis();
        for (int i = 0; i < 9999999; i++) {
            num += 20000;
        }
        long end = System.currentTimeMillis();
        System.out.println("时间差  >> :" + (end - start));

结果为：

1 2	----------------start------------------ 时间差 >> :2

2.

System.out.println("----------------start------------------");
        Integer num = 100000;
        long start = System.currentTimeMillis();
        for (int i = 0; i < 9999999; i++) {
            num += 20000;
        }
        long end = System.currentTimeMillis();
        System.out.println("时间差  >> :" + (end - start));

结果为：

1 2	----------------start------------------ 时间差 >> :20

结果差了整10倍。想必数据一大自动拆装箱也挺累的吧。故之后变量要多次基本操作声明尽量不用包装类

String相关

intern()

String str = "sss";
String str1 = new String("sss");
String str2 = str1;

System.out.println("str2.intern() == str1 >>" + (str2.intern() == str1));
System.out.println("str2.intern() == str3 >>" + (str2.intern() == str));
System.out.println("str2.intern().equals(str1) >>" + str2.intern().equals(str1));
System.out.println("str2 == str1 >>" + (str2 == str1));
System.out.println("str2.equals(str1) >>" + str2.equals(str1));

结果：

str2.intern() == str1 >>false
str2.intern() == str3 >>true
str2.intern().equals(str1) >>true
str2 == str1 >>true
str2.equals(str1) >>true

我个人理解是，str2.intern()即是str1.intern()指向的故是常量池中的”sss”,常量池中的”sss”就是str,str1指向一个String对象，而equals比较大小就不说了。这里面说得就详细多了。

new String

char[] c = { '1', '2', '3', '4', '5', '6', '7', '8' };
String strC = new String(c, 2, 3);
System.out.println("strC >>" + strC);

int[] arrInt = { 1, 2, 3, 4, 5, 6, 7, 8 };
String strI = new String(arrInt, 2, 3);
System.out.println("strI >>" + strI);

结果：

1 2	strC >>345 strI >>

从下标2位置（包含）开始截取，数量为3

join

1 2	String joinS = String.join(":", "e", "r", "y"); System.out.println("joinS >>" + joinS);

结果：

1	joinS >>e:r:y

我们走进join源码看一下：

public static String join(CharSequence delimiter, CharSequence... elements) {
        Objects.requireNonNull(delimiter);
        Objects.requireNonNull(elements);
        // Number of elements not likely worth Arrays.stream overhead.
        StringJoiner joiner = new StringJoiner(delimiter);
        for (CharSequence cs: elements) {
            joiner.add(cs);
        }
        return joiner.toString();
    }

发现了StringJoiner

StringJoiner

所以也可以这么用：

1
2
3

StringJoiner joiner = new StringJoiner(",");
joiner.add("a").add("b").add("c");
System.out.println(joiner.toString());

结果：

a,b,c

Today End.

Stream简介

什么是聚合操作

Java7的排序、取值实现

Java8的排序、取值实现

Stream总览

什么是流

流的构成

流的使用详解

流的构造与转换

流的操作

进阶：自己生成流

进阶：用Collectors来进行reduction操作

结束语

拥有一个自律的生活

indexedDB简介

与其他前端存储方式对比

indexedDB特性

使用示例

打开数据库

添加数据

删除数据

查找数据

更新对象

关闭与删除数据库

参考资料

对于我来说的黑色六月 2018

股市大震荡

世界杯

分手了

转正了

胡乱写一点

Base64加解密

rotate

tableSizeFor

插入排序 insertion sort

前言

各目录及文件的用途

示例

没有对控件进行设置

限制日期的范围是 2006-09-10到2008-12-20

限制日期的范围是 2008-3-8 11:30:00 到 2008-3-10 20:59:30

限制日期的范围是 2008年2月 到 2008年10月

限制日期的范围是 8:00:00 到 11:30:00

只能选择今天以前的日期(包括今天)

使用了运算表达式 只能选择今天以后的日期(不包括今天)

只能选择本月的日期1号至本月最后一天

只能选择今天7:00:00至明天21:00:00的日期

使用了运算表达式 只能选择 20小时前 至 30小时后 的日期

前面的日期不能大于后面的日期且两个日期都不能大于 2020-10-01

取值和赋值

html:

js:

参考

前言

JPA优点

Dao层

总结

参考资料

总览

Windows Win+R 快捷操作

打开本地服务

打开注册表

打开CMD界面

打开组策略

打开记事本

磁盘清理

查看win版本

打开画图板

远程连接

shutdown

CMD常用命令

查看IP信息

修改本机IP

网络诊断

无线WLAN操作

查看端口状态

Linux常用命令

系统显示

关机、重启

文件和目录

限制日期的范围是 2008年2月到 2008年10月

使用了运算表达式只能选择今天以后的日期(不包括今天)

使用了运算表达式只能选择 20小时前至 30小时后的日期