Map<Integer, Integer> map = new HashMap<Integer, Integer>();
//iterating over keys only
for (Integer key : map.keySet()) {
System.out.println("Key = " + key);
}
//iterating over values only
for (Integer value : map.values()) {
System.out.println("Value = " + value);
}
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
}
import java.io.*;
import java.util.*;
public class FilteredFileList {
public static File[] getFilteredFileList(File folder, final String filenameFilter, Date lastModifiedDateFilter) {
File[] listOfFiles = folder.listFiles(new FileFilter(){
public boolean accept(File file) {
//file is the object against which we are applying our logic.
//You can put your logic using filenameFilter and check whether
//the file's name comes under your criteria or not.
//To check against the lastmodified date you can use lastModifiedDateFilter.
return true;
}});
return listOfFiles;
}
}
import java.sql.*;
public class ConnectionInfo {
public Connection getConnection() {
Connection conn = null;
// the below properties should be read from a properties file based on the Database used
String url = "jdbc:mysql://localhost:3306/"; // url = jdbc:[subprotocol]://[hostname]:[portnumber]/
String dbName = "jdbctutorial"; // database name
String driver = "com.mysql.jdbc.Driver"; //Driver class name
String username = "root"; // username
String password = "root"; // password
try {
Class.forName(driver); // Dynamic loading based on database used.
conn = DriverManager.getConnection(url + dbName, username, password);
System.out.println("Connection Established");
} catch (SQLException e) {
e.printStackTrace();
} finally {
return conn;
}
}
public void closeConnection(Connection conn) {
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
public class RunnableExample implements Runnable {
private Thread thread;
public RunnableExample(String name) {
//here we pass the reference whose run method should be called.
thread = new Thread(this, name);
//creating thread
thread.start();
}
public void run() {
//your logic will go here
System.out.println(thread.getName());
}
}
public class RunnableMain {
public static void main(String[] args) {
//Creating three objects
Runnable run1 = new RunnableExample("Thread-1");
Runnable run2 = new RunnableExample("Thread-2");
Runnable run3 = new RunnableExample("Thread-3");
}
}
public class ThreadExample extends Thread {
public ThreadExample(String name) {
super(name);
}
public void run() {
//your logic will go here
System.out.println(thread.getName());
}
}
public class ThreadMain {
public static void main(String[] args) {
//Creating three objects
Thread t1 = new ThreadExample("Thread-1");
Thread t2 = new ThreadExample("Thread-2");
Thread t3 = new ThreadExample("Thread-3");
creating threads
t1.start();
t2.start();
t3.start();
}
}
int fact(int num) {
if(num == 0 || num == 1)
return 1;
else
return num * fact (num - 1);
}
int fibo(int num) {
if(num == 1 || num == 2)
return (num - 1);
else
return fibo(num - 2) + fibo(num - 1);
}
import java.io.*;
//Implement Externalizable interface to avoid object creation through Deserialization.
public class SingletonExample implements Externalizable {
//make a static object
private static SingletonExample g_instance;
//make the construct as provate to hide it from outer world.
private SingletonExample() {
//do nothing
}
//make this static method as synchronized for thread-safe model.
public synchronized static SingletonExample getInstance() {
if (g_instance == null)
g_instance = new SingletonExample();
return g_instance;
}
//override method and throw exception to avoid serialization
public void writeExternal(ObjectOutput out) throws SerializationNotAllowedException {
throw new SerializationNotAllowedException("Serialization is not supported.");
}
//override method and throw exception to avoid deserialization
public void readExternal(ObjectInput in) throws SerializationNotAllowedException {
throw new SerializationNotAllowedException("Deserialization is not supported.");
}
//override method to avoid object cloning
protected Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException("Cloning not allowed");
}
}
//As the methods writeExternal and readExternal throws IOException, hence we have to extend to create our own Exception.
class SerializationNotAllowedException extends IOException {
public SerializationNotAllowedException(String message) {
super(message);
}
}
System class are standard
input, standard output, and error output streams.