Исключающее или java. Изучаем Java
Последнее обновление: 31.10.2015
Конкатенация
Конкатенация строк или объединение может производиться как с помощью операции + , так и с помощью метода Concat:
String s1 = "hello"; string s2 = "world"; string s3 = s1 + " " + s2; // результат: строка "hello world" string s4 = String.Concat(s3, "!!!"); // результат: строка "hello world!!!" Console.WriteLine(s4);
Метод Concat является статическим методом класса String, принимающим в качестве параметров две строки. Также имеются другие версии метода, принимающие другое количество параметров.
Для объединения строк также может использоваться метод Join:
String s5 = "apple"; string s6 = "a day"; string s7 = "keeps"; string s8 = "a doctor"; string s9 = "away"; string values = new string { s5, s6, s7, s8, s9 }; String s10 = String.Join(" ", values); // результат: строка "apple a day keeps a doctor away"
Метод Join также является статическим. Использованная выше версия метода получает два параметра: строку-разделитель (в данном случае пробел) и массив строк, которые будут соединяться и разделяться разделителем.
Сравнение строк
Для сравнения строк применяется статический метод Compare:
String s1 = "hello"; string s2 = "world"; int result = String.Compare(s1, s2); if (result<0) { Console.WriteLine("Строка s1 перед строкой s2"); } else if (result > 0) { Console.WriteLine("Строка s1 стоит после строки s2"); } else { Console.WriteLine("Строки s1 и s2 идентичны"); } // результатом будет "Строка s1 перед строкой s2"
Данная версия метода Compare принимает две строки и возвращает число. Если первая строка по алфавиту стоит выше второй, то возвращается число меньше нуля. В противном случае возвращается число больше нуля. И третий случай - если строки равны, то возвращается число 0.
В данном случае так как символ h по алфавиту стоит выше символа w, то и первая строка будет стоять выше.
Поиск в строке
С помощью метода IndexOf мы можем определить индекс первого вхождения отдельного символа или подстроки в строке:
String s1 = "hello world"; char ch = "o"; int indexOfChar = s1.IndexOf(ch); // равно 4 Console.WriteLine(indexOfChar); string subString = "wor"; int indexOfSubstring = s1.IndexOf(subString); // равно 6 Console.WriteLine(indexOfSubstring);
Подобным образом действует метод LastIndexOf , только находит индекс последнего вхождения символа или подстроки в строку.
Еще одна группа методов позволяет узнать начинается или заканчивается ли строка на определенную подстроку. Для этого предназначены методы StartsWith и EndsWith . Например, у нас есть задача удалить из папки все файлы с расширением exe:
String path = @"C:\SomeDir"; string files = Directory.GetFiles(path); for (int i = 0; i < files.Length; i++) { if(files[i].EndsWith(".exe")) File.Delete(files[i]); }
Разделение строк
С помощью функции Split мы можем разделить строку на массив подстрок. В качестве параметра функция Split принимает массив символов или строк, которые и будут служить разделителями. Например, подсчитаем количество слов в сроке, разделив ее по пробельным символам:
String text = "И поэтому все так произошло"; string words = text.Split(new char { " " }); foreach (string s in words) { Console.WriteLine(s); }
Это не лучший способ разделения по пробелам, так как во входной строке у нас могло бы быть несколько подряд идущих пробелов и в итоговый массив также бы попадали пробелы, поэтому лучше использовать другую версию метода:
String words = text.Split(new char { " " }, StringSplitOptions.RemoveEmptyEntries);
Второй параметр StringSplitOptions.RemoveEmptyEntries говорит, что надо удалить все пустые подстроки.
Обрезка строки
Для обрезки начальных или концевых символов используется функция Trim:
String text = " hello world "; text = text.Trim(); // результат "hello world" text = text.Trim(new char { "d", "h" }); // результат "ello worl"
Функция Trim без параметров обрезает начальные и конечные пробелы и возвращает обрезанную строку. Чтобы явным образом указать, какие начальные и конечные символы следует обрезать, мы можем передать в функцию массив этих символов.
Эта функция имеет частичные аналоги: функция TrimStart обрезает начальные символы, а функция TrimEnd обрезает конечные символы.
Обрезать определенную часть строки позволяет функция Substring :
String text = "Хороший день"; // обрезаем начиная с третьего символа text = text.Substring(2); // результат "роший день" Console.WriteLine(text); // обрезаем сначала до последних двух символов text = text.Substring(0, text.Length - 2); // результат "роший де" Console.WriteLine(text);
Функция Substring также возвращает обрезанную строку. В качестве параметра первая использованная версия применяет индекс, начиная с которого надо обрезать строку. Вторая версия применяет два параметра - индекс начала обрезки и длину вырезаемой части строки.
Вставка
Для вставки одной строки в другую применяется функция Insert:
String text = "Хороший день"; string subString = "замечательный "; text = text.Insert(8, subString); Console.WriteLine(text);
Первым параметром в функции Insert является индекс, по которому надо вставлять подстроку, а второй параметр - собственно подстрока.
Удаление строк
Удалить часть строки помогает метод Remove:
String text = "Хороший день"; // индекс последнего символа int ind = text.Length - 1; // вырезаем последний символ text = text.Remove(ind); Console.WriteLine(text); // вырезаем первые два символа text = text.Remove(0, 2);
Первая версия метода Remove принимает индекс в строке, начиная с которого надо удалить все символы. Вторая версия принимает еще один параметр - сколько символов надо удалить.
Замена
Чтобы заменить один символ или подстроку на другую, применяется метод Replace :
String text = "хороший день"; text = text.Replace("хороший", "плохой"); Console.WriteLine(text); text = text.Replace("о", ""); Console.WriteLine(text);
Во втором случае применения функции Replace строка из одного символа "о" заменяется на пустую строку, то есть фактически удаляется из текста. Подобным способом легко удалять какой-то определенный текст в строках.
Смена регистра
Для приведения строки к верхнему и нижнему регистру используются соответственно функции ToUpper() и ToLower() :
String hello = "Hello world!"; Console.WriteLine(hello.ToLower()); // hello world! Console.WriteLine(hello.ToUpper()); // HELLO WORLD!
Класс Convert
Класс Console
Основные классы
Оператор switch
Полноценный логический тип данных
Помните, как замысловато был представлен логический тип данных в C – числовое значение 0 воспринималось как «ложь», а любое другое – как «истина». Так что цикл while(5){. . .} хотя и выглядел странновато, оказывался бесконечным циклом. Кроме того, в C операция присваивания имела два результата – побочный (сам факт копирования значения в правую часть) и основной – значение правой части после присваивания. Это позволяло выполнять цепочечные присваивания (a=b=c;). В силу этих двух особенностей многие невнимательные программисты (а кто же всегда будет внимателен?) допускали маленькую опечатку – вместо операции сравнения == в условных выражения использовали операцию присваивания =). Хуже всего, что с точки зрения компилятора эта конструкция воспринималась правильно. В результате цикл while(a=5){. . .} также становился бесконечным циклом.
В языке C# никакого хитроумного моделирования логических значений нет – вместо этого имеется полноценный логический тип bool, на самом деле реализованный классом Boolean (помните int и Int32?).
В результате компилятор обнаруживает ошибку в условном выражении a=1 и сообщает, что не может неявно преобразовать целую величину в логическую.
Отметим две особенности, отличающие оператор switch в языках C# и C++:
1. C# не поддерживает “провала” передачи управления, возникающего при отсутствии оператора break.
Фрагмент программы
{ case 1: cout<<”Один”;
case 2: cout<<”Два”;
case 3: cout<<”Три”;
case 4: cout<<”Четыре”;
приводил к выводу на экран строки «ДваТриЧетыре».
{ case 1: Console.Write(”Один”); break;
case 2: Console.Write(”Два”); break;
case 3: Console.Write(”Три”); break;
case 4: Console.Write(”Четыре”); break;
В результате на экране появится только слово «Два»
2. В качестве выражения и констант, отмечающих варианты оператора switch можно использовать строковые данные (тип string)
string a; a=”Два”;
{ case ”Один”: Console.Write(1); break;
case ”Два”: Console.Write(2); break;
case ”Три”: Console.Write(3); break;
case ”Четыре”: Console.Write(4); break;
Такой фрагмент выводит на экран число 2.
Ниже рассмотрим использование наиболее популярных классов платформы.NET
Как вы уже успели заметить, этот класс используется для организации взаимодействия пользователя с компьютером с помощью двух устройств: клавиатура (для ввода информации) и монитор (для вывода). В предыдущих примерах были использованы методы ReadLine и WriteLine. Отметим ещё одну полезную особенность метода WriteLine.
Допустим, нужно вывести на экран значения трёх переменных x, y и z. это можно сделать следующим образом:
Console.WriteLine(“x=”+x+”, y=”+y+”, z=”+z);
При вводе такого оператора приходится внимательно следить за соблюдением порядка множества элементов, составляющих параметр метода. Намного удобнее этой же цели добиться иначе:
Console.WriteLine(“x={0}, y={1}, z={2}”,x,y,z);
В этом случае метод WriteLine имеет несколько параметров. Первый обязательно является строкой, определяющей структуру выводимой информации. В этой строке присутствуют специальные элементы ({0}{1}{2}), вместо которых выводятся значения соответствующих других параметров (в нашем примере x, y и z).
Кроме ReadLine и WriteLine класс Console содержит дополнительные методы для управления клавиатурой и выводом информации на монитор. Например, с помощью метода SetCursorPosition можно управлять позицией курсора.
Мы уже знаем о существовании метода ToInt32, осуществляющего преобразование в целое число. Кроме того, в этом классе имеется ещё ряд методов преобразования: ToBoolean, ToByte, ToChar, ToDateTime, ToDecimal, ToDouble, ToSingle, ToString. Этот (неполный!) перечень методов позволяет сделать следующие выводы:
1. Система основных типов языка в основном унаследована от языка С++, однако, в ней появились и новшества.
Как уже говорилось, в C# имеется полноценный логический тип данных Boolean.
Тип Decimal это разновидность вещественного типа данных используемого, когда важно избежать накопления погрешностей вычислений.
Два основных вещественных типа языка C++ (float и double) в C# «поменялись местами» - стандартным теперь является Double. Это означает, что вещественные константы, записываемые обычным образом, относятся к типу Double. Поэтому оператор a = 0.5 будет признан компилятором ошибочным (несовместимость типов в присваивании), если переменная a имеет тип float.
Преобразованием в тип float занимается метод ToSingle.
2. Каждый из методов преобразования является перегруженным. Это позволяет применять метод с одним и тем же именем для преобразования разнотипной исходной информации. Например:
Convert.ToInt32(3.2);
Convert.ToInt32(false);
Convert.ToInt32(“Hello”);
В связи с этим полезно будет выполнть следующее задание: написать программу, проверяющую результаты применения методов преобразования к различным типам данных. Выявить комбинации типов, приводящие к ошибкам и дать этому объяснение.
Строковый тип данных string (класс String)
Работу со строками символов в.NET очень удобно осуществлять с помощью типа данных String из пространства имен System. Переменные этого типа можно описывать также с помощью ключевого слова string.
Переменная строкового типа может получить свое значение несколькими способами:
1. Присваиванием строковой константы или строкового выражения:
name=”John”;
name=”Mr. ” + name; //для строк + действует как конкатенация
2. Путем ввода с клавиатуры
name=Console.Readline();
Сравнивать строки можно операциями == (равно) и!= (не равно). При этом проверяется точное совпадение содержимого этих строк. Однако применять для сравнения операции <, >, >= и <= нельзя. Для таких сравнений существует специальный метод Compare в классе String.
В C# сохранилась возможность работать со строкой как с массивом символов.
В следующем фрагменте программы проиллюстрированы некоторые из перечисленных возможностей:
s1 = Console.ReadLine().ToLower();
s2 = ""; //строка может быть пустой
for (int i = 0; i < s1.Length; i++) s2 += s1;
Console.WriteLine(s2);
Здесь сначала описываются две строковые переменные s1 и s2. Далее с помощью метода ToLower вводимая с клавиатуры строка переводится в нижний регистр и результат присваивается переменной s1. Обратите внимание на цепочку вызовов методов Console.ReadLine().ToLower(). Сначала ReadLine возвращает строку, а затем ToLower переводит ее в нижний регистр.
Далее выполняется цикл, переворачивающий содержимое строки s1. Перевернутое содержимое оказывается в строке s2. Обратите внимание на то, что для определения длины строки используется Length. Вы не видите спика параметров в круглых скобках после Length. Это значит, что Length не является методом, а свойством класса. Позже мы обсудим свойства подробнее.
Обращение к символам строки с помощью индексации возможно только для чтения. Попытка изменить строку с помощью индексации приводит к ошибке компиляции:
s=’!’; //Ошибка
Класс String предлагает обширный набор полезных методов. В следующей таблице указаны некоторые из них.
Таблица членов класса String
| Член | Описание |
| Length | Свойство, возвращающее длину текущей строки |
| Compare() и CompareTo() | Методы, сравнивающие два заданных объекта String и возвращающие целое число (0,1,-1), которое показывает их связь друг с другом в порядке сортировки |
| Contains() | Метод, применяемый для выяснения того, содержит ли текущий строковый объект данную строку |
| Copy() | Метод, создающий новый экземпляр String, имеющий то же значение, что и заданный экземпляр String |
| CopyTo() | Метод, копирующий заданное число знаков начиная с указанной позиции в этом экземпляре до указанной позиции в массиве знаков Юникода |
| EndsWith() и StartsWith() | Методы, определяющие, совпадает ли конец (начало) экземпляра String с указанной строкой |
| Format() | Метод, который заменяет каждый элемент формата в указанном объекте String текстовым эквивалентом значения соответствующего объекта |
| IndexOf() | Метод, возвращающий индекс первого вхождения String или одного или нескольких знаков в данной строке |
| IndexOfAny() | Метод, возвращающий индекс первого обнаруженного в данном экземпляре знака из указанного массива знаков Юникода |
| Insert() | Метод, используемый для получения копии текущей строки, содержащей добавляемые строковые данные |
| Join() | Метод, который вставляет заданный разделитель типа String между элементами заданного массива String, создавая одну сцепленную строку |
| LastIndexOf() | Возвращает индекс последнего вхождения указанного знака Юникода или String в пределах данного экземпляра |
| LastIndexOfAny() | Возвращает индекс последнего вхождения в данном экземпляре какого-либо одного или нескольких знаков, указанных в массиве знаков Юникод |
| PadLeft() и PadRight() | Выравнивает знаки в данном экземпляре по левому (правому) краю, добавляя справа (слева) пробелы или указанные знаки Юникода до указанной общей длины |
| Remove() Replace() | Методы, используемые для получения копии строки с соответствующими модификациями (при удалении или замене символов) |
| Split() | Возвращает строковый массив, содержащий подстроки данного экземпляра, разделенные элементами заданной строки или массива знаков Юникода |
| Substring() | Метод, возвращающий строку, которая представляет подстроку текущей отроки |
| ToCharArray() | Метод, возвращающий массив символов, из которых состоит текущая строка |
| ToUpper() ToLower() | Методы, создающие копию данной строки, представленную символами в верхнем или, соответственно, нижнем регистре |
| Trim() | Удаляет все начальные и конечные вхождения заданных наборов знаков из текущего объекта String |
| TrimEnd() и TrimStart() | Удаляет все конечные (начальные) вхождения набора знаков, заданного в виде массива, из текущего объекта String |
Рассмотрим подробнее использование некоторых методов класса String.
Английское слово split означает «разбить на части». Одним вызовом этого метода можно решить популярную задачу разбиения текста на некоторые фрагменты.
Рассмотрим следующую постановку задачи:
Дан некоторый текст. Определить среднюю длину всех слов, содержащихся в этом тексте. Слова отделяются друг от друга одним или несколькими символами-разделителями, в число которых входят пробел, запятая и точка.
Очевидно, что для решения этой задачи нужно выделять в тексте отдельные слова. Это достаточно сложный циклический процесс, поскольку слова отделяются друг от друга множеством разных символов-разделителей. Именно эту задачу решает метод Split.
Исходную строку можно получить путём ввода с клавиатуры.
string text = Console.ReadLine();
Для успешной работы методу Split нужно передать параметр – массив символов-разделителей.
char separators = new char {" ", ",", "."};
(читатели, знакомые с массивами в языке С++ заметят, что описание и инициализация массивов в C# выглядит несколько иначе; об этом подробнее будет рассказано далее).
Метод Split в результате своей работы возвращает массив строк, полученных в результате выделения их из всего текста на основе информации о символах-разделителях.
string words = text.Split(separators);
Вот и всё! Однако, в этой короткой строчке содержится очень важное новшество, непосредственно относящее к объектно-ориентированному программированию. Метод Split вызывается в форме text.Split(…), то есть метод Split как будто принадлежит строковой переменной text. Это действительно правильная точка зрения, которую Вы должны усвоить в ходе этого курса. Будьте внимательны, поскольку некоторые методы класса String вызываются «от имени» класса, например, String.Format(…). Такие методы называются статическими . Методы, подобные Split называются нестатическими или методами экземпляра класса.
Теперь, имея массив слов текста легко окончательно решить задачу – найти среднюю длину всех слов. Для этого будет использован стандартный циклический алгоритм суммирования.
for(int i = 0; i double aL = Convert.ToDouble(L) / words.Length; Здесь мы видим, что по своей форме цикл for в C# такой же, как и в С++. Новшеством является удобная возможность задать границу цикла (количество
элементов массива!) с помощью свойства
Length массива words, то есть массив сам содержит информацию о своём размере. Аналогично можно определить и длину (количество символов) одной строки: words[i].Length. Приведение Convert.ToDouble понадобилось для того, чтобы операция «деления» выдала вещественный, а не целый результат. В C# имеется возможность несколько улучшить последний цикл, используя новую разновидность оператора цикла – foreach. foreach(string w in words) L += w.Length; Для читателя, знающего английский язык, этот цикл выглядит очень естественно, поскольку хорошо «переводится» на «человеческий» язык. В переводе на русский это звучит примерно так: «Для каждой строки w из words выполнить некоторое действие». Формальный синтаксис этого оператора следующий: foreach(<тип> <переменная> in
<массив>)
<тело цикла>;
Несмотря на правильную структуру, эта программа выдаёт неверный результат. Причина этого станет понятнее, если в цикл добавить вывод слов на экран. foreach(…) { Console.WriteLine(w); L += w.Length; } Выполнение программы с входной строкой " yes, no hello." покажет, что метод Split разбил эту строку не на три, а на шесть строк: пустая строка, “yes”, пустая строка, “no”,“hello”, пустая строка. Это произошло потому, что метод Split считает «словом» любую строку, расположенную между символами-разделителями. Чтобы избавиться от этой проблемы можно «заставить» метод Split работать несколько иначе – не
выделять в качестве «слов» пустые строки между соседними символами-разделителями. Для этого в метод Split нужно передать дополнительный
параметр - StringSplitOptions.RemoveEmptyEntries. Теперь вызов метода выглядит так: text.Split(separators, StringSplitOptions.RemoveEmptyEntries); Здесь мы опять встречаемся с использованием перегруженного варианта метода, который, благодаря дополнительному параметру, исключает пустые строки. Ещё больший интерес представляет форма записи и тип этого параметра. Тип параметра является перечислением
(подробнее об этом в следующем параграфе). Java предоставляет богатый набор операторов для управления переменными. Все операторы Java можно разделить на следующие группы: Арифметические операторы
- используются в математических выражениях таким же образом, как они используются в алгебре. Предположим, целая переменная A равна 10, а переменная B равна 20. В следующей таблице перечислены арифметические операторы в Java: Следующий простой пример показывает программно арифметические операторы. Скопируйте и вставьте следующий java-код в файл test.java, скомпилируйте и запустить эту программу: Public class Test {
public static void main(String args) {
int a = 10;
int b = 20;
int c = 25;
int d = 25;
System.out.println("a + b = " + (a + b));
System.out.println("a - b = " + (a - b));
System.out.println("a * b = " + (a * b));
System.out.println("b / a = " + (b / a));
System.out.println("b % a = " + (b % a));
System.out.println("c % a = " + (c % a));
System.out.println("a++ = " + (a++));
System.out.println("b-- = " + (a--));
// Проверьте разницу в d++ и ++d
System.out.println("d++ = " + (d++));
System.out.println("++d = " + (++d));
}
}
A + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
a++ = 10
b-- = 11
d++ = 25
++d = 27
Есть следующие операторы сравнения, поддерживаемые на языке Java. Предположим, переменная A равна 10, а переменная B равна 20. В следующей таблице перечислены реляционные операторы или операторы сравнения в Java: Следующий простой пример показывает, программно операторы сравнения в Java. Скопируйте и вставьте следующий java-код в файл test.java, скомпилируйте и запустить эту программу: Public class Test {
public static void main(String args) {
int a = 10;
int b = 20;
System.out.println("a == b = " + (a == b));
System.out.println("a != b = " + (a != b));
System.out.println("a > b = " + (a > b));
System.out.println("a = a = " + (b >= a));
System.out.println("b
A == b = false
a != b = true
a > b = false
a = a = true
b
Java определяет несколько побитовых операторов, которые могут быть применены для целочисленных типов: int, long, short, char и byte. В Java побитовый оператор работает над битами и выполняет операцию бит за битом. Предположим, если a = 60; и b = 13; то в двоичном формате они будут следующие: a = 0011 1100
Предположим целочисленные переменная A равна 60, а переменная B равна 13. В следующей таблице перечислены побитовые операторы в Java: Следующий простой пример показывает, программно побитовые операторы в Java. Скопируйте и вставьте следующий java-код в файл test.java, скомпилируйте и запустить эту программу: Public class Test {
public static void main(String args) {
int a = 60; /* 60 = 0011 1100 */
int b = 13; /* 13 = 0000 1101 */
int c = 0;
c = a & b; /* 12 = 0000 1100 */
System.out.println("a & b = " + c);
c = a | b; /* 61 = 0011 1101 */
System.out.println("a | b = " + c);
c = a ^ b; /* 49 = 0011 0001 */
System.out.println("a ^ b = " + c);
c = ~a; /*-61 = 1100 0011 */
System.out.println("~a = " + c);
c = a > 2; /* 215 = 1111 */
System.out.println("a >> 2 = " + c);
c = a >>> 2; /* 215 = 0000 1111 */
System.out.println("a >>> 2 = " + c);
}
}
Будет получен следующий результат: A & b = 12
a | b = 61
a ^ b = 49
~a = -61
a > 15
a >>> 15
Предположим, логическая переменная A имеет значение true, а переменная B хранит false. В следующей таблице перечислены логические операторы в Java: Public class Test {
public static void main(String args) {
boolean a = true;
boolean b = false;
System.out.println("a && b = " + (a&&b));
System.out.println("a || b = " + (a||b));
System.out.println("!(a && b) = " + !(a && b));
}
}
Это произведет следующий результат: A && b = false
a || b = true
!(a && b) = true
Существуют следующие операторы присваивания, поддерживаемые языком Java: Следующий простой пример показывает, программно логические операторы в Java. Скопируйте и вставьте следующий java-код в файл test.java, скомпилируйте и запустить эту программу: Public class Test {
public static void main(String args) {
int a = 10;
int b = 20;
int c = 0;
c = a + b;
System.out.println("c = a + b = " + c);
c += a ;
System.out.println("c += a = " + c);
c -= a ;
System.out.println("c -= a = " + c);
c *= a ;
System.out.println("c *= a = " + c);
a = 10;
c = 15;
c /= a ;
System.out.println("c /= a = " + c);
a = 10;
c = 15;
c %= a ;
System.out.println("c %= a = " + c);
c >= 2 ;
System.out.println("c >>= 2 = " + c);
c >>= 2 ;
System.out.println("c >>= a = " + c);
c &= a ;
System.out.println("c &= 2 = " + c);
c ^= a ;
System.out.println("c ^= a = " + c);
c |= a ;
System.out.println("c |= a = " + c);
}
}
Будет получен следующий результат: C = a + b = 30
c += a = 40
c -= a = 30
c *= a = 300
c /= a = 1
c %= a = 5
c >= 2 = 5
c >>= 2 = 1
c &= a = 0
c ^= a = 10
c |= a = 10
Есть несколько других операторов, поддерживаемых языком Java. Тернарный оператор
- оператор, который состоит из трех операндов и используется для оценки выражений типа boolean. Тернарный оператор в Java также известен как условный оператор. Этот. Цель тернарного оператора или условного оператора заключается в том, чтобы решить, какое значение должно быть присвоено переменной. Оператор записывается в виде: Переменная x = (выражение) ? значение if true: значение if false
Ниже приведен пример: Public class Test {
public static void main(String args){
int a , b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println("Значение b: " + b);
b = (a == 10) ? 20: 30;
System.out.println("Значение b: " + b);
}
}
Будет получен следующий результат: Значение b: 30
Значение b: 20
Оператор instanceof
- проверяет, является ли объект определенного типа (типа класса или типа интерфейса) и используется только для переменных ссылочного объекта. Оператор instanceof записывается в виде:
(Переменная ссылочного объекта) instanceof (класс/тип интерфейса)
Если переменная ссылочного объекта в левой части оператора проходит проверку для класса/типа интерфейса на правой стороне, результатом будет значение true. Ниже приведен пример и описание оператора instanceof: Public class Test {
public static void main(String args){
String name = "Олег";
// Следующее вернётся верно, поскольку тип String
boolean result = name instanceof String;
System.out.println(result);
}
}
Будет получен следующий результат: Этот оператор по-прежнему будет возвращать значение true, если сравниваемый объект является совместимым с типом на право назначения. Ниже приводится еще один пример: Class Vehicle {}
public class Car extends Vehicle {
public static void main(String args){
Vehicle a = new Car();
boolean result = a instanceof Car;
System.out.println(result);
}
}
Будет получен следующий результат: Приоритет операторов определяет группирование терминов в выражении. Это влияет как вычисляется выражение. Некоторые операторы имеют более высокий приоритет, чем другие; например оператор умножения имеет более высокий приоритет, чем оператор сложения: Например, x = 7 + 3 * 2. Здесь x присваивается значение 13, не 20, потому что оператор «*» имеет более высокий приоритет, чем «+», так что сначала перемножается «3 * 2», а затем добавляется «7». В таблице операторы с наивысшим приоритетом размещаются в верхней части, и уровень приоритета снижается к нижней части таблицы. В выражении высокий приоритет операторов в Java будет оцениваться слева направо. В следующем уроке поговорим об управлении циклом в программировании на Java. В этом уроке будут описаны различные типы циклов, как циклы могут быть использованы в разработке программ, и для каких целей они используются. Последнее обновление: 30.10.2018 Большинство операций в Java аналогичны тем, которые применяются в других си-подобных языках. Есть унарные операции (выполняются над одним операндом),
бинарные - над двумя операндами, а также тернарные - выполняются над тремя операндами. Операндом является переменная или значение (например, число),
участвующее в операции. Рассмотрим все виды операций. В арифметических операциях участвуют числами. В Java есть бинарные арифметические операции (производятся над двумя операндами) и унарные (выполняются над одним операндом). К бинарным операциям относят
следующие: операция сложения двух чисел: Int a = 10;
int b = 7;
int c = a + b; // 17
int d = 4 + b; // 11 операция вычитания двух чисел: Int a = 10;
int b = 7;
int c = a - b; // 3
int d = 4 - a; // -6 операция умножения двух чисел Int a = 10;
int b = 7;
int c = a * b; // 70
int d = b * 5; // 35 операция деления двух чисел: Int a = 20;
int b = 5;
int c = a / b; // 4
double d = 22.5 / 4.5; // 5.0
При делении стоит учитывать, так как если в операции участвуют два целых числа, то результат деления будет округляться до целого числа, даже если
результат присваивается переменной float или double: Double k = 10 / 4; // 2
System.out.println(k);
Чтобы результат представлял числос плавающей точкой, один из операндов также должен представлять число с плавающей точкой: Double k = 10.0 / 4; // 2.5
System.out.println(k); получение остатка от деления двух чисел: Int a = 33;
int b = 5;
int c = a % b; // 3
int d = 22 % 4; // 2 (22 - 4*5 = 2) Также есть две унарные арифметические операции, которые производятся над одним числом: ++ (инкремент) и -- (декремент). Каждая из операций имеет две разновидности: префиксная и постфиксная: ++ (префиксный инкремент)
Предполагает увеличение переменной на единицу, например, z=++y (вначале значение переменной y увеличивается на 1,
а затем ее значение присваивается переменной z) Int a = 8;
int b = ++a;
System.out.println(a); // 9
System.out.println(b); // 9 ++ (постфиксный инкремент)
Также представляет увеличение переменной на единицу, например, z=y++ (вначале значение переменной y присваивается
переменной z, а потом значение переменной y увеличивается на 1) Int a = 8;
int b = a++;
System.out.println(a); // 9
System.out.println(b); // 8 -- (префиксный декремент) уменьшение переменной на единицу, например, z=--y (вначале значение переменной y уменьшается на 1,
а потом ее значение присваивается переменной z) Int a = 8;
int b = --a;
System.out.println(a); // 7
System.out.println(b); // 7 -- (постфиксный декремент) z=y-- (сначала значение переменной y присваивается переменной z, а затем значение переменной y уменьшается на 1) Int a = 8;
int b = a--;
System.out.println(a); // 7
System.out.println(b); // 8 Одни операции имеют больший приоритет чем другие и поэтому выполняются вначале. Операции в порядке уменьшения приоритета: ++ (инкремент), -- (декремент) * (умножение), / (деление), % (остаток от деления) + (сложение), - (вычитание) Приоритет операций следует учитывать при выполнении набора арифметических выражений: Int a = 8;
int b = 7;
int c = a + 5 * ++b;
System.out.println(c); // 48
Вначале будет выполняться операция инкремента ++b , которая имеет больший приоритет - она увеличит значение переменной b и возвратит его в
качестве результата. Затем выполняется умножение 5 * ++b , и только в последнюю очередь выполняется сложение a + 5 * ++b Скобки позволяют переопределить порядок вычислений: Int a = 8;
int b = 7;
int c = (a + 5) * ++b;
System.out.println(c); // 104
Несмотря на то, что операция сложения имеет меньший приоритет, но вначале будет выполняться именно сложение, а не умножение, так как операция сложения заключена в скобки. Кроме приоритета операции отличаются таким понятием как
ассоциативность
. Когда операции имеют один и тот же приоритет, порядок вычисления определяется
ассоциативностью операторов. В зависимости от ассоциативности есть два типа операторов: Левоассоциативные операторы, которые выполняются слева направо Правоассоциативные операторы, которые выполняются справа налево Так, некоторые операции, например, операции умножения и деления, имеют один и тот же приоритет. Какой же тогда будет результат в выражении: Int x = 10 / 5 * 2;
Стоит нам трактовать это выражение как (10 / 5) * 2 или как 10 / (5 * 2) ? Ведь в зависимости от трактовки мы получим разные результаты. Поскольку все арифметические операторы (кроме префиксного инкремента и декремента) являются левоассоциативными, то есть выполняются слева направо. Поэтому выражение 10 / 5 * 2 необходимо трактовать как (10 / 5) * 2 ,
то есть результатом будет 4. Следует отметить, что числа с плавающей точкой не подходят для финансовых и других вычислений, где ошибки при округлении могут быть критичными. Например: Double d = 2.0 - 1.1;
System.out.println(d);
В данном случае переменная d будет равна не 0.9, как можно было бы изначально предположить, а 0.8999999999999999.
Подобные ошибки точности возникают из-за того, что на низком уровне для представления чисел с плавающей точкой применяется
двоичная система, однако для числа 0.1 не существует двоичного представления, также как и для других дробных значений.
Поэтому если в таких случаях обычно применяется класс BigDecimal, который позволяет обойти подобные сиуации. Большинство операций над примитивными типами выполняется не с помощью методов, а с помощью специальных символов, называемых знаком операции
.
Побитовое И
Побитовое ИЛИ
Побитовое исключающее ИЛИ
Сдвиг влево с учетом знака
Сдвиг вправо с учетом знака
Сдвиг вправо без учета знака
Арифметические операторы
Пример
Операторы сравнения
Оператор
Описание
Пример
==
Проверяет, равны или нет значения двух операндов, если да, то условие становится истинным
(A == B) - не верны
!=
Проверяет, равны или нет значения двух операндов, если значения не равны, то условие становится истинным
(A != B) - значение истинна
>
Проверяет, является ли значение левого операнда больше, чем значение правого операнда, если да, то условие становится истинным
(A > B) - не верны
Проверяет, является ли значение левого операнда меньше, чем значение правого операнда, если да, то условие становится истинным
(A
>=
Проверяет, является ли значение левого операнда больше или равно значению правого операнда, если да, то условие становится истинным
(A >= B) - значение не верны
Проверяет, если значение левого операнда меньше или равно значению правого операнда, если да, то условие становится истинным
(A
Пример
Побитовые операторы
b = 0000 1101
-----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011Оператор
Описание
Пример
& (побитовое и)
Бинарный оператор AND копирует бит в результат, если он существует в обоих операндах.
(A & B) даст 12, который является 0000 1100
| (побитовое или)
Бинарный оператор OR копирует бит, если он существует в любом из операндов.
(A | B) даст 61 который равен 0011 1101
^ (побитовое логическое или)
Бинарный оператор XOR копирует бит, если он установлен в одном операнде, но не в обоих.
(A ^ B) даст 49, которая является 0011 0001
~ (побитовое дополнение)
Бинарный оператор дополнения и имеет эффект «отражения» бит.
(~ A) даст -61, которая является формой дополнением 1100 0011 в двоичной записи
Бинарный оператор сдвига влево. Значение левых операндов перемещается влево на количество бит, заданных правым операндом.
A
>> (сдвиг вправо)
Бинарный оператор сдвига вправо. Значение правых операндов перемещается вправо на количество бит, заданных левых операндом.
A >> 2 даст 15, который является 1111
>>> (нулевой сдвиг вправо)
Нулевой оператор сдвига вправо. Значение левых операндов перемещается вправо на количество бит, заданных правым операндом, а сдвинутые значения заполняются нулями.
A >>> 2 даст 15, который является 0000 1111
Пример
Логические операторы
Пример
Операторы присваивания
Оператор
Описание
Пример
=
Простой оператор присваивания, присваивает значения из правой стороны операндов к левому операнду
C = A + B, присвоит значение A + B в C
+=
Оператор присваивания «Добавления», он присваивает левому операнду значения правого
C += A, эквивалентно C = C + A
-=
Оператор присваивания «Вычитания», он вычитает из правого операнда левый операнд
C -= A, эквивалентно C = C - A
*=
Оператор присваивания «Умножение», он умножает правый операнд на левый операнд
C * = A эквивалентно C = C * A
/=
Оператор присваивания «Деление», он делит левый операнд на правый операнд
C /= A эквивалентно C = C / A
%=
Оператор присваивания «Модуль», он принимает модуль, с помощью двух операндов и присваивает его результат левому операнду
C %= A, эквивалентно C = C % A
Оператор присваивания «Сдвиг влево»
C
>>=
Оператор присваивания «Сдвиг вправо»
C >>= 2, это как C = C >> 2
&=
Оператор присваивания побитового «И» («AND»)
C &= 2, это как C = C & 2
^=
Оператор присваивания побитового исключающего «ИЛИ» («XOR»)
C ^= 2, это как C = C ^ 2
|=
Оператор присваивания побитового «ИЛИ» («OR»)
C |= 2, это как C = C | 2
Пример
Прочие операторы
Тернарный оператор или условный оператор (?:)
Пример
Оператор instanceof
Примеры
Приоритет операторов в Java
Категория
Оператор
Ассоциативность
Постфикс
() . (точка)
Слева направо
Унарный
++ - - ! ~
Справа налево
Мультипликативный
* / %
Слева направо
Аддитивный
+ -
Слева направо
Сдвиг
>> >>>
Слева направо
Реляционный
> >=
Слева направо
Равенство
== !=
Слева направо
Побитовое «И» («AND»)
&
Слева направо
Побитовое исключающее «ИЛИ» («XOR»)
^
Слева направо
Побитовое «ИЛИ» («OR»)
|
Слева направо
Логическое «И» («AND»)
&&
Слева направо
Логическое «ИЛИ» («OR»)
||
Слева направо
Условный
?:
Справа налево
Присваивание
= += -= *= /= %= >>=
Справа налево
Запятая
,
Слева направо
Приоритет арифметических операций
Ассоциативность операций
Операции с числами с плавающей точкой
Операция присваивания
Присвоение переменной значения константы, другой переменной или выражения (переменных и/или констант, разделенных знаками операций), называется операцией присваивания
и обозначается знаком "=
", например:
x =
3
;
y =
x;
z =
x;
В Java допустимо многократное использование операции присваивания в одном выражении, например:
x1 =
x2 =
x3 =
0
;
Эта операция выполняется справа налево, т.е. сначала переменной x3 присваивается значение 0 , затем переменной x2 присваивается значение переменной x3 (0), и, наконец, переменной x1 присваивается значение переменной x2 (0).
Знаки операций, аргументами которых являются числа, разделяются на две категории: унарные
(unary) знаки операций с одним аргументом и бинарные
(binary) с двумя аргументами.
Унарные операции
В Java определены следующие унарные операции:
Примеры унарных операций " + " и " - ":
int
i =
3
,
j,
k;
j=
-
i;
// j = -3
k =
+
i;
// k = 3
Пример операции побитового дополнения:
int
a =
15
;
int
b;
b =
~
a;
// b = -16
Числа a и b являются числами типа int , т.е. представляются внутри компьютера как двоичные целые числа со знаком длиной 32 бита, поэтому двоичное представление чисел a и b будет выглядеть следующим образом:
a =
00000000
00000000
00000000
00001111
b =
11111111
11111111
11111111
11110000
Как видно из этого представления, все нулевые биты в числе a изменены на единичные биты в числе b , а единичные биты в a изменены на нулевые биты. Десятичным представлением числа b будет –16 .
Знаки операции инкремента и декремента могут размещаться как до, так и после переменной. Эти варианты называются соответственно префиксной
и постфиксной
записью этих операции. Знак операции в префиксной записи возвращает значение своего операнда после
вычисления выражения. При постфиксной записи знак операции сначала
возвращает значение своего операнда и только после этого вычисляет инкремент или декремент, например:
int
x =
1
,
y,
z;
y =
++
x;
z=
x++
;
Переменная y будет присвоено значение 2 , поскольку сначала значение x будет увеличено на 1 , а затем результат будет присвоен переменной y . Переменной z будет присвоено значение 1 , поскольку сначала переменной z будет присвоено значение, а затем значение x будет увеличено на 1 . В обоих случаях новое значение переменной x будет равно 2 .
Следует отметить, что в Java, в отличие от языка C, операции декремента и инкремента могут применяться и к вещественным переменным (типа float и double).
Бинарные знаки операций
подразделяются на операции с числовым результатом и операции сравнения, результатом которых является булевское значение.
Арифметические бинарные операции
В Java определены следующие арифметические бинарные операции
:
Примеры бинарных арифметических операций:
int
x =
7
,
x1,
x2,
x3,
x4,
x5;
x1 =
x +
10
;
// x1 = 17
x2 =
x – 8
;
// x2 = -1
x3 =
x2 *
x;
// x3 = -7
x4 =
x/
4
;
// x4 = 1 (при делении целых чисел
// дробная часть отбрасывается)
x5 =
x%
4
// x5 = 3 (остаток от деления
// 7 на 4)
Побитовые операции
Примеры побитовых операций:
Комбинированные операции
В Java для бинарных арифметических операций можно использовать комбинированные
(составные) знаки операций:
идентификатор операция = выражение
Это эквивалентно следующей операции: идентификатор = идентификатор операция выражение
Примеры:
Операции сравнения
В Java определены следующие операции сравнения:
имеют два операнда и возвращают булевское значение, соответствующее результату сравнения (false
или true
).
Следует обратить внимание, что при сравнении двух величин на равенство в Java, как и в C и в C++, используются символы "==
" (два идущих без пробела друг за другом знака равенства), в отличие от оператора присваивания, в котором используется символ "=
". Использование символа " = " при сравнении двух величин либо вызывает ошибку при компиляции, либо приводит к неверному результату.
Примеры операций сравнения:
boolean
isEqual,
isNonEqual,
isGreater,
isGreaterOrEqual,
isLess,
isLessOrEqual;
int
x1 =
5
,
x2 =
5
,
x3 =
3
,
x4 =
7
;
isEqual =
x1 ==
x2;
// isEqual = true
isNonEqual =
x1 !=
x2;
// isNonEqual = false
isGreater =
x1 >
x3;
// isGreater = true
// isGreaterOrEqual = true
isGreaterOrEqual =
x2 >=
x3;
isLess =
x3 <
x1;
// isLess = true
isLessOrEqual =
x1 <=
x3;
// isLessOrEqual = false
Булевские операции
Булевские операции
выполняются над булевскими переменными и их результатом также является значение типа boolean
. В Java определены следующие булевские операции:
Операции " & ", " | " и " ^ " можно, также как и соответствующие побитовые операции использовать в составных операциях присваивания: " &= ", " |= " и " ^= "
Кроме того, к булевским операндам применимы операции " == " (равно) и " != " (не равно).
Как видно из определения операций ИЛИ и И, операция ИЛИ приводит к результату true , когда первый операнд равен true , независимо от значения второго операнда, а операция И приводит к результату false , когда первый операнд равен false , независимо от значения второго операнда.
В Java определены еще две булевские операции: вторые версии булевских операций И и ИЛИ, известные как укороченные (short-circuit) логические операции: укороченное И " && " и укороченное ИЛИ " || ". При использовании этих операций второй операнд вообще не будет вычисляться, что полезно в тех случаях, когда правильное функционирование правого операнда зависит от того, имеет ли левый операнд значение true или false .
Примеры булевских операций:
boolean
isInRange,
isValid,
isNotValid,
isEqual,
isNotEqual;
int
x =
8
;
isInRange =
x >
0
&&
x <
5
;
// isInRange = false
isValid =
x >
0
||
x >
5
;
// isValid = true
isNotValid =
!
isValid;
// isNotValid = false
isEqual =
isInRange ==
isValid;
// isEqual = false
// isNotEqual = true
isNotEqual =
isInRange !=
isValid
Условная операция
Условная операция записывается в форме выражение-1?выражение-2:выражение-3 .
При этом сначала вычисляется выражение выражение-1 , которое должно дать булевское значение, а затем, если выражение-1 имеет значение true , вычисляется и возвращается выражение-2 как результат выполнения операции, либо (если выражение-1 имеет значение false), вычисляется и, как результат выполнения операции, возвращается выражение-3 .
Пример условной операции:
x=
n>
1
?
0
:
1
;
Переменной x будет присвоено значение 0 , если n>1 (выражение n>1 имеет значение true) или 1 , если n≤1 (выражение n>1 имеет значение false).
Старшинство операций
Операции в выражениях выполняются слева направо, однако, в соответствии со своим приоритетом. Так операции умножения в выражении
y =
x +
z*
5
;
будет выполнена раньше, чем операция сложения, поскольку приоритет операции умножения выше, чем приоритет операции сложения.
Приоритеты операций (в порядке уменьшения приоритета) в Java приведены в табл. 1.
Круглые скобки повышают старшинство операций, которые находятся внутри них. Так, если в приведенное выше выражение вставить скобки:
y =
(x +
z)
*
5
;
то сначала будет выполнена операция сложения, а затем операция умножения.
Иногда скобки используют просто для того, чтобы сделать выражение более читаемым, например:
(x >
1
)
&&
(x <=
5
)
;
Преобразование и приведение типов при выполнении операций
В операции присваивания и арифметических выражениях могут использоваться литералы, переменные и выражения разных типов, например:
double
y;
byte
x;
y =
x +
5
;
В этом примере выполняется операция сложения переменной x типа byte и литерала 5 (типа int) и результат присваивается переменной y типа double .
В Java, как и в языке C, преобразования типов при вычислении выражений могут выполняться автоматически, либо с помощью оператора приведения типа. Однако правила приведения типов несколько отличаются от правил языка C, и в целом являются более строгими, чем в языке C.
При выполнении операции присваивания преобразование типов происходит автоматически, если происходит расширяющее преобразование
(widening conversion) и два типа совместимы
.
Расширяющими преобразованиями являются преобразования byte
®short
®int
®long
®float
®double
.
Для расширяющих преобразований числовые типы, включая целый и с плавающей точкой, являются совместимыми друг с другом. Однако числовые типы не совместимы с типами char и boolean . Типы char и boolean не совместимы также и друг с другом.
В языке Java выполняется автоматическое преобразование типов также и при сохранении литеральной целочисленной константы (которая имеет по умолчанию тип int) в переменных типа byte , short или long (однако если литерал имеет значение вне диапазона допустимых значений для данного типа, выдается сообщение об ошибке: возможная потеря точности).
Если преобразование является сужающим (narrowing conversion), т. е. выполняется преобразование byte ¬ short ¬ char ¬ int ¬ long ¬ float ¬ double , то такое преобразование может привести к потере точности числа или к его искажению. Поэтому при сужающих преобразованиях при компиляции программы выводится диагностическое сообщение о несовместимости типов и файлы классов не создаются. Такое сообщение будет выдано и при попытке преобразование выражений типа byte или short в переменную типа char .
Если все же необходимо выполнить такие преобразования, используется операция приведения (cast) типа, которая имеет следующий формат: (тип-преобразования
) значение
, где тип-преобразования
определяет тип, в который необходимо преобразовать заданное значение
, например, в результате выполнения операторов:
byte
x =
71
;
char
symbol =
(char
)
x;
переменная symbol получит значение " G ".
Если значение с плавающей точкой присваивается целому типу, то (если значение с плавающей точкой имеет дробную часть) при явном преобразовании типа происходит также усечение
(truncation) числа. Так, в результате выполнения оператора
int
x =
(int
)
77.85
;
переменная x получит значение 77 . Если же присваиваемое значение лежит вне диапазона типа-преобразования
, то результатом преобразования будет остаток от деления значения на модуль диапазона присваиваемого типа (для чисел типа byte модуль диапазона будет равен 256 , для short – 65536 , для int – 4294967296 и для long – 18446744073709551616). Например, в результате выполнения оператора
byte
x =
(byte
)
514
;
переменная x получит значение 2 .
При преобразовании целых или вещественных чисел в данные типа char , преобразование в символ происходит, если исходное число лежит в диапазоне от 0 до 127, иначе символ получает значение " ? ".
При выполнении арифметических и побитовых преобразований все значения byte и short , а также char расширяются до int , (при этом в вычислениях для char используется числовое значение кода символа) затем, если хотя бы один операнд имеет тип long , тип целого выражения расширяется до long . Если один из операндов имеет тип float , то тип полного выражения расширяется до float , а если один из операндов имеет тип double , то тип результата будет double . Так, если объявлены переменные
byte
a,
c;
short
b;
то в выражении
a +
b*
c – 15
L +
1.5F
+
1.08
-
10
;
сначала, перед вычислением a + b*c значения переменных будут расширены до int , затем, поскольку константа 15 имеет тип long , перед вычитанием результат вычисления будет увеличен до long . После этого, поскольку литерал 1.5 имеет тип float перед сложением с этим литералом результат вычисления a + b*c – 15L будет расширен до float . Перед выполнением сложения с числом 1.08 результат предыдущих вычислений будет расширен до double (поскольку вещественные константы по умолчанию имеют тип double) и, наконец, перед выполнением последнего сложения литерал 10 (по умолчанию int) будет расширен до double . Таким образом, результат вычисления выражения будет иметь тип double .
Автоматические расширения типов (особенно расширения short и byte до int) могут вызывать плохо распознаваемые ошибки во время компиляции. Например, в операторах:
byte
x =
30
,
y =
5
;
x =
x +
y;
перед выполнением сложения значение переменных x и y будет расширено до int , а затем при выполнении попытки присвоения результата вычисления типа int переменной типа byte будет выдано сообщение об ошибке.
Чтобы этого избежать надо использовать во втором операторе явное преобразование типов:
x =
(byte
)
(x +
y)
;
Выражение x + y необходимо заключит в скобки потому, что приоритет операции приведения типа, заключенной в скобки, выше, чем приоритет операции сложения. Кстати, если записать второй оператор в виде:
x +=
y;
то сообщения об ошибке не будет.
Ссылка на перво
Поиск
Мы можем оповещать вас о новых статьях,