com.javarush.test.level08.lesson08.task05

public class Solution
{
    public static HashMap<String, String> createMap()
    {
        HashMap<String,String> map = new HashMap<String, String>();
        map.put("Сергей","Ефремов");
        map.put("ольга","Терентьева");
        map.put("Татьяна","Ефремов");
        map.put("Оксана","Митрофанова");
        map.put("Вячеслав","Оливанов");
        map.put("Виталий","Оливанов");
        map.put("Андрей","Алексеев");
        map.put("Алексей","Иванов");
        map.put("Леха","Николаев");
        map.put("Владислав","Оливанов");
        return map;
    }

    public static void removeTheFirstNameDuplicates(HashMap<String, String> map)
    {
        HashMap<String,String> copy = new HashMap<String, String>(map);
        Iterator<Map.Entry<String,String>> itr = copy.entrySet().iterator();
        while(itr.hasNext()){
            Map.Entry<String,String> name = itr.next();

            if (copy.containsValue(name.getValue()))
                removeItemFromMapByValue(map,name.getValue());
        }
    }

    public static void removeItemFromMapByValue(HashMap<String, String> map, String value)
    {
        HashMap<String, String> copy = new HashMap<String, String>(map);
        for (Map.Entry<String, String> pair: copy.entrySet())
        {
            if (pair.getValue().equals(value))
                map.remove(pair.getKey());
        }
    }

    public static void main(String[] args)
    {
        HashMap<String, String> map = createMap();
        removeTheFirstNameDuplicates(map);
        for (Map.Entry<String, String> pair:map.entrySet()){
            String s = pair.getValue();
            System.out.println(s);
        }
    }
}


или я не вижу какой то банальной ошибки, или я просто не понял, как оно должно работать, но у меня выводит пустой map.
  • ,

level39.lesson09.big01 задание 4

Вроде все работает как надо. Возможно я не верно понимаю описание методов. В чем может быть причина?

Задание 4

Реализуй интерфейс EventQuery у класса LogParser:
4.1. Метод getNumberOfAllEvents() должен возвращать количество различных типов
событий за указанный период.
4.2. Метод getAllEvents() должен возвращать события за указанный период.
4.3. Метод getEventsForIP() должен возвращать события, которые происходили с
указанного IP.
4.4. Метод getEventsForUser() должен возвращать события, которые инициировал
определенный пользователь.
4.5. Метод getFailedEvents() должен возвращать события, которые не выполнились.
4.6. Метод getErrorEvents() должен возвращать события, которые завершились
ошибкой.
4.7. Метод getNumberOfAttemptToSolveTask() должен возвращать количество попыток
решить определенную задачу.
4.8. Метод getNumberOfSuccessfulAttemptToSolveTask() должен возвращать количество
успешных решений определенной задачи.
4.9. Метод getAllSolvedTasksAndTheirNumber() должен возвращать мапу (номер_задачи:
количество_попыток_решить_ее).
4.10. Метод getAllDoneTasksAndTheirNumber() должен возвращать мапу (номер_задачи:
сколько_раз_ее_решили).


package com.javarush.test.level39.lesson09.big01;

import com.javarush.test.level39.lesson09.big01.query.DateQuery;
import com.javarush.test.level39.lesson09.big01.query.EventQuery;
import com.javarush.test.level39.lesson09.big01.query.IPQuery;
import com.javarush.test.level39.lesson09.big01.query.UserQuery;

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class LogParser implements IPQuery, UserQuery, DateQuery, EventQuery
{
    private Path logDir;

    public LogParser(Path logDir)
    {
        this.logDir = logDir;
    }

    private ArrayList<Log> getLogsBetweenDates(Date after, Date before)
    {
        File[] logFiles = logDir.toFile().listFiles(new FilenameFilter()
        {
            @Override
            public boolean accept(File dir, String name)
            {
                return name.endsWith(".log");
            }
        });

        ArrayList<Log> listLogs = new ArrayList<>();
        for (File logFile : logFiles)
        {
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(Files.newInputStream(logFile.toPath()))))
            {
                while (reader.ready())
                {
                    try
                    {
                        String string = reader.readLine();
                        Log log = parseStringToLog(string);

                        if ((after == null || after.getTime() <= log.getDate().getTime()) && (before == null || log.getDate().getTime() <= before.getTime()))
                        {
                            listLogs.add(log);
                        }
                    }
                    catch (Exception e)
                    {

                    }
                }
            }
            catch (IOException e)
            {

            }
        }
        return listLogs;
    }

    private Log parseStringToLog(String string)throws Exception
    {
        //146.34.15.5	Eduard Petrovich Morozko	05.01.2021 20:22:55	DONE_TASK 48	FAILED
        SimpleDateFormat sdf = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss");                                                                      //05.01.2021 20:22:55
        Pattern pattern = Pattern.compile("(\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3})\\s" +                                                     //IP
                "(\\D*)\\s" +                                                                                          //userName
                "(\\d{2}\\.\\d{2}\\.\\d{4}\\s\\d{2}\\:\\d{2}\\:\\d{2})\\s" +                                           //Date
                "(\\w*)\\s?" +                                                                                         //Event
                "(\\d*){0,1}\\s" +                                                                                     //eventValue
                "(\\D*)");                                                                                             //Status

        Matcher matcher = pattern.matcher(string);
        matcher.find();

        String ip = matcher.group(1);
        String userName = matcher.group(2);
        Date date = sdf.parse(matcher.group(3));
        Event event = Event.valueOf(matcher.group(4));
        String eventValue = matcher.group(5);
        Status status = Status.valueOf(matcher.group(6));

        return new Log(ip, userName, date, event, eventValue, status);
    }

    private class Log
    {
        //ip username date event status
        private String ip;
        private String userName;
        private Date date;
        private Event event;
        private String eventValue;
        private Status status;

        public Log(String ip, String userName, Date date, Event event,String eventValue, Status status)
        {
            this.ip = ip;
            this.userName = userName;
            this.date = date;
            this.event = event;
            this.eventValue = eventValue;
            this.status = status;
        }

        public String getIp()
        {
            return ip;
        }

        public String getUserName()
        {
            return userName;
        }

        public Date getDate()
        {
            return date;
        }

        public Event getEvent()
        {
            return event;
        }

        public Status getStatus()
        {
            return status;
        }

        public String getEventValue()
        {
            return eventValue;
        }
    }

    @Override
    public int getNumberOfUniqueIPs(Date after, Date before)
    {
        return getUniqueIPs(after, before).size();
    }

    @Override
    public Set<String> getUniqueIPs(Date after, Date before)
    {
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        Set<String> uniqIps = new HashSet<>();

        for (Log log : logs)
        {
            if (!uniqIps.contains(log.getIp()))
            {
                uniqIps.add(log.getIp());
            }
        }

        return uniqIps;
    }

    @Override
    public Set<String> getIPsForUser(String user, Date after, Date before)
    {
        Set<String> users = new HashSet<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getUserName().equals(user) && !users.contains(log.getIp()))
            {
                users.add(log.getIp());
            }
        }
        return users;
    }

    @Override
    public Set<String> getIPsForEvent(Event event, Date after, Date before)
    {
        Set<String> users = new HashSet<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getEvent().equals(event) && !users.contains(log.getIp()))
            {
                users.add(log.getIp());
            }
        }
        return users;
    }

    @Override
    public Set<String> getIPsForStatus(Status status, Date after, Date before)
    {
        Set<String> users = new HashSet<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getStatus().equals(status) && !users.contains(log.getIp()))
            {
                users.add(log.getIp());
            }
        }
        return users;
    }

    @Override
    public Set<String> getAllUsers()
    {
        Set<String> users = new HashSet<>();
        ArrayList<Log> logs = getLogsBetweenDates(null, null);
        for (Log log : logs)
        {
            if (!users.contains(log.getUserName()))
            {
                users.add(log.getUserName());
            }
        }
        return users;
    }

    @Override
    public int getNumberOfUsers(Date after, Date before)
    {
        Set<String> users = new HashSet<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (!users.contains(log.getUserName()))
            {
                users.add(log.getUserName());
            }
        }
        return users.size();
    }

    @Override
    public int getNumberOfUserEvents(String user, Date after, Date before)
    {
        int i = 0;
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getUserName().equals(user))
            {
                i++;
            }
        }
        return i;
    }

    @Override
    public Set<String> getUsersForIP(String ip, Date after, Date before)
    {
        Set<String> users = new HashSet<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getIp().equals(ip) && !users.contains(log.getUserName()))
            {
                users.add(log.getUserName());
            }
        }
        return users;
    }

    @Override
    public Set<String> getLoggedUsers(Date after, Date before)
    {
        Set<String> users = new HashSet<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getEvent().equals(Event.LOGIN) && !users.contains(log.getUserName()))
            {
                users.add(log.getUserName());
            }
        }
        return users;
    }

    @Override
    public Set<String> getDownloadedPluginUsers(Date after, Date before)
    {
        Set<String> users = new HashSet<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getEvent().equals(Event.DOWNLOAD_PLUGIN) && !users.contains(log.getUserName()))
            {
                users.add(log.getUserName());
            }
        }
        return users;
    }

    @Override
    public Set<String> getWroteMessageUsers(Date after, Date before)
    {
        Set<String> users = new HashSet<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getEvent().equals(Event.WRITE_MESSAGE) && !users.contains(log.getUserName()))
            {
                users.add(log.getUserName());
            }
        }
        return users;
    }

    @Override
    public Set<String> getSolvedTaskUsers(Date after, Date before)
    {
        Set<String> users = new HashSet<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getEvent().equals(Event.SOLVE_TASK) && !users.contains(log.getUserName()))
            {
                users.add(log.getUserName());
            }
        }
        return users;
    }

    @Override
    public Set<String> getSolvedTaskUsers(Date after, Date before, int task)
    {
        Set<String> users = new HashSet<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getEvent().equals(Event.SOLVE_TASK) && log.getEventValue().equals(String.valueOf(task)) && !users.contains(log.getIp()))
            {
                users.add(log.getUserName());
            }
        }
        return users;
    }

    @Override
    public Set<String> getDoneTaskUsers(Date after, Date before)
    {
        Set<String> users = new HashSet<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getEvent().equals(Event.DONE_TASK) && !users.contains(log.getUserName()))
            {
                users.add(log.getUserName());
            }
        }
        return users;
    }

    @Override
    public Set<String> getDoneTaskUsers(Date after, Date before, int task)
    {
        Set<String> users = new HashSet<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getEvent().equals(Event.DONE_TASK) && log.getEventValue().equals(String.valueOf(task)) && !users.contains(log.getUserName()))
            {
                users.add(log.getUserName());
            }
        }
        return users;
    }

    @Override
    public Set<Date> getDatesForUserAndEvent(String user, Event event, Date after, Date before)
    {
        Set<Date> dates = new HashSet<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getUserName().equals(user) && log.getEvent().equals(event))
            {
                dates.add(log.getDate());
            }
        }
        return dates;
    }

    @Override
    public Set<Date> getDatesWhenSomethingFailed(Date after, Date before)
    {
        Set<Date> dates = new HashSet<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getStatus().equals(Status.FAILED) && !dates.contains(log.getDate()))
            {
                dates.add(log.getDate());
            }
        }
        return dates;
    }

    @Override
    public Set<Date> getDatesWhenErrorHappened(Date after, Date before)
    {
        Set<Date> dates = new HashSet<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getStatus().equals(Status.ERROR) && !dates.contains(log.getDate()))
            {
                dates.add(log.getDate());
            }
        }
        return dates;
    }

    @Override
    public Date getDateWhenUserLoggedFirstTime(String user, Date after, Date before)
    {
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        Date date = null;
        for (Log log : logs)
        {
            if (log.getUserName().equals(user) && log.getEvent().equals(Event.LOGIN))
            {
                date = date == null? log.getDate() : date.getTime() > log.getDate().getTime()? log.getDate() : date;
            }
        }
        return date;
    }

    @Override
    public Date getDateWhenUserSolvedTask(String user, int task, Date after, Date before)
    {
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        Date date = null;
        for (Log log : logs)
        {
            if (log.getUserName().equals(user) && log.getEvent().equals(Event.SOLVE_TASK) && log.getEventValue().equals(String.valueOf(task)))
            {
                date = date == null? log.getDate() : date.getTime() > log.getDate().getTime()? log.getDate() : date;
            }
        }
        return date;
    }

    @Override
    public Date getDateWhenUserDoneTask(String user, int task, Date after, Date before)
    {
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        Date date = null;
        for (Log log : logs)
        {
            if (log.getUserName().equals(user) && log.getEvent().equals(Event.DONE_TASK) && log.getEventValue().equals(String.valueOf(task)))
            {
                date = date == null? log.getDate() : date.getTime() > log.getDate().getTime()? log.getDate() : date;
            }
        }
        return date;
    }

    @Override
    public Set<Date> getDatesWhenUserWroteMessage(String user, Date after, Date before)
    {
        Set<Date> dates = new HashSet<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getUserName().equals(user) && log.getEvent().equals(Event.WRITE_MESSAGE) && !dates.contains(log.getDate()))
            {
                dates.add(log.getDate());
            }
        }
        return dates;
    }

    @Override
    public Set<Date> getDatesWhenUserDownloadedPlugin(String user, Date after, Date before)
    {
        Set<Date> dates = new HashSet<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getUserName().equals(user) && log.getEvent().equals(Event.DOWNLOAD_PLUGIN) && !dates.contains(log.getDate()))
            {
                dates.add(log.getDate());
            }
        }
        return dates;
    }

    @Override
    public int getNumberOfAllEvents(Date after, Date before)
    {
        Set<Event> events = new HashSet<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (!events.contains(log.getEvent()))
            {
                events.add(log.getEvent());
            }
        }
        return events.size();
    }

    @Override
    public Set<Event> getAllEvents(Date after, Date before)
    {
        Set<Event> events = new HashSet<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            events.add(log.getEvent());
        }
        return events;
    }

    @Override
    public Set<Event> getEventsForIP(String ip, Date after, Date before)
    {
        Set<Event> events = new HashSet<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getIp().equals(ip))
            {
                events.add(log.getEvent());
            }
        }
        return events;
    }

    @Override
    public Set<Event> getEventsForUser(String user, Date after, Date before)
    {
        Set<Event> events = new HashSet<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getUserName().equals(user))
            {
                events.add(log.getEvent());
            }
        }
        return events;
    }

    @Override
    public Set<Event> getFailedEvents(Date after, Date before)
    {
        Set<Event> events = new HashSet<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getStatus().equals(Status.FAILED))
            {
                events.add(log.getEvent());
            }
        }
        return events;
    }

    @Override
    public Set<Event> getErrorEvents(Date after, Date before)
    {
        Set<Event> events = new HashSet<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getStatus().equals(Status.ERROR))
            {
                events.add(log.getEvent());
            }
        }
        return events;
    }

    @Override
    public int getNumberOfAttemptToSolveTask(int task, Date after, Date before)
    {
        int i = 0;
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getEvent().equals(Event.SOLVE_TASK) && log.getEventValue().equals(String.valueOf(task)))
            {
                i++;
            }
        }
        return i;
    }

    @Override
    public int getNumberOfSuccessfulAttemptToSolveTask(int task, Date after, Date before)
    {
        int i = 0;
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getEvent().equals(Event.SOLVE_TASK) && log.getEventValue().equals(String.valueOf(task)) && log.getStatus().equals(Status.OK))
            {
                i++;
            }
        }
        return i;
    }

    @Override
    public Map<Integer, Integer> getAllSolvedTasksAndTheirNumber(Date after, Date before)
    {
        Map<Integer, Integer> taskSolved = new HashMap<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getEvent().equals(Event.SOLVE_TASK))
            {
                int task = Integer.parseInt(log.getEventValue());
                if (taskSolved.containsKey(task))
                {
                    taskSolved.put(task, taskSolved.get(task) + 1);
                }else
                {
                    taskSolved.put(task, 1);
                }
            }
        }
        return taskSolved;
    }

    @Override
    public Map<Integer, Integer> getAllDoneTasksAndTheirNumber(Date after, Date before)
    {
        Map<Integer, Integer> taskDone = new HashMap<>();
        ArrayList<Log> logs = getLogsBetweenDates(after, before);
        for (Log log : logs)
        {
            if (log.getEvent().equals(Event.DONE_TASK))
            {
                int task = Integer.parseInt(log.getEventValue());
                if (taskDone.containsKey(task))
                {
                    taskDone.put(task, taskDone.get(task) + 1);
                }else
                {
                    taskDone.put(task, 1);
                }
            }
        }
        return taskDone;
    }
}

level18.lesson10.home07 Друзья, подскажите!

Результат дает верный, но не проходит проверку. Помогите, плиз
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Solution {
    public static void main(String[] args) throws IOException
    {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        List<String> list = new ArrayList<String>();
        Scanner in = new Scanner(new File(reader.readLine()));
        int id = 33;
        while (in.hasNextLine())
        {
            list.add(in.nextLine()); 
        }
        String[] line = new String[0];
        for (int i = 0; i<list.size(); i++)
        {
            line = list.get(i).split(" ");
            if (Integer.parseInt(line[1]) == id)
            System.out.println(list.get(i));
        }
        reader.close();
        in.close();
    }
}
  • ,

level14.lesson08.home09 прошу пояснений

package com.javarush.test.level14.lesson08.home09;

import java.util.ArrayList;
import java.util.List;

/* Валюты
1. Реализуй метод getAmount в классе Money:
1.1. Подумай, какого типа нужно создать приватную переменную, если метод getAmount будет ее возвращать.
1.2. Создай приватную переменную этого типа и верни ее в методе getAmount.
1.3. В конструкторе присвой ей значение, полученное параметром.
2. В отдельном файле создай класс Hrivna.
3. Наследуй класс Hrivna от класса Money.
4. В классе Hrivna реализуй метод getCurrencyName, который возвращает "HRN".
5. В отдельном файле создай класс USD.
6. Наследуй класс USD от класса Money.
7. В классе USD реализуй метод getCurrencyName, который возвращает "USD".
8. Подумай, объекты каких классов можно добавить в список(лист) allMoney.
9. Добавь в конструктор класса Person заполнение листа allMoney объектами всех возможных классов.
*/

public class Solution
{
    public static void main(String[] args)
    {
        Person ivan = new Person("Иван");
        for (Money money : ivan.getAllMoney())
        {
            System.out.println(ivan.name + " имеет заначку в размере " + money.getAmount() + " " + money.getCurrencyName());
        }
    }

    static class Person
    {
        public String name;

        Person(String name)
        {
            this.name = name;
            this.allMoney = new ArrayList<Money>();
            //Add your code here
            !!!    this.allMoney.add(new Hrivna(234534));
            !!!    this.allMoney.add(new USD(534));


        }

        private List<Money> allMoney;

        public List<Money> getAllMoney()
        {
            return allMoney;
        }
    }
}


Вопрос такой: как работают две выделенные восклицательными знаками строчки? Я так понимаю, команда «this.» обращается к соответствующему созданному листу. Что выполняет слово new и цифры внутри скобок?

level15.lesson12.home09

Два дня сидел над задачей. Удалось выполнить все условия задачи, но проверку не проходит. Подскажите, пожалуйста, что не так. Спасибо.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Solution {
    public static void main(String[] args) throws IOException
    {
        //add your code here
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String s = reader.readLine();

        //відрізаємо частину стрічки і виводимо нову стрічку, яка починається після символу "?"
        String stringAfterQuestion = "";
        for (int i = 0; i<s.length(); i++)
        {
            if (s.charAt(i) == '?')
            {
                stringAfterQuestion = s.substring(i+1);
            }
        }

        // розбиваємо текст, що залишився, на частини і додаємо ці частини в масив
        String[] x = stringAfterQuestion.split("&");

        // знаходимо і виводимо на екран список всіх параметрів
        for (int i = 0; i<x.length; i++)
        {
            if (x[i].contains("="))
            {
                System.out.print(x[i].substring(0, x[i].indexOf("=")) + " ");
            }
            else
            {
                System.out.print(x[i] + " ");
            }
        }
        System.out.println("");

        // знаходимо значення параметра obj, передаємо його в метод
        String s1 = "";
        for (int i = 0; i<x.length; i++)
        {
            if (x[i].contains("obj"))
            {
                s1 = x[i].substring(x[i].indexOf('=')+1);
                if (s1.contains("."))
                {
                    alert(Double.parseDouble(s1));
                }
                else
                {
                    alert(s1);
                }
            }
        }
    }

    public static void alert(double value) {
        System.out.println("double " + value);
    }

    public static void alert(String value) {
        System.out.println("String " + value);
    }
}
  • ,

level12.lesson12.bonus03 что не так?

Не могу понять, что в итоге должен выводить метод getMinimumAndIndex?

package com.javarush.test.level12.lesson12.bonus03;

/* Задача по алгоритмам
Написать метод, который возвращает минимальное число в массиве и его позицию (индекс).
*/

import java.util.Arrays;

public class Solution
{
    public static void main(String[] args) throws Exception
    {
        int[] data = new int[]{1, 2, 3, 5, -2, -8, 0, 77, 5, 5};

        Pair<Integer, Integer> result = getMinimumAndIndex(data);

        System.out.println("Minimum is " + result.x);
        System.out.println("Index of minimum element is " + result.y);
    }

    public static Pair<Integer, Integer> getMinimumAndIndex(int[] array)
    {
        if (array == null || array.length == 0)
        {
            return new Pair<Integer, Integer>(null, null);
        }

        //Напишите тут ваше решение
        int min = 0;
        for(int i = 0; i<array.length; i++)
        {
            if (min > array[i])
                min = array[i];
        }

        return new Pair<Integer, Integer>(min, array[min]);
    }


    public static class Pair<X, Y>
    {
        public X x;
        public Y y;

        public Pair(X x, Y y)
        {
            this.x = x;
            this.y = y;
        }
    }
}

Нужна помощь тех,кто уже работает,или купил подписку!

Совсем недавно закончил 10 уровень, пролистал к 15 и тут материя закончилась.Я остался один на один со всеми новыми вопросами.Тут мне пришло в голову, что я так и ничего стоящего написать не могу.Дайте мне масив я отсортирую, выведу в возрозтающем, убивающем порядке.Но ничего действительно ценного я не напишу.У меня вопрос:
Я действительно не создан для етого, или просто слишком мало практики, слишком мало знаний?
Вспомните себя, после окончания бесплатной части.Вы были такие же?(+-)Или уже четко знали как организировать и построить логику приложения?
P.S.мне 15, денег на подписку скорей всего не будет(но шанс есть)Извините за все ошибки, так как русский не мой родной язык.
  • ,

Где найти head first java 2nd edition на руском pdf???

Сколько ж я времени искал но все таки не нашол)Помогите, если есть ссилка или сам файл киньте в комент
А также какие книги прочитать после етой, я читаю Шиллера сейчас.Я на 12 лвл хоть не купил подписку)Просто решаю все задачки из 1-10лвл и на етой черной материи я иду дальше