## 前言

> 本文搬运自编程随想09年的文章，较为古老，但涉及到性能优化，想必还是有一些用的。

点击【阅读全文】查看正文。

<div class="article-ads"></div>



## 字符串过滤实战

[上一个帖子](https://oldmoon.top/post/86)已经介绍了基本类型和引用类型的性能差异（主要是由于内存分配方式不同导致）。为了给列位看官加深印象，今天拿一个具体的例子来实地操作一把，看看优化的效果如何。

### ★一个简单的需求

首先描述一下需求：给定一个 String 对象，过滤掉除了数字（字符'0'到'9'）以外的其它字符。要求时间开销尽可能小。过滤函数的原型如下：
```
String filter(String str);
```
针对上述需求，俺写了5个不同的过滤函数。为了叙述方便，函数名分别定为 filter1 到 filter5。其中 filter1 性能最差、filter5 性能最好。在看后续的内容之前，你先暗自思考一下，如果由你来实现该函数，大概会写成什么样？最好把你想好的函数写下来，便于跟俺给出的例子作对比。


### ★代码——循序渐进的5种实现方式

#### ◇测试代码

为了方便测试性能，先准备好一坨测试代码，具体如下：

```java
class Test
{
    public static void main(String[] args)
    {
        if(args.length != 1)
        {
            return;
        }

        String str = "";
        long nBegin = System.currentTimeMillis();
        for(int i=0; i<1024*1024; i++)
        {
            str = filterN(args[0]);  // 此处调用某个具体的过滤函数
        }
        long nEnd = System.currentTimeMillis();

        System.out.println(nEnd-nBegin);
        System.out.println(str);
    }
};
```

在没有想好你的实现方式之前，先别偷看后续内容哦！另外，先注明一下，俺的 Java 环境是 JDK 1.5.0-09，使用的测试字符串是随机生成的，长度32个 char，只含字母和数字。由于 JDK 版本和机器性能不尽相同，你在自己机器上测试的结果可能跟俺下面给出的数值不太一样。

#### ◇版本1

先来揭晓性能最差的filter1，代码如下：
```java
private static String filter1(String strOld)
{
    String strNew = new String();
    for(int i=0; i<strOld.length(); i++)
    {
        if('0'<=strOld.charAt(i) && strOld.charAt(i)<='9')
        {
            strNew += strOld.charAt(i);
        }
    }
    return strNew;
}
```

如果你的代码不幸和 filter1 雷同，那你的 Java 功底可就是相当糟糕了，连字符串拼接需要用 StringBuffer 来优化都没搞明白。

为了和后续对比，先记下 filter1 的处理时间，大约在 8.81-8.90秒 之间。

#### ◇版本2

再来看看 filter2，代码如下：
```java
private static String filter2(String strOld)
{
    StringBuffer strNew = new StringBuffer();
    for(int i=0; i<strOld.length(); i++)
    {
        if('0'<=strOld.charAt(i) && strOld.charAt(i)<='9')
        {
            strNew.append(strOld.charAt(i));
        }
    }
    return strNew.toString();
}
```

其实刚才在评价 filter1 的时候，已经泄露了 filter2 的天机。filter2 通过使用 StringBuffer 来优化连接字符串的性能。为什么 StringBuffer 连接字符串的性能比 String 好，这个已经是老生常谈，俺在这儿就不细说啦。尚不清楚的同学自己上 Google 一查便知。估计应该有挺多同学会写出类似 filter2 的代码。

有些同学可能会问：为啥不用 StringBuilder？

确实，在 JDK 1.5 新增加了 StringBuilder 这个类，其性能会比 StringBuffer 更好。不过捏，考虑到有可能要拿到其它版本的 JDK 上作对比测试，而且 StringBuilder 和 StringBuffer 之间的差异【不是】本文讨论的重点，所以后面的例子都使用 StringBuffer 来实现。

filter2 的处理时间大约为 2.14-2.18秒，提升了大约4倍。

#### ◇版本3

接着看看 filter3，代码如下：
```java
private static String filter3(String strOld)
{
    StringBuffer strNew = new StringBuffer();
    int nLen = strOld.length();
    for(int i=0; i<nLen; i++)
    {
        char ch = strOld.charAt(i);
        if('0'<=ch && ch<='9')
        {
            strNew.append(ch);
        }
    }
    return strNew.toString();
}
```

乍一看，filter3 和 filter2 的代码差不多嘛！再仔细瞧一瞧，原来先把 strOld.charAt(i) 赋值给 char 变量，节省了重复调用 charAt() 方法的开销；另外把 strOld.length() 先保存为 nLen，也节省了重复调用 length() 的开销。能想到这一步的同学，估计是比较细心的。

经过此一优化，处理时间节省为 1.48-1.52秒，提升了约30%。由于 charAt() 和 length() 的内部实现都挺简单的，所以提升的性能不太明显。

另外补充一下，经网友反馈，在 JDK 1.6 上，filter3 和 filter2 的性能基本相同。俺估计：可能是因为 JDK 1.6 在编译时已经进行了相关的优化。

#### ◇版本4

然后看看 filter4，代码如下：
```java
private static String filter4(String strOld)
{
    int nLen = strOld.length();
    StringBuffer strNew = new StringBuffer(nLen);
    for(int i=0; i<nLen; i++)
    {
        char ch = strOld.charAt(i);
        if('0'<=ch && ch<='9')
        {
            strNew.append(ch);
        }
    }
    return strNew.toString();
}
```

filter4 和 filter3 差别也很小，唯一差别就在于调用了 StringBuffer 带参数的构造函数。通过 StringBuffer 的构造函数设置初始的容量大小，可以有效避免 append() 追加字符时重新分配内存，从而提高性能。

filter4 的处理时间大约在 1.33-1.39秒，约提高10%左右。可惜提升的幅度有点小 :-(

#### ◇版本5

最后来看看“终极版本”——性能最好的 filter5。
```java
private static String filter5(String strOld)
{
    int nLen = strOld.length();
    char[] chArray = new char[nLen];
    int nPos = 0;
    for(int i=0; i<nLen; i++)
    {
        char ch = strOld.charAt(i);
        if('0'<=ch && ch<='9')
        {
            chArray[nPos] = ch;
            nPos++;
        }
    }
    return new String(chArray, 0, nPos);
}
```

猛一看，你可能会想：这个 filter5 和前几个版本的差别也忒大了吧！filter5 既没有用 String 也没有用 StringBuffer，而是拿字符数组进行中间处理。

filter5 的处理时间，只用了0.72-0.78秒，相对于 filter4 提升了将近50%。为啥捏？是不是因为直接操作字符数组，节省了 append(char) 的调用？通过查看 append(char) 的源代码，内部的实现很简单，应该不至于提升这么多。

**那是什么原因捏？**

首先，虽然 filter5 有一个字符数组的创建开销，但是相对于 filter4 来说，StringBuffer 的构造函数内部也会有字符数组的创建开销。两相抵消。所以 filter5 比 filter4 还多节省了 StringBuffer 对象本身的创建开销。（在俺的 JDK 1.5 环境中，这个因素比较明显）

其次，由于 StringBuffer 是线程安全的（它的方法都是 synchronized），因此调用它的方法有一定的同步开销，而字符数组则没有，这又是一个性能提升的地方。（经热心读者反馈，此因素在 JDK 1.6 中比较明显）

基于上述两个因素，所以 filter5 比 filter4 又有较大幅度的提升。

### ★对于5个版本的总结

上述5个版本，filter1 和 filter5 的性能相差约12倍（已经超过一个数量级）。除了 filter3 相对于 filter2 是通过消除函数重复调用来提升性能，其它的几个版本都是通过节省内存分配，降低了时间开销。可见内存分配对于性能的影响有多大啊！如果你是看了上一个帖子才写出 filter4 或者 filter5，那说明你已经领会了个中奥妙，俺那个帖子也就没白写了。

### ★补充说明

关于时间和空间的平衡

需要补充说明一下。版本4和版本5使用了空间换时间的手法来提升性能。假如被过滤的字符串【很大】，并且数字字符的比例【很低】，这种方式就不太合算了。

举个例子：被处理的字符串中，绝大部分都只含有不到10%的数字字符，只有少数字符串包含较多的数字字符。这时候该怎么办捏？

对于 filter4 来说，可以把 new StringBuffer(nLen); 修改为 new StringBuffer(nLen/10); 来节约空间开销。但是 filter5 就没法这么玩了。

所以，具体该用“版本4”还是“版本5”，要看具体情况了。只有在你【非常】看重时间开销，且数字字符比例很高（至少大于50%）的情况下，用 filter5 才合算。否则的话，建议用 filter4。

[下一个帖子](https://oldmoon.top/post/88)，打算介绍一下“关于垃圾回收（GC）”的话题。

<div class="article-ads"></div>

Java性能优化2：字符串过滤实战

## 前言

> 本文搬运自编程随想09年的文章，较为古老，但涉及到性能优化，想必还是有一些用的。

点击【阅读全文】查看正文。

<div class="article-ads"></div>


## 概述

考虑写性能优化系列，主要是因为之前看到了太多性能其烂无比的 Java 代码（有些代码看得俺口瞪目呆）。很多 Java 程序员在写程序时，由于不太了解 JVM 及语言本身的一些运作机制，从而导致了代码的性能出现【严重】问题（性能差一个数量级以上，我才称为“严重”）。

虽然网上也有针对 Java 性能的介绍，但是很多内容都仅仅告诉读者“该这么做”，而没有讲“为什么该这么做”。典型的例子就是关于 String 和 StringBuffer（StringBuilder），光介绍如何用，却没有说为什么这样用。这种现象导致了很多 Java 程序员只知其然，不知其所以然。所以本系列帖子会尽量介绍一些“所以然”的东东（也就是学习技术三部曲的 HOW 和 WHY），希望对 Java 程序员有所帮助。

先初步考虑聊如下几个话题：
1. [基本类型 vs 引用类型](https://oldmoon.top/post/86)(本文)
2. [字符串过滤实战](https://oldmoon.top/post/87)
3. [关于垃圾回收（GC）](https://oldmoon.top/post/88)
4. [finalize函数](https://oldmoon.top/post/89)

## 基本类型 vs 引用类型

在 Java 性能优化系列中，内存管理是一个要优先考虑的关键因素。而说到内存分配，就必然会涉及到基本类型和引用类型。所以我们今天就先来介绍一下这两种类型在性能方面各自有什么奥妙（关于引用类型的其它奥妙，请看“这里”）。


### ★名词定义

先明确一下什么是“基本类型”，什么是“引用类型”。
简单地说，所谓基本类型就是 Java 语言中如下的8种内置类型：
- boolean
- char
- byte
- short
- int
- long
- float
- double

而引用类型就是那些可以通过 new 来创建对象的类型（基本上都是派生自 Object）。

### ★两种类型的存储方式

这两种类型的差异，首先体现在存储方式上。

- ◇引用类型的创建

当你在函数中创建一个引用类型的对象时，比如下面这句：`StringBuffer str = new StringBuffer();` 该 StringBuffer 【对象】的内容是存储在堆（Heap）上的，需要申请堆内存。而变量 str 只不过是针对该 StringBuffer 对象的一个引用（或者叫地址）。变量 str 的【值】（也就是 StringBuffer 对象的地址）是存储在【栈】上的。

- ◇基本类型的创建

当你在【函数中}创建一个基本类型的变量时，比如下面这句：`int n = 123;`这个变量 n 的【值】也是存储在栈（Stack）上的，但是这个语句不需要再从堆中申请内存了。

为了更加形象，便于大伙儿理解，简单画了一个示意图如下：

![](https://images.oldmoon.top/images/dingdangdog/dingdangdog-1681455457966.jpg)

### ★堆和栈的性能差异

　　可能有同学会小声问：堆和栈有啥区别捏？
　　要说堆和栈的差别，那可就大了去了。如果你对这两个概念还是不太明白或者经常混淆，建议先找本操作系统的书拜读一下。
　　由于本系列是介绍性能，所以来讨论一下堆和栈在性能方面的差别（这个差异是很大滴）。堆相对进程来说是全局的，能够被所有线程访问；而栈是线程局部的，只能本线程访问。打个比方，栈就好比个人小金库，堆就好比国库。你从个人小金库拿钱去花，不需要办什么手续，拿了就花，但是钱数有限；而国库里面的钱虽然很多，但是每次申请花钱要打报告、盖图章、办 N 多手续，耗时又费力。
　　同样道理，由于堆是所有线程共有的，从堆里面申请内存要进行相关的加锁操作，因此申请堆内存的复杂度和时间开销比栈要大很多；从栈里面申请内存，虽然又简单又快，但是栈的大小有限，分配不了太多内存。


### ★当初为啥这样设计？

可能有同学又问了，干嘛把两种类型分开存储，干嘛不放到一起捏？这个问题问得好！下面我们就来揣测一下，当初 Java 为啥设计成这样。

当年 Java 它爹（James Gosling）设计语言的时候，对于这个问题有点进退两难。如果把各种东东都放置到栈中，显然不现实，一来栈是线程私有的（不便于共享），二来栈的大小是有限的，三来栈的结构也间接限制了它的用途。那为啥不把各种东东都放置到堆里面捏？都放堆里面，倒是能绕过上述问题，但是刚才也提到了，申请堆内存要办很多手续，太繁琐。如果仅仅在函数中写一个简单的“int n = 0;”，也要到堆里面去分配内存，那性能就大大滴差了（要知道 Java 是1995年生出来的，那年头俺买了台 PC 配【4兆内存】就属豪华配置了）。

左思右想之后，Java 它爹只好做了一个折中：把类型分为“基本类型”和“引用类型”，两者使用不同的创建方式。这种差异从 Java 语法上也可以看出来：引用类型总是用 new 创建对象（提醒一下：某些单键对象/单例对象，表面上没用 new，但是在 getInstance() 内部也还是用 new 创建的）；而基本类型则【不需要】用 new 来创建。


### ★这样设计的弊端

顺便跑题一下，斗胆评价 Java 它爹这种设计的弊端（希望 Java Fans 不要跟我急）。我个人认为：这个折中的决策，带来了许多深远的影响，随手举出几个例子：
1. 由于基本类型不是派生自 Object，因此不能算是纯种的对象。这导致了 Java 的“【纯】面向对象”招牌打了折扣（当年 Sun 老是吹嘘 Java 是“纯”OO 的语言，其实 Java 的 OO 是不够纯粹滴）。
2. 由于基本类型不是派生自 Object，出于某些场合（比如容器类）的考虑，不得不为每个基本类型加上对应的包装类（比如 Integer、Byte 等），使得语言变得有点冗余。


## ★结论

　　从上述的介绍，我们应该明白，使用 new 创建对象的开销是【不小】的。在程序中能避免就应该尽量避免。另外，使用 new 创建对象，不光是创建时开销大，将来垃圾回收时，销毁对象也是有开销的（关于 GC 的开销，咱们会在后面的帖子细谈）。[下一个帖子](https://oldmoon.top/post/87)，我们找一个例子来实战一下。
  
<div class="article-ads"></div>

Java性能优化1：基本类型 vs 引用类型

- Rainbow Brackets：代码括号变色插件（最新版已收费）。
- Rainbow Brackets Lite：免费版括号变色插件
- Free Mybatis plugin：简洁Mybatis辅助插件，已改名为 Free Mybatis Tool
- GitToolBox：每行代码git提交历史查看插件
- Translation：翻译插件（选中英文右键可翻译）
- Easy Code：代码生成器
- SonarLint：代码规范、漏洞检测工具
- Alibaba Java Coding Guidelines：阿里开发规范检测插件
- IDE Eval Reset：试用期重置插件

IDEA常用插件记录

## 原文链接

> 版权声明：本文为CSDN博主「冰小九」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
> 原文链接：https://blog.csdn.net/neadsc/article/details/126755917




## 可用记录

- kms.wxlost.com



以下按kms.之后的字母顺序排列

## A
kms.aic.la               

kms.abler.icu    

## B

kms.bearlele.top        

kms.bige0.com        

## C

kms.cangshui.net        

kms.cary.tech       

kms.catqu.com       

kms.cangshui.net

## D

kms.digiboy.ir        

kms.digiboy.ir                

kms.dwhd.org

## E

## F

xykz.f3322.org 

## G

kms.ghpym.com

## H

kms.hmg.pw

## I

kms.idina.cn            

kms.itsjzx.com

## J

kms.jm33.me        

nas.jszjcc.com

## K

kms.kmzs123.cn

## L

kms.luody.info

## M

kms.moeclub.org       

kms.myds.cloud        

kms.myftp.org

## N

## O

## P

enter.picp.net 

## Q

kms.qcmoe.com    

## R

roadkai.club    

## S

kms.sdit163.com        

nb.shenqw.win               

kms.sevenxu.cc

## T

kms.tttal.com

## U

## V

## W

kms.wlrxy.cn       

kms.wxlost.com

## X

kms.xingez.me    

## Y
## Z

www.zgbs.cc        

kms.zhuxiaole.org                

kms.zhi.fun


## 赞助

如果你觉得本文对你有用，想要给作者一些赞助，可以动动小手点击下方广告给予支持，万分感谢~

您的每次点击都能给予作者更多分享的动力！**请无情点击吧：**


<div class="article-ads"></div>

KMS服务器记录（搬运）

## 《罗伯特议事规则》简介

> 《罗伯特议事规则》（Robert's Rules of Order，RONR）是一本由美国将领亨利·马丁·罗伯特于1876年出版的手册，搜集并改编美国国会的议事程序，使之普及于美国民间组织，也是目前美国最广为使用的议事规范[1]。
> 《罗伯特议事规则》历经百年修改，最新版本（第12版）于2020年发行[2]，由丹尼尔·希柏德（Daniel E. Seabold）、萨谬尔·葛柏（Shmuel Gerber）等议事学者参与修订。
> 
> 《罗伯特议事规则》本质上属于对社团和会议进行有效率的民主化运营的操作手册，可以为制度设计提供一套守则，可以为不同群体间交换意见、达成和谐提供约定俗成的语法。
>
> `来自维基百科`




## 阅读原因

在当下社会，坐办公室工作的人总是频繁的开会，甚至有：“大会三六九，小会天天有”的说法。但是这只体现出了会议的频繁程度，仔细想想，真的需要这么频繁会议讨论吗？要知道一个会议往往会占用很多人共同的时间，如果能省去一些不必要的会议，或者更高效的会议，那么节省下来的时间是成倍增加的。

根据个人经验，平时工作的会议中，普遍存在很多无效发言，导致无效发言的原因可能有很多，如：会议前没有做好相关材料的准备，没有明确的会议目标，没有有效的会议组织等等。无论原因是什么，都可以概括为：没有一套完整、正确的会议规则。

读《罗伯特议事规则》，可以提升你的会议组织能力，提升你会议上发言的水平，教会你如何高效开会。

下文中的 **本书** 均代指《罗伯特议事规则》一书。

## 概述

《罗伯特议事规则》一书中，对会议做了全方位的阐述，主要内容包括但不限于：会议的基本概念、会议的人员要求、会议的组建方式、议事的流程规则、结果的达成规则等。本书虽然给出了非常详细的会议要求、规则等等，但作者也明确说明：**一般而言，各组织都有权利在章程中制定出一套适合的自己的“特别议事规则”，并从而决定“一次会议”的会议程序的构成。**

本文主要概括 **会议的讨论规则** 即 **议事规则** 。因为其他方面都较为官方，作者给出的很多规则和应用举例，针对大型的会议较多，如：董事会、代表大会等，但我认为这不代表本书的规则不适用与小型会议。当然如果你有组织大型会议的需求，通读本书一定能给你很多启发。

## 议事流程

议事流程一般可分为三步：

1. 提出动议；
2. 辩论；
3. 表决。

通过这三步，我们就完成了一个动议(`动议可理解为讨论的议题`)，走完了一个完整的议事流程。这个时候，会议中如果还有其他动议要处理，就再提出一个新的动议再辩论、再表决，以此类推。

要想快速的按照这三步进行议事，会议之前，需要进行充分准备。首先是会议内容：所有会议材料应当提前发给参会人员，参会人员也应当提前看完资料并做发言准备。其次是人员准备：《罗伯特议事规则》要求参会人数应当达到一定的人数。最后是组织准备，会议应设定一名主持人和一名秘书。主持人主持会议，执行议事规则。秘书形成会议的书面记录。且主持人应保持中立，在会议中尽量不发表自己的意见，他只是按照议事规则，推动会议向前进展。

## 议事规则

《罗伯特议事规则》作为一本著作，早有人将其议事规则概括的简明扼要，较多的概括是12原则：

1. 动议中心原则：动议是开会议事的基本单元。“动议者，行动的提议也。”会议讨论的内容应当是一系列明确的动议，它们必须是具体、明确、可操作的行动建议。先动议后讨论，无动议不讨论。
2. 主持中立原则：会议“主持人”的基本职责是遵照规则来裁判并执行程序，尽可能不发表自己的意见，也不能对别人的发言表示倾向。（主持人若要发言，必须先授权他人临时代行主持之责，直到当前动议表决结束。）
3. 机会均等原则：任何人发言前须示意主持人，得到其允许后方可发言。先举手者优先，但尚未对当前动议发过言者，优先于已发过言者。同时，主持人应尽量让意见相反的双方轮流得到发言机会，以保持平衡。
4. 立场明确原则：发言人应首先表明对当前待决动议的立场是赞成还是反对，然后说明理由。
5. 发言完整原则：不能打断别人的发言。
6. 面对主持原则：发言要面对主持人，参会者之间不得直接辩论。
7. 限时限次原则：每人每次发言的时间有限制 (比如约定不得超过2分钟）；每人对同一动议的发言次数也有限制（比如约定不得超过2次）。
8. 一时一件原则：发言不得偏离当前待决的问题。只有在一个动议处理完毕后，才能引入或讨论另外一个动议。（主持人对跑题行为应予制止。）
9. 遵守裁判原则：主持人应制止违反议事规则的行为，这类行为者应立即接受主持人的裁判。
10. 文明表达原则：不得进行人身攻击、不得质疑他人动机、习惯或偏好，辩论应就事论事，以当前待决问题为限。
11. 充分辩论原则：表决须在讨论充分展开之后方可进行。
12. 多数裁决原则：（在简单多数通过的情况下）动议的通过要求“赞成方”的票数严格多于“反对方”的票数（平局即没通过）。弃权者不计入有效票。 

这12原则的概括已经相当详尽，但可能有些原则并不适用于平时工作中的简单会议。所以我建议，如果是在平时工作中的会议，可以简化为以下8大原则(`首次阅读于喜马讲书`)：

1. **无动议不辩论**：在没有明确需要讨论的提议前，应当以讲述的形式为主，不要闲扯，保证会议的高效进行，同时会议发起人应该提前准备好会议需要讨论的议题，由主持人组织辩论。
2. **一时一件**：同一时间只讨论一件事（一个议题），与会人发言时不要偏离议题，一旦偏离，主持人应该立即打断并重回议题讨论。
3. **一事一议**：一个动议（提议）讨论完毕后，同一次会议不应有第二次讨论机会，保证会议的效率。
4. **充分辩论**：每个参会人都应该对议题发言，以保证充分的获得参会人的意见。
5. **机会均等**：每个人都有权力发言，发言应该有先后顺序，且每个人的发言时间应该有相等的时间限制。不得打断他人发言。
6. **立场先行**：参会人发言时，应当优先表明自己的观点：赞成？反对？表达完观点后再进行发言。
7. **限时限次**：每个参会人发言的次数和时间应该有限制。《罗伯特议事规则》规定，每人拥有两轮发言机会。
8. **多数裁决**：会议讨论的最终目的是达成共识，达成共识的依据应当是投票表决，多数赞成的结果才能作为议题的最终结果。

简单来说，《罗伯特议事规则》的众多规则就是依靠上述8条基本原则设计出来的。

## 拓展

会议，作为当今社会最主要的活动方式和组织形式，是人类社会公共治理中一项最具代表性的社交活动。而规范会议行为的议事规则同人类历史发展一样源远流长，它孕育于原始社会的生产和生活之中，在人类社会追求文明与民主的进程中逐步壮大。罗伯特议事规则作为当今最重要的议事规则，其诞生与发展是与人类历史的演变和议事规则逐步完善分不开的。

在当今社会，《罗伯特议事规则》已经不仅仅是一套会议的准则，而是人民行使民主权力的一种方式。曾经在1917年前后，孙中山先生着手编著了《民权初步》一书，该书以早期的《罗伯特议事规则》为蓝本，专门教国人如何开会。他在书中提出“集会者，实为民权发达之第一步”的命题，并且强调习练、演示罗伯特议事规则之类集会方法论的重要性，并对其规则进行了中国式的改造。孙中山先生在撰写完毕后，极力向社会推荐此书，“为普及起见，不取版费，交中华书局印行”，同时还请了多位同志作序以郑重推荐；出版后又广为赠送，以扩大影响。因而孙中山先生可算是中国议学的发轫者。1919年，孙中山亲自将此书编入《建国方略》，作为第二部分“社会建设”的部分内容。希望孙中山先生的伟大思想能够实现。

《罗伯特议事规则》

twitter:card

twitter:title

twitter:site

twitter:image

努力做一只帅气、有才、豁达的老狗！

twitter:description

程序员,笔记,Bug记录,编程技术,AI,Java,Node,Golang,个人博客,资源分享,月上老狗,dingdangdog