if (t) { return; }
System.out.println("Этo не будет выполнено ");
run:
До return
Для выхода из программы используется метод System.exit(КодОшибки). Если программа заканчивается нормально, то КодОшибки должен быть 0:
System.exit(0);
1.5 Одномерные статические массивы
Одномерные массивы служат для хранения линейного списка с данными. Статические массивы поддерживаются на уровне Java-синтаксиса. Число элементов указывается явно при создании объекта массива или определяется автоматически при перечислении элементов массива. По умолчанию элементы массива объектов устанавливаются в null или в 0 для простых типов. Индексация элементов начинается с 0. Размер массива определяется через функцию length.
Рассмотрим пример работы с одномерными статическими массивами:
package tsn01.array;
import java.util.Arrays;
public class TSN01_Array {
public static void main(String[] args) {
// Пример работы с одномерными статическими массивами
int a[], b[]; // Переменные-массивы целых чисел
a = new int[10]; // Создание массива без инициализации
b = new int[]{1, 2, 3, 4}; // Создание массива с инициализацией
String s[] = new String[] {"Hello ", "world", "!!!"}; // Описываем и создаем массив строк
Arrays.fill(a, 0); // Заполнить массив нулями
a[0] = 20; a[1] = 10; a[2] = 5; a[3] = 33; // Устанавливаем значения 4 элементам
Arrays.fill(a, 5,10,-1); // Присвоить с 5 по 9 (10-1) элементам значение "-1"
Arrays.sort(a); // Сортируем массив
b[3] = b[1]*0b11+b[2]*0x2; // Рассчитываем значение для 4 элемента
System.out.println(Arrays.toString(a)); // Вывод на экран массива "a"
System.out.println(Arrays.toString(b)); // Вывод на экран массива "b"
System.out.println(Arrays.toString(s)); // Вывод на экран массива "s"
// Вывод на экран размеров массивов
System.out.println("Количество элементов в массиве \"a\": " + a.length);
System.out.println("Количество элементов в массиве \"b\": " + b.length);
System.out.println("Количество элементов в массиве \"str\": " + s.length);
System.out.println(s[0] + s[1]); // Доступ к элементам массива
}
}
Результат работы программы:
[-1, -1, -1, -1, -1, 0, 5, 10, 20, 33]
[1, 2, 3, 12]
[Hello , world, !!!]
Количество элементов в массиве "a": 10
Количество элементов в массиве "b": 4
Количество элементов в массиве "str": 3
Hello world
1.6 Многомерные статические массивы
Многомерные статические массивы служат для хранения двухмерных таблиц с данными. Рассмотрим пример работы с двумерным статическим массивом:
package tsn01.matrix;
public class TSN01_Matrix {
public static void main(String[] args) {
// Работа с двумерным статическим массивом чисел
// Создание исходных данных (элементов массива) и вывод их на экран
final int r = 4; // Количество строк
final int c = 5; // Количество столбцов
int m[][] = new int[r][c]; // Двумерный массив
int k; System.out.println("Matrix:");
for (int i = 0; i < r; i++) { // Цикл по строкам
for (int j = 0; j < c; j++) { // Цикл по колонкам
k = (int) Math.round(Math.random() * 100); // Получение случайного числа
m[i][j] = k; // Присвоение элементу массива числа
System.out.print(String.format("%5d", m[i][j])); // Вывод на экран элемента массива
} System.out.println("");
}
// Поиск минимума и максимума в массиве
int min = m[0][0], max = m[0][0], maxi = 0, maxj = 0, mini = 0, minj = 0; // Задаем начальные значения мин и макс
for (int i = 0; i < r; i++) { // Цикл по строкам
for (int j = 0; j < c; j++) { // Цикл по колонкам
k = m[i][j]; // Получаем элемент массива
if (k > max) { max = k; maxi = i; maxj = j; } // Поиск максимума
if (k < min) { min = k; mini = i; minj = j; } // Поиск минимума
}
}
// Меняем максимальный и минимальный элементы в масиве местами
k = m[maxi][maxj]; m[maxi][maxj] = m[mini][minj]; m[mini][minj] = k;
// Вывод измененного массива на экран
System.out.println("New matrix:");
for (int i = 0; i < r; i++) { // Цикл по строкам
for (int j = 0; j < c; j++) { // Цикл по колонкам
System.out.print(String.format("%5d", m[i][j])); // Вывод на экран элемента массива
} System.out.println("");
}
}
}
Результат работы программы:
Matrix:
42 83 94 96 1
2 64 27 32 10
20 86 49 14 36
12 35 14 65 97
New matrix:
42 83 94 96 97
2 64 27 32 10
20 86 49 14 36
12 35 14 65 1
1.7 Динамические массивы-списки
Динамические массивы реализованы на уровне параметризованных классов: Vector и ArrayList. Однако в качестве элементов простые типы выступать не могут, допускаются только объектные типы.
Для управления элементами эти классы используют методы интерфейсов Collection и List:
add(E o) добавление элемента в конец;
add(int index, E element) вставка элемента в указанную позицию;
remove(int index) удаление элемента в указанной позиции;
remove(Object o) удаление первого вхождения объекта в списке;
clear() удаление всех элементов;
isEmpty() определяет, содержит ли список элементы;
size() число элементов;
set(int index, E element) заменить элемент в указанной позиции новым;
get(int index) получить элемент по указанному индексу;
contains(Object o) определение, содержится ли указанный объект в списке элементов;
lastIndexOf(Object o) поиск последнего вхождения элемента, возвращается индекс элемента или -1;
indexOf(Object o) поиск первого вхождения элемента, возвращается индекс элемента или -1;
toArray() возвращает копию в виде статического массива;
toArray(T[] a) сохраняет элементы в указанный массив.
Пример работы с динамическим массивом целых чисел:
package tsn01.arraylist;
import java.util.ArrayList;
public class TSN01_ArrayList {
public static void main(String[] args) {
// Работа с динамическим массивом чисел
ArrayList<Integer> i = new ArrayList<>(); // Создание динамического массива целых чисел
i.add(3); // Добавление значения
i.add(new Integer(3)); // Добавление значения
if (i.get(0)==i.get(1)) { System.out.println("Эта строчка не напечатается"); }
if (i.get(0).equals(i.get(1))) { System.out.println("3=3"); }
i.add(12+5); // Добавление значения
System.out.println("Размер массива: " + i.size());
System.out.println("Элементы массива: " + i.get(0).intValue() + ", " + i.get(1)+ ", " + i.get(2));
}
}
Результат работы программы:
3=3
Размер массива: 3
Элементы массива: 3, 3, 17
Пример работы с динамическим массивом строк:
package tsn01.arraylist;
import java.util.ArrayList;
public class TSN01_ArrayList {
public static void main(String[] args) {
// Работа с динамическим массивом строк
ArrayList<String> pozdr = new ArrayList<>(); // Массив пожеланий
ArrayList<String> fam = new ArrayList<>(); // Массив фамилий
// Добавление поздравления в массив
pozdr.add("Удачи"); pozdr.add("Здоровья"); pozdr.add("Денег");
// добавление фамилии в массив
fam.add("Петров"); fam.add("Сидоров"); fam.add("Иванов");
// Проверка количества поздравлений
if (fam.size() > pozdr.size()) { return; }
for (int i = 0; i < fam.size(); i++) {
// Генерируем случайное число в диапазоне от 0 до длины массива поздравлений
int p = (int) Math.floor(Math.random() * pozdr.size());
// Генерация поздравления
System.out.println("Уважаемый " + fam.get(i)
+ "! Поздравляем Вас с этим прекрасным праздником, и желаем Вам "
+ pozdr.get(p).toString().toLowerCase() + "!");
pozdr.remove(p); // Удаляем элемент с индексом р из массива поздравлений
} }
}
1.8 Работа со строками
В Java имеется три типа строк: String, StringBuilder и StringBuffer. Статические строки «String» обычные строки в Java, в которых нельзя изменить символы и их количество после создания строки.
Динамические строки «StringBuilder» изменяемые строки для использования в однопоточных программах. В однопоточном использовании StringBuilder практически всегда в 1.2-1.5 раза быстрее, чем StringBuffer.
Динамические строки StringBuffer изменяемые строки для использования в многопоточных программах. Самый медленный тип, но потокобезопасный.
Переменные типа динамических строк могут менять свои значения и длину во время выполнения программы.
Статические строки. Обычные строки в Java описываются классом String и являются статическими, т.е. в существующей строке нельзя изменить символы и их количество.
Кроме стандартного создания оператором new, строки могут быть созданы напрямую из строковой литералы. При этом в целях оптимизации, объекты созданные таким образом дополнительно сохраняются в отдельной области строковый пул.
String s1 = "d" // строка будет сохранена в пуле
// строка не будет сохранена в пуле и будет уничтожена сборщиком мусора
String s2 = new String("a");
Один из плюсов разделения строк на статические и динамические это повышение безопасности там, где строки используются в качестве аргументов (например, открытие баз данных, интернет соединений, механизм загрузки классов).
Операция сцепления. Для строк доступна операция +, позволяющая соединить несколько строк в одну. Если один из операндов не строка, то он автоматически преобразуется в строку. Для объектов в этих целях используется метод toString.
При каждой операции внутренне используется объект динамической строки StringBuilder или StringBuffer. Поэтому для собирания строки из нескольких все равно оптимальней использовать сразу один StringBuilder/StringBuffer.
Выделение подстроки. Есть замечание относительно метода substring возвращаемая строка использует тот же байтовый массив, что и исходная. Например, вы загрузили строку А из файла в 1мб. Что-то там нашли и выделили в отдельную строку Б длиной в 3 символа. Строка Б в реальности тоже занимает те же 1мб.
String s ="very .... long string from file";
String sub1 = s.substring(2,4); // совместно использует ту же память что и s