Длина массива и представление в памяти

Объявление массива

Переменную массива нужно объявить с помощью квадратных скобок:

int[] x; // мы объявили переменную массива

Возможна и альтернативная запись:

int x[]; // другой вариант

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

Мы пока только объявили массив, но на самом деле его ещё не существует, так как не заполнен данными. Фактически значение массива равно null.

Определение массива

После объявления переменной массива, можно определить сам массив с помощью ключевого слова new с указанием типа и размера. Например, массив должен состоять из 10 целых чисел:

x = new int[10];

Можно одновременно объявить переменную и определить массив (в основном так и делают):

 

int[] x = new int[10];

Если массив создается таким образом, то всем элементам массива автоматически присваиваются значения по умолчанию. Например, для числовых значений начальное значение будет 0. Для массива типа boolean начальное значение будет равно false, для массива типа char - '\u0000', для массива типа класса (объекты) - null.

Последнее правило может запутать начинающего программиста, который забудет, что строка типа String является объектом. Если вы объявите массив из десяти символьных строк следующим образом:

String[] sx = new String[10];

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

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

   xs[i] = "";

Доступ к элементам массива

Обращение к элементу массива происходит по имени массива, за которым следует значение индекса элемента, заключенного в квадратные скобки. Например, на первый элемент нашего массива x можно ссылаться как на x [0], на пятый элемент как x [4].

В качестве индекса можно использовать числа или выражения, которые создают положительное значение типа int. Поэтому при вычислении выражения с типом long, следует преобразовать результат в int, иначе получите ошибку. С типами short и byte проблем не будет, так как они полностью укладываются в диапазон int.

Инициализация массива

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

int[] x = {2, 5, 7, 8, 3, 0}; // массив из 6 элементов

Можно смешать два способа. Например, если требуется задать явно значения только для некоторых элементов массива, а остальные должные иметь значения по умолчанию.

Длина массива и представление в памяти

Так как массив является объектом, то в классе, его определяющем, у него есть поле length, которое можно прочитать (но не изменить). Оно позволяет получить количество элементов в массиве. Данное свойство удобно тем, что вы не ошибётесь с размером массива. Последний элемент массива всегда x[x.length - 1].

Представление в памяти массива х

length	X[0]	X[1]	X[2]	X[3]	X[4]	X[5]
6	2	5	7	8	3	0

Пример. Вычислить среднее арифметическое элементов массива.

int[] x = { 4, 8, 10, 12, 16 };int result = 0; for (int i = 0; i < x.length; i++) {       result = result + x[i];}result = result / ч.length; // общий результат делим на число элементов в массивеТеперь длина массива вычисляется автоматически, и если вы создадите новый массив y из x, то в цикле ничего менять не придётся. Если вам нужно изменять длину, то вместо массива следует использовать списочный массив ArrayList. Сами массивы неизменяемы. Будьте осторожны с копированием массивов. Массив - это не числа, а специальный объект, который по особому хранится в памяти. Чтобы не загромождать вас умными словами, лучше покажу на примере. int[] a = {2, 8, 11};int[] b = a;b[2] = 25;

Получим результат.

a: [2, 8, 25];b: [2, 8, 25]; так как b – содержит адрес выделенный массиву а

Если ваша программа выйдет за пределы индекса массива, то программа остановится с ошибкой времени исполнения ArrayOutOfBoundsException. Это очень частая ошибка у программистов, проверяйте свой код.

Датчик случайных чисел

Очень часто бывает нужно создать некоторые случайные данные, которые могут быть нам полезны как в работе алгоритмов, так и при их тестировании. Для этих целей в языке Java существует генератор случайных чисел Random. Данный класс имеет два конструктора: по умолчанию, который использует текущую дату для своей инициализации и конструктор, который принимает на вход некоторое число типа long. Очевидно, если вы будете использовать второй конструктор с одинаковым значением параметра, то в результате у вас будут генерироваться одинаковые случайные значения, поэтому на практике в основном применяют первый. Рассмотрим методы классы Random:

• nextBoolean()
• nextInt()
• nextLong()
• nextFloat()
• nextDouble()

Стоит отметить, что вещественные числа генерируются только в промежутке с 0 до 1, а целочисленные по всему спектру значений. Кроме того, целые числа можно генерировать в диапазоне с 0 до max — 1: nextInt(max).

Заполним массив байт случайными значениями:
Random r = new Random();
byte[] arr = new byte[100];
r.nextBytes(arr);

for(int i = 0; i < arr.length; i++){ System.out.println(arr[i]); }
К сожалению, аналогов функции nextBytes нет для других типов, поэтому придется явно инициализировать каждое значение:

Random r = new Random();
int[] arr = new int[100];
for(int i = 0; i < arr.length; i++){ arr[i] = r.nextInt(); System.out.println(arr[i]); }
Генерация случайных данных очень помогает для тестирования программ. Например, для того, чтобы проверить сортировку достаточно подать на вход случайную последовательность, а затем проверить, что предыдущее число меньше текущего.

1) В Java Math.random() возвращает double значение с положительным знаком, больше чем или равно 0.0 и меньше чем 1.0 (0.0 <= Math.random() < 1.0).

 

import java.util.Random;                                     // класс датчика случайных чисел

 

public class Test {

public static void main(String[] args) {

Random rand = new Random();

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

   int n = rand.nextInt(10);

  System.out.println(n);

}

}

}

2) int a = 0; // Начальное значение диапазона - "от"int b = 10; // Конечное значение диапазона - "до"

int random_number1 = a + (int) (Math.random() * b); // Генерация 1-го числа

System.out.println("1-ое случайное число: " + random_number1);

int random_number2 = a + (int) (Math.random() * b); // Генерация 2-го числа

System.out.println("2-ое случайное число: " + random_number2);

int random_number3 = a + (int) (Math.random() * b); // Генерация 3-го числа

System.out.println("3-е случайное число: " + random_number3);

3) создать случайное значение int в определенном диапазоне

На практике класс java.util.Random часто предпочтительнее java.lang.Math.random().

   public static int randInt(int min, int max) {          Random rand;      int randomNum = rand.nextInt((max - min) + 1) + min;          return randomNum;   }

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

Для создания многомерных массивов используются дополнительные скобки:

int[][] a = {{ 1, 2, 3 },{ 4, 5, 6 }}

Также массив может создаваться ключевым словом new:

// трехмерный массив фиксированной длиныint[][][] b = new int[2][4][4];

Двумерный массив

Двумерный массив - это массив одномерных массивов. Если вам нужен двумерный массив, то используйте пару квадратных скобок:

String[][] arr = new String[4][3]; arr[0][0] = "1";arr[0][1] = "Васька";arr[0][2] = "121987102"; arr[1][0] = "2";arr[1][1] = "Рыжик";arr[1][2] = "2819876107"; arr[2][0] = "3";arr[2][1] = "Барсик";arr[2][2] = "412345678"; arr[3][0] = "4";arr[3][1] = "Мурзик";arr[3][2] = "587654321";

Представляйте двумерный массив как таблицу, где первые скобки отвечают за ряды, а вторые - за колонки таблицы. Тогда пример выше представлят собой таблицу из четырёх рядов и трёх колонок.

1	Васька	121987102
2	Рыжик	2819876107
3	Барсик	412345678
4	Мурзик	587654321

Для двумерных массивов часто используются два цикла for, чтобы заполнить элементы данными слева направо и сверху вниз. Напишем такой код:

int[][] twoD = new int[3][4]; // определение двухмерного массиваint i, j, k = 0; for (i = 0; i < 3; i++)   for (j = 0; j < 4; j++) {          twoD[i][j] = k;          k++;   }

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

Логическое представление данного двухмерного массива будет выглядеть следующим образом:

[0, 0]	[0, 1]	[0, 2]	[0, 3]
[1, 0]	[1, 1]	[1, 2]	[1, 3]
[2, 0]	[2, 1]	[2, 2]	[2, 3]

Первое число в скобках обозначают ряд (строку), а второе число - столбец. Принято считать, что в массиве new int[M][N] первый размер означает количество строк, а второй - количество столбцов.

На экране после запуска примера мы увидим следующее:

0 1 2 34 5 6 78 9 10 11

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

int[][] twoD = new int[3][]; // память под первое измерение// далее резервируем память под второе измерениеtwoD[0] = new int[4];twoD[1] = new int[4];twoD[2] = new int[4];

В данном примере особого смысла в этом нет.

Еще одна интересная особенность при создании массива связана с запятой. Посмотрите на пример.

int[][] a = {{1, 2, 3}, {4, 0, 0,},};  System.out.println(Arrays.deepToString(a));

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

Чтобы совсем сбить вас с толку, приведу ещё один правильный пример.

Integer[] Integer[] = {{1, 2, 3}, {4, 0, 0,},};  System.out.println(Arrays.deepToString(Integer));

Я уже упоминал, что квадратные скобки можно использовать двумя способами. Сначала мы поставили скобки у типа переменной, а потом у имени переменной. При этом мы использовали в качестве имени имя класса Integer. Однако, Java догадывается, что на этот раз используется не класс, а имя и разрешает такой синтаксис. Но лучше так не выпендриваться.

Пример. Сложить два массива и копирование массива

Есть два массива, и вам нужно их соединить и получить общий массив.

private double[] concatArray(double[] a, double[] b) {   if (a == null)          return b;   if (b == null)          return a;   double[] r = new double[a.length + b.length];   System.arraycopy(a, 0, r, 0, a.length);//   System.arraycopy(b, 0, r, a.length, b.length);   return r;}Где System.arraycopy(a, 0, r, 0, a.length); метод- копирует a.length элементов массива а начиная с нулевого, и размещает их в массиве r, начиная с нулевого.System.arraycopy(b, 0, r, a.length, b.length); копирует b.length элементов массива b, начиная с нулевого, и размещает их в массиве r, начиная с a.length.

Пример сложения двух строковых массивов:

// метод для склеивания двух строковых массивовprivate String[] concatArray(String[] a, String[] b) {   if (a == null)          return b;   if (b == null)          return a;   String[] r = new String[a.length + b.length];   System.arraycopy(a, 0, r, 0, a.length);   System.arraycopy(b, 0, r, a.length, b.length);   return r;} String[] week1 = new String[] { "Понедельник", "Вторник", "Среда" }; String[] week2 = new String[] { "Четверг", "Котопятница", "Субкота",                  "Воскресенье" };                  String[] week = concatArray(week1, week2); // будет возвращён массив всех семи дней недели

Копировать часть массива

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

System.arraycopy(a, start, r, 0, a.length - start);Где start - с какой позиции нужно получить новый массив, отсчёт с 0private double[] copyPartArray(double[] a, int start) {   if (a == null)          return null;   if (start > a.length)      return null;   double[] r = new double[a.length - start];   System.arraycopy(a, start, r, 0, a.length - start);   return r;} public void onClick(View v) {   double[] digits = new double[] {6.5, 3.1, 5.72};   double[] part = copyPartArray(digits, 1);   Toast.makeText(v.getContext(), part[1] + "", Toast.LENGTH_LONG).show();}

Здесь вы также можете использовать другие типы вместо double. Вот пример использования:

private String[] copyPartArray(String[] a, int start) {   if (a == null)          return null;   if (start > a.length)          return null;   String[] r = new String[a.length - start];   System.arraycopy(a, start, r, 0, a.length - start);   return r;} public void onClick(View v) {   String[] weekday = new String[] { "Понедельник", "Вторник", "Среда" };    // нам нужен массив со второго элемента   String[] week = copyPartArray(weekday, 1); // вернёт Вторник и Среда   // выводим второй элемент из полученного массива, т.е. Среда   Toast.makeText(v.getContext(), week[1], Toast.LENGTH_LONG).show();}

Перемешать элементы массива

Бывает необходимость перемешать элементы массива в случайном порядке. В интернете нашёл готовый метод по алгоритму Fisher–Yates (прим.: Fisher - это рыбак, который ловит рыбу, например, кот)

// Implementing Fisher–Yates shufflestatic void shuffleArray(int[] ar) {   Random rnd = new Random();   for (int i = ar.length - 1; i > 0; i--) {          int index = rnd.nextInt(i + 1);          // Simple swap          int a = ar[index];          ar[index] = ar[i];          ar[i] = a;   }} // создадим массив и перемешаем егоint[] mSolutionArray = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,          13, 14 };shuffleArray(mSolutionArray); Log.i("Array", Arrays.toString(mSolutionArray));

Подводим итоги

1. Помните, что размер массива фиксируется и не может меняться на протяжении его жизненного цикла.

2. Если вам нужно изменять, то используйте ArrayList, который способен автоматически выделять дополнительное пространство, выделяя новый блок памяти и перемещая в него ссылки из старого.

Класс Arrays и его методы

В пакете java.util находится класс Arrays, который содержит методы манипулирования содержимым массива, а именно для поиска, заполнения, сравнения, преобразования в коллекцию и прочие.

int binarySearch(параметры)	– перегруженный метод организации бинарного поиска значения в массивах примитивных и объектных типов. Возвращает позицию первого совпадения;
void fill(параметры)	– перегруженный метод для заполнения массивов значениями различных типов и примитивами;
void sort(параметры)	– перегруженный метод сортировки массива или его части с использованием интерфейса Comparator и без него;
copyOf(оригинальный_массив,новая_длина)	– копирует заданную область массива в новый массив; int[] numbers = new int[] { 1, 2, 3, 5 }; int[] figures = Arrays.copyOf(numbers, numbers.length);
toString(ссылка на массив)	-вывод одномерного массива в строковом виде // вывод массива объектов String String[] strArr = {"A", "C", "B", "Z", "E"}; Arrays.sort(strArr); System.out.println(Arrays.toString(strArr)); / вывод массива int'ов int[] intArr = {5,9,1,10}; Arrays.sort(intArr); System.out.println(Arrays.toString(intArr));
static <T> T[] copyOfRange(T[] original, int from, int to)	– копирует заданную область массива в новый массив; String[] massive1 = {"Татьяна", "Сергей", "Александр", "Павлик"}; // Копируем элементы массива в другой массив String[] massive2= Arrays.copyOf(massive1, 3); // Копируем нужные элементы в диапазоне String[] massive3= Arrays.copyOfRange(massive1, 1,massive1.length);
deepToString(ссылка на двумерный массив)	- вывод двумерного массива System.out.println(Arrays.deepToString(ch)); где ch двумерный массив
equals(ссылка на одномерный массив 1, ссылка на одномерный массив 2).	Сравнение на равенство одномерных массивов. Результат true, если их длины равны и они поэлементно равны. //Создаем два массива int[]a1=newint[10]; int[]a2=new int[10]; //заполняем их девятками Arrays.fill(a1,9); Arrays.fill(a2,9); System.out.println("Сравним:"+Arrays.equals(a1,a2));

/* Перебор элементов массива, не лучший способ,* Вообще, никогда не используйте.length внутри цикла,* т.к. тогда он будет на каждой итерации

вызывать метод подсчета длины. */

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

out.printf("%s ", massive1[i]);

}

out.println();

// Правильный вывод элементов массива по быстродействию

for(String s: massive2){

out.printf("%s ", s);

}

out.println();

for(String s1: massive3){

out.printf("%s", s1);

}

}

}

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

/* пример # 21: методы класса Arrays: ArraysEqualDemo.java */

package chapt10;

import java.util.*;

public class ArraysEqualDemo {

public static void main(String[] args) {

char m1[] = new char [3];

char m2[] = { ‘a’, ‘b’, ‘c’ }, i;

Arrays.fill(m1, ‘a’);

System.out.print("массив m1:");

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

System.out.print(" " + m1[i]);

m1[1] = ‘b’;

m1[2] = ‘c’;

//m1[2]=’x’; // приведет к другому результату

if (Arrays.equals(m1, m2))

System.out.print("\nm1 и m2 эквивалентны");

Else

System.out.print("\nm1 и m2 не эквивалентны");

m1[0] = ‘z’;

Arrays.sort(m1);

System.out.print("\nмассив m1:");

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

System.out.print(" " + m1[i]);

System.out.print("\n значение ‘c’ находится в позиции-" + Arrays.binarySearch(m1, ‘c’));

Integer arr[] = {35, 71, 92};

//вывод массива объектов в строку

System.out.println(Arrays.deepToString(arr));

//вычисление хэш-кода исходя и значений элементов

System.out.println(Arrays.deepHashCode(arr));

Integer arr2[] = {35, 71, 92};

//сравнение массивов по седержимому

System.out.println(Arrays.deepEquals(arr, arr2));

char m3[] = new char [5];

// копирование массива

m3 = Arrays. copyOf (m1, 5);

System. out. print("массив m3:");

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

System. out. print(" " + m3[i]);

}

}

В результате компиляции и запуска будет выведено:

Массив m1: a a a

M1 и m2 эквивалентны

Массив m1: b c z

значение ‘c’ находится в позиции 1

[35, 71, 92]

65719

True

массив m3: b c z □ □

Объявление массива

Переменную массива нужно объявить с помощью квадратных скобок:

int[] x; // мы объявили переменную массива

Возможна и альтернативная запись:

int x[]; // другой вариант

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

Мы пока только объявили массив, но на самом деле его ещё не существует, так как не заполнен данными. Фактически значение массива равно null.

Определение массива

После объявления переменной массива, можно определить сам массив с помощью ключевого слова new с указанием типа и размера. Например, массив должен состоять из 10 целых чисел:

x = new int[10];

Можно одновременно объявить переменную и определить массив (в основном так и делают):

 

int[] x = new int[10];

Если массив создается таким образом, то всем элементам массива автоматически присваиваются значения по умолчанию. Например, для числовых значений начальное значение будет 0. Для массива типа boolean начальное значение будет равно false, для массива типа char - '\u0000', для массива типа класса (объекты) - null.

Последнее правило может запутать начинающего программиста, который забудет, что строка типа String является объектом. Если вы объявите массив из десяти символьных строк следующим образом:

String[] sx = new String[10];

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

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

   xs[i] = "";

Доступ к элементам массива

Обращение к элементу массива происходит по имени массива, за которым следует значение индекса элемента, заключенного в квадратные скобки. Например, на первый элемент нашего массива x можно ссылаться как на x [0], на пятый элемент как x [4].

В качестве индекса можно использовать числа или выражения, которые создают положительное значение типа int. Поэтому при вычислении выражения с типом long, следует преобразовать результат в int, иначе получите ошибку. С типами short и byte проблем не будет, так как они полностью укладываются в диапазон int.

Инициализация массива

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

int[] x = {2, 5, 7, 8, 3, 0}; // массив из 6 элементов

Можно смешать два способа. Например, если требуется задать явно значения только для некоторых элементов массива, а остальные должные иметь значения по умолчанию.

Длина массива и представление в памяти

Так как массив является объектом, то в классе, его определяющем, у него есть поле length, которое можно прочитать (но не изменить). Оно позволяет получить количество элементов в массиве. Данное свойство удобно тем, что вы не ошибётесь с размером массива. Последний элемент массива всегда x[x.length - 1].

Представление в памяти массива х

length	X[0]	X[1]	X[2]	X[3]	X[4]	X[5]
6	2	5	7	8	3	0

Пример. Вычислить среднее арифметическое элементов массива.

int[] x = { 4, 8, 10, 12, 16 };int result = 0; for (int i = 0; i < x.length; i++) {       result = result + x[i];}result = result / ч.length; // общий результат делим на число элементов в массивеТеперь длина массива вычисляется автоматически, и если вы создадите новый массив y из x, то в цикле ничего менять не придётся. Если вам нужно изменять длину, то вместо массива следует использовать списочный массив ArrayList. Сами массивы неизменяемы. Будьте осторожны с копированием массивов. Массив - это не числа, а специальный объект, который по особому хранится в памяти. Чтобы не загромождать вас умными словами, лучше покажу на примере. int[] a = {2, 8, 11};int[] b = a;b[2] = 25;

Получим результат.

a: [2, 8, 25];b: [2, 8, 25]; так как b – содержит адрес выделенный массиву а

Если ваша программа выйдет за пределы индекса массива, то программа остановится с ошибкой времени исполнения ArrayOutOfBoundsException. Это очень частая ошибка у программистов, проверяйте свой код.

Датчик случайных чисел

Очень часто бывает нужно создать некоторые случайные данные, которые могут быть нам полезны как в работе алгоритмов, так и при их тестировании. Для этих целей в языке Java существует генератор случайных чисел Random. Данный класс имеет два конструктора: по умолчанию, который использует текущую дату для своей инициализации и конструктор, который принимает на вход некоторое число типа long. Очевидно, если вы будете использовать второй конструктор с одинаковым значением параметра, то в результате у вас будут генерироваться одинаковые случайные значения, поэтому на практике в основном применяют первый. Рассмотрим методы классы Random:

• nextBoolean()
• nextInt()
• nextLong()
• nextFloat()
• nextDouble()

Стоит отметить, что вещественные числа генерируются только в промежутке с 0 до 1, а целочисленные по всему спектру значений. Кроме того, целые числа можно генерировать в диапазоне с 0 до max — 1: nextInt(max).

Заполним массив байт случайными значениями:
Random r = new Random();
byte[] arr = new byte[100];
r.nextBytes(arr);

for(int i = 0; i < arr.length; i++){ System.out.println(arr[i]); }
К сожалению, аналогов функции nextBytes нет для других типов, поэтому придется явно инициализировать каждое значение:

Random r = new Random();
int[] arr = new int[100];
for(int i = 0; i < arr.length; i++){ arr[i] = r.nextInt(); System.out.println(arr[i]); }
Генерация случайных данных очень помогает для тестирования программ. Например, для того, чтобы проверить сортировку достаточно подать на вход случайную последовательность, а затем проверить, что предыдущее число меньше текущего.

1) В Java Math.random() возвращает double значение с положительным знаком, больше чем или равно 0.0 и меньше чем 1.0 (0.0 <= Math.random() < 1.0).

 

import java.util.Random;                                     // класс датчика случайных чисел

 

public class Test {

public static void main(String[] args) {

Random rand = new Random();

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

   int n = rand.nextInt(10);

  System.out.println(n);

}

}

}

2) int a = 0; // Начальное значение диапазона - "от"int b = 10; // Конечное значение диапазона - "до"

int random_number1 = a + (int) (Math.random() * b); // Генерация 1-го числа

System.out.println("1-ое случайное число: " + random_number1);

int random_number2 = a + (int) (Math.random() * b); // Генерация 2-го числа

System.out.println("2-ое случайное число: " + random_number2);

int random_number3 = a + (int) (Math.random() * b); // Генерация 3-го числа

System.out.println("3-е случайное число: " + random_number3);

3) создать случайное значение int в определенном диапазоне

На практике класс java.util.Random часто предпочтительнее java.lang.Math.random().

   public static int randInt(int min, int max) {          Random rand;      int randomNum = rand.nextInt((max - min) + 1) + min;          return randomNum;   }