A null pointer exception occurs when you try to access an object or variable that is null. Here's an example:

	String str = null;
	// This line will throw a null pointer exception
	int length = str.length();

To avoid null pointer exceptions, make sure to always initialize your variables and check for null values before accessing them.

An array index out of bounds exception occurs when you try to access an index that does not exist in an array. Here's an example:

	int[] nums = {1, 2, 3};
	// This line will throw an array index out 
	// of bounds exception
	int num = nums[3];

To avoid array index out of bounds exceptions, make sure to always check the length of your arrays before accessing them and make sure that your index values are within the bounds of the array.

A class cast exception occurs when you try to cast an object to a type that is not compatible with the object's actual type. Here's an example:

	Object obj = new Integer(100);
	// This line will throw a class cast exception
	String str = (String) obj;

To avoid class cast exceptions, make sure to always check the type of an object before casting it and use the appropriate type casting methods.

An arithmetic exception occurs when you try to perform an illegal arithmetic operation, such as dividing by zero. Here's an example:

	int num1 = 10;
	int num2 = 0;
	// This line will throw an arithmetic exception
	int result = num1 / num2;

To avoid arithmetic exceptions, make sure to always check for illegal operations before performing them, such as checking for a divisor of zero before dividing.

A number format exception occurs when you try to convert a string to a number, but the string is not in the correct format. Here's an example:

	String str = "abc";
	// This line will throw a number format exception
	int num = Integer.parseInt(str);

To avoid number format exceptions, make sure to always check that the input string is in the correct format before attempting to convert it to a number.

A stack overflow error occurs when a program runs out of stack space, usually because of an excessive amount of recursion. Here's an example:

	public class RecursionExample {
	    public static void main(String[] args) {
	        recursiveMethod(1);
	    }
	  
	    public static void recursiveMethod(int i) {
	        System.out.println(i);
	        recursiveMethod(i+1);
	    }
	}

To avoid stack overflow errors, make sure to limit the amount of recursion in your program and use iterative methods when appropriate.

A concurrent modification exception occurs when a collection is modified while it is being iterated over. Here's an example:

	List<String> myList = new ArrayList<>();
	myList.add("A");
	myList.add("B");
	myList.add("C");
	
	for (String s : myList) {
	    if (s.equals("B")) {
	        // This line will throw a concurrent
	        // modification exception
	        myList.remove(s);
	    }
	}

To avoid concurrent modification exceptions, make sure to use the appropriate methods for modifying collections while they are being iterated over, such as using an iterator or a copy of the collection.

An unsupported operations exception occurs when a method or operation is called on an object that does not support that method or operation. Here's an example:

	List<String> myList = Collections.singletonList("A");
	// This line will throw an unsupported
	// operations exception
	myList.add("B");

To avoid unsupported operations exceptions, make sure to only use methods and operations that are supported by the object you are using.