apt-get update
apt-get upgrade

ssh -p <the port you set> name@server.ip

adduser [nickname_you_want]
adduser [nickname_you_want] sudo        # 或者 visudo

# 禁止 ping
echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_all
# 允许 ping
echo 0 > /proc/sys/net/ipv4/icmp_echo_ignore_all

*               hard    maxlogins       2

sudo apt install fail2ban

[DEFAULT]
# "ignoreip" can be an IP address, a CIDR mask or a DNS host. Fail2ban will not
# ban a host which matches an address in this list. Several addresses can be
# defined using space separator.
ignoreip = 127.0.0.1/8 123.45.67.89

# "bantime" is the number of seconds that a host is banned.
bantime  = 31536000            ; 1 year

# A host is banned if it has generated "maxretry" during the last "findtime"
# seconds.
findtime = 600
maxretry = 3

w

last

docker run \
    --volume=/:/rootfs:ro \
    --volume=/var/run:/var/run:rw \
    --volume=/sys:/sys:ro \
    --volume=/var/lib/docker/:/var/lib/docker:ro \
    --publish=8080:8080 \
    --detach=true \
    --name=cadvisor \
    google/cadvisor:latest

--privileged=true

--volume=/cgroup:/cgroup:ro 

wget https://github.com/google/cadvisor/releases/download/v0.26.1/cadvisor
chmod 755 cadvisor
./cadvisor

class Person {

	String name;
	int age;

	Person(String name, int age) {
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() {
		return name;
	}
}

@Test
public void testCollectAdvance() {
	List<Person> persons =
		Arrays.asList(
			new Person("Max", 18),
			new Person("Peter", 23),
			new Person("Pamela", 23),
			new Person("David", 12));

	Supplier<Stream<Person>> supplier = () -> persons.stream();

	Set<Person> nameWithP = supplier.get()
		.filter(p -> p.name.startsWith("P"))
		.collect(Collectors.toSet());
	System.out.println(nameWithP);  // [Pamela, Peter]

	Map<Integer, List<Person>> groupByAge = supplier.get()
		.collect(Collectors.groupingBy(p -> p.age));
	System.out.println(groupByAge);

	Double averageAge = supplier.get()
		.collect(Collectors.averagingInt(p -> p.age));
	System.out.println(averageAge);

	IntSummaryStatistics ageSummary = supplier.get()
		.collect(Collectors.summarizingInt(p -> p.age));
	System.out.println(ageSummary);

	String phrase = supplier.get()
		.filter(p -> p.age >= 18)
		.map(p -> p.name)
		.collect(Collectors.joining(" and ", "In Germany ", " are of legal age."));
	System.out.println(phrase);

	Map<Integer, String> map = supplier.get()
		.collect(Collectors.toMap(
			p -> p.age,
			p -> p.name,
			(name1, name2) -> name1 + ";" + name2
		));
	System.out.println(map);

	// 如果要实现自己的 collector
	Collector<Person, StringJoiner, String> personStringJoinerStringCollector = Collector.of(
		() -> new StringJoiner(" | ", "[ ", " ]"),          // supplier
		(j, p) -> j.add(p.name.toUpperCase()),  // accumulator
		(j1, j2) -> j1.merge(j2),               // combiner
		StringJoiner::toString                  // finisher
	);
	String personStr = supplier.get().collect(personStringJoinerStringCollector);
	System.out.println(personStr);
}

() -> new StringJoiner(" | ")

(joiner, person) -> joiner.add(person.name.toUpperCase())

(j1, j2) -> j1.merge(j2)

class Foo {

	String name;
	List<Bar> bars = new ArrayList<>();

	Foo(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "Foo{" +
			"name='" + name + '\'' +
			", bars=" + bars +
			'}';
	}
}

class Bar {

	String name;

	Bar(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "Bar{" +
			"name='" + name + '\'' +
			'}';
	}
}

@Test
public void testFlatMapAdvanced() {
	List<Foo> foos = Lists.newArrayList();

	IntStream.range(1, 4).forEach(i -> foos.add(new Foo("Foo" + i)));
	foos.forEach(f -> IntStream.range(1, 4)
		.forEach(i -> f.bars.add(new Bar("Bar" + i + " <- " + f.name))));

	Supplier<Stream<Foo>> supplier = foos::stream;
	supplier.get()
		.flatMap(f -> f.bars.stream())
		.forEach(b -> System.out.println(b.name));

	List<Bar> list = supplier.get()
		.flatMap(f -> f.bars.stream())
		.collect(Collectors.toList());
	System.out.println(list);
}

reduce(BinaryOperator<T>)
reduce(T, BinaryOperator<T>)
reduce(U, BiFunction<U, ? super T, U>, BinaryOperator<U>)

List<Person> persons =
    Arrays.asList(
        new Person("Max", 18),
        new Person("Peter", 23),
        new Person("Pamela", 23),
        new Person("David", 12));

Supplier<Stream<Person>> supplier = persons::stream;
supplier.get().reduce((p1, p2) -> p1.age > p2.age ? p1 : p2)
    .ifPresent(System.out::println);

	Person finalPerson = supplier.get()
    .reduce(new Person("", 0), (p1, p2) -> {
        p1.age += p2.age;
        p1.name = p1.name.concat(p2.name);
        return p1;
    });
System.out.println(finalPerson);

Integer totalAge = supplier.get()
    .reduce(
        0,
        (sum, p) -> {
            System.out.format("accumulator: sum=%s; person=%s\n", sum, p);
            return sum += p.age;
        },
        (sum1, sum2) -> {
            System.out.format("combiner: sum1=%s; sum2=%s", sum1, sum2);
            return sum1 + sum2;
        }
    );
System.out.println(totalAge);

accumulator: sum=0; person=Person{name='Max', age=18}
accumulator: sum=18; person=Person{name='Peter', age=23}
accumulator: sum=41; person=Person{name='Pamela', age=23}
accumulator: sum=64; person=Person{name='David', age=12}
76

Integer ageSum = persons
    .parallelStream()
    .reduce(0,
        (sum, p) -> {
            System.out.format("accumulator: sum=%s; person=%s\n", sum, p);
            return sum += p.age;
        },
        (sum1, sum2) -> {
            System.out.format("combiner: sum1=%s; sum2=%s\n", sum1, sum2);
            return sum1 + sum2;
        });

// accumulator: sum=0; person=Pamela
// accumulator: sum=0; person=David
// accumulator: sum=0; person=Max
// accumulator: sum=0; person=Peter
// combiner: sum1=18; sum2=23
// combiner: sum1=23; sum2=12
// combiner: sum1=41; sum2=35

docker volume create my-vol          # 创建数据卷
docker volume ls                     # 查看所有数据卷
docker volume inspect my-vol         # 查看指定数据卷内容
docker run -d -P \
    --name web \
    # -v my-vol:/wepapp \
    --mount source=my-vol,target=/webapp \
    training/webapp \
    python app.py                   # 启动并挂载一个数据卷 使用 `--mount`
docker inspect web                  # 查看容器中 mount 信息
docker volume rm my-vol             # 移除数据卷

docker volume prune

volumes:
  db_data:

[DOCKER_COMPOSE_NAME]_[VOLUME_NAME]

docker run --rm \ 
  --volume [DOCKER_COMPOSE_PREFIX]_[VOLUME_NAME]:/[TEMPORARY_DIRECTORY_TO_STORE_VOLUME_DATA] \
  --volume $(pwd):/[TEMPORARY_DIRECTORY_TO_STORE_BACKUP_FILE] \
  alpine \
  tar cvf /[TEMPORARY_DIRECTORY_TO_STORE_BACKUP_FILE]/[BACKUP_FILENAME].tar /[TEMPORARY_DIRECTORY_TO_STORE_VOLUME_DATA]

docker run --rm \ 
  --volume [DOCKER_COMPOSE_PREFIX]_[VOLUME_NAME]:/[TEMPORARY_DIRECTORY_STORING_EXTRACTED_BACKUP] \
  --volume $(pwd):/[TEMPORARY_DIRECTORY_TO_STORE_BACKUP_FILE] \
  alpine \
  tar xvf /[TEMPORARY_DIRECTORY_TO_STORE_BACKUP_FILE]/[BACKUP_FILENAME].tar -C /[TEMPORARY_DIRECTORY_STORING_EXTRACTED_BACKUP] --strip 1

docker exec [CONTAINER_NAME] /usr/bin/mysqldump -u root --password=root [DATABASE] > backup.sql

cat backup.sql | docker exec -i [CONTAINER_NAME] /usr/bin/mysql -u root --password=root [DATABASE]

curl -sSL https://get.docker.com | sh

sudo usermod -aG docker pi

FROM resin/rpi-raspbian:latest
ENTRYPOINT []

RUN apt-get update && \
    apt-get -qy install curl ca-certificates

CMD ["curl", "https://docker.com"]

FROM arm32v6/alpine:3.5

RUN apk add --no-cache curl ca-certificates

CMD ["curl", "https://docker.com"]

docker build -t curl_docker .
docker run curl_docker

gpu_mem=16

pt-online-schema-change [OPTIONS] DSN

--user:
-u，连接的用户名
--password：
-p，连接的密码
--database：
-D，连接的数据库
--port
-P，连接数据库的端口
--host:
-h，连接的主机地址
--socket:
-S，连接的套接字文件
--ask-pass
隐式输入连接 MySQL 的密码
--charset
指定修改的字符集
--defaults-file
-F，读取配置文件
--alter：
结构变更语句，不需要 alter table 关键字。可以指定多个更改，用逗号分隔。如下场景，需要注意：
    不能用 RENAME 来重命名表。
    列不能通过先删除，再添加的方式进行重命名，不会将数据拷贝到新列。
    如果加入的列非空而且没有默认值，则工具会失败。即其不会为你设置一个默认值，必须显示指定。
    删除外键 (drop foreign key constrain_name) 时，需要指定名称_constraint_name，而不是原始的 constraint_name。
    如：CONSTRAINT `fk_foo` FOREIGN KEY (`foo_id`) REFERENCES `bar` (`foo_id`)，需要指定：--alter "DROP FOREIGN KEY _fk_foo"
--alter-foreign-keys-method
如何把外键引用到新表？需要特殊处理带有外键约束的表，以保证它们可以应用到新表。当重命名表的时候，外键关系会带到重命名后的表上。
该工具有两种方法，可以自动找到子表，并修改约束关系。
auto： 在 rebuild_constraints 和 drop_swap 两种处理方式中选择一个。
rebuild_constraints：使用 ALTER TABLE 语句先删除外键约束，然后再添加。如果子表很大的话，会导致长时间的阻塞。
drop_swap： 执行 FOREIGN_KEY_CHECKS=0, 禁止外键约束，删除原表，再重命名新表。这种方式很快，也不会产生阻塞，但是有风险：
1, 在删除原表和重命名新表的短时间内，表是不存在的，程序会返回错误。
2, 如果重命名表出现错误，也不能回滚了。因为原表已经被删除。
none： 类似"drop_swap"的处理方式，但是它不删除原表，并且外键关系会随着重命名转到老表上面。
--[no]check-alter
默认 yes，语法解析。配合 --dry-run 和 --print 一起运行，来检查是否有问题（change column，drop primary key）。
--max-lag
默认 1s。每个 chunk 拷贝完成后，会查看所有复制 Slave 的延迟情况。要是延迟大于该值，则暂停复制数据，直到所有从的滞后小于这个值，使用 Seconds_Behind_Master。如果有任何从滞后超过此选项的值，则该工具将睡眠 --check-interval 指定的时间，再检查。如果从被停止，将会永远等待，直到从开始同步，并且延迟小于该值。如果指定 --check-slave-lag，该工具只检查该服务器的延迟，而不是所有服务器。
--check-slave-lag
指定一个从库的 DSN 连接地址，如果从库超过 --max-lag 参数设置的值，就会暂停操作。
--recursion-method
默认是 show processlist，发现从的方法，也可以是 host，但需要在从上指定 report_host，通过 show slave hosts 来找到，可以指定 none 来不检查 Slave。
METHOD       USES
===========  ==================
processlist  SHOW PROCESSLIST
hosts        SHOW SLAVE HOSTS
dsn=DSN      DSNs from a table
none         Do not find slaves
指定 none 则表示不在乎从的延迟。
--check-interval
默认是 1。--max-lag 检查的睡眠时间。

--[no]check-plan
默认 yes。检查查询执行计划的安全性。

--[no]check-replication-filters
默认 yes。如果工具检测到服务器选项中有任何复制相关的筛选，如指定 binlog_ignore_db 和 replicate_do_db 此类。发现有这样的筛选，工具会报错且退出。因为如果更新的表 Master 上存在，而 Slave 上不存在，会导致复制的失败。使用–no-check-replication-filters 选项来禁用该检查。

--[no]swap-tables
默认 yes。交换原始表和新表，除非你禁止 --[no]drop-old-table。

--[no]drop-triggers
默认 yes，删除原表上的触发器。 --no-drop-triggers 会强制开启 --no-drop-old-table 即：不删除触发器就会强制不删除原表。

--new-table-name
复制创建新表的名称，默认 %T_new。

--[no]drop-new-table
默认 yes。删除新表，如果复制组织表失败。

--[no]drop-old-table
默认 yes。复制数据完成重命名之后，删除原表。如果有错误则会保留原表。

--max-load
默认为 Threads_running=25。每个 chunk 拷贝完后，会检查 SHOW GLOBAL STATUS 的内容，检查指标是否超过了指定的阈值。如果超过，则先暂停。这里可以用逗号分隔，指定多个条件，每个条件格式： status 指标 =MAX_VALUE 或者 status 指标：MAX_VALUE。如果不指定 MAX_VALUE，那么工具会这只其为当前值的 120%。

--critical-load
默认为 Threads_running=50。用法基本与 --max-load 类似，如果不指定 MAX_VALUE，那么工具会这只其为当前值的 200%。如果超过指定值，则工具直接退出，而不是暂停。

--default-engine
默认情况下，新的表与原始表是相同的存储引擎，所以如果原来的表使用 InnoDB 的，那么新表将使用 InnoDB 的。在涉及复制某些情况下，很可能主从的存储引擎不一样。使用该选项会默认使用默认的存储引擎。

--set-vars
设置 MySQL 变量，多个用逗号分割。默认该工具设置的是： wait_timeout=10000 innodb_lock_wait_timeout=1 lock_wait_timeout=60

--chunk-size-limit
当需要复制的块远大于设置的 chunk-size 大小，就不复制。默认值是 4.0，一个没有主键或唯一索引的表，块大小就是不确定的。

--chunk-time
在 chunk-time 执行的时间内，动态调整 chunk-size 的大小，以适应服务器性能的变化，该参数设置为 0, 或者指定 chunk-size, 都可以禁止动态调整。

--chunk-size
指定块的大小，默认是 1000 行，可以添加 k,M,G 后缀。这个块的大小要尽量与 --chunk-time 匹配，如果明确指定这个选项，那么每个块就会指定行数的大小。

--[no]check-plan
默认 yes。为了安全，检查查询的执行计划。默认情况下，这个工具在执行查询之前会先 EXPLAIN, 以获取一次少量的数据，如果是不好的 EXPLAIN, 那么会获取一次大量的数据，这个工具会多次执行 EXPALIN, 如果 EXPLAIN 不同的结果，那么就会认为这个查询是不安全的。
--statistics
打印出内部事件的数目，可以看到复制数据插入的数目。
--dry-run
创建和修改新表，但不会创建触发器、复制数据、和替换原表。并不真正执行，可以看到生成的执行语句，了解其执行步骤与细节。--dry-run 与 --execute 必须指定一个，二者相互排斥。和 --print 配合最佳。
--execute
确定修改表，则指定该参数。真正执行。--dry-run 与 --execute 必须指定一个，二者相互排斥。
--print
打印 SQL 语句到标准输出。指定此选项可以让你看到该工具所执行的语句，和 --dry-run 配合最佳。
--progress
复制数据的时候打印进度报告，二部分组成：第一部分是百分比，第二部分是时间。
--quiet
-q，不把信息标准输出。

CREATE TABLE `online_table` (
  `id` int(11) primary key,
  `name` varchar(10) DEFAULT NULL,
  `age` int(11) DEFAULT NULL
) engine = innodb default charset utf8;

pt-online-schema-change --user=root --password=123456 --host=127.0.0.1  --alter "ADD COLUMN content text" D=test,t=online_table --print --dry-run

pt-online-schema-change --user=root --password=123456 --host=127.0.0.1  --alter "ADD COLUMN content text" D=test,t=online_table --print --execute

> describe online_table;
+---------+-------------+------+-----+---------+----------------+
| Field   | Type        | Null | Key | Default | Extra          |
+---------+-------------+------+-----+---------+----------------+
| id      | int(11)     | NO   | PRI | NULL    | auto_increment |
| name    | varchar(10) | YES  |     | NULL    |                |
| age     | int(11)     | YES  |     | NULL    |                |
| content | text        | YES  |     | NULL    |                |
+---------+-------------+------+-----+---------+----------------+
4 rows in set (0.00 sec)

Error setting innodb_lock_wait_timeout: DBD::mysql::db do failed: Variable ‘innodb_lock_wait_timeout’ is a read only variable [for Statement “SET SESSION innodb_lock_wait_timeout=1”]. The current value for innodb_lock_wait_timeout is 50. If the variable is read only (not dynamic), specify –set-vars innodb_lock_wait_timeout=50 to avoid this warning, else manually set the variable and restart MySQL. 根据提示（innodb_lock_wait_timeout 是静态参数），加上–set-vars innodb_lock_wait_timeout=50 即可：


pt-online-schema-change --user=root --passwor=root --host=localhost  --alter "ADD COLUMN content text" D=test,t=user --set-vars innodb_lock_wait_timeout=50 --print --execute

> describe tmp_test;
+-------+-------------+------+-----+---------+----------------+
| Field | Type        | Null | Key | Default | Extra          |
+-------+-------------+------+-----+---------+----------------+
| id    | int(11)     | NO   | PRI | NULL    | auto_increment |
| name  | varchar(10) | YES  |     | NULL    |                |
+-------+-------------+------+-----+---------+----------------+

pt-online-schema-change --user=root --host=127.0.0.1 --alter "ADD COLUMN content text" D=crm_production,t=tmp_test --ask-pass  --print --execute
Enter MySQL password:

Replication filters are set on these hosts:
database2
replicate_do_db = crm_production
Please read the –check-replication-filters documentation to learn how to solve this problem. at /usr/local/bin/pt-online-schema-change line 8015, line 2.

pt-online-schema-change --user=root --host=127.0.0.1  --alter "ADD COLUMN content text" D=crm_production,t=tmp_test --ask-pass --no-check-replication-filters  --print --execute

create table tt(
    id int not null auto_increment,
    name varchar(10),primary key(id)
) engine=innodb default charset utf8;

create table xx(
    id int not null auto_increment,
    tt_id int not null,
    name varchar(10),
    primary key(id)
) engine=innodb default charset utf8;

alter table xx add foreign key fk_xx_tt_id(tt_id) references tt(id);

pt-online-schema-change --user=root --password=123456 --host=127.0.0.1 --alter "ADD COLUMN content text" D=test,t=tt --no-check-replication-filters --print --execute

pt-online-schema-change --user=root --password=123456 --host=127.0.0.1  --alter "ADD COLUMN content text" D=test,t=tt --no-check-replication-filters --alter-foreign-keys-method auto --print --execute

--alter-foreign-keys-method rebuild_constraints

CREATE TABLE `tmp_test` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(10) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8

pt-online-schema-change --user=root --password=123456 --host=127.0.0.1  --alter "ADD COLUMN content text" D=test,t=tmp_test --no-check-replication-filters --alter-foreign-keys-method=auto --recursion-method=none --print --execute

pt-online-schema-change --user=root --password=123456 --host=127.0.0.1  --alter "DROP COLUMN content " D=test,t=tmp_test --no-check-replication-filters --alter-foreign-keys-method=auto --recursion-method=none --quiet --execute

pt-online-schema-change --user=root --password=123456 --host=127.0.0.1  --alter "MODIFY COLUMN age TINYINT NOT NULL DEFAULT 0" D=test,t=tmp_test --no-check-replication-filters --alter-foreign-keys-method=auto --recursion-method=none --quiet --execute

pt-online-schema-change --user=root --password=123456 --host=127.0.0.1  --alter "CHANGE COLUMN age address varchar(30)" D=test,t=tmp_test --no-check-alter --no-check-replication-filters --alter-foreign-keys-method=auto --recursion-method=none --quiet --execut

pt-online-schema-change --user=root --password=123456 --host=127.0.0.1  --alter "ADD INDEX idx_address(address)" D=test,t=tmp_test --no-check-alter --no-check-replication-filters --alter-foreign-keys-method=auto --recursion-method=none --print --execute

pt-online-schema-change --user=root --password=123456 --host=127.0.0.1  --alter "DROP INDEX idx_address" D=test,t=tmp_test --no-check-alter --no-check-replication-filters --alter-foreign-keys-method=auto --recursion-method=none --print --execute

pt-online-schema-change --user=root --password=123456 --host=127.0.0.1  --alter "ADD COLUMN a text" D=test,t=test_binlog --no-check-replication-filters --no-drop-old-table --print --execute

pt-online-schema-change --user=root --password=123456 --host=127.0.0.1  --alter "add INDEX idx_address(address)" D=test,t=tmp_test --no-check-alter --no-check-replication-filters --alter-foreign-keys-method=auto --recursion-method=none --max-load=Threads_running=2 --statistics --print --execute

List<String> list = Arrays.asList("a", "b", "a", "c").stream()
        .distinct()
        .collect(Collectors.toList());
System.out.println(list); //[a, b, c]

List<Integer> list = IntStream.range(1, 10)
        .filter(i -> i % 2 == 0)
        .boxed()
        .collect(Collectors.toList());
System.out.println(list); // [2, 4, 6, 8]

List<Integer> ints = IntStream.of(1,2,3,4,5)
                .boxed()
                .collect(Collectors.toList());

List<Integer> list = Stream.of("A", "B", "C")
        .map(c -> c.hashCode())
        .collect(Collectors.toList());
System.out.println(list); // [65, 66, 67]

Stream.of("a1", "a2", "a3")
    .map(s -> s.substring(1))
    .mapToInt(Integer::parseInt)
    .max()
    .ifPresent(System.out::println);  // 3

<R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)

List<List<String>> lists = Arrays.asList(Arrays.asList("a", "b"), Arrays.asList("c", "d"));
List<String> collect = lists.stream()
        .flatMap(Collection::stream)
        .collect(Collectors.toList());
System.out.println(collect); // [a, b, c, d]

List<Integer> l = IntStream.range(1,100).limit(5)
        .boxed()
        .collect(Collectors.toList());
System.out.println(l);//[1, 2, 3, 4, 5]

String[] arr = new String[]{"a","b","c","d"};
Arrays.stream(arr)
        .peek(System.out::println) //a,b,c,d
        .count();

List<String> list = Arrays.asList("ac", "ab", "bc", "dc", "ad", "ea").stream()
        .sorted((a, b) -> {
            if (a.charAt(0) == b.charAt(0)) {
                return a.substring(1).compareTo(b.substring(1));
            } else {
                return b.charAt(0) - a.charAt(0);
            }
        }).collect(Collectors.toList());
System.out.println(list);

System.out.println(Stream.of(1, 2, 3, 4, 5).allMatch(i -> i > 0)); //true
System.out.println(Stream.of(1, 2, 3, 4, 5).anyMatch(i -> i > 0)); //true
System.out.println(Stream.of(1, 2, 3, 4, 5).noneMatch(i -> i > 0)); //false
System.out.println(Stream.<Integer>empty().allMatch(i -> i > 0)); //true
System.out.println(Stream.<Integer>empty().anyMatch(i -> i > 0)); //false
System.out.println(Stream.<Integer>empty().noneMatch(i -> i > 0)); //true

long count = Stream.of(1, 2, 3, 4).count();
System.out.println(count);

mapToLong(e -> 1L).sum();

.collect(Collectors.toList());

Stream.of(1,2,3,4,5).forEach(System.out::println);

pubic Optional<T> reduce(BinaryOperator<T> accumulator)
pubic T reduce(T identity, BinaryOperator<T> accumulator)
pubic <U> U	reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner)

Optional<Integer> total = Stream.of(1,2,3,4,5).reduce( (x, y) -> x +y);
Integer total2 = Stream.of(1,2,3,4,5).reduce(0, (x, y) -> x +y);

Stream<String> stream =
    Stream.of("d2", "a2", "b1", "b3", "c")
        .filter(s -> s.startsWith("a"));

stream.anyMatch(s -> true);    // ok
stream.noneMatch(s -> true);   // exception

java.lang.IllegalStateException: stream has already been operated upon or closed
    at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:229)
    at java.util.stream.ReferencePipeline.noneMatch(ReferencePipeline.java:459)
    at com.winterbe.java8.Streams5.test7(Streams5.java:38)
    at com.winterbe.java8.Streams5.main(Streams5.java:28)

Supplier<Stream<String>> streamSupplier =
    () -> Stream.of("d2", "a2", "b1", "b3", "c")
            .filter(s -> s.startsWith("a"));

streamSupplier.get().anyMatch(s -> true);   // ok
streamSupplier.get().noneMatch(s -> true);  // ok

docker run -d \
  --name=nginxtest \
  --mount source=nginx-vol,destination=/usr/share/nginx/html \
  nginx:latest

docker run -d \
  --name=nginxtest \
  -v nginx-vol:/usr/share/nginx/html \
  nginx:latest