В этом уроке мы поговорим о формате вывода чисел в Java. Научимся выводить числа с заданной точностью.
Методы printf и format
Пакет java.io содержит класс PrintStream , который содержит эти два метода, эти методы можно использовать вместо print и println . Объект System.out , который вы уже использовали - это объект PrintStream , поэтому вы можете вызывать методы PrintStream используя System.out . Например: System. out. format (. . . . . ) ; Синтаксис методов одинаков: public PrintStream format (String format, Object. . . args) где format - это строка которая определяет шаблон, согласно которому будет происходить форматирование, args - это список переменных, для печати по заданному шаблону. Простой пример: System. out. format ("The value of " + "the float variable is " + "%f, while the value of the " + "integer variable is %d, " + "and the string is %s" , floatVar, intVar, stringVar) ; Строка format содержит обычный текст и специальные форматирующие символы. Эти символы начинаются со знака процента (%) и заканчиваются конвертером - символом, который определяет тип переменной для форматирования. Пример: int i = 461012 ; System. out. format ("The value of i is: %d%n" , i) ; Спецификатор %d определяет одну десятичную целую переменную. %n - переход на новую линию. Данный пример выведет: The value of i is: 461012 Пример Следующая таблица содержит некоторые флаги, которые используются в программе ниже.
Примеры использования этих конвертеров вы можете увидеть далее. Эта программа показывает различные варианты использования метода format. Вывод показан в комментариях.
Класс DecimalFormat
Вы можете использовать класс DecimalFormat для контроля вывода нулей в десятичных числах. Пример:
Данная программа выведет:
123456.789
###,
###.
### 123
,
456.789
123456.789
###.
## 123456.79
123.78
000000.000
000123.780
12345.67
$###,
###.
### $12
,
345.67
На этом всё!
Ссылка на перво
28.05.16. Данный материал посвящен системе ввода - вывода в Java. Система ввода-вывода (input/output, или I/O) информации, реализованные в составе стандартного пакета Java.io. Поддержка ввода-вывода реализован ядром библиотек программного интерфейса (API), а не ключевыми словами языка. Классы библиотек ввода – вывода Java разделены на две части – одни осуществляют ввод, другие вывод. Тем не менее, Java обеспечивает мощную и гибкую поддержку ввода – вывода, когда это касается файлов и сетей.
Потоки
Ввод – вывод в Java осуществляется с помощью так называемых потоков в Java (stream), которая либо порождает, либо принимает информацию. Осуществление ввода – вывода с помощью потоков имеет свои плюсы, потому что поток скрывает все детали низкоуровневых процессов, происходящих с данными непосредственно в устройствах ввода - вывода. Все потоки ведут себя на одинаково, даже несмотря на то, что реальные физические устройства, к которым они подключена, отличаются друг от друга. Таким образом, одни и те же классы и методы ввода – вывода применимы к устройствам разного типа. Это означает, что абстракция входного потока может охватить разные типы ввода: из дискового файла, клавиатуры или сетевого сокета. Аналогично выходной поток может ссылаться на консоль, дисковый файл или сетевое подключение. Потоки – это ясный способ обращения с вводом – выводом без необходимости для вашего кода разбираться с разницей, например между клавиатурой и сетью. Java реализует потоки внутри иерархии классов, определенных в пакете java.io. Java определяет два типа потоков: байтовые и символьные. Байтовые потоки предоставляют удобные средства для управления вводом и выводом байтов. Байтовые потоки используются, например, при чтении и записи бинарных данных. Обычный консольный ввод- вывод идет через байтовые потоки. Символьные потоки предлагают удобные возможности управления вводом и выводом символом. Они используют кодировку Unicode и, таким образом, могут быть интернационализированы. Кроме того, в некоторых случаях символьные потоки более эффективны, чем байтовые.
Классы байтовых потоков
Основные абстрактные классы, от которых наследуют все классы байтового ввода – вывода, - InputStream и OutputStream . Каждый из этих абстрактных классов имеет несколько реальных подклассов, которые управляют различиями между различными устройствами, такими как дисковые файлы, сетевые подключения и даже буферы памяти. Абстрактные классы InputStream и OutputStream переопределяют несколько ключевых методов, которые реализует другие потоковые классы. Два наиболее важных – это read() и write() , которые, соответственно, читают и пишут байты данных. Оба метода обновлены как абстрактные внутри InputStream OutputStream . В классы – наследниках они переопределяются. Классы байтовых потоков перечислены ниже.Классы байтовых потоков
BufferedInputStream - Буферизированный входной поток
BufferedOutpudStream - Буферизированный выходной поток.
ByteArrayInputStream Входной поток, читающий из массива байт.
ByteAOutputInputStream - Выходной поток, записывающий из массива байт
DataInputStream - Входной поток, записывающий методы для чтения стандартных типов данных Java
DataOutputStream - Выходной поток, включающий методы для записи стандартных типов Java.
FileInputStream - Выходной поток, читающий из файла
FileOutputStream - Входной поток, записывающий в файл.
FilterInputStream - Реализация InputStream
FilterOutputStream - Реализация OutputStream
InputStream - Абстрактный класс, описывающий поток ввода.
OutputStream - Абстрактный класс, описывающий поток вывода.
ObjectInputStream - Входной поток для объектов.
ObjectOutputStream - Выходной поток для объектов.
PipedInputStream - Входной канал (например, межпрограммный).
PipedOutpudStream - Выходной канал.
PrintStream - Выходной поток, включающий print() и println().
PushbackInputStream - Входной поток, поддерживающий однобайтовый возврат.
RandomAccessFile - Поддерживающий файловый ввод – вывод с произвольным доступом.
SequenceInputeStream - Входной поток, представляющий собой комбинацию двух и более входных потоков, которые читаются совместно – один после другого.
Классы символьных потоков
Основными абстрактными классами символьного потока являются классы Reader и Writer. Эти абстрактные классы управляют потоками символов Unicode. В Java предусмотрено несколько конкретных подклассов для каждого из них. Абстрактные классы Reader и Writer определяют несколько ключевых методов, которые реализуют другие потоковые классы. Два наиболее важных – это read () и write() , которые, соответственно читают и пишут символьные данные. Эти методы переопределяются в потоковых классах – наследниках. Классы символьных потоков перечислены ниже.Классы символьных потоков BufferedReader - Буферизованный входной символьный поток. BufferedWriter - Буферизованный выходной символьный поток. CharArrayReader - Входной поток, который читает из символьного массива. CharArrayWriter - Выходной поток, который читает из символьного массива. FilterWriter - Фильтр Писатель. FilterReader - Фильтр читатель. FileWriter - Выходной поток, пишущий в файл FileReader - Входной поток, пишущий в файл InputStreamRader - Входной поток, транслирующий байты в символы. LineNumberReader - Входной поток, подсчитывающий строки. OutputStreamWriter - Выходной поток, транслирующий байты в символы. PipedReader - Входной канал. PipedWriter - Выходной канал PrintWriter - Выходной поток, включающий print() и println(). PushbackReader - Входной поток, позволяющий возвращать символы обратно в поток. Reader - Абстрактный класс, описывающий символьный ввод. StringReader - Входной поток, читающий из строки. StringWriter - Входной поток, пишущий в строку. Writer - Абстрактный класс, описывающий символьный вывод
Чтение консольного ввода
В Java 1.0 единственным способом выполнения консольного ввода было использование байтового потока, и существует больщой объем старого кода, в котором применяется этот подход. Сегодня применение байтового потока для чтения консольного ввода попрежнему технически возможно, но поступать так не рекомендуется. Предпочтительный метод чтения консольного ввода – это использовать символ – орентированный поток, что значительно упрощает возможности интернационализации и поддержки разрабатываемых программ. В Java консольный ввод выполныется чтением System.in . Чтобы получить символьный поток, присоединенный к консоли, вы должны поместить System.in в оболочку объекта BufferedReader . BufferedReader поддерживает буфферизованный входной поток. Наиболее часто импользуемый его конструктор выглядит так:BufferedRader(Reader inputReader) Приведенной выше примере inputReader – это поток, который связывается с создаваемым экземпляром BufferedRader. Rader – абстрактный класс. Одним из его конскретных наследников является InputStreamReader , который преобразует байты в символы. Для получения объекта InputStreamRaeder , который присоединен к System.in можно применить следующую строку кода:
InputStreamReader()
Поскольку System.in ссылается на объект типа InputStream , он должен быть использован как параметр inputStream . Собрав все вместе, получим следующую строку кода, которая создает BufferedReader , соединенный с клавиатурой:
BufferaedReader br = new BufferedReader(new InputStreamReader(System.in));
После выполнения этого оператора br представляет собой основанный на символах поток, подключенный к консоли через System.in .
Чтение символов
Для чтения символов из BufferedReader применяется read() . Ниже показана версия read() , которая будет использоваться:Int read() throws Ioexception
Каждый раз, когда вызывается метод read() , он читает символ из входного потока и возвращает его как целое значение. При достижении конца потока везвращается -1. Как видите, метод может возбудить исключение IOException. В следующей программе демонстрируется применение read() , читая символы с консоли до тех пор, пока не пользователь не ведет "q”. Обратите внимание, что любые исключения ввода - вывода, которые могут быть сгенирированы, просто передаются в main() . Такой подход распространен при чтении с консоли, но при жеании вы можете обработать ошибки такого рода самостоятельно.
//Использование BufferedReader для чтения символов с консоли.
//Import java.io.*;
//Class BRRead{
//Public static void main(Straing args) throws IOException
//{
//char c;
//
//System.out.println("Вводите символы, ’q’ – для вывода.”);
//// читать символы
//do{
//c = (char) br.read();
//System.out.println(c);
//}while(c!= ‘q’);
//}
//}
Ниже показан пример запуска этой программы:
Вводите символы, ‘q’ – для вывода.
123abcq
1
2
3
A
B
C
Q
Этот вывод может выглядеть немного не так, как вы ожидали, потому что
System.in Является строчно – буферизованными по умолчанию. Это значит, что никакого ввода действительности программе предается до тех пор, пока будет нажата клавиша (ENTER). Как можно предположить, это делает
read() лишь отчасти применимым для интерактивного консольного.
Чтение строк
Чтобы прочесть строку с клавиатуры, используйте версию метода readLine() , который является членом класса BufferedReader . Его общая форма такова:String readLine() throws IOException
Как видите, он возвращает объект String . Следующая программа демонстрирует BuferedReader и метод readLine() . Программа читает и отображает строки текста до тех пор, пока вы не введете слово «стоп»:
Import java.io.*;
Class BRReadLines {
{
//Создатель BufferedReader с использованием System.in
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str;
System.out.println("Введите «стоп» для завершения.”);
do {
str = br.readLine();
System.out.println(str);
} while(!str.equals("стоп”));
}
}
В следующем примере создается крошечный тестовый редактор. В коде создается массив объектов String и затем читаются строки текста с сохранением каждой строки в виде элемента массива. Чтение произвидится до 100 строк или до того, как будет введено слово «стоп». Для чтения с консоли используется BuffeReader .
//Крошечный редактор.
import java.io.*;
class TinyEdit {
public static void main(String args) throws IOException
{
//Создатель BufferedReader, используя System.in
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = new String;
System.out.println("Вводите строки текста.”);
System.out.println("Введите ‘стоп’ для завершения.”);
for (int i = 0; i < 100; i++) {
str[i] = br.readLine();
if(str[i].equels("стоп”)) break;
}
System.out.println("\nВот ваш файл:”);
//отобразить строки
for(int i = 0; i<100; i++) {
if(str[i].equals("стоп”)) break;
System.out.println(str[i]);
}
}
}
Ниже показан результат запуска этой программы:
Вводите строки текста.
Введите ‘стоп’ для завершения.
Это строка один.
Это строка два.
стоп
Вот ваш файл:
Это строка один.
Это строка два.
Java делает работу со строками простой.
Просто создайте объект String.
Запись консольного вывода
Консольный вывод проще всего осуществлять с помощью методов print() и println. Эти методы определены в классе PrintSteam (котрый является типом объекта System.out ). Даже несмотря на то, что System.out – байтовый поток, применение его для вывода в простых программах вполне оправдано. Тем не менее, в следующем разделе описана символ – ориентированная альтернатива. Поскольку PrintStream – выходной поток, унаследованный от OutputStream , он также реализует низкоуревневый метод write() . То есть write() может применяться для записи на консоль. Простейшая форма write() , определенного в PrintStream , показана ниже:void write(int byteval)
Этот метод пишет в поток байт, переданных в byteval. Хотя параметр byteval объявлен как целочисленный, записываются только 8 его младших бит. Вот короткий пример, использующий write() для вывода буквы «А» с последующим преводом строки на экран:
//Демонстрация System.out.write().
class WriteDemo {
int b;
b = ‘A’;
System.out.write(b);
System.out.write(‘\n’);
}
}
Вам не часто придется использовать write() для вывода на консоль (хотя в некоторых ситуациах это и удобно), поскольку значительно проще применять для этого print() и println() .
Класс PrintWriter
Хотя применение System.out для вывода на консоль допустимо, он рекомендуется в основном для целей отладки программ. PrintWriter определяет несколько конструкторов. Один из тех, которые мы будем использовать, показан ниже:PrintWriter(OutputStream outputStream, boolean flushOnNewline)
Выше приведенном примере outputStream –является объектом типа OutputStream , а flushOnNewline управляет тем, будет ли Java сбрасывать буфер в выходной поток каждый раз при вызове метода println() . Если flushOnNewline равно true, то происходит автоматический сброс буфера, если же false, то автоматический не делается. PrintWriter поддерживает методы print() и println() для всех типов, включая object . То есть вы можете использовать эти методы таким же способом, как они применяются в System.out. Если аргумент не простого типа, то PrintWriter вызывает метод toString и затем печатает результат. Чтобы писать на консоль с помощью PrintWriter , специфицируйте System.out в качестве выходного потока и сбрасываете поток после каждого символа новой строки.
Например
Приведенной выше примере строка кода создает PrintWriter , который подключен к консольному выводу. Показанное ниже приложение демонстрирует применение PrintWriter для управления консольным выводом:
//Демонстрация PrintWriter
import java.io.*;
public class PrintWriterDemo {
public static void main(String args) {
PrintWriter pw = new PrintWriter(System.out, true);
Pw.println("Это строка”);
Int i = -7;
Pw.println(i);
Double d = 4.5e – 7;
Pw.println(d);
}
}
Вывод этой программы будет выглядеть следующим оразом:
Это строка
- 7
4.5Е – 7
Помните, что нет ничего неправильного в применении System.out для простого текстового вывода на консоль. Однако PrintWriter обеспечит возможность простой интернационализации для реальных программ.
Чтение и запись файлов
Java предоставляет множество классов и методов, которые позволяют вам читать и записывать файлы. В Java все файлы байт – ориентированы, и Java предоставляет методы для чтения и записи байтов в файл. Однако Java позволяет также поместить байт ориентированные файловые потоки в оболочки символ – ориентированных объектов. Java предоставляет множество классов и методов, которые позволяет вам читать и записывать файлы. В Java все файлы байт – ориентированы, и Java предоставляет методы для чтения и записи байтов в файл. Однако Java позволяет также поместить байт – ориентированные файловые потоки в оболочки символ – ориентированных объектов. Для из наиболее часто используемых потоков класса – это FileInputStream и FileOutputStream , которые создают байтовые потоки, связанные с файлами. Чтобы открыть файл, вы просто создаете объект одного из этих классов, указав имя файла в качестве аргумента конструктора. Хотя оба класса имеют и дополнительные переопределенные конструкторы, мы будем использовать только следующие из них:FileInputStream(String fileName) throws FileNotFoundEcxeption
FileOutputStream(String fileName) throws FileNotFoundEcxeption
Здесь filename – имя файла, которые вы хотите открыть. Когда вы создаете входной поток, то если файл не существовал, возбуждается исключение FileNotFountException. Для выходной поток, если файл не может быть создан, также возбуждается исключение FileNotFountException. Когда выходной файл открыть, любой ранее существовавший файл с тем же именем уничтожается. Когда вы завершаете работу с файлом, вы должны закрыть его вызовом метода close(). Этот метод определен и в FileInputStream и в FileOutputStream , как показано ниже:
void close() throws IOException
Чтобы читать файл, вы можете применять версию метода read() , которые определен в FileInputStream . Та, что мы будем использовать, выглядит так:
Int read() throws IOException
Всякий раз, когда вызывается этот метод, он читает единственный байт из файла и возвращает его как целое. Read() возвращает – 1, когда достигнуть конец файла. Метод может возбуждать исключение IOException.
В следующей программе read() используется для ввода и отображения содержимого текстового файла, имя которого специфицировано в аргументе командной строки. Обратите внимание на блок try/catch , обрабатывающий две ошибки, которые могут возникнуть при работе программы – когда указанный когда файл не найден, либо когда пользователь забыл указать имя файла. Вы можете применять тот же подход всякий раз при использовании аргументов командной строки. Другие возможные исключения ввода – вывода просто передаются в main() , что вполне приемлемо для такого простого примера. Однако, работа с файлами. Часто вы пожелаете обработать самостоятельно все исключение ввода – вывода.
/* Отображает текстового файла.
Чтобы использовать эту программу, укажите
имя файла, который хотите посмотреть.
Например, чтобы посмотреть файл TEST.TXT,
Используйте слудующую командную строку:
Java ShowFile TEST.TXT
*/
Import java.io.*;
class ShowFile {
public static void main(String args)
throws IOException
{
int i;
FileInputStream fin;
try {
fin = new FileInputStream(args);
} catch(FileNotFountException e) {
System.out.println("Файл не найдена”);
return;
} catch(ArrayIndexOutOfBoundsException e) {
System.out.println("Использование: ShowFile Файл”);
return;
}
//читать символ до получения символа EOF (конец файла)
do {
i = fin.read(); vif(I ! = 1) System.out.print((char) i);
}while(i ! = -1);
fin.close();
}
}
Для записи в файл вы будете использовать метод write() , определенныый в FileOutputStream . Его простейшая форма выглядит так:
void write(int byteval) throws IOException
Это метод пишет в файл байт, переданный в bytevavl . Хотя byteval объявлен как целочисленный, в файл записываются только его младшие восемь бит. Если при записи произойдет ошибка, возбуждается исключение IOException . В следующем примере write() используется для копирования текстового файла:
/*Копирование текстового файла.
Для использования этой программы укажите
имена исходного и целевого файлов.
Например, чтобы скопировать файл FIRST.TXT в файл
SECOND.TXT, используйте следующую командную строку:
Java CopyFile FIRST.TXT SECOND.TXT
*/
import java.io.*;
class CopyFile {
public static void main(String args) throws IOExecption
{
int i;
class CopyFile {
public static void main(String args) throws IOException
{
int i;
FileInputStream fin;
FilePutputStream fount;
try {
//открыть входной файл
try {
fin = new FileInputStream(args );
System.out.println("Входной файл не найден”);
return;
}
//открыть выходной файл
try {
fout = new FileOutputStream(args );
}catch(FileNotFountException e) {
System.out.println("Ошибка открытия выходного файла”);
return;
}
}catch(ArrayIndexoutOfBoundsException e) {
System.out.println("Использование: CopyFile Исходный целевой”);
return;
}
//Копировать файт
try{
do{
i = fin.read();
if(i ! = -1) fount.write(i);
}while(IOException e) {
System.out.println("Ошибка файла”);
}
fin.close();
fin.close();
}
}
Обратите внимание на способ обработка потенциальных ошибки ввода – вывда в этой программе. В отличие от некоторых других языков программирования, включая С и С++, которые используют коды ошибок для обнаружения файловых ошибок, Java применяет свой механизм исключений. Это не только делает управление файлами понятнее, но также позволяет Java просто отличать условие достижения конца файла от файловых ошибок во время ввода. В С/С++ многие функции ввода возвращают одно и то же значение, когда происходит ошибка и когда достигается конец файла. (То есть в С/С++ условие EOF часто отображается на то же значение, что и ошибка ввода.) Обычно это означает, что программист обязан включать дополнительные операторы для определения того, какое событие на самом деле произошло. В Java ошибки передаются вашей программе в виде исключений, а не через значение, возвращаемое read() . То есть, когда read() возвращает -1, это значит только одно: достигнут конец файла.
Есть много особенностей, про которые желательно знать, программируя на Java, даже если Вы начинающий программист. Под катом я расскажу как вывести кириллические символы в консоль Windows и наглядно это продемонстрирую.
Начнем с простого.
Базовые типы
Их в Java 8:
- boolean;
- byte, char, short, int, long;
- float, double.
Char
- это символьный тип данных. Переменная такого типа занимает 2 байта памяти, так как хранится в кодировке unicode.
С переменными этого типа можно производить только операции присваивания, но зато различными способами. Самый простой из них выглядит так:
c = "b";
Символ можно представить также в виде его кода, записанного в восьмеричной системе счисления:
c = "\077";
Где 077 – это обязательно трехзначное число, не большее чем 377 (=255 в десятичной системе счисления).
Или же в шестнадцатеричной системе счисления следующим образом:
c = "\u12a4";
Кроме того, существуют специальные символы, такие как знак абзаца, разрыв страницы и др. Знак абзаца запишется, например, так:
c = "\n";
Не нужно перечислять их здесь. При необходимости всегда можно заглянуть в справочник.
Теперь внимание. Кодировкой по-умолчанию среды программирования Java является Latin-1. Однако, при выводе в поток System.out символы преобразуются в кодировку по умолчанию для операционной системы. Так для русскоязычной локализации кодировкой по-умолчанию является Windows-1251, для linux таковой будет UTF-8. Однако по задумке Microsoft решили для консоли Windows использовать кодировку Cp866.
Соответственно вывод: для корректного отображения кириллических символов в консоли нужно выводить символы в кодировке Cp866!
Это можно сделать следующим способом:
Import java.io.PrintStream;
import java.io.UnsupportedEncodingException;
Public class Hello {
public static void main(String args) throws UnsupportedEncodingException { /*Может возникнуть исключение типа UnsupportedEncodingException*/
String x = "Привет, мир!!!"; //Это строка, которую мы будем выводить на экран
PrintStream printStream = new PrintStream(System.out, true, "cp866");
/*Создаем новый поток вывода, который будет автоматически преобразоввывать символы в кодировку Cp866*/
printStream.println(x);
}
}
Сохраним полученный код в файл Hello.java. Далее создадим Hello.bat файл следующего содержания:
javac Hello.java
java -cp . Hello
pause
И поместим его в одну папку с файлом Hello.java. Должно получиться примерно так:
Далее запускаем полученный Hello.bat файл и вуаля, у нас образовался файл Hello.class в той же директории а на экран вывелось сообщение «Привет, мир!!!» в кодировке Cp866.
Для того, чтобы узнать, какая кодировка в данный момент используется в консоли нужно набрать там «chcp». А для того, чтобы поменять кодировку консоли, нужно набрать «chcp <номер кодовой таблицы>» например «chcp 1251». Продемонстрирую использование этой команды:
Замечание: если у Вас не находит команду javac, то заходим (для Windows 7) «Мой компьютер» - «Свойства» - «Дополнительные параметры системы» - «Переменные среды», находим «Системные переменные» и в переменную Path добавляем строку, куда установлена JDK, например «C:\Program Files\Java\jdk1.7.0_25\bin» - по умолчанию.
Библиотека Swing включает богатый выбор стандартных диалоговых окон, существенно упрощающих и ускоряющих вывод простой информации типа сообщений о работе программы, ошибках и нестандартных ситуациях. Для вывода в графический интерфейс приложения разнообразной информации и выбора простых данных предназначен класс JOptionPane , работа с которым связана с вызовом одного из многочисленных статических методов, создающих и выводящих на экран модальное диалоговое окно стандартного вида. В диалоговых окнах JOptionPane можно выводить самую разнообразную информацию и, при необходимости, размещать в них дополнительные компоненты.
JOptionPane унаследован от базового класса JComponent библиотеки Swing, так что можно работать с ним напрямую, т.е. создавать экземпляры класса JOptionPane и настраивать их свойства. Использование стандартных диалоговых окон существенно упрощает разработку приложения и позволяет ускорить процесс освоения пользователем интерфейса.
Все стандартные диалоговые окна Swing имеют собственные UI-представители, отвечающие за интерфейс окна в используемом приложении. Это особенно важно для внешних видов окон, имитирующих известные платформы, пользователи которых не должны ощущать значительной разницы при переходе от «родных» приложений к Java-приложениям.
Класс JOptionPane
Интерфейс экземпляра класса JOptionPane имеет структуру, представленную на следующем рисунке. Иконка в интерфейсе может отсутствовать.
Основные диалоговые методы JOptionPane
Конструкторы окна сообщений showMessageDialog
// Простое диалоговое окно с заголовком «Message» public static void showMessageDialog(Component parent, Object message) throws HeadlessException // Диалоговое окно с заголовком и типом сообщения public static void showMessageDialog(Component parent, Object message, String title, int messageType) throws HeadlessException // Диалоговое окно с заголовком, типом сообщения и иконкой public static void showMessageDialog(Component parent, Object message, String title, int messageType, Icon icon) throws HeadlessException
Конструкторы окна подтверждения showConfirmDialog
// Простое диалоговое окно подтверждения с кнопками Yes, No, Cancel и // с заголовком «Select an Option» public static void showConfirmDialog(Component parent, Object message) throws HeadlessException // Окно подтверждения с заголовком и кнопками, определенными // опцией optionType public static void showConfirmDialog(Component parent, Object message, String title, int optionType) throws HeadlessException // Окно подтверждения с заголовком, кнопками, определенными // опцией optionType, и иконкой public static void showConfirmDialog(Component parent, Object message, String title, int optionType, Icon icon) throws HeadlessException
Конструкторы окна выбора showInputDialog
// Диалоговое окно с полем ввода public static void showInputDialog(Component parent, Object message) throws HeadlessException // Диалоговое окно с полем ввода, инициализируемое initialSelectionValue public static void showInputDialog(Component parent, Object message, Object initialSelectionValue) throws HeadlessException // Диалоговое окно с полем выбора из списка selectionValues public static void showInputDialog(Component parent, Object message, String title, int messageType, Icon icon, Object selectionValues, Object initialSelectionValue) throws HeadlessException
parent - родительское окно.
message - отображаемый в окне текст сообщения. В большинстве случаев это строка, но может быть использован массив строк String, компонент Component, иконка Icon, представленная меткой JLabel, объект Object, конвертируемый в строку методом toString().
title - заголовок окна.
messageType - тип диалогового окна:
- INFORMATION_MESSAGE - стандартное диалоговое окно для вывода информации со значком соответствующего вида;
- WARNING_MESSAGE - стандартное диалоговое окно для вывода предупреждающей информации со значком соответствующего вида;
- QUESTION_MESSAGE - стандартное диалоговое окно для вывода информации. Как правило, не используется для информационных сообщений;
- ERROR_MESSAGE - стандартное диалоговое окно для вывода информации об ошибке со значком соответствующего вида;
- PLAIN_MESSAGE - стандартное диалоговое окно для вывода информации без значка.
optionType - опция определения кнопок управления:
- DEFAULT_OPTION
- YES_NO_OPTION
- YES_NO_CANCEL_OPTION
- OK_CANCEL_OPTION
selectionValues - список возможных значений. В диалоговом окне InputDialog список будет представлен в компоненте JComboBox или JList. Если selectionValues = null, то в окне будет определено поле JTextField, в которое пользователь может ввести любое значение.
initialSelectionValue - инициализируемое значение.
icon - отображаемая в диалоговом окне иконка.
Локализация кнопок JOptionPane
Кнопки управления, как правило, имеют заголовки «Yes», «No», «Cancel». Для локализации кнопок диалогового компонента JOptionPane можно использовать UIManager следующим образом:
UIManager.put("OptionPane.yesButtonText" , "Да"); UIManager.put("OptionPane.noButtonText" , "Нет"); UIManager.put("OptionPane.cancelButtonText", "Отмена"); UIManager.put("OptionPane.okButtonText" , "Готово");
Пример использования JOptionPane
Пример JOptionPaneTest.java включает использование всех типов диалоговых окон JOptionPane . В интерфейсе окна, представленном на следующем скриншоте, размещаются кнопки, по нажатию на которые формируются соответствующие диалоговые окна JOptionPane .
Листинг примера JOptionPane
// Пример использования диалоговых окон JOptionPane import javax.swing.*; import java.awt.event.*; public class JOptionPaneTest extends JFrame { private JPanel contents = null; private JButton btnMessage1 = null; private JButton btnMessage2 = null; private JButton btnMessage3 = null; private JButton btnConfirm1 = null; private JButton btnConfirm2 = null; private JButton btnConfirm3 = null; private JButton btnInput1 = null; private JButton btnInput2 = null; private JButton btnInput3 = null; private ImageIcon icon = null; private final String TITLE_message = "Окно сообщения"; private final String TITLE_confirm = "Окно подтверждения"; private String drink = {"Сок", "Минералка", "Лимонад" , "Пиво"}; public JOptionPaneTest() { super("Пример использования JOptionPane"); setDefaultCloseOperation(EXIT_ON_CLOSE); // Локализация кнопок UIManager.put("OptionPane.yesButtonText" , "Да"); UIManager.put("OptionPane.noButtonText" , "Нет"); UIManager.put("OptionPane.cancelButtonText", "Отмена"); contents = new JPanel(); // Иконка для отображения в окне сообщений icon = new ImageIcon("images/warning.png"); // Кнопка формирования окна по 2-м параметрам btnMessage1 = new JButton("MessageDialog 2"); // Кнопка формирования окна по 4-м параметрам btnMessage2 = new JButton("MessageDialog 4"); // Кнопка формирования окна по 5-и параметрам btnMessage3 = new JButton("MessageDialog 5"); // Кнопки вывода сообщений подтверждения btnConfirm1 = new JButton("ConfirmDialog 4+2"); btnConfirm2 = new JButton("ConfirmDialog 5"); btnConfirm3 = new JButton("ConfirmDialog 6"); btnInput1 = new JButton("InputDialog 2+3"); btnInput2 = new JButton("InputDialog 4"); btnInput3 = new JButton("InputDialog 7"); addMessageListeners(); addConfirmListeners(); addInputListeners (); // Размещение кнопок в интерфейсе contents.add(btnMessage1); contents.add(btnMessage2); contents.add(btnMessage3); contents.add(btnConfirm1); contents.add(btnConfirm2); contents.add(btnConfirm3); contents.add(btnInput1); contents.add(btnInput2); contents.add(btnInput3); setContentPane(contents); // Вывод окна на экран setSize(500, 140); setVisible(true); } }
В методах addMessageListeners() , addConfirmListeners() , addInputListeners() определяются слушатели, обрабатывающие нажатие соответствующих кнопок.
Окна вывода сообщений MessageDialog
Листинг процедуры создания слушателей, формирующие диалоговые окна вывода сообщений.
Private void addMessageListeners() { btnMessage1.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { JOptionPane.showMessageDialog(JOptionPaneTest.this, "
Текст
в виде разметки HTML"); } }); btnMessage2.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { JOptionPane.showMessageDialog(JOptionPaneTest.this, new String {"Сообщение в виде массива строк:", " - первая строка", " - вторая строка"}, TITLE_message, JOptionPane.ERROR_MESSAGE); } }); btnMessage3.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { // Включение в интерфейс иконки JOptionPane.showMessageDialog(JOptionPaneTest.this, "Использование изображения в окне сообщений", TITLE_message, JOptionPane.INFORMATION_MESSAGE, icon); } }); }1. Интерфейс окна вывода сообщений по нажатию на кнопку btnMessage1 . Конструктор получает 2 параметра: родитель и текст сообщения. В заголовок подставляется значение «Message». Текст сообщения имеет HTML разметку.
2. Интерфейс окна вывода сообщений по нажатию на кнопку btnMessage2 . Конструктор получает 4 параметра: родитель, текст сообщения в виде массива строк, строку заголовка окна и тип сообщения.
3. Интерфейс окна вывода сообщений по нажатию на кнопку btnMessage2 . Конструктор получает 5 параметров: родитель, текст сообщения, строку заголовка окна, тип сообщения и иконку.
Диалоговые окна подтверждений ConfirmDialog
Листинг процедуры создания слушателей, формирующие диалоговые окна подтверждений.
Private void addConfirmListeners() { btnConfirm1.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { // Окно подтверждения c 4-мя параметрами int result = JOptionPane.showConfirmDialog(JOptionPaneTest.this, "Вам это нужно?", TITLE_confirm, JOptionPane.YES_NO_CANCEL_OPTION); // Окна подтверждения c 2-мя параметрами if (result == JOptionPane.YES_OPTION) JOptionPane.showConfirmDialog(JOptionPaneTest.this, "Вы не отказываетесь?"); else if (result == JOptionPane.NO_OPTION) JOptionPane.showConfirmDialog(JOptionPaneTest.this, "Вы отказались?"); } }); btnConfirm2.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { JOptionPane.showConfirmDialog(JOptionPaneTest.this, "Вы не отказываетесь?", TITLE_confirm, JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE); }}); btnConfirm3.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { JOptionPane.showConfirmDialog(JOptionPaneTest.this, "Вам нравится значок?", TITLE_confirm, JOptionPane.YES_NO_OPTION, JOptionPane.ERROR_MESSAGE, icon); }}); }
1. Интерфейс окна подтверждения по нажатию на кнопку btnConfirm1 . Конструктор получает 4 параметра: родитель, текст сообщения, строка заголовка и опция кнопок управления
В зависимости от нажатой кнопки открываются следующее окно подтверждение (одно из окон на следующем скриншот), конструктор которого получает 2 параметра. Текст заголовка имеет значение по умолчанию «Select an Option».
2. Интерфейс окна подтверждения по нажатию на кнопку btnConfirm2 . Конструктор получает 5 параметров: родитель, текст сообщения, строка заголовка, опция кнопок управления и тип сообщения.
3. Интерфейс окна подтверждения по нажатию на кнопку btnConfirm3 . Конструктор получает 6 параметров: родитель, текст сообщения, строка заголовка, опция кнопок управления, тип сообщения и иконка.
Диалоговые окна выбора данных InputDialog
Листинг процедуры создания слушателей, формирующие диалоговые окна выбора
Private void addInputListeners() { btnInput1.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { // Диалоговое окно ввода данных: родитель, HTML сообщение String result = JOptionPane.showInputDialog(JOptionPaneTest.this, "
Добро пожаловать"); JOptionPane.showInputDialog(JOptionPaneTest.this, "Вы ответили", result); } }); btnInput2.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { // Диалоговое окно ввода данных: родитель, сообщение в виде // массива строк, тип диалогового окна (иконки) JOptionPane.showInputDialog(JOptionPaneTest.this, new String {"Неверно введен пароль!", "Повторите пароль:"}, "Авторизация", JOptionPane.WARNING_MESSAGE); } }); btnInput3.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { // Диалоговое окно ввода данных Object result = JOptionPane.showInputDialog(JOptionPaneTest.this, "Выберите любимый напиток:", "Выбор напитка", JOptionPane.QUESTION_MESSAGE, icon, drink, drink); // Диалоговое окно вывода сообщения JOptionPane.showMessageDialog(JOptionPaneTest.this, result); } }); }
1. Интерфейс окна ввода данных по нажатию на кнопку btnInput1 представлен на скриншоте слева. Конструктор получает 2 параметра: родитель и текст сообщения с разметкой HTML. После ввода значения и нажатия на одну из клавиш открывается окно, представленное на скриншоте справа.
2. На следующем скриншоте представлен интерфейс окна ввода данных, создаваемое конструктором, которому в качестве текста передается родитель, текстовое сообщение в виде массива строк, строка заголовка и тип диалогового окна (иконки).
3. Интерфейс окна ввода данных по нажатию на кнопку btnInput3 представлен на следующем скриншоте слева. Конструктор получает все возможные параметры: родитель, текстовое сообщение, строка заголовка, тип диалогового окна, иконка, массив строк и выделенное значение по умолчанию. В диалоговом окне возможные значения представлены в компоненте выпадающего списка. После выбора значения и нажатия на одну из клавиш открывается окно вывода сообщения, представленное на скриншоте справа.
Скачать примеры
Исходные коды примеров, рассмотренных на странице, можно (2.25 Кб).
Эта статья адресована в первую очередь начинающим
Java программистам.Обычно вывод данных на консоль трудностей не представляет с System.out.print или System.out.println, как правило, справляются все. Но когда же дело доходит до ввода данных возникают трудности.
Виной тому неудобная и сложная для восприятия реализация консольного ввода в Java. Но тем не менее его можно освоить если изучить его работу.
Последняя строится на основе двух классов: InputStream (System.in) и Scanner.
Ввод с использованием InputStream (System.in)
Java получает данные из консоли при помощи системного потока ввода (Isystem.in ) поэтому данный способ ввода может показаться очевидным. Но, к сожалению, он имеет один серьёзный недостаток.
Дело в том, что системный поток ввода получает только числовые коды символов, которые введены в окно консоли и больше ничего. Причём за один раз из него можно прочитать код только одного символа. Поэтому для того чтобы прочитать слово или строку необходимо использовать цикл.
Ниже приведён пример считывания введённой в консоли строки подобным образом.
Java
int inChar; String s = ""; try { inChar = System.in.read(); while (System.in.available() > 0) { s += (char) inChar; inChar = System.in.read(); } } catch (IOException e) { System.out.println("Ошибка"); }
int inChar ; String s = "" ; try { while (System . in . available () > 0 ) { s += (char ) inChar ; inChar = System . in . read () ; } catch (IOException e ) { System . out . println ("Ошибка" ) ; |
Пока в потоке ввода есть данные (метод available возвращает значение больше нуля), мы раз разом считываем код символа, затем преобразуем его в собственно сам символ и добавляем этот символ в конец строки.
На этом неудобства данного подхода не заканчиваются потому, что мы всегда получаем данные в строковом формате. Если же нам требуется ввести, допустим, целое число? Тогда нам придётся дополнить вышеприведённый пример приведением типов с соответствующей проверкой.
Поэтому для получения данных от пользователя в консольных приложениях системный поток ввода на прямую сейчас почти не используется. Вместо него предпочтительнее работать с классом Scanner.
Ввод с использованием Scanner
Класс Scanner позволяет избежать всех трудностей, связанных с использованием системного потока ввода и максимально упростить ввод данных от пользователей в консольных приложениях.
Стоит отметить, что чтением данных из консоли возможности класса Scanner не ограничиваются. Но, это уже тема для отдельной статьи.
Экземпляр класса Scanner создаётся при помощи конструктора, который принимает в качестве единственного параметра поток ввода. После этого можно сразу считывать готовые данные при помощи семейства методов с префиксом next.
Вот пример, который демонстрирует считывание введённой в консоли строки. В конструктор передаётся системный поток ввода.
Java
Scanner in = new Scanner(System.in); System.out.print("Введите строку: "); String str = in.nextLine();
Scanner in = new Scanner (System . in ) ; System . out . print ("Введите строку: " ) ; String str = in . nextLine () ; |
Если сравнить этот пример с приведённым ранее прямым считыванием строки из системного потока ввода, то преимущество класса Scanner очевидно. Ведь нам уже не требуется вручную считывать коды символов и формировать строку в цикле. Класс Scanner самостоятельно выполняет все рутинные низкоуровневые функции, предоставляя данные, которые уже готовы к использованию в программе.
Как уже говорилось выше, класс Scanner имеет целый ряд методов для считывания данных, но все они отличаются друг от друга только типами возвращаемых значений и соответствующими им названиями.
Так, помимо метода nextLine, существуют методы nextBoolean, nextByte, nextInt, nextDouble и другие.
Кроме того, имеется ряд методов с префиксом hasNext, которые позволяют определить тип считываемых данных. Например, hasNextLine, hasNextInt, hasNextBollean и т. д. Если в потоке ввода находятся данные соответствующего типа, эти методы возвращают true.
