itech9

From http://stackoverflow.com/questions/1229780/question-about-lru-cache-implementation-in-java

import java.util.Map;
import java.util.LinkedHashMap;

public class t1 {

    final int MAX_ENTRIES = 2;

    Map cache = new LinkedHashMap(MAX_ENTRIES+1, .75F, true) {
        // This method is called just after a new entry has been added
        public boolean removeEldestEntry(Map.Entry eldest) {
            System.out.println("eldest: " + eldest.getKey() + "=" + eldest.getValue());
            return size() > MAX_ENTRIES;
        }
    };

    public void cacheAdd(String pkey, String pstr) {
        // Add to cache
        cache.put(pkey, pstr);
    }

    public static void main(String[] args) {
        t1 ot1 = new t1();
        ot1.cacheAdd("k1", "str1");
        ot1.cacheAdd("k2", "str2");
        ot1.cacheAdd("k3", "str3");
        ot1.cacheAdd("k4", "str4");
    }

    /* --
// Get object
Object o = cache.get(key);
if (o == null && !cache.containsKey(key)) {
    // Object not in cache. If null is not a possible value in the cache,
    // the call to cache.contains(key) is not needed
}

// If the cache is to be used by multiple threads,
// the cache must be wrapped with code to synchronize the methods
cache = (Map)Collections.synchronizedMap(cache);
-- */

}

Also, see http://codeidol.com/java/javagenerics/Maps/Implementing-Map/
. . .

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class TestPattern {
    public static void main(String[] args) {
	String pin = "1234567";
	String pinPattern = "[0-9]+";
	String result = null;

	Pattern pattern = Pattern.compile(pinPattern);
	Matcher matcher = pattern.matcher(pin);

	result = "";
	while(matcher.find()) {
	    result += matcher.group();
	}
	if (result.equals(pin)) {
	    result = "PIN accepted";
	}
	else {
	    result = "PIN invalid";
	}
	System.out.println(result);
    }
}

SOAP – Simple Object Access Protocol
WSDL – Web Services Description Language
UDDI – Universal Discovery, Description and Integration

Major characteristics:
— XML-Based
— Loosely coupled – interfaces may change without loss of service.
— Coarse-grained – provide high-level business functions.
— Both synchronous and Asynchronous
— Supports RPC (Remote Procedure Calls)
— Supports document exchange

• — Inheritance from anything (including abstract)
  should be a function of the business model.
• — If a class does not _really_ inherit from
  an abstract, one should not use it.
• — Use interface to avoid the problem of multiple
  inheritance.
• — Use interface to improve modularity.. if one
  uses an abstract class and the class changes,
  it may break subclasses.
  (not method signatures but logic/code.. changing
  method signatures is a problem for both abstract
  and interface)
• — Use interfaces when some part of the design
  will change frequently.
• — Interface for plug-in architectures – like
  the strategy pattern.
• — Use abstract class to provide basic services
  for derived classes (event, message handling)
• — In favor of abstract class:
  • — interfaces may be more difficult to read in
    code logic.
  • — interfaces are somewhat slower due to
    indirections.