发表于 | 分类于
字数统计: 375 | 阅读时长 ≈ 2

题目描述

你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。

假设你有 n 个版本 [1, 2, …, n]，你想找出导致之后所有版本出错的第一个错误的版本。

你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

示例:

1
2
3
4
5
6
7
给定 n = 5，并且 version = 4 是第一个错误的版本。

调用 isBadVersion(3) -> false
调用 isBadVersion(5) -> true
调用 isBadVersion(4) -> true

所以，4 是第一个错误的版本。

方法一：二叉树

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Solution extends VersionControl {
    public int firstBadVersion(int n) {
       int start=1;
       int end=n;
       //这里不能使用int half=(start+end)/2;
       //当数值过大，相加之后会进行反转操作，变为负数，从而影响计算
       int half=start/2+end/2;
       while(start<end){
           if(isBadVersion(half)){
               end=half;
           }else{
               start=half+1;
           }
           half=start/2+end/2;
       }
       return start;
    }
}

  • 执行用时 :13 ms, 在所有 java 提交中击败了89.64%的用户

  • 内存消耗 :32.7 MB, 在所有 java 提交中击败了71.38%的用户

发表于 | 分类于 ，
字数统计: 979 | 阅读时长 ≈ 4

Linux scp 命令用于 Linux 之间复制文件和目录。

scp 是 secure copy 的缩写, scp 是 linux 系统下基于 ssh 登陆进行安全的远程文件拷贝命令。

scp 是加密的，rcp 是不加密的，scp 是 rcp 的加强版。

语法

1
2
3
scp [-1246BCpqrv] [-c cipher] [-F ssh_config] [-i identity_file]
[-l limit] [-o ssh_option] [-P port] [-S program]
[[user@]host1:]file1 [...] [[user@]host2:]file2

简易写法:

1
scp [可选参数] file_source file_target

参数说明：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
-1： 强制scp命令使用协议ssh1
-2： 强制scp命令使用协议ssh2
-4： 强制scp命令只使用IPv4寻址
-6： 强制scp命令只使用IPv6寻址
-B： 使用批处理模式（传输过程中不询问传输口令或短语）
-C： 允许压缩。（将-C标志传递给ssh，从而打开压缩功能）
-p：保留原文件的修改时间，访问时间和访问权限。
-q： 不显示传输进度条。
-r： 递归复制整个目录。
-v：详细方式显示输出。scp和ssh(1)会显示出整个过程的调试信息。这些信息用于调试连接，验证和配置问题。
-c cipher： 以cipher将数据传输进行加密，这个选项将直接传递给ssh。
-F ssh_config： 指定一个替代的ssh配置文件，此参数直接传递给ssh。
-i identity_file： 从指定文件中读取传输时使用的密钥文件，此参数直接传递给ssh。
-l limit： 限定用户所能使用的带宽，以Kbit/s为单位。
-o ssh_option： 如果习惯于使用ssh_config(5)中的参数传递方式，
-P port：注意是大写的P, port是指定数据传输用到的端口号
-S program： 指定加密传输时所使用的程序。此程序必须能够理解ssh(1)的选项。

实例

从本地复制到远程

命令格式：

1
2
3
4
5
6
7
scp local_file remote_username@remote_ip:remote_folder 
或者 
scp local_file remote_username@remote_ip:remote_file 
或者 
scp local_file remote_ip:remote_folder 
或者 
scp local_file remote_ip:remote_file

  • 第1,2个指定了用户名，命令执行后需要再输入密码，第1个仅指定了远程的目录，文件名字不变，第2个指定了文件名；

  • 第3,4个没有指定用户名，命令执行后需要输入用户名和密码，第3个仅指定了远程的目录，文件名字不变，第4个指定了文件名；

应用实例：

1
2
3
4
scp /home/space/music/1.mp3 root@www.runoob.com:/home/root/others/music 
scp /home/space/music/1.mp3 root@www.runoob.com:/home/root/others/music/001.mp3 
scp /home/space/music/1.mp3 www.runoob.com:/home/root/others/music 
scp /home/space/music/1.mp3 www.runoob.com:/home/root/others/music/001.mp3

复制目录命令格式：

1
2
3
scp -r local_folder remote_username@remote_ip:remote_folder 
或者 
scp -r local_folder remote_ip:remote_folder

  • 第1个指定了用户名，命令执行后需要再输入密码；

  • 第2个没有指定用户名，命令执行后需要输入用户名和密码；

应用实例：

1
2
scp -r /home/space/music/ root@www.runoob.com:/home/root/others/ 
scp -r /home/space/music/ www.runoob.com:/home/root/others/

上面命令将本地 music 目录复制到远程 others 目录下。

从远程复制到本地

从远程复制到本地，只要将从本地复制到远程的命令的后2个参数调换顺序即可，如下实例

应用实例：

1
2
scp root@www.runoob.com:/home/root/others/music /home/space/music/1.mp3 
scp -r www.runoob.com:/home/root/others/ /home/space/music/

说明

如果远程服务器防火墙有为scp命令设置了指定的端口，我们需要使用 -P 参数来设置命令的端口号，命令格式如下：

1
2
#scp 命令使用端口号 4588
scp -P 4588 remote@www.runoob.com:/usr/local/sin.sh /home/administrator

使用scp命令要确保使用的用户具有可读取远程服务器相应文件的权限，否则scp命令是无法起作用的。

发表于 | 分类于
字数统计: 562 | 阅读时长 ≈ 3

题目描述

给你一个字符串 text，你需要使用 text 中的字母来拼凑尽可能多的单词 “balloon”（气球）。

字符串 text 中的每个字母最多只能被使用一次。请你返回最多可以拼凑出多少个单词 “balloon”。

示例 1：

1
2
输入：text = "nlaebolko"
输出：1

示例 2：

1
2
输入：text = "loonbalxballpoon"
输出：2

示例 3：

1
2
输入：text = "leetcode"
输出：0

提示：
1 <= text.length <= 10^4
text 全部由小写英文字母组成

方法一：字母计算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Solution {
    public int maxNumberOfBalloons(String text) {
        int ans = 10000;String began = "balloon";
        int [] arr = new int [26];
        char [] textCharArr = text.toCharArray();
        for (int i = 0; i < textCharArr.length; i++){
            arr[textCharArr[i]-'a']++;
        }
        arr['l' - 'a'] = arr['l' - 'a']/2;//因为气球单词中l为两个，因此除2减半
        arr['o' - 'a'] = arr['o' - 'a']/2; //因为气球单词中o为两个，因此除2减半
        int [] arrNew = new int [7];
        for (int i = 0; i < arrNew.length; i++){
            arrNew[i] = arr[began.charAt(i) - 'a'];
        }
        for (int i = 0; i < arrNew.length; i++){
            ans = Math.min(ans,arrNew[i]);
        }
        return ans;
    }
}
  • 执行用时 :1 ms, 在所有 java 提交中击败了100.00%的用户
  • 内存消耗 :37.5 MB, 在所有 java 提交中击败了100.00%的用户

方法二：正则计算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Solution {
  public static int maxNumberOfBalloons(String text) {
        int maxCount = text.length();
        String[] regexs = new String[]{"b", "a", "l", "o", "n"};
        for (String regex : regexs) {
            Matcher matcher = Pattern.compile(regex).matcher(text);

            int count =0;
            while(matcher.find()){
                count++;
            }
            if (regex.equals("o") || regex.equals("l")) {
                count /= 2;
            }
            maxCount = Math.min(maxCount, count);
        }
        return maxCount;
    }
}
  • 执行用时 :8 ms, 在所有 java 提交中击败了35.31%的用户
  • 内存消耗 :36.8 MB, 在所有 java 提交中击败了100.00%的用户

方法三：替换

1
2
3
4
5
6
7
8
9
10
11
12
class Solution {
    public int maxNumberOfBalloons(String text) {
        int b = text.length() - text.replace("b", "").length();
    	int a = text.length() - text.replace("a", "").length();
        int l  = (text.length() - text.replace("l", "").length())/2;
        int o = (text.length() - text.replace("o", "").length())/2;
        int n = text.length() - text.replace("n", "").length();
        int [] arr = new int[]{b,a,l,o,n};
        Arrays.sort(arr);
        return arr[0];
    }
}
  • 执行用时 :14 ms, 在所有 java 提交中击败了19.70%的用户
  • 内存消耗 :36.7 MB, 在所有 java 提交中击败了100.00%的用户

发表于 | 分类于
字数统计: 1,055 | 阅读时长 ≈ 4

题目描述

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

1
2
3
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

方法一：暴力法

暴力法很简单，遍历每个元素 x，并查找是否存在一个值与 target - x 相等的目标元素。

1
2
3
4
5
6
7
8
9
10
11
12
class Solution {
    public int[] twoSum(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[j] == target - nums[i]) {
                    return new int[] { i, j };
                }
            }
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}

复杂度分析：

  • 时间复杂度：O(n^2)，对于每个元素，我们试图通过遍历数组的其余部分来寻找它所对应的目标元素，这将耗费 O(n) 的时间。因此时间复杂度为 O(n^2)。

  • 空间复杂度：O(1)。

方法二：两遍哈希表

为了对运行时间复杂度进行优化，我们需要一种更有效的方法来检查数组中是否存在目标元素。如果存在，我们需要找出它的索引。保持数组中的每个元素与其索引相互对应的最好方法是什么？哈希表。

通过以空间换取速度的方式，我们可以将查找时间从 O(n) 降低到 O(1)。哈希表正是为此目的而构建的，它支持以 近似 恒定的时间进行快速查找。我用“近似”来描述，是因为一旦出现冲突，查找用时可能会退化到 O(n)。但只要你仔细地挑选哈希函数，在哈希表中进行查找的用时应当被摊销为 O(1)。

一个简单的实现使用了两次迭代。在第一次迭代中，我们将每个元素的值和它的索引添加到表中。然后，在第二次迭代中，我们将检查每个元素所对应的目标元素（target - nums[i]）是否存在于表中。注意，该目标元素不能是 nums[i] 本身！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            map.put(nums[i], i);
        }
        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];
            if (map.containsKey(complement) && map.get(complement) != i) {
                return new int[] { i, map.get(complement) };
            }
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}

复杂度分析：

  • 时间复杂度：O(n)，我们把包含有 n 个元素的列表遍历两次。由于哈希表将查找时间缩短到 O(1)，所以时间复杂度为 O(n)。

  • 空间复杂度：O(n)，所需的额外空间取决于哈希表中存储的元素数量，该表中存储了 n 个元素。

方法三：一遍哈希表

事实证明，我们可以一次完成。在进行迭代并将元素插入到表中的同时，我们还会回过头来检查表中是否已经存在当前元素所对应的目标元素。如果它存在，那我们已经找到了对应解，并立即将其返回。

1
2
3
4
5
6
7
8
9
10
11
12
13
class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];
            if (map.containsKey(complement)) {
                return new int[] { map.get(complement), i };
            }
            map.put(nums[i], i);
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}

复杂度分析：

  • 时间复杂度：O(n)，我们只遍历了包含有 n 个元素的列表一次。在表中进行的每次查找只花费 O(1) 的时间。

  • 空间复杂度：O(n)，所需的额外空间取决于哈希表中存储的元素数量，该表最多需要存储 n 个元素。

[转载自]

[作者]：LeetCode
[链接]：https://leetcode-cn.com/problems/two-sum/solution/liang-shu-zhi-he-by-leetcode-2/
[来源]：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

发表于 | 分类于 ，
字数统计: 281 | 阅读时长 ≈ 1

成长是一场冒险 迷途的人先上路

年少时处处风景 不想回头

成长是一场游戏 勇敢的人先开始

跌撞再慌张前行 不说回头
行歌，在草长莺飞的季节里喃喃低唱

走过人潮汹涌忽然止步

怎么，热烈时一步倦怠一步回望阑珊处

从前轻狂绕过时光

成长是一场失去 肩负枉然的意义

无论你懂得与否 不能回头

从哪来要往哪去 曾听爱的人说起

就此匆忙的错过 不必回头

行歌，在恍然半生的好景里不再多想

走过平淡日常忽然止步

怎么，伶仃时一步漠然一步回首梦尽处

从前轻狂绕过时光

行歌，谁在一边走一边唱一边回头张望

有些苦涩始终都要去尝

怎么，这些年不会失望也不太提及过往

从前轻狂绕过时光

让我们彼此分享互相陪伴吧

一起面对人生这一刻的孤独吧

从前轻狂绕过时光

发表于 | 分类于 ，
字数统计: 524 | 阅读时长 ≈ 3

资源加载器

使用Java，您可以使用当前线程的classLoader并尝试加载文件，但是Spring Framework为您提供了更为优雅的解决方案，例如ResourceLoader。

您只需要自动连接ResourceLoader，然后调用getResource(“somePath”)方法即可。

在Spring Boot（WAR）中从资源目录/类路径加载文件的示例

在下面的示例中，我们从类路径中加载名为GeoLite2-Country.mmdb的文件作为资源，然后将其作为File对象检索。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
@Service("geolocationservice")
public class GeoLocationServiceImpl implements GeoLocationService {

    private static final Logger LOGGER = LoggerFactory.getLogger(GeoLocationServiceImpl.class);

    private static DatabaseReader reader = null;

    private ResourceLoader resourceLoader;

    @Autowired
    public GeoLocationServiceImpl(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }

    @PostConstruct
    public void init() {
        try {
            LOGGER.info("GeoLocationServiceImpl: Trying to load GeoLite2-Country database...");

            Resource resource = resourceLoader.getResource("classpath:GeoLite2-Country.mmdb");
            File dbAsFile = resource.getFile();

            // Initialize the reader
            reader = new DatabaseReader
                        .Builder(dbAsFile)
                        .fileMode(Reader.FileMode.MEMORY)
                        .build();

            LOGGER.info("GeoLocationServiceImpl: Database was loaded successfully.");

        } catch (IOException | NullPointerException e) {
            LOGGER.error("Database reader cound not be initialized. ", e);
        }
    }

    @PreDestroy
    public void preDestroy() {
        if (reader != null) {
            try {
                reader.close();
            } catch (IOException e) {
                LOGGER.error("Failed to close the reader.");
            }
        }
    }
}

从Spring Boot JAR加载文件

如果您想从Spring Boot JAR中的 classpath加载文件，则必须使用该resource.getInputStream()方法将其作为InputStream检索。如果尝试使用resource.getFile()该方法，则会收到错误消息，因为Spring尝试访问文件系统路径，但无法访问JAR中的路径。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
@Service("geolocationservice")
public class GeoLocationServiceImpl implements GeoLocationService {

    private static final Logger LOGGER = LoggerFactory.getLogger(GeoLocationServiceImpl.class);

    private static DatabaseReader reader = null;
    private ResourceLoader resourceLoader;

    @Inject
    public GeoLocationServiceImpl(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }

    @PostConstruct
    public void init() {
        try {
            LOGGER.info("GeoLocationServiceImpl: Trying to load GeoLite2-Country database...");

            Resource resource = resourceLoader.getResource("classpath:GeoLite2-Country.mmdb");
            InputStream dbAsStream = resource.getInputStream(); // <-- this is the difference

            // Initialize the reader
            reader = new DatabaseReader
                        .Builder(dbAsStream)
                        .fileMode(Reader.FileMode.MEMORY)
                        .build();

            LOGGER.info("GeoLocationServiceImpl: Database was loaded successfully.");

        } catch (IOException | NullPointerException e) {
            LOGGER.error("Database reader cound not be initialized. ", e);
        }
    }

    @PreDestroy
    public void preDestroy() {
        if (reader != null) {
            try {
                reader.close();
            } catch (IOException e) {
                LOGGER.error("Failed to close the reader.");
            }
        }
    }
}

发表于 | 分类于 ，
字数统计: 3,223 | 阅读时长 ≈ 13

概述

Java 8 引入的 Lambda 表达式的主要作用就是简化部分匿名内部类的写法。
能够使用 Lambda 表达式的一个重要依据是必须有相应的函数接口。所谓函数接口，是指内部有且仅有一个抽象方法的接口。
Lambda 表达式的另一个依据是类型推断机制。在上下文信息足够的情况下，编译器可以推断出参数表的类型，而不需要显式指名。

常见用法

无参函数的简写

无参函数就是没有参数的函数，例如Runnable接口的run() 方法，其定义如下：

1
2
3
4
@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

在 Java 7 及之前版本，我们一般可以这样使用：

1
2
3
4
5
6
7
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello");
        System.out.println("Jimmy");
    }
}).start();

从 Java 8 开始，无参函数的匿名内部类可以简写成如下方式：

1
2
3
() -> {
    执行语句
}

这样接口名和函数名就可以省掉了。那么，上面的示例可以简写成：

1
2
3
4
new Thread(() -> {
    System.out.println("Hello");
    System.out.println("Jimmy");
}).start();

当只有一条语句时，我们还可以对代码块进行简写，格式如下：

1
() -> 表达式

注意这里使用的是表达式，并不是语句，也就是说不需要在末尾加分号。
那么，当上面的例子中执行的语句只有一条时，可以简写成这样：

1
new Thread(() -> System.out.println("Hello")).start();

单参函数的简写

单参函数是指只有一个参数的函数。例如 View 内部的接口 OnClickListener的方法onClick(View v)，其定义如下：

1
2
3
4
5
6
7
8
public interface OnClickListener {
    /**
     * Called when a view has been clicked.
     *
     * @param v The view that was clicked.
     */
    void onClick(View v);
}

在 Java 7 及之前的版本，我们通常可能会这么使用：

1
2
3
4
5
6
view.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        v.setVisibility(View.GONE);
    }
});

从 Java 8 开始，单参函数的匿名内部类可以简写成如下方式：

1
2
3
([类名 ]变量名) -> {
    执行语句
}

其中类名是可以省略的，因为Lambda 表达式可以自己推断出来。那么上面的例子可以简写成如下两种方式：

1
2
3
4
5
6
view.setOnClickListener((View v) -> {
    v.setVisibility(View.GONE);
});
view.setOnClickListener((v) -> {
    v.setVisibility(View.GONE);
});

单参函数甚至可以把括号去掉，官方也更建议使用这种方式：

1
2
3
变量名 -> {
    执行语句
}

那么，上面的示例可以简写成：

1
2
3
view.setOnClickListener(v -> {
    v.setVisibility(View.GONE);
});

当只有一条语句时，依然可以对代码块进行简写，格式如下：

1
([类名 ]变量名) -> 表达式

类名和括号依然可以省略，如下：

1
变量名 -> 表达式复制代码

那么，上面的示例可以进一步简写成：

1
view.setOnClickListener(v -> v.setVisibility(View.GONE));

多参函数的简写

多参函数是指具有两个及以上参数的函数。例如，Comparator 接口的compare(T o1, T o2)方法就具有两个参数，其定义如下：

1
2
3
4
@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
}

在 Java 7 及之前的版本，当我们对一个集合进行排序时，通常可以这么写：

1
2
3
4
5
6
7
List<Integer> list = Arrays.asList(1, 2, 3);
Collections.sort(list, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1.compareTo(o2);
    }
});

从 Java 8 开始，多参函数的匿名内部类可以简写成如下方式：

1
2
3
([类名1 ]变量名1, [类名2 ]变量名2[, ...]) -> {
    执行语句
}

同样类名可以省略，那么上面的例子可以简写成：

1
2
3
4
5
6
Collections.sort(list, (Integer o1, Integer o2) -> {
    return o1.compareTo(o2);
});
Collections.sort(list, (o1, o2) -> {
    return o1.compareTo(o2);
});

当只有一条语句时，依然可以对代码块进行简写，格式如下：

1
([类名1 ]变量名1, [类名2 ]变量名2[, ...]) -> 表达式

此时类名也是可以省略的，但括号不能省略。如果这条语句需要返回值，那么return关键字是不需要写的。
因此，上面的示例可以进一步简写成：

1
Collections.sort(list, (o1, o2) -> o1.compareTo(o2));

最后呢，这个示例还可以简写成这样：

1
Collections.sort(list, Integer::compareTo);

咦，这是什么特性？这就是我们下面要讲的内容：方法引用。

方法引用

方法引用也是一个语法糖，可以用来简化开发。
在我们使用Lambda 表达式的时候，如果->的右边要执行的表达式只是调用一个类已有的方法，那么就可以用「方法引用」来替代Lambda表达式。

方法引用可以分为 4 类：

  • 引用静态方法；
  • 引用对象的方法；
  • 引用类的方法；
  • 引用构造方法。

下面按照这 4 类分别进行阐述。

引用静态方法

当我们要执行的表达式是调用某个类的静态方法，并且这个静态方法的参数列表和接口里抽象函数的参数列表一一对应时，我们可以采用引用静态方法的格式。

假如 Lambda 表达式符合如下格式：

1
([变量1, 变量2, ...]) -> 类名.静态方法名([变量1, 变量2, ...])

我们可以简写成如下格式：

1
类名::静态方法名

注意这里静态方法名后面不需要加括号，也不用加参数，因为编译器都可以推断出来。下面我们使用示例来进行说明。

首先创建一个工具类，代码如下：

1
2
3
4
5
public class Utils {
    public static int compare(Integer o1, Integer o2) {
        return o1.compareTo(o2);
    }
}

注意这里的 compare() 函数的参数和 Comparable 接口的 compare() 函数的参数是一一对应的。然后一般的 Lambda 表达式可以这样写：

1
Collections.sort(list, (o1, o2) -> Utils.compare(o1, o2));

如果采用方法引用的方式，可以简写成这样：

1
Collections.sort(list, Utils::compare);

引用对象的方法

当我们要执行的表达式是调用某个对象的方法，并且这个方法的参数列表和接口里抽象函数的参数列表一一对应时，我们就可以采用引用对象的方法的格式。

假如 Lambda 表达式符合如下格式：

1
([变量1, 变量2, ...]) -> 对象引用.方法名([变量1, 变量2, ...])

我们可以简写成如下格式：

1
对象引用::方法名

下面我们使用示例来进行说明。首先创建一个类，代码如下：

1
2
3
4
5
public class MyClass {
    public int compare(Integer o1, Integer o2) {
        return o1.compareTo(o2);
    }
}

当我们创建一个该类的对象，并在 Lambda 表达式中使用该对象的方法时，一般可以这么写：

1
2
MyClass myClass = new MyClass();
Collections.sort(list, (o1, o2) -> myClass.compare(o1, o2));

注意这里函数的参数也是一一对应的，那么采用方法引用的方式，可以这样简写：

1
2
MyClass myClass = new MyClass();
Collections.sort(list, myClass::compare);

此外，当我们要执行的表达式是调用 Lambda 表达式所在的类的方法时，我们还可以采用如下格式：

1
this::方法名

例如我在 Lambda 表达式所在的类添加如下方法：

1
2
3
private int compare(Integer o1, Integer o2) {
    return o1.compareTo(o2);
}

当 Lambda 表达式使用这个方法时，一般可以这样写：

1
Collections.sort(list, (o1, o2) -> compare(o1, o2));

如果采用方法引用的方式，就可以简写成这样：

1
Collections.sort(list, this::compare);

引用类的方法

引用类的方法所采用的参数对应形式与上两种略有不同。如果 Lambda 表达式的->的右边要执行的表达式是调用的->的左边第一个参数的某个实例方法，并且从第二个参数开始（或无参）对应到该实例方法的参数列表时，就可以使用这种方法。

可能有点绕，假如我们的 Lambda 表达式符合如下格式：

1
(变量1[, 变量2, ...]) -> 变量1.实例方法([变量2, ...])

那么我们的代码就可以简写成：

1
变量1对应的类名::实例方法名

当我们使用的 Lambda 表达式是这样时：

1
Collections.sort(list, (o1, o2) -> o1.compareTo(o2));

按照上面的说法，就可以简写成这样：

1
Collections.sort(list, Integer::compareTo);

引用构造方法

当我们要执行的表达式是新建一个对象，并且这个对象的构造方法的参数列表和接口里函数的参数列表一一对应时，我们就可以采用「引用构造方法」的格式。

假如我们的 Lambda 表达式符合如下格式：

1
([变量1, 变量2, ...]) -> new 类名([变量1, 变量2, ...])

我们就可以简写成如下格式：

1
类名::new

下面举个例子说明一下。Java 8 引入了一个 Function 接口，它是一个函数接口，部分代码如下：

1
2
3
4
5
6
7
8
9
10
11
@FunctionalInterface
public interface Function<T, R> {
    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);
        // 省略部分代码
}

我们用这个接口来实现一个功能，创建一个指定大小的 ArrayList。一般我们可以这样实现：

1
2
3
4
5
6
7
Function<Integer, ArrayList> function = new Function<Integer, ArrayList>() {
    @Override
    public ArrayList apply(Integer n) {
        return new ArrayList(n);
    }
};
List list = function.apply(10);

使用 Lambda 表达式，我们一般可以这样写：

1
Function<Integer, ArrayList> function = n -> new ArrayList(n);

使用「引用构造方法」的方式，我们可以简写成这样：

1
Function<Integer, ArrayList> function = ArrayList::new;

自定义函数接口

自定义函数接口很容易，只需要编写一个只有一个抽象方法的接口即可，示例代码：

1
2
3
4
@FunctionalInterface
public interface MyInterface<T> {
    void function(T t);
}

上面代码中的 @FunctionalInterface 是可选的，但加上该注解编译器会帮你检查接口是否符合函数接口规范。就像加入 @Override 注解会检查是否重写了函数一样。

实现原理

经过上面的介绍，我们看到 Lambda 表达式只是为了简化匿名内部类书写，看起来似乎在编译阶段把所有的 Lambda 表达式替换成匿名内部类就可以了。但实际情况并非如此，在 JVM 层面，Lambda 表达式和匿名内部类其实有着明显的差别。

匿名内部类的实现

匿名内部类仍然是一个类，只是不需要我们显式指定类名，编译器会自动为该类取名。比如有如下形式的代码：

1
2
3
4
5
6
7
8
9
10
public class LambdaTest {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello World");
            }
        }).start();
    }
}

编译之后将会产生两个 class 文件：

1
2
LambdaTest.class
LambdaTest$1.class

使用 javap -c LambdaTest.class 进一步分析 LambdaTest.class的字节码，部分结果如下：

1
2
3
4
5
6
7
8
9
10
public static void main(java.lang.String[]);
  Code:
     0: new           #2                  // class java/lang/Thread
     3: dup
     4: new           #3                  // class com/example/myapplication/lambda/LambdaTest$1
     7: dup
     8: invokespecial #4                  // Method com/example/myapplication/lambda/LambdaTest$1."<init>":()V
    11: invokespecial #5                  // Method java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
    14: invokevirtual #6                  // Method java/lang/Thread.start:()V
    17: return

可以发现在 4: new #3 这一行创建了匿名内部类的对象。

Lambda 表达式的实现

接下来我们将上面的示例代码使用 Lambda 表达式实现，代码如下：

1
2
3
4
5
public class LambdaTest {
    public static void main(String[] args) {
        new Thread(() -> System.out.println("Hello World")).start();
    }
}

此时编译后只会产生一个文件 LambdaTest.class，再来看看通过 javap 对该文件反编译后的结果：

1
2
3
4
5
6
7
8
public static void main(java.lang.String[]);
  Code:
     0: new           #2                  // class java/lang/Thread
     3: dup
     4: invokedynamic #3,  0              // InvokeDynamic #0:run:()Ljava/lang/Runnable;
     9: invokespecial #4                  // Method java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
    12: invokevirtual #5                  // Method java/lang/Thread.start:()V
    15: return

从上面的结果我们发现 Lambda 表达式被封装成了主类的一个私有方法，并通过 invokedynamic 指令进行调用。

因此，我们可以得出结论：Lambda 表达式是通过 invokedynamic 指令实现的，并且书写 Lambda 表达式不会产生新的类。
既然 Lambda 表达式不会创建匿名内部类，那么在 Lambda 表达式中使用 this 关键字时，其指向的是外部类的引用。

优缺点

优点：

  • 可以减少代码的书写，减少匿名内部类的创建，节省内存占用。
  • 使用时不用去记忆所使用的接口和抽象函数。

缺点：

  • 易读性较差，阅读代码的人需要熟悉 Lambda 表达式和抽象函数中参数的类型。
  • 不方便进行调试。

[转载自]

作者：Android大强哥
链接：https://juejin.im/post/5db04b0b518825646f239b36
来源：掘金
著作权归作者所有

发表于 | 分类于
字数统计: 403 | 阅读时长 ≈ 2

官方地址

官方写的很详细并且是中文的,一步步按照操作就可以
https://www.zabbix.com/documentation/3.4/zh/manual/installation/containers

启动一个空的Mysql服务器实例

1
2
3
4
5
6
7
docker run --name mysql-server -t \
      -e MYSQL_DATABASE="zabbix" \
      -e MYSQL_USER="zabbix" \
      -e MYSQL_PASSWORD="zabbix" \
      -e MYSQL_ROOT_PASSWORD="zabbix" \
      -d mysql:5.7  \
--character-set-server=utf8 --collation-server=utf8_bin

启动Zabbix server实例，并关联这个实例到已创建的MySQL服务器实例

1
2
3
4
5
6
7
8
9
docker run --name zabbix-server-mysql -t \
      -e DB_SERVER_HOST="mysql-server" \
      -e MYSQL_DATABASE="zabbix" \
      -e MYSQL_USER="zabbix" \
      -e MYSQL_PASSWORD="zabbix" \
      -e MYSQL_ROOT_PASSWORD="zabbix" \
      --link mysql-server:mysql \
      -p 10051:10051 \
      -d zabbix/zabbix-server-mysql:latest

启动Zabbix web 接口，并将它与MySQL服务器实例和Zabbix server实例关联

1
2
3
4
5
6
7
8
9
10
docker run --name zabbix-web-nginx-mysql -t \
      -e DB_SERVER_HOST="mysql-server" \
      -e MYSQL_DATABASE="zabbix" \
      -e MYSQL_USER="zabbix" \
      -e MYSQL_PASSWORD="zabbix" \
      -e MYSQL_ROOT_PASSWORD="zabbix" \
      --link mysql-server:mysql \
      --link zabbix-server-mysql:zabbix-server \
      -p 8080:80 \
      -d zabbix/zabbix-web-nginx-mysql:latest

查看容器启动情况

1
2
3
4
5
[root@zabbix_server ~]# docker ps
CONTAINER ID        IMAGE                                  COMMAND                  CREATED              STATUS              PORTS                           NAMES
98cbe8d8a6bd        zabbix/zabbix-web-nginx-mysql:latest   "docker-entrypoint.sh"   6 seconds ago        Up 5 seconds        443/tcp, 0.0.0.0:8080->80/tcp   zabbix-web-nginx-mysql
de040d43d60f        zabbix/zabbix-server-mysql:latest      "docker-entrypoint.sh"   59 seconds ago       Up 59 seconds       0.0.0.0:10051->10051/tcp        zabbix-server-mysql
3276f18def8d        mysql:5.7                              "docker-entrypoint.s…"   About a minute ago   Up About a minute   3306/tcp                        mysql-server

查看docker镜像

1
2
3
4
5
[root@zabbix_server ~]# docker images
REPOSITORY                      TAG                 IMAGE ID            CREATED             SIZE
zabbix/zabbix-web-nginx-mysql   latest              4db891b4393a        10 hours ago        177MB
zabbix/zabbix-server-mysql      latest              f5e58dafe9ac        10 hours ago        62.2MB
mysql                           5.7                 f0f3956a9dd8        7 days ago          409MB

访问web界面

1
http://127.0.0.1:8080

帐号密码:

账号：Admin
默认密码：zabbix

发表于 | 分类于 ，
字数统计: 351 | 阅读时长 ≈ 1

文件表达式

1
2
3
4
5
6
7
8
9
10
11
-e filename 如果 filename存在，则为真
-d filename 如果 filename为目录，则为真
-f filename 如果 filename为常规文件，则为真
-L filename 如果 filename为符号链接，则为真
-r filename 如果 filename可读，则为真
-w filename 如果 filename可写，则为真
-x filename 如果 filename可执行，则为真
-s filename 如果文件长度不为0，则为真
-h filename 如果文件是软链接，则为真
filename1 -nt filename2 如果 filename1比 filename2新，则为真。
filename1 -ot filename2 如果 filename1比 filename2旧，则为真。

整数变量表达式

1
2
3
4
5
6
-eq 等于
-ne 不等于
-gt 大于
-ge 大于等于
-lt 小于
-le 小于等于

字符串变量表达式

1
2
3
4
5
6
If  [ $a = $b ]                 如果string1等于string2，则为真
# 字符串允许使用赋值号做等号
if  [ $string1 !=  $string2 ]   如果string1不等于string2，则为真
if  [ -n $string  ]             如果string 非空(非0），返回0(true)
if  [ -z $string  ]             如果string 为空，则为真
if  [ $sting ]                  如果string 非空，返回0 (和-n类似)

逻辑表达式

1
2
3
4
5
6
7
# 逻辑非 !条件表达式的相反
if [ ! 表达式 ]
if [ ! -d $num ]如果不存在目录$num
# 逻辑与 –a   条件表达式的并列
if [ 表达式1  –a  表达式2 ]
# 逻辑或 -o    条件表达式的或
if [ 表达式1  –o 表达式2 ]

发表于 | 分类于
字数统计: 1,372 | 阅读时长 ≈ 6

服务权限

systemd有系统和用户区分；

  1. 系统（/user/lib/systemd/system/）
  2. 用户（/etc/lib/systemd/user/）.

一般系统管理员手工创建的单元文件建议存放在/etc/systemd/system/目录下面。

创建服务文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
[Unit]
Description=nginx - high performance web server
Documentation=http://nginx.org/en/docs/
After=network.target remote-fs.target nss-lookup.target
  
[Service]
Type=forking
PIDFile=/run/nginx.pid
ExecStartPre=/usr/sbin/nginx -t -c /etc/nginx/nginx.conf
ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s QUIT $MAINPID
PrivateTmp=true
  
[Install]
WantedBy=multi-user.target

[Unit]

Description: 服务的简单描述

Documentation: 服务文档

Before、After: 定义启动顺序。

  1. Before=xxx.service,代表本服务在xxx.service启动之前启动。
  2. After=xxx.service,代表本服务在xxx.service之后启动。

Requires：这个单元启动了，它需要的单元也会被启动；它需要的单元被停止了，这个单元也停止了。

Wants：推荐使用。这个单元启动了，它需要的单元也会被启动；它需要的单元被停止了，对本单元没有影响。

[Service]

Type=simple（默认值）：systemd认为该服务将立即启动。服务进程不会fork。如果该服务要启动其他服务，不要使用此类型启动，除非该服务是socket激活型。

Type=forking：systemd认为当该服务进程fork，且父进程退出后服务启动成功。对于常规的守护进程（daemon），除非你确定此启动方式无法满足需求，使用此类型启动即可。使用此启动类型应同时指定 PIDFile=，以便systemd能够跟踪服务的主进程。

Type=oneshot：这一选项适用于只执行一项任务、随后立即退出的服务。可能需要同时设置 RemainAfterExit=yes 使得 systemd 在服务进程退出之后仍然认为服务处于激活状态。

Type=notify：与 Type=simple 相同，但约定服务会在就绪后向 systemd 发送一个信号。这一通知的实现由 libsystemd-daemon.so 提供。

Type=dbus：若以此方式启动，当指定的 BusName 出现在DBus系统总线上时，systemd认为服务就绪。

Type=idle: systemd会等待所有任务(Jobs)处理完成后，才开始执行idle类型的单元。除此之外，其他行为和Type=simple 类似。

PIDFile：pid文件路径

ExecStart：指定启动单元的命令或者脚本，ExecStartPre和ExecStartPost节指定在ExecStart之前或者之后用户自定义执行的脚本。Type=oneshot允许指定多个希望顺序执行的用户自定义命令。

ExecReload：指定单元重载时执行的命令或者脚本。

ExecStop：指定单元停止时执行的命令或者脚本。

PrivateTmp：True表示给服务分配独立的临时空间

Restart：这个选项如果被允许，服务重启的时候进程会退出，会通过systemctl命令执行清除并重启的操作。

RemainAfterExit：如果设置这个选择为真，服务会被认为是在激活状态，即使所以的进程已经退出，默认的值为假，这个选项只有在Type=oneshot时需要被配置。

[Install]

Alias：为单元提供一个空间分离的附加名字。

RequiredBy：单元被允许运行需要的一系列依赖单元，RequiredBy列表从Require获得依赖信息。

WantBy：单元被允许运行需要的弱依赖性单元，Wantby从Want列表获得依赖信息。

Also：指出和单元一起安装或者被协助的单元。

DefaultInstance：实例单元的限制，这个选项指定如果单元被允许运行默认的实例。

自启服务

systemctl enable nginx.service（设置开机自启）

就会在/etc/systemd/system/multi-user.target.wants/目录下新建一个/usr/lib/systemd/system/nginx.service 文件的链接。

操作服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#启动服务
$ sudo systemctl start nginx.service
  
#查看日志
$ sudo journalctl -f -u nginx.service
— Logs begin at 四 2015-06-25 17:32:20 CST. —
6月 25 10:28:24 Leco.lan systemd[1]: Starting nginx – high performance web server…
6月 25 10:28:24 Leco.lan nginx[7976]: nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
6月 25 10:28:24 Leco.lan nginx[7976]: nginx: configuration file /etc/nginx/nginx.conf test is successful
6月 25 10:28:24 Leco.lan systemd[1]: Started nginx – high performance web server.
  
#重启
$ sudo systemctl restart nginx.service
  
#重载
$ sudo systemctl reload nginx.service
  
#停止
$ sudo systemctl stop nginx.service
PS：使用命令 systemctl is-enabled postfix.service 得到的值可以是enable、disable或static，这里的 static 它是指对应的 Unit 文件中没有定义[Install]区域，因此无法配置为开机启动服务。 


#刚刚配置的服务需要让systemctl能识别，就必须刷新配置
$ systemctl daemon-reload
如果没有权限可以使用sudo
$ sudo systemctl daemon-reload
  • 启动一个服务：systemctl start nginx.service
  • 关闭一个服务：systemctl stop postfix.service
  • 重启一个服务：systemctl restart nginx.service
  • 显示一个服务的状态：systemctl status postfix.service
  • 在开机时启用一个服务：systemctl enable nginx.service
  • 在开机时禁用一个服务：systemctl disable nginx.service
  • 查看服务是否开机启动：systemctl is-enabled nginx.service
  • 查看已启动的服务列表：systemctl list-unit-files|grep enabled
  • 查看启动失败的服务列表：systemctl –failed

例子

1
2
3
4
5
6
7
8
9
10
11
12
[Unit]
Description=redis server
After=network.target

[Service]
Type=forking
ExecStart=/usr/local/redis/utils/redis_init_script start
ExecReload=/usr/local/redis/utils/redis_init_script stop && /usr/local/redis/utils/redis_init_script start
ExecStop=/usr/local/redis/utils/redis_init_script stop

[Install]
WantedBy=multi-user.target