Считывание и сортировка таблицы Excel из .txt файла.

0
12 мар 2018 07:59
Нужно написать программу, которая будет считывать таблицу из Excel таблицы, сохранённой в txt формате. После сортировки программа должна сохранить данные в новый txt файл. Вот примерное содержание исходного файла:
Бобриков 1 2 3 3 4
Петров 3 4 4 4 4 4 4
Жалкин 4 5 5 5 5 5
Кораблёв 2 3 2 3 3 3
Козлов 4 4 4 4
Зубкова 5 5 4 4 4
Красников 3 3 3 3 3 5 4
Астахов 5 3 5 4 4
Мельников 3 3 3 3 3 3 3
Новиков 5 4 4 4 4
Краснова 5 5 5 4 4 5
Прудов 5 3 4 5 4 3
Прыткин 2 2 2 3 3 3
Трынькина 4 5 4 5 4
Васницов 4 5 4 3 4 5
Символы разделены табуляцией. После считывания нужно посчитать среднее значение оценки по каждой строке для отдельного человека, кол-во оценок и дисперсию. Есть код на C, но так и не разобрался с считыванием с файла в Java
Вот код работающей программы на C
#include "stdafx.h"
#include <iostream>
#include <string>
#include <fstream>
#include <math.h>


using namespace std;
const int j = 7;

struct ocenki
{
	string famil;
	int a[j] = { 0,0,0,0,0,0,0 };
	float mo = 0;
	int k = 0;
	float dis = 0;
};

int main()
{
	int m = 0;
	char c='0';
	int g;
	setlocale(LC_ALL, "ru");
	cout << "введите количество учеников" << endl;
	cin >> g;
	if (g < 1 || g>101)
	{
		cout << "ERROR!! Неправильное число учеников" << endl;
		system("pause");
		return 0;
	}
	ocenki p[100];
	//считывание с файла
	ifstream file("text.txt");
	if (!file.is_open())
		cout << "Файл не был открыт" << endl;
	else
	{
		for (int i = 0; (i < g)&&!file.eof(); i++)
		{
			file >> p[i].famil;
			int n = -1;
			while(n<j&& !file.eof())
			{
				c = file.get();
				if (c != '\n')
					if (c != '\t')
					{
						p[i].a[n] = c-48;
					}
					else
						n++;
				else
					break;
			}
			if (!file.eof())
				m++;
		}
	}
	file.close();
	cout << "Вывод файла" << endl;
	//количество оценок и математическое ожидание
	for (int i = 0; i < m; i++)
	{
		for (int n = 0; n < j; n++)
			if (p[i].a[n] != 0)
			{
				p[i].mo += p[i].a[n];
				p[i].k++;
			}
		p[i].mo /= p[i].k;
	}
	//Дисперсия:
	for (int i = 0; i < m; i++)
	{
		for (int n = 0; n < j; n++)
		{
			if (p[i].a[n] != 0)
				p[i].dis +=pow((p[i].a[n] - p[i].mo),2);
		}
		p[i].dis /= p[i].k;
	}
	//сортировка
	for (int l = 0; l < m; l++)
		for (int i = 0; i < m; i++)
			if (p[l].mo > p[i].mo)
				swap(p[i], p[l]);
			else
				if (p[l].mo == p[i].mo)
					if (p[l].dis < p[i].dis)
						swap(p[i], p[l]);
					else
						if (p[l].dis == p[i].dis)
							if (p[l].k > p[i].k)
								swap(p[i], p[l]);
	//Запись в файл
	ofstream f("text2.txt");
	f << m;
	for (int i = 0; i < j+1; i++)
		f << "\t";
	f<< "Матем. ожид.\t" << "Диспер\t" << "Кол-во оцен.\n";
	for (int i = 0; i < m; i++)
	{
		f << p[i].famil << "\t";
		for (int n = 0; n < j; n++)
		{
			f << p[i].a[n] << "\t";
		}
		f<<p[i].mo << "\t"<<p[i].dis<< "\t"<<p[i].k<< "\n";
	}
	f.close();
	//проверочный вывд на экран
	cout << "Доступное кол-во: " << m << endl;
	for (int i = 0; i < m; i++)
	{
		cout << p[i].famil << " ";
		for(int n=0;n<j;n++)
			cout << p[i].a[n] << " ";
		cout << " ; Mat mod: " << p[i].mo;
		cout << " ; Disper: " << p[i].dis;
		cout << " ; Kol oc: " << p[i].k;
		cout << endl;
	}
	system("pause");
    return 0;
}

Ответов: 1

1
15 мар 2018 07:33
public class SchoolReport {
    private static final String LINE_DELIMITER = System.lineSeparator();
    private static final String COLUMN_DELIMITER = "\t";
    private static final String CHARSET_NAME = "windows-1251";
    //
    private List<Student> students = new ArrayList<>();

    public static void main(String[] args) throws IOException {
        SchoolReport schoolReport = new SchoolReport();

        int numberOfRecordsForRead = getNumberOfRecordsForRead();
        File source = new File("resources/source.txt");
        schoolReport.load(source, CHARSET_NAME, numberOfRecordsForRead);

        schoolReport.print();

        schoolReport.sort();

        File target = new File("resources/target.txt");
        schoolReport.write(target, CHARSET_NAME);

        schoolReport.print();
    }

    private static int getNumberOfRecordsForRead() {
        int numberOfRecordsForRead;
        System.out.println("Введите количество учеников:");
        try (Scanner console = new Scanner(System.in)) {
            numberOfRecordsForRead = console.nextInt();
        }
        return numberOfRecordsForRead;
    }

    public void load(File source, String charsetName, int numberOfRecordsForRead) throws IOException {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(source), charsetName))) {
            String line;
            int numberOfRecordsRead = 0;
            while ((numberOfRecordsRead < numberOfRecordsForRead)
                    && ((line = reader.readLine()) != null)) {
                students.add(getStudent(line));
                ++numberOfRecordsRead;
            }
        }
    }

    private Student getStudent(String studentAsString) {
        String[] items = studentAsString.split(COLUMN_DELIMITER);
        Student student = new Student(items[0]);
        for (int i = 1; i < items.length; ++i) {
            student.addAssessment(Integer.parseInt(items[i]));
        }

        return student;
    }

    public void write(File target, String charsetName) throws IOException {
        try (BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(target), charsetName))) {
            writer.write("" + students.size() + COLUMN_DELIMITER);

            int maxNumberOfAssessments = getMaxNumberOfAssessments(students);
            String tabs = String.join("", Collections.nCopies(maxNumberOfAssessments, COLUMN_DELIMITER));
            writer.write(tabs + "Математическое ожидание" + COLUMN_DELIMITER +
                                 "Дисперсия" + COLUMN_DELIMITER +
                                 "Кол-во оценок" + LINE_DELIMITER);

            for (Student student : students) {
                writer.write(student.getName() + COLUMN_DELIMITER);

                List<Integer> assessments = student.getAssessments();
                for (int i = 0; i < maxNumberOfAssessments; ++i) {
                    if (i < assessments.size()) {
                        writer.write(assessments.get(i) + COLUMN_DELIMITER);
                    } else {
                        writer.write("0" + COLUMN_DELIMITER);
                    }
                }
                writer.write(student.getMathematicalExpectation() + COLUMN_DELIMITER);
                writer.write(student.getDispersion() + COLUMN_DELIMITER);
                writer.write("" + assessments.size());
                writer.write(LINE_DELIMITER);
            }
        }
    }

    public void print() {
        System.out.print("" + students.size() + COLUMN_DELIMITER);

        int maxNumberOfAssessments = getMaxNumberOfAssessments(students);
        String tabs = String.join("", Collections.nCopies(maxNumberOfAssessments, COLUMN_DELIMITER));
        System.out.print(tabs + "Математическое ожидание" + COLUMN_DELIMITER +
                                 "Дисперсия" + COLUMN_DELIMITER +
                                 "Кол-во оценок" + LINE_DELIMITER);

        for (Student student : students) {
            System.out.print(student.getName() + COLUMN_DELIMITER);

            List<Integer> assessments = student.getAssessments();
            for (int i = 0; i < maxNumberOfAssessments; ++i) {
                if (i < assessments.size()) {
                    System.out.print(assessments.get(i) + COLUMN_DELIMITER);
                } else {
                    System.out.print("0" + COLUMN_DELIMITER);
                }
            }
            System.out.print(student.getMathematicalExpectation() + COLUMN_DELIMITER);
            System.out.print(student.getDispersion() + COLUMN_DELIMITER);
            System.out.print("" + assessments.size());
            System.out.print(LINE_DELIMITER);
        }
    }

    private int getMaxNumberOfAssessments(List<Student> students) {
        int maxNumberOfAssessments = 0;
        for (Student student : students) {
            int size = student.getAssessments().size();
            maxNumberOfAssessments = size > maxNumberOfAssessments ? size : maxNumberOfAssessments;
        }

        return maxNumberOfAssessments;
    }

    public void sort() {
        Collections.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int result = Float.compare(o1.getMathematicalExpectation(), o2.getMathematicalExpectation());
                if (result != 0) {
                    return result;
                }
                result = Float.compare(o1.getDispersion(), o2.getDispersion());
                if (result != 0) {
                    return result;
                }

                return Integer.compare(o1.getAssessments().size(), o2.getAssessments().size());
            }
        });
    }
}

public class Student {
    private static final float WRONG_RESULT = -1;
    //
    private String name;
    private List<Integer> assessments = new ArrayList<>();
    private float mathematicalExpectation = WRONG_RESULT;
    private float dispersion = WRONG_RESULT;

    public Student(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public List<Integer> getAssessments() {
        return Collections.unmodifiableList(assessments);
    }

    public boolean addAssessment(int assessment) {
        if (assessment != 0) {
            assessments.add(assessment);

            mathematicalExpectation = WRONG_RESULT;
            dispersion = WRONG_RESULT;

            return true;
        }

        return false;
    }

    public void clearAssessments() {
        assessments.clear();

        mathematicalExpectation = WRONG_RESULT;
        dispersion = WRONG_RESULT;
    }

    public float getMathematicalExpectation() {
        if (mathematicalExpectation == WRONG_RESULT) {
            int numberOfAssessments = 0;
            int amountOfAssessments = 0;
            for (int assessment : assessments) {
                if (assessment != 0) {
                    ++numberOfAssessments;
                    amountOfAssessments += assessment;
                }
            }

            mathematicalExpectation = (float) amountOfAssessments / numberOfAssessments;
        }

        return mathematicalExpectation;
    }

    public float getDispersion() {
        if (dispersion == WRONG_RESULT) {
            int numberOfAssessments = 0;
            float amount = 0;
            for (int assessment : assessments) {
                if (assessment != 0) {
                    amount += Math.pow(assessment - getMathematicalExpectation(), 2);
                    ++numberOfAssessments;
                }
            }

            dispersion = amount / numberOfAssessments;
        }

        return dispersion;
    }
}


P/S: На мой взгляд, эту тему уместнее было бы поднимать в этом разделе.
Модераторы: Нет
Сейчас эту тему просматривают: Нет