4

我有一个逗号分隔的文件，其中包含员工姓名、公司、年份。

一名员工可能隶属于多家公司。

例如，

约翰，谷歌，2
约翰，微软，1
詹姆斯，特斯拉，1
詹姆斯，苹果，5

我已经使用 java 扫描仪检索了信息

scanner.useDelimiter(",|\\n");
    while (scanner.hasNext()) {
        String line = scanner.next()

我是 Java 新手，我正在尝试使用链表数组或数组数组以排序顺序（使用经验作为排序标准）插入上述内容。所以

员工 -> Company1 -> Company2....（按员工经验排序）

所以在上面的例子中，它将是：

约翰- >微软->谷歌
詹姆斯->特斯拉->苹果

有人可以指出我正确的方向吗？

注意：如果经验相同，那么哪家公司先来并不重要。

4

3 回答 3

1

将此类用于 Person

公共类人{

@Getter @Setter
private String name;

@Getter @Setter
private TreeMap<String, String> companyExperience;

public Person(){
    companyExperience = new TreeMap<String, String>();
}

}

使用经验作为 TreeMap 中的键将自动按升序对 Person 的公司进行排序。

你的主要课程应该是这样的

public class App 
{
    public static void main( String[] args )
    {
        HashMap<String, Person> persons = new HashMap<String, Person>();

        BufferedReader br = null;
        try {
            br = new BufferedReader(new FileReader("C:\\Users\\Public Administrator\\test.txt"));
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        String line = null;

        try {
            while ((line = br.readLine()) != null) {
                String[] fields = line.split(",");
                String personName = fields[0];
                Person existingPerson = persons.get(personName);
                if (existingPerson==null){
                    Person newPerson = new Person();
                    newPerson.setName(personName);
                    newPerson.getCompanyExperience().put(Integer.parseInt(fields[2])+fields[1], fields[1]);
                    persons.put(personName, newPerson);
                } else{
                    existingPerson.getCompanyExperience().put(Integer.parseInt(fields[2])+fields[1], fields[1]);
                }
             }
        } catch (NumberFormatException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }    

        //output
        Iterator<Map.Entry<String, Person>> entries = persons.entrySet().iterator();
        while (entries.hasNext()) {
            Map.Entry<String, Person> entry = entries.next();
            Person _person = entry.getValue();
            System.out.print(_person.getName());

            Iterator<Map.Entry<String, String>> companyExperiences = _person.getCompanyExperience().entrySet().iterator();
            while (companyExperiences.hasNext()) {
                Map.Entry<String, String> companyExperience = companyExperiences.next();

                System.out.print(" > "+companyExperience.getValue());
            }
            System.out.println();

        }
    }
}

我已经测试过了，它看起来很漂亮，对我来说很好。

顺便说一句，@Getter 和 @Setter 注释来自 Lombok 项目。您可以使用它或创建自己的 getter/setter。

于 2013-02-13T10:58:45.217 回答
0

读取您的文件readLine()并使用 split 获取数据的每个字段，例如：

BufferedReader br = new BufferedReader(new FileReader("FileName"));
String line = null;
ArrayList<Person> list = new ArrayList<Person>();

while ((line = br.readLine()) != null) {
    String[] fields = line.split(",");
    list.add(new Person(fields[0], fields[1], Integer.parseInt(fields[2])));
 }

然后，您可以将您的数据保存在ArrayList一个自定义类中，例如，该类Person存储人员的信息并实现Comparable您执行排序逻辑的位置。

如果您需要按人名对数据进行分组，您可以考虑使用Hashtable其中的键是人名，值是ArrayList经验。

您可以为您的数据定义一个类，例如

class Person implements Comparable<Person> {
    private String name;
    private String company;
    private int experience;

    public Person(String name, String company, int experience) {

        this.name = name;
        this.company = company;
        this.experience = experience;
    }

    public int getExperience() {
        return experience;
    }

    @Override
    public int compareTo(Person person) {
        return new Integer(experience).compareTo(person.getExperience());
    }
}

对您的列表进行排序只需调用Collections.sort(list);; 但是此列表将包含所有数据，因此请修改代码以按员工姓名对数据进行分组，并为每个员工提供一个列表

于 2013-02-13T01:14:44.307 回答
0

出于您的目的，听起来您真的想要一个对象来代表一个具有一定经验的人。Map<String,Person>由于您的输入源具有非规范化的数据，因此最简单的方法是在解析文件时填充 a ：

scanner.useDelimiter(",|\\n");
while (scanner.hasNext()) {
    String line = scanner.next();
    String[] fields = line.split(",");

    String name = fields[0];
    Person person = map.get(name);
    if (person == null) {
        person = new Person(name);
        map.put(name, person);
    }
    person.addJob(fields[1], Integer.parseInt(fields[2]));
}

List<Person> people = new ArrayList<Person>(map.values());

在此过程之后，您将得到一个人员列表，没有特定的顺序。对于每个人，由于您希望按经验对他们的工作进行排序，因此您需要Person.addJob以保持其有序的方式实施。SortedSet是一种非常好的方法，但是您不能插入重复项，并且由于您想根据经验进行排序，并且一个人可能在两份工作上花费相同的时间，您需要使用另一种方法. List有几种方法可以做到这一点，但在不对您的数据进行假设的情况下，我建议保留排序Job对象：

class Person {
    private final List<Job> jobs = new LinkedList<Job>();

    // Constructor, etc... 

    public void addJob(String companyName, int yearsOfExperience) {
        Job newJob = new Job(companyName, yearsOfExperience);
        int insertionIndex = Collections.binarySearch(jobs, newJob);
        if (insertionIndex < 0) {
            insertionIndex = (-(insertionIndex) - 1);
        }
        jobs.add(insertionIndex, newJob);
    }
}

最后， a Jobshould implement Comparable<Job>，以便您查找它：

class Job implements Comparable<Job> {
    private final String companyName;
    private final int yearsOfExperience;

    // Constructor, etc... 

    public int compareTo(Job otherJob) {
        return Integer.compare(yearsOfExperience,otherJob.yearsOfExperience);
    }
}

里面的那一点诡计Person.addJob将List始终按约伯的“自然顺序”排序。（参见Collections.binarySearch）。

于 2013-02-13T03:43:03.660 回答