JAVA自学教程之集合框架工具类（一）



JAVA自学教程之集合框架工具类（一）。

一、Collections：集合框架的工具类

其中的方法都是静态的

排序方法演示

 

  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. import java.util.Comparator;
  4. import java.util.List;
  5. class ComparaByLeng implements Comparator<String>{
  6.     public int compare(String o1, String o2) {
  8.         int t = o1.length() - o2.length();
  9.         return t==0?o1.compareTo(o2):t;
  10.     }
  11. }
  12. public class Main
  13. {
  14.     public static void main(String[] args) {
  15.         Colletyions_Demo();
  16.     }
  17.     public static void Colletyions_Demo(){
  18.         List<String> li = new ArrayList<String>();
  19.         li.add(“asd”);    li.add(“d”);
  20.         li.add(“efasd”);  li.add(“efasd”);
  21.         li.add(“dsssfd”); li.add(“xxxxd”);
  22.         //System.out.println(list);
  23.         //Collections.sort(list);//排序
  24.         //System.out.println(list);
  25.         //sort :public static <T extends Comparable<? super T>> void sort(List<T> list)
  26.         //模拟sort
  27.         //Mysort(list);
  28.         //System.out.println(list);
  29.         Mysort(li,new ComparaByLeng());
  30.         System.out.println(li);
  31.         Collections.sort(li,new ComparaByLeng());
  32.         System.out.println(li);
  33.     }
  34.     /*public static <T extends Comparable<? super T>> void Mysort(List<T> list)
  35.     {
  36.         for (int i = 0; i < list.size()-1; i++) {
  37.             for (int j = i+1; j < list.size(); j++) {
  38.                 if(list.get(i).compareTo(list.get(j))>0){
  39.                     Collections.swap(list, i, j);//工具类  交换
  40.                 }
  41.             }
  42.         }
  43.     }   */
  44.     public static <T> void Mysort(List<T> li,Comparator<? super T> com) {
  45.         for (int i = 0; i < li.size()-1; i++) {
  46.             for (int j = i+1; j < li.size(); j++) {
  47.                 if(com.compare( li.get(i), li.get(j) ) > 0 ){
  48.                     Collections.swap(li, i, j);
  49.                 }
  50.             }
  51.         }
  52.     }
  53. }

 

 

二分查找、最值方法演示

 

  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. import java.util.Comparator;
  4. import java.util.List;
  5. public class Main
  6. {
  7.     public static void main(String[] args) {
  8.         Colletyions_Demo();
  9.     }
  10.     public static void Colletyions_Demo(){
  11.         List<String> li = new ArrayList<String>();
  12.         li.add(“asd”);    li.add(“d”);
  13.         li.add(“efasd”);  li.add(“efasd”);
  14.         li.add(“dsssfd”); li.add(“xxxxd”);
  16.         Collections.sort(li);
  17.         System.out.println(li);
  18.         int index = Collections.binarySearch(li, ”d”);
  19.         System.out.println(index);//负数代表没找到
  21.         //获取最大值
  22.         String maxstrString = Collections.max(li);
  23.         System.out.println(“max = ”+maxstrString);
  24.         //获取最小值
  25.         String minstrString = Collections.min(li);
  26.         System.out.println(“min = ”+minstrString);
  27.         //取最长
  28.         String maxlenString = Collections.max(li,new ComparaByLeng());
  29.         System.out.println(maxlenString);
  30.     }
  31. }


逆转、替换方法演示

 

 

  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. import java.util.List;
  4. import java.util.TreeSet;
  5. public class Main
  6. {
  7.     public static void main(String[] args) {
  8.         Colletyions_Demo();
  9.     }
  10.     public static void Colletyions_Demo(){
  11.         //原理
  12. //      TreeSet<String> ts = new TreeSet<String>(new Comparator<String>() {
  13. //          public int compare(String o1, String o2) {
  14. //
  15. //              return o2.compareTo(o1);
  16. //          }
  17. //      });
  18.         //封装后
  19.         TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());
  20.         ts.add(“ad”);ts.add(“xad”);
  21.         ts.add(“fdagrrgd”);ts.add(“a”);
  22.         ts.add(“gedsad”);
  23.         System.out.println(ts);
  24.         //如果有比较器，逆转
  25.         //长度逆转
  26.         TreeSet<String> td = new TreeSet<String>(Collections.reverseOrder(new ComparaByLeng()));
  27.         td.add(“ad”);td.add(“xad”);
  28.         td.add(“fdagrrgd”);td.add(“a”);
  29.         td.add(“gedsad”);
  30.         System.out.println(td);
  31.         //replaceAll / reverse方法
  32.         List<String> al = new ArrayList<String>();
  33.         al.add(“ads”);
  34.         al.add(“ds”);
  35.         al.add(“s”);
  36.         Collections.reverse(al);
  37.         System.out.println(al);
  38.         Collections.replaceAll(al, ”s”, ”y”);//实际上 -> set(indexOf(“s”),”y”)
  39.         System.out.println(al);
  40.     }
  41. }

 

 


其他方法
1、fill(List<? super T> list, T obj)
使用指定元素替换指定列表中的所有元素。

Collections.fill(list,”asd”);

 

2、shuffle(List<?> list)
使用默认随机源对指定列表进行置换

Collections.shuffle(list);随机

更多方法看API文档。。。

 

将非同步集合转成同步集合的方法

 

static

<T> Collection<T>
synchronizedCollection(Collection<T> c)
返回指定 collection 支持的同步（线程安全的）collection。
static

<T> List<T>
synchronizedList(List<T> list)
返回指定列表支持的同步（线程安全的）列表。
static

<K,V> Map<K,V>
synchronizedMap(Map<K,V> m)
返回由指定映射支持的同步（线程安全的）映射。
static

<T> Set<T>
synchronizedSet(Set<T> s)
返回指定 set 支持的同步（线程安全的）set。
static

<K,V> SortedMap<K,V>
synchronizedSortedMap(SortedMap<K,V> m)
返回指定有序映射支持的同步（线程安全的）有序映射。
static

<T> SortedSet<T>
synchronizedSortedSet(SortedSet<T> s)
返回指定有序 set 支持的同步（线程安全的）有序 set。

 

 

转换原理：

 

  1. List list = new ArrayList();
  2. List = MyCollections.synList(list);//返回一个同步的list
  4. class MyCollections{
  5.     public List synList (List list){
  6.         return new MyList(list);
  7.     }
  9.     private class MyList implements List{
  10.         private List list;
  11.         private static final Object lock = new Object();
  12.         public MyList() {
  13.             super();
  14.             // TODO Auto-generated constructor stub
  15.         }
  17.         public MyList(List list) {
  18.             super();
  19.             this.list = list;
  20.         }
  21.         public boolean add(Object obj){
  22.             synchronized (lock) {
  23.                 return list.add(obj);
  24.             }
  25.         }
  26.         public boolean remove(Object obj){
  27.             synchronized (lock) {
  28.                 return list.remove(obj);
  29.             }
  30.         }
  31.     }
  32. }