Java 如何打印增强for循环中的前10行

我有一个超过1000个名字的档案，其中还包括性别和有多少人有这个名字

范例

莎拉F 2000

我正在尝试打印从for循环创建的前10行，但由于某些原因，我尝试只打印最后一行10次

import java.util.*;
import java.io.*;
import java.util.Collections;
public class NameYear
{
  private String year;
  ArrayList<OneName> oneName = new ArrayList<OneName>();

  public NameYear(String year)
  {
    String line = ""; 
    String Top = "";
  Scanner sc = null;
  try
    {
    sc = new Scanner(new File
    ("/home/mathcs/courses/cs225/koch/names/yob"+year+".txt"));
    }
catch (Exception e)
    {
    System.out.println("Error Year should be between 1880 and 2013 not "+ year);
    System.exit(1);
    }

    while(sc.hasNextLine())
    {

    // read a line from the input file via sc into line
        line = sc.nextLine();



        StringTokenizer stk = new StringTokenizer(line, ",");
        String name = stk.nextToken();
        char sex = stk.nextToken().charAt(0);
        int count = Integer.parseInt(stk.nextToken());


        OneName list = new OneName(name, sex, count);

        oneName.add(list);      
    }
   for (int i = 0 ; i < 10; i++)
   {
   System.out.println(descending());
   }

public String descending()
{
    String x = "";
     Collections.sort(oneName, new OneNameCountCompare());
     for(OneName b: oneName)
    {
        x =  b.toString();
     }
    return x;

import java.util.*；
导入java.io.*；
导入java.util.Collections；
公共班级名称年
{
私人弦年；
ArrayList oneName=新的ArrayList（）；
公共名称年（字符串年）
{
字符串行=”；
字符串Top=“”；
扫描仪sc=空；
尝试
{
sc=新扫描仪（新文件
（“/home/mathcs/courses/cs225/koch/names/yob”+year+”.txt”）；
}
捕获（例外e）
{
System.out.println（“错误年份应介于1880年和2013年之间，而不是“+年”）；
系统出口（1）；
}
while（sc.hasNextLine（））
{
//通过sc将输入文件中的一行读取到第行
line=sc.nextLine（）；
StringTokenizer stk=新的StringTokenizer（行“，”）；
字符串名称=stk.nextToken（）；
char sex=stk.nextToken（）.charAt（0）；
int count=Integer.parseInt（stk.nextToken（））；
OneName列表=新的OneName（姓名、性别、计数）；
oneName.add（列表）；
}
对于（int i=0；i<10；i++）
{
System.out.println（降序（））；
}
公共字符串降序（）
{
字符串x=“”；
排序（oneName，new OneNameCountCompare（））；
对于（OneName b:OneName）
{
x=b.toString（）；
}
返回x；

OneName文件

public class OneName
{
private String Name;
private char Sex;
private int Count;

public OneName(String name, char sex, int count)
{
 Name =  name;
 Sex = sex;
 Count = count;

}
public String getName()
{
 return Name;
}
public char getSex()
{
 return Sex;
}
public int getCount()
{
 return Count;
}
public void setName(String name)
{
     if (name.length() < 1)
     {
     throw new NullPointerException("Baby name is missing");
     }

     Name =  name;

}
private char M; 
private char F;
public void setSex(char sex)
{
 if( sex != M)
 {
    if(sex != F)
    {
    throw new IllegalArgumentException("Sex has to be M or F");
    }
 }
 Sex = sex;

}
public void setCount(int count)
{
if(count < 0)
    { 
    throw new IllegalArgumentException("Count cant be negative");
    }

 Count = count;

}
public String toString()
{
        return String.format("%s %c %d", Name, Sex, Count);

}
}

公共类OneName
{
私有字符串名称；
私人性；
私人整数计数；
公共OneName（字符串名称、字符性别、整数计数）
{
名称=名称；
性别=性别；
计数=计数；
}
公共字符串getName（）
{
返回名称；
}
公共字符getSex（）
{
回归性；
}
public int getCount（）
{
返回计数；
}
公共void集合名（字符串名）
{
if（name.length（）<1）
{
抛出新的NullPointerException（“缺少婴儿名”）；
}
名称=名称；
}
私有字符M；
私有字符F；
公共无效设置（字符性别）
{
如果（性别！=M）
{
如果（性别！=F）
{
抛出新的非法辩论例外（“性必须是M或F”）；
}
}
性别=性别；
}
公共无效集合计数（整数计数）
{
如果（计数<0）
{ 
抛出新的IllegalArgumentException（“计数不能为负”）；
}
计数=计数；
}
公共字符串toString（）
{
返回字符串。格式（“%s%c%d”，名称，性别，计数）；
}
}

onenamecont

import java.util.Comparator;
import java.util.Collections;

public class OneNameCountCompare implements Comparator<OneName>
{
public int compare(OneName b1, OneName b2)
{
 if(b1.getCount() <b2.getCount())
 {
    return 1;
 }
 else
 {
    return -1; 
 }
}
}

import java.util.Comparator；
导入java.util.Collections；
公共类OnNameCountCompare实现了Comparator
{
公共整数比较（OneName b1、OneName b2）
{
如果（b1.getCount（）您的
降序
函数返回一个字符串，并且始终返回相同的字符串（对集合排序后的顺序中的最后一个）。无论您调用它的频率有多高，如果数据不变，您将始终返回相同的最后一个字符串

如果需要排序后的前10个值，
降序
需要返回一个包含以下10个值的
列表
：

public List<String> descending()
{
    List<String> x = new ArrayList<String>(10);
    Collections.sort(oneName, new OneNameCountCompare());
    for(OneName b: oneName)
    {
        x.add(b.toString());
        if (x.size() == 10) // Or don't use enhanced for, use an index instead
        {
            break;
        }
    }
    return x;
}

您的
降序
函数返回一个字符串，并且始终返回相同的字符串（对集合排序后的顺序中的最后一个）。无论您调用它的频率有多高，如果数据不变，您将始终返回相同的最后一个字符串

如果需要排序后的前10个值，
降序
需要返回一个包含以下10个值的
列表
：

public List<String> descending()
{
    List<String> x = new ArrayList<String>(10);
    Collections.sort(oneName, new OneNameCountCompare());
    for(OneName b: oneName)
    {
        x.add(b.toString());
        if (x.size() == 10) // Or don't use enhanced for, use an index instead
        {
            break;
        }
    }
    return x;
}

您的
降序
函数返回一个字符串，并且始终返回相同的字符串（对集合排序后的顺序中的最后一个）。无论您调用它的频率有多高，如果数据不变，您将始终返回相同的最后一个字符串

如果需要排序后的前10个值，
降序
需要返回一个包含以下10个值的
列表
：

public List<String> descending()
{
    List<String> x = new ArrayList<String>(10);
    Collections.sort(oneName, new OneNameCountCompare());
    for(OneName b: oneName)
    {
        x.add(b.toString());
        if (x.size() == 10) // Or don't use enhanced for, use an index instead
        {
            break;
        }
    }
    return x;
}

您的
降序
函数返回一个字符串，并且始终返回相同的字符串（对集合排序后的顺序中的最后一个）。无论您调用它的频率有多高，如果数据不变，您将始终返回相同的最后一个字符串

如果需要排序后的前10个值，
降序
需要返回一个包含以下10个值的
列表
：

public List<String> descending()
{
    List<String> x = new ArrayList<String>(10);
    Collections.sort(oneName, new OneNameCountCompare());
    for(OneName b: oneName)
    {
        x.add(b.toString());
        if (x.size() == 10) // Or don't use enhanced for, use an index instead
        {
            break;
        }
    }
    return x;
}

您的错误如下：

for (int i = 0 ; i < 10; i++) {
   System.out.println(descending());
}

public String descending() {
    String x = "";
    Collections.sort(oneName, new OneNameCountCompare());
    for(OneName b: oneName) {
       x =  b.toString();
    }
    return x;
}

您的错误如下：

for (int i = 0 ; i < 10; i++) {
   System.out.println(descending());
}

public String descending() {
    String x = "";
    Collections.sort(oneName, new OneNameCountCompare());
    for(OneName b: oneName) {
       x =  b.toString();
    }
    return x;
}

您的错误如下：

for (int i = 0 ; i < 10; i++) {
   System.out.println(descending());
}

public String descending() {
    String x = "";
    Collections.sort(oneName, new OneNameCountCompare());
    for(OneName b: oneName) {
       x =  b.toString();
    }
    return x;
}

您的错误如下：

for (int i = 0 ; i < 10; i++) {
   System.out.println(descending());
}

public String descending() {
    String x = "";
    Collections.sort(oneName, new OneNameCountCompare());
    for(OneName b: oneName) {
       x =  b.toString();
    }
    return x;
}

首先在OneName#setName中抛出非法参数异常，而不是NPE。其次，为什么要对其进行排序？只需按您希望的方式显示输入的前10个参数。使用调试器浏览代码并观察发生了什么。尤其要注意从
降序返回的内容。您的代码一团糟。原因是什么它的儿子-System.out.println（降序（））？对于在循环中打印某些项目的问题，这太多代码了。请尝试创建一个较小的示例来演示您的问题。要打印降序函数中的内容，请首先在OneName#setName中抛出非法参数异常，而不是NPE。其次，为什么要对其进行排序？只需按照您希望看到的前10个输入的方式显示它ed.使用调试器遍历代码并观察发生了什么。尤其要注意从
降序返回的内容。您的代码乱七八糟。这是什么原因-System.out.println（降序（））？对于在循环中打印某些项目的问题，这太多代码了。请尝试创建一个较小的示例来演示您的问题。要打印降序函数中的内容，请首先在OneName#setName中抛出非法参数异常，而不是NPE。其次，为什么要对其进行排序？只需按照您希望看到的前10个输入的方式显示它ed.使用调试器浏览代码并观察发生了什么。尤其要注意从
降序返回的内容。您的代码乱七八糟。这是什么原因