In Java, the java.util package provides a variety of utility classes that are extremely useful for day-to-day programming tasks. These classes offer methods for manipulating collections, random number generation, date/time facilities, and more. Below, I’ll provide an overview of some of the most commonly used utility classes in the java.util package, along with examples to illustrate their usage.
1. Collections
The Collections class provides static methods for working with collections. It includes algorithms for sorting, searching, and modifying collections.
Example: Sorting a List
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CollectionsExample {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Orange");
list.add("Banana");
// Sorting the list in natural order
Collections.sort(list);
System.out.println("Sorted List: " + list);
// Reversing the list
Collections.reverse(list);
System.out.println("Reversed List: " + list);
}
}Example: Finding Minimum and Maximum
import java.util.Collections;
import java.util.List;
import java.util.Arrays;
public class MinMaxExample {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(3, 5, 1, 4, 2);
// Finding the minimum and maximum elements
int min = Collections.min(numbers);
int max = Collections.max(numbers);
System.out.println("Minimum: " + min);
System.out.println("Maximum: " + max);
}
}2. Arrays
The Arrays class provides static methods to manipulate arrays (such as sorting and searching). It also contains methods for converting arrays to lists.
Example: Converting an Array to a List
import java.util.Arrays;
import java.util.List;
public class ArraysExample {
public static void main(String[] args) {
String[] array = {"Java", "Python", "C++"};
// Converting an array to a list
List<String> list = Arrays.asList(array);
System.out.println("List: " + list);
}
}Example: Sorting an Array
import java.util.Arrays;
public class ArraySortExample {
public static void main(String[] args) {
int[] numbers = {5, 3, 8, 1, 2};
// Sorting the array
Arrays.sort(numbers);
System.out.println("Sorted Array: " + Arrays.toString(numbers));
}
}3. Random
The Random class is used to generate pseudo-random numbers.
Example: Generating Random Numbers
import java.util.Random;
public class RandomExample {
public static void main(String[] args) {
Random random = new Random();
// Generate a random integer
int randomInt = random.nextInt();
System.out.println("Random Integer: " + randomInt);
// Generate a random integer between 0 and 9
int randomIntBounded = random.nextInt(10);
System.out.println("Random Integer (0-9): " + randomIntBounded);
// Generate a random double between 0.0 and 1.0
double randomDouble = random.nextDouble();
System.out.println("Random Double: " + randomDouble);
}
}4. Date and Calendar
The Date class represents a specific instant in time, with millisecond precision. The Calendar class is an abstract class that provides methods for converting between a specific instant in time and a set of calendar fields.
Example: Getting the Current Date and Time
import java.util.Date;
public class DateExample {
public static void main(String[] args) {
// Getting the current date and time
Date now = new Date();
System.out.println("Current Date and Time: " + now);
}
}Example: Using Calendar to Manipulate Date
import java.util.Calendar;
public class CalendarExample {
public static void main(String[] args) {
// Create a calendar instance and set it to the current date and time
Calendar calendar = Calendar.getInstance();
// Get the current year, month, and day
int year = calendar.get(Calendar.YEAR);
int month = calendar.get(Calendar.MONTH) + 1; // Months are 0-based
int day = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println("Current Date: " + year + "-" + month + "-" + day);
// Add 7 days to the current date
calendar.add(Calendar.DAY_OF_MONTH, 7);
System.out.println("Date after 7 days: " + calendar.getTime());
}
}5. Scanner
The Scanner class is used to parse primitive types and strings using regular expressions. It’s commonly used for reading user input from the console.
Example: Reading User Input
import java.util.Scanner;
public class ScannerExample {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Enter your name:");
String name = scanner.nextLine();
System.out.println("Enter your age:");
int age = scanner.nextInt();
System.out.println("Hello, " + name + ". You are " + age + " years old.");
}
}6. Timer and TimerTask
The Timer class is used to schedule tasks for future execution in a background thread. The TimerTask class represents a task that can be scheduled by a Timer.
Example: Scheduling a Repeated Task
import java.util.Timer;
import java.util.TimerTask;
public class TimerExample {
public static void main(String[] args) {
Timer timer = new Timer();
TimerTask task = new TimerTask() {
@Override
public void run() {
System.out.println("Task executed");
}
};
// Schedule the task to run every second, with a delay of 0 milliseconds before the first execution
timer.scheduleAtFixedRate(task, 0, 1000);
// Schedule a timer to cancel the task after 5 seconds
new Timer().schedule(new TimerTask() {
@Override
public void run() {
timer.cancel();
System.out.println("Timer cancelled");
}
}, 5000);
}
}7. Locale
The Locale class represents a specific geographical, political, or cultural region. It can be used to tailor programs to different regions or languages.
Example: Displaying Localized Information
import java.util.Locale;
public class LocaleExample {
public static void main(String[] args) {
// Create a locale for US
Locale localeUS = new Locale("en", "US");
// Create a locale for France
Locale localeFR = new Locale("fr", "FR");
// Display language and country
System.out.println("Locale US: " + localeUS.getDisplayLanguage() + ", " + localeUS.getDisplayCountry());
System.out.println("Locale FR: " + localeFR.getDisplayLanguage() + ", " + localeFR.getDisplayCountry());
}
}8. Properties
The Properties class is used to maintain lists of values in which both keys and values are strings. It’s often used for configuration data.
Example: Reading and Writing Properties
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;
public class PropertiesExample {
public static void main(String[] args) {
Properties properties = new Properties();
// Set properties
properties.setProperty("username", "admin");
properties.setProperty("password", "secret");
// Save properties to a file
try (FileOutputStream out = new FileOutputStream("config.properties")) {
properties.store(out, "Configuration Settings");
} catch (IOException e) {
e.printStackTrace();
}
// Load properties from a file
try (FileInputStream in = new FileInputStream("config.properties")) {
properties.load(in);
System.out.println("Username: " + properties.getProperty("username"));
System.out.println("Password: " + properties.getProperty("password"));
} catch (IOException e) {
e.printStackTrace();
}
}
}9. UUID
The UUID class is used to generate universally unique identifiers. UUIDs are useful for identifying unique objects in a distributed system.
Example: Generating a UUID
import java.util.UUID;
public class UUIDExample {
public static void main(String[] args) {
// Generate a random UUID
UUID uuid = UUID.randomUUID();
System.out.println("Random UUID: " + uuid);
// Generate a UUID from a string
UUID uuidFromString = UUID.fromString("12345678-1234-5678-1234-567812345678");
System.out.println("UUID from String: " + uuidFromString);
}
}Conclusion
The java.util package provides a comprehensive set of utility classes that simplify many common programming tasks. By leveraging these classes, developers can write more efficient and maintainable code. Understanding these classes and how to use them effectively is essential for any Java programmer.
