These 100 plus programming languages run on Java Virtual machine (List)

You will probably be surprised to know that more than 100 different programming languages produce softwares that can run on Java Virtual Machines. Many pre-existing languages have also been adapted or re-designed to run on the Java Platform.

This list consists of these languages that are either interpreted by a Java Program, or complied into Java Bytecode or JIT compiled during execution time. The list is maintained in Alphabetic order. Anything in the bracket denotes the JVM version of the language which also means the langauge also exists to run on other platforms.

  1. Ada (JGNAT)
  2. Alef++
  3. Anvil
  4. Ateji PX
  5. AWK (Jawk)
  6. Basic (jScriptBasic)
  7. BBx (BBj)
  8. BeanShell
  9. BexScript
  10. Boo (Boojay)
  11. C#
  12. CAL
  13. Ceylon
  14. Closure
  15. COBOL (Elastic COBOL, Micro Focus Visual COBOL, Veryant isCobol)
  16. ColdFusion (Adobe ColdFusion, Railo, Open BlueDragon)
  17. Common Lisp (Armed Bear Common Lisp, CLforJava, Jatha Common Lisp Library)
  18. Correlate
  19. Dawn
  20. Drools
  21. E
  22. Eiffel
  23. Erlang (Erjang)
  24. Fantom
  25. Flow Java
  26. Forth (myForth)
  27. Fortress
  28. Frege
  29. Frink
  30. Fscript
  31. Funnel
  32. G
  33. Go (jGo)
  34. Golo
  35. Gosu
  36. Hecl
  37. Hojo
  38. Icon
  39. Ioke
  40. iScript
  41. Jabaco
  42. Jaskell
  43. JavaScript (Rhino, Nashhorn)
  44. Jelly
  45. Jess
  46. JHCR
  47. Jickle
  48. Join Java
  49. Joy
  50. JRuby
  51. JudoScript
  52. Jython
  53. KBML
  54. Libretto
  55. Lisp
  56. LLP
  57. Logo (jLogo, XLogo)
  58. Lua (Kahlua, Luaj, Jill)
  59. Luck
  60. Mini
  61. Mirah
  62. Modula-2
  63. N.A.M.E. Basic
  64. NetLogo
  65. Nice
  66. Noop
  67. Oberon-2 (Canterbury Oberon-2 for JVM, JOB)
  68. Object Pascal (Oxygene)
  69. ObjectScript
  70. OCank (OCaml-Java)
  71. Pascal (Canterbury Pascal for JVM, Free Pascal, MIDletPascal)
  72. Phobos
  73. PHP (IBM Websphere sMash PHP P8, Caucho Quercus)
  74. PHP.reboot
  75. Piccola
  76. Pizza
  77. Pnuts
  78. Processing
  79. Prolog (JIProlog, Jekejeke Prolog, JLog, TuProlog, JinniProlog)
  80. Python (Jython)
  81. R (Renjin)
  82. Redline SmallTalk
  83. Rexx (NetRexx)
  84. Ruby (JRuby)
  85. SALSA
  86. Scala
  87. Scheme (Bigloo, Kawa, SISC, JScheme)
  88. Simkin
  89. Sleep
  90. Stab
  91. Sther
  92. TCL (Jacl, JTcl)
  93. Tea
  94. TermWare
  95. Tiger
  96. v-language
  97. WebL
  98. X10
  99. Xtend
  100. Yassl
  101. Yeti ML (Yeti)
  102. Yoix
  103. Zigzag

Java Tool To Compare Two Lists and Spit Out The Differences – Working Example

As a heavy java programmer, most of the time I encounter a problem where I have two lists and need to find out the differences between these two. One of the ways I sometimes quickly find out the difference is:

  • To print out the list and then use microsoft excel to compare the two columns.
  • Upload the file to temporary database tables and the run SQL query to find out the difference

As I started encountering the list compare more often, I thought of writing a tool that takes two lists and then simply print out the differences. Thus I coded the following simple piece of java program to achieve this.

The following program:

  • Can take an input of two ArrayLists presumably containing Strings, numbers of mix of both
  • It then compares the two lists and then prints out all items from first list which are not in the second lists and also prints out the items in second lists which are not in the first list

I can now use this program as often as I want and solves the hassle of me having to upload the data to database for compare or even import to excel to do the same.

Most of the programs from my blog come from my real world working experience. They are simple programs but sometimes save your huge time. Feel free to copy and modify any of the programs for your own use. Everything is open sourced and free in my blog

package com.kushal.tools;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

/**
 * @author Kushal Paudyal Last Modified On 2011-09-16
 * 
 *         This simple utility compares two String or number lists or a list
 *         that contains either strings or number and then prints out a list of
 *         items that are in first list but not in the second list and also a
 *         list of items that are in second list but not in the first list.
 */
public class ListCompare {

	public static void main(String args[]) {
		List listA = new ArrayList();
		listA.add(1);
		listA.add(2);
		listA.add("Kushal");
		listA.add("Madan");
		listA.add("Pooja");
		listA.add("Kripa");

		List listB = new ArrayList();
		listB.add(2);
		listB.add(3);
		listB.add("Kushal");
		listB.add("Madan");
		listB.add("Jenny");
		listB.add("Betsy");

		ListCompare listComp = new ListCompare();
		listComp.compareLists(listA, listB);

	}

	public void compareLists(List firstList, List secondList) {
		Map mapForFirstList = new HashMap();
		Map mapForSecondList = new HashMap();
		Iterator firstListIterator = firstList.iterator();
		Iterator secondListIterator = secondList.iterator();
		while (firstListIterator.hasNext()) {
			String firstListKeyValue = firstListIterator.next().toString();
			/**
			 * Put the value from the list into the map, only if the same value
			 * already does not exists. That means if there are duplicates, we
			 * put only one instance into the hashmap.
			 */
			if (!mapForFirstList.containsKey(firstListKeyValue)) {
				mapForFirstList.put(firstListKeyValue, firstListKeyValue);
			}

		}

		while (secondListIterator.hasNext()) {
			String secondListKeyValue = secondListIterator.next().toString();
			/**
			 * Put the value from the list into the map, only if the same value
			 * already does not exists. That means if there are duplicates, we
			 * put only one instance into the hashmap.
			 */
			if (!mapForSecondList.containsKey(secondListKeyValue)) {
				mapForSecondList.put(secondListKeyValue, secondListKeyValue);
			}

		}
		compareAndPrintResults(mapForFirstList, mapForSecondList);

	}

	private void compareAndPrintResults(Map mapForFirstList,
			Map mapForSecondList) {
		/** Compare first map against the second one and print the difference **/
		printItemsFromFirstListThatAreNotOnSecondList(mapForFirstList,
				mapForSecondList);
		/** Compare second map against the first and print the difference */
		printItemsFromSecondListThatAreNotOnFirstList(mapForSecondList,
				mapForFirstList);

	}

	private void printItemsFromFirstListThatAreNotOnSecondList(Map mapA,
			Map mapB) {
		System.out
				.println("***Items from first list that are not in second list");
		doComparisionAndPrint(mapA, mapB);

	}

	private void printItemsFromSecondListThatAreNotOnFirstList(Map mapA,
			Map mapB) {
		System.out
				.println("***Items from second list that are not in firstList list");
		doComparisionAndPrint(mapA, mapB);

	}

	/**
	 * @param mapA
	 * @param mapB
	 * 
	 *            This method compares two hashmaps and prints out the values
	 *            from the first one that are not in the second one.
	 */
	private void doComparisionAndPrint(Map mapA, Map mapB) {
		// both maps should be non-empty for comparison.
		if (mapA != null && mapB != null) {
			Iterator mapAIterator = mapA.keySet().iterator();

			while (mapAIterator.hasNext()) {
				String key = mapAIterator.next().toString();
				if (!mapB.containsKey(key)) {
					System.out.println(key);
				}
			}
		}
	}
}

The following is the output of this program:

		***Items from first list that are not in second list
		1
		Kripa
		Pooja
		***Items from second list that are not in firstList list
		3
		Betsy
		Jenny