Архив метки: Java

Конкатенация строк Java

Для конкатенации (объединения) строк в языке Java применяется знак «+». Выведем «Привет, мир!» с помощью конкатенации.

public class JavaApplication1 {

    public static void main(String[] args) {

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

        String a = "Привет, ";
        String b = "мир!";

        System.out.println(a + b);
    }
}

public class JavaApplication1 {

public static void main(String[] args) {

//Задаём каждое слово в виде переменной,

//Пробелы также нужно указать внутри кавычек, иначе строка склеится без них.

String a = "Привет, ";

String b = "мир!";

System.out.println(a + b);

}

Если при конкатенации одно из значений не является значением строкового типа, то оно автоматически преобразуется в строку. Подробнее в примере.

public class JavaApplication1 {

    public static void main(String[] args) {
        
        //Соединим строку с числом.
        //Число преобразуется в строку, происходит конкатенация.
        String a = "Строка ";
        int b = 1;
        System.out.println(a + b);
        
        //В следующем коде конкатенации не получится.
        //Вместо этого произойдёт арифметическое сложение значений.
        //На экран выведется 2.
        int c = 1;
        int d = 1;
        System.out.println(c + d);
        
        //Для "склеивания" двух чисел вставьте пустую строку между ними.
        //В консоли будет 11.
        System.out.println(c +""+ d);
        
        //Если пустую строку вставлять в начале выражения, то произойдёт
        //сначала преобразование чисел в строку, затем их конкатенация.
        //В консоли будет 11.
        System.out.println("" + c + d);
        
        //Но если поместить пустую (или непустую) строку после
        //двух числовых типов, то сначала произойдёт арифметическое сложение,
        //затем последует конкатенация полученного значения со строкой.
        //В консоли будет 2.
        System.out.println(c + d + "");
        
        //Всегда можно воспользоваться скобками.
        //В консоли будет 2.
        System.out.println("" + (c + d));
    }
}

public class JavaApplication1 {

public static void main(String[] args) {

//Соединим строку с числом.

//Число преобразуется в строку, происходит конкатенация.

String a = "Строка ";

int b = 1;

System.out.println(a + b);

//В следующем коде конкатенации не получится.

//Вместо этого произойдёт арифметическое сложение значений.

//На экран выведется 2.

int c = 1;

int d = 1;

System.out.println(c + d);

//Для "склеивания" двух чисел вставьте пустую строку между ними.

//В консоли будет 11.

System.out.println(c +""+ d);

//Если пустую строку вставлять в начале выражения, то произойдёт

//сначала преобразование чисел в строку, затем их конкатенация.

//В консоли будет 11.

System.out.println("" + c + d);

//Но если поместить пустую (или непустую) строку после

//двух числовых типов, то сначала произойдёт арифметическое сложение,

//затем последует конкатенация полученного значения со строкой.

//В консоли будет 2.

System.out.println(c + d + "");

//Всегда можно воспользоваться скобками.

//В консоли будет 2.

System.out.println("" + (c + d));

}

Управляющие последовательности Java

Управляющая последовательность (Escape Sequence, escape-последовательность) начинается со знака обратной косой черты, после которого идёт один из описанных в таблице символов. Последовательность Описание Unicode \b возврат на одну позицию \u0008 \t табуляция \u0009 \n перевод строки \u 000A \f прогон страницы \u000C \r возврат каретки \u000D \” двойная кавычка \u0022 \’ одинарная кавычка \u0027… Читать далее »

Приоритет операций Java

Во время выполнения операций можно задавать приоритет выполнения с помощью скобок (операции в скобках выполняются раньше). Если скобки отсутствуют, выполняются сначала более приоритетные операции. Ниже приведена таблица приоритета выполнения операций. Оператор Описание Ассоциативность ++, — постинкремент, постдекремент справа налево ++, —, +, -, ~, ! преинкремент, предекремент, унарный плюс, унарный минус, поразрядное дополнение,… Читать далее »

Ключевые слова Java

В языке Java есть 50 ключевых слов: abstract — абстрактный метод, абстрактный класс; assert — отладка программы; boolean — булев тип; break — оператор для выхода из цикла или оператора switch; byte — целочисленный тип; case — переключатель оператора switch; catch — оператор обработки исключений; char — символьный тип; class — класс; const; continue —… Читать далее »

Примитивные типы Java

Java — строго типизированный язык (необходимо объявлять тип каждой переменной). В Java восемь простых (примитивных) типов: boolean иcпользуется для вычисления логических выражений, имеет значения true(истина) или false(ложь), не преобразуется в целочисленные типы, и они не преобразуются в булев тип, занимает 1 байт; char применяется для представления одного символа Unicode, диапазон значений от \u0000 до \uFFFF… Читать далее »

Заполнение двумерного массива по спирали

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

public class JavaApplication1 {

    public static void main(String[] args) {
        //Заполним массив, количество строк мы обозначим m, а столбцов - n.
        int m = 5;
        int n = 5;

        //С помощью переменной s задаются числа внутри массива начиная с 1.
        int s = 1;

        //Объявляем и инициализируем массив.
        int[][] array = new int[m][n];

        //Заполняем периметр массива по часовой стрелке.
        for (int y = 0; y < n; y++) {
            array[0][y] = s;
            s++;
        }
        for (int x = 1; x < m; x++) {
            array[x][n - 1] = s;
            s++;
        }
        for (int y = n - 2; y >= 0; y--) {
            array[m - 1][y] = s;
            s++;
        }
        for (int x = m - 2; x > 0; x--) {
            array[x][0] = s;
            s++;
        }

        //Периметр заполнен. Продолжаем заполнять массив и задаём
        //координаты ячейки, которую необходимо заполнить следующей.
        int c = 1;
        int d = 1;

        while (s < m * n) {
            //В Java инициализированный интовый массив заполняется нулями.
            //Периметр мы заполнили числами, отличными от нулей.
            //Следующие циклы поочерёдно работают, заполняя ячейки.
            //Вложенный цикл останавливается, если следующая ячейка имеет 
            //значение, отличное от ноля. Ячейка, на которой остановился 
            //цикл, не заполняется.

            //Движемся вправо.
            while (array[c][d + 1] == 0) {
                array[c][d] = s;
                s++;
                d++;
            }

            //Движемся вниз.
            while (array[c + 1][d] == 0) {
                array[c][d] = s;
                s++;
                c++;
            }

            //Движемся влево.
            while (array[c][d - 1] == 0) {
                array[c][d] = s;
                s++;
                d--;
            }

            //Движемся вверх.
            while (array[c - 1][d] == 0) {
                array[c][d] = s;
                s++;
                c--;
            }
        }

        //При данном решении в центре всегда остаётся незаполненная ячейка.
        //Убираем её при помощи следующего цикла.
        for (int x = 0; x < m; x++) {
            for (int y = 0; y < n; y++) {
                if (array[x][y] == 0) {
                    array[x][y] = s;
                }
            }
        }

        //Выводим массив в консоль.
        for (int x = 0; x < m; x++) {
            for (int y = 0; y < n; y++) {
                if (array[x][y] < 10) {
                    //Два пробела, чтобы в консоли столбцы были ровные.
                    System.out.print(array[x][y] + ",  ");
                } else {
                    System.out.print(array[x][y] + ", ");
                }
            }
            System.out.println("");
        }
    }
}

public class JavaApplication1 {

public static void main(String[] args) {

//Заполним массив, количество строк мы обозначим m, а столбцов - n.

int m = 5;

int n = 5;

//С помощью переменной s задаются числа внутри массива начиная с 1.

int s = 1;

//Объявляем и инициализируем массив.

int[][] array = new int[m][n];

//Заполняем периметр массива по часовой стрелке.

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

array[0][y] = s;

s++;

}

for (int x = 1; x < m; x++) {

array[x][n - 1] = s;

s++;

}

for (int y = n - 2; y >= 0; y--) {

array[m - 1][y] = s;

s++;

}

for (int x = m - 2; x > 0; x--) {

array[x][0] = s;

s++;

}

//Периметр заполнен. Продолжаем заполнять массив и задаём

//координаты ячейки, которую необходимо заполнить следующей.

int c = 1;

int d = 1;

while (s < m * n) {

//В Java инициализированный интовый массив заполняется нулями.

//Периметр мы заполнили числами, отличными от нулей.

//Следующие циклы поочерёдно работают, заполняя ячейки.

//Вложенный цикл останавливается, если следующая ячейка имеет

//значение, отличное от ноля. Ячейка, на которой остановился

//цикл, не заполняется.

//Движемся вправо.

while (array[c][d + 1] == 0) {

array[c][d] = s;

s++;

d++;

}

//Движемся вниз.

while (array[c + 1][d] == 0) {

array[c][d] = s;

s++;

c++;

}

//Движемся влево.

while (array[c][d - 1] == 0) {

array[c][d] = s;

s++;

d--;

}

//Движемся вверх.

while (array[c - 1][d] == 0) {

array[c][d] = s;

s++;

c--;

}

//При данном решении в центре всегда остаётся незаполненная ячейка.

//Убираем её при помощи следующего цикла.

for (int x = 0; x < m; x++) {

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

if (array[x][y] == 0) {

array[x][y] = s;

}

//Выводим массив в консоль.

for (int x = 0; x < m; x++) {

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

if (array[x][y] < 10) {

//Два пробела, чтобы в консоли столбцы были ровные.

System.out.print(array[x][y] + ", ");

} else {

System.out.print(array[x][y] + ", ");

}

System.out.println("");

}

В консоли видим: 1, 2, 3, 4, 5, 16, 17, 18, 19, 6, 15, 24, 25, 20, 7,… Читать далее »

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

Возьмём две переменные x и y, поменяем местами их значения, выведем на экран.

public class JavaApplication1 {

    public static void main(String[] args) {
        //Зададим переменные.
        System.out.println("Возьмём две переменные:");
        System.out.println("x = 25,  y = 15.");
        int x = 25;
        int y = 15;

        //Меняем их местами с помощью введения третьей переменной.
        int c = x;
        x = y;
        y = c;
        System.out.println("Внимание, x = " + x + ", а y = " + y + ".");

        //Поменяем их обратно вторым способом.
        x = x + y;
        y = x - y;
        x = x - y;
        System.out.println("А теперь x = " + x + ", а y = " + y + ".");

        //Третий способ.
        x = x * y;
        y = x / y;
        x = x / y;
        System.out.println("И снова x = " + x + ", а y = " + y + ".");

        //Четвёртый способ с битовой операцией "исключающее или".
        x = x ^ y;
        y = y ^ x;
        x = x ^ y;
        System.out.println("Ну вот, опять х = " + x + ", а y = " + y + ".");
    }
}

public class JavaApplication1 {

public static void main(String[] args) {

//Зададим переменные.

System.out.println("Возьмём две переменные:");

System.out.println("x = 25, y = 15.");

int x = 25;

int y = 15;

//Меняем их местами с помощью введения третьей переменной.

int c = x;

x = y;

y = c;

System.out.println("Внимание, x = " + x + ", а y = " + y + ".");

//Поменяем их обратно вторым способом.

x = x + y;

y = x - y;

x = x - y;

System.out.println("А теперь x = " + x + ", а y = " + y + ".");

//Третий способ.

x = x * y;

y = x / y;

x = x / y;

System.out.println("И снова x = " + x + ", а y = " + y + ".");

//Четвёртый способ с битовой операцией "исключающее или".

x = x ^ y;

y = y ^ x;

x = x ^ y;

System.out.println("Ну вот, опять х = " + x + ", а y = " + y + ".");

}

В консоли на выходе получим следующее: Возьмём две переменные: x = 25, y = 15. Внимание, x = 15, а y = 25. А теперь x = 25, а y = 15. И снова x = 15, а y = 25.… Читать далее »