Как Правильно Разбить Данный Код На 3 Класса?

Тема в разделе "Java", создана пользователем neomax38, 9 дек 2011.

Статус темы:
Закрыта.
  1. neomax38

    neomax38 Гость

    Требуется разбить на 3 класса (писал не сам) Сам новичок в java .
    Из первого класса все выводы сделать.

    Вот задание если что:
    a) Сгенерируйте числовой ряд длиной 30 элементов, представляющий квадраты чисел натурального ряда. Сформируйте из полученных значений два массива: один с четными значениями, другой с нечетными.
    :) Подсчитайте, какие символы наиболее часто встречаются в предложении.
    с) Выберите из множества числа, удовлетворяющие условию введенному в командной строке при запуске программы.

    <!--shcode--><pre><code class='java'>import java.util.*;
    import java.util.Map.Entry;

    public class Test {

    public static void main(String[] args) {

    //// Задание 1:

    // Создаём список квадратов
    List<Integer> numbers = createRealNumbers(30);
    // Сортируем квадраты на чётные и нечётные
    OddsAndEvensResult sortResult = sortOddsAndEvens(numbers);

    // Это результаты задания 1:
    Integer[] odds = sortResult.getOdds().toArray(new Integer[0]);
    Integer[] evens = sortResult.getEvens().toArray(new Integer[0]);
    // -----


    //// Задание 2:

    // Сортируем строку
    LettersSortResult lsortResult = sortLetters("some simple string wis lots ofs as's and sim imount of iiiiis");

    // Это результаты задания 2:
    Character[] topLetters = lsortResult.getTops();
    int topLettersCount = lsortResult.getCount();
    // -----

    //// Задание 3:

    // Парсим аргументы
    ArgsParseResult parseResult = parseArgs(args);
    Equality eq = parseResult.getEqualityType();
    int equaler = parseResult.getEqualer();

    // Сортируем полученные ранее квадраты
    List<Integer> sorted = sortNumbersByEquality(numbers, eq, equaler);

    // Это результат задания 3:
    Integer[] sortedNums = sorted.toArray(new Integer[0]);
    // -----

    System.out.println(sorted.size() > 0 ? sorted : "[No match]");
    }

    private static List<Integer> createRealNumbers(final int n) {

    List<Integer> numbers = new ArrayList<Integer>(n);

    for (int i = 1; i <= n; i++) {
    numbers.add((int) Math.pow(i, 2));
    }

    return numbers;
    }

    private static OddsAndEvensResult sortOddsAndEvens(List<Integer> numbers) {

    if (numbers == null) throw new IllegalArgumentException();

    int cap = (numbers.size() / 2) + 1;
    final List<Integer> odds = new ArrayList<Integer>(cap);
    final List<Integer> evens = new ArrayList<Integer>(cap);

    for (int i : numbers) {

    if (i % 2 == 0) {

    evens.add(i);
    }
    else {

    odds.add(i);
    }
    }

    return new OddsAndEvensResult() {

    @Override
    public List<Integer> getOdds() {
    return odds;
    }

    @Override
    public List<Integer> getEvens() {
    return evens;
    }
    };
    }

    private static interface OddsAndEvensResult {
    List<Integer> getOdds();
    List<Integer> getEvens();
    }

    private static List<Integer> sortNumbersByEquality(List<Integer> numbers, Equality equality, int equaler) {

    List<Integer> list = new ArrayList<Integer>();
    for (int i : numbers) {

    if (equality.isEqual(i, equaler)) {

    list.add(i);
    }
    }

    return list;
    }

    private static LettersSortResult sortLetters(String input) {

    Map<Character, Integer> map = new HashMap<Character, Integer>();
    Integer i;
    for (Character c : input.toCharArray()) {

    if (!Character.isWhitespace(c)) {

    i = map.containsKey(c) ? map.get(c) + 1 : 1;
    map.put(c, i);
    }
    }

    int count = 0;
    List<Character> topLetters = new ArrayList<Character>();

    for (Entry<Character, Integer> entry : map.entrySet()) {

    int value = entry.getValue();
    if (value > count) {

    topLetters.clear();
    topLetters.add(entry.getKey());
    count = value;
    }
    else if (value == count) {

    topLetters.add(entry.getKey());
    }
    }

    final Character[] tops = topLetters.toArray(new Character[0]);
    final int topsCount = count;

    return new LettersSortResult() {

    @Override
    public Character[] getTops() {
    return tops;
    }

    @Override
    public int getCount() {
    return topsCount;
    }
    };
    }

    private static interface LettersSortResult {
    Character[] getTops();
    int getCount();
    }

    enum Equality {

    ALL {
    @Override
    boolean isEqual(int num, int equaler) {
    return true;
    }
    },
    LESS {
    @Override
    boolean isEqual(int num, int equaler) {
    return num < equaler;
    }
    },
    LESS_OR_EQUAL {
    @Override
    boolean isEqual(int num, int equaler) {
    return num <= equaler;
    }
    },
    GREAT {
    @Override
    boolean isEqual(int num, int equaler) {
    return num > equaler;
    }
    },
    GREAT_OR_EQUAL {
    @Override
    boolean isEqual(int num, int equaler) {
    return num >= equaler;
    }
    },
    EQUAL {
    @Override
    boolean isEqual(int num, int equaler) {
    return num == equaler;
    }
    };

    abstract boolean isEqual(int num, int equaler);

    static Equality getByString(String s) {

    if (s.length() == 1) {
    char c = s.charAt(0);
    switch (c) {

    case '<': return LESS;
    case '>': return GREAT;
    case '=': return EQUAL;
    }
    }
    else if (s.equals("<=")) {
    return LESS_OR_EQUAL;
    }
    else if (s.equals(">=")) {
    return GREAT_OR_EQUAL;
    }

    return null;
    }
    }

    private static ArgsParseResult parseArgs(String[] args) {

    Equality equality = Equality.ALL;
    int equaler = 0;

    argsparse: if (args.length > 0) {

    if (args.length == 2) {

    statement: {

    String statement = args[0];
    if (statement.length() == 1 || statement.length() == 2) {

    Equality e = Equality.getByString(statement);
    if (e != null) {

    equality = e;
    break statement;
    }
    }

    System.err.println("Wront statement format!\nAll by default:\n");
    break argsparse;
    }

    String number = args[1];
    try {

    equaler = Integer.parseInt(number);

    } catch (NumberFormatException e) {

    System.err.println("Wrong number format!\nAll by default:\n");
    break argsparse;
    }
    }
    else {

    System.out.println(
    "Wrong arguments format!\n" +
    "Use: <statement> <number>\n" +
    "Where <statement> is one of: \"<\", \">\", \"<=\", \">=\", \"=\"\n" +
    "All by default:\n");
    }
    }

    final Equality requality = equality;
    final int requaler = equaler;

    return new ArgsParseResult() {

    @Override
    public Equality getEqualityType() {
    return requality;
    }

    @Override
    public int getEqualer() {
    return requaler;
    }
    };
    }

    private static interface ArgsParseResult {
    Equality getEqualityType();
    int getEqualer();
    }
    }[/CODE]
     
Загрузка...
Статус темы:
Закрыта.

Поделиться этой страницей