package org.kodejava.util;
import java.util.SortedSet;
import java.util.TreeSet;
public class LastSetElement {
public static void main(String[] args) {
SortedSet<String> numbers = new TreeSet<>();
numbers.add("One");
numbers.add("Two");
numbers.add("Three");
numbers.add("Four");
numbers.add("Five");
// SortedSet orders the items it contains. We can get the last
// item from the set using the last() method. The last item
// will be "Two".
String lastElement = numbers.last();
System.out.println("lastElement = " + lastElement);
}
}
How do I get the first element of SortedSet?
package org.kodejava.util;
import java.util.TreeSet;
import java.util.SortedSet;
public class FirstSetElement {
public static void main(String[] args) {
SortedSet<String> numbers = new TreeSet<>();
numbers.add("One");
numbers.add("Two");
numbers.add("Three");
numbers.add("Four");
numbers.add("Five");
// SortedSet orders the items it contains. We can get the first
// item from the SortedSet using the first() method. The fist item
// will be "Five".
String firstElement = numbers.first();
System.out.println("firstElement = " + firstElement);
}
}
How do I get all annotations?
To obtains all annotations for classes, methods, constructors, or fields we use the getAnnotations()method. This method returns an array of Annotation
In the following example we tried to read all annotations from the sayHi() method. First we need to obtain the method object itself. Because the sayHi() method has parameters, we need to pass not only the method name to the getMethod() method, but we also need to pass the parameter’s type.
The getAnnotations() method returns only annotation that has a RetentionPolicy.RUNTIME, because other retention policy doesn’t allow the annotation to available at runtime.
package org.kodejava.lang.annotation;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
public class GetAllAnnotation {
private final Map<String, String> data = new HashMap<>();
public static void main(String[] args) {
GetAllAnnotation demo = new GetAllAnnotation();
demo.sayHi("001", "Alice");
demo.sayHi("004", "Malory");
try {
Class<? extends GetAllAnnotation> clazz = demo.getClass();
// To get the sayHi() method we need to pass not only the method
// name but also its parameters type so the getMethod() method
// return the correct method for us to use.
Method method = clazz.getMethod("sayHi", String.class, String.class);
// Get all annotations from the sayHi() method. But this actually
// will only return one annotation. Because only the HelloAnnotation
// annotation that has RUNTIME retention policy, which means that
// the other annotations associated with sayHi() method is not
// available at runtime.
Annotation[] annotations = method.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println("Type: " + annotation.annotationType());
}
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
}
@MyAnnotation("Hi")
@HelloAnnotation(value = "Hello", greetTo = "Everyone")
public void sayHi(String dataId, String name) {
Map<String, String> data = getData();
if (data.containsKey(dataId)) {
System.out.println("Hello " + data.get(dataId));
} else {
data.put(dataId, name);
}
}
private Map<String, String> getData() {
data.put("001", "Alice");
data.put("002", "Bob");
data.put("003", "Carol");
return data;
}
}
package org.kodejava.lang.annotation;
public @interface MyAnnotation {
String value();
}
Check the HelloAnnotation on the following link How do I create a simple annotation?.
The result of this code snippet:
Hello Alice
Type: interface org.kodejava.lang.annotation.HelloAnnotation
How do I obtain annotations at runtime using reflection?
This example demonstrate how to obtain annotations of a class and methods. We use the reflection API to get class and method information from where we can read information about annotation attached to the class or the method.
package org.kodejava.lang.annotation;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
@HelloAnnotation(value = "Hello", greetTo = "Universe")
public class GettingAnnotation {
public static void main(String[] args) {
GettingAnnotation demo = new GettingAnnotation();
Class<? extends GettingAnnotation> clazz = demo.getClass();
Annotation[] annotations = clazz.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println("Annotation Type: " + annotation.annotationType());
}
HelloAnnotation annotation = clazz.getAnnotation(HelloAnnotation.class);
System.out.println("Value : " + annotation.value());
System.out.println("GreetTo: " + annotation.greetTo());
try {
Method m = clazz.getMethod("sayHi");
annotation = m.getAnnotation(HelloAnnotation.class);
System.out.println("Value : " + annotation.value());
System.out.println("GreetTo: " + annotation.greetTo());
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
demo.sayHello();
}
@HelloAnnotation(value = "Hi", greetTo = "Alice")
public void sayHi() {
}
@HelloAnnotation(value = "Hello", greetTo = "Bob")
public void sayHello() {
try {
Method method = getClass().getMethod("sayHello");
HelloAnnotation annotation = method.getAnnotation(HelloAnnotation.class);
System.out.println(annotation.value() + " " + annotation.greetTo());
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
}
}
You can find the HelloAnnotation annotation that we use above on the following example: How do I create a simple annotation?.
The result of our program is:
Annotation Type: interface org.kodejava.lang.annotation.HelloAnnotation
Value : Hello
GreetTo: Universe
Value : Hi
GreetTo: Alice
Hello Bob
How do I annotate a class or method?
This example show you how to use the HelloAnnotation annotation on the previous example code, How do I create a simple annotation?. We add the HelloAnnotation annotation to our class and its methods.
package org.kodejava.lang.annotation;
@HelloAnnotation(value = "Good Morning", greetTo = "Universe")
public class HelloAnnotationExample {
public static void main(String[] args) {
HelloAnnotationExample hello = new HelloAnnotationExample();
hello.sayHi();
hello.sayHello();
}
@HelloAnnotation(value = "Hi there", greetTo = "Alice")
private void sayHi() {
}
@HelloAnnotation(value = "Hello there", greetTo = "Bob")
private void sayHello() {
}
}