Merge remote-tracking branch 'upstream/master'

core-java/README.md

@@ -127,3 +127,13 @@
 - [Polymorphism in Java](http://www.baeldung.com/java-polymorphism)
 - [Recursion In Java](http://www.baeldung.com/java-recursion)
 - [A Guide to the finalize Method in Java](http://www.baeldung.com/java-finalize)
+- [Compiling Java *.class Files with javac](http://www.baeldung.com/javac)
+- [Method Overloading and Overriding in Java](http://www.baeldung.com/java-method-overload-override)
+- [A Guide to TreeSet in Java](http://www.baeldung.com/java-tree-set)
+- [Guide to ThreadLocalRandom in Java](http://www.baeldung.com/java-thread-local-random)
+- [Java TreeMap vs HashMap](http://www.baeldung.com/java-treemap-vs-hashmap)
+- [A Guide to Iterator in Java](http://www.baeldung.com/java-iterator)
+- [The Trie Data Structure in Java](http://www.baeldung.com/trie-java)
+- [Introduction to Javadoc](http://www.baeldung.com/javadoc)
+- [How to TDD a List Implementation](http://jira.baeldung.com/browse/BAEL-1537)
+

core-java/pom.xml

@@ -78,6 +78,11 @@
             <artifactId>jackson-databind</artifactId>
             <version>${jackson.version}</version>
         </dependency>
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <version>${gson.version}</version>
+        </dependency>
 
         <!-- logging -->
         <dependency>
@@ -468,6 +473,7 @@
     <properties>
         <!-- marshalling -->
         <jackson.version>2.8.5</jackson.version>
+        <gson.version>2.8.2</gson.version>
 
         <!-- logging -->
         <org.slf4j.version>1.7.21</org.slf4j.version>

core-java/src/main/java/com/baeldung/array/Find2ndLargestInArray.java

@@ -0,0 +1,20 @@
+package com.baeldung.array;
+
+public class Find2ndLargestInArray {
+
+    public static int find2ndLargestElement(int[] array) {
+        int maxElement = array[0];
+        int secondLargestElement = -1;
+
+        for (int index = 0; index < array.length; index++) {
+            if (maxElement <= array[index]) {
+                secondLargestElement = maxElement;
+                maxElement = array[index];
+            } else if (secondLargestElement < array[index]) {
+                secondLargestElement = array[index];
+            }
+        }
+        return secondLargestElement;
+    }
+
+}

core-java/src/main/java/com/baeldung/array/FindElementInArray.java

@@ -0,0 +1,22 @@
+package com.baeldung.array;
+
+import java.util.Arrays;
+
+public class FindElementInArray {
+
+    public static boolean findGivenElementInArrayWithoutUsingStream(int[] array, int element) {
+        boolean actualResult = false;
+
+        for (int index = 0; index < array.length; index++) {
+            if (element == array[index]) {
+                actualResult = true;
+                break;
+            }
+        }
+        return actualResult;
+    }
+
+    public static boolean findGivenElementInArrayUsingStream(int[] array, int element) {
+        return Arrays.stream(array).filter(x -> element == x).findFirst().isPresent();
+    }
+}

core-java/src/main/java/com/baeldung/array/SumAndAverageInArray.java

@@ -0,0 +1,27 @@
+package com.baeldung.array;
+
+import java.util.Arrays;
+
+public class SumAndAverageInArray {
+
+    public static int findSumWithoutUsingStream(int[] array) {
+        int sum = 0;
+        for (int index = 0; index < array.length; index++) {
+            sum += array[index];
+        }
+        return sum;
+    }
+
+    public static int findSumUsingStream(int[] array) {
+        return Arrays.stream(array).sum();
+    }
+
+    public static double findAverageWithoutUsingStream(int[] array) {
+        int sum = findSumWithoutUsingStream(array);
+        return (double) sum / array.length;
+    }
+
+    public static double findAverageUsingStream(int[] array) {
+        return Arrays.stream(array).average().getAsDouble();
+    }
+}

core-java/src/main/java/com/baeldung/asciiart/AsciiArt.java

@@ -0,0 +1,62 @@
+package com.baeldung.asciiart;
+
+import java.awt.Font;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+import java.awt.image.BufferedImage;
+
+public class AsciiArt {
+
+    public AsciiArt() {
+    }
+
+    public void drawString(String text, String artChar, Settings settings) {
+        BufferedImage image = getImageIntegerMode(settings.width, settings.height);
+
+        Graphics2D graphics2D = getGraphics2D(image.getGraphics(), settings);
+        graphics2D.drawString(text, 6, ((int) (settings.height * 0.67)));
+
+        for (int y = 0; y < settings.height; y++) {
+            StringBuilder stringBuilder = new StringBuilder();
+
+            for (int x = 0; x < settings.width; x++) {
+                stringBuilder.append(image.getRGB(x, y) == -16777216 ? " " : artChar);
+            }
+
+            if (stringBuilder.toString()
+                .trim()
+                .isEmpty()) {
+                continue;
+            }
+
+            System.out.println(stringBuilder);
+        }
+
+    }
+
+    private BufferedImage getImageIntegerMode(int width, int height) {
+        return new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
+    }
+
+    private Graphics2D getGraphics2D(Graphics graphics, Settings settings) {
+        graphics.setFont(settings.font);
+
+        Graphics2D graphics2D = (Graphics2D) graphics;
+        graphics2D.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
+
+        return graphics2D;
+    }
+
+    public class Settings {
+        public Font font;
+        public int width;
+        public int height;
+
+        public Settings(Font font, int width, int height) {
+            this.font = font;
+            this.width = width;
+            this.height = height;
+        }
+    }
+}

core-java/src/main/java/com/baeldung/casting/Animal.java

@@ -0,0 +1,13 @@
+package com.baeldung.casting;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Animal {
+    private static final Logger LOGGER = LoggerFactory.getLogger(Animal.class);
+
+    public void eat() {
+        LOGGER.info("animal is eating");
+    }
+
+}

core-java/src/main/java/com/baeldung/casting/AnimalFeeder.java

@@ -0,0 +1,23 @@
+package com.baeldung.casting;
+
+import java.util.List;
+
+public class AnimalFeeder {
+
+    public void feed(List<Animal> animals) {
+        animals.forEach(animal -> {
+            animal.eat();
+            if (animal instanceof Cat) {
+                ((Cat) animal).meow();
+            }
+        });
+    }
+
+    public void uncheckedFeed(List<Animal> animals) {
+        animals.forEach(animal -> {
+            animal.eat();
+            ((Cat) animal).meow();
+        });
+    }
+
+}

core-java/src/main/java/com/baeldung/casting/AnimalFeederGeneric.java

@@ -0,0 +1,24 @@
+package com.baeldung.casting;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class AnimalFeederGeneric<T> {
+    private Class<T> type;
+
+    public AnimalFeederGeneric(Class<T> type) {
+        this.type = type;
+    }
+
+    public List<T> feed(List<Animal> animals) {
+        List<T> list = new ArrayList<T>();
+        animals.forEach(animal -> {
+            if (type.isInstance(animal)) {
+                T objAsType = type.cast(animal);
+                list.add(objAsType);
+            }
+        });
+        return list;
+    }
+
+}

core-java/src/main/java/com/baeldung/casting/Cat.java

@@ -0,0 +1,16 @@
+package com.baeldung.casting;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Cat extends Animal implements Mew {
+    private static final Logger LOGGER = LoggerFactory.getLogger(Cat.class);
+
+    public void eat() {
+        LOGGER.info("cat is eating");
+    }
+
+    public void meow() {
+        LOGGER.info("meow");
+    }
+}

core-java/src/main/java/com/baeldung/casting/Dog.java

@@ -0,0 +1,12 @@
+package com.baeldung.casting;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Dog extends Animal {
+    private static final Logger LOGGER = LoggerFactory.getLogger(Dog.class);
+
+    public void eat() {
+        LOGGER.info("dog is eating");
+    }
+}

core-java/src/main/java/com/baeldung/casting/Mew.java

@@ -0,0 +1,5 @@
+package com.baeldung.casting;
+
+public interface Mew {
+    public void meow();
+}

core-java/src/main/java/com/baeldung/classloader/CustomClassLoader.java

@@ -0,0 +1,29 @@
+package com.baeldung.classloader;
+
+import java.io.*;
+
+public class CustomClassLoader extends ClassLoader {
+
+
+    public Class getClass(String name) throws ClassNotFoundException {
+        byte[] b = loadClassFromFile(name);
+        return defineClass(name, b, 0, b.length);
+    }
+
+    private byte[] loadClassFromFile(String fileName)  {
+        InputStream inputStream = getClass().getClassLoader().getResourceAsStream(
+                fileName.replace('.', File.separatorChar) + ".class");
+        byte[] buffer;
+        ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
+        int nextValue = 0;
+        try {
+            while ( (nextValue = inputStream.read()) != -1 ) {
+                byteStream.write(nextValue);
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        buffer = byteStream.toByteArray();
+        return buffer;
+    }
+}

core-java/src/main/java/com/baeldung/classloader/PrintClassLoader.java

@@ -0,0 +1,22 @@
+package com.baeldung.classloader;
+
+import com.sun.javafx.util.Logging;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.ArrayList;
+
+public class PrintClassLoader {
+
+    public void printClassLoaders() throws ClassNotFoundException {
+
+        System.out.println("Classloader of this class:" + PrintClassLoader.class.getClassLoader());
+        System.out.println("Classloader of Logging:" + Logging.class.getClassLoader());
+        System.out.println("Classloader of ArrayList:" + ArrayList.class.getClassLoader());
+
+    }
+}

core-java/src/main/java/com/baeldung/deepcopy/Address.java

@@ -0,0 +1,59 @@
+package com.baeldung.deepcopy;
+
+import java.io.Serializable;
+
+public class Address implements Serializable, Cloneable {
+
+    @Override
+    public Object clone() {
+        try {
+            return (Address) super.clone();
+        } catch (CloneNotSupportedException e) {
+            return new Address(this.street, this.getCity(), this.getCountry());
+        }
+    }
+
+    private static final long serialVersionUID = 1740913841244949416L;
+    private String street;
+    private String city;
+
+    private String country;
+
+    public Address(Address that) {
+        this(that.getStreet(), that.getCity(), that.getCountry());
+    }
+
+    public Address(String street, String city, String country) {
+        this.street = street;
+        this.city = city;
+        this.country = country;
+    }
+
+    public Address() {
+    }
+
+    public String getStreet() {
+        return street;
+    }
+
+    public String getCity() {
+        return city;
+    }
+
+    public String getCountry() {
+        return country;
+    }
+
+    public void setStreet(String street) {
+        this.street = street;
+    }
+
+    public void setCity(String city) {
+        this.city = city;
+    }
+
+    public void setCountry(String country) {
+        this.country = country;
+    }
+}
+

core-java/src/main/java/com/baeldung/deepcopy/User.java

@@ -0,0 +1,48 @@
+package com.baeldung.deepcopy;
+
+import java.io.Serializable;
+
+public class User implements Serializable, Cloneable {
+
+    private static final long serialVersionUID = -3427002229954777557L;
+    private String firstName;
+    private String lastName;
+    private Address address;
+
+    public User(String firstName, String lastName, Address address) {
+        this.firstName = firstName;
+        this.lastName = lastName;
+        this.address = address;
+    }
+
+    public User(User that) {
+        this(that.getFirstName(), that.getLastName(), new Address(that.getAddress()));
+    }
+
+    public User() {
+    }
+
+    @Override
+    public Object clone() {
+        User user;
+        try {
+            user = (User) super.clone();
+        } catch (CloneNotSupportedException e) {
+            user = new User(this.getFirstName(), this.getLastName(), this.getAddress());
+        }
+        user.address = (Address) this.address.clone();
+        return user;
+    }
+
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+
+    public Address getAddress() {
+        return address;
+    }
+}

core-java/src/main/java/com/baeldung/designpatterns/flyweight/Car.java

@@ -0,0 +1,85 @@
+package com.baeldung.designpatterns.flyweight;
+
+import java.awt.Color;
+
+import javax.annotation.concurrent.Immutable;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Represents a car. This class is immutable.
+ * 
+ * @author Donato Rimenti
+ */
+@Immutable
+public class Car implements Vehicle {
+
+	/**
+	 * Logger.
+	 */
+	private final static Logger LOG = LoggerFactory.getLogger(Car.class);
+
+	/**
+	 * The car's engine.
+	 */
+	private Engine engine;
+
+	/**
+	 * The car's color.
+	 */
+	private Color color;
+
+	/**
+	 * Instantiates a new Car.
+	 *
+	 * @param engine
+	 *            the {@link #engine}
+	 * @param color
+	 *            the {@link #color}
+	 */
+	public Car(Engine engine, Color color) {
+		this.engine = engine;
+		this.color = color;
+
+		// Building a new car is a very expensive operation!
+		try {
+			Thread.sleep(2000);
+		} catch (InterruptedException e) {
+			LOG.error("Error while creating a new car", e);
+		}
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see com.baeldung.designpatterns.flyweight.Vehicle#start()
+	 */
+	@Override
+	public void start() {
+		LOG.info("Car is starting!");
+		engine.start();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see com.baeldung.designpatterns.flyweight.Vehicle#stop()
+	 */
+	@Override
+	public void stop() {
+		LOG.info("Car is stopping!");
+		engine.stop();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see com.baeldung.designpatterns.flyweight.Vehicle#getColor()
+	 */
+	@Override
+	public Color getColor() {
+		return this.color;
+	}
+
+}

core-java/src/main/java/com/baeldung/designpatterns/flyweight/Engine.java

@@ -0,0 +1,31 @@
+package com.baeldung.designpatterns.flyweight;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Engine for a vehicle.
+ * 
+ * @author Donato Rimenti
+ */
+public class Engine {
+
+	/**
+	 * Logger.
+	 */
+	private final static Logger LOG = LoggerFactory.getLogger(Engine.class);
+
+	/**
+	 * Starts the engine.
+	 */
+	public void start() {
+		LOG.info("Engine is starting!");
+	}
+
+	/**
+	 * Stops the engine.
+	 */
+	public void stop() {
+		LOG.info("Engine is stopping!");
+	}
+}

core-java/src/main/java/com/baeldung/designpatterns/flyweight/Vehicle.java

@@ -0,0 +1,29 @@
+package com.baeldung.designpatterns.flyweight;
+
+import java.awt.Color;
+
+/**
+ * Interface for a vehicle.
+ * 
+ * @author Donato Rimenti
+ */
+public interface Vehicle {
+
+	/**
+	 * Starts the vehicle.
+	 */
+	public void start();
+
+	/**
+	 * Stops the vehicle.
+	 */
+	public void stop();
+
+	/**
+	 * Gets the color of the vehicle.
+	 * 
+	 * @return the color of the vehicle
+	 */
+	public Color getColor();
+
+}

core-java/src/main/java/com/baeldung/designpatterns/flyweight/VehicleFactory.java

@@ -0,0 +1,45 @@
+package com.baeldung.designpatterns.flyweight;
+
+import java.awt.Color;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Factory which implements the Flyweight pattern to return an existing vehicle
+ * if present or a new one otherwise.
+ * 
+ * @author Donato Rimenti
+ */
+public class VehicleFactory {
+
+	/**
+	 * Stores the already created vehicles.
+	 */
+	private static Map<Color, Vehicle> vehiclesCache = new HashMap<Color, Vehicle>();
+
+	/**
+	 * Private constructor to prevent this class instantiation.
+	 */
+	private VehicleFactory() {
+	}
+
+	/**
+	 * Returns a vehicle of the same color passed as argument. If that vehicle
+	 * was already created by this factory, that vehicle is returned, otherwise
+	 * a new one is created and returned.
+	 * 
+	 * @param color
+	 *            the color of the vehicle to return
+	 * @return a vehicle of the specified color
+	 */
+	public static Vehicle createVehicle(Color color) {
+		// Looks for the requested vehicle into the cache.
+		// If the vehicle doesn't exist, a new one is created.
+		Vehicle newVehicle = vehiclesCache.computeIfAbsent(color, newColor -> {
+			// Creates the new car.
+			Engine newEngine = new Engine();
+			return new Car(newEngine, newColor);
+		});
+		return newVehicle;
+	}
+}

core-java/src/main/java/com/baeldung/inheritance/ArmoredCar.java

@@ -0,0 +1,43 @@
+package com.baeldung.inheritance;
+
+public class ArmoredCar extends Car implements Floatable, Flyable{
+    private int bulletProofWindows;
+    private String model;
+    
+    public void remoteStartCar() {
+        // this vehicle can be started by using a remote control
+    }
+    
+    public String registerModel() {
+        return model;
+    }
+    
+    public String getAValue() {
+        return super.model;   // returns value of model defined in base class Car
+        // return this.model;   // will return value of model defined in ArmoredCar
+        // return model;   // will return value of model defined in ArmoredCar
+    }
+    
+    public static String msg() {
+    	// return super.msg(); // this won't compile.
+    	return "ArmoredCar"; 
+    }
+    
+	@Override
+    public void floatOnWater() {
+        System.out.println("I can float!");
+    }
+    
+	@Override
+    public void fly() {
+        System.out.println("I can fly!");
+    }
+    
+    public void aMethod() {
+        // System.out.println(duration); // Won't compile
+        System.out.println(Floatable.duration); // outputs 10
+        System.out.println(Flyable.duration); // outputs 20
+    }
+    
+    
+}

core-java/src/main/java/com/baeldung/inheritance/BMW.java

@@ -0,0 +1,12 @@
+package com.baeldung.inheritance;
+
+public class BMW extends Car {
+    public BMW() {
+    	super(5, "BMW");
+    }
+	
+	@Override
+    public String toString() {
+    	return model;
+    }
+}

core-java/src/main/java/com/baeldung/inheritance/Car.java

@@ -0,0 +1,32 @@
+package com.baeldung.inheritance;
+
+public class Car {
+	private final int DEFAULT_WHEEL_COUNT = 5;
+	private final String DEFAULT_MODEL = "Basic";
+
+	protected int wheels;
+    protected String model;
+    
+    public Car() {
+    	this.wheels = DEFAULT_WHEEL_COUNT;
+    	this.model = DEFAULT_MODEL;
+    }
+    
+    public Car(int wheels, String model) {
+    	this.wheels = wheels;
+    	this.model = model;
+    }
+        
+    public void start() {
+        // Check essential parts
+        // If okay, start.
+    }
+    public static int count = 10;
+    public static String msg() {
+        return "Car";
+    }
+    
+    public String toString() {
+    	return model;
+    } 
+}

core-java/src/main/java/com/baeldung/inheritance/Employee.java

@@ -0,0 +1,15 @@
+package com.baeldung.inheritance;
+
+public class Employee {
+    private String name;
+    private Car car;
+    
+    public Employee(String name, Car car) {
+        this.name = name;
+        this.car = car;
+    }
+    
+    public Car getCar() {
+    	return car;
+    }
+}

core-java/src/main/java/com/baeldung/inheritance/Floatable.java

@@ -0,0 +1,10 @@
+package com.baeldung.inheritance;
+
+public interface Floatable {
+    int duration = 10;
+    void floatOnWater();
+    
+    default void repair() {
+        System.out.println("Repairing Floatable object");   
+    }
+}

core-java/src/main/java/com/baeldung/inheritance/Flyable.java

@@ -0,0 +1,13 @@
+package com.baeldung.inheritance;
+
+public interface Flyable {
+    int duration = 10;
+    void fly();
+    
+    /*
+     * Commented 
+     */
+    //default void repair() {
+    //    System.out.println("Repairing Flyable object"); 
+    //}
+}

core-java/src/main/java/com/baeldung/inheritance/SpaceCar.java

@@ -0,0 +1,18 @@
+package com.baeldung.inheritance;
+
+public class SpaceCar extends Car implements SpaceTraveller {
+	@Override
+    public void floatOnWater() {
+        System.out.println("SpaceCar floating!");
+    }
+    
+	@Override
+    public void fly() {
+        System.out.println("SpaceCar flying!");
+    }
+    
+	@Override
+    public void remoteControl() {
+        System.out.println("SpaceCar being controlled remotely!");
+    }
+}

core-java/src/main/java/com/baeldung/inheritance/SpaceTraveller.java

@@ -0,0 +1,6 @@
+package com.baeldung.inheritance;
+
+public interface SpaceTraveller extends Floatable, Flyable {
+    int duration = 10;
+    void remoteControl();
+}

core-java/src/main/java/com/baeldung/java/list/CustomList.java

@@ -0,0 +1,210 @@
+package com.baeldung.java.list;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+public class CustomList<E> implements List<E> {
+    private Object[] internal = {};
+
+    @Override
+    public boolean isEmpty() {
+        // the first cycle
+        // return true;
+
+        // the second cycle
+        // if (internal.length != 0) {
+        //     return false;
+        // } else {
+        //     return true;
+        // }
+
+        // refactoring
+        return internal.length == 0;
+    }
+
+    @Override
+    public int size() {
+        // the first cycle
+        // if (isEmpty()) {
+        //     return 0;
+        // } else {
+        //     return internal.length;
+        // }
+
+        // refactoring
+        return internal.length;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public E get(int index) {
+        // the first cycle
+        // return (E) internal[0];
+
+        // improvement
+        return (E) internal[index];
+    }
+
+    @Override
+    public boolean add(E element) {
+        // the first cycle
+        // internal = new Object[] { element };
+        // return true;
+
+        // the second cycle
+        Object[] temp = Arrays.copyOf(internal, internal.length + 1);
+        temp[internal.length] = element;
+        internal = temp;
+        return true;
+    }
+
+    @Override
+    public void add(int index, E element) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean addAll(Collection<? extends E> collection) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean addAll(int index, Collection<? extends E> collection) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public E remove(int index) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean remove(Object object) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean removeAll(Collection<?> collection) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean retainAll(Collection<?> collection) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean contains(Object object) {
+        for (Object element : internal) {
+            if (object.equals(element)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean containsAll(Collection<?> collection) {
+        for (Object element : collection)
+            if (!contains(element)) {
+                return false;
+            }
+        return true;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public E set(int index, E element) {
+        E oldElement = (E) internal[index];
+        internal[index] = element;
+        return oldElement;
+    }
+
+    @Override
+    public void clear() {
+        internal = new Object[0];
+    }
+
+    @Override
+    public int indexOf(Object object) {
+        for (int i = 0; i < internal.length; i++) {
+            if (object.equals(internal[i])) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    @Override
+    public int lastIndexOf(Object object) {
+        for (int i = internal.length - 1; i >= 0; i--) {
+            if (object.equals(internal[i])) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public List<E> subList(int fromIndex, int toIndex) {
+        Object[] temp = new Object[toIndex - fromIndex];
+        System.arraycopy(internal, fromIndex, temp, 0, temp.length);
+        return (List<E>) Arrays.asList(temp);
+    }
+
+    @Override
+    public Object[] toArray() {
+        return Arrays.copyOf(internal, internal.length);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public <T> T[] toArray(T[] array) {
+        if (array.length < internal.length) {
+            return (T[]) Arrays.copyOf(internal, internal.length, array.getClass());
+        }
+
+        System.arraycopy(internal, 0, array, 0, internal.length);
+        if (array.length > internal.length) {
+            array[internal.length] = null;
+        }
+        return array;
+    }
+
+    @Override
+    public Iterator<E> iterator() {
+        return new CustomIterator();
+    }
+
+    @Override
+    public ListIterator<E> listIterator() {
+        return null;
+    }
+
+    @Override
+    public ListIterator<E> listIterator(int index) {
+        // ignored for brevity
+        return null;
+    }
+
+    private class CustomIterator implements Iterator<E> {
+        int index;
+
+        @Override
+        public boolean hasNext() {
+            return index != internal.length;
+        }
+
+        @SuppressWarnings("unchecked")
+        @Override
+        public E next() {
+            E element = (E) CustomList.this.internal[index];
+            index++;
+            return element;
+        }
+    }
+}

core-java/src/main/java/com/baeldung/javadoc/SuperHero.java

@@ -23,9 +23,15 @@ public class SuperHero extends Person {
      * @return the amount of health hero has after attack
      * @see <a href="http://www.link_to_jira/HERO-402">HERO-402</a>
      * @since 1.0
+     * @deprecated As of version 1.1, use . . . instead
+     * @version 1.2
+     * @throws IllegalArgumentException if incomingDamage is negative
      */
-    public int successfullyAttacked(int incomingDamage, String damageType) {
+    public int successfullyAttacked(int incomingDamage, String damageType) throws Exception {
     	// do things
+    	if (incomingDamage < 0) {
+    		throw new IllegalArgumentException ("Cannot cause negative damage");
+    	}
         return 0;
     }