小决的专栏

辗转相除法

辗转相除法， 又名欧几里德算法（Euclidean algorithm），是求最大公约数的一种方法。它的具体做法是：用较大数除以较小数，再用出现的余数（第一余数）去除除数，再用出现的余数（第二余数）去除第一余数，如此反复，直到最后余数是 0 为止。

public int getVal(int a, int b) {
    int mid;
    while (b != 0) {
        mid = a % b;
        a = b;
        b = mid;
    }
    return a;
}

更相减损术

更相减损术是出自《九章算术》的一种求最大公约数的算法，它原本是为约分而设计的，但它适用于任何需要求最大公约数的场合。

原文是：

可半者半之，不可半者，副置分母、子之数，以少减多，更相减损，求其等也。以等数约之。

白话文译文：

（如果需要对分数进行约分，那么）可以折半的话，就折半（也就是用 2 来约分）。如果不可以折半的话，那么就比较分母和分子的大小，用大数减去小数，互相减来减去，一直到减数与差相等为止，用这个相等的数字来约分。

更相减损术原理：两个正整数 a 和 b（a>b），它们的最大公约数等于 a-b 的差值 c 和较小数 b 的最大公约数。

public int getGCD(int m, int n) {
    while (m != n) {
        if (m > n) {
            m -= n;
        } else {
            n -= m;
        }
    }
    return m;
}

按日期清理

要删除超过 10 天的日志文件，可以使用以下命令。

Unix
find /path/to/httplogs/ -name "*.log" -type f -mtime +10 -exec rm -f {} \;

For Windows Server OS:
forfiles /p "C:\path\to\httplogs" /s /m *.log /d -10 /c "cmd /c del @PATH"

按 Key 升序

Comparator 实现

Map<Integer,Integer> sortMap = new TreeMap<Integer,Integer>(
        new Comparator<Integer>(){
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        }
);

lambda 实现

LinkedHashMap sortMap = map.entrySet().stream()
        .sorted(Map.Entry.comparingByKey())
        .collect(Collectors.toMap(Map.Entry::getKey,Map.Entry::getValue, (e1, e2) -> e2, LinkedHashMap::new));

按 Key 降序

Comparator 实现

Map<Integer,Integer> sortMap = new TreeMap<Integer,Integer>(
        new Comparator<Integer>(){
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        }
);

lambda 实现

LinkedHashMap sortMap = map.entrySet().stream()
        .sorted(Collections.reverseOrder(Map.Entry.comparingByKey()))
        .collect(Collectors.toMap(Map.Entry::getKey,Map.Entry::getValue, (e1, e2) -> e2, LinkedHashMap::new));

按 Value 升序

Comparator 实现

// 定义 Map
Map<Integer, Integer> map = new HashMap<>();
// 排序
Map<Integer, Integer> sortMap = new LinkedHashMap<Integer, Integer>();
List<Map.Entry<Integer, Integer>> entryList = new ArrayList<Map.Entry<Integer, Integer>>(map.entrySet());
Collections.sort(entryList, new Comparator<Map.Entry<Integer, Integer>>(){
    @Override
    public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
        return o1.getValue()-o2.getValue();
    }
});
// 遍历输出
for(Map.Entry<Integer, Integer> tmpEntry:entryList){
    sortMap.put(tmpEntry.getKey(), tmpEntry.getValue());
}

lambda 实现

LinkedHashMap sortMap = map.entrySet().stream()
        .sorted(Map.Entry.comparingByValue())
        .collect(Collectors.toMap(Map.Entry::getKey,Map.Entry::getValue, (e1, e2) -> e2, LinkedHashMap::new));

按 Value 降序

Comparator 实现

// 定义 Map
Map<Integer, Integer> map = new HashMap<>();
// 排序
Map<Integer, Integer> sortMap = new LinkedHashMap<Integer, Integer>();
List<Map.Entry<Integer, Integer>> entryList = new ArrayList<Map.Entry<Integer, Integer>>(map.entrySet());
Collections.sort(entryList, new Comparator<Map.Entry<Integer, Integer>>(){
    @Override
    public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
        return o2.getValue()-o1.getValue();
    }
});
// 遍历输出
for(Map.Entry<Integer, Integer> tmpEntry:entryList){
    sortMap.put(tmpEntry.getKey(), tmpEntry.getValue());
}

lambda 实现

LinkedHashMap sortMap = map.entrySet().stream()
        .sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
        .collect(Collectors.toMap(Map.Entry::getKey,Map.Entry::getValue, (e1, e2) -> e2, LinkedHashMap::new));

自定义复杂排序

按照每个值的频率 升序 排序。如果有多个值的频率相同，按照数值本身将它们 降序 排序。

// 定义 Map
Map<Integer, Integer> map = new HashMap<>();
// 排序
List<Map.Entry<Integer, Integer>> list = new ArrayList<Map.Entry<Integer, Integer>>(map.entrySet());
Collections.sort(list, new Comparator<Map.Entry<Integer, Integer>>() {
    public int compare(Map.Entry<Integer, Integer> o1,
                       Map.Entry<Integer, Integer> o2) {
        int val = o1.getValue().compareTo(o2.getValue());
        if (val == 0) {
            return o2.getKey() - o1.getKey();
        }
        return val;
    }
});
// 遍历输出
for (Map.Entry<Integer, Integer> entry : list) {
    
}

报错内容

Error running ‘HelloWorld’: Command line is too long. Shorten command line for HelloWorld or also for Application default configuration.

解决方法

修改项目下 .idea\workspace.xml，找到标签

<component name="PropertiesComponent">

在标签里加一行

<property name="dynamic.classpath" value="true" />

如下图所示：

<component name="PropertiesComponent">
  <property name="RunOnceActivity.OpenProjectViewOnStart" value="true" />
  <property name="last_opened_file_path" value="$PROJECT_DIR$/src/test/java/com/XXX/util" />
  <property name="project.structure.last.edited" value="Global Libraries" />
  <property name="project.structure.proportion" value="0.0" />
  <property name="project.structure.side.proportion" value="0.2" />
  <property name="dynamic.classpath" value="true" />
</component>

也有可能是以下样式：

<component name="PropertiesComponent"><![CDATA[{
  "keyToString": {
    "RunOnceActivity.OpenProjectViewOnStart": "true",
    "RunOnceActivity.ShowReadmeOnStart": "true",
    "settings.editor.selected.configurable": "preferences.pluginManager"
  }
}]]></component>

添加以下内容即可：

"dynamic.classpath": "true"

最终展示效果为：

<component name="PropertiesComponent"><![CDATA[{
  "keyToString": {
    "RunOnceActivity.OpenProjectViewOnStart": "true",
    "RunOnceActivity.ShowReadmeOnStart": "true",
    "settings.editor.selected.configurable": "preferences.pluginManager",
    "dynamic.classpath": "true"
  }
}]]></component>

fieldset 标签实现

CSS

CSS 样式如下：

fieldset.test {
	font-size:12px;
    padding:10px;
    margin:10px;
    width:270px;
    color:#333; 
    border:#06c solid 1px;
} 
legend {
    color:#06c;
    padding:5px 10px;
    font-weight:800; 
    background:white;
}

HTML

示例 HTML 如下：

<fieldset class="test"> 
	<legend>文字标题</legend> 
    <div>文字内容</div>
</fieldset>

实现效果

加入上述 css 样式：

原生样式效果：

bootstrap 引入冲突

出现问题

当页面引入 bootstrap 时，fieldset 效果消失，如下：

这是由于 bootstrap 重写了 fieldset 标签和其中的 legend 标签样式。

还原设置

fieldset {
    padding: .35em .625em .75em;
    margin: 0 2px;
    border: 1px solid silver;
 }

legend {
    padding: .5em;
    border: 0;
    width: auto;
    margin-bottom: 0px;
 }

效果如下：

纯 CSS 实现效果一

在边框上添加文字。

CSS

CSS 样式如下：

.wrap{
  margin: 100px auto;
  width: 500px;
}
/* 方法实现 */
.method-fieldset{
  position: relative;
  border: 1px solid #ccc;
  padding: 20px;
  box-sizing: border-box;
}
.method-fieldset .title{
	position: absolute;
	top: -13px;
	left: 10%;
	line-height: 2em;
	padding: 0 1em;
	background-color: #fff;
}

HTML

示例 HTML 如下：

<div class="method-fieldset wrap">
  <span class="title">文字标题</span>
  <div class="content">
    <p>文字内容</p>
   </div>
</div>

实现效果

纯 CSS 实现效果二

文字 .title:before 实现分隔效果，并通过 z-index: -1; 置于底部。

CSS

CSS 样式如下：

.wrap{
  margin: 100px auto;
  width: 500px;
}
.method-fieldset .title{
  position: relative;
  text-align: center;
}
.method-fieldset .title:before{
  content: '';
  position: absolute;
  left:0;
  right:0;
  top: 50%;
  border-top: 1px solid #ccc;
  z-index: -1;
}
.method-fieldset .title span{
  padding: 0 1em;
  background-color: #fff;
}
.method-fieldset .content{
  padding:20px;
}

HTML

示例 HTML 如下：

<div class="method-fieldset wrap">
  <div class="title">
    <span>文字标题</span>
  </div>
  <div class="content">文字内容</div>
</div>

实现效果

在我们完成一棵树的构建之后，如果我们想要看这棵树的结构，不像数组或者 List 等数据结构，我们可以非常方便地用各种方式将其中的所有元素打印出来，对于树而言，这个过程要麻烦得多，我们可以用各种遍历方式得到这棵树的结构，但是终究还是不够直观。

如果我们可以按照树的结构，将其打印出来就好了，那么本文就是一种实现这个目标的思路以供参考。