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.