Generics的方法参数，Set 两集合进行并、交、差

一、利用Generic方法参数,对两个集合进行并，交，差，并-交

   1、union 并：1》在方法体增加一个集合，构造函数的初始化数据，用方法里传过来的集合。

                        2》再加一个集合addAll(b)。

  2、intersection 交：1>在方法体增加一个集合，构造函数的初始化数据，用方法里传过来的集合。

                                2>retainAll(b); 同时在俩集合的数。

 3、差（补）集：1>在方法体增加一个集合，构造函数的初始化数据，用方法里传过来的集合。

                         2>removeAll(b); 只在第一个集合的数

 4、总集合-交集

   下面例子：使用  Generics(通用)<T> Set<T> 方法参数表示法。

                   EnumSet.range(a,e)：返回set的一个集合，EnumSet是Set 的一个实现类。

package net.mindview.util;
import java.util.HashSet;
import java.util.Set;

public class Sets {
  //并
 
  public static <T> Set<T> union(Set<T> a, Set<T> b) {
    Set<T> result = new HashSet<T>(a);
    result.addAll(b);
    return result;
  }//交
  public static <T> Set<T> intersection(Set<T> a, Set<T> b) {
    Set<T> result = new HashSet<T>(a);
    result.retainAll(b);
    return result;
  }
  // 差
  public static <T> Set<T>
  difference(Set<T> superset, Set<T> subset) {
    Set<T> result = new HashSet<T>(superset);
    result.removeAll(subset);
    return result;
  }
  // 两个并集-两个交集
  public static <T> Set<T> complement(Set<T> a, Set<T> b) {
    return difference(union(a, b), intersection(a, b));
  }
} ///:~

//列举常量
package generics.watercolors;
public enum Alpha {a,b,c,d,e,f}

//使用上面方法的类
package generics;

import generics.watercolors.*;
import java.util.*;
import static net.mindview.util.Print.*;
import static net.mindview.util.Sets.*;
import static generics.watercolors.Alpha.*;

public class WatercolorSets {
public static void main(String[] args) {
Set<Alpha> set1 = EnumSet.range(a,e);
Set<Alpha> set2 = EnumSet.range(c,f);
print("set1: " + set1);
print("set2: " + set2);
print("并: " + union(set1, set2));
Set<Alpha> subset = intersection(set1, set2);
print("交: " + subset);
print("差1: " + difference(set1, subset));
print("差2: " + difference(set2, subset));
print("并-交: " + complement(set1, set2));
}
}

二、两个类（接口）的方法 的差集，好像项目中从没有用过。

       各种Conllection 和 Map 类（java.util.）,即集合类（袋子类）的方法差集

        Collection.class,所有的.class 表示调用这个类入内存，成为Class 的类对象，类的所有方法存在Method table中，这是装入内存的类，运行起来，必须用反射取出它的所有方法。

     Class<?>：？表示Class的所有类对象(.class)。

        

package net.mindview.util;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.TreeSet;
//求出集合类的所有方法存入TreeSet中
public class ContainerMethodDifferences {
  static Set<String> methodSet(Class<?> type) {
    Set<String> result = new TreeSet<String>();
    for(Method m : type.getMethods())
      result.add(m.getName());
    return result;
  }
//求出集合类的实现的所有接口，名字存入ArrayList中
  static void interfaces(Class<?> type) {
    System.out.print("Interfaces in " + type.getSimpleName() + ": ");
    List<String> result = new ArrayList<String>();
    for(Class<?> c : type.getInterfaces())
      result.add(c.getSimpleName());
    System.out.println(result);
  }

  //类的连接（实例）变量
  static Set<String> object = methodSet(Object.class);

  //类的静态块
  static { object.add("clone"); }

  //两个集合类的方法差集
  static void difference(Class<?> superset, Class<?> subset) {
 System.out.print(superset.getSimpleName() +" extends " + subset.getSimpleName() + ", adds: ");
    Set<String> comp = Sets.difference(methodSet(superset), methodSet(subset));
    comp.removeAll(object); // Don't show 'Object' methods
    System.out.println(comp);
    interfaces(superset);
  }
  public static void main(String[] args) {
    System.out.println("Collection: "+methodSet(Collection.class));
    interfaces(Collection.class);
    difference(Set.class, Collection.class);
    difference(HashSet.class, Set.class);
    difference(LinkedHashSet.class, HashSet.class);
    difference(TreeSet.class, Set.class);
    difference(List.class, Collection.class);
    difference(ArrayList.class, List.class);
    difference(LinkedList.class, List.class);
    difference(Queue.class, Collection.class);
    difference(PriorityQueue.class, Queue.class);
    System.out.println("Map: " + methodSet(Map.class));
    difference(HashMap.class, Map.class);
    difference(LinkedHashMap.class, HashMap.class);
    difference(SortedMap.class, Map.class);
    difference(TreeMap.class, Map.class);
  }
} ///:~