Java之1个月时间，10点重要经验总结

开心一笑

【长这么大佩服过三个男人，一是许仙，二是董永，三是宁采臣。一个敢曰蛇，一个敢曰仙，最后一个连鬼都不放过。直到看了花千骨，我才知道，落十一才是真汉子，敢曰毛毛虫。最看不起的就是孙悟空，把七个仙女定住，他居然跑去偷桃子了，但我不得不佩服孙悟空他爹、居然能把石头整怀孕了我也是醉了…】

---

---

学习地址

CSDN学习地址：

http://edu.csdn.net/lecturer/994

51CTO学习地址：

http://edu.51cto.com/lecturer/5592452.html

51CTO学习地址：

https://huangwy.ke.qq.com/

提出问题

一个月时间，我的10点工作经验总结？？？

---

解决问题

前言

该笔记已经录制成视频，可以到CSDN,51CTO,或者腾讯学院观看~~~

Lists.partition集合分割

package com.example.java.toolkit.guava;

import com.google.common.collect.Lists;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.CollectionUtils;

import java.util.List;


/**
 * 描述：Guava工具类partition使用
 *
 * @author Ay
 * @date 2017/10/22
 */
public class Lists_Partition {


    Logger log = LoggerFactory.getLogger(Lists_Partition.class);

    public static void main(String[] args) {

        //step.1 集合切割正常逻辑
        List<Integer> numList = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8);

        List<List<Integer>> partList = Lists.partition(numList, 3);
        if (!CollectionUtils.isEmpty(partList)) {
            for (List<Integer> list : partList) {
                System.out.println(list.toString());
            }
        }

        //step.2 切割数量大于集合数量
        List<Integer> numList2 = Lists.newArrayList(1);
        List<List<Integer>> partList2 = Lists.partition(numList2, 3);
        if (!CollectionUtils.isEmpty(partList2)) {
            for (List<Integer> list : partList2) {
                System.out.println(list.toString());
            }
        }


        //step.3 修改切割后的集合，检查原集合是否被修改
        List<Integer> numList3 = Lists.newArrayList(1,2,3,4,5,6,7,89,9);

        List<List<Integer>> partList3 = Lists.partition(numList3, 3);
        if (!CollectionUtils.isEmpty(partList3)) {
            for (List<Integer> list : partList3) {
                for(int i=0,len = list.size();i<len;i++){
                    list.set(i,8);
                }
            }
            //打印原集合
            System.out.println(numList3.toString());

        }

        //注意：partition返回的是原list的subview.视图,即原list改变后,partition之后的结果也会随着改变

        //step.4 List.partition（）在真实项目中的运用
        List<Integer> numList4 = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8, 9);

        List<List<Integer>> partList4 = Lists.partition(numList4, 100);
        if (!CollectionUtils.isEmpty(partList4)) {

            for (List<Integer> list : partList4) {
                //将切割的集合按照固定数量查询数据库
                //xxxx.findById(list)
                //select * from user u where u.id in (1,2,3 ....) 这里的id数量不要超过100个
            }    
        }    
    }

}

TypeReference在Json与对象转换中的使用

package com.example.java.toolkit.guava;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.collect.Lists;
import org.junit.Test;

import java.io.Serializable;
import java.util.List;

/**
 * 描述：
 * @author Ay
 * @date   2017-11-01
 *
 */
public class TypeReference_Test {


    public static ObjectMapper mapper = new ObjectMapper();

    public static final TypeReference LIST_STRING = new TypeReference<List<String>>() {};

    @Test
    public void test() throws Exception{
        //step.1 数据初始化
        List<Person> persionList = Lists.newArrayList();
        Person ay = new Person();
        ay.setName("ay");
        ay.setPassword("123");
        Person al = new Person();
        al.setName("al");
        al.setPassword("123");
        persionList.add(ay);
        persionList.add(al);
        //对象转换为json的字符串
        String personJsonStr = mapper.writeValueAsString(persionList);
        System.out.println(persionList);
        //字符串转换为对象
        //List<Person> getlistPerson = mapper.readValue(personJsonStr, new TypeReference<List<Person>>() {});
        List<Person> getlistPerson = mapper.readValue(personJsonStr, LIST_STRING);

        System.out.println(getlistPerson);


        //================================
        // TypeReference的源码
        /*public class TypeReference<T> {

            private final Type type;

            public TypeReference() {
                //获得当前类带有泛型信息的父类
                Type superClass = getClass().getGenericSuperclass();//1

                //获取父类的泛型信息
                type = ((ParameterizedType) superClass).getActualTypeArguments()[0];//2
            }

            public Type getType() {
                return type;
            }
            实例，TypeReference的使用方法
            public static final TypeReference LIST_STRING = new TypeReference<List<String>>() {
            }.getType();//3
        }*/

    }

}

class Person implements Serializable{

    private String name;
    private String password;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

return与try catch之间的执行顺序

package com.example.java.test;

import org.junit.Test;

/**
 * return 与 try catch的关系
 * @author Ay
 * @date   2017-10-1
 */
public class ReturnAndTryCatchTest {


    @Test
    public void test() {

        try{

            System.out.println("try");
        }catch (Exception e){

            System.out.println("catch");
        }finally {
            System.out.println("finally");

        }
        System.out.println("method body");
        return;

        //打印结果
        //try
        //finally
        //method body
    }


    @Test
    public void test2() {

        try{
            System.out.println("try");
            String str = null;
            str.split(",");
        }catch (Exception e){

            System.out.println("catch");
            System.out.println("return");
            return;
        }finally {
            System.out.println("finally");

        }
        System.out.println("method body");
        return;

        //打印结果
        //try
        //catch
        //return
        //finally
    }

    @Test
    public void test3() {

        try{
            System.out.println("try");
            System.out.println("try return");
            String str = null;
            str.split(",");

            return;
        }catch (Exception e){

            System.out.println("catch");
            System.out.println("catch return");
            return;
        }finally {
            System.out.println("finally");
            return;
        }

        //打印结果
        //try
        //try return
        //catch
        //catch return
        //finally
    }

    @Test
    public void test4() {


        try{
            System.out.println("try");
            System.out.println("try return");
            return;
        }catch (Exception e){

            System.out.println("catch");
            System.out.println("catch return");
            return;
        }finally {
            System.out.println("finally");
            return;
        }

        //打印结果
        //try
        //try return
        //finally
    }

    @Test
    public void test5(){

        System.out.println("最终打印的值是：" + returnTest());
    }

    private String returnTest(){
        String msg = "";

        try{
            msg = "try";
            return msg;
        }catch (Exception e){

            msg = "catch";
            return msg;
        }finally {
            msg = "finally";
            //return msg; //1
        }

        //打印结果
        //最终打印的值是：finally

        //注释掉 1 打印结果
        //最终打印的值是：try

        //结论
        //如果finally语句中没有return语句覆盖返回值，那么原来的保存下来的返回值不一定会因为finally里的修
    }

    //结论
    //任何执行try 或者catch中的return语句之前，都会先执行finally语句，如果finally存在的话。
    //如果finally中有return语句，那么程序就return了，所以finally中的return是一定会被return的，
    //编译器把finally中的return实现为一个warning。   
}

静态导入与导入的运用

package com.example.java.test;  
//import static org.junit.Assert.assertTrue;
import static java.lang.Integer.MAX_VALUE;
//import static java.lang.Long.MAX_VALUE;
import org.junit.Assert;
import org.junit.Test;
import static java.lang.Math.PI;

/**
 * 描述：静态导入 和导入 的区别
 * @author Ay
 * @date   2017-11-08
 */
public class StaticImportAndImportTest {

    //静态导入的运用：


    /**
     * 使用普通导入
     * @param productId
     */
    @Test
    public void test(Integer productId){

        Assert.assertTrue(productId >= 0);
        Assert.assertTrue(productId != null);

    }


    /**
     * 使用静态导入
     * @param productId
     */
    @Test
    public void test2(Integer productId){

        //assertTrue(productId >= 0);
        //Assert.assertTrue(productId != null);

    }

    /**
     * 错误例子
     * @param productId
     */
    @Test
    public void test3(Integer productId){
        //提防含糊不清的命名static成员
        System.out.println(MAX_VALUE);

    }


    /**
     * 正确运用
     * @param productId
     */
    @Test
    public void test4(Integer productId){
        //1.static方法上进行静态导入
        //assertTrue(productId >= 0);
        //Assert.assertTrue(productId != null);

        //2.常量
        System.out.println(PI);

    }


    //你必须说import static， 不能说static import。
    //提防含糊不清的命名static成员。例如，如果你对Integer类和Long类执行了静态导入，引用MAX_VALUE将导致一个编译器错误，
    // 因为Integer和Long都有一个MAX_VALUE常量，并且Java不会知道你在引用哪个MAX_VALUE。
    //你可以在static对象引用、常量（记住，它们是static 或final）和static方法上进行静态导入。

}

CollectionUtils.subtract()集合相减在工作中运用

package com.example.java.toolkit.guava;
import com.google.common.collect.Lists;
import org.apache.commons.collections4.CollectionUtils;
import org.junit.Test;

import java.util.List;

/**
 * 描述：集合相减测试
 * @author Ay
 * @data   2017-11-08
 */
public class CollectionUtils_Subtract_Test {


    //CollectionUtils 出自 commons.collections 这个包

    //需要在pom.xml引入依赖
    //<dependency>
    //    <groupId>org.apache.commons</groupId>
    //    <artifactId>commons-collections4</artifactId>
    //    <version>4.1</version>
    //</dependency>

    @Test
    public void test() {

        List<Integer> oldList = Lists.newArrayList(1,3,5,7);

        List<Integer> newList = Lists.newArrayList(1,3);

        //oldList - newLit
        System.out.println(CollectionUtils.subtract(oldList,newList));

        //newList - oldList
        System.out.println(CollectionUtils.subtract(newList,oldList));

    }


    /**
     * 运用
     */
    @Test
    public void test2(){

        //数据库中  项目表  和 负责人表    负责人id：1,3,5,7

        List<Integer> newList = Lists.newArrayList(1,3,5,7,9);

        List<Integer> oldList = Lists.newArrayList(1,3,5,7);

        //newList - oldList
        List<Integer> addList = Lists.newArrayList(CollectionUtils.subtract(newList,oldList));
        System.out.println(addList);

        //oldList - newList
        List<Integer> delList = Lists.newArrayList(CollectionUtils.subtract(oldList,newList));

        System.out.println(delList);

        //addList插入数据库
        //insert(addList)

        //删除数据
        //delList(delList)


    }
}

Lists.transform()的原理及坑点

package com.example.java.toolkit.guava;

import com.google.common.base.Function;
import com.google.common.collect.Lists;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

public class Lists_Transform {

    /*

    Function :
    public interface Function<F, T> {
        @Nullable
        T apply(@Nullable F var1);

        boolean equals(@Nullable Object var1);
    }

    Function是一个接口，实现该接口后需要实现apply方法，将 F 转化为 T
    Function是一种策略，把一种对象转化为另一种对象的策略

    */


    @Test
    public void test(){

        List<AyUser> ayUserList = new ArrayList<>();
        ayUserList.add(new AyUser(1,"ay"));
        ayUserList.add(new AyUser(2,"al"));
        ayUserList.add(new AyUser(3, "love"));
        //遍历List 对每个旧类型元素调用 apply方法，转化成另外一种类型的元素，形成一个新List，存放新类型元素
        List<Integer> ids = Lists.transform(ayUserList, AyUserTransformer.AYUSER_ID_TRANS);
        System.out.println(ids);
    }

    @Test
    public void test2(){

        List<AyUser> ayUserList = new ArrayList<>();
        ayUserList.add(new AyUser(1,"ay"));
        ayUserList.add(new AyUser(2,"al"));
        ayUserList.add(new AyUser(3, "love"));
        //遍历List 对每个旧类型元素调用 apply方法，转化成另外一种类型的元素，形成一个新List，存放新类型元素
        List<NewAyUser> newAyUserList = Lists.transform(ayUserList, AyUserTransformer.AYUSER_TO_NEWAYUSER_TRANS);
        System.out.println(newAyUserList);
    }


    @Test
    public void test3(){

        List<AyUser> ayUserList = new ArrayList<>();
        ayUserList.add(new AyUser(1,"ay"));
        ayUserList.add(new AyUser(2,"al"));
        ayUserList.add(new AyUser(3, "love"));
        //遍历List 对每个旧类型元素调用 apply方法，转化成另外一种类型的元素，形成一个新List，存放新类型元素
        List<NewAyUser> newAyUserList = Lists.transform(ayUserList, AyUserTransformer.AYUSER_TO_NEWAYUSER_TRANS);

        newAyUserList.add(new NewAyUser(4,"4"));
        newAyUserList.add(new NewAyUser(5,"5"));

        System.out.println(newAyUserList);


        //总结：transform函数返回的List是一个特殊类型的List，只支持遍历，不支持任何修改（增删改移）
        //所以，对这个list做的所有修改操作都会抛异常。
    }

    //简单看下源码
    //public static <F, T> List<T> transform(List<F> fromList, Function<? super F, ? extends T> function) {
    //    return (List)(fromList instanceof RandomAccess ? new Lists.TransformingRandomAccessList(fromList, function) :
    //                                                     new Lists.TransformingSequentialList(fromList, function));
    //}
}

class AyUserTransformer{

    public static final Function<AyUser, Integer> AYUSER_ID_TRANS = new AyUserIDTransfer();

    /**
     * 用户实体转换ID
     */
    public static class AyUserIDTransfer implements Function<AyUser, Integer> {

        @Override
        public Integer apply(AyUser input) {
            return input.getId();
        }
    }


    public static final Function<AyUser, NewAyUser> AYUSER_TO_NEWAYUSER_TRANS = new AyUserTONewAyUserTransfer();

    /**
     * 用户实体转换新的用户实体
     */
    public static class AyUserTONewAyUserTransfer implements Function<AyUser, NewAyUser> {

        @Override
        public NewAyUser apply(AyUser ayUser) {
            NewAyUser newAyUser = new NewAyUser();
            newAyUser.setNewId(ayUser.getId());
            newAyUser.setNewName(ayUser.getName());
            return newAyUser;
        }
    }

}


class NewAyUser{

    private String newName;
    private Integer newId;

    public NewAyUser(){}

    public NewAyUser(Integer newId, String newName){
        this.newId = newId;
        this.newName = newName;
    }

    public String getNewName() {
        return newName;
    }

    public void setNewName(String newName) {
        this.newName = newName;
    }

    public Integer getNewId() {
        return newId;
    }

    public void setNewId(Integer newId) {
        this.newId = newId;
    }
}


class AyUser{

    private String name;
    private Integer id;

    public AyUser(){}

    public AyUser(Integer id, String name){
        this.id = id;
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }
}

表达式引擎aviator（一）

表达式引擎aviator（二）

package com.example.java.toolkit.aviator;

import com.googlecode.aviator.AviatorEvaluator;
import com.googlecode.aviator.Expression;
import com.googlecode.aviator.runtime.function.AbstractFunction;
import com.googlecode.aviator.runtime.function.FunctionUtils;
import com.googlecode.aviator.runtime.type.AviatorDouble;
import com.googlecode.aviator.runtime.type.AviatorObject;
import org.junit.Test;

import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 描述：表达式引擎
 * @author Ay
 * @date   2017/11/10.
 */
public class Aviator_Test {

    @Test
    public void test(){
        //Aviator的数值类型仅支持Long和Double
        Long result = (Long) AviatorEvaluator.execute("1+2+3");
        System.out.println(result);

        String yourName = "ay";
        Map<String, Object> env = new HashMap<>();
        env.put("yourName", yourName);
        String result2 = (String) AviatorEvaluator.execute(" 'hello ' + yourName ", env);
        System.out.println(result2);  // hello ay

        //Aviator 2.2 开始新增加一个exec方法, 可以更方便地传入变量并执行, 而不需要构造env这个map了
        //只要在exec中按照变量在表达式中的出现顺序传入变量值就可以执行, 不需要构建Map了。
        String name = "ay";
        String result3 = (String) AviatorEvaluator.exec(" 'hello ' + yourName ", name); // hello ay
        System.out.println(result3);

        Long result4 = (Long) AviatorEvaluator.execute("string.length('hello')");
        System.out.println(result4);


        //注册函数
        AviatorEvaluator.addFunction(new AddFunction());
        System.out.println(AviatorEvaluator.execute("add(1, 2)"));           // 3.0
        System.out.println(AviatorEvaluator.execute("add(add(1, 2), 100)")); // 103.0

        // 编译表达式
        String expression = "a-(b-c)";

        Expression compiledExp = AviatorEvaluator.compile(expression);
        Map<String, Object> env2 = new HashMap<>();
        env2.put("a", 100.3);
        env2.put("b", 45);
        env2.put("c", -199.100);
        // 执行表达式
        compiledExp.execute(env2);

        //访问数组和集合
        final List<String> list = new ArrayList<String>();
        list.add("hello");
        list.add(" world");
        final int[] array = new int[3];
        array[0] = 0;
        array[1] = 1;
        array[2] = 3;
        final Map<String, Date> map = new HashMap<>();
        map.put("date", new Date());
        Map<String, Object> env3 = new HashMap<>();
        env3.put("list", list);
        env3.put("array", array);
        env3.put("mmap", map);
        System.out.println(AviatorEvaluator.execute("list[0] + list[1]", env3));   // hello world
        System.out.println(AviatorEvaluator.execute("'array[0]+array[1]+array[2]=' + (array[0]+array[1]+array[2])", env3));  // array[0]+array[1]+array[2]=4
        System.out.println(AviatorEvaluator.execute("'today is ' + mmap.date ", env3));  // today is Wed Feb 24 17:31:45 CST 2016

        //三元操作符
        AviatorEvaluator.exec("a>0? 'yes':'no'", 1);


        TestAviator foo = new TestAviator(100, 3.14f, new Date());
        Map<String, Object> env6 = new HashMap<>();
        env6.put("foo", foo);
        System.out.println(AviatorEvaluator.execute("'foo.i = ' + foo.i", env6));   // foo.i = 100
        System.out.println(AviatorEvaluator.execute("'foo.f = ' + foo.f", env6));   // foo.f = 3.14
        System.out.println(AviatorEvaluator.execute("'foo.date.year = ' + (foo.date.year+1990)", env6));  // foo.date.year = 2106

        AviatorEvaluator.execute("nil == nil");   //true
        AviatorEvaluator.execute(" 3> nil");      //true
        AviatorEvaluator.execute(" true!= nil");  //true
        AviatorEvaluator.execute(" ' '>nil ");    //true
        AviatorEvaluator.execute(" a==nil ");     //true, a 是 null

        //日期比较
        Map<String, Object> env7 = new HashMap<>();
        final Date date = new Date();
        String dateStr = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS").format(date);
        env7.put("date", date);
        env7.put("dateStr", dateStr);
        Boolean result8 = (Boolean) AviatorEvaluator.execute("date==dateStr", env7);
        System.out.println(result8);  // true
        result8 = (Boolean) AviatorEvaluator.execute("date > '2010-12-20 00:00:00:00' ", env7);
        System.out.println(result8);  // true
        result8 = (Boolean) AviatorEvaluator.execute("date < '2200-12-20 00:00:00:00' ", env7);
        System.out.println(result8);  // true
        result8 = (Boolean) AviatorEvaluator.execute("date==date ", env);
        System.out.println(result8);  // true

        //强大的 seq 库
        Map<String, Object> env9 = new HashMap<>();
        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(3);
        list2.add(20);
        list2.add(10);
        env9.put("list2", list2);
        Object result7 = AviatorEvaluator.execute("count(list2)", env9);
        System.out.println(result7);  // 3
        result7 = AviatorEvaluator.execute("reduce(list2,+,0)", env9);
        System.out.println(result7);  // 33
        result7 = AviatorEvaluator.execute("filter(list2,seq.gt(9))", env9);
        System.out.println(result7);  // [10, 20]
        result7 = AviatorEvaluator.execute("include(list2,10)", env9);
        System.out.println(result7);  // true
        result7 = AviatorEvaluator.execute("sort(list2)", env9);
        System.out.println(result7);  // [3, 10, 20]
        AviatorEvaluator.execute("map(list2,println)", env9);

    }

    class AddFunction extends AbstractFunction {
        @Override
        public AviatorObject call(Map<String, Object> env, AviatorObject arg1, AviatorObject arg2) {
            Number left = FunctionUtils.getNumberValue(arg1, env);
            Number right = FunctionUtils.getNumberValue(arg2, env);
            return new AviatorDouble(left.doubleValue() + right.doubleValue());
        }
        public String getName() {
            return "add";
        }
    }

    public class TestAviator {
        int i;
        float f;
        Date date;
        // 构造方法
        public TestAviator(int i, float f, Date date) {
            this.i = i;
            this.f = f;
            this.date = date;
        }

        public int getI() {
            return i;
        }

        public void setI(int i) {
            this.i = i;
        }

        public float getF() {
            return f;
        }

        public void setF(float f) {
            this.f = f;
        }

        public Date getDate() {
            return date;
        }

        public void setDate(Date date) {
            this.date = date;
        }
    }


}

结构化数据、半结构化数据、非结构化数据

结构化数据：
结构化的数据是指可以使用关系型数据库表示和存储，表现为二维形式的数据。

半结构化数据:
半结构化数据，属于同一类实体可以有不同的属性，即使他们被组合在一起，这些属性的顺序并不重要。

<person>
    <name>A</name>
    <age>13</age>
    <gender>female</gender>
</person>

或者

<person>
    <name>B</name>
    <gender>male</gender>
</person>

从上面的例子中，属性的顺序是不重要的，不同的半结构化数据的属性的个数是不一定一样的。有些人说半结构化数据是以树或者图的数据结构存储的数据，怎么理解呢？上面的例子中，标签是树的根节点，和标签是子节点。通过这样的数据格式，可以自由地表达很多有用的信息，包括自我描述信息（元数据）。所以，半结构化数据的扩展性是很好的。

半结构数据有：XML和JSON

扫描二维码关注公众号，回复： 2741863 查看本文章

非结构化数据：
就是没有固定结构的数据。各种文档、图片、视频/音频等都属于非结构化数据。对于这类数据，我们一般直接整体进行存储，而且一般存储为二进制的数据格式。

NASA的10大编程规则

/**
 * 描述：NASA 的 10 大编程规则
 * @author Ay
 * @date   2017-11-10
 */
public class NASA_10_Code_Principles {

    /*
    美国宇航局（National Aeronautics and Space Administration，缩写为 NASA）是美国联邦政府的一个独立机构，
    负责制定、实施美国的民用太空计划、与开展航空科学暨太空科学的研究。在太空计划之外，美国国家航空航天局还进行长期的民用以及军用航空航天研究。
    在普通人的眼中，NASA 是一个很“高级”的机构，其成员包含大量不同领域的科学家和研究人员。与其他任何组织机构类似，NASA 的日常工作，
    以及所执行的几乎全部项目也离不开计算机的辅助，出于需求的特殊性和重要性，他们所使用的很多计算机软件都是内部自行开发的，在一些重要项目的关键领域发挥着作用。
    去年，一位前 NASA 实习生把美国阿波罗登月项目的 11 号计算机 --- 阿波罗导航计算机 (Apollo Guidance Computer) 系统源代码上传到了 GitHub，此举在开发者群体中引起了极大的热议。

    */

    public static void main(String[] args) {


   /*
       原则1 �C 简化控制流程（Simple Control Flow）
       用非常简单的控制流结构体来编写程序 — 不要用 setjmp 或者 longjmp 结构体，goto 语句，以及直接或间接的递归调用。
       尽量避免：if else  , 递归等函数编写  ,使用卫语句

        if(){

        }else if{

        }else if(){

        }

        卫语句
        //
        if(){

        }

        if(){

        }

        if(){

        }


       第 2 条规则 — 循环设置固定的上限
       所有的循环必须有一个固定的上限。对于检查工具来说，在给定循环次数的情况下，可以通过静态分析证实循环结果不超过预设的上限。
       如果工具不能静态检测出循环上限，那么这条规则就不适用。

       第 3 条规则 — 没有动态内存分配
       初始化之后不要使用动态内存分配。

       第 4 条规则 — 没有大函数
       如果以一行一条声明和一行一条语句这样标准的格式来写，那么函数的长度不应该超过一张纸。这也就是说一个函数不应该超过 60 行代码。
       备注：单一职权原则

       第 5 条原则 — 低断言使用密度
       代码断言的密度应该低至平均每个函数两个。断言是用来检查现实执行中不会发生的不正常情况。它应该被定义为布尔测试。当断言失败，应当立即采取恢复措施。
       如果静态检测工具证明断言永远不会失败或者条件永远不为真，这条规则就无效。
       public void test（Stirng productId）{
         Assert(productId > 0);
         Assert(productId > 0);
         Assert(productId > 0);
         Assert(productId > 0);
         Assert(productId > 0);
       }


       第 6 条规则 — 最小范围内声明数据对象
       这条规则支持数据隐藏的基本原则。所有的数据对象必须在尽可能最小范围内声明。
       备注：变量的作用域最小

       class A{

         //private String a = "a";

         public void test(){
            //String a = "a";
            system.out.println(a);

            for(){
              String a = "a";

            }

         }

       }

       第 7 条规则 — 检查参数和返回值
       当函数的返回值为非空的时候，每次函数调用都应该检查其返回值，并且每个被调用的函数还要检查所带参数的有效性。
       在最严格的模式下，这条规则意味着printf和文件关闭语句的返回值也要检查


        class A{

         //private String a = "a";

         public List<Stirng> test(){

            system.out.println(a);

            for(){
              String a = "a";

            }

         }

         public void test2(){
            List<Stirng> list =  test();
            //检查返回值
            if(list == null && list.size() > 0){
                //
            }

         }

       }

       第 8 条规则 — 限制使用预处理器

       第 9 条规则 — 限制使用指针

       第 10 条规则 — 所有代码必须能编译通过

       从开发的第一天起，所有的代码都必须通过编译。所有的编译器警告必须遵循编译器可使用警告。在编译器可使用警告范围内，编译的代码必须没有警告。
       所有代码必须每天至少使用一个（最好多于一个）最新的静态源代码分析器进行检查，而且以0警告通过所有的分析。

       备注：1）intellij Idea 软件本身带有警告信息 2）可以使用FindBugs-IDEA检查错误。3）rebuild product下
    */   
    }

}

Multimaps.index运用

package com.example.java.toolkit.guava;

import com.google.common.base.Function;
import com.google.common.collect.*;
import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * 描述：Multimaps.index使用
 * @author Ay
 * @date   2017-11-16
 */
public class Multimaps_index {

    //作为Maps.uniqueIndex的兄弟方法，Multimaps.index(Iterable, Function)通常针对的场景是：
    //有一组对象，它们有共同的特定属性，我们希望按照这个属性的值查询对象，但属性值不一定是独一无二的。

    @Test
    public void test(){
        ImmutableSet digits = ImmutableSet.of("zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine");
        Function<String, Integer> lengthFunction = new Function<String, Integer>() {
            public Integer apply(String string) {
                return string.length();
            }
        };
        ImmutableListMultimap<Integer, String> digitsByLength= Multimaps.index(digits, lengthFunction);
        List<String> three =  digitsByLength.get(3);
    }

    @Test
    public void test2(){
        List<Person> persons = Arrays.asList(
                new Person("zhang", 15),
                new Person("wang", 16),
                new Person("lee", 18)
        );

        //Maps.uniqueIndex(Iterable,Function)通常针对的场景是：有一组对象，
        //它们在某个属性上分别有独一无二的值，而我们希望能够按照这个属性值查找对象——
        //译者注：这个方法返回一个Map，键为Function返回的属性值，值为Iterable中相应的元素，因此我们可以反复用这个Map进行查找操作。

        /**
         * 转换后的Map具有唯一键
         */
        Map<String, Person> map = Maps.uniqueIndex(persons, new Function<Person, String>() {
            @Override
            public String apply(Person person) {
                return person.getName();
            }
        });

        /**
         * 转换后的Map有重复键
         */
        Multimap<String, Person> multiMap = Multimaps.index(persons, new Function<Person, String>() {
            public String apply(Person person) {
                return person.getName();
            }
        });
    }

    public class Person {

        private String name;
        private int age;

        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public int getAge() {
            return age;
        }
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}

结束语

---

你的鼓励，我的动力，一分都是爱

---

读书感悟

来自《褚时健传》

• 一个人不是生来就要被打败的，你尽可以把他消灭掉，可就是打不败他。
• 抗日战争、解放战争、“反右”、“文革”、改革开放。寿则多辱、面对不公平的命运，愤然一跃固然悲壮，有原则的隐忍更加可贵。
• 搞物质生产，就是消耗要低，质量要好。成本核算和产品质量都非常重要。不管什么事，你要先搞懂才做，不懂的事，先向别人学习。不然你亏本了都不知道为什么。
• 做事、把事做好，就会快乐，就会有成就感。

---

经典故事

《我恰恰相反》

有一天，歌德漫步在魏玛公园。不料，在一条小径遇到了一个曾把他的所有作品都贬得一文不值的批评家。这条狭窄的过道，只能通过一个人。他们面对面地相遇了。
那个批评家十分傲慢，他头一昂说：“对一个傻子，我绝不让路！”
“我却恰恰相反。”歌德微笑着，马上站到了一边。

---

大神文章

【1】http://blog.csdn.net/liangyihuai/article/details/54864952
【2】http://blog.jobbole.com/104016/
【3】http://blog.csdn.net/foreverling/article/details/52204493
【4】http://blog.csdn.net/keda8997110/article/details/50782848
【5】http://blog.csdn.net/liuxiao723846/article/details/75670290
【6】http://www.cnblogs.com/fery/p/4709841.html

---

其他

如果有带给你一丝丝小快乐，就让快乐继续传递下去，欢迎鼓励，点赞、顶、欢迎留下宝贵的意见、多谢支持

---