How to use Comparator in Java to sort

JavaSortingComparator

Java Problem Overview

I learned how to use the comparable but I'm having difficulty with the Comparator. I am having a error in my code:

Exception in thread "main" java.lang.ClassCastException: New.People cannot be cast to java.lang.Comparable
 at java.util.Arrays.mergeSort(Unknown Source)
 at java.util.Arrays.sort(Unknown Source)
 at java.util.Collections.sort(Unknown Source)
 at New.TestPeople.main(TestPeople.java:18)

Here is my code:

import java.util.Comparator;

public class People implements Comparator {
   private int id;
   private String info;
   private double price;
 
   public People(int newid, String newinfo, double newprice) {
       setid(newid);
       setinfo(newinfo);
       setprice(newprice);
   }
 
   public int getid() {
       return id;
   }

   public void setid(int id) {
       this.id = id;
   }

   public String getinfo() {
       return info;
   }

   public void setinfo(String info) {
       this.info = info;
   }

   public double getprice() {
       return price;
   }

   public void setprice(double price) {
       this.price = price;
   }

   public int compare(Object obj1, Object obj2) {
       Integer p1 = ((People) obj1).getid();
       Integer p2 = ((People) obj2).getid();
  
       if (p1 > p2) {
           return 1;
       } else if (p1 < p2){
           return -1;
       } else {
           return 0;
       }
    }
}


import java.util.ArrayList;
import java.util.Collections;

public class TestPeople {
    public static void main(String[] args) {
        ArrayList peps = new ArrayList();
  
        peps.add(new People(123, "M", 14.25));
        peps.add(new People(234, "M", 6.21));
        peps.add(new People(362, "F", 9.23));
        peps.add(new People(111, "M", 65.99));
        peps.add(new People(535, "F", 9.23));
  
        Collections.sort(peps);
  
        for (int i = 0; i < peps.size(); i++){
            System.out.println(peps.get(i));
        }
    }
}

I believe it has to do something with the casting in the compare method but I was playing around with it and still could not find the solution

Java Solutions

Solution 1 - Java

There are a couple of awkward things with your example class:

  • it's called People while it has a price and info (more something for objects, not people);
  • when naming a class as a plural of something, it suggests it is an abstraction of more than one thing.

Anyway, here's a demo of how to use a Comparator<T>:

public class ComparatorDemo {

    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
                new Person("Joe", 24),
                new Person("Pete", 18),
                new Person("Chris", 21)
        );
        Collections.sort(people, new LexicographicComparator());
        System.out.println(people);
        Collections.sort(people, new AgeComparator());
        System.out.println(people);
    }
}

class LexicographicComparator implements Comparator<Person> {
    @Override
    public int compare(Person a, Person b) {
        return a.name.compareToIgnoreCase(b.name);
    }
}

class AgeComparator implements Comparator<Person> {
    @Override
    public int compare(Person a, Person b) {
        return a.age < b.age ? -1 : a.age == b.age ? 0 : 1;
    }
}

class Person {

    String name;
    int age;

    Person(String n, int a) {
        name = n;
        age = a;
    }

    @Override
    public String toString() {
        return String.format("{name=%s, age=%d}", name, age);
    }
}

EDIT

And an equivalent Java 8 demo would look like this:

public class ComparatorDemo {

    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
                new Person("Joe", 24),
                new Person("Pete", 18),
                new Person("Chris", 21)
        );
        Collections.sort(people, (a, b) -> a.name.compareToIgnoreCase(b.name));
        System.out.println(people);
        Collections.sort(people, (a, b) -> a.age < b.age ? -1 : a.age == b.age ? 0 : 1);
        System.out.println(people);
    }
}

Solution 2 - Java

Here's a super short template to do the sorting right away :

Collections.sort(people,new Comparator<Person>(){
   @Override
   public int compare(final Person lhs,Person rhs) {
     //TODO return 1 if rhs should be before lhs 
     //     return -1 if lhs should be before rhs
     //     return 0 otherwise (meaning the order stays the same)
     }
 });

if it's hard to remember, try to just remember that it's similar (in terms of the sign of the number) to:

 lhs-rhs

That's in case you want to sort in ascending order : from smallest number to largest number.

Solution 3 - Java

Use People implements Comparable<People> instead; this defines the natural ordering for People.

A Comparator<People> can also be defined in addition, but People implements Comparator<People> is not the right way of doing things.

The two overloads for Collections.sort are different:

  • <T extends Comparable<? super T>> void sort(List<T> list)
    • Sorts Comparable objects using their natural ordering
  • <T> void sort(List<T> list, Comparator<? super T> c)
    • Sorts whatever using a compatible Comparator

You're confusing the two by trying to sort a Comparator (which is again why it doesn't make sense that Person implements Comparator<Person>). Again, to use Collections.sort, you need one of these to be true:

  • The type must be Comparable (use the 1-arg sort)
  • A Comparator for the type must be provided (use the 2-args sort)

Also, do not use raw types in new code. Raw types are unsafe, and it's provided only for compatibility.

That is, instead of this:

ArrayList peps = new ArrayList(); // BAD!!! No generic safety!

you should've used the typesafe generic declaration like this:

List<People> peps = new ArrayList<People>(); // GOOD!!!

You will then find that your code doesn't even compile!! That would be a good thing, because there IS something wrong with the code (Person does not implements Comparable<Person>), but because you used raw type, the compiler didn't check for this, and instead you get a ClassCastException at run-time!!!

This should convince you to always use typesafe generic types in new code. Always.

See also

Solution 4 - Java

For the sake of completeness, here's a simple one-liner compare method:

Collections.sort(people, new Comparator<Person>() {
    @Override
    public int compare(Person lhs, Person rhs) {  
        return Integer.signum(lhs.getId() - rhs.getId());  
    }
});

Solution 5 - Java

Java 8 added a new way of making Comparators that reduces the amount of code you have to write, Comparator.comparing. Also check out Comparator.reversed

Here's a sample

import org.junit.Test;

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

import static org.junit.Assert.assertTrue;

public class ComparatorTest {

    @Test
    public void test() {
        List<Person> peopleList = new ArrayList<>();
        peopleList.add(new Person("A", 1000));
        peopleList.add(new Person("B", 1));
        peopleList.add(new Person("C", 50));
        peopleList.add(new Person("Z", 500));
        //sort by name, ascending
        peopleList.sort(Comparator.comparing(Person::getName));
        assertTrue(peopleList.get(0).getName().equals("A"));
        assertTrue(peopleList.get(peopleList.size() - 1).getName().equals("Z"));
        //sort by name, descending
        peopleList.sort(Comparator.comparing(Person::getName).reversed());
        assertTrue(peopleList.get(0).getName().equals("Z"));
        assertTrue(peopleList.get(peopleList.size() - 1).getName().equals("A"));
        //sort by age, ascending
        peopleList.sort(Comparator.comparing(Person::getAge));
        assertTrue(peopleList.get(0).getAge() == 1);
        assertTrue(peopleList.get(peopleList.size() - 1).getAge() == 1000);
        //sort by age, descending
        peopleList.sort(Comparator.comparing(Person::getAge).reversed());
        assertTrue(peopleList.get(0).getAge() == 1000);
        assertTrue(peopleList.get(peopleList.size() - 1).getAge() == 1);
    }

    class Person {

        String name;
        int age;

        Person(String n, int a) {
            name = n;
            age = a;
        }

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }

        public void setName(String name) {
            this.name = name;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }



}

Solution 6 - Java

For the sake of completeness.

Using Java8

people.sort(Comparator.comparingInt(People::getId));

if you want in descending order

people.sort(Comparator.comparingInt(People::getId).reversed());

Solution 7 - Java

You want to implement Comparable, not Comparator. You need to implement the compareTo method. You're close though. Comparator is a "3rd party" comparison routine. Comparable is that this object can be compared with another.

public int compareTo(Object obj1) {
  People that = (People)obj1;
  Integer p1 = this.getId();
  Integer p2 = that.getid();

  if (p1 > p2 ){
   return 1;
  }
  else if (p1 < p2){
   return -1;
  }
  else
   return 0;
 }

Note, you may want to check for nulls in here for getId..just in case.

Solution 8 - Java

Two corrections:

  1. You have to make an ArrayList of People objects:

     ArrayList<People> preps = new ArrayList<People>();

  2. After adding the objects to the preps, use:

     Collections.sort(preps, new CompareId());

Also, add a CompareId class as:

class CompareId implements Comparator {  
    public int compare(Object obj1, Object obj2) {  
        People t1 = (People)obj1;  
        People t2 = (People)obj2;  
  
        if (t1.marks > t2.marks)  
            return 1;   
        else  
            return -1;
    }  
}

Solution 9 - Java

Here's an example of a Comparator that will work for any zero arg method that returns a Comparable. Does something like this exist in a jdk or library?

import java.lang.reflect.Method;
import java.util.Comparator;

public class NamedMethodComparator implements Comparator<Object> {

	//
	// instance variables
	//

	private String methodName;

	private boolean isAsc;

	//
	// constructor
	//

	public NamedMethodComparator(String methodName, boolean isAsc) {
		this.methodName = methodName;
		this.isAsc = isAsc;
	}

	/**
	 * Method to compare two objects using the method named in the constructor.
	 */
	@Override
	public int compare(Object obj1, Object obj2) {
		Comparable comp1 = getValue(obj1, methodName);
		Comparable comp2 = getValue(obj2, methodName);
		if (isAsc) {
			return comp1.compareTo(comp2);
		} else {
			return comp2.compareTo(comp1);
		}
	}

	//
	// implementation
	//

	private Comparable getValue(Object obj, String methodName) {
		Method method = getMethod(obj, methodName);
		Comparable comp = getValue(obj, method);
		return comp;
	}

	private Method getMethod(Object obj, String methodName) {
		try {
			Class[] signature = {};
			Method method = obj.getClass().getMethod(methodName, signature);
			return method;
		} catch (Exception exp) {
			throw new RuntimeException(exp);
		}
	}

	private Comparable getValue(Object obj, Method method) {
		Object[] args = {};
		try {
			Object rtn = method.invoke(obj, args);
			Comparable comp = (Comparable) rtn;
			return comp;
		} catch (Exception exp) {
			throw new RuntimeException(exp);
		}
	}

}

Solution 10 - Java

public static Comparator<JobSet> JobEndTimeComparator = new Comparator<JobSet>() {
    		public int compare(JobSet j1, JobSet j2) {
    			int cost1 = j1.cost;
    			int cost2 = j2.cost;
    			return cost1-cost2;
    		}
    	};

Solution 11 - Java

The solution can be optimized in following way: Firstly, use a private inner class as the scope for the fields is to be the enclosing class TestPeople so as the implementation of class People won't get exposed to outer world. This can be understood in terms of creating an APIthat expects a sorted list of people Secondly, using the Lamba expression(java 8) which reduces the code, hence development effort

Hence code would be as below:

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class TestPeople {
	public static void main(String[] args) {
		ArrayList<People> peps = new ArrayList<>();// Be specific, to avoid
													// classCast Exception

		TestPeople test = new TestPeople();

		peps.add(test.new People(123, "M", 14.25));
		peps.add(test.new People(234, "M", 6.21));
		peps.add(test.new People(362, "F", 9.23));
		peps.add(test.new People(111, "M", 65.99));
		peps.add(test.new People(535, "F", 9.23));

		/*
		 * Collections.sort(peps);
		 * 
		 * for (int i = 0; i < peps.size(); i++){
		 * System.out.println(peps.get(i)); }
		 */

		// The above code can be replaced by followin:

		peps.sort((People p1, People p2) -> p1.getid() - p2.getid());

		peps.forEach((p) -> System.out.println(" " + p.toString()));

	}

	private class People {
		private int id;

		@Override
		public String toString() {
			return "People [id=" + id + ", info=" + info + ", price=" + price + "]";
		}

		private String info;
		private double price;

		public People(int newid, String newinfo, double newprice) {
			setid(newid);
			setinfo(newinfo);
			setprice(newprice);
		}

		public int getid() {
			return id;
		}

		public void setid(int id) {
			this.id = id;
		}

		public String getinfo() {
			return info;
		}

		public void setinfo(String info) {
			this.info = info;
		}

		public double getprice() {
			return price;
		}

		public void setprice(double price) {
			this.price = price;
		}
	}
}

Solution 12 - Java

Here is a lambda version of comparator. This will sort a string list according to length.

Collections.sort(str, (str1, str2) -> {
    if(str1.length() < str2.length())
        return 1;
    else if(str2.length() < str1.length())
        return -1;
    else
        return 0;
});

Solution 13 - Java

You should use the overloaded sort(peps, new People()) method

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Test 
{
    public static void main(String[] args) 
    {
        List<People> peps = new ArrayList<>();

        peps.add(new People(123, "M", 14.25));
        peps.add(new People(234, "M", 6.21));
        peps.add(new People(362, "F", 9.23));
        peps.add(new People(111, "M", 65.99));
        peps.add(new People(535, "F", 9.23));

        Collections.sort(peps, new People().new ComparatorId());

        for (int i = 0; i < peps.size(); i++)
        {
            System.out.println(peps.get(i));
        }
    }
}

class People
{
       private int id;
       private String info;
       private double price;

       public People()
       {

       }

       public People(int newid, String newinfo, double newprice) {
           setid(newid);
           setinfo(newinfo);
           setprice(newprice);
       }

       public int getid() {
           return id;
       }

       public void setid(int id) {
           this.id = id;
       }

       public String getinfo() {
           return info;
       }

       public void setinfo(String info) {
           this.info = info;
       }

       public double getprice() {
           return price;
       }

       public void setprice(double price) {
           this.price = price;
       }

       class ComparatorId implements Comparator<People>
       {

		@Override
		public int compare(People obj1, People obj2) {
	           Integer p1 = obj1.getid();
	           Integer p2 = obj2.getid();

	           if (p1 > p2) {
	               return 1;
	           } else if (p1 < p2){
	               return -1;
	           } else {
	               return 0;
	           }
	        }
       }
    }

Solution 14 - Java

Here is my answer for a simple comparator tool

public class Comparator {
public boolean isComparatorRunning  = false;
public void compareTableColumns(List<String> tableNames) {
	if(!isComparatorRunning) {
		isComparatorRunning = true;
		try {
			for (String schTableName : tableNames) {
				Map<String, String> schemaTableMap = ComparatorUtil.getSchemaTableMap(schTableName); 
				Map<String, ColumnInfo> primaryColMap = ComparatorUtil.getColumnMetadataMap(DbConnectionRepository.getConnectionOne(), schemaTableMap);
				Map<String, ColumnInfo> secondaryColMap = ComparatorUtil.getColumnMetadataMap(DbConnectionRepository.getConnectionTwo(), schemaTableMap);
				ComparatorUtil.publishColumnInfoOutput("Comparing table : "+ schemaTableMap.get(CompConstants.TABLE_NAME));
				compareColumns(primaryColMap, secondaryColMap);
			}
		} catch (Exception e) {
			ComparatorUtil.publishColumnInfoOutput("ERROR"+e.getMessage());
		}
		isComparatorRunning = false;
	}
}

public void compareColumns(Map<String, ColumnInfo> primaryColMap, Map<String, ColumnInfo> secondaryColMap) {
	try {
		boolean isEqual = true;
		for(Map.Entry<String, ColumnInfo> entry : primaryColMap.entrySet()) {
			String columnName = entry.getKey();
			ColumnInfo primaryColInfo = entry.getValue();
			ColumnInfo secondaryColInfo = secondaryColMap.remove(columnName);
			if(secondaryColInfo == null) {
				// column is not present in Secondary Environment
				ComparatorUtil.publishColumnInfoOutput("ALTER", primaryColInfo);
				isEqual = false;
				continue;
			}
			if(!primaryColInfo.equals(secondaryColInfo)) {
				isEqual = false;
				// Column not equal in secondary env
				ComparatorUtil.publishColumnInfoOutput("MODIFY", primaryColInfo);
			}
		}
		if(!secondaryColMap.isEmpty()) {
			isEqual = false;
			for(Map.Entry<String, ColumnInfo> entry : secondaryColMap.entrySet()) {
				// column is not present in Primary Environment
				ComparatorUtil.publishColumnInfoOutput("DROP", entry.getValue());
			}
		}
		
		if(isEqual) {
			ComparatorUtil.publishColumnInfoOutput("--Exact Match");
		}
	} catch (Exception e) {
		ComparatorUtil.publishColumnInfoOutput("ERROR"+e.getMessage());
	}
}

public void compareTableColumnsValues(String primaryTableName, String primaryColumnNames, String primaryCondition, String primaryKeyColumn, 
		String secTableName, String secColumnNames, String secCondition, String secKeyColumn) {
	if(!isComparatorRunning) {
		isComparatorRunning = true;
		Connection conn1 = DbConnectionRepository.getConnectionOne();
		Connection conn2 = DbConnectionRepository.getConnectionTwo();
		
		String query1 = buildQuery(primaryTableName, primaryColumnNames, primaryCondition, primaryKeyColumn);
		String query2 = buildQuery(secTableName, secColumnNames, secCondition, secKeyColumn);
		try {
			Map<String,Map<String, Object>> query1Data = executeAndRefactorData(conn1, query1, primaryKeyColumn);
			Map<String,Map<String, Object>> query2Data = executeAndRefactorData(conn2, query2, secKeyColumn);
			
			for(Map.Entry<String,Map<String, Object>> entry : query1Data.entrySet()) {
				String key = entry.getKey();
				Map<String, Object> value = entry.getValue();
				Map<String, Object> secondaryValue = query2Data.remove(key);
				if(secondaryValue == null) {
					ComparatorUtil.publishColumnValuesInfoOutput("NO SUCH VALUE AVAILABLE IN SECONDARY DB "+ value.toString());
					continue;
				}
				compareMap(value, secondaryValue, key);
			}
			
			if(!query2Data.isEmpty()) {
				ComparatorUtil.publishColumnValuesInfoOutput("Extra Values in Secondary table "+ ((Map)query2Data.values()).values().toString());
			}
		} catch (Exception e) {
			ComparatorUtil.publishColumnValuesInfoOutput("ERROR"+e.getMessage());
		}
		isComparatorRunning = false;
	}
}

private void compareMap(Map<String, Object> primaryValues, Map<String, Object> secondaryValues, String columnIdentification) {
	for(Map.Entry<String, Object> entry : primaryValues.entrySet()) {
		String key = entry.getKey();
		Object value = entry.getValue();
		Object secValue = secondaryValues.get(key);
		if(value!=null && secValue!=null && !String.valueOf(value).equalsIgnoreCase(String.valueOf(secValue))) {
			ComparatorUtil.publishColumnValuesInfoOutput(columnIdentification+" : Secondary Table does not match value ("+ value +") for column ("+ key+")");
		}
		if(value==null && secValue!=null) {
			ComparatorUtil.publishColumnValuesInfoOutput(columnIdentification+" : Values not available in primary table for column "+ key);
		}
		if(value!=null && secValue==null) {
			ComparatorUtil.publishColumnValuesInfoOutput(columnIdentification+" : Values not available in Secondary table for column "+ key);
		}
	}
}

private String buildQuery(String tableName, String column, String condition, String keyCol) {
	if(!"*".equalsIgnoreCase(column)) {
		String[] keyColArr = keyCol.split(",");
		for(String key: keyColArr) {
			if(!column.contains(key.trim())) {
				column+=","+key.trim();
			}
		}
	}
	StringBuilder queryBuilder = new StringBuilder();
	queryBuilder.append("select "+column+" from "+ tableName);
	if(!ComparatorUtil.isNullorEmpty(condition)) {
		queryBuilder.append(" where 1=1 and "+condition);
	}
	return queryBuilder.toString();
}

private Map<String,Map<String, Object>> executeAndRefactorData(Connection connection, String query, String keyColumn) {
	Map<String,Map<String, Object>> result = new HashMap<String, Map<String,Object>>();
	try {
		PreparedStatement preparedStatement = connection.prepareStatement(query);
		ResultSet resultSet = preparedStatement.executeQuery();
        resultSet.setFetchSize(1000);
        if (resultSet != null && !resultSet.isClosed()) {
        	while (resultSet.next()) {
				Map<String, Object> columnValueDetails = new HashMap<String, Object>();
				int columnCount = resultSet.getMetaData().getColumnCount();
				for (int i=1; i<=columnCount; i++) {
					String columnName = String.valueOf(resultSet.getMetaData().getColumnName(i));
					Object columnValue = resultSet.getObject(columnName);
					columnValueDetails.put(columnName, columnValue);
				}
				String[] keys = keyColumn.split(",");
				String newKey = "";
				for(int j=0; j<keys.length; j++) {
					newKey += String.valueOf(columnValueDetails.get(keys[j]));
				}
				result.put(newKey , columnValueDetails);
			}
		}
		
	} catch (SQLException e) {
		ComparatorUtil.publishColumnValuesInfoOutput("ERROR"+e.getMessage());
	}
	return result;
}

}

Utility Tool for the same

public class ComparatorUtil {

public static Map<String, String> getSchemaTableMap(String tableNameWithSchema) {
	if(isNullorEmpty(tableNameWithSchema)) {
		return null;
	}
	Map<String, String> result = new LinkedHashMap<>();
	int index = tableNameWithSchema.indexOf(".");
	String schemaName = tableNameWithSchema.substring(0, index);
	String tableName = tableNameWithSchema.substring(index+1);
	result.put(CompConstants.SCHEMA_NAME, schemaName);
	result.put(CompConstants.TABLE_NAME, tableName);
	return result;
}

public static Map<String, ColumnInfo> getColumnMetadataMap(Connection conn, Map<String, String> schemaTableMap) {
	try {
		String schemaName = schemaTableMap.get(CompConstants.SCHEMA_NAME);
		String tableName = schemaTableMap.get(CompConstants.TABLE_NAME);
		ResultSet resultSetConnOne = conn.getMetaData().getColumns(null, schemaName, tableName, null);
		Map<String, ColumnInfo> resultSetTwoColInfo = getColumnInfo(schemaName, tableName, resultSetConnOne);
		return resultSetTwoColInfo;
	} catch (SQLException e) {
		e.printStackTrace();
	}
	return null;
}

/* Number Type mapping
 * 12-----VARCHAR
 * 3-----DECIMAL
 * 93-----TIMESTAMP
 * 1111-----OTHER
*/
public static Map<String, ColumnInfo> getColumnInfo(String schemaName, String tableName, ResultSet columns) {
	try {
		Map<String, ColumnInfo> tableColumnInfo = new LinkedHashMap<String, ColumnInfo>();
		while (columns.next()) {
			ColumnInfo columnInfo = new ColumnInfo();
			columnInfo.setSchemaName(schemaName);
			columnInfo.setTableName(tableName);
			columnInfo.setColumnName(columns.getString("COLUMN_NAME"));
			columnInfo.setDatatype(columns.getString("DATA_TYPE"));
			columnInfo.setColumnsize(columns.getString("COLUMN_SIZE"));
			columnInfo.setDecimaldigits(columns.getString("DECIMAL_DIGITS"));
			columnInfo.setIsNullable(columns.getString("IS_NULLABLE"));
			tableColumnInfo.put(columnInfo.getColumnName(), columnInfo);
		}
		return tableColumnInfo;
	} catch (Exception e) {
		e.printStackTrace();
	}
	return null;
}

public static boolean isNullOrEmpty(Object obj) {
    if (obj == null)
        return true;
    if (String.valueOf(obj).equalsIgnoreCase("NULL")) 
    	return true;
    if (obj.toString().trim().length() == 0)
        return true;
    return false;
}



public static boolean isNullorEmpty(String str) {
	if(str == null)
		return true;
	if(str.trim().length() == 0) 
		return true;
	return false;
}

public static void publishColumnInfoOutput(String type, ColumnInfo columnInfo) {
	String str = "ALTER TABLE "+columnInfo.getSchemaName()+"."+columnInfo.getTableName();
	switch(type.toUpperCase()) {
		case "ALTER":
			if("NUMBER".equalsIgnoreCase(columnInfo.getDatatype()) || "DATE".equalsIgnoreCase(columnInfo.getDatatype())) {
				str += " ADD ("+columnInfo.getColumnName()+" "+ columnInfo.getDatatype()+");";
			} else {
				str += " ADD ("+columnInfo.getColumnName()+" "+ columnInfo.getDatatype() +"("+columnInfo.getColumnsize()+"));";
			}
			break;
		case "DROP":
			str += " DROP ("+columnInfo.getColumnName()+");";
			break;
		case "MODIFY":
			if("NUMBER".equalsIgnoreCase(columnInfo.getDatatype()) || "DATE".equalsIgnoreCase(columnInfo.getDatatype())) {
				str += " MODIFY ("+columnInfo.getColumnName()+" "+ columnInfo.getDatatype()+");";
			} else {
				str += " MODIFY ("+columnInfo.getColumnName()+" "+ columnInfo.getDatatype() +"("+columnInfo.getColumnsize()+"));";
			}
			break;
	}
	publishColumnInfoOutput(str);
}

public static Map<Integer, String> allJdbcTypeName = null;

public static Map<Integer, String> getAllJdbcTypeNames() {
	Map<Integer, String> result = new HashMap<Integer, String>();
	if(allJdbcTypeName != null)
		return allJdbcTypeName;
	try {
		for (Field field : java.sql.Types.class.getFields()) {
			result.put((Integer) field.get(null), field.getName());
		}
	} catch (Exception e) {
		e.printStackTrace();
	}
	return allJdbcTypeName=result;
}

public static String getStringPlaces(String[] attribs) {
	String params = "";
	for(int i=0; i<attribs.length; i++) { params += "?,"; }
	return params.substring(0, params.length()-1);
}

}

Column Info Class

public class ColumnInfo {
private String schemaName;
private String tableName;
private String columnName;
private String datatype;
private String columnsize;
private String decimaldigits;
private String isNullable;

Solution 15 - Java

If you are using Java 8 then it's better to use below code like this:

Comparator<People> comparator = Comparator.comparing(People::getName);

And then simply use:

Collections.sort(list, comparator);

If you are using Java 7 or below then you can use a comparator for customized sorting order by implementing compare method.

For example:

import java.util.Comparator;

public class PeopleNameComparator implements Comparator<People> {
    @Override
    public int compare(People people1, People people2) {
        return people1.getName().compareTo(people2.getName());
    }
}

And then simply use like this:

Collections.sort(list, new PeopleNameComparator);

Solution 16 - Java

Do not waste time implementing Sorting Algorithm by your own. Instead use Collections.sort() to sort data.

Categories
Recommended Java Solutions
Recommended Sorting Solutions
Recommended Comparator Solutions

Previous Solution:

Difference between HashSet and HashMap?

JavaCollectionsHashmapHashset

Next Solution:

git rebase, keeping track of 'local' and 'remote'

GitConflictRebase

Attributions

All content for this solution is sourced from the original question on Stackoverflow.

The content on this page is licensed under the Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) license.

Content TypeOriginal AuthorOriginal Content on Stackoverflow
QuestionDanView Question on Stackoverflow
Solution 1 - JavaBart KiersView Answer on Stackoverflow
Solution 2 - Javaandroid developerView Answer on Stackoverflow
Solution 3 - JavapolygenelubricantsView Answer on Stackoverflow
Solution 4 - JavaNumberFourView Answer on Stackoverflow
Solution 5 - JavarinceView Answer on Stackoverflow
Solution 6 - JavaAnkit SharmaView Answer on Stackoverflow
Solution 7 - JavaWill HartungView Answer on Stackoverflow
Solution 8 - JavaCoderSamView Answer on Stackoverflow
Solution 9 - JavaJohnView Answer on Stackoverflow
Solution 10 - JavaQuadBikerView Answer on Stackoverflow
Solution 11 - JavaAkhil GuptaView Answer on Stackoverflow
Solution 12 - JavayılmazView Answer on Stackoverflow
Solution 13 - JavamichalView Answer on Stackoverflow
Solution 14 - JavaVrajendra Singh MandloiView Answer on Stackoverflow
Solution 15 - JavaPramod BaggolliView Answer on Stackoverflow
Solution 16 - Javapooja jardoshView Answer on Stackoverflow