Входной поток

Содержание
  1. Потоки ввода-вывода. Работа с файлами
  2. Класс InputStream
  3. Класс OutputStream
  4. Абстрактные классы Reader и Writer
  5. Потоки, программные каналы и перенаправления
  6. Краткий обзор
  7. Необходимые условия
  8. Подготовка к выполнению примеров
  9. Листинг 1. Создание файлов, необходимых для примеров этой статьи
  10. Листинг 2. Результаты создания необходимых файлов
  11. Перенаправление вывода
  12. Листинг 3. Перенаправление вывода
  13. Листинг 4. Перенаправление вывода с помощью опции noclobber
  14. Листинг 5. Перенаправление двух потоков в один файл
  15. Листинг 6. Игнорирование стандартного потока ошибок посредством использования /dev/null
  16. Листинг 14. Использование команды xargs и кавычек
  17. Листинг 15. Использование команды xargs и строк ввода
  18. Потоки ввода — вывода.Байтовые потоки — Java программирование
  19. Конструкторы класса FileInputStream:
  20. Конструкторы класса FileOutputStream:
  21. Пример 1. Использование FileInputStream и FileOutputStream
  22. Пример 2. Использование FileInputStream и FileOutputStream
  23. Java 8 потоки ввода/вывода
  24. Введение
  25. Потоки байт
  26. Диаграмма классов, показывающая иерархию основных дочерних классов для класса java.io.OutputStream
  27. java.io.InputStream
  28. java.io.OutputStream
  29. java.io.FileInputStream и java.io.FileOutputStream
  30. java.io.ByteArrayInputStream и java.io.ByteArrayOutputStream
  31. java.io.FilterInputStream и java.io.FilterOutputStream
  32. java.io.DataInputStream и java.io.DataOutputStream
  33. java.io.BufferedInputStream и java.io.BufferedOutputStream
  34. java.io.PipedInputStream и java.io.PipedOutputStream
  35. java.io.ObjectInputStream и java.io.ObjectOutputStream
  36. Потоки символов
  37. java.util.Scanner и java.io.PrintStream
  38. 8.2. Характеристики и свойства потоков вызовов. 8. Основы теории телетрафика. Сети связи и системы коммутации
  39. 8.2.1. Основные понятия случайного процесса в системе массового обслуживания
  40. 8.2.2. Характеристики и свойства потоков вызовов
  41. 8.2.3. Длительность обслуживания вызовов

Потоки ввода-вывода. Работа с файлами

Входной поток

Последнее обновление: 25.04.2018

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

Ключевым понятием здесь является понятие потока. Хотя понятие «поток» в программировании довольно перегружено и может обозначать множество различных концепций. В данном случае применительно к работе с файлами и вводом-выводом мы будем говорить о потоке (stream), как об абстракции, которая используется для чтения или записи информации (файлов, сокетов, текста консоли и т.д.).

Поток связан с реальным физическим устройством с помощью системы ввода-вывода Java. У нас может быть определен поток, который связан с файлом и через который мы можем вести чтение или запись файла.

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

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

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

В основе всех классов, управляющих потоками байтов, находятся два абстрактных класса: InputStream (представляющий потоки ввода) и OutputStream (представляющий потоки вывода)

Но поскольку работать с байтами не очень удобно, то для работы с потоками символов были добавлены абстрактные классы Reader (для чтения потоков символов) и Writer (для записи потоков символов).

Все остальные классы, работающие с потоками, являются наследниками этих абстрактных классов. Основные классы потоков:

Класс InputStream

Класс InputStream является базовым для всех классов, управляющих байтовыми потоками ввода. Рассмотрим его основные методы:

  • int available(): возвращает количество байтов, доступных для чтения в потоке
  • void close(): закрывает поток
  • int read(): возвращает целочисленное представление следующего байта в потоке. Когда в потоке не останется доступных для чтения байтов, данный метод возвратит число -1
  • int read(byte[] buffer): считывает байты из потока в массив buffer. После чтения возвращает число считанных байтов. Если ни одного байта не было считано, то возвращается число -1
  • int read(byte[] buffer, int offset, int length): считывает некоторое количество байтов, равное length, из потока в массив buffer. При этом считанные байты помещаются в массиве, начиная со смещения offset, то есть с элемента buffer[offset]. Метод возвращает число успешно прочитанных байтов.
  • long skip(long number): пропускает в потоке при чтении некоторое количество байт, которое равно number

Класс OutputStream

Класс OutputStream является базовым классом для всех классов, которые работают с бинарными потоками записи. Свою функциональность он реализует через следующие методы:

  • void close(): закрывает поток
  • void flush(): очищает буфер вывода, записывая все его содержимое
  • void write(int b): записывает в выходной поток один байт, который представлен целочисленным параметром b
  • void write(byte[] buffer): записывает в выходной поток массив байтов buffer.
  • void write(byte[] buffer, int offset, int length): записывает в выходной поток некоторое число байтов, равное length, из массива buffer, начиная со смещения offset, то есть с элемента buffer[offset].

Абстрактные классы Reader и Writer

Абстрактный класс Reader предоставляет функционал для чтения текстовой информации. Рассмотрим его основные методы:

  • absract void close(): закрывает поток ввода
  • int read(): возвращает целочисленное представление следующего символа в потоке. Если таких символов нет, и достигнут конец файла, то возвращается число -1
  • int read(char[] buffer): считывает в массив buffer из потока символы, количество которых равно длине массива buffer. Возвращает количество успешно считанных символов. При достижении конца файла возвращает -1
  • int read(CharBuffer buffer): считывает в объект CharBuffer из потока символы. Возвращает количество успешно считанных символов. При достижении конца файла возвращает -1
  • absract int read(char[] buffer, int offset, int count): считывает в массив buffer, начиная со смещения offset, из потока символы, количество которых равно count
  • long skip(long count): пропускает количество символов, равное count. Возвращает число успешно пропущенных символов

Класс Writer определяет функционал для всех символьных потоков вывода. Его основные методы:

  • Writer append(char c): добавляет в конец выходного потока символ c. Возвращает объект Writer
  • Writer append(CharSequence chars): добавляет в конец выходного потока набор символов chars. Возвращает объект Writer
  • abstract void close(): закрывает поток
  • abstract void flush(): очищает буферы потока
  • void write(int c): записывает в поток один символ, который имеет целочисленное представление
  • void write(char[] buffer): записывает в поток массив символов
  • absract void write(char[] buffer, int off, int len) : записывает в поток только несколько символов из массива buffer. Причем количество символов равно len, а отбор символов из массива начинается с индекса off
  • void write(String str): записывает в поток строку
  • void write(String str, int off, int len): записывает в поток из строки некоторое количество символов, которое равно len, причем отбор символов из строки начинается с индекса off

Функционал, описанный классами Reader и Writer, наследуется непосредственно классами символьных потоков, в частности классами FileReader и FileWriter соответственно, предназначенными для работы с текстовыми файлами.

Теперь рассмотрим конкретные классы потоков.

Источник: https://metanit.com/java/tutorial/6.1.php

Потоки, программные каналы и перенаправления

Входной поток

Изучаем Linux, 101

Изучение основ работы с конвейерами Linux

Ян Шилдс
29.11.2011 Следите за выходом новых статей этой серии.

Следите за выходом новых статей этой серии.

Краткий обзор

Из этой статьи вы узнаете об основных приемах перенаправления стандартных потоков ввода/вывода в Linux. Вы научитесь:

  • Перенаправлять стандартные потоки ввода/вывода: стандартный поток ввода, стандартный поток вывода и стандартный поток ошибок.
  • Направлять вывод одной команды на вход другой команды.
  • Отправлять вывод одновременно на стандартное устройство вывода (stdout) и в файл.
  • Использовать вывод команды в качестве аргументов другой команды.

Эта статья поможет вам подготовиться к сдаче экзамена LPI 101 на администратора начального уровня (LPIC-1) и содержит материалы цели 103.4 темы 103. Цель имеет вес 4.

Необходимые условия

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

Подготовка к выполнению примеров

Ян – один из наших наиболее популярных и плодовитых авторов. Ознакомьтесь со всеми статьями Яна (EN), опубликованными на сайте developerWorks. Вы можете найти контактные данные в профиле Яна и связаться с ним, а также с другими авторами и участниками ресурса My developerWorks.

Для выполнения примеров в этой статье мы будем использовать некоторые файлы, созданные ранее в статье «Изучаем Linux, 101: текстовые потоки и фильтры».

Если вы не читали эту статью или не сохранили эти файлы, не расстраивайтесь! Давайте начнем с создания новой директории lpi103-4 и всех необходимых файлов. Для этого откройте текстовое окно и перейдите в вашу домашнюю директорию.

Скопируйте содержимое листинга 1 в текстовое окно; в результате выполнения команд в вашей домашней директории будет создана поддиректория lpi103-4 и все необходимые файлы в ней, которые мы и будем использовать в наших примерах.

Листинг 1. Создание файлов, необходимых для примеров этой статьи

mkdir -p lpi103-4 && cd lpi103-4 && {echo -e «1 apple2 pear3 banana» > text1echo -e «9\tplum3\tbanana10\tapple» > text2echo «This is a sentence. » !#:* !#:1->text3split -l 2 text1split -b 17 text2 y; }

Ваше окно должно выглядеть так, как показано в листинге 2, а вашей текущей рабочей директорией должна стать вновь созданная директория lpi103-4.

Листинг 2. Результаты создания необходимых файлов

[ian@echidna ~]$ mkdir -p lpi103-4 && cd lpi103-4 && {> echo -e «1 apple2 pear3 banana» > text1> echo -e «9\tplum3\tbanana10\tapple» > text2> echo «This is a sentence. » !#:* !#:1->text3echo «This is a sentence. » «This is a sentence. » «This is a sentence.

«>text3> split -l 2 text1> split -b 17 text2 y; }[ian@echidna lpi103-4]$

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

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

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

  1. stdout – стандартный поток вывода, отображает вывод команд и имеет дескриптор 1.
  2. stderr – стандартный поток ошибок, отображает ошибки команд и имеет дескриптор 2.
  3. stdin – стандартный поток ввода, передает входные данные командам и имеет дескриптор 0.

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

Если вы уже прочитали руководство «Изучаем Linux, 101: текстовые потоки и фильтры», то часть материала из этой статьи окажется вам знакомой.

Перенаправление вывода

Существует два способа перенаправления вывода в файл:

n>перенаправляет вывод из файлового дескриптора n в файл. Вы должны иметь права на запись в файл. Если файла не существует, то он будет создан. Если файл существует, то все его содержимое, как правило, уничтожается без каких-либо предупреждений.n>>также перенаправляет вывод из файлового дескриптора n в файл. Вы также должны иметь права на запись в файл. Если файла не существует, то он будет создан. Если файл существует, то вывод добавляется к его содержимому.

Символ n в операторах n> или n>> является файловым дескриптором. Если он не указан, то предполагается, что используется стандартное устройство вывода.

В листинге 3 продемонстрирована операция перенаправления для разделения стандартного потока вывода и стандартного потока ошибок команды ls с использованием файлов, которые были созданы ранее в директории lpi103-4.

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

Листинг 3. Перенаправление вывода

[ian@echidna lpi103-4]$ ls x* z*ls: cannot access z*: No such file or directoryxaa xab[ian@echidna lpi103-4]$ ls x* z* >stdout.txt 2>stderr.txt[ian@echidna lpi103-4]$ ls w* y*ls: cannot access w*: No such file or directoryyaa yab[ian@echidna lpi103-4]$ ls w* y* >>stdout.txt 2>>stderr.txt[ian@echidna lpi103-4]$ cat stdout.txtxaaxabyaayab[ian@echidna lpi103-4]$ cat stderr.

txtls: cannot access z*: No such file or directoryls: cannot access w*: No such file or directory

Мы уже говорили, что перенаправление вывода с помощью оператора n> обычно приводит к перезаписи существующих файлов. Вы можете управлять этим свойством при помощи опции noclobber встроенной команды set.

Если эта опция определена, то вы можете переопределить ее с помощью оператора n>|, как показано в листинге 4.

Листинг 4. Перенаправление вывода с помощью опции noclobber

[ian@echidna lpi103-4]$ set -o noclobber[ian@echidna lpi103-4]$ ls x* z* >stdout.txt 2>stderr.txt-bash: stdout.txt: cannot overwrite existing file[ian@echidna lpi103-4]$ ls x* z* >|stdout.txt 2>|stderr.txt[ian@echidna lpi103-4]$ cat stdout.txtxaaxab[ian@echidna lpi103-4]$ cat stderr.

txtls: cannot access z*: No such file or directory[ian@echidna lpi103-4]$ set +o noclobber #restore original noclobber setting

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

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

Альтернативный вариант – перенаправить файловый дескриптор n и затем файловый дескриптор m в одно и то же место с помощью конструкции m>&n или m>>&n. В этом случае важен порядок перенаправления потоков. Например, команда
command 2>&1 >output.txt это не то же самое, что команда

command >output.txt 2>&1

В первом случае поток ошибок stderr перенаправляется в текущее месторасположение потока stdout, а затем поток stdout перенаправляется в файл output.txt; однако второе перенаправление затрагивает только stdout, но не stderr. Во втором случае поток stderr перенаправляется в текущее месторасположение потока stdout, то есть, в файл output.txt. Эти перенаправления проиллюстрированы в листинге 5. Обратите внимание на последнюю команду, в которой стандартный вывод был перенаправлен после стандартного потока ошибок, и, как следствие, поток ошибок продолжает выводиться в окно терминала.

Листинг 5. Перенаправление двух потоков в один файл

[ian@echidna lpi103-4]$ ls x* z* &>output.txt[ian@echidna lpi103-4]$ cat output.txtls: cannot access z*: No such file or directoryxaaxab[ian@echidna lpi103-4]$ ls x* z* >output.txt 2>&1[ian@echidna lpi103-4]$ cat output.

txtls: cannot access z*: No such file or directoryxaaxab[ian@echidna lpi103-4]$ ls x* z* 2>&1 >output.txt # stderr does not go to output.txtls: cannot access z*: No such file or directory[ian@echidna lpi103-4]$ cat output.

txtxaaxab

В других ситуациях вам может потребоваться полностью проигнорировать стандартный вывод или стандартный поток ошибок. Для этого следует перенаправить соответствующий поток в пустой файл /dev/null.

В листинге 6 показано, как проигнорировать поток ошибок команды ls и как с помощью команды cat убедиться в том, что файл /dev/null на самом деле пуст.

Листинг 6. Игнорирование стандартного потока ошибок посредством использования /dev/null

[ian@echidna lpi103-4]$ ls x* z* 2>/dev/nullxaa xab[ian@echidna lpi103-4]$ cat /dev/null

Так же, как мы можем перенаправить потоки stdout и stderr, мы можем перенаправить поток stdin из файла с помощью оператора pear 3 banana[ian@echidna lpi103-4]$ xargs -n 1 1args > appleargs > 2args > pearargs > 3args > banana

Если входные данные содержат пробелы, но при этом они заключены в одиночные или двойные кавычки (либо пробелы представлены в виде escape-последовательностей с использованием обратной косой черты), то xargs не будет разбивать их на отдельные части. Это показано в листинге 14.

Листинг 14. Использование команды xargs и кавычек

[ian@echidna lpi103-4]$ echo '»4 plum»' | cat text1 -1 apple2 pear3 banana»4 plum»[ian@echidna lpi103-4]$ echo '»4 plum»' | cat text1 — | xargs -n 11apple2pear3banana4 plum

До сих пор все аргументы добавлялись в конец команды.

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

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

Также вы можете использовать опцию -L команды xargs, в результате чего в качестве аргумента будет использоваться вся строка целиком, а не отдельные ее фрагменты, разделенные пробелами. Использование опции -I неявно вызывает использование опции -L 1. В листинге 15 приведены примеры использования опций -I и –L.

Листинг 15. Использование команды xargs и строк ввода

[ian@echidna lpi103-4]$ xargs -I XYZ echo «START XYZ REPEAT XYZ END»

Источник: https://www.ibm.com/developerworks/ru/library/l-lpic1-v3-103-4/index.html

Потоки ввода — вывода.Байтовые потоки — Java программирование

Входной поток

Класс InputStream – это абстрактный класс. Все байтовые потоки чтения наследуются от класса InputStream.

Существует 3 основных read() метода:

  • int read() — возвращает целочисленное представление следующего доступного байта в потоке. При достижении конца файла возвращается значение -1.
  • int read(byte[] buffer) — пытается прочесть максимум buffer.length байт из входного потока в массив buffer. Возвращает количество байт, в действительности прочитанных из потока. По достижении конца файла возвращает значение -1.
  • int read(byte[] buffer, int offset, int length) — пытается прочесть максимум length байт, расположив их в массиве buffer, начиная с элемента offset. Возвращает количество реально прочитанных байт. По достижении конца файла возвращает -1.

Методы read() будут блокированы, пока доступные данные не будут прочитаны. 

  • int available() — возвращает количество байтов ввода, доступные в данный момент для чтения.
  • close() — закрывает источник ввода. Следующие попытки чтения передадут исключение IOException.
  • long skip(long byteCount) — пропускает byteCount байт ввода, возвращая количество проигнорированных байтов.

Все методы выбрасывают исключение IOException, если происходит ошибка ввода вывода. 

Все байтовые потоки записи наследуются от абстрактного класса OutputStream.

Существуют 3 основных write() метода:

  • void write(int data) — записывает один байт в выходной поток. Аргумент этого метода имеет тип int, что позволяет вызывать write, передавая ему выражение, при этом не нужно выполнять приведение его типа к byte.
  • void write(byte[] buffer) — записывает в выходной поток весь указанный массив байт.
  • void write(byte[] buffer, int offset, int length) — записывает в поток часть массива — length байт, начиная с элемента buffer[offset].
  • flush() — очищает любые выходные буферы, завершая операцию вывода.
  • close() — закрывает выходной поток. Последующие попытки записи в этот поток будут возбуждать IOException.

Методы выбрасывают исключение IOException, если происходит ошибка ввода вывода.

Поток FileInputStream используется в Java для чтения данных из файла.

Конструкторы класса FileInputStream:

InputStream a = new FileInputStream(«D:/myprogramm/java/test.txt»);

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

File file = new File(«D:/myprogramm/java/test.txt»); InputStream a = new FileInputStream(file);

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

В Javа FileOutputStream используется для создания файла и последующей записи в него. Поток создаст файл в случае его отсутствия перед его открытием для вывода.

Конструкторы класса FileOutputStream:

OutputStream outputStream = new FileOutputStream(«D:/myprogramm/java/test.txt»);

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

File file = new File(«D:/myprogramm/java/test.txt»); OutputStream a = new FileOutputStream(file);

Этот конструктор использует объектный файл с целью создания объекта выходного потока для записи файла.

Пример 1. Использование FileInputStream и FileOutputStream

import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.

IOException; public class FileCopy { public static void main(String[] args) throws IOException { FileInputStream fileIn = null; FileOutputStream fileOut = null; try { fileIn = new FileInputStream(«src\\io\\file.

txt»); fileOut = new FileOutputStream(«src\\io\\copied_file.txt»); int a; while ((a = fileIn.read()) != -1) { fileOut.write(a); } } finally { if (fileIn != null) { fileIn.close(); } if (fileOut != null) { fileOut.close(); } } } }

Пример 2. Использование FileInputStream и FileOutputStream

import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.

InputStream; import java.io.OutputStream; import java.io.IOException; public class FileInputOutputStreamDemo { public static void main(String[] args) { try { char[] symbols = {'a', 'b', 'c'}; OutputStream output = new FileOutputStream(«a.txt»); for (int i = 0; i < symbols.length; i++) { // Запись каждого символа в текстовый файл output.write(symbols[i]); } output.close(); InputStream input = new FileInputStream("a.txt"); int size = input.available(); for (int i = 0; i < size; i++) { // Чтение текстового файла посимвольно System.out.print((char) input.read() + " "); } input.close(); } catch (IOException e) { System.out.print("Exception"); } } }

Класс Назначение
BufferedlnputStreamБуферизированный входной поток.
BufferedOutputStreamБуферизированный выходной поток.
ByteArraylnputStreamВходной поток, читающий из массива байт.
ByteArrayOutputStreamВыходной поток, записывающий в массив байт.
DatalnputStreamВходной поток, включающий методы для чтения стандартных типов  данных Java.
DataOutputStreamВыходной поток, включающий методы для записи стандартных типов данных Java.
FilelnputStreamВходной поток, читающий из файла.
FileOutputStreamВыходной поток, записывающий в файл.
FilterlnputStreamРеализация InputStream.
FilterOutputStreamРеализация OutputStream.
ObjectlnputStreamВходной поток для объектов.
ObjectOutputStreamВыходной поток для объектов.
OutputStreamАбстрактный класс, описывающий поток вывода.
PipedlnputStreamВходной канал (например, межпрограммный).
PipedOutputStreamВыходной канал.
PrintStreamВыходной поток, включающий print() и println().
PushbacklnputStreamВходной поток, реализующий операцию pushback (вернуть назад).
RandomAccessFileПозволяет перемещаться по файлу, читать из него или писать в него.
SequencelnputStreamВходной поток, представляющий собой комбинацию двух и более входных потоков, которые читаются совместно  один после другого.

Источник: https://www.examclouds.com/ru/java/java-core-russian/byte-streams

Java 8 потоки ввода/вывода

Входной поток

Цикл статей «Учебник Java 8».

Следующая статья — «Java 8 сериализация».
Предыдущая статья — «Java 8 исключения».

Введение

Потоки байт

— Диаграмма классов, показывающая иерархию основных дочерних классов для класса java.io.InputStream

— Диаграмма классов, показывающая иерархию основных дочерних классов для класса java.io.OutputStream

— java.io.InputStream

— java.io.OutputStream

— java.io.FileInputStream и java.io.FileOutputStream

— java.io.ByteArrayInputStream и java.io.ByteArrayOutputStream

— java.io.FilterInputStream и java.io.FilterOutputStream

— java.io.DataInputStream и java.io.DataOutputStream

— java.io.BufferedInputStream и java.io.BufferedOutputStream

— java.io.PipedInputStream и java.io.PipedOutputStream

— java.io.ObjectInputStream и java.io.ObjectOutputStream

Потоки символов

— Диаграмма классов, показывающая иерархию основных дочерних классов для java.io.Reader

— Диаграмма классов, показывающая иерархию основных дочерних классов для java.io.Writer

— java.util.Scanner и java.io.PrintStream

Введение

Поток ввода/вывода (I/O Stream) представляет собой источник данных или место их назначения. Потоки могут представлять собой абсолютно различные источники и места назначения: файлы на диска, устройства, сеть, другие программы, массивы в памяти т. д.

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

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

Потоки байт

Все классы, работающие с потоками байт, наследуются от абстрактных классов java.io.InputStream  или java.io.OutputStream.

Диаграмма классов, показывающая иерархию основных дочерних классов для класса java.io.OutputStream

Принцип работы с каждым из этих классов весьма схож. Важно знать методы java.io.InputStream  и java.io.OutputStream, поскольку они наследуются в каждом из этих классов.

java.io.InputStream

Абстрактный класс, являющийся базовым классом для всех классов, представляющий поток ввода.

Основные методы:

public int available() throws IOException

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

public void close() throws IOException

Закрывает поток и освобождает все ресурсы.

public void mark(int readlimit)

public void mark(int readlimit)

Помечает текущую позицию во входной строке. Работает только если markSupported()  возвращает true.

Смысл этого метода в том, что поток каким-нибудь образом запоминает все считанные после вызова этого метода данные и может вернуть те же самые данные ещё раз после вызова метода reset().

Если после вызова метода mark(int readLimit)  из потока было прочитано больше readLimit  байт, то поток не обязан запоминать что бы то ни было.

public void reset() throws IOException

Если метод markSupported()  возвращает true, то:

  • Если метод mark()  не был вызван ни разу, либо количество байт, которые были прочитаны из потока после вызова mark() , больше аргумента метода mark()  в последнем его вызове, то может броситься исключение IOException.
  • Если исключение IOException  не было брошено, то поток возвращается в такое состояние, что все вызовы методов read()  в дальнейшем будут возвращать те же данные, которые они возвращали с момента последнего вызова метода mark()  (либо с начала потока, если метод mark()  не был вызван ни разу).

Если метод markSupported()  возвращает false, то:

  • Вызов метода reset()  может бросить исключение IOException.
  • Если не бросается исключение IOException, то поток сбрасывается в фиксированное состояние, которое зависит от конкретного типа входного потока, и как он был создан. Байты, которые будут прочитаны при последующих вызовах методов read(),  зависят от конкретного типа входной строки.

public boolean markSupported()

public boolean markSupported()

Возвращает true, если реализация InputStream  поддерживает методы mark() и reset().

public abstract int read() throws IOException

public abstract int read()

Считывает один байт из потока. Возвращает его в int, содержащем значение от 0 до 255. Возвращает -1, если достигли конца потока. Блокирует выполнение текущего потока программы до тех пор, пока не появятся входные данные, не достигнется конец потока, либо бросится исключение.

public int read(byte[] b) throws IOException

public int read(byte[] b)

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

Если длина массива b  равна нулю, то байты не считываются и возвращается 0, в противном случае происходит попытка считать хотя бы один байт. Если достигнут конец потока, то возвращается -1.

Метод read(b)  у класса InputStream  имеет такой же эффект, что и read(b, 0, b.length), но дочерние классы могут переопределить его, если нужно.

public int read(byte[] b, int off, int len) throws IOException

public int read(byte[] b,

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

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

Если len  равен нулю, то байты не считываются, и возвращается 0. В противном случае происходит попытка считать хотя бы один байт. Если никаких байт нет, так как был достигнут конец потока, то возвращается -1, иначе хотя бы один байт считывается и сохраняется в b.

Первый байт считывается в b[off] , второй в b[off + 1]  и так далее.

Реализация этого метода в классе InputStream  просто вызывает метод read()  в цикле. Потомки могут переопределить это поведение на более оптимальное.

public long skip(long n) throws IOException

Пропускает n  следующих байт во входном потоке. Может пропустить меньшее количество байт по какой-нибудь причине. Возвращается реальное количество пропущенных байт.

java.io.OutputStream

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

Основные методы:

public void close() throws IOException

Закрывает выходной поток и освобождает ресурсы.

public void flush() throws IOException

Записывает все байты из буфера. Некоторые реализации выходного потока могут накапливать байты в буфере и лишь потом реально записывать их. Вызов этого методы принудительно записывает данные из буфера и очищает его.

public abstract void write(int b) throws IOException

public abstract void write(int b)

Записывает байт в выходной поток.

public void write(byte[] b) throws IOException

public void write(byte[] b)

Записывает b.length  байт из  указанного массива байт в выходной поток. Аналогично вызову write(b, 0, b.length).

public void write(byte[] b, int off, int len) throws IOException

public void write(byte[] b,

Записывает len  байт из массива байт, начиная с off , в выходной поток. Реализация этого метода в OutputStream  вызывает в цикле метод write(int b). Дочерние классы могут переопределить его, дав более оптимальную реализацию.

java.io.FileInputStream и java.io.FileOutputStream

Предназначены для чтения и записи данных в файл и из файла. Пример использования:

import java.io.InputStream;import java.io.OutputStream;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException; class Main { public static void main(String[] args) { try (InputStream is = new FileInputStream(«input.txt»); OutputStream os = new FileOutputStream(«output.txt»)) { int bytesReaded; final int BUFFER_SIZE = 10_000; byte[] buff = new byte[BUFFER_SIZE]; while ((bytesReaded = is.read(buff)) != -1) { os.write(buff, 0, bytesReaded); } } catch (IOException ioex) { ioex.printStackTrace(); } }}

import java.io.InputStream;import java.io.OutputStream;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;    public static void main(String[] args) {        try (InputStream is = new FileInputStream(«input.txt»); OutputStream os = new FileOutputStream(«output.txt»)) {            final int BUFFER_SIZE = 10_000;            byte[] buff = new byte[BUFFER_SIZE];            while ((bytesReaded = is.read(buff)) != -1) {                os.write(buff, 0, bytesReaded);        } catch (IOException ioex) {

В диаграмме наследников InputStream и диаграмме наследников OutputStream показаны конструкторы этих классов.

java.io.ByteArrayInputStream и java.io.ByteArrayOutputStream

Класс ByteArrayInputStream  позволяет создать входной поток, который будет считывать данные из массива байт. Класс ByteArrayOutputStream  позволяет записывать данные в поток, а по окончании получить записанные данные в виде массива байт с помощью метода toByteArray(). Принцип работы с этими классами такой же, как и с остальными наследниками java.io.InputStream  и java.io.OutputStream.

В диаграмме наследников InputStream и диаграмме наследников OutputStream показаны конструкторы и методы этих классов.

java.io.FilterInputStream и java.io.FilterOutputStream

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

В диаграмме наследников InputStream и диаграмме наследников OutputStream показаны конструкторы и методы этих классов.

java.io.DataInputStream и java.io.DataOutputStream

Классы DataInputStream  и DataOutputStream  позволяют платформонезависимо записывать в поток и считывать из потока примитивные типы языка Java.

Класс DataInputStream  реализует интерфейс DataInput, который содержит методы для чтения примитивных типов, а класс DataOutputStream  реализует интерфейс DataOutput, который содержит методы для записи примитивных типов.

Эти классы используют в качестве обёртки над другими потоками, например так:

DataInputStream dis = new DataInputStream(new FileInputStream(«myfile.data»));

DataInputStream dis = new DataInputStream(new FileInputStream(«myfile.data»));

Методы интерфейса DataInput  используют исключение java.io.EOFException для обозначения конца потока, в отличие от методов класса InputStream, которые возвращают -1.

В диаграмме наследников InputStream и диаграмме наследников OutputStream показаны конструкторы этих классов.

java.io.BufferedInputStream и java.io.BufferedOutputStream

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

В диаграмме наследников InputStream и диаграмме наследников OutputStream показаны конструкторы этих классов.

java.io.PipedInputStream и java.io.PipedOutputStream

Экземпляр класса PipedInputStream  должен быть связан с экземпляром класса PipedOutputStream  с помощью метода connect(PipedOutputStream src). С помощью PipedInputStream  считываются данные, которые в другом потоке записываются в PipedOutputStream.

В диаграмме наследников InputStream и диаграмме наследников OutputStream показаны конструкторы этих классов.

java.io.ObjectInputStream и java.io.ObjectOutputStream

Классы ObjectInputStream  и ObjectOutputStream  позволяют считывать объекты из потока и записывать объекты в поток, то есть используются для сериализации и десериализации объектов.

Потоки символов

Все классы потоков символов наследуются от java.io.Reader  или java.io.Writer. Как и у потоков байт есть два специализированных класса для файлового ввода/вывода: java.io.FileReader  и java.io.FileWriter. Работа с потоками символов аналогична работе с потоками классов.

Любой поток байт можно превратить в поток символов, обернув его в java.io.InputStreamReader  или в java.io.OutputStreamWriter  для потока вывода.

try (Reader reader = new InputStreamReader(new ByteArrayInputStream(byteArray), «windows-1251»)) { // … some code}

try (Reader reader = new InputStreamReader(new ByteArrayInputStream(byteArray), «windows-1251»)) {

С помощью класса java.io.BufferedReader  можно считывать данные построчно, используя метод readLine() , который считает за конец строки символ ''  (LF), '\r'  (CR) или строку из двух символов «\r»  (CR LF).

java.util.Scanner и java.io.PrintStream

Класс PrintStream позволяет записывать в поток форматированные данные. Особенно важны его методы printf

Класс Scanner позволяет считывать из текста форматированные данные.

Работа с этими классами несколько отличается от работы с большинством классов, описанных в этой статье. Я не буду из здесь описывать. Когда-нибудь я, скорее всего, напишу отдельную статью по ним.

RandomAccessFile

Источник: https://urvanov.ru/2016/05/13/java-8-%D0%BF%D0%BE%D1%82%D0%BE%D0%BA%D0%B8-%D0%B2%D0%B2%D0%BE%D0%B4%D0%B0%D0%B2%D1%8B%D0%B2%D0%BE%D0%B4%D0%B0/

8.2. Характеристики и свойства потоков вызовов. 8. Основы теории телетрафика. Сети связи и системы коммутации

Входной поток

8.2.1. Основные понятия случайного процесса в системе массового обслуживания

8.2.2. Характеристики и свойства потоков вызовов

8.2.3. Длительность обслуживания вызовов

8.2.1. Основные понятия случайного процесса в системе массового обслуживания

Система массового обслуживания (СМО) состоит из какого-либо числа обслуживающих единиц (например, числа каналов связи). Работа любой СМО состоит в выполнении поступающего на нее потока требований (заявок).

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

В зависимости от числа каналов СМО обладает пропускной способностью, которая позволяет более или менее справляться с потоком заявок. Различают:

· абсолютную пропускную способностьчисло заявок, которое система может обслужить в единицу времени;

· относительную пропускную способностьсреднее отношение числа обслуженных заявок к числу поданных.

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

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

Таким образом, процесс функционирования СМО представляет собой случайный процесс.

Случайный процесс, протекающий в СМО, состоит в том, что система в случайные моменты времени переходит из одного состояния в другое: меняется число занятых каналов, число заявок в очереди и т. п.

СМО представляет собой физическую систему дискретного типа с конечным (счетным) множеством состояний, а переход системы из одного состояния в другое происходит скачком в тот момент, когда происходит какое-то новое событие (поступление новой заявки, уход заявки из очереди и т. п.).

Рассмотрим физическую систему Х со счетным множеством состояний [1]:

х1,х2, . . .хn, . . .

В любой момент времени t система Х может находится в одном из этих состояний. Обозначим рk(t) (k=1, 2, . . . n, . . .) вероятность того, что в момент времени t система будет находится в состоянии хk. Для такого случая будет справедливо равенство:

(8.1)

Совокупность вероятностей рk(t) для каждого момента времени t характеризует данное сечение случайного процесса, протекающего в системе. Случайные процессы в дискретной системе со счетным множеством состояний бывают двух типов: с дискретным и непрерывным временем.

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

Случайные процессы протекающие в СМО, как правило, представляют собой процессы с непрерывным временем.

В качестве примера рассмотрим одноканальную СМО (одна телефонная линия), в которой заявка, заставшая канал занятым, не становится в очередь, а покидает систему (получает отказ).

Эта система с непрерывным временем и двумя возможными состояниями: х0 – канал свободен, х1 – канал занят. Переходы из одного состояния в другое обратимы.

Для n-канальной системы имеются следующие состояния: х0 – все каналы свободны; х1 – один канал занят; х2 – занято два канала и т. д. На рисунке 8.1 показаны схемы возможных переходов.

Рисунок 8.1 – Переходы состояний для одноканальной и n-канальной систем

Другим примером дискретной системы с непрерывным временем является одноканальная СМО с четырьмя состояниями: х0 – канал исправен и свободен; х1 –канал исправен и занят; х2 – канал неисправен и ждет ремонта; х3 – канал неисправен и ремонтируется. Схема возможных переходов для этого случае показана на рисунке 8.2.

Рисунок 8.2 – Переходы для одноканальной системы с ремонтом

Для СМО основным фактором, обуславливающим протекающие в ней процессы, является поток заявок (вызовов). Поэтому математическое описание любой СМО начинается с описания потоков вызовов.

8.2.2. Характеристики и свойства потоков вызовов

Поток вызововпоследовательность вызовов, поступающих один за другим в какие-либо моменты времени (вызовы, поступающие от группы абонентов или группы устройств телефонной сети, поток информации, поступающий на ЭВМ, поток телеграмм и т. п.).

Потоки вызовов подразделяются на следующие виды:

· детерминированные – с фиксированными моментами поступления;

· случайные – потоки, в которых моменты поступления вызовов зависят от случайных факторов.

Детерминированные потоки являются частным случаем случайных потоков и на практике встречаются редко. В связи с этим в теории телетрафика основное внимание уделяется рассмотрению случайных потоков вызовов.

Основными характеристиками случайных потоков являются:

1) параметр потока l(t) в момент времени t есть предел отношения вероятности поступления не менее одного вызова в промежутке (t, t +Dt) к величине этого промежутка Dt при Dt®0:

, (8.2)

где i – количество вызовов

2) интенсивность потокаm(t) в момент времени t есть предел отношения приращения математического ожидания числа вызовов в промежуток времени (t, t +Dt) к величине этого промежутка Dt при Dt®0:

, (8.3)

где m(0,t) m(0,t+Dt) – математические ожидания числа вызовов за промежутки времени (0,t) (0,t+Dt).

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

Основными свойствами случайных потоков являются:

1) стационарность – стационарным называется поток, если вероятность поступления определенного количества вызовов за любой промежуток времени определяется лишь длительностью этого промежутка и не зависит от момента его начала;

2) ординарность – ординарным называется поток, в котором вероятность поступления более чем одного вызова за малый промежуток времени пренебрежительно мала по сравнению с вероятностью поступления одного вызова;

3) отсутствие последствия – поток вызовов называется потоком без последствия, если вероятность поступления вызова в момент времени t не зависит от предыдущих событий.

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

8.2.3. Длительность обслуживания вызовов

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

При hk=h длительность обслуживания называется постоянной. Детерминированная длительность обслуживания характерна для управляющих устройств АТС.

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

, (8.4)

где — вероятность того, что длительность случайного времени обслуживания t будет меньше наперед заданного значения времени t;

h – среднее время обслуживания.

Источник: https://siblec.ru/telekommunikatsii/seti-svyazi-i-sistemy-kommutatsii/8-osnovy-teorii-teletrafika/8-2-kharakteristiki-i-svojstva-potokov-vyzovov

Все термины
Добавить комментарий

;-) :| :x :twisted: :smile: :shock: :sad: :roll: :razz: :oops: :o :mrgreen: :lol: :idea: :grin: :evil: :cry: :cool: :arrow: :???: :?: :!: