Вы достигли нового уровня

Начавшаяся в конце 20 века компьютерная революция привела в середине 90-х годов к созданию интернета (веба). И это было началом еще большей революции. Эффект от появления интернета сопоставим с эффектом индустриализации. Но самое вкусное в том, что этот процесс еще находится в самом начале.

Новый мир

Количество сайтов превышает 200 миллионов. Пользователей интернета – 3 миллиарда. Интернет-аукционы, интернет-сайты, интернет-магазины, интернет-услуги. ИТ-экономика растет на 20%-30% ежегодно. Это чудовищные темпы. Но они все не падают и не падают.

За последние 10 лет в Силиконовой Долине (центр ИТ-мира), каждые 2 месяца основывалась компания, впоследствии стоящая миллиард долларов. И это не говоря уже о таких звездах интернета, как Facebook ($220 миллиардов), Amazon ($140 миллиардов) и Google ($350 миллиардов). Все эти компании не появились бы, если бы не было интернета.

Все это приводит к высокому спросу на ИТ-специалистов. Мировой ИТ-экономике требуются: программисты, дизайнеры, тестировщики, архитекторы, менеджера, системные администраторы и другие специалисты.

Хорошо быть айтишником

Если вы ИТ-специалист, то для вас настало золотое время. Вы можете работать на западную компанию, а жить – в небольшом городе или вообще в другой стране. Доходы будут, конечно, меньше чем на западе (обычно раза в два), но выше, чем на местном рынке труда (в 3-10 раз). Чем меньше ваш город, тем заметней разница.

Вы будете получать ценный опыт работы, хорошие деньги и блестящие перспективы. Иногда будете ездить в командировки в офис к работодателю. А если вам там очень понравится, можете туда и переехать.

Прилив поднимает все лодки. Но почему бы вам не оказаться той лодкой, которая находится в нужное время и в нужном месте? Это тоже надо уметь.

Перспективы иммиграции

На западе ИТ-специалисты входят в тройку самых высокооплачиваемых профессий наряду с врачами и юристами. Средние зарплаты программистов около $90 тысяч/год. Но самое интересное в том, что ИТ-профессии отлично подходят для глобального рынка труда.

Что будет, если врач захочет сменить страну? Другая страна – другие медицинские стандарты. С дипломом его страны работать в новой скорее всего не дадут. Придется выучить язык, заново сдать экзамены, пройти практику – долгий путь.

У юристов все еще хуже. В одной стране одни законы, в другой - другие. Тут главнее связи, там - прецедентное право. От хороших юристов из одного места будет мало толку в другом.

ИТ-специалисты. Очень часто напрямую или через посредников работают на крупные западные компании. Те же технологии, те же бизнес-процессы. Вся документация в интернете на английском. Резюме – на английском. Можно переехать в любую страну мира и ничего не поменяется. Даже заказчики/работодатели часто одни и те же.

А зарплаты айтишников в Калифорнии ох как хороши. Вот зачем нужно все время развиваться.

Лучший способ мотивировать себя что-то учить - это заплатить за это деньги. Жадность банально сильнее лени.

- Привет, Амиго!

- День добрый, Элли!

- Сегодня я расскажу тебе о новой интересной сущности – о массивах. Массив – это специальный тип данных, который может хранить не одно значение, а несколько.

- Начну с аналогии. Давай сравним обычный жилой дом и многоэтажку. В обычном доме чаще всего живет одна семья, а многоэтажка разбита на квартиры. Чтобы написать письмо семье, которая живет в обычном доме, надо указать его уникальный адрес. А чтобы написать письмо семье, которая живет в квартире, надо указать уникальный адрес дома и еще номер квартиры.

- Да, тут все понятно.

- Так вот, переменная-массив – это переменная-многоэтажка. В ней можно хранить не одно значение, а несколько. В такой переменной есть несколько квартир (ячеек), к каждой из которых можно обратиться по ее номеру (индексу). Для этого после имени переменной в квадратных скобках надо указать индекс ячейки, к которой обращаемся. Это довольно просто.

- Надеюсь.

- Переменная-многоэтажка (переменная-массив) может быть любого типа, надо лишь вместо «TypeName имя_переменной», написать «TypeName[] имя_переменной».

- Примеры:

for (int i = 0; i < list.length; i++)
{
     System.out.println(list[i]);
}

- Как интересно.

- Переменная-массив требует дополнительной инициализации.

- ?

- Обычную переменную нужно было просто объявить и уже можно присваивать ей различные значения. С массивом все немного сложнее.

- Сначала надо создать контейнер на N элементов, а затем в него уже можно класть значения.

- Ага. Кое-что проясняется.

- Основные факты о массивах:

1) Массив состоит из множества ячеек.

2) Доступ к конкретной ячейке идёт через указание её номера.

3) Все ячейки одного типа.

4) Начальное значение для всех ячеек – null, для примитивных типов – 0, 0.0 (для дробных), false (для типа boolean). Точно такое же, как и у простых неинициализированных переменных.

5) String[] list - это просто объявление переменной. Сначала нужно создать массив (контейнер) и положить его в эту переменную, а потом уже им пользоваться. См. пример ниже.

6) Когда мы создаём объект массив (контейнер), нужно указать, какой он длины – сколько в нем ячеек. Это делается командой вида: new TypeName[n];

- Примеры:

- Привет, Амиго! Давай я покажу тебе, как это все работает в памяти:

- А что это ещё за 345?

- Вообще-то я взял его с потолка, но, по идее, это адрес строки, содержащей слово «Мама».

- С массивами все немного сложнее:

- 155,166,177 – это тоже взятые с потолка числа, символизирующие адреса строк справа?

- Ага. Хорошо, что ты сам догадался. Обрати внимание, тут присутствует дополнительный объект – массив из 10 ячеек.

- Все ясно и понятно, спасибо. Действительно, лучше один раз увидеть. Спасибо, Риша.

- Хочу дать тебе несколько примеров, что интересного можно делать с массивами:

Пример 1.

public class MainClass
{
    public static void main(String[] args) 
    {
        int[] numbers = new int[10];

        for (int i = 0; i < numbers.length; i++)
        {
           numbers[i] = i + 1;
        }
    }
}

public class MainClass
{
    public static void main(String[] args) 
    {
        int[] numbers = new int[10];

        for (int i = 0; i < numbers.length; i++)
        {
           numbers[i] = 10 - i;
        }
    }
}

public class MainClass
{
    public static void main(String[] args) 
    {
        int[] numbers = new int[10];

        for (int i = 0; i < numbers.length; i++)
        {
           numbers[i] = i;
        }
    }
}

public class MainClass
{
    public static void main(String[] args) 
    {
        int[] numbers = new int[10];

        for (int i = 0; i < numbers.length; i++)
        {
           numbers[i] = 9 - i;
        }
    }
}

Пример 2.

public class MainClass
{
  public static void main(String[] args) throws IOException
  {
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    String[] list = new String[10];

    for (int i = 0; i < list.length; i++)
    {
      list[i] = reader.readLine();
     }
  }
}

public class MainClass
{
  public static void main(String[] args) throws IOException
  {
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    int[] list = new int[10];

    for (int i = 0; i < list.length; i++)
    {
      String s = reader.readLine();
      list[i] = Integer.parseInt(s);
    }
  }
}

Пример 3.

public class MainClass
{
    public static void main(String[] args) throws IOException
    {
        int[] list = new int[10];

        //заполнение массива
        for (int i = 0; i < list.length; i++) 
           list[i] = i;

        //вывод на экран
        for (int i = 0; i < list.length; i++)  
          System.out.println(list[i]);
    }
}

Пример 4.

public class MainClass
{
    public static void main(String[] args) throws IOException
    {
        //это статическая инициализация
        int[] list = {5, 6, 7, 8, 1, 2, 5, -7, -9, 2, 0};        
        
        //подсчёт суммы элементов
        int sum = 0;
        for (int i = 0; i < list.length; i++) 
           sum += list[i];

        System.out.println("Sum is " + sum);
    }
}

Пример 5.

public class MainClass
{
    public static void main(String[] args) throws IOException
    {
        int[] list = {5, 6, 7, 8, 1, 2, 5, -7, -9, 2, 0};

        int min = list[0];
        for (int i = 1; i < list.length; i++)
        {
             if (list[i] < min) 
                  min = list[i];
        }

       System.out.println ("Min is " + min);
    }
}

- Привет, Амиго! Вот тебе пара задачек, дружище:

- А вот и я.

- Привет, Элли!

- Сегодня новая интересная тема! Сейчас я расскажу тебе о новом интересном классе – ArrayList.

- О, новый класс? Круто! И что он умеет делать?

- Начну с небольшой предыстории. Программистам очень не нравилось одно свойство массива – его размер нельзя изменять. Что делать, если нужно сохранить в массиве ещё три элемента, а свободное место только одно?

- Единственным решением проблемы нехватки места в массиве было создание массива очень большого размера, чтобы все элементы туда точно поместились. Но это часто приводило к нерациональному расходу памяти. Если чаще всего в массиве хранилось три элемента, но был хотя бы мизерный шанс, что там их будет 100, приходилось создавать массив на 100 элементов.

- И что же придумали программисты?

- Они написали класс ArrayList, который выполнял ту же работу, что и Array (массив), но мог изменять свой размер.

- Интересный ход. И как же они это сделали?

- Внутри каждого объекта типа ArrayList хранится обычный массив элементов. Когда ты считываешь элементы из ArrayList, он считывает их из своего внутреннего массива. Когда записываешь – записывает их во внутренний массив. Вот сравни:

- И в чем же преимущество ArrayList? Как по мне, так код стал длиннее.

- Во-первых, ArrayList поддерживает несколько дополнительных действий, которые очень часто приходится делать программистам во время работы, и которых нет у массива. Например – вставка и удаление элементов из середины массива, и чтобы не оставалось дырок.

- Во-вторых, изменение размера: когда нужно записать во внутренний массив ещё один элемент, а свободного места там нет, то внутри ArrayList делается вот что:

а) создаётся ещё один массив, вдвое большего размера.

б) все элементы из старого массива копируются в новый массив.

в) новый массив сохраняется во внутренней переменной объекта ArrayList, старый массив объявляется мусором (мы просто перестаём хранить на него ссылку).

- А как работать с этим ArrayList’ом?

- А практически так же, как и с массивом. Вот смотри. Давай сравним работу с ArrayList с работой с массивом. Для примера решим такую задачу «ввести 10 строк с клавиатуры и вывести их на экран в обратном порядке» .

- Смотри:

public static void main(String[] args)
{
Reader r = new InputStreamReader(System.in);
BufferedReader reader = new BufferedReader(r);

//ввод строк с клавиатуры
String[] list = new String[10];
for (int i = 0; i < list.length; i++)
{
  String s = reader.readLine();
  list[i] = s;
}

//вывод содержимого массива на экран
for (int i = 0; i < list.length; i++)
{
  int j = list.length - i - 1;
  System.out.println( list[j] );
}
}

public static void main(String[] args)
{
Reader r = new InputStreamReader(System.in);
BufferedReader reader = new BufferedReader(r);

//ввод строк с клавиатуры
ArrayList<String> list = new ArrayList<String>();
for (int i = 0; i < 10; i++)
{
  String s = reader.readLine();
  list.add(s);
}

//вывод содержимого коллекции на экран 
for (int i = 0; i < list.size(); i++)
{
  int j = list.size() - i - 1;
  System.out.println( list.get(j) );
}
}

- Я раскрасил одним цветом эквивалентные действия в обеих колонках.

- С одной стороны все по-другому, с другой – все осталось тем же самым.

- Ага. Только мы теперь не используем квадратные скобочки при работе с ArrayList. Вместо них мы используем методы get, set и add.

- Да, я уже заметил. Но все равно очень похоже.

- Ты опять ничего не делаешь? Ты же робот! Роботы все время чем-то заняты. Вот тебе пара задачек, чтобы ты не расслаблялся. Но для начала – пара подсказок:

- Подсказка 1:

Список (анг. List), чаще всего под этим словом подразумевается ArrayList.

- Подсказка 2:

Строка (анг. String), под этим подразумевается тип String.

- Подсказка 3:

Создать список строк чаще всего означает: ArrayList<String> list = new ArrayList<String>();

- И ещё одна крутая тема.

- Одни сюрпризы. Прямо не день, а день рождения.

- Сегодня я расскажу тебе, что такое Generics. “Дженерики” – это типы с параметром. В Java классы-контейнеры позволяют указывать тип их внутренних объектов.

- Когда мы объявляем generic-переменную, то мы указываем не один тип, а два: тип переменной и тип данных, которые она у себя хранит.

Хороший пример этого – ArrayList. Когда мы создаём новый объект/переменную типа ArrayList, нам удобно указать, значения какого типа будут храниться внутри этого списка.

- Звучит очень интересно. Особенно про любой тип.

- Это только кажется, что это хорошо. На самом деле, если в одном методе в ArrayList кладутся строки, а в другом мы работаем с его содержимым и ожидаем, что там будут только числа, программа упадет (закроется с ошибкой).

- Ясно.

- Пока что мы не будем создавать свои классы с типами-параметрами, но будем использовать чужие.

- А в качестве типа-параметра можно поставить любой класс, даже тот, что напишу я?

- Да, любой тип, кроме примитивных типов. Все классы-параметры должны быть унаследованы от класса Object.

- Т.е. я не могу написать ArrayList<int> ?

- В общем-то, да, не можешь. Но для примитивных типов разработчики языка Java написали их непримитивные аналоги - классы, унаследованные от Object. Вот как это будет выглядеть:

- Примитивные типы и их классы-аналоги (классы-обёртки) можно спокойно присваивать друг другу:

- Отлично. Тогда я думаю, я буду почаще использовать ArrayList.

- Давай-ка я начну с действительно полезных вещей. Сейчас ты увидишь несколько полезных примеров работы с ArrayList и Generics:

- Пример 1:

public static void main(String[] args) throws IOException
{
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in) );
    ArrayList<Integer> list = new ArrayList<Integer>();

    while (true)
    {
        String s = reader.readLine();
        if (s.isEmpty()) break;
        list.add(Integer.parseInt(s));
    }
}

- Пример 2:

public static void main(String[] args) throws IOException
{
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    ArrayList<Integer> list = new ArrayList<Integer>();

    while (true)
    {
        String s = reader.readLine();
        if (s.isEmpty()) break;

        int x = Integer.parseInt(s);
        if (x % 2 == 0)  //проверяем, что остаток от деления на два равен нулю
            list.add(x);          //добавление в конец
        else
            list.add(0, x);      //вставка в начало      
    }
}

- Пример 3:

public static void main(String[] args) throws IOException
{
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in) );
    ArrayList<Integer> list = new ArrayList<Integer>();

    list.add(1);
    list.add(7);
    list.add(11);
    list.add(3);
    list.add(15);

    for (int i = 0; i < list.size(); )  //убрали увеличение i внутрь цикла
    {
        if (list.get(i) > 5)
            list.remove(i);  //не увеличиваем i, если удалили текущий  элемент  
        else
            i++;
    }
}

- Пример 4:

public static void main(String[] args) throws IOException
{
    //статическая инициализация массива
    int[] data = {1, 5, 6, 11, 3, 15, 7, 8};  

    //создание списка, где все элементы должны быть типа Integer 
    ArrayList<Integer> list = new ArrayList<Integer>();   

    //заполнение списка из массива
    for (int i = 0; i < data.length; i++) list.add(data[i]);  

    ArrayList<Integer> even = new ArrayList<Integer>();  //чётные
    ArrayList<Integer> odd = new ArrayList<Integer>();    //нечётные

    for (int i = 0; i < list.size(); i++)
    {
        Integer x = list.get(i);
        if (x % 2 == 0)    //если x - чётное
            even.add(x);   // добавляем x в коллекцию четных чисел  
        else
            odd.add(x);    // добавляем x в коллекцию нечетных чисел
    }
}

- Пример 5:

public static void main(String[] args) throws IOException
{
    ArrayList<Integer> list1 = new ArrayList<Integer>();   //создание списка  
    Collections.addAll(list1, 1, 5, 6, 11, 3, 15, 7, 8);   //заполнение списка

    ArrayList<Integer> list2 = new ArrayList<Integer>();
    Collections.addAll(list2, 1, 8, 6, 21, 53, 5, 67, 18);

    ArrayList<Integer> result = new ArrayList<Integer>();

    result.addAll(list1);   //добавление всех значений из одного списка в другой
    result.addAll(list2);

    for (Integer x : result)   //быстрый for по всем элементам, только для коллекций
    {
        System.out.println(x);
    }
}

- Круто. И что Диего даст мне сейчас кучу аналогичных задач, да?

- Ага!

- Наконец-то ты освободился. Устал уже держать в уме твои задачи. Вот тебе ещё парочка, чтобы не расслаблялся:

- Я нашёл мои “замечательные” лекции! Так что сегодня ты станешь обладателем “ценнейшего знания” по массивам и спискам. Вот они:

Дополнительные материалы к уровню 7

- Привет, Амиго! Рад, что ты со всем этим справился – ты заслужил награду:

- Здорово, боец!

- Здравия желаю, капитан Бобров!

- У меня для тебя шикарная новость. Вот тебе задания для закрепления полученных навыков. Выполняй их каждый день, и твои навыки будут расти с неимоверной скоростью. Они специально разработаны для выполнения их в Intellij IDEA.

- Те задания были для духов. Для дедушек я добавил бонусные задания повышенной сложности. Только для старослужащих.