Рассмотрим несколько простых задач на языке программирования Java. Узнаем, как вычислять факториалы, искать наибольшие числа в последовательности, определять високосные года, сортировать целые числа и другие полезные вещи.
Немного о Java
Java — это язык программирования, который был создан в 1995 году компанией Sun Microsystems. В начале 1990-х годов Sun пыталась разработать платформу для электронных бытовых устройств. В результате был создан язык Oak, который позже переименовали в Java.
Особенности языка
- Программы, написанные на этом языке, могут работать на любом устройстве, где есть специальная программа, виртуальная машина Java, или сокращенно — JVM. Исходный код на Java транслируется в специальный байт-код, который потом выполняется в среде JVM.
- Java — строго типизированный язык, поэтому все переменные и выражения имеют определенный тип, который нужно указывать. Это помогает избежать ошибок и делает код более надежным.
- Java — это объектно-ориентированный язык, что означает, что все в нем представлено в виде объектов. Это позволяет создавать код, который легко можно использовать в разных проектах.
- Java автоматически управляет памятью, освобождая ее от ненужных данных. Это упрощает работу и делает программы более стабильными.
- Java — простой язык для начинающих, но при этом надежный и масштабируемый для больших проектов. У него большое сообщество и множество полезных инструментов.
- Недостатки Java: большое потребление памяти и то, что код на нем может работать медленнее, чем на некоторых других языках. А еще с 2019 года обновления для Java стали платными.
Где применяют Java
Java применяется в разных сферах. Например, на нем пишут приложения для смартфонов и планшетов, работающих на платформе Android. Java также используется для создания веб-сайтов и корпоративных приложений. Java важен для работы с большими объемами данных и научными приложениями. Его применяют во встраиваемых системах и в играх, таких как Minecraft или RuneScape.
Java востребован на рынке труда. Разработчики, знающие Java, могут получать хорошие зарплаты и часто работают удаленно. По сравнению с Python, Java сложнее в изучении, но работает быстрее. В отличие от C#, Java безопаснее и не использует указатели, что делает его идеальным для создания корпоративных приложений.
«Привет, Мир!» на Java
С этой программы обычно и начинается знакомство с миром программирования. Как и во многих других языках, в Java точкой входа является метод main:
public static void main(String[] args) {
System.out.print("Привет, Мир!");
}
Вывод в консоли:
Привет, Мир!
Вывод чисел от 1 до 10
Самая простая задача. Для ее решения можно воспользоваться циклом for:
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
System.out.print(i + " ");
}
}
Вывод:
1 2 3 4 5 6 7 8 9 10
Вычисление факториала
Факториал числа — это произведение всех натуральных чисел от 1 до самого этого числа включительно. Обозначается факториал восклицательным знаком идущим после числа, факториал которого требуется найти. Примеры вычисления факториалов:
1! = 1 2! = 1 * 2 = 2 3! = 1 * 2 * 3 = 6 4! = 1 * 2 * 3 * 4 = 24 5! = 1 * 2 * 3 * 4 * 5 = 120 6! = 1 * 2 * 3 * 4 * 5 * 6 = 720
В Java факториал можно вычислить таким способом:
public static void main(String[] args) {
int number = 6;
int result = 1;
for (int i = 1; i <= number; i++) {
result = result * i;
}
System.out.print(number+"!="+result);
}
Как видим, здесь ничего сложного нет: в теле цикла умножаем result на значения счетчика цикла i (1, 2, 3 и так далее), пока он не станет равен number. Последнее значение переменной result и будет искомым факториалом. Для вышеприведенного примера результат в консоли будет таким:
6!=720
Поиск наибольшего числа
Пусть нам дана такая последовательность целых чисел:
5, 3, -2, 9, 1, -8
И нужно найти в ней наибольшее число. В Java это можно легко сделать при помощи цикла for и вложенного в него условного оператора if:
public static void main(String[] args) {
int[] numbers = {5, 3, -2, 9, 1, -8};
int maxNumber = numbers[0];
for (int number : numbers) {
if (number > maxNumber) {
maxNumber = number;
}
}
System.out.println(maxNumber);
}
Из чисел мы создали массив numbers и самый первый элемент массива записали в переменную maxNumber. Далее при помощи цикла перебираем все элементы массива и если какой-то из элементов оказывается больше maxNumber, то переменной maxNumber присваивается значение этого элемента. Если запустить вышеприведенный код, то в консоли получим следующее:
9
Получение последовательности Фибоначчи
Последовательность Фибоначчи состоит из целых чисел, первые два числа 0 и 1, а каждое следующее равно сумме двух предыдущих:
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, ...
В Java первые 20 чисел этой последовательности можно получить таким способом:
public static void main(String[] args) {
int[] arr = new int[20];
arr[0] = 0;
arr[1] = 1;
for (int i = 2; i < arr.length; ++i) {
arr[i] = arr[i - 1] + arr[i - 2];
}
for (int j : arr) {
System.out.print(j + " ");
}
}
Создаем массив из 20-и элементов. Инициализируем нулем и единицей первые два элемента массива. Далее в первом цикле складываем предыдущие два элемента массива, чтобы получить следующий. Во втором цикле выводим последовательность в консоль. После запуска вывод в консоли будет таким:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181
Определение простых чисел
Простые числа делятся нацело только на единицу и на само себя. Последовательность простых чисел бесконечна и начинается так:
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, ...
В Java есть класс BigInteger, который используется для операций над большими числами и в этом классе имеется метод isProbablePrime, служащий для определения простоты чисел на основе вероятностного теста Миллера-Рабина. Сначала делаем импорт класса BigInteger в самом начале исходника и только потом используем его в коде:
import java.math.BigInteger;
public static void main(String[] args) {
Integer integer = 5;
BigInteger bigInteger = BigInteger.valueOf(integer);
boolean probablePrimeNumber = bigInteger.isProbablePrime((int) Math.log(integer));
System.out.println(probablePrimeNumber);
}
На вход метода isProbablePrime подается натуральный логарифм проверяемого числа с явным приведением к типу int. В результате значение логарифма будет округлено до ближайшего целого числа. Метод возвращает значения true или false в зависимости от того простое число или составное. Так, если запустить вышеприведенный код, то в консоли получим такой результат:
true
Это значит, что число 5 является простым. А если взять, допустим, число 7638, то получим:
false
Это значит, что число 7638 не является простым.
Определение високосного года
Високосным называют год, содержащий один дополнительный день (29 февраля). Определить является ли год високосным можно довольно просто. Високосный год:
- делится на 4 без остатка;
- Не делится на 100 без остатка;
- делится на 400 без остатка.
Во всех остальных случаях год не является високосным. Учитывая все вышесказанное, можно написать такую программу на Java:
public static void main(String[] args) {
int year = 2020;
if ((year % 400 == 0) || ((year % 4 == 0) && (year % 100 != 0))) {
System.out.println(year + " - високосный год");
}else{
System.out.println(year + " - невисокосный год");
}
}
В консоли получим:
2020 - високосный год
Но также мы можем упростить код, если воспользуемся методом isLeap из класса Year:
import java.time.Year;
public static void main(String[] args) {
int year = 2025;
if (Year.of(year).isLeap()) {
System.out.println(year + " - високосный год");
}else{
System.out.println(year + " - невисокосный год");
}
}
Вывод будет таким:
2025 - невисокосный год
Разворачивание строки
Предположим, что перед нами стоит задача написать программу, которая принимает от пользователя введенную им строку и разворачивает ее, то есть выводит в обратном порядке. Для того чтобы пользователь смог что-то вводить нам понадобится класс Scanner. А для разворачивания строки используем метод reverse из класса StringBuilder.
Код:
import java.util.Scanner;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Введите строку:");
String str = scanner.nextLine();
String reversedStr = new StringBuilder(str).reverse().toString();
System.out.println(reversedStr);
}
Испытаем программу в работе. Запускаем и видим приглашение к вводу строки:
Введите строку:
Введем, например, слово «привет»:
Введите строку: привет
Нажимаем клавишу Enter и видим следующее:
Введите строку: привет тевирп
Все работает как надо!
Калькулятор суммы двух чисел с запросом завершения выполнения
Такой калькулятор после того как суммирует два числа и покажет пользователю ответ, спрашивает надо ли завершить программу или продолжить работу. Этот функционал можно реализовать при помощи цикла do — while. Весь основной код программы вносится в тело цикла и будет там крутиться, пока не получит условие завершения цикла. Для получения чисел от пользователя используется класс Scanner. Вот код такого калькулятора:
import java.util.Scanner;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n;
do
{
System.out.println("Введите первое число: ");
int number1 = scanner.nextInt();
System.out.println("Введите второе число: ");
int number2 = scanner.nextInt();
System.out.printf("%d + %d = %d \n", number1, number2, number1 + number2);
System.out.println("Для завершения работы приложения введите 0. Для продолжения работы введите любую другую цифру:");
n = in.nextInt();
}
while(n!=0);
in.close();
}
Пример работы программы с продолжением:
Введите первое число: 2 Введите второе число: 3 2 + 3 = 5 Для завершения работы приложения введите 0. Для продолжения работы введите любую другую цифру: 6 Введите первое число:
Пример работы программы с завершением:
Введите первое число: 4 Введите второе число: 2 4 + 2 = 6 Для завершения работы приложения введите 0. Для продолжения работы введите любую другую цифру: 0 Процесс завершен с кодом выхода 0
Поиск слова в строке
Для поиска слова в строке идеально подходит метод indexOf. Он возвращает позицию слова в строке в виде целого числа. Вот простой пример, как можно этот метод использовать:
public static void main(String[] args) {
String str = "Java — объектно-ориентированный язык программирования общего назначения.";
String word = "язык";
int position = str.indexOf(word);
System.out.println("Строка: " + str);
System.out.println("Искомое слово: " + word);
if (position != -1) {
System.out.println("Слово '" + word + "' найдено на позиции " + position);
} else {
System.out.println("Слово '" + word + "' не найдено в данной строке");
}
}
Вывод в консоли:
Строка: Java -- объектно-ориентированный язык программирования общего назначения. Искомое слово: язык Слово 'язык' найдено на позиции 32
Если мы присвоим переменной word значение, например, «python», то вывод в консоли уже будет такой:
Строка: Java -- объектно-ориентированный язык программирования общего назначения. Искомое слово: python Слово 'python' не найдено в данной строке
Таблица умножения
Для вывода таблицы умножения (таблицы Пифагора) в консоль нам понадобится два цикла for. Причем один цикл будет вложен в другой:
public static void main(String[] args) {
for (int i = 1; i < 10; i++) {
for (int j = 1; j < 10; j++) {
System.out.printf("%d\t", i * j);
}
System.out.println();
}
}
Один цикл занимается строками, а другой столбцами. В результате работы этой программы в консоли появится вот такая таблица:
1 2 3 4 5 6 7 8 9 2 4 6 8 10 12 14 16 18 3 6 9 12 15 18 21 24 27 4 8 12 16 20 24 28 32 36 5 10 15 20 25 30 35 40 45 6 12 18 24 30 36 42 48 54 7 14 21 28 35 42 49 56 63 8 16 24 32 40 48 56 64 72 9 18 27 36 45 54 63 72 81
Сортировка целых чисел
Допустим у нас есть некоторая последовательность чисел:
6, 2, 8, 1, 3, 9, 5, 4, 7
И нужно отсортировать их сначала по возрастанию, а потом по убыванию.
Сортировка по возрастанию
В Java есть класс Arrays для работы с массивами. Чтобы начать с ним работать, его сначала нужно импортировать:
import java.util.Arrays;
Теперь создадим массив из чисел и подадим его на вход метода sort из класса Arrays. Этот метод как раз и отсортирует числа в массиве по возрастанию:
int[] array = {6, 2, 8, 1, 3, 9, 5, 4, 7};
Arrays.sort(array);
Осталось только вывести отсортированные числа в консоль. Делаем это при помощи цикла for:
for (int number : array) {
System.out.print(number + " ");
}
Весь код будет выглядеть так:
import java.util.Arrays;
public static void main(String[] args) {
int[] array = {6, 2, 8, 1, 3, 9, 5, 4, 7};
Arrays.sort(array);
for (int number : array) {
System.out.print(number + " ");
}
}
Вывод в консоли:
1 2 3 4 5 6 7 8 9
Теперь попробуем вывести числа в порядке убывания.
Сортировка по убыванию
Для этого нам потребуется еще один импорт:
import java.util.Comparator;
Из этого класса нам понадобится только метод reverseOrder, но до его использования нужно провести вот такое преобразование нашего массива с числами:
Integer[] boxedArray = Arrays.stream(array).boxed().toArray(Integer[]::new);
По сути, этот код использует довольно лаконичный и эффективный способ преобразования примитивного массива int в массив Integer с использованием потоков. Теперь можно производить сортировку:
Arrays.sort(boxedArray, Comparator.reverseOrder());
И на последнем этапе выводим числа с помощью цикла for:
for (int number : boxedArray) {
System.out.print(number + " ");
}
Весь код будет такой:
import java.util.Arrays;
import java.util.Comparator;
public static void main(String[] args) {
int[] array = {6, 2, 8, 1, 3, 9, 5, 4, 7};
Integer[] boxedArray = Arrays.stream(array).boxed().toArray(Integer[]::new);
Arrays.sort(boxedArray, Comparator.reverseOrder());
for (int number : boxedArray) {
System.out.print(number + " ");
}
}
Вывод в консоли:
9 8 7 6 5 4 3 2 1
