Better Java

来源于git上，对java优化的建议，可以逐步改变自己的编码习惯，使用更简洁高效的方法来使用java编程。

better-java

 

1.(JavaBean)对象的构造方法：

常用：

public class DataHolder {
    private String data;

    public DataHolder() {
    }

    public void setData(String data) {
        this.data = data;
    }

    public String getData() {
        return this.data;
    }
}

　　

Better ：

public class DataHolder {
    public final String data;

    public DataHolder(String data) {
        this.data = data;
    }
}

／／类似于c的构造方法，更少的代码量，如果你在使用Map或者List保存对象，易于修改，不妨试一下，ImmutableMap，ImmutableList

 

2.建造者模式(The Builder Pattern)：

public class ComplicatedDataHolder {
    public final String data;
    public final int num;
    // lots more fields and a constructor

    public static class Builder {
        private String data;
        private int num;

        public Builder data(String data) {
            this.data = data;
            return this;
        }

        public Builder num(int num) {
            this.num = num;
            return this;
        }

        public ComplicatedDataHolder build() {
            return new ComplicatedDataHolder(data, num); // etc
        }  
    }
}

　　

使用如下：

final ComplicatedDataHolder cdh = new ComplicatedDataHolder.Builder()
    .data("set this")
    .num(523)
    .build();

　　

3. 异常(Exception)：

异常使用慎重，尤其是在安卓应用中，合理的异常处理，可以大大提高应用的用户体验。可以使用try{}catch{}包裹，或者抛出异常，最好是让你的异常处理继承于RuntimeException，这样可以使处理异常更方便，尽量不要使用throws抛出，会污染自己的代码。

 

4.关于依赖注入（Dependency Injection : DI）：

由于java鼓励00，面向对象的思想，所以在测试软件的时候，DI无疑是最好的选择，在java中spring框架用XML配置文件，或者依赖注入是最常见的，谷歌和square自己的框架，则是更喜欢用依赖注入。

 

5.（Avoid Nulls）空对象

避免使用nulls，如果非要使用，了解@Nullable注解. IntelliJ IDEA系列开发工具 已经支持@Nullable 注解.

如果在jdk8+,那么使用Optional会更加爽歪歪：

eg:

public class FooWidget {
    private final String data;
    private final Optional<Bar> bar;

    public FooWidget(String data) {
        this(data, Optional.empty());
    }

    public FooWidget(String data, Optional<Bar> bar) {
        this.data = data;
        this.bar = bar;
    }

    public Optional<Bar> getBar() {
        return bar;
    }
}

//data never null,but Bar may be null

　　

use Optional ,like this:

final Optional<FooWidget> fooWidget = maybeGetFooWidget();
final Baz baz = fooWidget.flatMap(FooWidget::getBar)
                         .flatMap(BarWidget::getBaz)
                         .orElse(defaultBaz);

//需要看一下，jdk8的新特性

 

6.Avoid lots of util classes

public class MiscUtil {
    public static String frobnicateString(String base, int times) {
        // ... etc
    }

    public static void throwIfCondition(boolean condition, String msg) {
        // ... etc
    }
}

　　

Bettet:

public interface Thrower {
    default void throwIfCondition(boolean condition, String msg) {
        // ...
    }

    default void throwAorB(Throwable a, Throwable b, boolean throwA) {
        // ...
    }
}

//使用jdk8+,default methods on interfaces you could lump common actions into interfaces. And, since they're interfaces, you can implement //multiple of them.

　　

7.规范化（Formatting）：

关于java编码规范化问题，最好的是参见，<a href="http://google.github.io/styleguide/javaguide.html">Google java style</a>

另外<a href="http://google.github.io/styleguide/javaguide.html#s6-programming-practices">值得阅读</a>。

 

8.流操作（Streams)

使用阅读性更高的lambda表达式：

final List<String> filtered = list.stream()
    .filter(s -> s.startsWith("s"))
    .map(s -> s.toUpperCase())
    .collect(Collectors.toList());

　　

代替：

final List<String> filtered = new ArrayList<>();
for (String str : list) {
    if (str.startsWith("s") {
        filtered.add(str.toUpperCase());
    }
}

　　

来源Github