How to Avoid NullPointerException in Java Part 2

Table of Contents

• Related Posts
• Don’t be unnecessarily null tolerant
• Use Non-Null Default Value
• Use a local variable
• @UnderInitialization
• @UnknownInitialization
• Use @Nollable
• MonotonicNonNull
• When to use @Nullable
• Generics
• Useful Checker Annotations for Nullness Analysis
• @SuppressWarnings

Avoid Call Instance Method in Constructor to Prevent NullPointerException

Table of Contents

• Related Posts
• Avoid Call Instance Method in Constructor

Bazel Tips and Tricks

Table of Contents

• Install Bazel
• Bazel Tips
• Bazel build
• –compilation_mode (fastbuild|opt|dbg) (-c)
• Bazel Query
• Bazel test
• Common params
• :all VS :*
• IntelliJ Bazel Plugin

Google Flogger Best Practices

Table of Contents

• Make the logger the first static field in a class
• Format Specifiers
• Avoid doing work at log sites
• Don’t create a Throwable just to log it:
• Consider rate limiting warnings which can be triggered by bad user input.
• Don’t log and throw
• Other flogger Tips
• flogger Implementation
• Resource

Code Smell: Avoid Using Object as Input or Output

Table of Contents

• read(List<Object> keyValues)
• of(Object ...)
• Other bad examples that uses Object

Managing Projects in IntelliJ IDEA

Table of Contents

• Renaming a project in IntelliJ IDEA
• Remove projects from recent project list

Which approach to use to iterate a collection in Java

Table of Contents

• Ways to iterate
• Use foreach or stream api when possible and make sense
• Iterator
• For loop

Guide to Google AutoValue

Table of Contents

• Set a default value for a property
• @Nullable properties
• toBuilder
• AutoValue.Builder
  • Optional properties
  • autoBuild
  • Misc
  • Resource

AutoValue runs inside javac as a standard annotation processor.
Use Builder when there too many parameters or same type.

@AutoValue
public abstract class Foo {
  public static Foo create(String text, int number) {
    // defensive copies, preconditions
    return new AutoValue_Foo(text, number);
  }
  public abstract String text(); // or getText(), if you like
  public abstract int number();
}

Set a default value for a property

static Builder builder() {
  return new AutoValue_Foo.Builder()
      .setSomeIntegerField(1).setSomeImmutableSetFeild(ImmutableSet.of());
}

@Nullable properties

@Nullable abstract Foo foo();

toBuilder

public abstract Builder toBuilder();

AutoValue.Builder

@AutoValue
public abstract class Foo {
  static Builder builder() {
    return new AutoValue_Foo.Builder();
  }

  public abstract String text(); // or getText(), if you like
  public abstract int number();

  @AutoValue.Builder
  abstract static class Builder {
    abstract Builder text(String value);
    abstract Builder number(int value);
    abstract Foo build();
  }  
}

Optional properties

public abstract Optional<String> optionalProperty();


@AutoValue.Builder
public abstract static class Builder {
  public abstract Builder SetOptionalProperty(String optionalProperty);
}

autoBuild

@AutoValue.Builder
public abstract static class Builder {
  abstract Animal autoBuild(); 

  public Animal build() {
    // we can do validation, or normalization, or any other logic here.
    return autoBuild();
  }
}

Misc

• Use immutable properties.
• We can perform validations at create factory or build method.
• We can write our own equals or hashcode methods.

Resource

• AutoValue userguide
• AutoValue Extensions
• IntellJ AutoValue Plugin

Protocol Buffers in Practice

Table of Contents

• Import and usage of different package files
• Any
• Field Masks
• enum
• Misc Tips
• Resources

Java Enum Best Practice

Table of Contents

• Java Enum
• Item 35: Use instance fields instead of ordinals
• Use EnumSet
• Implement interface
• Use enum for Singleton class
• Prefer equals() over ==
• Add abstract methods(constant-specific method implementations) to enum
• Create an enum with Case Insensitive String
• Misc Tips about Enum

Java Varargs Best Practice

Table of Contents

• Varargs
• Don’t use Varargs unless really needed
• Require one
• Good Cases to Use Varargs
• Performance-critical Methods
• Careful when Overloading with Varargs
• Careful when Overloading with Varargs and Autoboxing
• Java Generic and Array doesn’t mix well
• Item 32: Combine generics and varargs judiciously
• Varargs gotchas: passing an array, a collection into varargs
• @SafeVarargs

How to Simplify and Improve Code

Table of Contents

• Remove Redundant
• Inline
• Reduce the nesting/wrapping caused by if or lambda
• Simplify lambda
• Use static import to simplify code
• Import nested class
• Merge
• Avoid String.format when the method already supports formatting
• Method that takes vargs
• Optional
• Misc Tips about Code Simplification

Javadoc Best Practice

Table of Contents

• What to Comment
• The summary fragment
• Where to Write Javadoc
• Javadoc for class
• Params
• throws
• Overriding
• Use minimal HTML tags, not valid XHTML
• [@link and @code](https://blog.joda.org/2012/11/javadoc-coding-standards.html)
• More Elements
• Deprecated
• More Javadoc Annotations
• Misc Tips about Javadoc
• Common Mistake when Write Javadoc

Mastering IntelliJ IDEA Keyboard Shortcuts in Linux and Windows

Table of Contents

• Find action
• Quick Lists
• Disable Linux Default Shortcuts
• Customize Shortcuts
• Common shortcuts
• Shortcuts for Navigation
• Shortcuts for Refactoring
• Shortcuts for Debugging
• Presentation Mode
• More tips about shortcuts

How to Avoid NullPointerException in Java Part 1

Table of Contents

• Related Posts
• Check Null
• Use null safe methods and libraries
• Return empty collection/array, instead returning null
• Throw exceptions instead return a null or an empty string
• Unboxing and NullPointerException
• NullPointerException related with Collection
  • Check whether collection is Null before loop
  • Copying between different collection may throw NullPointerException
  • Use Advanced Data Structure: Multimap, HashBasedTable
  • Avoid null key or null value in the collection
  • Rules for using primitive data types and wrapper classes
  • Use Optional Class
  • Check Null explicitly, don’t catch NullPointerException
  • Convenience methods to work with Null
  • Other NullPointerException Cases
  • Check Whether nullable
  • NullPointer Bugs
  • Resources

wait(0) - Timed_Waiting vs Waiting: Troubleshooting Practice

Table of Contents

• The Problem
• Troubleshooting
• Troubleshooting: another clue
• The root cause
• Why didn’t capture this problem before?
• How to prevent it happen again?
• What Knowledge we learned?
• Misc
  • Threaddump Analysis
  • Another mistake made

Eclipse vs IntelliJ

Better ways to organize info - Winner: Eclipse
-  Eclipse provides workspace, working set, projects
-  Organizes views into perspectives, provides view like console, problems, errors. 
- We always know where to find info we need.

Editor -Winner: Eclipse
Eclipse shows error/warning in current window in left side bar. 
IntelliJ only shows error/warning for all content in right side bar. (Eclipse also shows things in right side bar)
When you write code, its much easier to check error/warning in Eclipse.

Shortcut keys -Winner: Eclipse
Eclipse's default shortcut is more natural to me: easier to remember and type. Usually Eclipse uses less keys. IntelliJ uses all keys F1-10.

To format code: Cmd+shift+f in eclipse Cmd+alt+l in IntelliJ
- what L means?

Quick fix - Winner: Eclipse
- Eclipse quick fix(ctrl+1) is too powerful, it can fix bugs, generate code based on current context.
- IntelliJ provides too many ways to do similar things - wtf?
Show intention actions - alt+enter
Basic code completion - ctrl+space

Smart type code completion - ctrl+shift+space

Debug
- Drop to frame always works in Eclipse, but doesn't in IntelliJ
- Display view in Eclipse stores history, it's much easier to use

IntelliJ does have its own advantages such as: smart step into for anonymous classes and lambdas.

Search everywhere in IntelliJ
In Eclipse, you have to use different shortcuts/ways to search type, resource, views. 
In IntelliJ, just double press shift keys.

Better Performance/More Stable - Winner: IntelliJ
Sometimes Eclipse is slow or gets stuck, you need take time to customize it, check Improve Eclipse Performance


Same code may work in Eclipse but not in IntelliJ
Eclipse and IntelliJ doesn't works well together, if some team members are using eclipse, you better also use eclipse, as sometimes, the same code works and can be deployed in eclipse's tomcat but doesn't work or can't be deployed in IntelliJ tomcat.

More about Eclipse and IntelliJ:
Mastering Eclipse IDE - Tips, Tricks
IntelliJ IDEA Tips and Tricks

Java Optional Best Practices

Table of Contents

• map vs flatMap
• Filter out Optional.empty() from a stream of Optional
• Call chains of nullable API
• orElse, orElseGet, orElseThrow
• When to (not) use Optional in API?
• Other Tips about Optional
• Methods of Optional
• New methods after Java 8
• When work with legacy code
• Example of Using Optinonal

Best Practices to Handle Exceptions in Java

Table of Contents

• Throw Exception
• Impossible Conditions
• Throw early catch late
• Valid parameter, user input early
• Logging
• Catch Exception
• Finally
• Be careful of NullPointerException
• InterruptedException
• Common Exceptions
• Misc

Autoboxing and Unboxing Tips and Traps in Java

Table of Contents

• What’s Autoboxing
• What’s Unboxing
• When Autoboxing/unboxing Happens
• Effective Java Item 61: Prefer primitive types to boxed primitives
• Always use Objects.equals instead of ==(identity comparison) to compare wrapper class
• Unboxing and NullPointerException
• Widening or Boxing, but not both
• Some Puzzles
• No Widen for wrapper type
• Widening takes priority than boxing
• Boxing takes priority than Varargs
• Varargs gotchas: passing an array of primitives
• Performance Hit
• Misc Tips