JournalDev

Java, Java EE, Android, Python, Web Development Tutorials

You are here: Home » Java » Java Generics Example Tutorial – Generic Method, Class, Interface

Java Generics Example Tutorial – Generic Method, Class, Interface

56 Comments

Java Genrics is one of the most important feature introduced in Java 5. If you have been working on Java Collections and with version 5 or higher, I am sure that you have used it. Generics in Java with collection classes is very easy but it provides a lot more features than just creating the type of collection and we will try to learn features of generics in this article. Understanding generics can become confusing sometimes if we go with jargon words, so I would try to keep it simple and easy to understand.

Java Generics – Generics in Java

java generics example tutorial, java generic method, class, interface

We will look into below topics of generics in java.

  1. Generics in Java
  2. Java Generic Class
  3. Java Generic Interface
  4. Java Generic Type
  5. Java Generic Method
  6. Java Generics Bounded Type Parameters
  7. Java Generics and Inheritance
  8. Java Generic Classes and Subtyping
  9. Java Generics Wildcards
    1. Java Generics Upper Bounded Wildcard
    2. Java Generics Unbounded Wildcard
    3. Java Generics Lower bounded Wildcard
  10. Subtyping using Generics Wildcard
  11. Java Generics Type Erasure

Generics in Java

Generics was added in Java 5 to provide compile-time type checking and removing risk of ClassCastException that was common while working with collection classes. The whole collection framework was re-written to use generics for type-safety. Let’s see how generics help us using collection classes safely.

Copy

List list = new ArrayList();
list.add("abc");
list.add(new Integer(5)); //OK

for(Object obj : list){
	//type casting leading to ClassCastException at runtime
    String str=(String) obj; 
}

Above code compiles fine but throws ClassCastException at runtime because we are trying to cast Object in the list to String whereas one of the element is of type Integer. After Java 5, we use collection classes like below.

Copy

List<String> list1 = new ArrayList<String>(); // java 7 ? List<String> list1 = new ArrayList<>(); 
list1.add("abc");
//list1.add(new Integer(5)); //compiler error

for(String str : list1){
     //no type casting needed, avoids ClassCastException
}

Notice that at the time of list creation, we have specified that the type of elements in the list will be String. So if we try to add any other type of object in the list, the program will throw compile time error. Also notice that in for loop, we don’t need type casting of the element in the list, hence removing the ClassCastException at runtime.

Java Generic Class

We can define our own classes with generics type. A generic type is a class or interface that is parameterized over types. We use angle brackets (<>) to specify the type parameter.

To understand the benefit, lets say we have a simple class as:

Copy

package com.journaldev.generics;

public class GenericsTypeOld {

	private Object t;

	public Object get() {
		return t;
	}

	public void set(Object t) {
		this.t = t;
	}

        public static void main(String args[]){
		GenericsTypeOld type = new GenericsTypeOld();
		type.set("Pankaj"); 
		String str = (String) type.get(); //type casting, error prone and can cause ClassCastException
	}
}

Notice that while using this class, we have to use type casting and it can produce ClassCastException at runtime. Now we will use java generic class to rewrite the same class as shown below.

Copy

package com.journaldev.generics;

public class GenericsType<T> {

	private T t;
	
	public T get(){
		return this.t;
	}
	
	public void set(T t1){
		this.t=t1;
	}
	
	public static void main(String args[]){
		GenericsType<String> type = new GenericsType<>();
		type.set("Pankaj"); //valid
		
		GenericsType type1 = new GenericsType(); //raw type
		type1.set("Pankaj"); //valid
		type1.set(10); //valid and autoboxing support
	}
}

Notice the use of GenericsType class in the main method. We don’t need to do type-casting and we can remove ClassCastException at runtime. If we don’t provide the type at the time of creation, compiler will produce a warning that “GenericsType is a raw type. References to generic type GenericsType<T> should be parameterized”. When we don’t provide type, the type becomes Object and hence it’s allowing both String and Integer objects but we should always try to avoid this because we will have to use type casting while working on raw type that can produce runtime errors.

Tip: We can use @SuppressWarnings("rawtypes") annotation to suppress the compiler warning, check out java annotations tutorial.

Also notice that it supports java autoboxing.

Java Generic Interface

Comparable interface is a great example of Generics in interfaces and it’s written as:

Copy

package java.lang;
import java.util.*;

public interface Comparable<T> {
    public int compareTo(T o);
}

In similar way, we can create generic interfaces in java. We can also have multiple type parameters as in Map interface. Again we can provide parameterized value to a parameterized type also, for example new HashMap<String, List<String>>(); is valid.

Java Generic Type

Java Generic Type Naming convention helps us understanding code easily and having a naming convention is one of the best practices of java programming language. So generics also comes with it’s own naming conventions. Usually type parameter names are single, uppercase letters to make it easily distinguishable from java variables. The most commonly used type parameter names are:

  • E – Element (used extensively by the Java Collections Framework, for example ArrayList, Set etc.)
  • K – Key (Used in Map)
  • N – Number
  • T – Type
  • V – Value (Used in Map)
  • S,U,V etc. – 2nd, 3rd, 4th types

Java Generic Method

Sometimes we don’t want whole class to be parameterized, in that case we can create java generics method. Since constructor is a special kind of method, we can use generics type in constructors too.

Here is a class showing example of java generic method.

Copy

package com.journaldev.generics;

public class GenericsMethods {

	//Java Generic Method
	public static <T> boolean isEqual(GenericsType<T> g1, GenericsType<T> g2){
		return g1.get().equals(g2.get());
	}
	
	public static void main(String args[]){
		GenericsType<String> g1 = new GenericsType<>();
		g1.set("Pankaj");
		
		GenericsType<String> g2 = new GenericsType<>();
		g2.set("Pankaj");
		
		boolean isEqual = GenericsMethods.<String>isEqual(g1, g2);
		//above statement can be written simply as
		isEqual = GenericsMethods.isEqual(g1, g2);
		//This feature, known as type inference, allows you to invoke a generic method as an ordinary method, without specifying a type between angle brackets.
		//Compiler will infer the type that is needed
	}
}

Notice the isEqual method signature showing syntax to use generics type in methods. Also notice how to use these methods in our java program. We can specify type while calling these methods or we can invoke them like a normal method. Java compiler is smart enough to determine the type of variable to be used, this facility is called as type inference.

Java Generics Bounded Type Parameters

Suppose we want to restrict the type of objects that can be used in the parameterized type, for example in a method that compares two objects and we want to make sure that the accepted objects are Comparables. To declare a bounded type parameter, list the type parameter’s name, followed by the extends keyword, followed by its upper bound, similar like below method.

Copy

public static <T extends Comparable<T>> int compare(T t1, T t2){
		return t1.compareTo(t2);
	}

The invocation of these methods is similar to unbounded method except that if we will try to use any class that is not Comparable, it will throw compile time error.

Bounded type parameters can be used with methods as well as classes and interfaces.

Java Generics supports multiple bounds also, i.e <T extends A & B & C>. In this case A can be an interface or class. If A is class then B and C should be interfaces. We can’t have more than one class in multiple bounds.

Java Generics and Inheritance

We know that Java inheritance allows us to assign a variable A to another variable B if A is subclass of B. So we might think that any generic type of A can be assigned to generic type of B, but it’s not the case. Lets see this with a simple program.

Copy

package com.journaldev.generics;

public class GenericsInheritance {

	public static void main(String[] args) {
		String str = "abc";
		Object obj = new Object();
		obj=str; // works because String is-a Object, inheritance in java
		
		MyClass<String> myClass1 = new MyClass<String>();
		MyClass<Object> myClass2 = new MyClass<Object>();
		//myClass2=myClass1; // compilation error since MyClass<String> is not a MyClass<Object>
		obj = myClass1; // MyClass<T> parent is Object
	}
	
	public static class MyClass<T>{}

}

We are not allowed to assign MyClass<String> variable to MyClass<Object> variable because they are not related, in fact MyClass<T> parent is Object.

Java Generic Classes and Subtyping

We can subtype a generic class or interface by extending or implementing it. The relationship between the type parameters of one class or interface and the type parameters of another are determined by the extends and implements clauses.

For example, ArrayList<E> implements List<E> that extends Collection<E>, so ArrayList<String> is a subtype of List<String> and List<String> is subtype of Collection<String>.

The subtyping relationship is preserved as long as we don’t change the type argument, below shows an example of multiple type parameters.

Copy

interface MyList<E,T> extends List<E>{
}

The subtypes of List<String> can be MyList<String,Object>, MyList<String,Integer> and so on.

Java Generics Wildcards

Question mark (?) is the wildcard in generics and represent an unknown type. The wildcard can be used as the type of a parameter, field, or local variable and sometimes as a return type. We can’t use wildcards while invoking a generic method or instantiating a generic class. In following sections, we will learn about upper bounded wildcards, lower bounded wildcards, and wildcard capture.

Java Generics Upper Bounded Wildcard

Upper bounded wildcards are used to relax the restriction on the type of variable in a method. Suppose we want to write a method that will return the sum of numbers in the list, so our implementation will be something like this.

Copy

public static double sum(List<Number> list){
		double sum = 0;
		for(Number n : list){
			sum += n.doubleValue();
		}
		return sum;
	}

Now the problem with above implementation is that it won’t work with List of Integers or Doubles because we know that List<Integer> and List<Double> are not related, this is when upper bounded wildcard is helpful. We use generics wildcard with extends keyword and the upper bound class or interface that will allow us to pass argument of upper bound or it’s subclasses types.

The above implementation can be modified like below program.

Copy

package com.journaldev.generics;

import java.util.ArrayList;
import java.util.List;

public class GenericsWildcards {

	public static void main(String[] args) {
		List<Integer> ints = new ArrayList<>();
		ints.add(3); ints.add(5); ints.add(10);
		double sum = sum(ints);
		System.out.println("Sum of ints="+sum);
	}

	public static double sum(List<? extends Number> list){
		double sum = 0;
		for(Number n : list){
			sum += n.doubleValue();
		}
		return sum;
	}
}

It’s similar like writing our code in terms of interface, in above method we can use all the methods of upper bound class Number. Note that with upper bounded list, we are not allowed to add any object to the list except null. If we will try to add an element to the list inside the sum method, the program won’t compile.

Java Generics Unbounded Wildcard

Sometimes we have a situation where we want our generic method to be working with all types, in this case unbounded wildcard can be used. Its same as using <? extends Object>.

Copy

public static void printData(List<?> list){
		for(Object obj : list){
			System.out.print(obj + "::");
		}
	}

We can provide List<String> or List<Integer> or any other type of Object list argument to the printData method. Similar to upper bound list, we are not allowed to add anything to the list.

Java Generics Lower bounded Wildcard

Suppose we want to add Integers to a list of integers in a method, we can keep the argument type as List<Integer> but it will be tied up with Integers whereas List<Number> and List<Object> can also hold integers, so we can use lower bound wildcard to achieve this. We use generics wildcard (?) with super keyword and lower bound class to achieve this.

We can pass lower bound or any super type of lower bound as an argument in this case, java compiler allows to add lower bound object types to the list.

Copy

public static void addIntegers(List<? super Integer> list){
		list.add(new Integer(50));
	}

Subtyping using Generics Wildcard

Copy

List<? extends Integer> intList = new ArrayList<>();
List<? extends Number>  numList = intList;  // OK. List<? extends Integer> is a subtype of List<? extends Number>

Java Generics Type Erasure

Generics in Java was added to provide type-checking at compile time and it has no use at run time, so java compiler uses type erasure feature to remove all the generics type checking code in byte code and insert type-casting if necessary. Type erasure ensures that no new classes are created for parameterized types; consequently, generics incur no runtime overhead.

For example if we have a generic class like below;

Copy

public class Test<T extends Comparable<T>> {

    private T data;
    private Test<T> next;

    public Test(T d, Test<T> n) {
        this.data = d;
        this.next = n;
    }

    public T getData() { return this.data; }
}

The Java compiler replaces the bounded type parameter T with the first bound interface, Comparable, as below code:

Copy

public class Test {

    private Comparable data;
    private Test next;

    public Node(Comparable d, Test n) {
        this.data = d;
        this.next = n;
    }

    public Comparable getData() { return data; }
}

Generics in Java – Further Readings

Thats all for generics in java, java generics is a really vast topic and requires a lot of time to understand and use it effectively. This post here is an attempt to provide basic details of generics and how can we use it to extend our program with type-safety.

WhatsAppRedditLinkedin

Comments

  2. public class GenericsTypeOld {

    private Object t;

    public Object get() {
    return t;
    }

    public void set(Object t) {
    this.t = t;
    }

    public static void main(String args[]){
    GenericsTypeOld type = new GenericsTypeOld();
    type.set(“Pankaj”);
    112 //String str = (String) type.get(); //type casting, error prone and can cause ClassCastException
    }

    I think line number 112 is not giving erroe

    Reply

  3. Hi Pankaj,

    quite amid follower of your tutorials. Short but well explained topics. However, felt some topics are missing in this article. Like PECS of generics, how shall we use them. or maybe it’s me only who is finding it difficult.

    Reply

  4. Generics forces the java programmer to store specific type of objects. The language is very easy to understand. Thanks for sharing.

    Reply

  5. sir plz muje bato ki generics methode me hum 2 object ko jo generics h ko “+” operant se add kyo nahi kr pa rahe.

    Reply

  6. interface Parent {
    }

    interface Child extends Parent {

    }

    public class Subtyping implements Child {

    T tobj;
    U uobj;

    public Subtyping(T t, U u) {
    tobj = t;
    uobj = u;
    }

    public static void main(String[] args) {

    Parent obj = new Subtyping(4, “raj”);
    Parent obj1 = new Subtyping(4, 40.0);

    /*
    * The subtypes of Parent can be
    * Subtyping , Subtyping and so on.
    * but not Subtyping
    *
    * this statement will give error
    * Parent obj2 = new Subtyping( “raj”,4);
    */

    System.out.println(obj);
    System.out.println(obj1);

    }

    @Override
    public String toString() {
    return ” t= ” + tobj + ” ” + uobj;
    }

    }

    Reply

  7. An example for Java Generic Classes and Subtyping .

    interface Parent {
    }

    interface Child extends Parent {

    }

    public class Subtyping implements Child {

    T tobj;
    U uobj;

    public Subtyping(T t, U u) {
    tobj = t;
    uobj = u;
    }

    public static void main(String[] args) {

    Parent obj = new Subtyping(4, “raj”);
    Parent obj1 = new Subtyping(4, 40.0);

    /*
    * The subtypes of Parent can be
    * Subtyping , Subtyping and so on.
    * but not Subtyping
    *
    * this statement will give error
    * Parent obj2 = new Subtyping( “raj”,4);
    */

    System.out.println(obj);
    System.out.println(obj1);

    }

    @Override
    public String toString() {
    return ” t= ” + tobj + ” ” + uobj;
    }

    }

    Reply

  8. public class GenTest
    {
    T t;
    public void setType(T t)
    {
    this.t=t;
    }
    public T getType()
    {
    return t;
    }
    public static void main(String[] arg)
    {
    GenTest gt=new GenTest();
    Kamala k=new Kamala();
    gt.setType(k);
    //Object o=gt.getType();
    System.out.println(gt.getType().aboutu());
    }
    }

    //kamala class
    public class Kamala
    {
    public void aboutu()
    {
    System.out.println(“I am kamala ! i am helping class to check generic concept”);
    }
    }

    Sir above program i am getting error: ‘ void’ type not allowed here

    Reply

    • 1. First of all while using T t in GenTest you need to declare T as type parameter as class GenTest.
      2. While instantiating the generic class you must have used GenTest gt = new GenTest();
      3. calling aboutu in sysout – no need to use System.out.println(gt.getType().aboutu());
      use gt.getType().aboutu() as method return type is void.

      Hope this solves your problem and I recommend you to study the generics post thoroughly.

      Reply

  9. Thanks for the nice article.

    I couldnt understand Raw & Unbounded generics.
    What is the difference in below?

    Set setOfRawType = new HashSet();
    setOfRawType = new HashSet();
    Set setOfUnknownType = new HashSet();
    setOfUnknownType = new HashSet();

    Please explain its very urgent.

    TIA!

    Reply

    • 1. a raw type (Set) treats the type as if it had no generic type information at all. Note the subtle effect that not only will the type argument T be ignored, but also all other type arguments that methods of that type might have. You can add any value to it and it will always return Object.
      2. Set is a Set that accepts all Object objects (i.e. all objects) and will return objects of type Object.
      3. Set is a Set that accepts all objects of some specific, but unknown type and will return objects of that type. Since nothing is known about this type, you can’t add anything to that set (except for null) and the only thing that you know about the values it returns is that they are some sub-type of Object.

      http://stackoverflow.com/a/7360664

      Reply

  10. Hi..
    Have a doubt. Could you please help?

    Three classes are there. A,B & C. Both B & C extends A.
    So in generics how can I make the class C not to be included. It should allow only B

    Thanks,
    Shashi

    Reply

  13. Sir as I was going through your tutorial. I got stuck at a point

    public Object get() {
    return t;
    }

    public void set(Object t) {
    this.t = t;

    As I have seen in getter(), setter() methord, we write in such a way…

    public Object getT() {
    return t;
    }

    public void setT(Object t) {
    this.t = t;

    What you have done is OK for 1 variable???

    Reply

    • public Object getT() {
      return t;
      }

      public void setT(Object t) {
      this.t = t;

      Should be …

      public T getT() {
      return t;
      }

      public void setT(T t) {
      this.t = t;

      This allows any type. If you do it how you had it originally, you’re just making 2 Object type getters/setters with different names.

      Reply

  14. How converting int to String is autoboxing in the Class generic example given above.
    type1.set(10); //valid and autoboxing support

    Reply

  19. Excellent article. I am wondering for simple cases, is there a reason to use Wildcard instead of generics?
    e.g. The printData method in the “Generics Unbounded Wildcard” could have been written like that?

    public static void printData(List list) {
    for(T obj : list) {
    System.out.print(obj + “::”);
    }
    }

    And we don’t have the limitations of wildcard either (add method not allowed). So, is there any benefit of using wildcard in such cases?

    Reply

  20. Hi Pankaj,

    Your explanations and sample programs are very easy to understand.

    I have a query regarding generics.

    A sample progam:

    package main.test;

    import java.util.ArrayList;
    import java.util.List;

    public class MainClass {

    /**
    * @param args
    */
    public static void main(String[] args) {

    List list = new ArrayList();
    list.add(8);
    list.add(7);
    printList1(list);
    printList2(list);
    printList3(list);
    printList4(list);

    }

    /**
    * Using Generics Bounded Type Parameters
    * @param list
    */
    public static void printList1(List list){
    System.out.println(list);
    }

    /**
    * Using Generics Upper Bounded Wildcard
    * @param list
    */
    public static void printList2(List list){
    System.out.println(list);
    }

    /**
    * Using Simple Generics Method
    * @param list
    */
    public static void printList3(List list){
    System.out.println(list);
    }

    /**
    * Using Generics Unbounded Wildcard
    * @param list
    */
    public static void printList4(List list){
    System.out.println(list);
    }

    }

    There are 4 methods printing a list:
    printList1: Using Generics Bounded Type Parameters
    printList2: Using Generics Upper Bounded Wildcard
    printList3: Using Simple Generics Method
    printList4: Using Generics Unbounded Wildcard

    I have two questions:
    1) When to use Generics Upper Bounded Wildcard? Because the same thing can be done using Generics Bounded Type Parameters?(methods: printList1 and printList2)
    I mean how to decide which one to use between these two?

    2) Similar Question regarding method: printList3 and printList4.When to use the Generics Unbounded Wildcard?Because the same thing can be done using Using Simple Generics Method.

    Reply

    • Generic Upper/Lower Bounded Wildcard and Bounded Type parameters are similar, however bounded type parameters help us in writing generic algorithms, for example in above code, we are using bounded type parameters with Comparable.

      Reply

  21. Could you please explain what is that which can be done in a generic class but not in a normal java class without generics?

    Reply

    • Firstly u need to understand that GENERIC in java represents a General Model( be it a method or a class).

      Secondly, by creating generic class u r creating a General Class which can operate on any type of Object.

      Thirdly, without using generics u need to create separate class for supporting various types of objects.

      thus use of generic class helps u in reusability of code i.e less LOC & Compile time Type Checking.

      thanks
      Finishing School

      Reply

  27. Dear sir i have a query regarding generics plz solve this…
    I have a generic super class Employee and this super class have two sub class Admin and Finance…so tell me can i use Admin data in Finance sub class and Finance data in Admin sub class.

    Reply

    • This is not generics, its inheritance. Think of it like Integer and String class, both have super class as Object. Can you assign Integer to String and vice versa, NO.

      Reply

  28. Hi
    Respected Sir

    My expectation is growing high after getting answer from you and solving my previous problem.

    I face another problem while using java generic in my program.

    The problem is i have to GROUP BY a ganeric list based on one or two field.

    Suppose i have a POJO class named StationInformation with CODE,STATION,NAME,ADDRESS
    i have created a list ArrayList StationInformationList= new ArrayList

    and populate this list with station data.

    After some operation with this list object i have to GROUP BY this list based on CODE field and after that CODE and STATION field. This GROUP BY should be same as GROUP BY in database.
    There is no way to go database from here because data is coming from api.

    This is very essential to me and i have to resolve it as soon as possible.

    I hope i’ll get another feedback from you with solution my problem.
    This GROUP BY is vary urgent and please give me a solution.

    I am waiting for your answer/reply.

    Please please sir give me a solution.

    If possible please give me code example.

    Reply

  32. I want to create xlsx file from a ArrayList.
    TableBean means a class with some fields and its getter and setter.

    I have three (3) list
    1. ArrayList CompanyBeanList (CompanyBean has 4 fileds with getter – setter)
    2.ArrayList EmployeeBeanList (EmployeeBean has 10 fileds with getter – setter)
    3.ArrayList ClientBeanList (ClientBeanBean has 8 fileds with getter – setter)

    I want to call exportToExcel method as exportToExcel(“D:\Back Up\PROJECT\”,CompanyBeanList ,”CompanyBean”)
    and exportToExcel(“D:\Back Up\PROJECT\”,EmployeeBeanList ,”EmployeeBean”)
    and exportToExcel(“D:\Back Up\PROJECT\”,ClientBeanList ,”ClientBean”)

    exportToExcel is a method which create an .xlsx file in the specified path with data from the beanList (2 nd parameter)

    But problem is i can not pass these 3 different type of list in exportToExcel.
    Error says The method exportToExcel(String, ArrayList, String) in the type Utility is not applicable for the arguments (String, List, String) (same for other two class)

    I do not want to write BeanClass name in parameter. it should be parametrized.

    public static void exportToExcel(String outputPath , ArrayList beanClassName,String sheetName)
    {
    try{

    Map data = new TreeMap();
    XSSFWorkbook workbook = new XSSFWorkbook();
    XSSFSheet sheet = workbook.createSheet(sheetName);

    Object[] colName =new Object[20];
    if(beanClassName.size()>0)
    {
    Field[] field=beanClassName.get(0).getClass().getDeclaredFields();
    for(int i=0;i<field.length;i++)
    {
    colName[i]=field[i].getName().toUpperCase();
    }
    data.put("1", colName);

    for(int i=0;i<beanClassName.size();i++)
    {
    Object[] colValue =new Object[20];
    Field[] field1=beanClassName.get(0).getClass().getDeclaredFields();
    for(int f=0;i<field1.length;i++)
    {
    Method method=null;
    try {
    method=beanClassName.get(i).getClass().getMethod("get"+field1[f].getName().toUpperCase(), null);
    }catch (IllegalArgumentException e) {
    log.error("User: "+getUserName()+" : "+"exportToExcel..1.."+e.getMessage());
    e.printStackTrace();
    } catch (Exception e) {
    log.error("User: "+getUserName()+" : "+"exportToExcel..2…."+e.getMessage());
    e.printStackTrace();
    }
    colValue[f]=method.invoke(beanClassName.get(i), null);
    }
    data.put((i+2)+"", colValue);

    }
    Set keyset = data.keySet();
    int rownum = 0;
    for (String key : keyset)
    {
    Row row = sheet.createRow(rownum++);
    Object [] objArr = data.get(key);
    int cellnum = 0;
    for (Object obj : objArr)
    {
    Cell cell = row.createCell(cellnum++);
    if(obj instanceof String)
    cell.setCellValue((String)obj);
    else if(obj instanceof Integer)
    cell.setCellValue((Integer)obj);
    else if(obj instanceof Double)
    cell.setCellValue((Double)obj);
    else if(obj instanceof Float)
    cell.setCellValue((Float)obj);
    else if(obj instanceof Number)
    cell.setCellValue((Double)obj);
    }
    }
    try
    {
    //Write the workbook in file system
    FileOutputStream out = new FileOutputStream(new File(outputPath+File.separator+”OrderCounts.xlsx”));
    workbook.write(out);
    out.close();

    }
    catch (Exception e)
    {
    e.printStackTrace();
    }

    }
    else
    {
    return;
    }

    }catch (Exception e) {
    log.error(“User: “+getUserName()+” : “+”exportToExcel……”+e.getMessage());
    e.printStackTrace();
    }
    }

    I only want to call
    exportToExcel(“D:\Back Up\PROJECT\”,CompanyBeanList ,”CompanyBean”)
    and exportToExcel(“D:\Back Up\PROJECT\”,EmployeeBeanList ,”EmployeeBean”)
    and exportToExcel(“D:\Back Up\PROJECT\”,ClientBeanList ,”ClientBean”)

    and it will create .xlsx file in the path. That is my main aim.

    Is it possible.??
    Which modification is necessary in exportToExcel method. ???
    If solution is known to you please write / modify exportToExcel method as you wish and reply me over mail or post in this site.

    It is very urgent to me. I am waiting for your reply.

    I hope i’ll get a suitable solution from you.I believe on you.

    Reply

    • its simple, the error is coming because your method argument is expecting ArrayList but you might be creating at client side as List myList = new ArrayList();.

      All you need to do is change the method argument type to List and you should be good to go.

      Reply

  34. List str=null;
    str.add(“varun”);
    str.add(new Integer(10), str);

    im getting compile time error..plz give me solution .how to add string and integer both in arrylist ???

    Reply

    • The classes should have something in common, if nothing specified then Object is the common parent class that we can use to define the type of list.

      Reply

  36. hi! i want to devlop my future in java ,i want to learn it i am beginner no from whrere do i start please help me!!!

    Reply

  37. Hi

    Thanks for the very informative article..

    However could you please explain the difference between:

    public static void printData(List list){
    for(Object obj : list){
    System.out.print(obj + “::”);
    }
    }

    And

    public static void printData(List list){
    for(Object obj : list){
    System.out.print(obj + “::”);
    }
    }

    Reply

Leave a Reply

Your email address will not be published. Required fields are marked *