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

  • Автор темы neomax38
  • Дата начала
Статус
Закрыто для дальнейших ответов.
N

neomax38

#1
Требуется разбить на 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]
 
Статус
Закрыто для дальнейших ответов.