在ArrayList上实现比较器的Java

Question

我对Java很陌生，所以这可能是非常简单的问题。

我想根据指定键的自然顺序对类MediaLib中的ArrayList排序。

我不知道如何使用Media类中的比较器（compareTo(MediaInterface, key)）。这是什么最好的方式呢？

package assign1; 

import java.util.*; 

public class Media implements MediaInterface { 

    private Map<String, Object> fields; 
    private static int compare; 

public Media(String title, String format) { 
    fields = new TreeMap<String, Object>(); 
    fields.put("title", title); 
    fields.put("format", format); 
} 


public Object get(String key) { 
    return fields.get(key); 
} 


public void put(String key, Object value) { 
    fields.put(key, value); 
} 


public boolean hasKeywords(String[] words, boolean combineWithAND) { 
    Collection<Object> values = (Collection<Object>) fields.values(); 
    int count = 0; 
    int size = 0; 
    for (String s: words) { 
     for (Object o: values) { 
       String t = o.toString(); 
       if (t.indexOf(s) >= 0) { 
        count++; 
        break; 
       } 
     } 
     size++; 
    } 
    if ((count == 0 && !combineWithAND) || (combineWithAND && (count != size))) { 
     return false; 
    } 
    return true; 
} 


public int compareTo(MediaInterface mi, String key) { //<<<<<<<------calling this!! 
    if (mi == null) 
    throw new NullPointerException(); 
    Media m = (Media) mi; 
    Comparable mValue = (Comparable) m.get(key); 
    Comparable lValue = (Comparable) fields.get(key); 
    if ((mValue == null) && (lValue == null)){ 
     return 0; 
    } 
    if ((lValue == null)){ 
      return 1; 
     } 
    if ((mValue == null)){ 
      return -1; 
     } 
    return (lValue).compareTo(mValue); 
} 


@Override 
public int compareTo(MediaInterface mi) { 
    if (mi == null) 
    throw new NullPointerException(); 
    Media m = (Media) mi; 
    Set<String> lSet = fields.keySet(); 
    if (compareTo(m, "title") != 0) { 
     return compareTo(m, "title"); 
    } 
    if (compareTo(m, "year") != 0) { 
      return compareTo(m, "year"); 
     } 
    for (String s: lSet) { 
     if (compareTo(m, s) != 0) { 
      return compareTo(m, s); 
     } 
    } 
    return 0; 
} 


public boolean equals(Object object) { 
    if (object == null) 
    return false; 
    if (!(object instanceof Media)) 
    return false; 
    Media m = (Media) object; 
    if (compareTo(m) != 0) { 
     return false; 
    } 
    return true; 
} 
} 

---

package assign1; 

import java.util.ArrayList; 
import java.util.Collection; 
import java.util.Collections; 
import java.util.Comparator; 

public class MediaLib implements Searchable { 
private ArrayList<MediaInterface> media; 

public MediaLib() { 
    media = new ArrayList<MediaInterface>(); 
} 


@Override 
public void add(MediaInterface mi) { 
    if (media.isEmpty()) { 
     media.add(mi); 
    } 
    else { 
     for (MediaInterface m: media) { 
      if (mi.equals(m)) { 
       return; 
      } 
     } 
     media.add(mi); 
    } 
} 


@Override 
public boolean contains(MediaInterface mi) { 
    for (MediaInterface m: media) { 
      if (mi.equals(m)) { 
       return true; 
      } 
     } 
    return false; 
} 


@Override 
public Collection<MediaInterface> findByKeyword(String[] words, boolean combineWithAND) { 
    Collection<MediaInterface> foundList = new ArrayList<MediaInterface>(); 
    for (MediaInterface mi: media) { 
     if (mi.hasKeywords(words, combineWithAND)) { 
      foundList.add(mi); 
     } 
    } 
    return foundList; 
} 


@Override 
public Collection<MediaInterface> findByTitle(String str) { 
    Collection<MediaInterface> foundList = new ArrayList<MediaInterface>(); 
     for (MediaInterface mi: media) { 
      if ((mi.get("title")).equals(str)) { 
       foundList.add(mi); 
      } 
     } 
     return foundList; 
} 


@Override 
public Collection<MediaInterface> getAllWithFormat(String formatName) { 
    Collection<MediaInterface> foundList = new ArrayList<MediaInterface>(); 
     for (MediaInterface mi: media) { 
      if ((mi.get("format")).equals(formatName)) { 
       foundList.add(mi); 
      } 
     } 
     return foundList; 
} 

public Collection<MediaInterface> getAll() { 
    Collection<MediaInterface> fullList = new ArrayList<MediaInterface>(); 
     for (MediaInterface mi: media) { 
      fullList.add(mi); 
     } 
     return fullList; 
} 


@Override 
public void removeAllWithKeyword(String[] words, boolean combineWithAND) { 
    Collection<MediaInterface> foundList = findByKeyword(words, combineWithAND); 
    for (MediaInterface mi: foundList) { 
     media.remove(mi); 
    } 
} 


@Override 
public void removeAllWithFormat(String format) { 
    Collection<MediaInterface> foundList = getAllWithFormat(format); 
     for (MediaInterface mi: foundList) { 
      media.remove(mi); 
     } 
} 


@Override 
public void sort() { 
    Collections.sort(media); 
} 


@Override 
public void sort(final String fieldName) { 
    Collections.sort(media, new Media.compareTo(MediaInterface, fieldName)) //<<<<<--------Trying to call compareTo() 

    } 
} 


public void parse(java.io.BufferedReader br) throws java.io.IOException { 
    while(br.readLine()!= null) { 
     Media mi = new Media(/n br.readLine(), br.readLine()); 
     while 

    } 
} 
} 

Answer 1

你已经实现你的MediaInterface类Comparable接口，这是一个通用的接口，所以你再实现Comparable<MediaInterface>然后将要求您实现与签名的方法

public int compareTo(final MediaInterface other) 

这就是为什么你的电话Collections.sort(media);编译

为了按特定字段名称排序，您需要提供Comparator的实例，最简单的方法是在Media类中创建一个内部类，然后您可以将其传递到Collections.sort。例如

public class Media implements MediaInterface { 
    public static final class FieldComparator implements Comparator<Media> { 
     private final String field; 

     public FieldComparator(final String field) { 
      this.field = field; 
     } 

     public int compare(final Media a, final Media b) { 
      // implementation to compare a.field to b.field 
     } 
    } 
} 

然后，您可以改写你的第二个sort方法

@Override 
public void sort(final String fieldName) { 
    Collections.sort(media, new Media.FieldComparator(fieldName)); 
}