Admin: 1 версия

2010-06-01T07:23:34Z

1 версия

в 18:01, 31 мая 2010

2010-05-31T18:01:48Z

Новая страница

== Bean Comparator ( Sorting based on Properties of class ) ==



<source lang="java">

package com.googelcode.jpractices.rumon;
import org.apache.rumons.lang.builder.ToStringBuilder;
/**
* Copyright 2009 @ jPractices v 1.0
* @SVN URL : http://jpractices.googlecode.ru
* @author Ganesh Gowtham
* @Homepage : http://ganesh.gowtham.googlepages.ru
*/
public class Person {
private String firstName;
private String lastName;
private int salary;
public Person(String firstName, String lastName, int salary) {
super();
this.firstName = firstName;
this.lastName = lastName;
this.salary = salary;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
@Override
public String toString() {
return ToStringBuilder.reflectionToString(this);
}
}
-------------
package com.googelcode.jpractices;
import java.util.ArrayList;
import java.util.Collections;
import java.util.ruparator;
import java.util.List;
import org.apache.rumons.beanutils.BeanComparator;
import com.googelcode.jpractices.rumon.Person;
/**
* Copyright 2009 @ jPractices v 1.0
* @SVN URL : http://jpractices.googlecode.ru
* @author Ganesh Gowtham
* @Homepage : http://ganesh.gowtham.googlepages.ru
*/
public class BeanComparatorExample {
List<Person> personList = new ArrayList<Person>();
/**
* Basic method which creates the list of person object"s
*
*/
void setUpData() {
personList.add(new Person("jennefer", "gowtham", 35000));
personList.add(new Person("britney", "spears", 45000));
personList.add(new Person("tom", "gowtham", 36000));
personList.add(new Person("joe", "dummy", 45000));
}
void sortPersons(String propertyName)
{
Comparator<Person> comp = new BeanComparator(propertyName);
Collections.sort(personList, comp);
for (Person person : personList) {
System.out.println(person);
}
}
public static void main(String[] args) {
BeanComparatorExample beanComparatorExample = new BeanComparatorExample();
beanComparatorExample.setUpData();
beanComparatorExample.sortPersons("firstName");
}
}

</source>



== Collection Bag ==



<source lang="java">
import org.apache.rumons.collections.Bag;
import org.apache.rumons.collections.bag.HashBag;
import org.apache.rumons.collections.bag.TreeBag;
import java.util.Arrays;
public class CookieBagV1 {
private Bag cookieBag;
private Bag sortedCookieBag;
public static void main(String args[]) {
CookieBagV1 app = new CookieBagV1();
app.prepareBags();
app.printBagContents();
app.addRandomCookies();
app.printBagContents();
}
private void printBagContents() {
System.err.println("Cookie Bag Contents: " + cookieBag);
System.err.println("Sorted Cookie Bag Contents: " + sortedCookieBag);
}
private void addRandomCookies() {
int count = (int)(Math.random() * 10);
int pick = (int)(Math.random() * 10);
pick = pick > 6 ? 6 : pick;
if (count > 5) cookieBag.add(cookieJar[pick], count);
else sortedCookieBag.add(cookieJar[pick], count);
}
private void prepareBags() {
prepareCookieBag();
prepareSortedCookieBag();
}
private void prepareCookieBag() {
cookieBag = new HashBag(Arrays.asList(cookieJar));
}
private void prepareSortedCookieBag() {
sortedCookieBag = new TreeBag(Arrays.asList(cookieJar));
}
private String[] cookieJar =
{"Bar", "Drop", "Brownies", "Cut Out", "Molded", "Sliced", "No Bake"};
}

</source>



== Collection BidiMap ==



<source lang="java">
import org.apache.rumons.collections.BidiMap;
import org.apache.rumons.collections.bidimap.DualHashBidiMap;
import org.apache.rumons.collections.bidimap.UnmodifiableBidiMap;
public class BidiMapExample {
public static void main(String args[]) {
BidiMap agentToCode = new DualHashBidiMap();
agentToCode.put("007", "Bond");
agentToCode.put("006", "Joe");
agentToCode = UnmodifiableBidiMap.decorate(agentToCode);
agentToCode.put("002", "Fairbanks"); // throws Exception
agentToCode.remove("007"); // throws Exception
agentToCode.removeValue("Bond"); // throws Exception
}
}

</source>



== Collection Buffer ==



<source lang="java">
import org.apache.rumons.collections.Buffer;
import org.apache.rumons.collections.buffer.BlockingBuffer;
import org.apache.rumons.collections.buffer.PriorityBuffer;
public class BufferExample {
public static void main(String args[]) {
Buffer buffer = new PriorityBuffer();
buffer.add("2");
buffer.add("1");
buffer = BlockingBuffer.decorate(buffer);
buffer.remove();
System.err.println(buffer);
buffer.clear();
AddElementThread runner = new AddElementThread(buffer);
runner.start();
buffer.remove();
System.err.println(buffer);
}
}
class AddElementThread extends Thread {
private Buffer buffer;
public AddElementThread(Buffer buffer) {
this.buffer = buffer;
}
public void run() {
try {
sleep(2000);
} catch (InterruptedException ie) {}
buffer.add("3");
}
}

</source>



== Collection Closure ==



<source lang="java">
import org.apache.rumons.collections.Closure;
import org.apache.rumons.collections.ClosureUtils;
import org.apache.rumons.collections.PredicateUtils;
public class ClosureExample {
public static void main(String args[]) {
Closure ifClosure = ClosureUtils.ifClosure(
PredicateUtils.equalPredicate(new Integer(20)),
ClosureUtils.nopClosure(),
ClosureUtils.exceptionClosure());
ifClosure.execute(new Integer(20));
// ifClosure.execute(new Integer(30));
}
}

</source>



== Comparator Example For BuildIn Data Type ==



<source lang="java">
import org.apache.rumons.collections.ruparatorUtils;
import org.apache.rumons.collections.ruparators.BooleanComparator;
import org.apache.rumons.collections.ruparators.FixedOrderComparator;
import java.util.Arrays;
import java.util.ruparator;
public class ComparatorExampleForBuildInDataType {
private static Comparator boolComp;
private static Comparator fixedComp;
private static Boolean boolParams[] = {new Boolean(true), new Boolean(true),
new Boolean(false), new Boolean(false)};
private static String stringParams[] = {"Russia", "Canada", "USA", "Australia", "India"};

public static void main(String args[]) {
ComparatorExampleForBuildInDataType example = new ComparatorExampleForBuildInDataType();
example.createComparators();
Arrays.sort(boolParams, boolComp);
example.printArray(boolParams);
Arrays.sort(stringParams);
example.printArray(stringParams);
Arrays.sort(stringParams, fixedComp);
example.printArray(stringParams);
}
private void createComparators() {
boolComp = ComparatorUtils.booleanComparator(true);
fixedComp = new FixedOrderComparator(stringParams);
}
private void printArray(Object[] array) {
for(int i = 0; i < array.length; i++)
System.err.println(array[i]);
}
}

</source>



== Comparator Example For User Defined Class ==



<source lang="java">
import org.apache.rumons.collections.ruparators.ruparatorChain;
import java.util.Arrays;
import java.util.ruparator;
public class ComparatorExampleForUserDefinedClass {
public static void main(String args[]) {
prepareData();
ComparatorChain chain = new ComparatorChain();
chain.addComparator(new NameComparator());
chain.addComparator(new NumberComparator());
printArray(dataArray);
Arrays.sort(dataArray, chain);
printArray(dataArray);
}
private static void prepareData() {
dataArray[0] = "S4";
dataArray[1] = "Sa";
dataArray[2] = "K";
dataArray[3] = "K4";
dataArray[4] = "W";
dataArray[5] = "Sha";
dataArray[6] = "War";
}
private static void printArray(String[] array) {
System.err.println("---- Elements in Array ---- ");
for(int i = 0; i < array.length; i++) {
System.err.print(array[i] + ", ");
}
System.err.println("");
}
private static String[] dataArray = new String[7];
}

class NameComparator implements Comparator {
public int compare(Object o1, Object o2) {
if(o1 instanceof String && o2 instanceof String) {
String s1 = (String)o1;
String s2 = (String)o2;
s1 = s1.substring(0, s1.indexOf("-"));
s2 = s2.substring(0, s2.indexOf("-"));
return s1.rupareTo(s2);
}
return 0;
}
}
class NumberComparator implements Comparator {
public int compare(Object o1, Object o2) {
if(o1 instanceof String && o2 instanceof String) {
String s1 = (String)o1;
String s2 = (String)o2;
Integer i1 = new Integer(s1.substring(s1.indexOf("-"), s1.length()));
Integer i2 = new Integer(s2.substring(s2.indexOf("-"), s2.length()));
return i1.rupareTo(i2);
}
return 0;
}
}

</source>



== Cookie Bag 2 ==



<source lang="java">
import org.apache.rumons.collections.Bag;
import org.apache.rumons.collections.bag.HashBag;
import org.apache.rumons.collections.bag.TreeBag;
import org.apache.rumons.collections.TransformerUtils;
import org.apache.rumons.collections.bag.TransformedBag;
import java.util.Arrays;
public class CookieBagV2 {
private Bag cookieBag;
private Bag sortedCookieBag;
public static void main(String args[]) {
CookieBagV2 app = new CookieBagV2();
app.prepareBags();
app.printBagContents();
app.addRandomCookies();
app.printBagContents();
}
private void printBagContents() {
System.err.println("Cookie Bag Contents: " + cookieBag);
System.err.println("Sorted Cookie Bag Contents: " + sortedCookieBag);
}
private void addRandomCookies() {
int count = (int)(Math.random() * 10);
int pick = (int)(Math.random() * 10);
pick = pick > 6 ? 6 : pick;
if (count > 5) cookieBag.add(cookieJar[pick], count);
else sortedCookieBag.add(cookieJar[pick], count);
}
private void prepareBags() {
prepareCookieBag();
prepareSortedCookieBag();
}
private void prepareCookieBag() {
cookieBag =
TransformedBag.decorate(
new HashBag(Arrays.asList(cookieJar)),
TransformerUtils.constantTransformer(cookieJar[2]));
// cookieBag.addAll(Arrays.asList(cookieJar));
}
private void prepareSortedCookieBag() {
sortedCookieBag = new TreeBag(Arrays.asList(cookieJar));
}
private String[] cookieJar =
{"Bar", "Drop", "Brownies", "Cut Out", "Molded", "Sliced", "No Bake"};
}

</source>



== Factory Example 1 ==



<source lang="java">
import org.apache.rumons.collections.Factory;
import org.apache.rumons.collections.FactoryUtils;
public class FactoryExampleV1 {
public static void main(String args[]) {
Factory bufferFactory = FactoryUtils.instantiateFactory(StringBuffer.class,
new Class[] {String.class},
new Object[] {"a string"});
System.err.println(bufferFactory.create());
}
}

</source>



== HashMap Example 1 ==



<source lang="java">
import org.apache.rumons.collections.BidiMap;
import org.apache.rumons.collections.bidimap.DualHashBidiMap;
public class HashMapExampleV1 {
public static void main(String args[]) {
BidiMap agentToCode = new DualHashBidiMap();
agentToCode.put("007", "Bond");
agentToCode.put("006", "Trevelyan");
agentToCode.put("002", "Fairbanks");
System.err.println("Agent name from code: " + agentToCode.get("007"));
System.err.println("Code from Agent name: " + agentToCode.getKey("Bond"));
}
}

</source>



== List Example 1 ==



<source lang="java">
import org.apache.rumons.collections.list.TreeList;
import org.apache.rumons.collections.list.SetUniqueList;
import org.apache.rumons.collections.list.CursorableLinkedList;
import java.util.List;
import java.util.ListIterator;
public class ListExampleV1 {
public static void main(String args[]) {
ListExampleV1 listExample = new ListExampleV1();
listExample.createLists();
uniqueList.add("Value1");
uniqueList.add("Value1");
System.err.println(uniqueList); // should contain only one element
cursorList.add("Element1");
cursorList.add("Element2");
cursorList.add("Element3");
ListIterator iterator = cursorList.listIterator();
iterator.next(); // cursor now between 0th and 1st element
iterator.add("Element2.5"); // adds this between 0th and 1st element
System.err.println(cursorList); // modification done to the iterator are visible in the list
}
private void createLists() {
uniqueList = SetUniqueList.decorate(new TreeList());
cursorList = new CursorableLinkedList();
}
private static List uniqueList;
private static List cursorList;
}

</source>



== MapHeaven 1 ==



<source lang="java">
import java.util.Map;
import java.util.Date;
import java.util.HashMap;
import org.apache.rumons.collections.map.LazyMap;
import org.apache.rumons.collections.FactoryUtils;
import org.apache.rumons.collections.map.IdentityMap;
import org.apache.rumons.collections.map.CaseInsensitiveMap;
public class MapHeavenV1 {
public static void main(String args[]) {
MapHeavenV1 instance = new MapHeavenV1();
instance.createMaps();
instance.testMaps();
}
private void testMaps() {
cIMap.put("key1", "value1");
cIMap.put("key2", "value2");
cIMap.put("KeY1", "value3");
System.err.println("Value of key1: " + cIMap.get("key1")); // value3 because it is case insensitive
Integer identRef = new Integer(1);
Integer identRef2 = new Integer(1);
identMap.put(identRef, "value1");
identMap.put(identRef2, "value3");
System.err.println("Value of identRef2: " + identMap.get(identRef2)); // value 3 even though both identRef and identRef2 are equal
System.err.println(lazyMap); // only creates elements when they are accessed
lazyMap.get("EmptyBuffer");
System.err.println(lazyMap);
}
private void createMaps() {
cIMap = new CaseInsensitiveMap();
identMap = new IdentityMap();
lazyMap = LazyMap.decorate(
new HashMap(),
FactoryUtils.instantiateFactory(StringBuffer.class));
}
private CaseInsensitiveMap cIMap;
private IdentityMap identMap;
private Map lazyMap;
}

</source>



== Multi Key Example 1 ==



<source lang="java">
import java.util.HashMap;
public class MultiKeyExampleV1 {
public static void main(String args[]) {
HashMap codeToText_en = new HashMap();
codeToText_en.put("GM", "Good Morning");
codeToText_en.put("GN", "Good Night");
codeToText_en.put("GE", "Good Evening");
HashMap codeToText_de = new HashMap();
codeToText_de.put("GM", "Guten Morgen");
codeToText_de.put("GE", "Guten Abend");
codeToText_de.put("GN", "Guten Nacht");
HashMap langToMap = new HashMap();
langToMap.put("en", codeToText_en);
langToMap.put("de", codeToText_de);
System.err.println("Good Evening in English: " +
((HashMap)langToMap.get("en")).get("GE"));
System.err.println("Good Night in German: " +
((HashMap)langToMap.get("de")).get("GN"));
}
}

</source>



== MultiKey Example 2 ==



<source lang="java">
import java.util.HashMap;
import org.apache.rumons.collections.keyvalue.MultiKey;
public class MultiKeyExampleV2 {
private static HashMap codeAndLangToText;
public static void main(String args[]) {
codeAndLangToText = new HashMap();
addMultiKeyAndValue("en", "GM", "Good Morning");
addMultiKeyAndValue("en", "GE", "Good Evening");
addMultiKeyAndValue("en", "GN", "Good Night");
addMultiKeyAndValue("de", "GM", "Guten Morgen");
addMultiKeyAndValue("de", "GE", "Guten Abend");
addMultiKeyAndValue("de", "GN", "Guten Nacht");
System.err.println("Good Evening in English: " +
codeAndLangToText.get(new MultiKey("en", "GE")));
System.err.println("Good Night in German: " +
codeAndLangToText.get(new MultiKey("de", "GN")));
}
private static void addMultiKeyAndValue(
Object key1, Object key2, Object value) {
MultiKey key = new MultiKey(key1, key2);
codeAndLangToText.put(key, value);
}
}

</source>



== Set Example 1 ==



<source lang="java">
import org.apache.rumons.collections.set.MapBackedSet;
import java.util.Map;
import java.util.Set;
import java.util.HashMap;
import java.util.Iterator;
public class SetExampleV1 {
public static void main(String args[]) {
// create a Map
Map map = new HashMap();
map.put("Key1", "Value1");
// create the decoration
Set set = MapBackedSet.decorate(map);
map.put("Key2", "Any dummy value");
set.add("Key3");
Iterator itr = set.iterator();
while(itr.hasNext()) {
System.err.println(itr.next());
}
}
}

</source>



== Set Example 2 ==



<source lang="java">
import org.apache.rumons.collections.collection.*;
import org.apache.rumons.collections.set.*;
import java.util.Set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Collection;
public class SetExampleV2 {
public static void main(String args[]) {
// create two sets
Set set1 = new HashSet();
set1.add("Red");
set1.add("Green");
Set set2 = new HashSet();
set2.add("Yellow");
set2.add("Red");
// create a composite set out of these two
CompositeSet composite = new CompositeSet();
// set the class that handles additions, conflicts etc
// composite.setMutator(new CompositeMutator());
// initialize the composite with the sets
// Cannot be used if set1 and set2 intersect is not null and
// a strategy to deal with it has not been set
composite.addComposited(new Set[] {set1, set2});
// do some addition/deletions
// composite.add("Pink");
// composite.remove("Green");
// whats left in the composite?
Iterator itr = composite.iterator();
while(itr.hasNext()) {
System.err.println(itr.next());
}
}
}
class CompositeMutator implements CompositeSet.SetMutator {
public void resolveCollision(
CompositeSet comp,
Set existing,
Set added,
Collection intersection) {
added.removeAll(intersection);
}
public boolean add(
CompositeCollection collection,
Collection[] collections,
Object obj) {
return collections[0].add(obj);
}
public boolean remove(
CompositeCollection collection,
Collection[] collections,
Object obj) {
return collections[0].remove(obj);
}
public boolean addAll(
CompositeCollection collection,
Collection[] collections,
Collection coll) {
return collections[0].addAll(coll);
}
}

</source>



== Transformer Example ==



<source lang="java">
import org.apache.rumons.collections.Transformer;
import org.apache.rumons.collections.TransformerUtils;
public class TransformerExampleV1 {
public static void main(String args[]) {
Transformer transformer = TransformerUtils.invokerTransformer(
"append",
new Class[] {String.class},
new Object[] {" a Transformer?"});
Object newObject = transformer.transform(new StringBuffer("Are you"));
System.err.println(newObject);
}
}

</source>

← Предыдущая	Версия 07:23, 1 июня 2010
(нет различий)

Java/Apache Common/Collection - История изменений

Admin: 1 версия

в 18:01, 31 мая 2010