int[] array = {1, 2, 3};
What I learned from the book Core Java for the Impatient
TweetPosted on Friday Jun 19, 2015 at 06:07PM in Java
I’m reading a book named Core Java for the Impatient. I leave some notes that what I learned from that book.
Array construction
You can omit the new int[] statement when you declare a variable as follows:
You can’t omit it when you don’t declare a variable at the same time (in other words, when you use an existing variable).
For example, the following is illegal:
int[] array;
array = {2, 3, 4};
You need to write like the following instead:
int[] array;
array = new int[]{2, 3, 4};
NumberFormat
The NumberFormat class provides some useful text formatting functions for numeric variables.
Currency formatting
final BigDecimal val1 = new BigDecimal("0.126");
final NumberFormat currencyInstance = NumberFormat.getCurrencyInstance(Locale.US);
System.out.println(currencyInstance.format(val1));
Yields:
$0.13
Percentage formatting
final BigDecimal val2 = new BigDecimal("0.126");
final NumberFormat percentInstance = NumberFormat.getPercentInstance(Locale.US);
System.out.println(percentInstance.format(val2));
Yields:
13%
They automatically adds the symbol and round up on 6 and round down on 5.
Wildcard for the classpath
Consider a class which depends on the class corejava.jar1.Foo and corejava.jar2.Bar:
package corejava.classpath;
public class Main {
public static void main(String[] args) {
System.out.println(new corejava.jar1.Foo());
System.out.println(new corejava.jar2.Bar());
}
}
You have these classes in separated three jar files in the /tmp/jar directory as follows:
$ ls -l /tmp/jar total 24 -rw-r--r-- 1 kyle wheel 2192 Jun 19 16:06 classpath-1.0-SNAPSHOT.jar -rw-r--r-- 1 kyle wheel 1962 Jun 19 16:04 jar1-1.0-SNAPSHOT.jar -rw-r--r-- 1 kyle wheel 1962 Jun 19 16:04 jar2-1.0-SNAPSHOT.jar
In this setup, you can specify all of three jar files with the wildcard * as follows:
$ java -cp '/tmp/jar/*' corejava.classpath.Main corejava.jar1.Foo@511d50c0 corejava.jar2.Bar@5e2de80c
Note that you can’t use complex wildcard that smarter UNIX shells recognize. in other words, it doesn’t recognize patterns like *.jar. for example, the following command won’t work:
$ java -cp '/tmp/jar/*.jar' corejava.classpath.Main Error: Could not find or load main class corejava.classpath.Main
Including an image to javadoc
Consider you have a class named Dog in a Maven project. you want to include an image of a dog named chihuahua.jpg to the javadoc of the class. in such case you can write the class as follows:
package corejava.main;
/**
* The class represents a dog. <br> <img src="doc-files/chihuahua.jpg" alt="a cute chihuahua dog">
*/
public class Dog {
/**
* The dog will say woof.
*/
public void bark() {
System.out.println("Woof!");
}
}
Next, put the chihuahua.jpg in src/main/javadoc/corejava/main/doc-files. structure under the src/main will be:
. |-- java | `-- corejava | `-- main | `-- Dog.java |-- javadoc | `-- corejava | `-- main | `-- doc-files | `-- chihuahua.jpg `-- resources
Then execute mvn javadoc:javadoc in the top of the project directory. javadoc will be produced in the target/site/apidocs directory. open index.html in that directory and go to the documentation of Dog class, you will see the image of a dog as follows:
Including a link to relevant part of javadoc
Consider you have a class named Cat:
package corejava.main;
/**
* Represents a cat.
*/
public class Cat {
/**
* The cat starts meowing.
*
* @see corejava.main.Dog#bark()
* */
public void meow() {
System.out.println("Meow!");
}
}
This produces the following javadoc:
There are some of more useful syntaxes such as link to external URLs.
Method references
The following three statements produce identical Comparator:
Comparator<String> c1 = new Comparator<String>() {
@Override
public int compare(String x, String y) {
return x.compareTo(y);
}
};
Comparator<String> c2 = (x, y) -> x.compareTo(y);
Comparator<String> c3 = String::compareTo;
Constructor references
Constructor references are useful with Streams. consider you have a class named Dog:
public class Dog {
private String name;
public Dog(String name) {
this.name = name;
}
public String getName() {
return name;
}
@Override
public String toString() {
return "Dog{" + "name='" + name + '\'' + '}';
}
}
You can convert a List<String> that contains name of dogs to a Stream<Dog> as follows:
List<String> dogs = Arrays.asList("Snoopy", "Spike", "Olaf");
Stream<Dog> dogStream = dogs.stream().map(Dog::new);
If you need to create a typed array from that Stream<Dog>, you can use following idiom:
Dog[] dogArray = dogStream.toArray(Dog[]::new);
Tags: book
