Поможем в ✍️ написании учебной работы

Имя

Поможем с курсовой, контрольной, дипломной, рефератом, отчетом по практике, научно-исследовательской и любой другой работой

Выберите тип работыЧасть дипломаДипломная работаКурсовая работаКонтрольная работаРешение задачРефератНаучно - исследовательская работаОтчет по практикеОтветы на билетыТест/экзамен onlineМонографияЭссеДокладКомпьютерный набор текстаКомпьютерный чертежРецензияПереводРепетиторБизнес-планКонспектыПроверка качестваЭкзамен на сайтеАспирантский рефератМагистерская работаНаучная статьяНаучный трудТехническая редакция текстаЧертеж от рукиДиаграммы, таблицыПрезентация к защитеТезисный планРечь к дипломуДоработка заказа клиентаОтзыв на дипломПубликация статьи в ВАКПубликация статьи в ScopusДипломная работа MBAПовышение оригинальностиКопирайтингДругое

Нажимая кнопку "Продолжить", я принимаю политику конфиденциальности

Лекция 2. Происхождение языка Java

Происхождение Java

Язык Jаvа тесно связан с языком С++, который, в свою очередь, является прямым наследником языка С. Многие особенности Jаvа унаследованы от обоих этих языков. От С язык Jаvа унаследовал свой синтаксис, а многие его объектно-ориентированные свойства были перенесены из С++.

К концу 1980-х и в начале 1990-х гг. объектно-ориентированное программирование на С++ стало основной методикой программирования. И в течение некоторого, хотя и непродолжительного периода времени казалось, что программисты наконец изобрели идеальный язык. Ведь язык С++ сочетает в себе высокую эффективность и стилистические элементы языка С наряду с объектно-ориентированным подходом, и поэтому его можно было использовать для создания самых разных программ.

Над разработкой языка Java работали целые группы американских программистов из компании Sun Microsystems, Inc, впоследствии поглощенной компанией Oracle. В 1995 году впервые публично было объявлено о создании Java.

Как ни странно, первоначальной побудительной причиной для создания языка Java послужил совсем не Интернет, а потребность в независящем от конкретной платформы (т.е. архитектурно - нейтральном) языке, который можно было бы использовать для создания программного обеспечения, встраиваемого в различные бытовые электронные устройства, в том числе микроволновые печи и устройства дистанционного управления.

В контроллерах таких устройств применяются разнотипные процессоры. Но трудность применения С и С++ (как и большинства других языков) состоит в том, что написанные на них программы должны компилироваться для конкретной платформы. И хотя программы на С++ могут быть скомпилированы практически для любого типа процессора, тем не менее, для этого потребуется наличие полного компилятора С++, предназначенного для данного конкретного процессора. Компилятор – это программа, которая переводит программу на писанную на языке программирования в машинный код.

Интерпретатор языка программирования (interpreter) - программа или технические средства, необходимые для выполнения других программ, вид транслятора, который осуществляет пооператорную (покомандную, построчную) обработку и выполнение программы или запроса.

Но дело в том, что создание компиляторов обходится дорого и отнимает немало времени. Поэтому требовалось более простое и экономически выгодное решение. Пытаясь найти такое решение, Гослинг и другие разработчики начал работ над переносимым, не зависящим от конкретной платформы языком, который можно было бы использовать для создания кода, пригодного для выполнения на разнотипных процессорах в различных средах. И в конечном итоге их усилия привели к созданию языка Java. Примерно в то время, когда определялись основные характеристики языка Java, появился второй, еще более важный фактор, который должен был сыграть решающую роль в судьбе этого языка. И этим вторым фактором, конечно же, стала Всемирная паутина (веб). Если бы формирование веб не происходило почти одновременно с реализацией языка Java, он мог бы остаться полезным, но незамеченным языком программирования бытовых электронных устройств. Но с появлени­ем веб язык jаvа вышел на передний край разработки языков программирования, поскольку среда веб также нуждалась в  переносимых программах.

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

 

Установка Java

Для работы программ на языке Java на целевой машине должна быть установлена JRE (Java Runtime Environment – среда выполнения). JRE представляет минимальную реализацию виртуальной машины, а также библиотеку классов. Поэтому, если мы хотим запускать программы, то нам надо установить JRE. Для каждой конкретной платформы имеется своя версия JRE.

Однако, так как мы собираемся не только запускать программы, но и разрабатывать их, нам потребуется специальный комплект для разработки JDK (Java Development Kit). JDK уже содержит JRE, а также включает ряд дополнительных программ и утилит, в частности компилятор Java - javac.

Есть несколько типов платформ Java. Базовую функциональность обеспечивает стандартная версия языка Java SE (Standard Edition – стандартная версия). Она предназначена для создания небольших приложений в масштабах малого предприятия.

Кроме того, существует платформа Java EE (Enterprise Edition – версия для предприятий), которая нацелена на создание более сложных приложений и в комплект которой входит веб-сервер Glassfish.

Для наших целей будет достаточно Java SE, поэтому мы можем загрузить и установить соответствующую версию JDK с официального сайта Oracle: http://www.oracle.com/technetwork/java/javase/downloads/index.html

При открытии сайта мы видим последнюю официально выпущенную версию Java. В данном случае Java SE 8 (u144 – update 144).

Нажимаем на кнопку DOWNLOAD:

 

 

В открывшемся окне появится список JDK под различные платформы. Перед тем как начать скачивание соответствующей версии JDK выберите кнопку Accept License Agreement. А затем выбираем версию JDK под установленную на компьютере операционную систему. Рекомендуется установить jdk-8u144-windows-i586.exe (под 32 битную windows).

Начнётся процесс загрузки выбранного файла на компьютер.

После окончания загрузки запустите процесс установки — дважды щелкните кнопкой мыши по загруженному файлу. Произойдет запуск мастера установки. Например, на компьютере под управлением Windows будет создан следующий каталог: C:\Program Files (x86)\Java\jdk1.8.0_144.

Следуйте указаниям мастера установки — просто нажимайте кнопки Next, Install и Finish в появляющихся на экране окнах. В течение нескольких минут установка Java на компьютер будет завершена.

Но на этом установка Java не завершена!

Теперь необходимо задать две системные переменные. Например, В Windows 10 нажмите кнопку Пуск -> Параметры-> Система-> О системе-> Сведения о системе -> Дополнительные параметры системы. Или же Панель управления –> Система и безопасность –> Система –> Дополнительные параметры системы. Откроется окно, представленное ниже. В нем нажмите кнопку Переменные среды.

 

Ниже приведено изображение окна с настройками для Windows 10. Так выглядит окно, которое содержит все системные переменные, которые есть в системе:

 

 

Нажмите нижнюю кнопку Создать и объявите переменную Path (если она не объявлена), которая поможет Windows найти пакет JDK на вашем компьютере. Тщательно проверьте путь к каталогу, в который была произведена установка Java (C:\Program Files (x86)\Java\jdk1.8.0_144\bin). Если переменная Path уже существует, просто добавьте путь к каталогу Java в Значение переменной:

 

 

Также объявите переменную CLASSPATH. В качестве ее значения укажите точку, за которой следует точкa с запятой (.;). Данная системная переменная поможет Java найти ваши программы. Точка означает, что Java начнет поиск ваших программ в текущем каталоге. Точка с запятой всего лишь играет роль разделителя, за которыми могут идти другие каталоги.

 

 

Ну вот, установка пакета JDK завершена!

Чтобы проверить, что JDK установлена на компьютере верно, в командной строке наберите java – version

 

Каким бы ни был текущий каталог, вы увидите установленную на компьютере версию java !!!

Шаг 3 – запуск программы

 

Теперь, запустим программу. В том же командном окне введите  следующую команду:

Java HelloWorld

 

 

Обратите внимание, что в этот раз вы использовали программу  java, а не javac. Данная программа входит в среду выполнения JRE (Java Runtime Environment)  и она запускает JVM,  в которую загружает вашу программу HelloWorld.

Помните,  что  язык Java чувствителен  к  регистру,  это  значит,  что  если  вы  назвали  программу  HelloWorld с  заглавной  буквой  H и  с  заглавной  буквой  W,  не  пытайтесь  запустить  программу  helloworld или helloWorld – JVM будет жаловаться, что, мол, не нахожу файл.  

 

Установка Eclipse IDE

Откройте веб-сайт https://www.eclipse.org/home/index.php

Нажмите кнопку IDE & Tools . Откроется страничка, приведённая ниже.

На этой странице нажмите ссылку Java EE . Откроется страничка, приведённая ниже.

 

Нажмите на ссылку Windows 32- bit . Откроется страничка, приведённая ниже.

Нажмите на кнопку DOWNLOAD . Начнётся загрузка на ваш компьютер файла eclipse - jee - oxygen - R - win 32. zip

Теперь нужно просто  распаковать этот файл на диск  C:. Для этого щелкните  правой кнопкой мыши по  архиву. Выберите пункт  Извлечь все…

Установка Eclipse выполнена. Для удобства создайте ярлык для Eclipse.  Щелкните  правой  кнопкой  по  рабочему  столу.  В  появившемся  меню  последовательно  выберите  пункты  Создать -> Ярлык -> Обзор  и  выберите  в  папке C:\eclipse файл ec l ipse.exe. Чтобы  запустить  программу, дважды щелкните по синему значку Eclipse.

 

При первом  запуске  Eclipse  будет  открыто  окно  с  просьбой  указать  расположение  рабочей  области  (workspace) — каталога,  в  котором  будут храниться файлы ваших программ.

 

В поле Workspace («Рабочая область») укажите удобное для вас место на  диске, например  D:\Workspace (создайте папку на диске, который не является системным).  Если такой папки нет, то она будет автоматически создана.

Если  вы  не  хотите,  чтобы  Eclipse каждый  раз  при  запуске  просила  вас  указать  рабочую  область,  установите  флажок  Use this as the default and do not ask again («Использовать это значение по умолчанию в дальнейшем»). Нажмите  кнопку  OK.  

Если в процессе работы со средой вам необходимо сменить рабочую область, то выполните File -> Switch WorkSpace -> Other . Появиться окно, в котором можно указать нужную директорию.

После  запуска  Eclipse открывается  начальная  страница  Welcome. Внешний  вид  этого  окна незначительно  меняется  с  каждой  сборкой Eclipse.

 

 

 

Закрываем эту страницу.

Проверьте выбор нужной платформы Java по команде Window -> Perspective -> Open Perspective -> Other -> Java (для работы с Java SE) или Java EE (для работы с Java EE). Соответствующая кнопка появится справа окна.

 

 

Чтобы  начать  работать  над  программой,  необходимо  создать  новый  проект. Чтобы  создать  новый  проект  в Eclipse,  выберите  следующие  пункты  меню  File («Файл»), New («Создать»), Java Project («Проект Java»).  В  результате  откроется  окно New Java Project («Создание  проекта Java»). Теперь  необходимо  ввести  имя  нового  проекта,  например,  My First Project.

 

Чтобы создать новый файл проекта выберите File->New->Class

 

 

Появится окно

 

в котором необходимо ввести имя класса (оно же и имя файла) и установить галочку автоматического создания метода (функции) public static void main ( String [] args ) и нажать Finish .

После написания программы, приведённой на картинке ниже,

 

 

её необходимо запустить. Для этого

 

 

 

Внизу появится окно Console, в котором появится результат работы программы. Или можно нажать на зелёную кнопку Run в панели вверху.

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

 

                                                                                                                            

 

 

ДЗ – создать проект AboutMe , в котором написать программу, выдающую на экран информацию следующего вида:

 

Я, Ф.И.О. студента, обязуюсь не пропускать занятия по дисциплине «Алгоритмизация и программирование». В случае несоблюдения данного обязательства, даю согласие на использование меня как бесплатной рабочей силы.

 

 

Пример программы:

public static void main(String[] args) {

        char ch1 , ch2 ;

        ch1= 88 ; // кодсимвола Х

        ch2 ='У' ;

        System.out.print( " chl и ch2 :" ) ;

        System.out.println( ch1 + " " + ch2 ) ;//x y

 

  }

 

double d;

d=Math.pow(8, (double)1/3);

System.out.println(d) ;//2.0

 

Пример: Написать программу, вычисляющую корень квадратный из числа, которое вводится с клавиатуры

import java.util.*;

 

public class HelloWorld {

 

public static void main(String[] args) {

         

     double x,y;

         

     Scanner in=new Scanner(System.in);

     System.out.print("Введите значение х=");

     x=in.nextDouble();

     y=Math.pow(x,(double)1/2);

     System.out.println("Корень квадратный из "+x+" ="+y);

     in.close();

 

}

 

 

 

Пример: Предыдущая программа, только с форматированием данных

import java.util.*;

import static java.lang.Math.*;

public class HelloWorld {

 

public static void main(String[] args) {

     double x,y;

     Scanner in=new Scanner(System.in);

     System.out.print("Введите значение х=");

     x=in.nextDouble();

     y=pow(x,(double)1/2);

     System.out.printf("Корень квадратный из %5.2f = %5.2f",x,y);

     in.close();

}

}

ДЗ. Попробовать работу программы с разными символами преобразования.

Оператор условия

Одним из фундаментальных элементов многих языков программирования являются условные конструкции. Данные конструкции позволяют направить работу программы по одному из путей в зависимости от определенных условий. В языке Java используются следующие условные конструкции: if..else и switch..case

 

Конструкция if/else

Выражение if/else проверяет истинность некоторого условия и в зависимости от результатов проверки выполняет определенный код:

int num1 = 6; int num2 = 4; if(num1>num2){ System.out.println("Первое число больше второго"); }

После ключевого слова if ставится условие. И если это условие выполняется, то срабатывает код, который помещен в далее в блоке if после фигурных скобок. В качестве условий выступает операция сравнения двух чисел.

Так как, в данном случае первое число больше второго, то выражение num1 > num2 истинно и возвращает значение true. Следовательно, управление переходит в блок кода после фигурных скобок и начинает выполнять содержащиеся там инструкции, а конкретно метод System.out.println("Первое число больше второго");. Если бы первое число оказалось бы меньше второго или равно ему, то инструкции в блоке if не выполнялись бы.

Но что, если мы захотим, чтобы при несоблюдении условия также выполнялись какие-либо действия? В этом случае мы можем добавить блок else:

 

int num1 = 6; int num2 = 4; if(num1>num2){ System.out.println("Первое число больше второго"); } else{ System.out.println("Первое число меньше второго");

Но при сравнении чисел мы можем насчитать три состояния: первое число больше второго, первое число меньше второго и числа равны. С помощью выражения else if, мы можем обрабатывать дополнительные условия:

 

int num1 = 6; int num2 = 8; if(num1>num2){ System.out.println("Первое число больше второго"); } else if(num1<num2){ System.out.println("Первое число меньше второго"); } else{ System.out.println("Числа равны"); }

Также мы можем соединить сразу несколько условий, используя логические операторы:

int num1 = 8; int num2 = 6; if(num1 > num2 && num1>7){ System.out.println("Первое число больше второго и больше 7"); }

Здесь блок if будет выполняться, если num1 > num2 равно true и одновременно num1>7 равно true.

Конструкция switch

Конструкция switch/case аналогична конструкции if/else, так как позволяет обработать сразу несколько условий:

 

int num = 8; switch(num){ case 1: System.out.println(" число равно 1"); break; case 8: System.out.println(" число равно 8"); num++; break; case 9: System.out.println(" число равно 9"); break; default: System.out.println(" число не равно 1, 8, 9"); }

После ключевого слова switch в скобках идет сравниваемое выражение. Значение этого выражения последовательно сравнивается со значениями, помещенными после оператора сase. И если совпадение будет найдено, то будет выполняться определенный блок сase.

В конце блока сase ставится оператор break, чтобы избежать выполнения других блоков. Например, если бы убрали бы оператор break в следующем случае:

case 8: System.out.println(" число равно 8"); num++; case 9: System.out.println(" число равно 9"); break;

то так как у нас переменная num равно 8, то выполнился бы блок case 8, оператор break отсутствует, то начал бы выполняться блок case 9.

Если мы хотим также обработать ситуацию, когда совпадения не будет найдено, то можно добавить блок default, как в примере выше. Хотя блок default необязателен.

Начиная с JDK 7 в выражении switch..case кроме примитивных типов можно также использовать строки:

package firstapp; import java.util.Scanner; public class FirstApp { public static void main(String[] args) { Scanner in = new Scanner(System.in); System.out.println("Введите Y или N: "); String input= in.nextLine(); switch(input){ case "Y": System.out.println("Вы нажали букву Y"); break; case "N": System.out.println("Вы нажали букву N"); break; default: System.out.println("Вы нажали неизвестную букву"); } } }

Решение квадратного уравнения:

double a,b,c,d;

     Scanner in=new Scanner(System.in);

     a=in.nextDouble();

     b=in.nextDouble();

     c=in.nextDouble();

     d=b*b-4*a*c;

     if (d<0) System.out.println("корней нет!!!!");

     else

           if (d==0)

                System.out.println("x1=x2="+(-b/(2*a)));

           else

           {

                double x1,x2;

                x1=(-b+sqrt(d))/(2*a);

                x2=(-b-sqrt(d))/(2*a);

                System.out.printf("x1=%5.2f x2=%5.2f",x1,x2);

           }

Операторы цикла

Цикл используется тогда, когда нужно выполнить какую-либо конструкцию кода многократно, определенное количество раз (либо до выполнения какого-либо условия).

Операторы цикла
• for
• while
• do … while

Цикл for
• Обычно состоит из 3-х частей
• Некоторые части могут быть пропущены (например, инициализация переменной вне цикла)

                 Инициализация   условие    итерация(шаг)
for (int i = 0; i < 10; i++) {
System. out.println("i = " + i);

}

 

Цикл while
• Используется, когда заранее может быть неизвестно количество шагов
• Отличие от цикла for – проверку условия можно выполнять как в начале итерации, так и в конце

int i = 0;// инициализация
// условие
while (i < 10) {
System. out.println("i = " + i);
i++;// итерация ( шаг )

}

 

Цикл do…while

Хотя бы один раз выполнится

int i = 0; //инициализация
do {
i ++; //итерация (шаг)
System . out . println (" i = " + i );
} while ( i <10); //условие

Операторы break и continue
• break – выход из цикла, даже если не все шаги выполнены
• Также может использоваться и в других конструкциях (например, switch)
• continue – переход к следующему шагу (даже если текущий не завершен)
• Операторы могут использоваться в обоих типах циклов: for и while

1. Написати програму, обчислюючу y=tg(x)+tg(x²)+…+tg(x¹⁰), х– задається з клавіатури.

2. Обчислити p= , n>2

3. Написати програму для підрахунку n!

 

4. Написати програму виведення значень функції y= , x – задається з клавіатури.

5. Написати програму виведення значень функції y=sin(x)+cos(x)-tg(x²),

x Є [0, π/2], крок зміни x h=0.5.

Подготовка к контрольной работе

Решение разных типов задач

Y=

х – вводится с клавиатуры, у – вычисляется.

double x,y=0;

Scanner in=new Scanner(System.in);

System.out.print("Введите х=");

x=in.nextDouble();

if (x<=-3) {

y=cos(x)*sqrt(sin(x));

}

if (x>-3 && x<0) {

y=(pow(x,3)-3)/pow(x+2.5,2);

}

if (x>0 && x<4) {

y=sqrt(7-x*x);

}

if (x>5) {

y=log(x)*pow(sin(x),2);

}

if (x>=4 && x<=5) {

System.out.println("Функция не определена!!!");

in.close();

return;

}

System.out.printf("При х=%5.3f y=%5.3f",x,y);

in.close();

 

Массивы

Массивом называется множество однотипных объектов, объединенных одним именем и доступ к каждому объекту в этом множестве осуществляется по порядковому номеру (индексу).

Если переменные предназначены для хранения одиночного значения, то массив представляет набор однотипных значений.

Объявление массива похоже на объявление переменной:

тип_данных название_массива[] , либо тип_данных[] название_массива.

 

Например,

int nums[];

char[] stroka;

 

Создание массива производится с помощью следующей конструкции:

new тип_данных[количество_элементов] ,

где new - ключевое слово, выделяющее память для указанного в скобках количества элементов.

 

Например,

int nums[] = new int[4]; - в этом выражении создается массив из четырех элементов int

При создании пустого массива элементам присваиваются значения в зависимости от типа данных массива:

§ для int - 0

§ для float, double - 0.0

§ для String - значение null

§ для char - \0

§ для boolean - значение false

 

После создания массива мы можем обратиться к любому его элементу и изменить его:

int[] nums = new int[4];

nums[0] = 1;

nums[1] = 2;

nums[2] = 4;

nums[3] = 100;

 

System.out.println(nums[3]);

 

Отсчет элементов массива начинается с 0, поэтому в данном случае, чтобы обратиться к четвертому элементу в массиве, нам надо использовать выражение nums[3].

И так как у нас массив определен только для 4 элементов, то мы не можем обратиться, например, к шестому элементу: nums[5] = 5;. Если мы так попытаемся сделать, то мы получим ошибку.

 

В предыдущем примере мы сначала создали массив, а потом по отдельности проинициализировали каждый его элемент. Однако есть и альтернативные пути инициализации массивов:

 

// эти два способа равноценны

int[] nums2 = new int[] { 1, 2, 3, 5 };

 

int[] nums3 = { 1, 2, 3, 5 };

 

Предлагаем теперь Вам ответить какая длина у этих 3 массивов?

Важнейшее свойство, которым обладают массивы, является свойство length, возвращающее длину массива, то есть количество его элементов: int length = nums.length;

Для вывода содержимого массива нужно использовать цикл for или foreach!

for(int i=0;i<nums.length;i++)

System.out.println(nums[i]);

 

Цикл foreach

В этом разделе мы познакомимся с циклом foreach. Он позволяет более просто записать проход по всем элементам массива. Внешне он очень похож на цикл for, но имеет ряд особенностей и ловушек, с которыми мы сейчас познакомимся. Рассмотрим простой пример — инициализация массива и вывод всех его элементов. Обратите внимание на форму записи цикла.

int[] sample = {12, 56, 7, 34, 89, 43, 23, 9};   // выводим элементы в цикле foreach for (int t : sample) { System.out.println(t);

Самой главной в этом примере является строка for (int t : sample). Эту запись можно интерпретировать следующим образом — цикл проходит по всем элементам массива, каждый раз помещая в переменную t значение следующего элемента массива. Т.е. при каждом проходе цикла в переменной t последовательно будет появляться значение sample[0], sample[1], sample[2] и т.д.

Цикл выглядит более компактно и пользоваться им удобно. Но существует важная особенность, о которой надо обязательно помнить. Я только что ее проговорил, но повторю еще раз: «при каждом проходе цикла в переменной t последовательно будет появляться значение». Иными словами, в переменную t КОПИРУЕТСЯ значение из элемента массива. Таким образом получается, что перменная t и переменная sample[0] — это РАЗНЫЕ переменные. Рассмотрим более сложный пример:

int[] sample = new int[5];   System.out.println("До foreach"); // выводим элементы в цикле foreach - их значение 0 for (int t : sample) { System.out.println(t); }   // Думаем, что происходит инициализация for (int t : sample) { t = 99; }   System.out.println("После foreach"); // выводим элементы в цикле foreach - снова 0 for (int t : sample) System.out.println(t);

При запуске этого примера мы можем увидеть, что элементы массива остались такими, какими и были — равными 0. Для инициализации придется использовать обычную конструкцию.

 

int[] sample = new int[5];   System.out.println("До foreach"); // выводим элементы в цикле foreach - их значение 0 for (int t : sample) { System.out.println(t); } // Для инициализации элементов foreach не подходит for (int i = 0; i < sample.length; i++) { sample[i] = 99; } System.out.println("После foreach"); // выводим элементы в цикле foreach - теперь 99 for (int t : sample) { System.out.println(t); }

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

 

Напишите программу, которая должна имитировать раздачу карт для игры в покер. Программа получает число n, задаваемое с консоли пользователем, и раздает карты на n игроков (по 5 карт каждому) из рассортированной колоды. Разделяйте пять карт, выданных каждому игроку, пустой строкой.

 

import java.util.Scanner;

public class Deal {

public static void main(String[] args) {

 

// часть 1 - инициализацияпеременных

int cardsPlayer = 5;

int players =0 ;      

               

String[] suits = {

                  "Пик", "Бубен", "Черв", "Треф"

              };

String[] rank = {

                       "2", "3", "4", "5", "6", "7", "8", "9", "10",

                       "Валет", "Королева", "Король", "Туз"

              };

               

int n = suits.length * rank.length; // количествокарт

               

// часть 2 - ввод с консоли

for(;;){

    Scanner sc = new Scanner(System.in);

    System.out.println("Введите количество игроков: ");  

    if(sc.hasNextInt()){

    players = sc.nextInt();

    if (players ==0){

              System.out.println("Игра прекращена.");

              break;

              }

    if (players<0){

              System.out.println("Число игроков не может быть меньше 0");

              break;

              }

    if(cardsPlayer * players <= n){

              break;

              } else {

                       System.out.println("Слишком много игроков!");

                       }

     }else{

              System.out.println("Вы ввели не число!");

       }

}

// часть 3 - инициализацияколоды

String[] deck = new String[n];

for (int i = 0; i < rank.length; i++) {

for (int j = 0; j < suits.length; j++) {

    deck[suits.length*i + j] = rank[i] + " " + suits[j];

}

}

               

// часть 4 - перетасовкаколоды

for (int i = 0; i < n; i++) {

int r = i + (int) (Math.random() * (n-i)); // случайнаякарта в колоде

String temp = deck[r];

deck[r] = deck[i];

deck[i] = temp;

}

               

// часть 5 - перетасованнаяколодавыводитсянаэкран

for (int i = 0; i < players * cardsPlayer; i++) {

System.out.println(deck[i]);

if (i % cardsPlayer == cardsPlayer - 1)

    System.out.println();

}

}

}

Комментарии к задаче:

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

Что самое сложное? Тасовка карт. Но оно в целом основывается на задаче смене местами элементов массива. Но в прошлой задачи мы "переворачивали", а в этой меняться местами должны случайные карты. Случайные карты - значит будем использовать (псевдо)случайные числа.

Еще сложным может показаться процес верификации (то есть определение, большое число или нет, и число ли это вообще) числа с консоли - часть 2.

 

Итак, разберем все части по порядку:

Часть 1 - инициализация переменных. Мы создаем переменные:

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

players - объявляем переменную и временно задаем ей значение 0. Если этого не сделать, часть, в которой работаем с консолью (часть 2) будет работать неисправно.

Массив suits - хранит масти карт.

Массив rank - хранит ранги карт. Обратите внимание: это массив строк String, и элементы "2", "3", "4" и другие - тоже строки, к ним нельзя обращаться как к числовым значениям.

n - хранит общее количество карт в колоде. Для того, чтобы посчитать, сколько в колоде карт, умножаем количество мастей на количество рангов ( длину массива suits на длину массива rank).

Часть 2 - верификация введенной переменной. Эта часть в целом должна быть Вам знакома из решения других задач. Ее общий смысл - попросить ввести параметр заново, если он неправильно задан с консоли. Например, наш параметр - количество людей. Он не может быль меньше нуля. Он не может быть равным строке, и мы должны убедиться, что карт в колоде хватит на всех игроков. Для этого использованы условия if.

Часть 3 - инициализация колоды. Создается новый массив deck, который хранит полные названия карт "Дама Треф", "Король Пик" и т.д. Названия создаются с помощью конкатенации названий рангов и названий мастей.

Часть 4 - перетасовываем колоду. Как уже говорилось, принцип очень похож на предыдущую задачу. В этом блоке создается цикл, в котором каждая карта в колоде по очереди меняется местами с другой картой, которая определяется случайно с помощью Math.random().

Часть 5 - раздаем карты. Как в покере карты просто раздаются сверху перетасованной колоды, так и в программе - берется подряд по пять карт для каждого игрока. Цикл выполняется 5*количество_игроков раз, и через каждые 5 карт ставит пустую строку:

if (i % carsPlayer == cardsPlayer - 1) { System.out.println(); }

Тут нет простого и понятного " if ( i%5 == 0 ) ", потому что i начинается с 0. Если так написать, первому игроку досталось бы 6 карт. Постоянный остаток от деления тут равен не 0, а 4 (т.е. cardsPlayer - 1).

 

 

 

Для работы с массивами в библиотеке классов Java в пакете java.util определен специальный класс Arrays. С его помощью мы можем производить ряд операций над массивами.

 

Копирование массивов

Массивы, также как и переменные, мы можем присваивать:

int[] numbers = new int[] { 1, 2, 3, 5 }; int[] figures = numbers;   figures[2]=30; System.out.println(numbers[2]); // равно 30

Здесь два массива, второму присваивается первый массив. Однако на самом деле при присвоении переменная figures будет хранить ссылку на область в памяти, где находится массив. В итоге и figures и numbers будут указывать на один и тот же массив, и если мы изменим элемент в массиве figures figures[2]=30, то изменится и массив numbers, так как это фактически один и тот же массив. Чтобы такой проблемы избежать, надо использовать копирование массивов.

Для копирования используется метод Arrays.copyOf:

 

import java.util.Arrays; public class Program { public static void main(String[] args) { int[] numbers = new int[] { 1, 2, 3, 5 }; int[] figures = Arrays.copyOf(numbers, numbers.length); figures[2]=30; System.out.println(numbers[2]); // равно 3 } }

Метод Arrays.copyOf(numbers, numbers.length) принимает два параметра: первый параметр - массив, который надо скопировать, а второй параметр - сколько элементов надо скопировать.

Сортировка

С помощью метода Arrays.sort можно отсортировать массив:

// элементы массива в произвольном порядке int[] numbers = new int[] { 1, 7, 3, 5, 2, 6, 4 };   Arrays.sort(numbers);   // в цикле выводим все элементы массива по порядку for(int i=0;i<numbers.length;i++) System.out.println(numbers[i]);

Многомерные массивы

Многомерный массив в Java по сути является массивом из массивов. Т.е. Вы создаете массив, внутри которого находятся указатели на одномерные массивы — массив массивов.

Популярным примером использования такого рода массивов, являются матрицы, для представления которых, используются двумерные массивы. Итак, что же такое матрица и как ее представить с помощью двумерного массива в Java.

Матрица это прямоугольная таблица, состоящая из строк и столбцов на пересечении которых находятся её элементы. Количество строк и столбцов матрицы задают ее размер.

Общий вид матрицы размером m x n ( m — количество строк, n — количество столбцов), выглядит следующим образом:

 

Это математическая нумерация строк и столбцов. В программировании всё нумеруется с 0. Каждый элемент матрицы имеет свой индекс, где первая цифра обозначает номер строки на которой находится элемент, а вторая — номер столбца.

Рассмотрим примеры конкретных матриц и создадим их с помощью Java.

Матрица A имеет размерность 2 на 3 (2 строки, 3 столбца).

Нумерация элементов матрицы А в программировании:

 

Создадим двухмерный массив этой размерности:

int[][] matrixA= new int[2][3];

 

Для доступа к элементам двумерного массива необходимо использовать 2 индекса: первый для строки, второй – для столбца. Как и в случае с одномерными массивами, индексы также начинаются с нуля. Поэтому нумерация строк и столбцов в таблице начинается с 0.

matrixA[0][0] = 1;

matrixA[0][1] = -2;

matrixA[0][2] = 3;

matrixA[1][0] = 4;

matrixA[1][1] = 1;

matrixA[1][2] = 7;

 

Для того, чтобы вывести матрицу на консоль, нужно пройти все элементы, используя два цикла. Количество циклов, при прохождении элементов массива, равно его размерности. В нашем случае первый цикл осуществляется по строкам, второй — по столбцам. Первый цикл for перебирает каждую строку двумерного массива, второй цикл for перебирает столбцы в этой строке.

 

for (int i = 0; i < 2; i++) {

for (int j = 0; j < 3; j++) {

   System.out.print(matrixA[i][j] + "\t");

}

System.out.println();

}

Или

for (int i = 0; i < matrixA.length; i++) {

for (int j = 0; j < matrixA[i].length; j++) {

   System.out.print(matrixA[i][j] + "\t");

}

System.out.println();

}

 

То есть, сначала выводим все элементы первой строки, отделяя их символом табуляции "\t", переносим строку и выводим все элементы второй строки.

Чтобы организовать генерацию элементов матрицы и сразу же вывод на экран, надо:

        for (int i = 0; i < 2; i++) {

               for (int j = 0; j < 3; j++) {

               matrixA[i][j]=(int)(Math.random()*11)-5;

           System.out.print(matrixA[i][j] + "\t");

 

               }

          System.out.println();

        }

 

Для матрицы B воспользуемся упрощенным способом инициализации — в момент объявления. По аналогии с одномерными массивами.

int[][] matrixB = {

{-9,1,0},

{4,1,1},

{-2,2,-1}

};

Каждую строку массива необходимо заключить в пару фигурных скобок и отделить друг от друга запятой.

Полностью код для матрицы B:

public class Matrix {

 

public static void main(String[] args) {

 

        int[][] matrixB = {

                    {-9,1,0},

                    {4,1,1},

                    {-2,2,-1}

        };                     

 

        for (int i = 0; i < 3; i++) {

               for (int j = 0; j < 3; j++) {

               System.out.print(matrixB[i][j] + "\t");

               }

               System.out.println();

           }

}

}

 

Задачи на двумерные массивы

1. Создайте массив размерностью 5 на 6 и заполните его случайными числами (в диапазоне от 0 до 99 ). Выведите на консоль третью строку

2. Знайти мінімальний елемент матриці K(3,5) і його індекс.

3. Всі елементи матриці М(4,5) з непарними значеннями замінити на 1, а з парними - на 0.

4. Даны матрицы С и D размерностью 3 на 3 и заполненные случайными числами в диапазоне от 0 до 99. Выполните сложение матриц. Выведете исходные матрицы и результат вычислений на консоль.

5. Просуммируйте все элементы двумерного массива

6. Знайти суму елементів головної та побічної діагоналі матриці А(5,5).

7. Елементи 1-го та 3-го рядка матриці поміняти місцями.

Строки в JAVA

Строка — это упорядоченная последовательность символов. В Java строка является основным носителем текстовой информации. Для работы со строками здесь используются следующие классы: String, StringBuilder, StringBuffer.

String

Для создания и манипулирования строками Java платформа предоставляет общедоступный финальный (не может иметь подклассов) класс java.lang.String. Данный класс является неизменяемым (immutable) — созданный объект класса String не может быть изменен. Можно подумать, что методы имеют право изменять этот объект, но это неверно. Методы могут только создавать и возвращать новые строки, в которых хранится результат операции. То есть при любых операциях над строкой, которые изменяют эту строку, фактически будет создаваться новая строка.

Создание строк

String str1 = "Java";

String str2 = new String(); // пустая строка

String str3 = new String ("Java");

String str4 = new String(new char[] {'h', 'e', 'l', 'l', 'o'});

String str5 = new String(new char[]{'w', 'e', 'l', 'c', 'o', 'm', 'e'}, 3, 4);//3 -начальный //индекс, 4 -кол-во символов come

Поскольку строка рассматривается как набор символов, то мы можем применить метод length() для нахождения длины строки или длины набора символов:

String str1 = "Java";

System.out.println(str1.length()); // 4

 

Соединение строк

Для соединения строк можно использовать операцию сложения ("+"):

String str1 = "Java";String str2 = "Hello";String str3 = str1 + " " + str2;System.out.println(str3); // Java Hello

 

При этом если в операции сложения строк используется нестроковый объект, например, число, то этот объект преобразуется к строке:

String str3 = "Год " + 2015;

 

Фактически же при сложении строк с нестроковыми объектами будет вызываться метод valueOf() класса String. Данный метод имеет множество перегрузок и преобразует практически все типы данных к строке. Для преобразования объектов различных классов метод valueOf вызывает метод toString() этих классов.

Другой способ объединения строк представляет метод concat():

String str1 = "Java";String str2 = "Hello";str2 = str2.concat(str1); // HelloJava

 

Метод concat() принимает строку, с которой надо объединить вызывающую строку, и возвращает соединенную строку.

 

Еще один метод объединения - метод join() позволяет объединить строки с учетом разделителя. Например, выше две строки сливались в одно слово "HelloJava", но в идеале мы бы хотели, чтобы две подстроки были разделены пробелом. И для этого используем метод join():

String str1 = "Java";String str2 = "Hello";String str3 = String.join(" ", str2, str1); // Hello Java

Метод join является статическим. Первым параметром идет разделитель, которым будут разделяться подстроки в общей строке, а все последующие параметры передают через запятую произвольный набор объединяемых подстрок - в данном случае две строки, хотя их может быть и больше

 

Модификация строк

Модификация строк не является модификацией как таковой. Дело в том, что объекты класса String после создания уже нельзя изменять. Но можно создать копию строки с изменениями. Именно это и делают следующие методы.

toLowerCase() — преобразовать строку в нижний регистр;
toUpperCase() — преобразовать строку в верхний регистр;
trim() — отсечь на концах строки пустые символы;

 

Пример

String str = " Я помню ЧУДНОЕ мгновенье "; //убрали символы пробела в начале и конце строкиstr = str.trim();//я помню чудное мгновеньеSystem.out.println(str.toLowerCase()); //Я ПОМНЮ ЧУДНОЕ МГНОВЕНЬЕSystem.out.println(str.toUpperCase());

Пример. Проверить, является ли введённое слово из 5 букв палиндромом. Если введённое слово не из 5 букв, то сообщать об ошибке. Программа должна обрабатывать ситуации, если регистр букв отличается и считать палиндромами слова вида «Комок», «РОТОР»

 

Scanner in=new Scanner (System.in);

    System.out.print("Введите слово из 5 букв:");

    String word=in.next();

    if (word.length()!=5) {

    System.out.println("Условие не выполнено!!!");

    return;

    }

    word=word.toLowerCase();//словопреобразуем в нижнийрегистр

    int n=word.length();

    boolean flag=false;

    for(int i=0; i<n/2;i++)

     if (word.charAt(i)!=word.charAt(n-1-i))

               {flag=false;

                break;

               }

               

    if (flag)    

               System.out.print("Слово - палиндром");

    else

    System.out.print("Слово - не палиндром");         

Пример. Ввести с клавиатуры 3 строки и подсчитать в них количество различных букв для 33 букв алфавита). Вывести результат на экран.
Пример вывода:
а 5
б 8
в 3
г 7
…
я 9

char[] alphabet=new char[33];

for(int i=0;i<32;i++)

   {

       alphabet[i]=(char)('а'+i);//задаём алфавит русских букв

   }

alphabet[32]='ё';//добавляем букву ё

for (int i=0;i<alphabet.length;i++) {

   System.out.print(alphabet[i]+" ");//выводим алфавит

}

System.out.println();

 

String[] text=new String[] {"Привет всем","Хороший день сегодня","Пора идти в колледж"};//задаём строки

int count;//кол-во повторов буквы

for (int i=0; i<alphabet.length;i++) {

    count=0;

    for (String t:text) {

              String s=t.toLowerCase();//строку переводим в нижний регистр

              for (int j=0; j<s.length();j++)

                       if (alphabet[i]==s.charAt(j))                                                                      count++;

                       }

                       System.out.println(alphabet[i]+" - \t"+count);

              }

Пример. Написать программу, которая вводит с клавиатуры строку текста. Программа заменяет в тексте первые буквы всех слов на заглавные.
Пример ввода:
мама мыла раму.
Пример вывода:
Мама Мыла Раму.

Scanner in=new Scanner (System.in);

System.out.print("Введите строку:");

String text=in.nextLine();

char[] a = text.toCharArray();

a[0] = Character.toUpperCase(a[0]);

     for (int i=1;i<a.length;i++)

               if (a[i]!=' ' && a[i-1]==' ')

                        a[i]=Character.toUpperCase(a[i]);

     a.toString();

     System.out.print(a);

 

Character – класс для работы с отдельными символами

String replace ( char oldChar , char newChar ), replace ( CharSequence target , CharSequence replacement ) — замена в строке одного символа или подстроки на другой символ или подстроку.

Вспомним пример, где нужно было поменять в строке символы пробела на точки и перепишем его с использованием replace:

String str = "1 000 000 000";String newStr = str.replace(" ", ".");System.out.println(newStr);// 1.000.000.000

 

Поиск в строке

boolean contains(CharSequence s) — проверяет, содержит ли строка заданную последовательность символов и возвращает true или false.

Пример.

String s = "www.mysite.com";boolean isContain1 = s.contains("mysite");System.out.println(isContain1);// нашел - выведет true boolean isContain2 = s.contains("mysite.ru");System.out.println(isContain2);// не нашел - выведет false

 

boolean endsWith(String suffix) — проверяет завершается ли строка определенными символами и возвращает true или false.

Пример.

String s = "www.mysite.com"; //проверяем заканчивается ли строка суффиксом "com" boolean isComEnding = s.endsWith("com"); System.out.println(isComEnding);//выведет true //проверяем заканчивается ли строка суффиксом "ru" boolean isRuEnding = s.contains("ru"); System.out.println(isRuEnding);//выведет false

 

boolean startsWith(String prefix) или startsWith(String prefix, int toffset) — проверяет, начинается ли строка с определенных символов. Во втором случае можно указать позицию, с которой необходимо начать поиск префикса.

Пример.

String s = "www.mysite.com"; //Проверяем, начинается ли адрес с wwwboolean isWWW = s.startsWith("www"); if(isWWW){/* Eсли да, проверяем начинается ли имя сайтас "my". Поскольку адрес начинается с wwwпроверку начинаем с 4 символа*/boolean isNameStarts = s.startsWith("my", 4);}else{/* Eсли нет, проверяем начинается ли имя сайтас "my". Поскольку адрес не начинается с wwwпроверку производим с начала строки*/boolean isNameStarts = s.startsWith("my");}

int indexOf(int ch), indexOf(int ch, int fromIndex), indexOf(String str), indexOf(String str, int fromIndex) — метод indexOf применяется для поиска первого вхождения указанного символа в строке или первого вхождения указанной подстроки. Поиск также можно произвести с указанием позиции в строке от которой нужно начинать искать. Для поиска нужно указать соответствующие параметры. Метод возвращает число соответствующее индексу первого вхождения символа или подстроки. В случае отсутствия указанного символа или подстроки в строке, будет возвращена -1.

Пример

String data = "name:Igor\nsurname:Kolashnikov\nage:14\ntime:14:55";//разбиваем строку на несколько подстрок на основании// встречаемого символа новой строкиString[]lines=data.split("\n"); //проходим каждую подстрокуfor (String line : lines){ //находим индекс первого вхождения символа ":" в подстроке int pos = line.indexOf(":"); //вычленяем имя атрибута из подстроки String attributeName= line.substring(0,pos); //вычленяем значение атрибута String value = line.substring(pos+1,line.length()); //вывод на экран вычлененных значений в нужном нам формате. System.out.println(attributeName + " - " + value);}

int lastIndexOf(int ch), lastIndexOf(int ch, int fromIndex), lastIndexOf(String str), lastIndexOf(String str, int fromIndex) — аналогично предыдущему случаю, только ищется последнее вхождение символа или подстроки в строке.

 

Сравнение строк

В отличие от сравнения числовых и других данных примитивных типов для строк не применяется знак равенства ==. Вместо него надо использовать метод equals().

boolean equals(Object anObject) — проверяет идентичность строк. Возвращает true только в том случае, если в строках представлена одинаковая последовательность символов одной величины.

equalsIgnoreCase() (без учета регистра)

Пример

String str = "Я помню ЧУДНОЕ мгновенье";

String str2 = "я помню чудное мгновенье";

//строки не идентичны

System.out.println(str.equals(str2)); //false

 

//строки идентичны после перевода первой строки

//в нижний регистр

System.out.println(str.toLowerCase().equals(str2)); // true

 

Пример(уже делали) 2-й способ. Проверить, является ли введённое слово из 5 букв палиндромом. Если введённое слово не из 5 букв, то сообщать об ошибке. Программа должна обрабатывать ситуации, если регистр букв отличается и считать палиндромами слова вида «Комок», «РОТОР»

 

Scanner in=new Scanner (System.in);

    System.out.print("Введите слово из 5 букв:");

    String word=in.next();

    if (word.length()!=5) {

    System.out.println("Условие не выполнено!!!");

    return;

    }

            

    char[] word_two=new char[word.length()];

    for (int j=0,i=word.length()-1;i>=0;i--,j++)

    {word_two[j]=word.charAt(i);}

 

//Метод .toString() возвращает представление класса + хэшкод объекта в //шестнадцатиричном представлении, поэтому использовать word_two.toString() нельзя

 

    String word_three=new String(word_two);//так получаем из массива строку

        

    if (word.toLowerCase().equals(word_three.toLowerCase()))    

               System.out.print("Слово - палиндром");

    else

          System.out.print("Слово - не палиндром");

int compareTo ( String anotherString ), int compareToIgnoreCase ( String str ) — так же проверяет идентичность строк, однако, в отличии от метода equals возвращает:

· нулевое значение, если строки равны,

· целое отрицательное число, если первая строка предшествует второй

· целое положительное число, если первая строка следует за второй

 

Данный метод предназначен для упорядочивания строк. Он позволяет сравнить строки между собой и определить предшествующую строку. Для того, чтобы реализовать такое сравнение метод сравнивает числовые значения букв.

Рассмотрим пример с именами «Маша» и «Миша». При сравнении этих двух имен, метод compareTo укажет, что имя «Маша» предшествует имени «Миша» (выдав отрицательное число) или наоборот, «Миша» следует за «Маша» (выдав положительное число). При упорядочивании имен по алфавиту мы бы упорядочили эти имена именно так. Метод в данном случае определяет, что числовое значение буквы «а» в «Маша» меньше, чем числовое значение «и» в Миша.

 

Пример

String name1 = "Маша";

String name2 = "Миша";

System.out.println(name1.compareTo(name2)); //-8

System.out.println(name2.compareTo(name1)); //8

 

Однако, в случае, если мы напишем «маша» с маленькой буквы и попробуем сравнить с «Миша», то получим положительное число.

System.out.println("маша".compareTo("Миша")); //32

 

То есть в данном случае имя «Миша» предшествует имени «маша». Это происходит потому, что в таблице символов Юникода буквы верхнего регистра предшествуют нижнему.

Для сравнения строк без учета регистра символов используется функция int compareToIgnoreCase(String str)

System.out.println("маша".compareToIgnoreCase("Миша")); //-8

 

Как мы видим, при сравнивании «маша» с «Миша» мы снова получаем отрицательное значение, то есть «маша» предшествует имени «Миша».

Примеры:

Дан список студентов группы. Отсортировать его по алфавиту.

String[] students= {"Иванов Сергей","Иващенко Андрей","Иващенко Антон","Айнагоз Степан","Иванов Серхио","Белоусов Дмитрий"};

System.out.println("Список студентов до сортировки:");

int i=0;

for (String st:students) {

    i++;  

    System.out.println(i+" "+st);

}

boolean change=true;

while (change) {

    change=false;

    for(i=0;i<students.length-1;i++) {

    if (students[i].compareTo(students[i+1])>0) {

              String temp=students[i];

              students[i]=students[i+1];

              students[i+1]=temp;

              change=true;

    }

}

}

System.out.println("Список студентов по алфавиту:");

i=0;

for (String st:students) {

i++;  

System.out.println(i+" "+st);

}

           

 

Регулярные выражения Regular Expressions

Регулярные выражения – эта система обработки текста, основанная на специальной системе записи образцов для поиска. Образец (pattern), задающий правило поиска, по-русски также иногда называют «шаблоном», «маской». Сейчас регулярные выражения используются многими текстовыми редакторами и утилитами для поиска и изменения текста на основе выбранных правил. Язык программирования Java также поддерживает регулярные выражения для работы со строками.

Например, при помощи регулярных выражений можно задать шаблоны, позволяющие: найти все последовательности символов «кот» в любом контексте, как то: «кот», «котлета», «терракотовый»; найти отдельно стоящее слово «кот» и заменить его на «кошка»; найти слово «кот», которому предшествует слово «персидский» или «чеширский»; убрать из текста все предложения, в которых упоминается слово кот или кошка.

A .toString();

System. out .print( a );

2 вариант

1. Дано слово. Поменять местами его первую и последнюю буквы

 

String str1 = " мама " ;

char [] str = str1 .toCharArray();

char temp = str [0];

str [0]= str [ str1 .length()-1];

str [ str1 .length()-1]= str [0];

String str3 = new String( str );

System. out .println( str3 );

 

2. Задана строка. Сформировать из её три строки. Первая должна содержать только знаки операций отношения, вторая – скобки, третья – цифры.

3. Даны две строки, содержащие значения двух годов "2017" и "2018". Создать третью строку, содержащую в качестве значения сумму этих годов "4035"

String str1 = "2017" ;

String str2 = "2018" ;

int st =Integer.parseInt( str1 )+Integer.parseInt( str2 );

String str3 =Integer.toString( st );

System. out .println( str3 );

4.

Методы в Java

Если переменные и константы хранят некоторые значения, то методы содержат собой набор операторов, которые выполняют определенные действия.

Общее определение методов выглядит следующим образом:

 

[модификаторы] тип_возвращаемого_значения название_метода ([параметры]){

// тело метода

}

 

Модификаторы и параметры необязательны.

По умолчанию главный класс любой программы на Java содержит метод main, который служит точкой входа в программу:

 

public static void main(String[] args) {

System.out.println("привет мир!");

}

 

Ключевые слова public и static являются модификаторами. Далее идет тип возвращаемого значения. Ключевое слово void указывает на то, что метод ничего не возвращает.

Затем идут название метода - main и в скобках параметры метода - String[] args. И в фигурные скобки заключено тело метода - все действия, которые он выполняет.

Создадим еще пару процедур:

 

// определение первого метода

static void method1(){

System.out.println("Method1");

}

 

//определение третьего метода

void method2(){

System.out.println("Method2");

}

 

Условно методы, которые не возвращают никакого значения, называются процедурами.

Кроме void методы в Java могут возвращать конкретное значение. Такие методы, также условно называют функциями. Например:

int factorial(){

return 1;}

String hello(){

return "Hell to World";

}

 

В функции в качестве типа возвращаемого значения вместо void используется любой другой тип. В данном случае тип int и тип String. Функции также отличаются тем, что мы обязательно должны использовать оператор return, после которого ставится возвращаемое значение.

При этом возвращаемое значение всегда должно иметь тот же тип, что значится в определении функции. И если функция возвращает значение типа int, то после оператора return стоит целочисленное значение (как в данном случае число 1), которое неявно является объектом типа int.

 

Public class Solution

{

public static void main(String[] args) throws Exception

{

   int[] array = initializeArray();

   int max = max(array);

   System.out.println(max);

}

public static int[] initializeArray() throws IOException {

   int[] numbers = new int[20];

   BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

   for (int i =0; i < numbers.length; i++)

   numbers[i] = Integer.parseInt(reader.readLine());

   return numbers;

}

public static int max(int[] array) {

   int max = array[0];

   for (int i = 0; i < array.length; i++)

   if (array[i] > max)

   max = array[i];

   return max;

}

}

 

При вызове функции в качестве формальных параметров ей передаются КОПИИ фактических значений, поэтому все манипуляции с этими параметрами не будут влиять на значения фактических параметров.

Пример:

Написать функцию, которая меняет местами значения двух переменных:

public static void swap(int a, int b)

{

       int c=a;

       a = b;

       b = c;

}

     

public static void main(String args[]) {

       int a = 4;

       int b = 5;

       swap(a,b);

       System.out.println("a = "+a+" b = "+b);

     

}

Результата не даст (как было а=4 и b=5 так и останется)

 Надо создавать классы – обёртки, потому что классы передаются в методы по ссылке, а не по значению.

static class Int

{

       int a;

}

public static void swap(Int a, Int b)

{

       int c=a.a;

       a.a = b.a;

       b.a = c;

}

     

public static void main(String args[]) {

       Int a = new Int();

       Int b = new Int();

       a.a=4;

       b.a=5;

       swap(a,b);

       System.out.println("a = "+a.a+" b = "+b.a);

}

 

Консольный калькулятор

Необходимо написать простой консольный калькулятор на Java.

§ Метод int getInt() - должен считывать с консоли целое число и возвращать его

§ Метод char getOperation() - должен считывать с консоли какое-то значение и возвращать символ с операцией (+, -, * или /)

§ Метод int calc(int num1, int num2, char operation) - должен выполнять над числами num1 и num2 арифметическую операцию, заданную operation.

§ Метод main() - должен считывать 2 числа (с помощью getInt()), считать операцию (с помощью getOperation(), передать все методу calc() и вывести на экран результат.

 

Простейший вариант

static int getInt()

{

     Scanner in = new Scanner(System.in);

     System.out.print("Введите число: ");

     int num = in.nextInt();

     return num;

}

    

static char[] getOperation() {

     Scanner in = new Scanner(System.in);

     System.out.print("Введите знак операции: ");

     char[] ch = in.next().toCharArray();

     return ch;

}

    

static int calc(int num1, int num2, char operation)

{

     int result = 0;

     switch (operation)

     {

     case '+' : result = num1 + num2; break;

     case '-' : result = num1 - num2; break;

     case '*' : result = num1 * num2; break;

     case '/' : result = num1 / num2; break;

     }

     return result;

}

    

     public static void main(String args[]) {

           int num1 = getInt();

           char[] ch = getOperation();

           int num2 = getInt();

     int rez = calc(num1, num2, ch[0]);

           System.out.println("Ответ: " + rez);

}

 

С проверками (ДЗ)

static int getInt()

{

     int num = 0;

     for(;;)

     {

     Scanner in = new Scanner(System.in);

     System.out.print("Введите число: ");

     if (in.hasNextInt()) {

     num = in.nextInt();

           break;

     }

     else System.out.println("Ошибка ввода!");

     }

return num;

}

    

static char getOperation() {

     String s = null;

     char[] ch = null;

     for(;;)

     {

     Scanner in = new Scanner(System.in);

     System.out.print("Введите знак операции: ");

     s = in.next();

     if (s.equals("+") || s.equals("-") || s.equals("*") || s.equals("/")) {

           ch = s.toCharArray();

           break;

     }

     else System.out.println("Ошибка ввода!");

     }

     return ch[0];

}

    

static int calc(int num1, int num2, char operation)

{

     int result = 0;

     switch (operation)

     {

     case '+' : result = num1 + num2; break;

     case '-' : result = num1 - num2; break;

     case '*' : result = num1 * num2; break;

     case '/' : result = num1 / num2; break;

     }

     return result;

}

    

     public static void main(String args[]) {

           int num1 = getInt();

           char ch = getOperation();

           int num2 = getInt();

           int rez = calc(num1, num2, ch);

           System.out.println("Ответ: " + rez);

}

 

 

Перегрузка методов

В программе мы можем использовать методы с одним и тем же именем, но с разными типами и/или количеством параметров. Такой механизм называется перегрузкой методов.

Перегрузка методов - это возможность создавать несколько методов с одинаковым названием, но разными параметрами. Не все языки программирования позволяют это делать. Перегрузка методов - это часть такой составляющей ООП, как полиморфизм.

public class HelloWorld {

public static void main(String[] args) {

       

   int n1 = getSum(20,10);

   System.out.println(n1);

        

   double n2 = getSum(20.3, 30.4, 9.8);

   System.out.println(n2);

}

static int getSum(int x, int y){

        

return x+y;

}

static double getSum(double x, double y, double z){

        

return x+y+z;

}

static double getSum(double x, double y){

        

return x+y;

}

}

 

Здесь у нас есть три варианта метода getSum(), но при его вызове в зависимости от типа и количества передаваемых параметров система выберет именно ту версию, которая наиболее подходит.

Параметры переменной длины

Метод может принимать параметры переменной длины одного типа. Например, нам надо передать в метод массив и вычислить сумму чисел этого массива:

public static void main(String[] args) {

 

int n1 = getSum(20,10);

System.out.println(n1); // 30

int n2 = getSum(20, 34, 9, 5);

System.out.println(n2); // 68

int n3 = getSum();

System.out.println(n3); // 0

}

static int getSum(int ...nums){

 

int result =0;

for(int x:nums)

result+=x;

return result;

}

 

Троеточие перед названием параметра int ...nums указывает на то, что он будет необязательным и будет представлять массив. Мы можем передать в метод getSum одно число, несколько чисел, а можем вообще не передавать никаких параметров. Причем, если мы хотим передать несколько параметров, то необязательный параметр должен указываться в конце:

public static void main(String[] args) {

 

int n1 = getSum("Welcome!", 20,10);

System.out.println(n1); // 30

int n3 = getSum("Hello World!");

System.out.println(n3); // 0

}

static int getSum(String message, int ...nums){

 

System.out.println(message);

int result =0;

for(int x:nums)

result+=x;

return result;

}

 

Рекурсивные функции

Рекурсивная функция может вызывать саму себя.

Например, рассмотрим функцию, определяющую факториал числа:

 

static int factorial(int x){

 

if (x == 1){

 

return 1;

}

else{

 

return x * factorial(x - 1);

}

}

Еще одним распространенным примером рекурсивной функции служит функция, вычисляющая числа Фибоначчи. В теории n-й член последовательности Фибоначчи определяется по формуле:

f(n)=f(n-1) + f(n-2), причем f(0)=0, а f(1)=1.

 

static int fibonachi(int n){

 

if (n == 0){

return 0;

}

if (n == 1){

return 1;

}

else{

return fibonachi(n - 1) + fibonachi(n - 2);

}

}

 

В программу калькулятор добавить рекурсию (ДЗ):

 

static Scanner in = new Scanner(System.in);

    

static int getInt()

{

     int num;

     System.out.print("Введите число: ");

     if (in.hasNextInt()) {

           num = in.nextInt();

     }

     else

           {

           System.out.println("Ошибка ввода!");

           in.next();

           num = getInt();

           }

return num;

}

    

static char getOperation() {

String s = null;

     char ch;

     System.out.print("Введите знак операции (+, -, *, /): ");

     s = in.next();

     if (s.equals("+") || s.equals("-") || s.equals("*") || s.equals("/")) {

           ch = s.charAt(0);

     }

     else

           {

           System.out.println("Ошибка ввода!");

           ch = getOperation();

           }

     return ch;

}

    

static int calc(int num1, int num2, char operation)

{

     int result = 0;

     switch (operation)

     {

     case '+' : result = num1 + num2; break;

     case '-' : result = num1 - num2; break;

     case '*' : result = num1 * num2; break;

     case '/' : result = num1 / num2; break;

     }

     return result;

}

    

     public static void main(String args[]) {

           int num1 = getInt();

           char ch = getOperation();

           int num2 = getInt();

           int rez = calc(num1, num2, ch);

           System.out.println("Ответ: " + rez);

}

 

      

ArrayList vs. Array

Versus — латинское слово, означающее «против». Часто сокращается до vs или v.

 

Допустим, Вы работаете программистом на компанию, которая осуществляет доставку товаров по всему миру. И Вам необходимо сохранить список городов, в которые осуществляется доставка.

Вы это можете сделать 2 способами:

1. С помощью обычного массива

2. С помощью Arraylist

 

1. С ПОМОЩЬЮ ОБЫЧНОГО МАССИВА

Создаем обычный массив с именем deliveryCities. В фигурных скобках прописываем значения элементов массива, то есть названия городов. Например:

String [] deliveryCities = {"Chicago", "New York", "Toronto", "Paris"}

Но что, если мы хотим добавить еще один город для доставки, например, London?

String [] deliveryCities2 = new String[deliveryCities.length + 1];

for (int i = 0; i < deliveryCities.length; i++) {

deliveryCities2[i] = deliveryCities[i];

}

deliveryCities2[deliveryCities.length] = "London";

 

Это достаточно неудобно.

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

 

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

Они написали класс ArrayList, который выполняет ту же работу, что и Array, но может изменять свой размер, добавлять, удалять, заменять элементы массива в любое время и в любом месте. Arraylist, как резиновый, его можно увеличивать или уменьшать безо всяких проблем.

Как это работает?

Когда в ArrayList нужно добавить еще один элемент и нет свободного пространства, внутри ArrayList происходит следующее:

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

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

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

 

Arraylist - это так называемый объектный тип, который входит в Java Core, а именно java.util.ArrayList.

Создать список можно несколькими способами. Наиболее распространенным способом является следующая структура:

Но будьте внимательные: ArrayList не умеет работать с примитивными типами. Поэтому если Вы хотите сохранять примитивные типы, Вам нужно использовать классы-оболочки для соответствующих типов. Для типа int класс-оболочка Integer, для типа double – Double и т.д.

 

 

Примеры использования методов:

 

ArrayList <String> deliveryCities = new ArrayList<>();

 

deliveryCities.add(“Chicago”);

deliveryCities.add(“New York”);

deliveryCities.add(“Toronto”);

deliveryCities.add(“Paris”);

deliveryCities.add(1, "Mariupol");//на первую позицию

Все элементы, которые находятся после нового индекса, автоматически сдвинутся.

 

deliveryCities.add(0, "Paris");//в начало списка

deliveryCities.get(2);// Chicago

deliveryCities.indexOf("New York")); // 3

deliveryCities.indexOf("Amsterdam")); // -1, т.к. его нет в списке

 

Таким образом с помощью метода indexOf можно узнать, есть ли такой элемент в списке. Кроме этого, для этих целей существует отдельный метод contains(Object o), который:

¾ возвращает true, если элемент хотя бы один раз встречается в списке;

¾ возвращает false, если такого элемента нет.

Обратите внимание, что в ArrayList элементы могут повторяться (скажем, могут быть 2 города «New York»), и если вам нужно узнать не просто, есть ли такой элемент, а конкретное число вхождений, то вам придется пробегать весь массив и сравнивать каждый элемент с искомым, либо же воспользоваться сторонними классами.

deliveryCities.set(2, "Berlin");//заменяем Chicago на Berlin

deliveryCities.remove(1); // удалит Mariupol

deliveryCities.remove("Mariupol");

если таких элементов несколько, то метод удалит только первый из них. Для удаления всех элементов сначала нужно опять же использовать цикл. Если же нам нужно удалить все элементы списка, мы можем использовать метод clear().

 

ПОДЫТОЖИМ

Когда же использовать обычные массивы, а когда ArrayList?

Массивы используются, когда:

¾ заранее известно точное количество элементов

¾ не будут добавляться/удаляться элементы

ArrayList используют во всех остальных случаях.

Мы рассмотрели самые распространенные методы. Если же Вас интересуют все методы ArrayList, – изучите официальную страничку документации от Oracle: https://docs.oracle.com/javase/7/docs/api/java/util/ArrayList.html

 

Task.

1. Create a list of strings.

2. Add 5 different strings to the list.

3. Display to the screen its size.

4. Display to the screen contents of the list. Each value should be on a new line. Use a loop.

 

import java.util.ArrayList;

import java.io.BufferedReader;

import java.io.InputStreamReader;

public class Solution

{

public static void main(String[] args) throws Exception

{

   ArrayList<String> list = new ArrayList<String>();

   BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));

   for (int i = 0; i < 5; i++)

   {

       list.add(buf.readLine());

     }

   System.out.println("Size of list is "+ list.size());

   for (int i = 0; i < list.size(); i++)

    System.out.println(list.get(i));

 

}

}

 

Task.

1. Create a list of strings.

2. Add 5 strings to the list. «101», «102», «103», «104», «105».

3. Delete the first one, the middle one and the last one.

4. Display to the screen contents of the list. Each value should be on a new line. Use a loop.

5. Display to the screen its size. (After deleting one entry, the indexes of other entries change. For instance, if we delete first element, the second becomes the first one).

 

import java.util.ArrayList;

public class Solution

{

public static void main(String[] args) throws Exception

{

ArrayList<String> list = new ArrayList<String>();

     

for (int i = 101; i<=105; i++)

   list.add(String.valueOf(i));

       

list.remove(0);

list.remove(list.size()-1);

list.remove(list.size()/2);

     

for (int i =0; i< list.size(); i++)

System.out.println(list.get(i));

     

System.out.println(list.size());

}

}

 

Task.

1. Create a list of strings.

2. Read 5 strings from keyboard, then add them to the list.

3. Arrange them in reverse order.

4. Display to the screen contents of the list. Each value should be on a new line. Use a loop.

 

import java.util.ArrayList;

import java.io.BufferedReader;

import java.io.InputStreamReader;

 

public class Solution

{

public static void main(String[] args) throws Exception

{

   ArrayList<String> list = new ArrayList<String>();

   BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));

   for (int i = 0; i < 5; i++)

   {

          list.add(buf.readLine());//добавляет в конец списка

   }

       

   for (int i = 0; i < list.size()/2; i++)

   {

       String temp = list.get(i);

       list.set(i, list.get(list.size()-1-i));//set() – это замена одного эл-та на другой

       list.set(list.size()-1-i, temp);

   }

   for (int i = 0; i < list.size(); i++)

   {

       System.out.println(list.get(i));

   }

}

Task.

1. Create a list of strings.

2. Read from keyboard 5 strings. Add these strings to the list.

3. Delete the last string and add it to the beginning of the list. Repeat this action 13 times.

4. Display to the screen contents of the list. Each value should be on a new line. Use a loop.

 

import java.util.ArrayList;

import java.io.BufferedReader;

import java.io.InputStreamReader;

 

public class Solution

{

public static void main(String[] args) throws Exception

{

   ArrayList<String> list = new ArrayList<String>();

   BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));

   for (int i = 0; i < 5; i++)

   {

       list.add(buf.readLine());//добавляет в конец списка

   }

       

   for (int i=0; i<13; i++)

   {

   String temp = list.get(list.size()-1);

   list.add(0,temp);

   list.remove(list.size()-1);

   }

   for (int i = 0; i < list.size(); i++)

   {

       System.out.println(list.get(i));

   }

}

}

 

Task

1. Create a list of strings.

2. Read from the keyboard 5 strings. Add these strings to the beginning of the list, not to the end.

3. Display to the screen contents of the list. Each value should be on a new line. Use a loop.

 

import java.util.*;

import java.io.BufferedReader;

import java.io.InputStreamReader;

public class Solution

{

public static void main(String[] args) throws Exception

{

   ArrayList<String> list = new ArrayList<String>();

    BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));

       for (int i = 0; i < 5; i++)

       {

       String s = buf.readLine();

           list.add(0,s);

       }

   for (int i = 0; i < list.size(); i++)

   {

       System.out.println(list.get(i));

   }

}

}

 

 

Task.

1. Create a list of strings.

2. Add 5 different strings to the list.

3. Display to the screen its size.

4. Display to the screen contents of the list. Each value should be on a new line. Use a loop.

 

Task.

1. Create a list of strings.

2. Add 5 strings to the list. «101», «102», «103», «104», «105».

3. Delete the first one, the middle one and the last one.

4. Display to the screen contents of the list. Each value should be on a new line. Use a loop.

5. Display to the screen its size. (After deleting one entry, the indexes of other entries change. For instance, if we delete first element, the second becomes the first one).

 

Task.

1. Create a list of strings.

2. Read 5 strings from keyboard, then add them to the list.

3. Arrange them in reverse order.

4. Display to the screen contents of the list. Each value should be on a new line. Use a loop.

 

Task

1. Create a list of strings.

2. Read from the keyboard 5 strings. Add these strings to the beginning of the list, not to the end.

3. Display to the screen contents of the list. Each value should be on a new line. Use a loop.

СР по ArrayList

Заполнить список случайными целыми числами. Вывести его на экран. Найти первое отрицательное число в этом списке. Все числа, стоящие до него занести во второй список, а все числа, стоящие после него – в третий список. Списки вывести на экран.

Ответы на СР по ArrayList :

1- е задание

import java.util.ArrayList;

 

public class Main {

    static void outList (ArrayList<Integer> list) {

              for (int now:list )

                       System.out.print(now + "\t");

              System.out.println();

    }

        

static void fillList(ArrayList <Integer> list, int many) {

    for (int i=0; i<many;i++)

              list.add((int)(Math.random()*51)-25);

}

    public static void main(String[] args) {

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

              fillList(list,10);

              System.out.println("Before:");

              outList(list);

              int minindex = 0, maxindex= 0, min = list.get(0), max = list.get(0);

              for (int i=1; i<list.size();i++) {

                       if (list.get(i)<min) {

                                 min = list.get(i);

                                 minindex = i;

                       }

                       if (list.get(i)>max) {

                                 max = list.get(i);

                                 maxindex = i;

                       }

              }

                       list.set(maxindex, min);

                       list.set(minindex, max);

                       System.out.println();

                  System.out.println("After:");

                       outList(list);

    }

 

}

2-е задание

import java.util.ArrayList;

 

public class Main {

    static void outList (ArrayList<Integer> list) {

              for (int now:list )

                       System.out.print(now + "\t");

              System.out.println();

    }

        

static void fillList(ArrayList <Integer> list, int many) {

    for (int i=0; i<many;i++)

              list.add((int)(Math.random()*51)-25);

}

 

static void reverse(ArrayList<Integer> list) {

    int temp = 0;

    for (int i =0, j = list.size()-1; i<j; i++,j--) {

              temp = list.get(i);

              list.set(i,list.get(j));

              list.set(j,temp);

    }

}

    public static void main(String[] args) {

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

              fillList(list,10);

              System.out.println("Before:");

              outList(list);

              reverse(list);

              System.out.println();

              System.out.println("After:");

              outList(list);

    }

 

}

 

3-е задание

import java.util.ArrayList;

 

public class Main {

    static void outList (ArrayList<Integer> list) {

              for (int now:list )

                       System.out.print(now + "\t");

              System.out.println();

    }

        

static void fillList(ArrayList <Integer> list, int many) {

    for (int i=0; i<many;i++)

              list.add((int)(Math.random()*51)-25);

}

 

    public static void main(String[] args) {

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

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

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

                  

              fillList(list,20);

              int index = 0;

              for (;index < list.size();index++)

                       if (list.get(index)<0)

                                 break;

              if (index==list.size()) {

                       System.out.println("<0 net");

                       return;

              }

              for (int i=0; i<index;i++)

                       before.add(list.get(i));

              for (int i=index+1; i<list.size();i++)

                       after.add(list.get(i));

                  

              outList(list);

              System.out.println();

              outList(before);

              System.out.println();

              outList(after);

    }

 

}

 

Оператор throw (бросать)

Чтобы сообщить о выполнении исключительных ситуаций в программе, можно использовать оператор throw. То есть с помощью этого оператора мы сами можем создать исключение и вызвать его в процессе выполнения.

Оператор throws

(переброс обработки исключения в точку вызова метода)

 

Иногда метод, в котором может генерироваться исключение, сам не обрабатывает это исключение. В этом случае в объявлении метода используется оператор throws, который надо обработать при вызове этого метода. Например, у нас имеется метод вычисления факториала, и нам надо обработать ситуацию, если в метод передается число меньше 0:

	public static int getFactorial(int num) throws Exception{   if(num<0) throw new Exception("Число не может быть меньше 0"); if (num ==0) return 1; else return getFactorial(num-1)*num; }

 

С помощью оператора throw по условию выбрасывается исключение. В то же время метод сам это исключение не обрабатывает с помощью try..catch, поэтому в определении метода используется выражение throws Exception.

Теперь при вызове этого метода нам обязательно надо обработать выбрасываемое исключение:

public static void main(String[] args){   try{ int result = getFactorial(-6);   System.out.println(result); } catch(Exception ex){   System.out.println(ex.getMessage()); } }

Без обработки исключения у нас возникнет ошибка компиляции, и мы не сможем скомпилировать программу.

В качестве альтернативы мы могли бы и не использовать оператор throws, а обработать исключение прямо в методе:

	public static int getFactorial(int num){ int result = 1;         try     {     if(num<0) throw new Exception("Число не может быть меньше 0");               if (num ==0) return result;               else result = getFactorial(num-1)*num;     }     catch (Exception ex)     {        System.out.println(ex.getMessage());     }     return result; }

 

Потоки ввода – вывода

 

Большинство программ работает с данными. При этом данные потоком поступают в программу, она их обрабатывает и передаёт дальше.

Процесс чтения данных с ресурса и записи их в назначенное место показан на рисунке ниже:

 

 

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

Различают следующие типы потоков:

¾  По направлению движения данных потоки можно разделить на две группы:

1. Поток ввода (Input) — данные поступают из потока в нашу программу. Мы их читаем из этого потока

2. Поток вывода (Output) — данные поступают в поток из нашей программы. Мы их пишем в этот поток

¾  По типу передаваемых данных:

1.  Поток байтов

2.  Поток символов (человек может визуально их прочесть)

 

В итоге мы получаем 4 типа потоков. По сути потоки можно представить, как трубу, в которую “заливаются” байты или символы.

Для каждого из этих типов Java предлагает отдельный базовый абстрактный класс. Почему абстрактный? Потому, что у нас есть специализация — файлы, сеть, память. И расширяя базовый класс специальный класс решает свои специальные задачи. Но базовые функции для всех одинаковые. Что удобно — все специальные потоки по своей сути одно и тоже. Это дает гибкость и универсальность. Вот эти классы:

1. InputStream — поток для чтения байтов (поток ввода)

2. Reader — поток для чтения символов (поток ввода)

3. OutputStream — поток для записи байтов (поток вывода)

4. Writer — поток для записи символов (поток вывода)

Ниже схематично показана программа, которая должна считать данные с потока и записать в поток:

 

Все остальные классы, работающие с потоками, являются наследниками этих абстрактных классов. Все классы - наследники мы рассматривать не будем, а только классы для работы с файлами:

 

Для работы с потоками в программе необходимо импортировать пакет java . io

Схема работы с потоком в упрощенном виде выглядит так:

1. Создается экземпляр потока

2. Поток открывается (для чтения или записи)

3. Производится чтение из потока/запись в поток

4. Поток закрывается

 

Пример программы для записи и считывания информации из текстового файла:

 

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.util.Scanner;

 

public class Main {

    //записьтекстовыхданных в файл

    public static void writeTextToFile() throws IOException {

              FileWriter file = new FileWriter("myfile.txt");

              file.write("Первая строка: 12 -13 17");

              file.write("\n");

              file.write("Вторая строка строка: 0 -6 12");

              file.close();

    }

 

    //считываниетекстовыхданных из файла

    public static void readTextFromFile() throws IOException {

              FileReader file = new FileReader("myfile.txt");

              Scanner scan = new Scanner(file);

              String s = null;

              while (scan.hasNextLine()){ // пока есть следующая строка

                       s = scan.nextLine();

                       System.out.println(s);

              }

                  

              file.close();

              scan.close();

    }

        

              public static void main(String args[]) throws IOException {

              writeTextToFile();

              readTextFromFile();

              }

}

 

Пример программы, создающей копию уже существующего . doc . pdf или . jpg файла (считывание и запись информации надо производить по байтам):

public static void copyFile(String source, String target) throws IOException {

               

   FileInputStream fis = new FileInputStream(source);

   FileOutputStream fos = new FileOutputStream(target);

             

       int data;

//чтение происходит по одному байту, -1 является признаком окончания //байтов

       while ( (data = fis.read()) != -1) {

           fos.write(data);

       }

           

       fis.close();

       fos.close();

    }

public static void main(String args[]) throws IOException {

copyFile("zadaniya.pdf","zadaniya_copy.pdf");

copyFile ("1. jpg ","2. jpg ");

}

 

При небольших размерах файлов все работает вполне прилично. Но если вы попробуете скопировать файл хотя бы в несколько мегабайт, то это может происходить крайне долго. Причина в том, что вы читаете по ОДНОМУ байту. Это крайне неэффективно. На самом деле для чтения каждого байта вы считываете достаточно приличный кусок данных с диска, но используете только один байт. И так много-много раз. Производительность ужасающая, загрузка дисковой подсистемы сумасшедшая.

На помощь придет буферизованные версии чтения/записи.

Буфер – это временное хранилище данных в оперативной памяти. Т.е. данные копируются из потока в буфер. После получения всех данных в буфер, они проверяются на целостность и только потом передаются в программу. Это радикально повышает производительность.

Для этого надо использовать другой вариант вызова методов read и write — он принимает в качестве входного параметра массив байтов. Т.е. при чтении поток сразу заполняет весь массив (или его часть) и делает операцию сразу для большого количества — читает или пишет.

На что следует обратить внимание в этом случае — при операции чтения вам возвращается количество реально считанных байт (если оно равно “-1”, значит поток закончился), а операция записи может писать не весь массив, а только какую-то его часть. Вы указываете индекс начального элемента массива и количество.

Пример создания копии графического файла ( в переменную buffer мы считываем байты, а в переменной size сохраняем количество реально считанных байт ):

public static void copyFile(String source, String target) throws IOException {

               

   FileInputStream fis = new FileInputStream(source);

   FileOutputStream fos = new FileOutputStream(target);

             

   byte[] buffer = new byte[8192]; // размербуфера 8 Кб

   int size = 0;

   while ( (size = fis.read(buffer)) != -1) {

       fos.write(buffer, 0, size);

   }

           

       fis.close();

       fos.close();

 

    }

    public static void main(String args[]) throws IOException {

              copyFile("1.jpg","2.jpg");

    }

 

Создание проектов JavaFX

JavaFX — платформа на основе Java для создания приложений с насыщенным графическим интерфейсом. Может использоваться для создания настольных приложений, запускаемых непосредственно из-под операционных систем (Desktop приложений); для интернет-приложений (RIA - Rich Internet Application), загружаемых пользователем через интернет, предназначенных для выполнения функций традиционных настольных приложений и работающих в браузерах; и для приложений на мобильных устройствах.

Мы будем использовать JavaFX8 (был выпущен 18 Марта 2014 года) и уже стал частью пакетов JRE/JDK вместе с версией Java 8.

Примеры приложений, созданных на javafx - http://www.oracle.com/technetwork/java/javase/overview/javafx-samples-2158687.html . Тут более 100 примеров приложений с показом возможностей работы с графикой, анимацией, мультимедиа, построением диаграмм и приведением кода программ.

Обратите внимание, что эти приложения открываются с помощью Java Web Start (часто JavaWS) — технологии, позволяющей запускать приложения на Java из браузера. Приложения Web Start работают не в окне браузера и не имеют с ним прямой связи (файл .jnlp)

JavaFX призвана заменить использовавшуюся ранее библиотеку Swing. По мимо более широких возможностей JavaFX (имеет большее количество сторонних библиотек) по сравнению со Swing, JavaFX позволяет создавать приложения с архитектурой MVC (Model – View - Controller)

 

 

Где мы будем это всё разрабатывать:

 

 

JavaFX Scene Builder - визуальный инструмент проектирования GUI в формат FXML.

Основные составляющие приложения на JavaFX:

 

 

Stage – главное окно (контейнер) приложения. Содержит объект Scene.

Scene – корневой контейнер, который содержит все компоненты интерфейса (панели, кнопки и пр.)

SceneGraph – дерево (граф) компонентов, структура GUI. Это не класс, а понятие. Каждый элемент этого графа – Node (контрол, панель, графика, медиа и т.д. )

 

Аналогия с театром

Stage – место действия (сцена) с декорациями, названием

Scene – эпизод, что показывать в данный момент. Scene меняются, Stage – один и тот же. В один момент времени – только один эпизод.

Каждый эпизод может использовать любое количество актеров – элементов управления (Node).

 

ПРОЕКТИРОВАНИЕ GUI

Проектирование GUI – подробный разбор и рисование интерфейса (макет приложения).

Существует множество Mockup сервисов для создания макетов приложения.

Например, онлайн сервис http://moqups.com/

 

 

Локализация приложения

( поддержка нескольких языков )

 

Локализация (Localization - l10n) — это процесс перевода ресурсов приложения (добавление различных файлов переводов, которые могут использоваться в приложении) в локализованные версии для каждого языка и региональных параметров, которые поддерживает приложение. Переход локализации должен происходить только после того, как выполнено условие локализуемости (Localizability), т.е. исполняемый код отделен от любых элементов пользовательского интерфейса.

С понятием локализации в Java тесно связан объект Locale.

Locale – объект, объединяющий значения (параметры) для локализации

• Язык

• Страна

• Валюта

• Часовой пояс

• Формат даты

• ...

Как только мы указываем для Locale какой - либо регион или язык, то он автоматически подтягивает все перечисленные параметры для этого региона.

Реализация поддержки нескольких языков в JavaFX (похожий подход используется и в web -  технологиях):

1. Добавить файлы *.properties для нужных языков

2. Заполнить файлы значениями «ключ-перевод»

3. Указать местоположение файлов *.properties (через код или настройки)

4. Изменить компоненты для использования файлов локализации (в коде также все текстовые значения нужно заменить на значения ключа)

5. Реализовать переключение языка в приложении

JAR – файлы

Когда разрабатывается относительно небольшое десктопное приложение на Java, часто возникает вполне, на мой взгляд, естественное желание запихать все классы, библиотеки и ресурсы в один исполняемый JAR-файл. В некоторых случаях именно такое решение является предпочтительным.

Развёртывание

 

JavaFX предоставляет новую возможность развёртывания, называемую "нативная упаковка" (Native Packaging) (другое название - "Автономная упаковка приложения" (Self-Containde Application Package)).

Нативный Пакет - это пакет, который вместе с приложением Java содержит и среду выполнения Java для конкретной платформы.

Файл build.fxbuild используется плагином e(fx)clipse для генерации файла, который в свою очередь будет использоваться инструментом сборки Ant.

 

Лекция 2. Происхождение языка Java

Происхождение Java

Язык Jаvа тесно связан с языком С++, который, в свою очередь, является прямым наследником языка С. Многие особенности Jаvа унаследованы от обоих этих языков. От С язык Jаvа унаследовал свой синтаксис, а многие его объектно-ориентированные свойства были перенесены из С++.

К концу 1980-х и в начале 1990-х гг. объектно-ориентированное программирование на С++ стало основной методикой программирования. И в течение некоторого, хотя и непродолжительного периода времени казалось, что программисты наконец изобрели идеальный язык. Ведь язык С++ сочетает в себе высокую эффективность и стилистические элементы языка С наряду с объектно-ориентированным подходом, и поэтому его можно было использовать для создания самых разных программ.

Над разработкой языка Java работали целые группы американских программистов из компании Sun Microsystems, Inc, впоследствии поглощенной компанией Oracle. В 1995 году впервые публично было объявлено о создании Java.

Как ни странно, первоначальной побудительной причиной для создания языка Java послужил совсем не Интернет, а потребность в независящем от конкретной платформы (т.е. архитектурно - нейтральном) языке, который можно было бы использовать для создания программного обеспечения, встраиваемого в различные бытовые электронные устройства, в том числе микроволновые печи и устройства дистанционного управления.

В контроллерах таких устройств применяются разнотипные процессоры. Но трудность применения С и С++ (как и большинства других языков) состоит в том, что написанные на них программы должны компилироваться для конкретной платформы. И хотя программы на С++ могут быть скомпилированы практически для любого типа процессора, тем не менее, для этого потребуется наличие полного компилятора С++, предназначенного для данного конкретного процессора. Компилятор – это программа, которая переводит программу на писанную на языке программирования в машинный код.

Интерпретатор языка программирования (interpreter) - программа или технические средства, необходимые для выполнения других программ, вид транслятора, который осуществляет пооператорную (покомандную, построчную) обработку и выполнение программы или запроса.

Но дело в том, что создание компиляторов обходится дорого и отнимает немало времени. Поэтому требовалось более простое и экономически выгодное решение. Пытаясь найти такое решение, Гослинг и другие разработчики начал работ над переносимым, не зависящим от конкретной платформы языком, который можно было бы использовать для создания кода, пригодного для выполнения на разнотипных процессорах в различных средах. И в конечном итоге их усилия привели к созданию языка Java. Примерно в то время, когда определялись основные характеристики языка Java, появился второй, еще более важный фактор, который должен был сыграть решающую роль в судьбе этого языка. И этим вторым фактором, конечно же, стала Всемирная паутина (веб). Если бы формирование веб не происходило почти одновременно с реализацией языка Java, он мог бы остаться полезным, но незамеченным языком программирования бытовых электронных устройств. Но с появлени­ем веб язык jаvа вышел на передний край разработки языков программирования, поскольку среда веб также нуждалась в  переносимых программах.

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