Java比较器警告

我使用Comparator按大小比较文件，但当我试图编译代码时，我得到警告：“java使用未经检查或不安全的操作”。我把我的代码放到注释中，然后程序就开始工作了，所以我认为在Comparator类中排序是个问题。这是我的密码：

public class size implements Comparator {

    @Override
    public int compare(Object o1, Object o2) {

        long s1 = ((Class)o1).getSize();
        long s2 = ((Class)o2).getSize();

        if (s1 > s2){
            return 1;
        }
        else if (s1 < s2){
            return -1;
        }
        else {
            return 0;
        }
    }
}

公共类大小实现了Comparator{
@凌驾
公共整数比较（对象o1、对象o2）{
长s1=（（类）o1.getSize（）；
长s2=（（类）o2）.getSize（）；
如果（s1>s2）{
返回1；
}
否则如果（s1

这就是它抱怨的地方。我认为这可以解决问题：

if(o1 instanceof Class)  
{  
     long s1 = ((Class)o1).getSize();
}  

基本上，您没有保证

o1

是

类

这就是它抱怨的地方。我认为这可以解决问题：

if(o1 instanceof Class)  
{  
     long s1 = ((Class)o1).getSize();
}  

---

基本上，您没有保证

o1

是

类

这两行包含不安全的强制转换：

long s1 = ((Class)o1).getSize();
long s2 = ((Class)o2).getSize();

不安全强制转换是这样的表达式：

（Class）o1

，您将对象o1强制转换为类，而事先未检查

o1

是否为

类的实例

如果向方法提供类的实例，则程序运行良好。问题是，您无法确保没有人使用非类的对象调用yur方法

您应该实现一个类型安全的比较器，前提是您的java版本比1.4版本更新

public class size implements Comparator<Class> {   
    @Override
    public int compare(Class o1, Class o2) {
        // compare the two class objects

公共类大小实现了比较器{
@凌驾
公共整数比较（o1类、o2类）{
//比较两个类对象
这两行包含不安全的强制转换：

long s1 = ((Class)o1).getSize();
long s2 = ((Class)o2).getSize();

不安全强制转换是这样的表达式：
（Class）o1
，您将对象o1强制转换为类，而事先未检查
o1
是否为
类的实例

如果向方法提供类的实例，则程序运行良好。问题是，无法确保没有人使用非类的对象调用yur方法

您应该实现一个类型安全的比较器，前提是您的java版本比1.4版本更新

public class size implements Comparator<Class> {   
    @Override
    public int compare(Class o1, Class o2) {
        // compare the two class objects

公共类大小实现了比较器{
@凌驾
公共整数比较（o1类、o2类）{
//比较两个类对象
将您的
比较器
声明为
比较器
，并将比较方法替换为

compare(File o1, File o2)

编辑：或
比较器
，如果您正在比较类。这似乎是您要做的
将您的
比较器声明为
比较器
，并将比较方法替换为

compare(File o1, File o2)

编辑：如果您正在比较类，则使用或
Comparator
。这是您似乎要做的事情
您应该使用o1.getClass（）而不是强制转换
您应该使用o1.getClass（）而不是强制转换
我认为代码中有错误。
你应该这样做：

 public static void main(String[] args) {
    File parentFile = new File("path to your parent file");
    File[] files = parentFile.listFiles();
    Arrays.sort(files, new Comparator<File>() {
    @Override
    public int compare(File o1, File o2) {
        return new Long(o1.length()).compareTo(o2.length());
    }
});

publicstaticvoidmain（字符串[]args）{
File parentFile=新文件（“父文件的路径”）；
File[]files=parentFile.listFiles（）；
Arrays.sort（文件，新的Comparator（）{
@凌驾
公共整数比较（文件o1、文件o2）{
返回新的Long（o1.length（））.compareTo（o2.length（））；
}
});
我认为代码中有错误。
你应该这样做：

 public static void main(String[] args) {
    File parentFile = new File("path to your parent file");
    File[] files = parentFile.listFiles();
    Arrays.sort(files, new Comparator<File>() {
    @Override
    public int compare(File o1, File o2) {
        return new Long(o1.length()).compareTo(o2.length());
    }
});

publicstaticvoidmain（字符串[]args）{
File parentFile=新文件（“父文件的路径”）；
File[]files=parentFile.listFiles（）；
Arrays.sort（文件，新的Comparator（）{
@凌驾
公共整数比较（文件o1、文件o2）{
返回新的Long（o1.length（））.compareTo（o2.length（））；
}
});
首先，您将Comparator用作原始类型。这是错误的，请向其添加类型参数，然后实现
比较（文件，文件）

其次，比较器的性能将非常糟糕，因为
length
会导致本机系统调用以查找文件的大小

要解决性能问题，您需要为文件编写一个包装类。它可以直接实现
Comparable
：

public class FileBySize implements Comparable<FileBySize> {
   private final File f;
   private final Long size;
   public FileBySize(File f) { this.f = f; this.size = f.length(); }
   @Override public int compareTo(FileBySize other) {
     return this.size.compareTo(other.size);
   }
}

公共类FileBySize实现可比较{
私人最终文件f；
私人最终长尺寸；
公共FileBySize（文件f）{this.f=f；this.size=f.length（）；}
@覆盖公共整数比较（按文件大小其他）{
返回此.size.compareTo（其他.size）；
}
}
首先，您将Comparator用作原始类型。这是错误的，请向其添加类型参数，然后实现
比较（文件，文件）

其次，比较器的性能将非常糟糕，因为
length
会导致本机系统调用以查找文件的大小

要解决性能问题，您需要为文件编写一个包装类。它可以直接实现
Comparable
：

public class FileBySize implements Comparable<FileBySize> {
   private final File f;
   private final Long size;
   public FileBySize(File f) { this.f = f; this.size = f.length(); }
   @Override public int compareTo(FileBySize other) {
     return this.size.compareTo(other.size);
   }
}

公共类FileBySize实现可比较{
私人最终文件f；
私人最终长尺寸；
公共FileBySize（文件f）{this.f=f；this.size=f.length（）；}
@覆盖公共整数比较（按文件大小其他）{
返回此.size.compareTo（其他.size）；
}
}
这是正确的。
比较器是一个参数化接口，即使用泛型定义的类

这是实现比较器的方法，以避免出现警告和引发
ClassCasetException
的机会：

public class SizeComparator implements Comparator<Object> {
......
}

顺便说一句，在您的情况下，您还可以定义比较器，如下所示：

public class SizeComparator implements Comparator<T extends Object> {
     public int compare(T o1, T o2) {
         .......
     }
}

公共类SizeComparator实现Comparator{
公共整数比较（tO1，tO2）{
.......
}
}

请注意，我更改了类的名称。遵循广为人知的命名约定很重要。
这是正确的。
Comparator
是一个参数化接口，即使用泛型定义的类

这是实现比较器的方法，以避免警告和出现
ClassCasetException