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

В этом уроке мы рассмотрим:

Откуда скачать установочный пакет Java.

Процесс инсталляции.

Настройку путей к выполняемым файлам.

Проверку установки.

Скачиваем инсталлятор Java.

Скачать инсталляционный пакет можно на сайте компании Oracle по ссылке:

http://www.oracle.com/technetwork/java/javase/downloads/index.html

Качаем JDK последней версии (Java 7 или Java 8). Выберете в таблице (рис 1.1) вариант, подходящий для вашей операционной системы.

Дальнейшая установка будет рассмотрена на примере Windows. Если вы не знаете тип вашей Windows (x86 или x64) откройте Панель управления -> Система там будет указан Тип системы. Если тип вашей системы — 32 разрядная, то нужно устанавливать версию для x86, если 64 разрядная, то x64.

Внимание, перед тем как начать скачивание, нужно выбрать выбрать пункт Accept License Agreement вверху таблицы.

Если у вас компьютер Apple и на нем еще не установлена Java, то установочный пакет можно скачать отсюда: http://support.apple.com/downloads/#java

Инсталлируем Java.

Для того, чтобы установить Java на компьютер, запустите скаченный файл, после чего начнется процесс установки (рис1.2).

Нажмите Next.

Установка по умолчанию будет происходить в директорию C:\Program Files\Java\jdk1.x.x_xx (вместо иксов номер версии), при желании директорию можно изменить, нажав на кнопку Change (рис 1.3).

Следуйте инструкциям мастера установки, и через несколько минут установка будет завершена.

По окончанию установки, программа предложит перейти к технической документации и руководствам по Java, для чего нужно будет нажать кнопку Next Steps. После этого в вашем браузере откроется страница с документацией Java http://docs.oracle.com/javase/ , которая является очень полезной для изучения.

Настройка переменных сред.

На следующем шаге необходимо задать пути к выполняемым файлам, а именно задать системные переменные PATH, CLASSPATH и JAVA_HOME .

Для этого откройте Панель управления -> Система, выберете Дополнительные параметры системы. В появившемся окне нажмите кнопку Переменные среды.

В открывшемся окне в блоке Системные переменные нужно проверить существует ли переменная PATH, если переменная не существует, то ее нужно создать нажав на кнопку Создать, если переменная PATH уже существует, то ее нужно Изменить (рис. 1.4).

В следующем окне для переменной PATH нужно установить Значение переменной — путь к каталогу, в который была установлена Java (рис. 1.5).

Если переменной PATH уже присвоены другие значения, то новое значение добавляется через точку с запятой «;» в самом конце строки.

Также необходимо создать переменную CLASSPATH, если она еще не создана. В качестве ее значения необходимо указать «.;» (рис. 1.6).

Подобным образом создается/изменяется переменная JAVA_HOME. Значение этой переменной — путь к каталогу, в который была установлена Java (как для PAHT), но уже без поддериктории bin. Например:

Значение в PATH: C:\Program Files\Java\jdk1.7.0_25\bin

Значение в JAVA_HOME: C:\Program Files\Java\jdk1.7.0_25

После того, как были прописаны переменные, установку Java можно считать завершенной!

Проверка установки.

Чтобы проверить, успешно ли прошла установка, откройте командную строку. Для этого в меню Windows Пуск в строке поиска введите команду cmd и нажмите Enter. После этого откроется командное окно, в котором нужно ввести следующую команду.

Код

java -version

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

Частые проблемы:

«java» не является внутренней или внешней командой, исполняемой программой или пакетным файлом.

Проверьте правильность пути, прописанного в PATH. Старайтесь избегать пробелов в названии папки, в которую производите установку JDK.

не является приложением win 32

Возникает в следствии установки версии Java, не соответствующей разрядности системы (например, при установке 64 разрядной версии Java в 32-разрядную операционную систему).

Ошибка, призывающая проверить JAVA_HOME

Проверить, что в этой переменной хранится путь к установленной JAVA (без bin)

В этом уроке мы создадим нашу первую программу на языке Java.
Создание приложения на языке Java состоит из трех следующих шагов:

Создание исходного файла

Компиляция исходного файла

Запуск программы

Создание исходного файла

Для начала нужно написать текст программы на языке Java и сохранить его. Это и будет нашим исходным файлом. Для создания исходного файла подойдет любой текстовый редактор, например стандартный «Блокнот». Однако, существуют и другие текстовые редакторы, которые более удобны для написания кода. Можно воспользоваться например, Notepad++ . Это бесплатный текстовый редактор, который поддерживает синтаксис большинства языков программирования, в том числе и Java.

Итак, открываем текстовый редактор и пишем в нем код программы Hello World, цель которой — вывод на экран сообщения Hello World!

Код

class HelloWorld {
    public static void main(String[] args) {
        // Display "Hello World!"
        System.out.println("Hello World!");
    }
}

После написания этого кода, файл нужно сохранить под именем HelloWorld.java.
Для этого в вашем текстовом редакторе нужно выбрать пункт меню Файл-> Сохранить как… Если вы пользуетесь стандартным Блокнотом Windows, то для того, чтобы сохранить файл с расширением .java необходимо при сохранении выбрать Тип файла: Все файлы и ввести Имя файла: HelloWorld.java (рис 2.1).

Если вы пользуетесь Notepad++ то нужно выбрать Тип файла:Java source file (*.java)

Будьте внимательны! файл должен называться в точности так, как называется наш класс — HelloWorld. Так же важно учитывать регистр букв. HelloWorld и helloworld в данном случае это разные слова!

Обратите также внимание на кодировку в которой сохраняете файл. Должно быть выбрано ANSI. В Notepad++ кодировку можно установить в меню Кодировки.

Компиляция исходного файла

Исходный файл с кодом программы создан, теперь перейдем к компиляции. Для компиляции Java предназначен компилятор javac, который входит в состав установленного нами в первом уроке пакета JDK.

Для того, чтобы скомпилировать исходный файл, открываем командную строку. Для этого в меню Windows Пуск в строке поиска вводим команду cmd и жмем Enter. После этого откроется командное окно.

Теперь в нем нужно изменить текущий каталог на тот, в котором находится наш исходный файл (например C:\studyjava\). Для этого вводим следующую команду:

Код

cd C:\studyjava\

и нажимаем Enter.

После того, как директория изменилась, вводим команду компиляции

Код

javac HelloWorld.java

нажимаем Enter.

После этого, окно командной строки должно выглядеть следующим образом (рис 2.2):

То есть, мы не получим никакого подтверждения, о том, что программа скомпилировалась успешно. Однако, в папке с нашим исходным файлом, должен появиться файл HelloWorld.class. Это можно проверить с помощью команды

Код

dir

Эта команда выводит на экран список всех файлов, находящихся в выбранной директории (рис 2.3).

Если файл HelloWorld.class присутствует в этом списке, то это значит, что программа скомпилировалась успешно.

Если в коде программы есть ошибка, то компилятор Java при компиляции нам об этом сообщит.

Проведем эксперимент: Откроем в текстовом редакторе наш файл HelloWorld.java и удалим последнюю закрывающуюся фигурную скобку «}». Сохраним файл и попробуем его еще раз скомпилировать. В итоге получаем сообщение об ошибке (рис 2.4).

Чтобы исправить ошибку, нужно вновь открыть файл для редактирования, устранить ошибку, сохранить файл и еще раз его скомпилировать.

Запуск программы

Переходим к последней стадии — запуску программы.

Вводим в командном окне:

Код

java HelloWorld

и если все перед этим было сделано правильно, то получаем результат — вывод сообщения «Hello World!» (рис 2.5).

Еще раз обратите внимание на чувствительность к регистру в Java. Если вы напишете helloworld вместо HelloWorld, то программа запущена не будет, потому что Java попросту не найдет файл с таким именем.

В качестве домашнего задания можете поэкспериментировать и выводить на экран какое-либо свое сообщение вместо Hello World!.

Конечно, для написания, компилирования и запуска программ на языке Java существуют более удобный инструмент, нежели Блокнот и командная строка . Этот так называемая Интегрированная среда обработки IDE. Об этом мы поговорим в следующем уроке.

IDE (Integrated Development Environment) или же по-русски интегрированная среда разработки, это инструмент, предназначенный для разработки программного обеспечения. В предыдущем уроке мы писали код программы в текстовом редакторе, потом компилировали и запускали программу через командную строку, что не совсем удобно. IDE же позволяет в единой среде писать, компилировать, запускать и отлаживать программу.

Наиболее популярными бесплатными IDE для Java программистов являются: Eclipse, NetBeans и IntelliJ IDEA. В интернете существует много споров о том, какая же IDE лучше, однако, однозначного ответа на этот вопрос не существует, все зависит от круга задач, которые необходимо решать. Также, каждый программист обычно выбирает ту, которая ему удобнее и к которой он привык. На начальном этапе можете выбрать любую, это не имеет значения.

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

В этом уроке мы рассмотрим, как начать работу с Eclipse IDE.

Установим Eclipse IDE на компьютер

Создадим в ней программу Hello World.

Установка и запуск Eclipse IDE

Переходим по ссылке http://www.eclipse.org/downloa....keplerr и скачиваем Eclipse, соответствующую операционной системе.
Далее будет рассмотрена установка для Windows.
Распаковываем скаченный .zip архив в директорию C:\Program Files\
На этом установка завершена!
Чтобы запустить Eclipse IDE, нужно открыть файл eclipse.exe, находящийся в папке C:\Program Files\eclipse\.
При запуске откроется окно, предлагающее выбрать рабочую область (Workspace), где будут храниться программные файлы проекта. Указываем удобную для нас директорию (рис. 3.1.) и нажимаем OK.

6. Закрываем приветственное сообщение (рис. 3.2.), тем самым перейдя в рабочую среду.

Начало работы с Eclipse IDE

Теперь создадим новый проект. Для этого выберем меню File->New->Project..

В открывшемся окне выберем Java Project (рис. 3.3.) и нажмем Next.

В следующем окне введем имя нашего проекта (рис. 3.4.) и нажмем Finish.

Проект отобразится в левой части экрана и должен в себе содержать элемент JRE System Library (рис. 3.5.)

Если этого элемента нет, то его необходимо добавить вручную! Для этого выберем Windows -> Preferences, в открывшемся окне Preferences слева выберем Java -> Installed JREs, нажмем кнопку Add… справа (рис 3.6.). В открывшемся окне выберем Standard VM и нажмем кнопку Next.

В открывшемся окне Add JRE, укажем директорию, в которой установлена Java (рис 3.7.) и нажмем Finish.

Далее рассмотрим создание программы Hello World из урока 2, но уже в Eclipse.

Первым делом необходимо создать класс. Нажмем правой кнопкой на папке с проектом и выберем из контекстного меню New -> Class (рис 2.7.).

В открывшемся окне New Java Class введем имя класса проекта HelloWorld и установим флажок для метода public static void main(String[] args) (рис 2.8.). Нажмем Finish.

В итоге, Eclipse создаст новый класс Hello World

Откроем созданный класс и завершим нашу программу. Добавим в метод main следующий код (рис 2.9.).

Код

System.out.println("Hello World");

Сохраним изменения с при помощи клавиш Ctrl+S или специального значка вверху на панели инструментов. Готово!

Далее запустим наш проект, для этого в меню выберем Run -> Run Configurations.

В открывшемся окне в левой части 2 раза кликнем на Java Application после чего, будет создан новый под элемент с именем New_configuration, которое впоследствии в правой части можем изменить . В правой части также заполним поля Project и Main Class. Project должен содержать имя проекта, Main Class — имя главного класса, в нашем случае — HelloWorld (рис. 3.10). После чего нажмем Apply и Run.

В результате, в консоле будут напечатаны слова Hello World (рис. 3.11).

Для запуска программы в дальнейшем, достаточно нажимать специальный значок на панели инструментов, выбрав Hello World (рис. 3.12.).

На этом закончим данный урок.

Подробные инструкции по работе с Eclipse, правда на английском языке, можно найти по ссылке: http://www.vogella.com/articles/Eclipse/article.html

Или прочитать перевод (в укороченном виде) этого мануала на русском http://sotnyk.com/2011/10/09/rukovodstvo-po-eclipse-ide/

Java относится к языкам объектно-ориентированного типа, поэтому, прежде чем приступать к написанию программ, следует познакомиться с принципами объектно-ориентированного программирования.

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

Класс Robot может состоять из таких атрибутов как:

ID

имя

тип

цвет

вес

скорость передвижения

…

можно придумать много других атрибутов.

Также класс Robot будет содержать методы, отвечающие за его поведение. К примеру, на начальном этапе робот умеет:

Спрашивать имя

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

Выполнять какую-либо работу

Абстракция

Важно помнить, что описывая поведение какого-либо объекта, нужно выбрать подходящий для решения конкретной задачи уровень абстракции. Объекты реального света могут быть достаточно сложны, чтобы описать все их характеристики, более того, решение конкретных задач потребует лишь наличие некоторых из них. Таким образом, мы должны абстрагироваться от некоторых конкретных деталей объекта. Но также важно, чтобы абстракция не была слишком обобщенной и позволила правильно моделировать поведение объекта.

Далее рассмотрим 3 главных принципа, на которых строится объектно-ориентированное программирование:

Инкапсуляция;

Наследование;

Полиморфизм.

Инкапсуляция

Инкапсуляция это механизм, объединяющий атрибуты и методы (которые составляют объект) и охраняющий их от внешнего вмешательства. Инкапсуляция — защитная оболочка, позволяющая обращаться к атрибутам и методам класса только внутри этого класса или при помощи специально спроектированного интерфейса.

Атрибуты или методы класса могут быть открытыми (public) или закрытыми (private). Закрытые атрибуты и методы могут быть доступны только внутри класса, в котором они находятся, они не доступны той части программного кода, которая находится вне этого класса. Открытые атрибуты и методы доступны, в том числе, и коду программы вне класса. Таким образом, открытые методы используются для предоставления контролируемого интерфейса к закрытым элементам класса.

Например, представим, что у нашего робота на голове находятся светодиоды, которые меняют цвет по голосовой команде «Измени цвет». Мы не можем ни как по-другому повлиять на смену цвета диодов, потому что этого не позволят настройки приватности. Мы можем повлиять на смену цвета, только при помощи конкретной голосовой команды, которая в данном случае является интерфейсом к светодиодам.

Наследование

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

Например, на основе уже существующего объекта Robot мы можем создать новый объект CoffeRobot, который будет варить кофе. Новый робот будет иметь все атрибуты и методы что и предыдущий, плюс содержать дополнительный метод «Варить кофе».

Полиморфизм

Если мы имеем объекты, которые принадлежат одной и той же ветви иерархии (были унаследованы), то для них можно использовать единый интерфейс, который будет для каждого объекта производить однотипное действие, но результат для каждого объекта будет различным (зависящим от этого конкретного объекта).

Например, если мы при помощи наследования создадим серию роботов разных типов (робот, который варит кофе; робот, который моет пол; робот, который поливает цветы), а потом каждому роботу дадим команду «работай», то каждый робот в ответ на ту же самую команду будет делать различные действия, в соответствии с его типом. То есть, единым интерфейсом здесь является объект Robot с методом «работать», а то, как именно он будет работать, зависит от его реализации.

В данной статье понятия ООП были рассмотрены с ознакомительной целью, в дальнейшем они будут рассмотрены более подробно.

Создавать класс мы будем в программе Ecllipse, но также можно работать в любой другой IDE или в блокноте. В качестве примера мы будем создавать класс, который описывает характеристики и поведение кота.

Вспомним урок 3, и создадим в нашем проекте новый класс под именем Сat. Для этого в меню Ecllipse выберем File -> new -> class и, в открывшемся окне, введем имя класса – Сat (обязательно с большой буквы!). Обратите внимание, что галочка public static void main (String[] args) должна быть снята! Затем нажмем Finish (рис 5.1).



В итоге, у нас создался новый класс (рис 5.2).



Структура класса в java

Класс в java оформляется с помощью следующей конструкции:



Рассмотрим ее составляющие:

public – модификатор доступа к классу, в данном случае он нам говорит, что этот класс будет доступен не только данному классу, но и другим. В java существуют и другие модификаторы, но об этого поговорим позднее.

class – ключевое слово, говорящее о том, что это класс.

Cat – имя класса. Имена классов принято писать с заглавной буквы.

{ } – фигурные скобки, между которыми разместится тело нашего класса.

В предыдущем уроке мы упоминали, что классы в java состоят из атрибутов и методов, присвоим некоторые и нашему коту.

Атрибуты класса Сat

Атрибутами кота могут быть: имя, вес, окраска. Атрибуты это переменные, которые объявляются следующим образом:



private – здесь опять же указывает на права доступа. К переменной, в данном случае, можно обращаться только из ее класса, чтобы классы извне не могли ее изменить (вспомним инкапсуляцию из урока 4).

int, String – это типы данных. В данном случае вес будет задан при помощи целого числа – int, a имя и цвет при помощи символьной строки String.

После объявления каждого атрибута должна ставиться точка с запятой ;

При помощи // в коде программы оформляются комментарии, которые являются правилом хорошего тона.

Методы класса Сat

Пусть наш кот умеет есть, спать и разговаривать. Опишем это поведение с помощью методов.



public void eat() – сигнатура метода, его определение. В данном случае она нам говорит о том, что:

метод eat() доступен для других классов – public;

метод eat() не возвращает никаких данных – void.

eat – имя метода. Имена методов, в отличие от имен классов, принято писать с маленькой буквы. На конце каждого метода после имени всегда идут круглые скобки ( ), пустые или содержащие параметры (об этом позднее).

После сигнатуры метода идут фигурные скобки { }. В них содержится тело метода. Тело нашего метода содержит просто вывод сообщения о том, что кот кушает — "Eating...\n". За вывод текстового сообщения отвечает метод System.out.print("Eating...\n").

\n — символ перевода строки, чтобы при выводе наших сообщений все они не писались в одну строку.

Аналогично предыдущему методу опишем спящего кота:

Код

//кот спит
public void sleep(){
    System.out.print("Sleeping zz-z-z-z...\n");
}

И немного иначе опишем метод – кот говорит:

Код

//кот говорит
public String speak(String words){
    String phrase = words + "...mauu...\n";
    return phrase;
}

В отличие от предыдущих методов этот метод возвращает значение и имеет входные параметры. Давайте подробнее рассмотрим сигнатуру метода public String speak(String words):

public - метод speak() доступен для других классов;

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

Что же это значит? В процессе своей работы метод выполняет определенные действия над данными. Иногда необходимо, чтобы результат этих действий был передан для дальнейшей обработки другим классам, в этом случае метод передает (возвращает) этот результат. Эти возвращаемые данные относятся к какому-либо типу. В нашем примере это тип символьной строки, String.

Возвращающие методы должны содержать в своем теле ключевое слово return, которое указывает на то, что именно возвращает данный метод. В нашем случае это переменная phrase.

speak - имя метода.

(String words) — входные параметры. Входные параметры — это какие-либо данные, которые передаются из других классов и, которые метод должен обработать. Наш метод получает в качестве входных данных строку в виде переменной words, к этой строке дописывает «...mauu...» и возвращает то, что получилось.

В итоге класс Cat выглядит следующим образом:

Код

public class Cat {

    private int weight; // вес кота
    private String name; // имя кота
    private String color; //окрас кота

    //кот ест
    public void eat(){
  System.out.print("Eating...\n");
    }

    //кот спит
    public void sleep(){
  System.out.print("Sleeping zz-z-z-z...\n");
    }

    //кот говорит
    public String speak(String words){
  String phrase = words + "...mauu...\n";
  return phrase;
    }

}

Обращение к классу в Java

Далее рассмотрим обращение к классу Cat. И то, как его использовать в работе.

Перейдем в класс HelloWorld, который мы создавали в уроке 3 и немного его модифицируем. Удалим строку System.out.println("Hello World"); , чтобы у нас осталось только следующее (рис 5.3).:

Код

public class HelloWorld {

    /**
  * @param args
  */
    public static void main(String[] args) {

    }
}

Если вы не проходили урок 3 и не создавали класс HelloWorld, то вам его нужно создать: File -> new -> class, ввести в открывшемся окне имя класса и в этот раз обязательно установить галочку public static void main(String[] args).

public static void main(String[] args) – сигнатура метода main(). Программа состоит из нескольких классов, но только один из классов может содержать метод main(). Метод main(), это так называемая точка входа в программу. Без этого метода мы не сможем стартовать программу. Теперь, вместо приветствия миру, этот метод будет содержать код для работы с классом Cat.

Пишем в тело метода main() (между его фигурными скобками) следующие строки:

Код

Cat ourcat = new Cat();
ourcat.eat();
ourcat.sleep();
String say = ourcat.speak("Play with me");
System.out.println(say);

Разберем подробнее, что это значит.

Прежде чем вызывать созданные нами методы в классе Cat и заставить нашего кота есть, спать и говорить, сперва нужно создать экземпляр класса (инстанцию).

Код

Cat ourcat = new Cat();

Данная строчка нам говорит о том, что в памяти создан экземпляр объекта Cat, а переменная ourcat типа Cat (такого же, как и наш объект) указывает на то место в памяти, где был этот объект создан.

Переменную ourcat теперь можно использовать для вызова методов класса Cat, например:

Код

ourcat.eat();
ourcat.sleep();

При вызове этих методов в программе Eclipse удобно пользоваться комбинацией клавиш

Ctrl + пробел, после введения имени переменной и точки (рис 5.4). Программа подскажет, какие можно использовать методы для данной переменной.

Если метод возвращает какое-либо значение, например, как наш метод speak() возвращает значение типа String, то его можно вызывать следующим образом:

объявить переменную такого же типа, что и возвращаемое значение (в нашем случае String)

присвоить ей вызванный метод, например:

Код

String say = ourcat.speak("Play with me");

Вспомним, что при описании нашего метода он содержал параметры speak(String words). Теперь, при вызове в качестве параметра выступила фраза "Play with me", метод speak() ее обработал и вернул "Play with me...mauu...". Именно это значение он присвоил переменной say.

Мы это можем проверить, выведя say на печать при помощи команды:

Код

System.out.println(say);

Итак, наш класс HelloWorld теперь выглядит следующим образом:

Код

public class HelloWorld {

    /**
  * @param args
  */
    public static void main(String[] args) {

  Cat ourcat= new Cat();
  ourcat.eat();
  ourcat.sleep();
  String say = ourcat.speak("Play with me");
  System.out.println(say);
    }

}

Теперь сохраним (Ctrl+Shift+S или ) и запустим () нашу программу. При запуске Eclipse может предложить выбрать Java Applet или Java Application. Нужно выбрать Java Application (рис 5.5).

В качестве результата внизу в консоли мы получаем следующие строки.

Код

Eating...
Sleeping zz-z-z-z...
Play with me...mauu...

На этом закончим данный урок, итак, в этом уроке мы:

Научились создавать класс в java.

Научились объявлять атрибуты и методы класса.

Узнали, что методы могут возвращать или не возвращать значения, иметь или не иметь входных параметров.

Узнали что такое метод main().

Научились создавать экземпляр класса и вызывать его методы, то есть работать с созданным объектом.

Для закрепления материала предлагаю самостоятельно создать класс Dog, где описать характеристики и поведение собаки, а потом вызвать этот класс из HelloWorld.

Для написания программ на языке Java необходимо знать его синтаксис. С этого урока мы начинаем знакомство с основами языка. В этом уроке мы рассмотрим:

что такое переменные в java и как их объявлять,

как правильно именовать переменные,

какие существуют типы данных в java:

примитивные типы данных,

ссылочные типы данных,

отдельно рассмотрим тип String.

Java переменные

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

Объявление переменных в java

Пример:

Код

int x = 1;
int y = 2;

При объявлении переменной, в следующей последовательности указываются:

тип данных (в данном примере — int — переменная содержит целое число),

имя переменной (в данном примере имена — x и y),

начальное значение переменной или, другими словами, инициализация переменной. В данном примере переменным x и y присвоены значения 1 и 2. Однако, это не является обязательным условием при объявлении переменной.

Пример: объявление переменных без инициализации:

Код

int x;
int y;

После каждой строки при объявлении переменных необходимо ставить точку с запятой «;».

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

Код

int x,y;

Правила именования переменных в java

1. Имя переменной должно начинаться с буквы (маленькой) и состоять из букв (Unicode) цифр и символа подчеркивания «_». Технически возможно начать имя переменной также с «$» или «_», однако это запрещено соглашением по оформлению кода в Java (Java Code Conventions). Кроме того, символ доллара «$», по соглашению, никогда не используется вообще. В соответствии с соглашением имя переменной должно начинаться именно с маленькой буквы (с заглавной буквы начинаются имена классов). Пробелы при именовании переменных не допускаются.
2. Имя переменной не должно быть ключевым или зарезервированным словом языка Java.
3. Имя переменной чувствительно к регистру. newVariable и newvariable — разные имена.
4. При выборе имени переменных, следует использовать полные слова вместо загадочных аббревиатур. Это сделает ваш код более удобным для чтения и понимания. Во многих случаях это также сделает ваш код самодокументируемым.
5. Если выбранное вами имя переменной состоит только из одного слова — запишите его маленькими буквами. Если оно состоит из более чем одного слова, то отделяйте каждое последующее слово в имени переменной заглавной буквой. Например: superCounter, myDomesticAnimal
6. Если переменная сохраняет постоянное значение, то каждое слово следует писать заглавными буквами и отделять при помощи символа подчеркивания. Пример: static final int NUMBER_OF_HOURS_IN_A_DAY = 24

Типы данных в java

Каждая переменная и каждое выражение в Java обладает типом и этот тип строго определен.

Примитивные типы данных

В Java существует 8 примитивных типов данных:

byte (целые числа, 1 байт)

short (целые числа, 2 байта)

int (целые числа, 4 байта)

long (целые числа, 8 байтов)

float (вещественные числа, 4 байта)

double (вещественные числа, 8 байтов)

char (символ Unicode, 2 байта)

boolean (значение истина/ложь, 1 байт)

Эти 8 типов служат основой для всех остальных типов данных. Примитивные типы обладают явным диапазоном допустимых значений.

byte — диапазон допустимых значений от -128 до 127

Код

//объявление переменных типа byte.
byte getByte, putByte;
// инициализация переменных
getByte = 0;
putByte = 0;

Переменные типа byte полезны при работе с потоком данных, который поступает из сети или файла.

short - диапазон допустимых значений от -32768 до 32767

Код

//объявление и инициализация переменной типа short.
short employeeID = 0;

int — диапазон допустимых значений от -2147483648 до 2147483647

Код

//объявление и инициализация переменной типа int.
int max = 2147483647;

Тип int используется чаще при работе с целочисленными данными, нежели byte и short, даже если их диапазона хватает. Это происходит потому, что при указании значений типа byte и short в выражениях, их тип все равно автоматически повышается до int при вычислении.

long — диапазон допустимых значений от -9223372036854775808 до 9223372036854775807

Код

//Использование переменных типа long.
long days = getDays();
long seconds;
seconds = days * 24 * 60 * 60;

Тип удобен для работы с большими целыми числами.

float — диапазон допустимых значений от ~1,4*10-45 до ~3,4*1038

Код

//Объявление и инициализация переменных типа float.
float usd = 31.24f;
float eur = 44.03f;

Удобен для использования, когда не требуется особой точности в дробной части числа.

double — диапазон допустимых значений от ~4,9*10-324 до ~1,8*10308

Код

//Объявление и инициализация переменных типа double.
double pi = 3.14159;

Математические функции такие как sin(), cos(), sqrt() возвращают значение double

char — символьный тип данных представляет собой один 16-битный Unicode символ. Он имеет минимальное значение ‘\ u0000′ (или 0), и максимальное значение ‘\ uffff’ (или 65535 включительно). Символы char можно задавать также при помощи соответствующих чисел. Например символ ‘Ы’ соответствует числу 1067. Рассмотрим на примере:

Код

public static void main(String[] args) {

    char symb1=1067;
    char symb2 ='Ы';

    System.out.println("symb1 contains "+ symb1);
    System.out.println("symb2 contains "+ symb2);
}

Вывод этой программы будет:

Код

symb1 contains Ы
symb2 contains Ы

Небольшой пример того, как узнать, какому числу соответствует символ. Основан на претиповании данных.

Код

public static void main(String[] args) {

       char ch = 'J';
       int intCh = (int) ch;

       System.out.println("J corresponds with "+ intCh);
}

На выводе программа показывает, что символу 'J' соответствует число 74.

Код

J corresponds with 74

boolean — предназначен для хранения логических значений. Переменные этого типа могут принимать только одно из 2х возможных значений true или false.

Код

//Объявление и инициализация переменной типа boolean.
boolean b = true;

Тип String

Тип String не является примитивным типом данных, однако это один из наиболее используемых типов в Java. String предназначен для хранения строк текста. Несколько примеров использования String

Код

//Создание строки с помощью конструктора
String myString = new String("The weather was fine");
//Можно также создать строку используя кавычки ""
String myString = "The weather was fine";

Для строк определен оператор «+»

Код

public static void main(String[] args) {

    String s1 = "I have ";
    String s2 = " apples ";
    int num = 3;
    String s = s1 + num + s2;

    System.out.println(s);
}

Вывод программы.

Код

I have 3 apples

Ссылочные типы данных

В ссылочные типы входят все классы, интерфейсы, массивы. Описанный выше тип String также относится к ссылочным типам. Этот класс из стандартной библиотеки Java.

Также существуют классы-оболочки:

Byte

Short

Integer

Long

Float

Double

Character

Boolean

В отличие от примитивных типов, они пишутся с заглавной буквы. Эти типы соответствуют примитивным типам, однако являются ссылочными. Их классы cодержат методы для преобразования типов, а также другие константы и методы полезные при работе с примитивными типами данных.

В качестве типа также выступает любой созданный нами класс при создании инстанции класса. Вспомним прошлый урок, где мы создали класс Cat, а потом создали переменную ourcat типа Cat при создании экземпляра класса.

Код

Cat ourcat = new Cat();

На этом закончим наше знакомство с переменными и типами в Java.

Итак, в этом уроке мы узнали какие бывают типы данных, научились объявлять переменные. В следующем уроке рассмотрим приведение типов.

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

Преобразование строки в число

String to byte

String to short

String to int

String to long

String to float

String to double

String to boolean

Преобразование числа в строку

int to String

double to String

long to String

float to String

Преобразования символа char

char to String

char to int

Преобразования чисел

int to long

int to float

long to int

double to int

Java преобразование строки в число (STRING to NUMBER)

В следующих примерах будет использована конструкция try-catch. Это необходимо для обработки ошибки, в случае, если строка содержит иные символы кроме чисел или число, выходящее за рамки диапазона допустимых значений определенного типа.

Например, строка «somenumber» не может быть переведена в тип int или в любой другой числовой тип. В это случае, при компеляции возникнет ошибка. Чтобы этого избежать, следует обезопаситься с помощью конструкции try-catch.

String to byte

C использованием конструктора

Код

try {
        Byte b1 = new Byte("10");
        System.out.println(b1);
    } catch (NumberFormatException e) {
        System.err.println("Неверный формат строки!");
    }

С использованием метода valueOf класса Byte

Код

String str1 = "111";
    try {
        Byte b2 = Byte.valueOf(str1);
        System.out.println(b2);
    } catch (NumberFormatException e) {
        System.err.println("Неверный формат строки!");
    }

С использованием метода parseByte класса Byte

Код

byte b = 0;
    String str2 = "100";
    try {
        b = Byte.parseByte(str2);
        System.out.println(b);
    } catch (NumberFormatException e) {
        System.err.println("Неверный формат строки!");
    }

Перевод строки в массив байтов и обратно из массива байтов в строку

Код

String str3 = "20150";
    byte[] b3 = str3.getBytes();
    System.out.println(b3);
    
    //массив байтов переводим обратно в строку
    try {
   String s = new String(b3, "cp1251");
   System.out.println(s);
    } catch (UnsupportedEncodingException e) {
   e.printStackTrace();
    }

String to short

C использованием конструктора

Код

try {
        Short s1 = new Short("68");
        System.out.println(s1);
    }catch (NumberFormatException e) {  
        System.err.println("Неверный формат строки!");  
    }

C использованием метода valueOf класса Short

Код

String str1 = "59";
    try {
        Short s2 = Short.valueOf(str1);
        System.out.println(s2);    
    }catch (NumberFormatException e) {  
        System.err.println("Неверный формат строки!");  
    }

C использованием метода parseShort класса Short

Код

short s3 = 0;  
    String str2 = "100";  
    try {  
        s3 = Short.parseShort(str2);  
        System.out.println(s3);  
    } catch (NumberFormatException e) {  
        System.err.println("Неверный формат строки!");  
    }

String to int

C использованием конструктора

Код

try {
        Integer i1 = new Integer("20349");
        System.out.println(i1);
    }catch (NumberFormatException e) {  
        System.err.println("Неверный формат строки!");  
    }

C использованием метода valueOf класса Integer

Код

String str1 = "1451";
    try {
        Integer i2 = Integer.valueOf(str1);
        System.out.println(i2);    
    }catch (NumberFormatException e) {  
        System.err.println("Неверный формат строки!");  
    }

C использованием метода parseInt класса Integer

Код

int i3 = 0;
    String str2 = "102944";
    try {
        i3 = Integer.parseInt(str2);
        System.out.println(i3);  
    } catch (NumberFormatException e) {  
        System.err.println("Неверный формат строки!");  
    }

String to long

C использованием конструктора

Код

try {
        Long l1 = new Long("11111111");
        System.out.println(l1);
    } catch (NumberFormatException e) {
        System.err.println("Неверный формат строки!");
    }

C использованием метода valueOf класса Long

Код

String str1 = "222222222";
    try {
        Long l2 = Long.valueOf(str1);
        System.out.println(l2);
    } catch (NumberFormatException e) {
        System.err.println("Неверный формат строки!");
    }

C использованием метода parseLong класса Long

Код

long l3 = 0;
    String str2 = "333333333";
    try {
        l3 = Long.parseLong(str2);
        System.out.println(l3);
    } catch (NumberFormatException e) {
        System.err.println("Неверный формат строки!");
    }

String to float

С использованием конструктора

Код

try {
        Float f1 = new Float("123.5");
        System.out.println(f1);
    } catch (NumberFormatException e) {
        System.err.println("Неверный формат строки!");
    }

C использованием метода valueOf класса Float

Код

String str1 = "3.1415";
    try {
        Float f2 = Float.valueOf(str1);
        System.out.println(f2);
    } catch (NumberFormatException e) {
        System.err.println("Неверный формат строки!");
    }

C использованием метода parseFloat класса Float

Код

float f3 = 0;
    String str2 = "36.6";
    try {
        f3 = Float.parseFloat(str2);
        System.out.println(f3);
    } catch (NumberFormatException e) {
        System.err.println("Неверный формат строки!");
    }

String to double

С использованием конструктора

Код

try {
        Double d1 = new Double("4.4e10");
        System.out.println(d1);
    } catch (NumberFormatException e) {
        System.err.println("Неверный формат строки!");
    }

C использованием метода valueOf класса Double

Код

String str1 = "564.6e10";
    try {
        Double d2 = Double.valueOf(str1);
        System.out.println(d2);
    } catch (NumberFormatException e) {
        System.err.println("Неверный формат строки!");
    }

C использованием метода parseDouble класса Double

Код

double d3 = 0;
    String str2 = "13.7e10";
    try {
        d3 = Double.parseDouble(str2);
        System.out.println(d3);
    } catch (NumberFormatException e) {
        System.err.println("Неверный формат строки!");
    }

String to boolean

Преобразование строки в логический тип 2мя способами. Обратите внимание, что строка не соответствующая true, будет преобразована в логическое значение false.

Код

String s1 = "True";
    String s2 = "yes";
    boolean bool1, bool2, boolean1, boolean2;

    //с использованием метода parseBoolean
    bool1 = Boolean.parseBoolean(s1);
    bool2 = Boolean.parseBoolean(s2);
    System.out.println( bool1 );
    System.out.println( bool2 );

    //c использованием метода valueOf
    boolean1 = Boolean.valueOf(s1);
    boolean2 = Boolean.valueOf(s2);
    System.out.println( boolean1 );
    System.out.println( boolean2 );

Java преобразование числа в строку (NUMBER to STRING)

int to String

Код

int i = 35;
   String str = Integer.toString(i);
   System.out.println(str);

double to String

Код

double  i = 32.4e10;
   String str = Double.toString(i);
   System.out.println(str);

long to String

Код

long  i = 3422222;
   String str = Long.toString(i);
   System.out.println(str);

float to String

Код

float  i = 3.46f;
   String str = Float.toString(i);
   System.out.println(str);

Преобразования символа char

char to String

Код

char ch = 'S';

    // c использованием класса Character
    String charToString = Character.toString(ch);
    System.out.println(charToString);

    // с использованием операции добавления класса String
    String str = "" + ch;
    System.out.println(str);

    //с использованием массива
    String fromChar = new String(new char[] { ch });
    System.out.println(fromChar);

    // с использованием метода valueOf класса String
    String valueOfchar = String.valueOf(ch);
    System.out.println(valueOfchar);

char to int

Код

char ch = '9';

    // c использованием метода getNumericValue
    // класса Character
    int i1 = Character.getNumericValue(ch);
    System.out.println(i1);

    // c использованием метода digit класса Character
    int i2 = Character.digit(ch,10);
    System.out.println(i2);

Преобразования чисел

int to long

Код

int i = 2015;
    long l = (long) (i);
    System.out.println(l);

int to float

Код

int i = 2015;
    float f = (float) (i);
    System.out.println(f);

long to int

Код

long l = 214748364;
    int i = (int) l;
    System.out.println(i);

double to int

Код

double d = 3.14;
    int i = (int) d;
    System.out.println(i);

обратите внимание на то, что после преобразования double в int отбрасывается дробная часть и остается только целое число. Так, в нашем примере, на консоль будет выведено число 3.

Для того, чтобы изменить последовательность выполнения фрагментов программы, в языке Java применяются конструкции if, if-else и switch.

В этом уроке мы рассмотрим:

Как применяются условные операторы if, if-else и switch.

Какие существуют Логические операторы в Java.

В чем отличие между оператором == и методом equals при сравнении.

Какие возможны сокращения для конструкции if-else.

В конце урока предложены упражнения для закрепления материала.

Конструкция if-else имеет следующий вид:

Код

if (логическое_выражение) {
    //блок кода 1
}
else{
    //блок кода 1
}

Блок else не является обязательным.

Логическое выражение это выражение (или переменная), возвращающее значение типа boolean.

Пример:

Код

boolean b = true;
if (b) {
    System.out.println("b - истина");
}

Логические операторы в Java.

В логическом выражении могут использоваться следующие логические операторы: ==, !=,<=,>=,>,<, &&,||,! .

Рассмотрим на примере:

Код

int a = 4;
int b = 5;
boolean result;
result = a == b // a равно b - false
result = a != b // a не равно b - true
result = a < b; // a меньше b - true
result = a > b; // a больше b - false
result = a <= 4 // a меньше или равно 4 - true
result = b >= 6 // b больше или равно 6 - false
result = a > b || a < b // (a больше b) логическое или (a меньше b) - true
result = 3 < a && a < 6 // (3 меньше a) логическое и(a меньше 6) - true
result = !result // логическое нет - false

Отличие == и equals

Оператор == работает иначе на объектных типах данных, нежели на примитивных. Когда мы используем объекты и хотим проверить их равенство, то оператор == укажет нам лишь на то, являются ли объекты одними и теми же или нет. Если же необходимо проверить логическое равенство объектов, то следует использовать метод equals. Пример:

Код

String str1 = new String("Привет");
String str2 = new String("Привет");
String sameStr = str1;

boolean b1 = str1 == str2; // b1 - false, потому что str1 и str2 это 2 разных объекта
boolean b2 = str1.equals(str2); // b2 - true, потому что str1 и str2 логически эквивалентны
boolean b3 = str1 == sameStr; // b3 -true, потому что str1 и sameStr в действительности один и тот же объект

Условный оператор if

Ели логическое выражение в скобках правдиво, то выполняется , блок кода в фигурных скобках {} после if. Если логическое выражение принимает значение false, то ничего не происходит.

Код

if (a == b) {
    //Если a равно b - выводим сообщение
    System.out.println("a и b равны!");
}

Условный оператор if-else

Конструкция if-else отличается от предыдущей тем, что если логическое выражение в круглых скобках принимает значение false, то выполняется блок кода, находящийся в фигурных скобках после ключевого слова else

Код

if (a == b) {
    //Если a равно b - выводим сообщение
    System.out.println("a и b равны!");
}
else{
    //Если a не равно b - выводим сообщение
    System.out.println("a и b не равны!");
}

Возможные сокращения if-else

1. Если блоки кода if, else содержат лишь одну строку, то можно обойтись без использования фигурных скобок. Предыдущий пример можем записать так:

Код

if (a == b)
    System.out.println("a и b равны!");
else
    System.out.println("a и b не равны!");

2. Существует еще один способ сокращения оператора if-else при помощи оператора ? :. Запишем предыдущий пример следующим образом:

Код

System.out.println(a==b ? "a и b равны!" : "a и b не равны!");

Общая форма записи условия выглядит следующим образом:

Код

Логическое_выражение ? Выражение1 : Выражение2

Если Логическое_выражение принимает значение true, то выполняется Выражение1, а иначе — Выражение2. Внимание: при использовании этой конструкции два последних выражения должны иметь один и тот же тип.

Условный оператор switch — case

Условный оператор switch — case удобен в тех случаях, когда количество вариантов очень много и писать для каждого if-else очень долго. Конструкция имеет следующий вид:

Код

switch (выражение) {
      case значение1:
        //блок кода 1;
        break;
      case значение2:
        //блок кода 2;  
        break;
        ...  
      case значениеN:
        //блок кода N;  
        break;  
      default:  
        блок N+1;
   }

switch работает с такими примитивными типами данных как: byte, short, char, и int. Также с типами Enum, классом String и несколькими специальными классами-оболочками примитивных типов: Character, Byte, Short, Integer.

Выражение в круглых скобках после switch сравнивается со значениями, указанными после слова case, и, в случае совпадения, управление передается соответствующему блоку кода. Если выражение не совпадает ни с одним вариантом case, то управление передается блоку default, который не является обязательным. После выполнения соответствующего блока, оператор break вызывает завершение выполнения оператора switch. Если break отсутствует, то управление передается следующему блоку за только что выполненным.

В следующем примере, для целочисленного значения, представляющего день недели, определяется его название в виде строки. Для значения 3, переменная dayString примет значение «Среда».

Код

int day = 3;
    String dayString;
    switch (day) {
        case 1:  dayString = "Понедельник";
                 break;
        case 2:  dayString = "Вторник";
                 break;
        case 3:  dayString = "Среда";
                 break;
        case 4:  dayString = "Четверг";
                 break;
        case 5:  dayString = "Пятница";
                 break;
        case 6:  dayString = "Суббота";
                 break;
        case 7:  dayString = "Воскресенье";
                 break;
        default: dayString = "Ошибка";
                 break;
    }
    System.out.print(dayString);

Упражнения на тему Условные операторы в Java:

1. Даны 4 числа типа int. Сравнить их и вывести наименьшее на консоль.
2. Вывести на консоль количество максимальных чисел среди этих четырех.
3. Даны 5 чисел (тип int). Вывести вначале наименьшее, а затем наибольшее из данных чисел.
4. Даны имена 2х человек (тип String). Если имена равны, то вывести сообщение о том, что люди являются тезками.
5. Дано число месяца (тип int). Необходимо определить время года (зима, весна, лето, осень) и вывести на консоль.

Цикл в программировании используется для многократного повторения определенного фрагмента кода. В Java существует 3 оператора цикла: for, while, do-while.

В этом уроке мы рассмотрим:

Как применяются операторы цикла for, while, do-while.

Досрочный выход из цикла

В конце урока предложены упражнения для закрепления материала.

Рассмотрим подробнее использование операторов цикла в Java.

При использовании конструкции for заранее известно, сколько раз необходимо осуществить повторение. При использовании конструкций while или do-while повторения будут происходить до тех пор, пока выполняется некоторое условие (логическое выражение)

Цикл for в Java.

Рассмотрим пример: вывод на экран числа от 1 до 10.

Код

for (int i = 1; i <= 10; i++) {
  System.out.print(i + " ");
}

Конструкция for имеет следующий вид:

Код

for (инициализация; условие; итерация) {
    //тело цикла
}

Инициализация — первый параметр, который содержит переменную и ее начальное значение. С помощью этой переменной будет подсчитываться количество повторений цикла. В нашем примере это переменная int i = 1.

Условие — второй параметр, содержит некоторое логическое выражение — условие при котором будет выполняться цикл. В нашем примере это условие i <= 10.

Итерация — третий параметр, выражение, изменяющее переменную (заданную в инициализации) после каждого шага цикла. Изменение происходит только в случае выполнения условия. В нашем примере итерация i++ — увеличение переменной на единицу. Также для итерации часто используется i— — уменьшение переменной на единицу.

Пример: Вывод на экран чисел от 10 до −10:

Код

for (int i = 10; i > -11; i--) {
  System.out.print(i + " ");
}

Цикл while в Java.

Пример: Вывод на экран значений от 1 до 10.

Код

int i = 1;
while(i < 11){
    System.out.println("i= " + i);
    i++;
}

Конструкция while имеет следующий вид:

Код

while(логическое_выражение) {
    //тело цикла
}

Конструкция while выполняет выражение в фигурных скобках до тех пор, пока параметр логическое_выражение имеет истинное значение (true). Этот параметр является условием выполнения цикла. В выше приведенном примере, логическое выражение имеет вид i < 11.

Истинность логического выражения (условия) проверяется перед каждым шагом цикла, в том числе и перед первым. while так же называют оператором предусловия.

Приведем пример цикла, который не выполнится ни разу:

Код

int i =10;
while(i < 5){
    System.out.println("i= " + i);
    i++;
}

Для реализации бесконечного цикла, в качестве параметра достаточно указать true

Код

while(true) {
    //тело цикла
}

Цикл do-while в Java.

В отличие от оператора while, do-while является оператором постусловия, который сначала выполняет тело цикла, а потом осуществляет проверку условия. Таким образом, тело цикла выполнится всегда хотя бы один раз.

Пример: Вывод на экран значений от 1 до 10.

Код

int i = 1;
do{
    System.out.println("i = " + i);
    i++;
}while(i < 11);

Конструкция do — while имеет следующий вид:

Код

do {
    //тело цикла
}while(логическое_выражение);

Как видно из конструкции, тело цикла выполняется перед проверкой условия. Впоследствии, тело цикла повторится в случае, если логическое_выражение было истинно. Оператор do-while удобно применять, если некоторые действия необходимо выполнить, по крайней мере, один раз, а их повторение будет зависеть от условия.

Вспомним пример цикла while, который не выполнится ни разу, и перепишем его с помощью оператора do-while

Код

int i =10;
do{
    System.out.println("i= " + i);
    i++;
}while(i < 5);

После выполнения цикла, на экран будет выведено значение i= 10.

Досрочный выход из цикла (оператор break)

Выполнение цикла можно прервать, если внутри тела цикла вызвать оператор break. После выполнения оператора break произойдет моментальный выход из цикла (не будет окончена даже текущая итерация). Управление передастся оператору, следующему за циклом.

В следующем примере реализован поиск символа в строке. Оператор break используется для выхода из цикла for. В цикле происходит прохождение всех символов строки (с первого по последний) и сравнение с искомым символом. В случае нахождения нужного символа нет смысла просматривать оставшуюся часть строки, тем самым продолжая цикл, поэтому имеет смысл использовать оператор break, как только символ будет найден.

Код

public class BreakDemo {

    public static void main(String[] args) {

        //строка для поиска
        String searchMe = "Мама мыла раму";
        //количество символов в строке
        int max = searchMe.length();
        //символ, который нужно найти в строке
        char symb = 'ы';
        //переключатель найдено/не найдено
        boolean find = false;

        for (int i = 0; i < max; i++) {
            // если символ на позиции i в строке равен искомому символу
            if (searchMe.charAt(i) == symb) {
                //переключаемся в режим "найдено" и выходим из цикла
                find = true;
                break;
            }

        }

        //выводим соответствующее сообщение: найден или не найден символ
        if (find)
            System.out.println("Символ '" + symb + "' найден в строке");
        else
            System.out.println("Символ '" + symb + "' не найден в строке");

    }
}

Упражнения на тему Операторы цикла в Java:

1. При помощи цикла for вывести на экран нечетные числа от 1 до 99.
2. Дано число n при помощи цикла for посчитать факториал n!
3. Перепишите программы с использованием цикла while.
4. Даны переменные x и n вычислить x^n.
5. Вывести 10 первых чисел последовательности 0, -5,-10,-15..
6. Переделайте последний пример на break. Необходимо, чтобы заданный символ встречался в строке хотя бы 2 раза.

Массив (англ. Array) это объект, хранящий в себе фиксированное количество значений одного типа. Другими словами, массив — это нумерованный набор переменных. Переменная в массиве называется элементом массива, а ее позиция в массиве задается индексом. Например, нам нужно хранить 50 различных имен, согласитесь, неудобно для каждого имени создавать отдельную переменную, поэтому мы будем использовать массив. Нумерация элементов массива начинается с 0, а длинна массива устанавливается в момент его создания и фиксируется.

Для наглядности картинка, взятая мною с The Java Tutorial.



Для того чтобы создать массив нужно его объявить, зарезервировать для него память и инициализировать.

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

При создании массива в Java первым делом его нужно объявить. Это можно сделать следующим образом:



Можно также объявить массив так:



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

Исходя из данного примера, мы объявили 2 массива с именами myFirstArray и mySecondArray. Оба массива будут содержать элементы типа int.

Подобным образом можно объявить массив любого типа:



Тип массива задается следующим образом type[], где type это тип данных содержащихся в нем элементов. Скобки являются специальным обозначением того, что переменные содержатся в массиве. Имя массива может быль любым, однако, оно должно соответствовать правилам именования переменных.

Массивы можно создавать не только из переменных базовых типов, но и из произвольных объектов.

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

Резервация памяти для массива и его инициализация.

Далее, для объявленного myFirstArray, зарезервируем память при помощи ключевого слова new.



В нашем примере мы создали массив из 15 элементов типа int и присвоили его ранее объявленной переменной myFirstArray.

Объявлять имя массива и резервировать для него память также можно на одной строке.



При создании массива с помощью ключевого слова new, все элементы массива автоматически инициализированы нулевыми значениями. Для того, чтобы присвоить элементам массива свои начальные значения, необходимо провести его инициализацию. Инициализацию можно проводить как поэлементно



так и в цикле, с помощью индекса проходя все элементы массива и присваивая им значения.



Как видно из предыдущих примеров, для того, чтобы обратиться к элементу массива, нужно указать его имя и, затем, в квадратных скобках — индекс элемента. Элемент массива с конкретным индексом ведёт себя также, как и переменная.

Рассмотрим создание и инициализацию массива на следующем примере. В нем мы создаем массив, содержащий цифры 0-9 и выводим значения на консоль.



Упрощенная форма записи

Для создания и инициализации массива можно также использовать упрощенную запись. Она не содержит слово new, а в скобках перечисляются начальные значения массива.



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

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

Размер массива не всегда очевиден, поэтому для того, чтобы его узнать следует использовать свойство length, которое возвращает длину массива.



Данный код поможет нам узнать, что длина массива myColor равна 3.

Пример: Задано 4 числа, необходимо найти минимальное



Упражнения на тему одномерные массивы в Java:

1. Создайте массив, содержащий 10 первых нечетных чисел. Выведете элементы массива на консоль в одну строку, разделяя запятой.
2. Дан массив размерности N, найти наименьший элемент массива и вывести на консоль (если наименьших элементов несколько — вывести их все).
3. В массиве из задания 2. найти наибольший элемент.
4. Поменять наибольший и наименьший элементы массива местами. Пример: дан массив {4, -5, 0, 6, 8}. После замены будет выглядеть {4, 8, 0, 6, -5}.
5. Найти среднее арифметическое всех элементов массива.

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

Если тема для вас новая, и вы еще не знакомы с алгоритмами сортировки, то наверняка при решении задачи «Отсортировать массив по возрастанию» первое что придет в голову, это перебор, то есть: найти минимальный элемент и поменять его местами с начальным, потом, в оставшейся части массива (кроме первого элемента), найти снова минимальный элемент и поменять его со вторым элементом и т.д. Такой алгоритм называется Сортировка выбором. Рассмотрим его подробнее.

Сортировка выбором (Selection sort) в Java.

Реализация алгоритма Сортировка выбором на Java:



Еще одним достаточно простым и известным способом сортировки является Сортировка пузырьком.

Сортировка пузырьком (Bubble sort) в Java.

Алгоритм проходит массив от начала и до конца, сравнивая попарно соседние элементы, Если элементы стоят в неправильном порядке, то они меняются местами, таким образом, после первого прохода на конце массива оказывается максимальный элемент (для сортировки по возрастанию). Затем проход массива повторяется, и на предпоследнем месте оказывается другой наибольший после максимального элемент и т.д. В итоге, наименьший элемент постепенно перемещается к началу массива («всплывает» до нужной позиции как пузырёк в воде).

Реализация алгоритма Сортировка пузырьком на Java (по возрастанию):



Следующие 2 видео наглядно демонстрируют работу алгоритмов сортировки пузырьком и выбором.





Рассмотрим примеры того, как можно воспользоваться выше приведенными алгоритмами.
Для начала создадим массив. Это можно сделать так:



Или мы можем создать массив случайных чисел



Затем воспользуемся вышеприведенными алгоритмами сортировки



или



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

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

Сортировка массива при помощи метода sort() из класса Arrays.

Метод sort() из класса Arrays использует усовершенствованный алгоритм Быстрой сортировки (Quicksort), который эффективен в большинстве случаев. Для того чтобы отсортировать массив, необходимо написать всего одну строку.



Примечание: в начале файла предварительно нужно подключить библиотеку java.util.



Сортировка массива целых чисел по возрастанию:



Сортировка массива целых чисел по убыванию:



Обратите внимание, что при сортировке массива в обратном порядке (по убыванию) нужно использовать тип Integer[] вместо примитивного типа int[].

Сортировка массива строк в Java:



В этом примере массив имен сортируется в порядке от А до Я. Для того чтобы отсортировать массив в обратном порядке, необходимо в методе sort() указать Collections.reverseOrder().



К сожалению, по умолчанию метод sort() сортирует только примитивные типы данных и строки. Как сортировать массив из собственно созданных объектов, будет рассмотрено в следующих уроках, поскольку это требует более углубленных знаний.

Упражнения на тему сортировка массивов в Java:

1. Создайте массив из 20 случайных чисел (числа должны быть в диапазоне от 0 до 1000) и отсортируйте массив по убыванию при помощи сортировки пузырьком.
2. Создайте массив содержащий марки автомобилей, отсортируйте его сначала по возрастанию, потом по убыванию.

В уроке 10 мы научились создавать одномерные массивы. Подобным образом в Java можно создать двумерный, трехмерный, четырехмерный… иначе говоря, многомерные массивы. Многомерный массив в Java по сути является массивом из массивов.

Популярным примером использования такого рода массивов, являются матрицы, для представления которых, используются двумерные массивы. Итак, что же такое матрица и как ее представить с помощью двумерного массива в Java.

Матрицы и двумерные массивы в Java

Матрица это прямоугольная таблица, состоящая из строк и столбцов на пересечении которых находятся её элементы. Количество строк и столбцов матрицы задают ее размер.

Общий вид матрицы размером m x n (m — количество строк, n — количество столбцов), выглядит следующим образом:



Каждый элемент матрицы имеет свой индекс, где первая цифра обозначает номер строки на которой находится элемент, а вторая — номер столбца.

Рассмотрим примеры конкретных матриц и создадим их с помощью Java.



Матрица A имеет размерность 2 на 3 (2 строки, 3 столбца). Создадим двухмерный массив этой размерности:



Мы объявили двумерный массив целых чисел (поскольку матрица в данном случае содержит целые числа) и зарезервировали для него память. Для этого мы использовали 2 индекса: первый индекс определяет строку и ее размер, второй индекс определяет столбец и его размер.

Далее будем инициализировать массив поэлементно. Запишем матрицу A в виде таблицы, чтобы было визуально понятно, какому индексу соответствует элемент.



Для доступа к элементам двумерного массива необходимо использовать 2 индекса: первый для строки, второй – для столбца. Как и в случае с одномерными массивами, индексы также начинаются с нуля. Поэтому нумерация строк и столбцов в таблице начинается с 0.



Для того, чтобы вывести матрицу на консоль, нужно пройти все элементы, используя два цикла. Количество циклов, при прохождении элементов массива, равно его размерности. В нашем случае первый цикл осуществляется по строкам, второй — по столбцам.



То есть, сначала выводим все элементы первой строки, отделяя их символом табуляции "\t", переносим строку и выводим все элементы второй строки.

Полностью код для матрицы А выглядит следующим образом:



Для матрицы B воспользуемся упрощенным способом инициализации - в момент объявления. По аналогии с одномерными массивами.



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

Полностью код для матрицы B:



Рассмотрим инициализацию в цикле для двумерного массива на примере таблицы умножения.



Здесь инициализация элементов значениями таблицы умножения совмещена с их выводом на консоль в одном цикле.

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

Создаются многомерные массивы в Java аналогичным способом. Количество квадратных скобок указывает на размерность.
Примеры создания массивов фиксированной длины:



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



В данном случае, пока неизвестно сколько будет элементов в каждой строке, это можно определить позже, причем, массив может содержать в каждой строке разное количество элементов, то есть быть несимметричным. Определим количество элементов в каждой строке для массива a1



В результате, при выводе на экран,



массив будет иметь такой вид:

0
0 0
0 0 0
0 0 0 0
0 0 0 0 0

При создании массива его элементы автоматически инициализируются нулями, поэтому в это примере на экран выведены нули.

Упражнения на тему многомерные массивы в Java:

1. Создайте массив размерностью 5 на 6 и заполните его случайными числами (в диапазоне от 0 до 99 ). Выведите на консоль третью строку
2. Даны матрицы С и D размерностью 3 на 3 и заполненные случайными числами в диапазоне от 0 до 99. Выполните по отдельности сначала сложение, потом умножения матриц друг на друга. Выведете исходные матрицы и результат вычислений на консоль.
3. Просуммируйте все элементы двумерного массива.
4. Дан двумерный массив, содержащий отрицательные и положительные числа. Выведете на экран номера тех ячеек массива, которые содержат отрицательные числа.
5. Отсортируйте элементы в строках двумерного массива по возрастанию

В уроке 8 мы затронули логические операторы, они нам были необходимы для формирования логического выражения в условиях if. Этот урок будет посвящен математике в Java, и поэтому мы рассмотрим подробнее арифметические операторы и частично возможности класса Math.

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

Арифметические операторы в Java

Для стандартных арифметических операций, таких как сложение, вычитание, умножение, деление в Java используются традиционные символы, к которым мы привыкли со школы:



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



В Java также имеется специальный оператор %, обозначающий остаток от делния.



Пример использования: дан массив целых чисел, вывести на консоль только те числа, которые делятся на 3.



Операции с присваиванием

Рассмотрим задачу вывода на экран 10 первых четных чисел чисел



строку



мы можем записать сокращенно



+= это оператор сложения с присваиванием. Подобные операторы есть для всех основных 5 операций, рассмотренных выше



Пример использования: Найти факториал числа 7.



Инкрементирование и декрементирование

Инкремент, обозначается ++ и увеличивает значение переменной на единицу. Декремент обозначается — и уменьшает значение на единицу. С инкрементом и декрементом мы часто встречаемся в цикле for.

Инкремент и декремент бывают двух форм

Префиксная форма:



Постфиксная форма



Различие префиксной и постфиксной формы проявляется только тогда, когда эти операции присутствуют в выражениях. Если форма префиксная, то сначала произойдет увеличение (или уменьшение) переменной на единицу, а потом с новым значением будет произведены дальнейшие вычисления. Если форма постфиксная, то расчет выражения будет происходить со старым значением переменной, а переменная увеличится (или уменьшится) на единицу после вычисления выражения. Пример



В первом случае сначала переменная a увеличится на 1, потом произойдет вычисление всего выражения. Во втором случае произойдет вычисление выражения при старом значении b = 3, и после вычисления b увеличится на 1, на результат в postfix это уже не повлияет.



Если вы поняли принцип работы постфиксного и префиксного инкремента/декремента, то предлагаю решить в уме такую задачу:



Вопрос: чему в итоге равны x и y? После того, как вы сделали предположение, проверьте его в java.

Задача со зведочкой. Дан код:



Какие числа будут выведены на экран? Почему? Разобраться самостоятельно.

Примечание: инкремент и декремент применяются только к переменной. Выражение вида 7++ считается недопустимым.

Математические функции и константы (класс Math)

Для решения задач нередко требуется использование математических функций. В Java такие функции включены в класс Math. Для того, чтобы использовать методы класса Math, нужно подключить его в начале .java файла с вашим кодом.



Часто используемые математические функции

sqrt(a) — извлекает квадратный корень из числа а.

pow(a, n) — a возводится в степень n.

sin(a), cos(a), tan(a) — тригонометрические функции sin, cos и tg угла a указанного в радианах.

asin(n), acos(n), atan(n) — обратные тригонометрические функции, возвращают угол в радианах.

exp(a) — возвращает значение экспоненты, возведенной в степень a.

log(a) — возвращает значение натурального логарифма числа a.

log10(a) — возвращает значение десятичного логарифма числа a.

abs(a) — возвращает модуль числа a.

round(a) — округляет вещественное число до ближайшего целого.

Константы

PI — число «пи», с точностью в 15 десятичных знаков.

E — число «e»(основание экспоненциальной функции), с точностью в 15 десятичных знаков.

Примеры

Код

System.out.println(sqrt(81));// выведет 9.0
System.out.println(pow(2,10));// выведет 1024.0
System.out.println(sin(PI/2));// выведет 1.0
System.out.println(cos(PI));// выведет -1.0
System.out.println(acos(-1));// выведет 3.141592653589793
System.out.println(round(E));// выведет 3
System.out.println(abs(-6.7));// выведет 6.7

Упражнения

1. Дан массив целых чисел, найти среди элементов массива числа, которые делятся на 3 и на 6
2. Посчитать среднее арифметическое чисел в массиве
3. Известны катеты прямоугольного треугольника, найти его площадь и периметр
4. Даны два целых числа, найти их наибольший общий делитель и наименьшее общее кратное
5. Даны радиус вращения и высота конуса, вычислить объем конуса.

Строка — это упорядоченная последовательность символов. В Java строка является основным носителем текстовой информации. Для работы со строками здесь используются следующие классы: String, StringBuilder, StringBuffer. В этом уроке речь пойдет о классе String, его на первых порах будет вполне достаточно.

В данном уроке рассматривается:

Создание строк

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

Наиболее употребительные методы класса String

Конкатенация

Определение количества символов в строке

Извлечение символов из строки

Извлечение подстроки из строки

Разбиение строк

Поиск в строке

Модификация строк

Сравнение строк

В уроке 6 уже упоминалась работа со строками, а именно, как создавать строку. Также частично со строками мы встречались в предыдущих уроках. В этом и следующих двух уроках мы углубим знания о строках. В этом уроке будут рассмотрены создание строк в Java и наиболее популярные методы при работе со строками. Следующий урок будет посвящен форматированию строк. И еще один урок будет на тему работы с регулярными выражениями в Java, поскольку регулярные выражения достаточно мощный и нужный инструмент при работе со строками.

Но начнем с самого начала.

Создание строк

Строка в Java является объектом, поэтому ее можно создать, как и любой другой объект, при помощи оператора new.

Код

String str1 = new String("Строка созданная при помощи оператора new");

Также строку можно создать при помощи литерала (фразы заключенной в кавычки) следующим образом.

Код

String str2 = "Эта строка создана при помощи литерала.";

Обе строки, независимо от способа создания являются объектами — экземплярами класса String.

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

Можно также создать массив строк. Например, так:

Код

String[] auto = {"Маша", "Петя", "Вася", "Коля"};

Подробнее о массивах и их создании написано в уроке 10.

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

Для того, чтобы объединить несколько разных строк в одну, в Java можно использовать перегруженные (специально для объектов String) операторы «+» и «=+».

Еще один важный момент: операторы «+» и «=+», перегруженные для String, являются единственными перегруженными операторами в Java. Программист здесь не имеет возможности самостоятельно перегружать какие-либо операторы (как, например, в С++ и некоторых других языках).

Пример 1:

Код

String str1 = "Мама ";
String str2 = "мыла ";
String str3 = "раму";

String result = str1 + str2 + str3;
System.out.print(result);

На консоль будет выведено «Мама мыла раму»

Пример 2:

Код

String[] animals = {"Хаски","Морж"};// массив строк 1
String[] food = {"колбаски","корж"}; // массив строк 2

//составляем строки из элементов массивов и связующего слова
String result1 = animals[0] + " ест " + food[0];
String result2 = animals[1] + " ест " + food[1];

//выводим на консоль
System.out.println(result1);
System.out.println(result2);

Пример 3:

Код

String[] auto = {"Волга", "Чайка", "Жигули"}; //задан массив строк
String result = "В гараже стоят машины: "; //задана строка

//прибавляем к строке элементы массива
for(int i = 0; i < auto.length; i++){
   //если элемент не последний, разделяем запятой
   if(i != auto.length-1 )
      result += auto[i] + ", ";
   //если последний, ставим после него точку
   else
      result += auto[i] + ".";
}
//выводим результат
System.out.print(result);

Наиболее употребительные методы класса String

При использовании IDE можно легко увидеть, какие методы есть у класса и получить подсказку по их использованию. На примере IDE Eclipse: для того, чтобы открыть список методов и быстро выбрать подходящий, нужно после имени переменной поставить точку и нажать комбинацию клавиш CTRL + Space (пробел). После этого появится окно, как на рисунке 14.1, где будут перечислены все доступные методы класса.

При выборе метода из этого списка, справа (или слева) появится желтое окно с подсказкой по его использованию. При помощи нажатия Enter или двойного клика мыши метод можно вставить в ваш код, не прибегая к ручному набору.
Также после имени переменной и точки можно начать набирать вручную имя метода и после введения нескольких первых букв нажать CTRL + Space (пробел). При этом, если метод, начинающийся на эти буквы один, то он автоматически подставится в код, если методов несколько, то откроется окно, как на рисунке 14.1, где будут перечислены только те методы, которые начинаются с этих введенных вами букв.
Это было лирическое отступление о том, как облегчить себе жизнь. Далее рассмотрим методы, которые чаще всего используются при работе со строками. Некоторые задачи можно решить и без применения этих методов, но их знание значительно облегчает процесс программирования. В дальнейшем описании, первое слово, которое стоит перед названием метода — тип значения, которое возникнет в результате работы метода (значение, которое метод возвращает).

Еще раз конкатенация

String concat(String str) — производит ту же конкатенацию, что была описана выше, но использование этого метода из класса String положительно влияет на производительность и скорость программы. На небольших примерах это незаметно и не существенно, но в более серьезных приложениях стоит использовать этот метод. Результатом работы метода будет строка. Параметр, который нужно передавать в метод для конкатенации — тоже строка, о чем нам говорит значение в скобках (String str).

Перепишем пример 2, при помощи concat():

Код

String[] animals = {"Хаски","Морж"};// массив строк 1
String[] food = {"колбаски","корж"}; // массив строк 2

//составляем строки из элементов массивов и связующего слова
String result1 = animals[0].concat(" ест ").concat(food[0]);
String result2 = animals[1].concat(" ест ").concat(food[1]);

//выводим на консоль
System.out.println(result1);
System.out.println(result2);

Определение количества символов в строке

Для того чтобы определить количество символов в строке, используется метод length.

int length() — возвращает длину строки. Длина равна количеству символов Unicode в строке.

Пример 4:

Код

String str = "Строка из букв, цифр 492 и специальных символов %*;№?";
int length = str.length();
System.out.println("Длина строки = " + length);

Извлечение символов из строки

Если нам требуется узнать, какой символ находиться в строке на конкретной позиции, можем использовать метод charAt.

char charAt(int index) - возвращает символ, находящийся по указанному индексу в строке. Результатом работы метода будет символ типа char. Параметр, который передается в метод — целое число. Первый символ в строке, подобно массивам, имеет индекс 0.

Пример 5: определить последний символ в строке.

Код

String str = "Последний символ в этой строке - о";
int last = str.length()-1;//длина строки - 1, так как отсчет начинается с 0
char ch = str.charAt(last);
System.out.println(ch);

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

char[] toCharArray() - преобразует строку в новый массив символов.

Пример 6: поменять в строке символы пробела на точки при помощи преобразования в массив символов (для этой задачи есть более простое решение, нежели преобразование в массив, но об этом чуть позже).

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

Код

String str = "1 000 000 000";
//преобразовываем строку в массив
char[] chArray = str.toCharArray();
//перебираем все элементы массива
for(int i = 0; i<chArray.length; i++){
        //находим пробел    
    if(chArray[i] == ' '){
                //заменяем на точку
  chArray[i] = '.';
    
        }    
}
//выводим результат
System.out.println(chArray);

Извлечение подстроки из строки

String substring(int beginIndex, int endIndex) или substring(int beginIndex) - возвращает новую строку, которая является подстрокой используемой строки. В параметрах метода нужно указать индекс строки, с которого начинается подстрока и индекс, которым заканчивается. Также возможно указывать только начальный индекс. В этом случае будет возвращена подстрока от начального индекса и до конца строки.

Пример 7.

Код

String s = "www.mysite.com";
String name = s.substring(4, s.length()-4);
System.out.println(name); // на консоль выведет "mysite"

String domain = s.substring(4);
System.out.println(domain); // на консоль выведет "mysite.com"

Разбиение строк

Для разбиения строк на части используется метод String[] split(String regex), который разбивает строку на основании заданного регулярного выражения. О регулярных выражениях поговорим в одном из следующих уроков. Здесь покажем пример простого разбиения строки заданного одним символом.

Пример 8.

Код

String isbn = "978-3-16-148410-0";
String[] isbnParts = isbn.split("-");

System.out.println("префикс EAN.UCC: " + isbnParts[0]);
System.out.println("номер регистрационной группы: " + isbnParts[1]);
System.out.println("номер регистранта: " + isbnParts[2]);
System.out.println("номер издания: " + isbnParts[3]);
System.out.println("контрольная цифра: " + isbnParts[4]);

Поиск в строке

boolean contains(CharSequence s) — проверяет, содержит ли строка заданную последовательность символов и возвращает true или false.

Пример 9.

Код

String s = "www.mysite.com";
boolean isContain1 = s.contains("mysite");
System.out.println(isContain1);// нашел - выведет true

boolean isContain2 = s.contains("mysite.ru");
System.out.println(isContain2);// не нашел - выведет false

boolean endsWith(String suffix) — проверяет завершается ли строка определенными символами и возвращает true или false.

Пример 10.

Код

String s = "www.mysite.com";

//проверяем заканчивается ли строка суффиксом "com"
boolean isComEnding = s.endsWith("com");
System.out.println(isComEnding);//выведет true

//проверяем заканчивается ли строка суффиксом "ru"
boolean isRuEnding = s.contains("ru");
System.out.println(isRuEnding);//выведет false

boolean startsWith(String prefix) или startsWith(String prefix, int toffset) — проверяет, начинается ли строка с определенных символов. Во втором случае можно указать позицию с которой необходимо начать поиск префикса.

Пример 11.

Код

String s = "www.mysite.com";

//Проверяем, начинается ли адрес с www
boolean isWWW = s.startsWith("www");

if(isWWW){
/* Eсли да, проверяем начинается ли имя сайта
с "my". Поскольку адрес начинается с www
проверку начинаем с 4 символа*/
boolean isNameStarts = s.startsWith("my", 4);
}else{
/* Eсли нет, проверяем начинается ли имя сайта
с "my". Поскольку адрес не начинается с www
проверку производим с начала строки*/
boolean isNameStarts = s.startsWith("my");
}

int indexOf(int ch), indexOf(int ch, int fromIndex), indexOf(String str), indexOf(String str, int fromIndex) - метод indexOf применяется для поиска первого вхождения указанного символа в строке или первого вхождения указанной подстроки. Поиск также можно произвести с указанием позиции в строке от которой нужно начинать искать. Для поиска нужно указать соответствующие параметры. Метод возвращает число соответствующее индексу первого вхождения символа или подстроки. В случае отсутствия указанного символа или подстроки в строке, будет возвращена -1.

Пример 12

Код

String data = "name:Igor\nsurname:Kolashnikov\nage:14\ntime:14:55";
//разбиваем строку на несколько подстрок на основании
// встречаемого символа новой строки
String[]lines=data.split("\n");

//проходим каждую подстроку
for (String line : lines){
     //находим индекс первого вхождения символа ":" в подстроке
     int pos = line.indexOf(":");
     //вычленяем имя атрибута из подстроки
     String attributeName= line.substring(0,pos);
     //вычленяем значение атрибута
     String value = line.substring(pos+1,line.length());
     //вывод на экран вычлененных значений в нужном нам формате.
     System.out.println(attributeName + " - " + value);
}

int lastIndexOf(int ch), lastIndexOf(int ch, int fromIndex), lastIndexOf(String str), lastIndexOf(String str, int fromIndex) — аналогично предыдущему случаю, только ищется последнее вхождение символа или подстроки в строке.

Модификация строк

Модификация строк не является модификацией как таковой. Дело в том, что объекты класса String после создания уже нельзя изменять. Но можно создать копию строки с изменениями. Именно это и делают следующие методы.
toLowerCase() — преобразовать строку в нижний регистр;
toUpperCase() — преобразовать строку в верхний регистр;
trim() - отсечь на концах строки пустые символы;

Пример 13

Код

String str = " Я помню ЧУДНОЕ мгновенье ";

//убрали символы пробела в начале и конце строки
str = str.trim();

//я помню чудное мгновенье
System.out.println(str.toLowerCase());

//Я ПОМНЮ ЧУДНОЕ МГНОВЕНЬЕ
System.out.println(str.toUpperCase());

String replace(char oldChar, char newChar), replace(CharSequence target, CharSequence replacement) — замена в строке одного символа или подстроки на другой символ или подстроку.

Вспомним пример 6, где нужно было поменять в строке символы пробела на точки и перепишем его с использованием replace:

Код

String str = "1 000 000 000";
String newStr = str.replace(" ", ".");
System.out.println(newStr);

Сравнение строк

boolean equals(Object anObject) — проверяет идентичность строк. Возвращает true только в том случае, если в строках представлена одинаковая последовательность символов одной величены.

Пример 14

Код

String str = "Я помню ЧУДНОЕ мгновенье";
String str2 = "я помню чудное мгновенье";
//строки не идентичны
System.out.println(str.equals(str2)); //false

//строки идентичны после перевода первой строки
//в нижний регистр
System.out.println(str.toLowerCase().equals(str2)); // true

int compareTo(String anotherString) - так же проверяет идентичность строк, однако, в отличии от метода equals возвращает:

нулевое значение, если строки равны,

целое отрицательное число, если первая строка предшествует второй

целое положительное число, если первая строка следует за второй

Данный метод предназначен для упорядочивания строк. Он позволяет сравнить строки между собой и определить предшествующую строку. Для того, чтобы реализовать такое сравнение метод сравнивает числовые значения букв.

Рассмотрим пример с именами «Маша» и «Миша». При сравнении этих двух имен (пример 15), метод compareTo укажет, что имя «Маша» предшествует имени «Миша» (выдав отрицательное число) или наоборот, «Миша» следует за «Маша» (выдав положительное число). При упорядочивании имен по алфавиту мы бы упорядочили эти имена именно так. Метод в данном случае определяет, что числовое значение буквы «а» в «Маша» меньше, чем числовое значение «и» в Миша.

Пример 15

Код

String name1 = "Маша";
String name2 = "Миша";
System.out.println(name1.compareTo(name2)); //-8
System.out.println(name2.compareTo(name1)); //8

Однако, в случае, если мы напишем «маша» с маленькой буквы и попробуем сравнить с «Миша», то получим положительное число.

Код

System.out.println("маша".compareTo("Миша")); //32

То есть в данном случае имя «Миша» предшествует имени «маша». Это происходит потому, что в таблице символов Юникода буквы верхнего регистра предшествуют нижнему.

Для сравнения строк без учета регистра символов используется функция int compareToIgnoreCase(String str)

Код

System.out.println("маша".compareToIgnoreCase("Миша")); //-8

Как мы видим, при сравнивании «маша» с «Миша» мы снова получаем отрицательное значение, то есть «маша» предшествует имени «Миша».

На этом закончим знакомство с методами класса String. Это далеко не все методы. Все методы класса String и их описание можно найти в официальной документации http://docs.oracle.com/javase....summary