Булевские переменные и булевская алгебра
class BoolLogic {
public static void main(String args[]) { boolean a = true;
boolean b = false;
boolean с = a | b;
boolean d = a & b;
boolean e = a ^ b;
boolean f = (!a & b) | (a & !b);
boolean g = !a;
System.out.println(" b = " + b); System.out.println(" a|b = " + c); System.out.println(" a&b = " + d); System.out.println(" a^b = " + e); System.out.println("!a&b|a&!b = " + f); System.out.println(" !a = " + g);
}
}
а = true
b = false
a|b = true
a&b = false
a^b = true
!a&b|a&!b = true
!a = false
Условные операторы
If – оператор условия, он направляет выполнение программы по двум разным маршрутам. Общая форма оператора:
If (логическое выражение) оператор1;
else оператор2;
- Раздел else необязателен.
- На месте любого из операторов может стоять составной оператор (несколько операторов, заключенных в фигурные скобки).
- Логическое выражение — это любое выражение, возвращающее значение типа boolean
1.<оператор-0> ;
If <логическое выражение>
<оператор-1>;
else <оператор-2>;
<оператор-3>;
1.if (a>b)
y = a;
else y = b;
2. int x = 5;
If ( x < 4)
{ System.out.println("Меньше 4"); }
else if (x > 4)
{ System.out.println("Больше 4"); }
else if (x == 4)
{ System.out.println("Равно 4"); }
else
{ System.out.println("Другое значение"); }
Так же существуют вложенные операторы if и многозвенные.
Class Math
Стандартные математические функции в Java определены в классе Math. Они реализованы как статические методы.
Помимо арифметических, в Math определены функции min(x,y) и max(x,y). Кроме того, в этом же классе объявлены константы PI и E. sin(x), cos(x)…, exp(x), log(x), sqrt(x) - корень квадратный, pow(x,y) - x в степени y, ceil(x) – наименьшее целое, floor(x) - наибольшее целое, abs(x) абсолютная величина
Значения углов для тригонометрических функций указываются в радианах. Для удобства работы, в Math определены также функции преобразования значений из радиан в градусы ( toDegrees(x)) и наоборот (toRadians(x)).
Оператор Break
Break – оператор перехода. В Java используется в нескольких случаях:
Выход из цикла:
Break сообщает программе, что следует прекратить выполнение именованного блока и передать управление оператору, следующему за данным блоком. Т.е. выход из любого блока.
Используется как «цивилизованная» форма оператора goto:
Break в Java может заменять оператор goto. Конечно такое зарезервированное слово имеется, но не используется.
В этом случае можно выйти из одного или большего количества блоков кода. Данная форма оператора работает с меткой и обеспечивает точное определение, где выполнение будет продолжено, не смотря на большую вложенность блоков
подразумевается выход из текущего блока.
Метка – любой допустимый идентификатор Java, за которым следует двоеточие.
<метка>: <оператор>|<блок>;
- Метку можно указывать в качестве параметра для операторов break и continue.
- Область видимости метки ограничивается оператором, или блоком, к которому она относится.
- Например, в следующей программе имеется три вложенных блока, и у каждого своя уникальная метка. Оператор break, стоящий во внутреннем блоке, вызывает переход на оператор, следующий за блоком b.
class Break {
public static void main(String args[]) {
boolean t = true;
a: {
b:{
c:{
System.out.println("Before the break");
if (t)
break b;
System.out.println("This won't execute");
// He будет выполнено
} // end of c
System.out.println("This won't execute");
// He будет выполнено
} //end of b
System.out.println("This is after b");
} //end of a
}
}
Вывод на экран:
Before the break
This is after b
Оператор Switch
Оператор switch обеспечивает ясный способ переключения между различными частями программного кода в зависимости от значения одной переменной или выражения. Хорошая альтернатива многозвенному if-else-if.
Оператор switch работает следующим образом: значение выражения сравнивается с каждым из указанных значений в case-операторах. Если соответствие найдено, то выполняется кодовая последовательность, следующая после этого оператора case. Если ни одна из case-констант не соответствует значению выражения, то выполняется оператор default. Однако оператор default не обязателен. Если согласующихся case нет, и default не присутствует, то никаких дальнейших действий не выполняется.
switch(int value | выражение) {
case const1: выражение или блок
case const2: выражение или блок
….
case constn: выражение или блок
default: выражение или блок
}
В качестве параметра switch может использоваться переменная типа byte, short, int, char или выражение дающие эти типы
int x = 2;
switch(x) {
case 1:
case 2: System.out.println("Равно 1
или 2");
break;
case 3:
case 4:
System.out.println("Равно 3 или
4");
break;
default:
System.out.println( "Значение не
определено");
}
public class SwitchDemo2 {
public static void main(String[] args) { int month = 2;
int year = 2000;
int numDays = 0;
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
numDays = 31; break;
case 4:
case 6:
case 9:
case 11: numDays = 30;
break;
case 2:
if ( ((year % 4 == 0) && !(year % 100 == 0)) || (year % 400 == 0) )
numDays = 29;
else
numDays = 28;
break;
}
System.out.println("Number of Days = " + numDays);
}
}
Цикл While
Оператор цикла while – повторяет оператор или блок операторов, пока его управляющее выражение имеет значение true
While (логическое выражение)
<повторяющееся выражение,
или блок>;
<оператор1>;
While (логич.выражение)
<оператор2>;
<оператор3>;
Цикл while оценивает условное выражение в самом начале своей работы, тело цикла не будет выполняться если условие сразу же имеет значение false.
- Если в теле цикла встретился оператор continue, то операторы, следующие за ним, будут пропущены и выполнение цикла начнется сначала.
- Если continue используется с меткой и метка принадлежит к данному while, то выполнение его будет аналогичным.
- Если метка не относится к данному while, его выполнение будет прекращено и управление будет передано на оператор, или блок, к которому относится метка.
- Если встретился оператор break, то выполнение цикла будет прекращено
1.public class Test {
public static void main(String[] args){
int x = 0;
while(x < 5) {
x++;
if(x % 2 == 0) continue;
System.out.print(" " + x);
} } } // вывод: 1 3 5
2.Public class Test {
public static void main(String[] args) {
int x = 0;
int y = 0;
lbl: while(y < 3) {
y++;
while(x < 5) {
x++;
if(x % 2 == 0)
continue lbl;
System.out.println("x=" + x + "
y="+y);
} // конец внутрен. цикла
} // конец внешнего цикла } }
x=1 y=1
x=3 y=2
x=5 y=3
Цикл Do
do
<повторяющееся выражение или блок;>
while(логическое выражение)
Цикл do будет выполняться до тех пор, пока логическое выражение будет истинным.
В отличие от цикла while, этот цикл будет выполнен, как минимум, один раз.
do
<оператор-1>;
<оператор-2>;
…
<оператор-n>;
while (логическое выражение);
int counter = 0;
do {
counter ++;
System.out.println("Counter is " +
counter);
} while(counter > 5);
class DoWhile {
public static void main(String args[]) {
int n = 10; do {
System.out.println("tick " + n);
} while (--n > 0); } }
Цикл For
Довольно часто бывает необходимо изменять значение какой-либо переменной в заданном диапазоне и выполнять повторяющуюся последовательность операторов с использованием этой переменной.
for ( инициализация; завершение; итерация )
<оператор или блок>;
Example1
class ForDemo {
public static void main(String args[]){
for (int i = 1; i <= 10; i++) System.out.println("i = " + i); }}
Example2
class ForTick {
public static void main(String args[]) { for (int n = 10; n > 0; n--) System.out.println("tick " + n); } }
Example3
... for(counter=0;counter<10;counter++)
{
System.out.println("Counter is " +
counter);
} /* Цикл будет выполнен 10 раз и будут напечатаны значения счетчика от 0 до 9; переменная counter была объявлена ранее. */
Example4
... for(int cnt = 0;cnt < 10; cnt++)
{
System.out.println("Counter is " +
cnt);
} /* область видимости переменной cnt будет ограничена телом цикла */
Example5
Любая часть конструкции for() может быть опущена.
В вырожденном случае мы получим оператор for с пустыми значениями
for(;;) { ... }
class Comma {
public static void main(String args[]) {
int a, b;
for (a = 1, b = 4; a < b; a++, b--)
{ System.out.println("a = " + a);
System.out.println("b = " + b); } } }
Результат а = 1 b = 4 а = 2 b = 3
Пример 1 с continue
class ContinueDemo {
public static void main(String args[]) {
for (int i=0; i < 10; i++)
{ System.out.print(i + " ");
if (i % 2 == 0) continue;
System.out.println(""); }}}
0 1 2 3 4 5 6 7 8 9
Пример 2 с continue
class ContinueLabel {
public static void main(String args[]) {
outer: for (int i=0; i < 10; i++)
{ for (int j = 0; j< 10; j++)
{ if (j > i)
{System.out.println(""); continue outer; }
System.out.print(" " + (i * j)); } } }}
0 1
0 2 4
0 3 6 9
0 4 8 12 16
0 5 10 15 20 25
0 6 12 18 24 30 36
0 7 14 21 28 35 42 49
0 8 16 24 32 40 48 56 64
0 9 18 27 36 45 54 63 72 81
Одномерные массивы
Массив – набор однотипных переменных, на которые ссылаются по общему имени. К определенному элементу в массиве обращаются по его индексу (номеру)
Одномерный массив – список однотипных переменных, состоит из размера массива (поле length) и собственно массива..
Чтобы задать массив следует создать переменную массива желаемого типа. Базовый тип определяет тип данных каждого эл-та массива.
Для выделения памяти под массив нужно использовать операцию new/
<имя переменной> = new int[12(size)]
Элементы массива автоматически инициализируются нулями.
Как только память выделена, нужно обращаться к массиву через его индекс, для заполнения его желаемыми числами.
Нумерация элементов массива начинается с нуля.
Этот объект
// Создает массив из 10 целых и адрес этого массива заносит в intAry
// intAry –ссылка на массив
int[] intAry = new int[10]; //допустимо
int intAry[] = {1, 2, 3, 4}; //без new
-int a[]=new int[5];
-int array[]=new int[5];
for (int i=0; i<5; i++)
{ array[i]=i*i; };
for (int j=0; j<6; j++)
{ System.out.println(j+"*"+j+"=“
+array[j]); }
-Результатом выполнения программы будет:
0*0=0
1*1=1
2*2=4
3*3=9
4*4=16
RuntimeError
-Одна переменная может ссылаться на массивы разной длины:
int i[]=new int[5];
...
i=new int[7]; // переменная та же,
// длина массива другая
//поле length
int p[]= new int[5];
…
for (int i=0; i<p.length; i++)
{System.out.pritnln(p[i]); }
Многомерные массивы
Массив – объект с набором однотипных переменных, на которые ссылаются по общему имени. К определенному элементу в массиве обращаются по его индексу (номеру). любой массив имеет поле length, которое определяет его размер. Элементы массива автоматически инициализируются нулями.
Java жестко контролирует выход за границы массива (прерывание IndexOutOfBoundException).
Массив элементарного типа, например int, — это действительно массив значений (т.е. массив целых чисел). Массив объектов — это массив ссылок на объекты.
Существуют два способа создания массива — операцией new и явной инициализацией.
Для многомерных массивов существует возможность задания разного размера массивов второго, третьего и т.д. измерений
Многомерные массивы строятся по принципу "массив массивов".
Двумерный массив — это массив ссылок на объекты-массивы.
Трехмерный массив — это массив ссылок на массивы, которые, в свою очередь, являются массивами ссылок на массивы.
Пример: создать массив целых 3*3.
Вариант 1. (явное создание)
int ary[][] = new int[3][3];
Вариант 2. (использование списка инициализации)
int ary[][] = new int[][] {
{1, 1, 1},
{2, 2, 2},
{1, 2, 3},
};
Можно создать “рваный”, “непрямоугольный” многомерный массив, потому, что многомерный массив является массивом ссылок на массивы.
Т.е. каждый массив следующего уровня является самостоятельным массивом и может иметь свой размер
1.int ary[][] = new int[][] {
{1, 1, 1, 1},
{2, 2, 2},
{1, 2, 3, 4, 5},
};
// инициализация массива
2.int ary[][] = new int[3][];
ary[0] = new int[5];
ary[1] = new int[2];
ary[2] = new int[6];
// задание кол-ва элементов в столбце вручную
Присваивание и копирование
int ary[][] = new int[][] {
{1, 1, 1, 1},
{2, 2, 2},
{1, 2, 3, 4, 5},
};
int copyAry[][] = ary; //массив тот же
copyAry — это не ссылка на копию массива, а еще одна ссылка на тот же массив
Заполнение и вывод элементов
int pithagor_table[][]=new int[5][5];
for (int i=0; i<5; i++) {
for (int j=0; j<5; j++)
{pithagor_table[i][j]=i*j; System.out.print(pithagor_table[i][j] + "\t");
}
System.out.println(); }
Вывод
0 0 0 0 0
0 1 2 3 4
0 2 4 6 8
0 3 6 9 12
0 4 8 12 16
Вывод матрицы:
Float [][] mat = new float[4] [4];
….
for (int y=0; y<mat.length; y++) {
for (int x=0; x,mat[y].length; x++)
System.out.print(mat [x][y]+ “”);
System.out.println( );
}
Введение в строки
В пакет java.lang встроен класс, инкапсулирующий структуру данных, соответствующую строке.
Класс String - объектное представление неизменяемого символьного массива (статические строки).
В этом классе есть методы, которые позволяют сравнивать строки, осуществлять в них поиск и извлекать определенные символы и подстроки.
Класс StringBuffer используется тогда, когда строку после создания требуется изменять (динамические строки).
Можно создавать объекты типа String с помощью оператора new.
Переменную, объявленную как String-ссылка, можно в любое время изменить так, чтобы она указывала на другой String-объект.
Для создания пустой строки используется конструктор без параметров:
1. String s = new String();
2. String s = new String("какая-то
строка");
-В общем случае у конструктора—3 параметра:
String(char chars[],
int <начальныйИндекс>,
int <числоСимволов>);
char chars[] = { 'a', 'b', 'с', 'd', 'e', 'f' }:
String s = new String(chars,2,3);
System.out.println(s); // “cde”.
char chars[] = { 'а', 'b', 'с' };
String s = new String(chars);
System.out.println(s): // “abc “
В Java включено несколько синтаксических дополнений, цель которых—помочь программистам в выполнении операций со строками. В числе таких операций создание объектов типа String, слияние нескольких строк и преобразование других типов данных в символьное представление.
String s = "abc"; //упрощенный вариант
System.out.println(s);
Один из общих методов, используемых с объектами String—метод length, возвращающий число символов в строке
String s = "abc";
System.out.println(s.length());
System.out.println("abc".length());
/*для каждой строки-литерала создается свой представитель класса String */
Основные конструкторы класса String
Класс String поддерживает несколько конструкторов. Чтобы создать пустой объект нужно вызвать конструктор по умолчанию.
String s = new String(); //пустая строка
Чтобы создать String-объект инициализированный массивом символов, нужно использовать следующий конструктор:
String (char chars[])
Char chars[] – {‘a’, ‘b’, ‘c’};
String s = new String(chars);
String(char chars[], int startIndex, int numChars)
Этот конструктор используется в качестве указания поддиапазона символьного массива.
Слияние строк
-По определению каждый объект класса String не может изменяться.
- Нельзя ни вставить новые символы в уже существующую строку, ни поменять в ней одни символы на другие.
-И добавить одну строку в конец другой тоже нельзя.
-Поэтому транслятор Java преобразует операции, выглядящие, как модификация объектов String, в операции с родственным классом StringBuffer.
Извлечение символов
-Чтобы извлечь одиночный символ из строки, можно сослаться непосредственно на индекс символа в строке с помощью метода charAt :
public char charAt(int index)
Выбирает из строки символ с индексом index (символы индексируются от нуля).
-Если нужно извлечь несколько символов, можете воспользоваться методом getChars :
class getCharsDemo {
public static void main(String args[]) {
String s = "This is a demo of the getChars
method.";
int start = 10;
int end = 14;
char buf[] = new char[end—start];
s.getChars(start, end, buf, 0);
System.out.println(buf);// demo } }
Сравнение
-метод equals
- метод equalsIgnoreCase
class equalDemo {
public static void main(String args[]) {
String s1="Hello";
String s2="Hello";
String s3="Good-bye";
String s4="HELLO";
System.out.println(s1+"equals"+s2+ "->“
+s1.equals(s2));
System.out.println(s1+"equals"+s3+"->“
+s1.equals(s3));
System.out.println(s1+"equals"+s4+"->“
+s1.equals(s4));
System.out.println(s1+"equalsIgnoreCase"+
s4 + "->"+ s1.equalsIgnoreCase(s4)); }}
С:\> java equalsDemo
Hello equals Hello -> true
Hello equals Good-bye -> false
Hello equals HELLO -> false
Hello equalsIgnoreCase HELLO -> true
-Метод equals и оператор == выполняют две совершенно различных проверки.
- Mетод equal сравнивает символы внутри строк
- Оператор == сравнивает две переменные-ссылки на объекты и проверяет, указывают ли они на разные объекты или на один и тот же.
class EqualsNotEqualTo {
public static void main(String args[]) {
String s1="Hello";
String s2=new String(s1);
System.out.println(s1+"equals"+s2+
"->"+s1.equals(s2));
System.out.println(s1+"=="+s2+",
->"+(s1==s2));} }
C:\> java EqualsNotEqualTo
Hello equals Hello -> true
Hello == Hello -> false
-Метод compareTo класса String.
если целое значение, возвращенное методом, отрицательно, то строка, с которой был вызван метод, меньше строки-параметра,
если положительно—больше.
если же метод compareTo вернул значение 0, строки идентичны.
/** отсортированный в порядке возрастания список строк */
class SortString {
static String arr[] = {"Now", "is", "the",
"time", "for", "all", "good", "men", "to",
"come", "to", "the", "aid", "of", "their",
"country" };
public static void main(String args[]) {
for (int j = 0; j < arr.length; j++) {
for (int i = j + 1; i < arr.length; i++) {
if (arr[i].compareTo(arr[j]) < 0)
{ String t = arr[j];
arr[j] = arr[i];
arr[i] = t;
}
}// конец цикла i
System.out.println(arr[j]);
} // конец цикла j} }
Модификация
-объекты класса String нельзя изменять, всякий раз, когда модифицируется строка,
1. копировать ее в объект типа StringBuffer,
2. использовать один из методов класса String, которые создают новую копию строки, внося в нее изменения.
-substring
метод создает новую копию символов из того диапазона индексов оригинальной строки, который указан при вызове.
Можно указать только индекс первого символа нужной подстроки—тогда будут скопированы все символы, начиная с указанного и до конца строки
можно указать и начальный, и конечный индексы—при этом в новую строку будут скопированы все символы, начиная с первого указанного, и до (но не включая его) символа, заданного конечным индексом.
"Hello World".substring(6) -> "World"
"Hello World".substring(3,8) -> "lo Wo"
-concat
Слияние, или конкатенация строк выполняется с помощью метода concat.
Этот метод создает новый объект String, копируя в него содержимое исходной строки и добавляя в ее конец строку, указанную в параметре метода.
"Hello".concat(" World") -> "Hello World"
-replace (int old, int new)
Методу replace в качестве параметров задаются два символа. Все символы, совпадающие с первым, заменяются в новой копии строки на второй символ.
"Hello".replace('l' , 'w') -> "Hewwo"
-toLowerCase и toUpperCase
Эта пара методов преобразует все символы исходной строки в нижний и верхний регистр, соответственно.
"Hello".toLowerCase() -> "hello"
"Hello".toUpperCase() -> "HELLO"
-trim
метод trim убирает из исходной строки все ведущие и замыкающие пробелы.
"Hello World ".trim() -> "Hello World”
-valueOf
преобразование любого значения в текстовую строку
Такой статический метод определен для любого существующего в Java типа данных
может преобразовывать типы: boolean, byte, short, int, long, float, double и тип Object
Например:
boolean bTmp = true;
String s = String.valueOf(bTmp);
-toString () ,
переопределенный или просто унаследованный от класса Object .
Он преобразует объекты класса в строку. Фактически, метод valueOf() вызывает метод toString() соответствующего класса. Поэтому результат преобразования зависит от того, как реализован метод toString ().
-Обратное преобразование, из строки
Метод parse<Type>() класса-оболочки этого типа, где вместо <Type> будет имя типа.
-byte b = Byte.parseByte("10");
-short shrt = Short.parseShort("1234");
-long lng = Long.parseLong("1234567");
-float flt = Float.parseFloat("1.123");
-double dbl = Double.parseDouble("1.123");
-int i = Integer.parseInt("10");
Класс StringBuffer
StringBuffer равен по положению классу String. Он обеспечивает много функциональных возможностей для строк. StringBuffer представляет возрастающие и перезаписываемые символьные последовательности. С его помощью можно вставлять символы и подстроки в середину строки или добавлять их в конец строки
Создать объект класса StringBuffer можно только конструкторами.
Конструкторы класса StringBuffer:
StringBuffer() – резервирует участок памяти для шестнадцати доп. Символов, не участвующих в распределении.
StringBuffer(int,size) – принимает целочисленный аргумент, который явно устанавливает размер буфера.
StringBuffer(String str) – принимает String-аргумент, который устанавливает начальное содержимое объекта типа StringBuffer и резервирует участок памяти для еще шестнадцати доп. символов
Поиск
В класс String включена поддержка поиска определенного символа или подстроки, для этого в нем имеются два метода—indexOf и lastIndexOf. Каждый из этих методов возвращает индекс того искомого символа, либо индекс начала искомой подстроки. В любом случае, если поиск оказался неудачным методы возвращают значение -1.
String s = "Now is the time for all good men" + "to come to the aid of their country " + "and pay their due taxes.";
System.out.println("indexOf(t) = " +
s.indexOf(‘t'));
System.out.println("lastlndexOf(t) = " +
s.lastlndexOf(‘t'));
System.out.println("indexOf(the) = " +
s.indexOf("the"));
System.out.println("lastlndexOf(the) = " +
s.lastlndexOf("the"));
System.out.println("indexOf(t, 10) = " +
s.indexOf('f' , 10));
System.out.println("lastlndexOf(t, 50) = " +
s.lastlndexOf('f' , 50));
System.out.println("lastlndexOf(the, 50) = " + s.lastlndexOf("the", 50));
indexOf(t) = 7
lastlndexOf(t) = 87
indexOf(the) = 7
lastlndexOf(the) = 77
index0f(t, 10) = 11
lastlndex0f(t, 50) = 44
lastlndex0f(the, 50) = 44
Текущую длину StringBuffer можно определить, вызвав метод length
Методы StringBuffer
ensureCapacity
Если нужно после создания объекта StringBuffer зарезервировать в нем место для определенного количества символов, можно для установки размера строки воспользоваться методом ensureCapacity. Это бывает полезно, когда заранее известно, что придется добавлять к буферу много небольших строк.
Void ensureCapacity(int capacity)
setLength
Если нужно в явном виде установить длину строки в буфере, можно использовать метод setLength. Если задать значение, большее чем длина содержащейся в объекте строки, этот метод заполнит конец новой, расширенной строки символами с кодом нуль.
Void setLength(int len)
charAt и setCharAt (replace)
Одиночный символ может быть извлечен из объекта StringBuffer с помощью метода charAt.
Метод setCharAt позволяет записать в заданную позицию строки нужный символ.
Char charAt(int where)
Void setCharAt(int where, char ch)
class setCharAtDemo {
public static void main(String args[]) {
StringBuffer sb = new
StringBuffer("Hello");
System.out.println("buffer before = " +
System.out.println("charAt(1) before = " +
sb.charAt(1));
sb.setCharAt(1, 'i');
sb.setLength(2);
System.out.println("buffer after = " + sb);
System.out.println("charAt(1) after = " +
sb.charAt(1));
}
}
C:\> java setCharAtDemo
buffer before = Hello
charAt(1) before = e
buffer after = Hi
charAt(1) after = i
append
Метод append класса StringBuffer обычно вызывается неявно при использовании оператора + в выражениях со строками.
Для каждого параметра вызывается метод String.valueOf и его результат добавляется к текущему объекту StringBuffer.
Основной метод
append (String str) присоединяет строку str в конец данной строки. Если ссылка str == null, то добавляется строка "null".
Шесть методов
append (type elem)
добавляют примитивные типы boolean, char, int, long, float, double, преобразованные в строку.
Два метода присоединяют к строке массив chars и подмассив sub символов,
преобразованные в строку:
append (char [] chars)
append (char [] sub, int offset, int len).
Десятый метод добавляет просто объект append (Object obj). Перед этим объект obj преобразуется в строку своим методом toString ().
При каждом вызове метод append возвращает ссылку на объект StringBuffer, с которым он был вызван.
Это позволяет выстраивать в цепочку последовательные вызовы метода
class appendDemo {
public static void main(String args[]) {
String s; int a = 42;
StringBuffer sb = new StringBuffer(40);
s = sb.append("a = ").append(a). append("!").
toString();
System.out.println(s); } }
С:\> Java appendDemo
а = 42!
insert
Метод insert идентичен методу append в том смысле, что для каждого возможного типа данных существует своя совмещенная версия этого метода.
В отличие от append, он не добавляет символы, возвращаемые методом String.valueOf, в конец объекта StringBuffer, а вставляет их в определенное место в строке, задаваемое первым его параметром.
StringBuffer insert(int index, String str)
StringBuffer insert(int index, char ch)
StringBuffer insert(int index, Object obj)
class insertDemo {
public static void main(String args[]) {
StringBuffer sb = new
StringBuffer("hello world !");
sb.insert(6,"there ");
System.out.println(sb); } }
delete (int begin, int end)
удаляет из строки символы, начиная с индекса begin включительно до индекса end исключительно, если end больше длины строки, то до конца строки.
String s = new StringBuffer("Это небольшая строка");
s.delete(4, 6).toString();
//s == "Это большая строка".
Если begin отрицательно, больше длины строки или больше end , возникает исключительная ситуация.
Если begin == end, удаление не происходит.
deleteCharAt (int ind)
удаляет символ с указанным индексом int. Длина строки уменьшается на единицу.
Если индекс int отрицателен или больше длины строки, возникает исключительная ситуация.
В StringBuffer в ранних версиях не существовало методов, которые бы удаляли часть содержимого строки, в этом случае придется преобразовать строку в символьный массив, удалить то, что нужно, построить новую строку по массиву с оставшимися символами.
следует воспользоваться методом getChars, который аналогичен методу String. getChars.
public void getChars (int srcBegin, int srcEnd, char[] dst, int dstBegin);
Копирует символы из заданной части буферной строки (определяемой позициями srcBegin и srcEnd) в массив dst начиная с dst [dstBegin]
public static StringBuffer
remove (StringBuffer buf, int pos,int cnt) {
if (pos<0||cnt<0||pos+cnt>buf.length ( ) )
throw new IndexOutOfBoundsException( );
int leftover = buf.length()-(pos + cnt);
if (leftover ==0) {/* простое усечение
строки*/
buf.setlength(pos) ;
return buf; }
char [] chrs = new char [leftover] ;
buf.getChars (pos+cnt,buf .Length( ),
chrs, 0) ;
buf.setLength(pos) ;//обрезаем строку
buf.append ( chrs ) ;//добавляем
//выделенный ранее остаток строки
return buf ;}
replace (int begin, int end, String str )
Заменяет внутри StringBuffer-объекта один набор символов на другой
StringBuffer replace(int ctartIndex, int endIndex, String str)
reverse()
меняет порядок расположения символов в строке на обратный порядок.
String s = new StringBuffer("Это небольшая строка");
s.reverse().toString();
получим s == "акортс яашьлобен отЭ".
Класс StringTokenizer
В пакет java.util входит простой класс StringTokenizer , облегчающий разбор строк.
Класс StringTokenizer – лексический анализатор или сканер производит синтаксический анализ (деление текста на множество лексем, которые в некоторой последовательности могут передавать семантическое значение.)
StringTokenizer имеет следующие конструкторы:
StringTokenizer (String str)
создает объект, готовый разбить строку str на слова, разделенные пробелами, символами табуляций '\t', перевода строки '\n' и возврата каретки '\r' . Разделители не включаются в число слов.
StringTokenizer (String str, String delimeters)
задает разделители вторым параметром delimeters , например:
StringTokenizer("Казнить,нельзя:пробелов-нет", " \t\n\r,:-");
первый разделитель — пробел. Потом идут символ табуляции, символ перевода строки, символ возврата каретки, запятая, двоеточие, дефис. Порядок расположения разделителей в строке delimeters не имеет значения. Разделители не включаются в число слов.
StringTokenizer(String str, String delimeters, boolean flag)
Позволяет включить разделители в число слов.
Если параметр flag равен true , то разделители включаются в число слов, если false — нет. Например:
StringTokenizer("а - (Ь + с) / Ь * с", " \t\n\r+*-/(), true);
В разборе строки на слова активно участвуют два метода: метод
nextToken ()
возвращает в виде строки следующее слово;
логический метод
hasMoreTokens ()
возвращает true , если в строке еще есть слова, и false , если слов больше нет
Метод countTokens ()
возвращает число оставшихся слов
nextToken(string newDeiimeters)
позволяет "на ходу" менять разделители. Следующее слово будет выделено по новым разделителям newDelimeters; новые разделители действуют далее вместо старых разделителей, определенных в конструкторе или предыдущем методе nextToken ().
Пример: Разбиение строки на слова :
String s = "Строка, которую мы хотим разобрать на слова";
StringTokenizer st = new StringTokenizer(s, " \t\n\r,.");
while(st.hasMoreTokens()){
// Получаем слово и что-нибудь делаем с ним, //например,
// просто выводим на экран
System.out.println(st.nextToken()) ; }
Полученные слова обычно заносятся в какой-нибудь класс-коллекцию: Vector, Stack или другой, наиболее подходящий для дальнейшей обработки текста контейнер.
Методология ООП
OOP (Object-Oriented Programming) – методология программирования, которая помогает организовывать сложные программы с помощью наследования, инкапсуляции и полиморфизма.
-При объектно-ориентированном подходе эти предметы и понятия реального мира заменяются моделями, т.е. определенными формальными конструкциями.
-Модель содержит не все признаки и свойства представляемого ею предмета или понятия, а только те, которые существенны для разрабатываемой программной системы.
-Простота модели по отношению к реальному предмету позволяет сделать ее формальной.
-Благодаря такому характеру моделей при разработке можно четко выделить все зависимости и операции над ними в создаваемой программной системе.
-Это упрощает как разработку и изучение (анализ) моделей, так и их реализацию на компьютере.
Три принципа ООП: инкапсуляция, наследование, полиморфизм
Достоинства ООП
-уменьшение сложности программного обеспечения;
-повышение надежности программного обеспечения;
-обеспечение возможности модификации отдельных компонентов программного обеспечения без изменения остальных его компонентов;
-обеспечение возможности повторного использования отдельных компонентов программного обеспечения.
Недостатки ООП
1.Неэффективность на этапе выполнения
2.Неэффективность в смысле распределения памяти
3.Излишняя универсальность