När man har en begränsad mängd med kodduplicering i Java kan det vara svårt att bli av med den, utan omständligt kodande som ger en totalt större kodmängd som slutresultat

Om man i stället programmerar med Scala så kan man skicka en funktion/metod som parameter till en metod och behöver därmed inte (vilket man behöver med Java) skapa ett interface med en enda metod som sedan måste instansieras och implementeras med en resulterande 'code smell' av redundant och omständlig kod.

Antag t.ex. att du har många Java-metoder som tar emot en Lista av en viss typ, och som skall returnerar en Lista av en annan (eller i bland samma) typ, och att det enda som skiljer är någon kodrad i mitten som tar elementet från input-listan och transformerar den till ett element som skall läggas in till resultat-listan.

		
	public List<Integer> getMappedList(final List<String> inputList) {
		final List<Integer> returnedList = new ArrayList<Integer>();
		for (String element : inputList) {
			 [ exempelvis:  Integer returnElement = getIntegerFromString(element); ]
			returnedList.add(returnElement);
		}
		return Collections.unmodifiableList(returnedList);
	}
		

Det som ovan är skrivet i fetstilt inom hakparenteser representerar alltså den typ av koden som varierar i olika metoder som ser ut enligt ovan, förutom att typerna även kan variera och vara annat än en String som ska mappas till Integer. Om du med Java vill försöka undvika dupliceringen i diverse metoder med ovanstående struktur, så kan man försöka använda GoF designmönstren Template Method eller Strategy, och om vi utgår från det sistnämnda, så skulle man kunna definiera ett Strategy-interface (med Java) på följande sätt:

interface ElementMappingStrategy {
    U getMappedValue(T value);
}

Sedan kan Java-interfacet ovan användas med en generell återanvändbar java-metod på följande sätt:

    private <T, U> List<U> getMappedList(
        final List<T> elementsToBeMapped,
        final ElementMappingStrategy<T, U> elementMappingStrategy
    ) {
        final List<U> returnedElements = new ArrayList<U>();
        for (T elementToBeMapped: elementsToBeMapped) {
            returnedElements.add(elementMappingStrategy.getMappedValue(elementToBeMapped));
        }
        return Collections.unmodifiableList(returnedElements);
    }

När man sedan skapar implementationerna och instansierar dem som parametrar till metoden ovan så blir dock den resulterande koden i princip lika omfattande som den initiala dupliceringen, och man har egentligen inte vunnit särskilt mycket.

Om man i stället skulle implementera en refaktorisering (som reducerar den ovan nämnda dupliceringen) med språket Scala (som är ett statiskt kompilerande språk som skapar JVM-class-filer som kan användas från Java) så behöver man inte skapa (och implementera!) ett interface som innehåller en enda metod utan kan i stället använda en funktion (metod) som parameter till en generell metod som anropar den funktionen för att hantera det som skiljer implementationerna.

En sådan generell metod som tar emot en funktion skulle kunna se ut enligt Scala-koden nedan:
(men observera dock att while-loopar egentligen inte uppmuntras i språket Scala, se t.ex. kapitel 7.2 i boken 'Programming in Scala') men det används i alla fall här, eftersom koden bör vara lätt att förstå för en java-utvecklare utan java-kunskaper)

  def getMappedList[T,U](
    elementsToBeMapped: java.util.List[T],
    elementMappingStrategy: (T => U)
  ): java.util.List[U] = {
    val returnedElements = new java.util.ArrayList[U]
    val iterator = elementsToBeMapped.iterator
    while(iterator.hasNext) {
      returnedElements.add(elementMappingStrategy(iterator.next))
    }
    return returnedElements
  }

Metoden ovan kan exempelvis anropas på något av följande sätt, och observera att all kod är statiskt typad dvs det handlar alltså om kompilerande kod, även om det kan se ut som att typerna saknas, t.ex. den andra metoden nedan mappar en String till Integer, men det fungerar statiskt typat utan att man behöver deklarera Integer som returtyp i den andra funktionen nedan, tack vare den s.k. typ inferensen.

  final def getLowerCasedStrings(stringsToBeReturnedLowerCased: java.util.List[String]): java.util.List[String] = {
    getMappedList(stringsToBeReturnedLowerCased, (s : String) => s.toLowerCase)
  }

  final def getLengthsOfStrings(stringsWithLengthsToBeReturned: java.util.List[java.lang.String]): java.util.List[Integer] = {
    getMappedList(stringsWithLengthsToBeReturned, (s : String) => s.length)
  }

På websidan som länkas nedan finns mer detaljerad källkod (och kommentarer på engelska) för ovanstående exempel, inklusive JUnit tester som exekverar två Java-implementationer och två Scala-implementationer av ett interface, vars initiala Java-implementation innehåller den typ av duplicering som har nämnts ovan.
Using Scala functions to reduce duplication, as alternative to Strategy and Template method design patterns