<!doctype html>Java IO&NIO

figure:first-child { margin-top: -20px; }
#write ol, #write ul { position: relative; }
img { max-width: 100%; vertical-align: middle; }
button, input, select, textarea { color: inherit; font-family: inherit; font-size: inherit; font-style: inherit; font-variant-caps: inherit; font-weight: inherit; font-stretch: inherit; line-height: inherit; }
input[type="checkbox"], input[type="radio"] { line-height: normal; padding: 0px; }
*, ::after, ::before { box-sizing: border-box; }
#write h1, #write h2, #write h3, #write h4, #write h5, #write h6, #write p, #write pre { width: inherit; }
#write h1, #write h2, #write h3, #write h4, #write h5, #write h6, #write p { position: relative; }
h1, h2, h3, h4, h5, h6 { break-after: avoid-page; break-inside: avoid; orphans: 2; }
p { orphans: 4; }
h1 { font-size: 2rem; }
h2 { font-size: 1.8rem; }
h3 { font-size: 1.6rem; }
h4 { font-size: 1.4rem; }
h5 { font-size: 1.2rem; }
h6 { font-size: 1rem; }
.md-math-block, .md-rawblock, h1, h2, h3, h4, h5, h6, p { margin-top: 1rem; margin-bottom: 1rem; }
.hidden { display: none; }
.md-blockmeta { color: rgb(204, 204, 204); font-weight: 700; font-style: italic; }
a { cursor: pointer; }
sup.md-footnote { padding: 2px 4px; background-color: rgba(238, 238, 238, 0.701961); color: rgb(85, 85, 85); border-top-left-radius: 4px; border-top-right-radius: 4px; border-bottom-right-radius: 4px; border-bottom-left-radius: 4px; cursor: pointer; }
sup.md-footnote a, sup.md-footnote a:hover { color: inherit; text-transform: inherit; text-decoration: inherit; }
#write input[type="checkbox"] { cursor: pointer; width: inherit; height: inherit; }
figure { overflow-x: auto; margin: 1.2em 0px; max-width: calc(100% + 16px); padding: 0px; }
figure > table { margin: 0px !important; }
tr { break-inside: avoid; break-after: auto; }
thead { display: table-header-group; }
table { border-collapse: collapse; border-spacing: 0px; width: 100%; overflow: auto; break-inside: auto; text-align: left; }
table.md-table td { min-width: 32px; }
.CodeMirror-gutters { border-right-width: 0px; background-color: inherit; }
.CodeMirror { text-align: left; }
.CodeMirror-placeholder { opacity: 0.3; }
.CodeMirror pre { padding: 0px 4px; }
.CodeMirror-lines { padding: 0px; }
div.hr:focus { cursor: none; }
#write pre { white-space: pre-wrap; }
#write.fences-no-line-wrapping pre { white-space: pre; }
#write pre.ty-contain-cm { white-space: normal; }
.CodeMirror-gutters { margin-right: 4px; }
.md-fences { font-size: 0.9rem; display: block; break-inside: avoid; text-align: left; overflow: visible; white-space: pre; background-image: inherit; background-size: inherit; background-attachment: inherit; background-origin: inherit; background-clip: inherit; background-color: inherit; position: relative !important; background-position: inherit inherit; background-repeat: inherit inherit; }
.md-diagram-panel { width: 100%; margin-top: 10px; text-align: center; padding-top: 0px; padding-bottom: 8px; overflow-x: auto; }
#write .md-fences.mock-cm { white-space: pre-wrap; }
.md-fences.md-fences-with-lineno { padding-left: 0px; }
#write.fences-no-line-wrapping .md-fences.mock-cm { white-space: pre; overflow-x: auto; }
.md-fences.mock-cm.md-fences-with-lineno { padding-left: 8px; }
.CodeMirror-line, twitterwidget { break-inside: avoid; }
.footnotes { opacity: 0.8; font-size: 0.9rem; margin-top: 1em; margin-bottom: 1em; }
.footnotes + .footnotes { margin-top: 0px; }
.md-reset { margin: 0px; padding: 0px; border: 0px; outline: 0px; vertical-align: top; text-decoration: none; text-shadow: none; float: none; position: static; width: auto; height: auto; white-space: nowrap; cursor: inherit; line-height: normal; font-weight: 400; text-align: left; box-sizing: content-box; direction: ltr; background-position: 0px 0px; background-repeat: initial initial; }
li div { padding-top: 0px; }
blockquote { margin: 1rem 0px; }
li .mathjax-block, li p { margin: 0.5rem 0px; }
li { margin: 0px; position: relative; }
blockquote > :last-child { margin-bottom: 0px; }
blockquote > :first-child, li > :first-child { margin-top: 0px; }
.footnotes-area { color: rgb(136, 136, 136); margin-top: 0.714rem; padding-bottom: 0.143rem; white-space: normal; }
#write .footnote-line { white-space: pre-wrap; }
@media print {
body, html { border: 1px solid transparent; height: 99%; break-after: avoid-page; break-before: avoid-page; }
#write { margin-top: 0px; padding-top: 0px; border-color: transparent !important; }
.typora-export * { -webkit-print-color-adjust: exact; }
html.blink-to-pdf { font-size: 13px; }
.typora-export #write { padding-left: 32px; padding-right: 32px; padding-bottom: 0px; break-after: avoid-page; }
.typora-export #write::after { height: 0px; }
@page { margin: 20mm 0px; }
}
.footnote-line { margin-top: 0.714em; font-size: 0.7em; }
a img, img a { cursor: pointer; }
pre.md-meta-block { font-size: 0.8rem; min-height: 0.8rem; white-space: pre-wrap; background-color: rgb(204, 204, 204); display: block; overflow-x: hidden; background-position: initial initial; background-repeat: initial initial; }
p > .md-image:only-child:not(.md-img-error) img, p > img:only-child { display: block; margin: auto; }
p > .md-image:only-child { display: inline-block; width: 100%; }
#write .MathJax_Display { margin: 0.8em 0px 0px; }
.md-math-block { width: 100%; }
.md-math-block:not(:empty)::after { display: none; }
[contenteditable="true"]:active, [contenteditable="true"]:focus { outline: 0px; box-shadow: none; }
.md-task-list-item { position: relative; list-style-type: none; }
.task-list-item.md-task-list-item { padding-left: 0px; }
.md-task-list-item > input { position: absolute; top: 0px; left: 0px; margin-left: -1.2em; margin-top: calc(1em - 10px); }
.math { font-size: 1rem; }
.md-toc { min-height: 3.58rem; position: relative; font-size: 0.9rem; border-top-left-radius: 10px; border-top-right-radius: 10px; border-bottom-right-radius: 10px; border-bottom-left-radius: 10px; }
.md-toc-content { position: relative; margin-left: 0px; }
.md-toc-content::after, .md-toc::after { display: none; }
.md-toc-item { display: block; color: rgb(65, 131, 196); }
.md-toc-item a { text-decoration: none; }
.md-toc-inner:hover { text-decoration: underline; }
.md-toc-inner { display: inline-block; cursor: pointer; }
.md-toc-h1 .md-toc-inner { margin-left: 0px; font-weight: 700; }
.md-toc-h2 .md-toc-inner { margin-left: 2em; }
.md-toc-h3 .md-toc-inner { margin-left: 4em; }
.md-toc-h4 .md-toc-inner { margin-left: 6em; }
.md-toc-h5 .md-toc-inner { margin-left: 8em; }
.md-toc-h6 .md-toc-inner { margin-left: 10em; }
@media screen and (max-width: 48em) {
.md-toc-h3 .md-toc-inner { margin-left: 3.5em; }
.md-toc-h4 .md-toc-inner { margin-left: 5em; }
.md-toc-h5 .md-toc-inner { margin-left: 6.5em; }
.md-toc-h6 .md-toc-inner { margin-left: 8em; }
}
a.md-toc-inner { font-size: inherit; font-style: inherit; font-weight: inherit; line-height: inherit; }
.footnote-line a:not(.reversefootnote) { color: inherit; }
.md-attr { display: none; }
.md-fn-count::after { content: "."; }
code, pre, samp, tt { font-family: var(--monospace); }
kbd { margin: 0px 0.1em; padding: 0.1em 0.6em; font-size: 0.8em; color: rgb(36, 39, 41); background-color: rgb(255, 255, 255); border: 1px solid rgb(173, 179, 185); border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; box-shadow: rgba(12, 13, 14, 0.2) 0px 1px 0px, rgb(255, 255, 255) 0px 0px 0px 2px inset; white-space: nowrap; vertical-align: middle; background-position: initial initial; background-repeat: initial initial; }
.md-comment { color: rgb(162, 127, 3); opacity: 0.8; font-family: var(--monospace); }
code { text-align: left; }
a.md-print-anchor { white-space: pre !important; border: none !important; display: inline-block !important; position: absolute !important; width: 1px !important; right: 0px !important; outline: 0px !important; text-shadow: initial !important; background-position: 0px 0px !important; background-repeat: initial initial !important; }
.md-inline-math .MathJax_SVG .noError { display: none !important; }
.html-for-mac .inline-math-svg .MathJax_SVG { vertical-align: 0.2px; }
.md-math-block .MathJax_SVG_Display { text-align: center; margin: 0px; position: relative; text-indent: 0px; max-width: none; max-height: none; min-height: 0px; min-width: 100%; width: auto; overflow-y: hidden; display: block !important; }
.MathJax_SVG_Display, .md-inline-math .MathJax_SVG_Display { width: auto; margin: inherit; display: inline-block !important; }
.MathJax_SVG .MJX-monospace { font-family: var(--monospace); }
.MathJax_SVG .MJX-sans-serif { font-family: sans-serif; }
.MathJax_SVG { display: inline; font-style: normal; font-weight: 400; line-height: normal; zoom: 90%; text-indent: 0px; text-align: left; text-transform: none; letter-spacing: normal; word-spacing: normal; word-wrap: normal; white-space: nowrap; float: none; direction: ltr; max-width: none; max-height: none; min-width: 0px; min-height: 0px; border: 0px; padding: 0px; margin: 0px; }
.MathJax_SVG * { transition: none; }
.MathJax_SVG_Display svg { vertical-align: middle !important; margin-bottom: 0px !important; }
.os-windows.monocolor-emoji .md-emoji { font-family: "Segoe UI Symbol", sans-serif; }
.md-diagram-panel > svg { max-width: 100%; }
[lang="mermaid"] svg, [lang="flow"] svg { max-width: 100%; }
[lang="mermaid"] .node text { font-size: 1rem; }
table tr th { border-bottom-width: 0px; }
video { max-width: 100%; display: block; margin: 0px auto; }
iframe { max-width: 100%; width: 100%; border: none; }
.highlight td, .highlight tr { border: 0px; }

.CodeMirror { height: auto; }
.CodeMirror.cm-s-inner { background-image: inherit; background-size: inherit; background-attachment: inherit; background-origin: inherit; background-clip: inherit; background-color: inherit; background-position: inherit inherit; background-repeat: inherit inherit; }
.CodeMirror-scroll { overflow-y: hidden; overflow-x: auto; z-index: 3; }
.CodeMirror-gutter-filler, .CodeMirror-scrollbar-filler { background-color: rgb(255, 255, 255); }
.CodeMirror-gutters { border-right-width: 1px; border-right-style: solid; border-right-color: rgb(221, 221, 221); background-image: inherit; background-size: inherit; background-attachment: inherit; background-origin: inherit; background-clip: inherit; background-color: inherit; white-space: nowrap; background-position: inherit inherit; background-repeat: inherit inherit; }
.CodeMirror-linenumber { padding: 0px 3px 0px 5px; text-align: right; color: rgb(153, 153, 153); }
.cm-s-inner .cm-keyword { color: rgb(119, 0, 136); }
.cm-s-inner .cm-atom, .cm-s-inner.cm-atom { color: rgb(34, 17, 153); }
.cm-s-inner .cm-number { color: rgb(17, 102, 68); }
.cm-s-inner .cm-def { color: rgb(0, 0, 255); }
.cm-s-inner .cm-variable { color: rgb(0, 0, 0); }
.cm-s-inner .cm-variable-2 { color: rgb(0, 85, 170); }
.cm-s-inner .cm-variable-3 { color: rgb(0, 136, 85); }
.cm-s-inner .cm-string { color: rgb(170, 17, 17); }
.cm-s-inner .cm-property { color: rgb(0, 0, 0); }
.cm-s-inner .cm-operator { color: rgb(152, 26, 26); }
.cm-s-inner .cm-comment, .cm-s-inner.cm-comment { color: rgb(170, 85, 0); }
.cm-s-inner .cm-string-2 { color: rgb(255, 85, 0); }
.cm-s-inner .cm-meta { color: rgb(85, 85, 85); }
.cm-s-inner .cm-qualifier { color: rgb(85, 85, 85); }
.cm-s-inner .cm-builtin { color: rgb(51, 0, 170); }
.cm-s-inner .cm-bracket { color: rgb(153, 153, 119); }
.cm-s-inner .cm-tag { color: rgb(17, 119, 0); }
.cm-s-inner .cm-attribute { color: rgb(0, 0, 204); }
.cm-s-inner .cm-header, .cm-s-inner.cm-header { color: rgb(0, 0, 255); }
.cm-s-inner .cm-quote, .cm-s-inner.cm-quote { color: rgb(0, 153, 0); }
.cm-s-inner .cm-hr, .cm-s-inner.cm-hr { color: rgb(153, 153, 153); }
.cm-s-inner .cm-link, .cm-s-inner.cm-link { color: rgb(0, 0, 204); }
.cm-negative { color: rgb(221, 68, 68); }
.cm-positive { color: rgb(34, 153, 34); }
.cm-header, .cm-strong { font-weight: 700; }
.cm-del { text-decoration: line-through; }
.cm-em { font-style: italic; }
.cm-link { text-decoration: underline; }
.cm-error { color: red; }
.cm-invalidchar { color: red; }
.cm-constant { color: rgb(38, 139, 210); }
.cm-defined { color: rgb(181, 137, 0); }
div.CodeMirror span.CodeMirror-matchingbracket { color: rgb(0, 255, 0); }
div.CodeMirror span.CodeMirror-nonmatchingbracket { color: rgb(255, 34, 34); }
.cm-s-inner .CodeMirror-activeline-background { background-image: inherit; background-size: inherit; background-attachment: inherit; background-origin: inherit; background-clip: inherit; background-color: inherit; background-position: inherit inherit; background-repeat: inherit inherit; }
.CodeMirror { position: relative; overflow: hidden; }
.CodeMirror-scroll { height: 100%; outline: 0px; position: relative; box-sizing: content-box; background-image: inherit; background-size: inherit; background-attachment: inherit; background-origin: inherit; background-clip: inherit; background-color: inherit; background-position: inherit inherit; background-repeat: inherit inherit; }
.CodeMirror-sizer { position: relative; }
.CodeMirror-gutter-filler, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler, .CodeMirror-vscrollbar { position: absolute; z-index: 6; display: none; }
.CodeMirror-vscrollbar { right: 0px; top: 0px; overflow: hidden; }
.CodeMirror-hscrollbar { bottom: 0px; left: 0px; overflow: hidden; }
.CodeMirror-scrollbar-filler { right: 0px; bottom: 0px; }
.CodeMirror-gutter-filler { left: 0px; bottom: 0px; }
.CodeMirror-gutters { position: absolute; left: 0px; top: 0px; padding-bottom: 30px; z-index: 3; }
.CodeMirror-gutter { white-space: normal; height: 100%; box-sizing: content-box; padding-bottom: 30px; margin-bottom: -32px; display: inline-block; }
.CodeMirror-gutter-wrapper { position: absolute; z-index: 4; border: none !important; background-position: 0px 0px !important; background-repeat: initial initial !important; }
.CodeMirror-gutter-background { position: absolute; top: 0px; bottom: 0px; z-index: 4; }
.CodeMirror-gutter-elt { position: absolute; cursor: default; z-index: 4; }
.CodeMirror-lines { cursor: text; }
.CodeMirror pre { border-top-left-radius: 0px; border-top-right-radius: 0px; border-bottom-right-radius: 0px; border-bottom-left-radius: 0px; border-width: 0px; font-family: inherit; font-size: inherit; margin: 0px; white-space: pre; word-wrap: normal; color: inherit; z-index: 2; position: relative; overflow: visible; background-position: 0px 0px; background-repeat: initial initial; }
.CodeMirror-wrap pre { word-wrap: break-word; white-space: pre-wrap; word-break: normal; }
.CodeMirror-code pre { border-right-width: 30px; border-right-style: solid; border-right-color: transparent; width: fit-content; }
.CodeMirror-wrap .CodeMirror-code pre { border-right-style: none; width: auto; }
.CodeMirror-linebackground { position: absolute; left: 0px; right: 0px; top: 0px; bottom: 0px; z-index: 0; }
.CodeMirror-linewidget { position: relative; z-index: 2; overflow: auto; }
.CodeMirror-wrap .CodeMirror-scroll { overflow-x: hidden; }
.CodeMirror-measure { position: absolute; width: 100%; height: 0px; overflow: hidden; visibility: hidden; }
.CodeMirror-measure pre { position: static; }
.CodeMirror div.CodeMirror-cursor { position: absolute; visibility: hidden; border-right-style: none; width: 0px; }
.CodeMirror div.CodeMirror-cursor { visibility: hidden; }
.CodeMirror-focused div.CodeMirror-cursor { visibility: inherit; }
.cm-searching { background-color: rgba(255, 255, 0, 0.4); background-position: initial initial; background-repeat: initial initial; }
@media print {
.CodeMirror div.CodeMirror-cursor { visibility: hidden; }
}

:root {
--side-bar-bg-color: #fafafa;
--control-text-color: #777;
}

@include-when-export url(https://fonts.loli.net/css?family=Open+Sans:400italic,700italic,700,400&subset=latin,latin-ext);

html {
font-size: 16px;
}

body {
font-family: "Open Sans","Clear Sans","Helvetica Neue",Helvetica,Arial,sans-serif;
color: rgb(51, 51, 51);
line-height: 1.6;
}

#write {
max-width: 860px;
margin: 0 auto;
padding: 30px;
padding-bottom: 100px;
}
#write > ul:first-child,
#write > ol:first-child{
margin-top: 30px;
}

a {
color: #4183C4;
}
h1,
h2,
h3,
h4,
h5,
h6 {
position: relative;
margin-top: 1rem;
margin-bottom: 1rem;
font-weight: bold;
line-height: 1.4;
cursor: text;
}
h1:hover a.anchor,
h2:hover a.anchor,
h3:hover a.anchor,
h4:hover a.anchor,
h5:hover a.anchor,
h6:hover a.anchor {
text-decoration: none;
}
h1 tt,
h1 code {
font-size: inherit;
}
h2 tt,
h2 code {
font-size: inherit;
}
h3 tt,
h3 code {
font-size: inherit;
}
h4 tt,
h4 code {
font-size: inherit;
}
h5 tt,
h5 code {
font-size: inherit;
}
h6 tt,
h6 code {
font-size: inherit;
}
h1 {
padding-bottom: .3em;
font-size: 2.25em;
line-height: 1.2;
border-bottom: 1px solid #eee;
}
h2 {
padding-bottom: .3em;
font-size: 1.75em;
line-height: 1.225;
border-bottom: 1px solid #eee;
}
h3 {
font-size: 1.5em;
line-height: 1.43;
}
h4 {
font-size: 1.25em;
}
h5 {
font-size: 1em;
}
h6 {
font-size: 1em;
color: #777;
}
p,
blockquote,
ul,
ol,
dl,
table{
margin: 0.8em 0;
}
li>ol,
li>ul {
margin: 0 0;
}
hr {
height: 2px;
padding: 0;
margin: 16px 0;
background-color: #e7e7e7;
border: 0 none;
overflow: hidden;
box-sizing: content-box;
}

li p.first {
display: inline-block;
}
ul,
ol {
padding-left: 30px;
}
ul:first-child,
ol:first-child {
margin-top: 0;
}
ul:last-child,
ol:last-child {
margin-bottom: 0;
}
blockquote {
border-left: 4px solid #dfe2e5;
padding: 0 15px;
color: #777777;
}
blockquote blockquote {
padding-right: 0;
}
table {
padding: 0;
word-break: initial;
}
table tr {
border-top: 1px solid #dfe2e5;
margin: 0;
padding: 0;
}
table tr:nth-child(2n),
thead {
background-color: #f8f8f8;
}
table tr th {
font-weight: bold;
border: 1px solid #dfe2e5;
border-bottom: 0;
text-align: left;
margin: 0;
padding: 6px 13px;
}
table tr td {
border: 1px solid #dfe2e5;
text-align: left;
margin: 0;
padding: 6px 13px;
}
table tr th:first-child,
table tr td:first-child {
margin-top: 0;
}
table tr th:last-child,
table tr td:last-child {
margin-bottom: 0;
}

.CodeMirror-lines {
padding-left: 4px;
}

.code-tooltip {
box-shadow: 0 1px 1px 0 rgba(0,28,36,.3);
border-top: 1px solid #eef2f2;
}

.md-fences,
code,
tt {
border: 1px solid #e7eaed;
background-color: #f8f8f8;
border-radius: 3px;
padding: 0;
padding: 2px 4px 0px 4px;
font-size: 0.9em;
}

code {
background-color: #f3f4f4;
padding: 0 2px 0 2px;
}

.md-fences {
margin-bottom: 15px;
margin-top: 15px;
padding-top: 8px;
padding-bottom: 6px;
}

.md-task-list-item > input {
margin-left: -1.3em;
}

@media print {
html {
font-size: 13px;
}
table,
pre {
page-break-inside: avoid;
}
pre {
word-wrap: break-word;
}
}

.md-fences {
background-color: #f8f8f8;
}
#write pre.md-meta-block {
padding: 1rem;
font-size: 85%;
line-height: 1.45;
background-color: #f7f7f7;
border: 0;
border-radius: 3px;
color: #777777;
margin-top: 0 !important;
}

.mathjax-block>.code-tooltip {
bottom: .375rem;
}

.md-mathjax-midline {
background: #fafafa;
}

#write>h3.md-focus:before{
left: -1.5625rem;
top: .375rem;
}
#write>h4.md-focus:before{
left: -1.5625rem;
top: .285714286rem;
}
#write>h5.md-focus:before{
left: -1.5625rem;
top: .285714286rem;
}
#write>h6.md-focus:before{
left: -1.5625rem;
top: .285714286rem;
}
.md-image>.md-meta {
/*border: 1px solid #ddd;*/
border-radius: 3px;
padding: 2px 0px 0px 4px;
font-size: 0.9em;
color: inherit;
}

.md-tag {
color: #a7a7a7;
opacity: 1;
}

.md-toc {
margin-top:20px;
padding-bottom:20px;
}

.sidebar-tabs {
border-bottom: none;
}

#typora-quick-open {
border: 1px solid #ddd;
background-color: #f8f8f8;
}

#typora-quick-open-item {
background-color: #FAFAFA;
border-color: #FEFEFE #e5e5e5 #e5e5e5 #eee;
border-style: solid;
border-width: 1px;
}

/** focus mode */
.on-focus-mode blockquote {
border-left-color: rgba(85, 85, 85, 0.12);
}

header, .context-menu, .megamenu-content, footer{
font-family: "Segoe UI", "Arial", sans-serif;
}

.file-node-content:hover .file-node-icon,
.file-node-content:hover .file-node-open-state{
visibility: visible;
}

.mac-seamless-mode #typora-sidebar {
background-color: #fafafa;
background-color: var(--side-bar-bg-color);
}

.md-lang {
color: #b4654d;
}

.html-for-mac .context-menu {
--item-hover-bg-color: #E6F0FE;
}

#md-notification .btn {
border: 0;
}

.dropdown-menu .divider {
border-color: #e5e5e5;
}

.typora-export li, .typora-export p, .typora-export, .footnote-line {white-space: normal;}
-->

Java I/O的类库的基本架构

IO是任何编程语言都无法避免的问题,是整个人机交互的核心问题。

Java的IO大致分为四类:

「1」字节操作:InputStream和OutputStream

「2」字符操作:Write和Reader

「3」磁盘操作:File

「4」网络操作:Socket

字节操作

基于字节的输入和输出操作的接口是:InputStream和OutputStream,分别表示输入和输出。

InputStream框架

InputStream(抽象类)

⊢ObjectInputStream

|构造:一个InputStream的实现类的对象

⊢PipedInputStream

|构造:PipedOutputStream对象可额外设定大小

⊢ByteArrayInputStream

|构造:一个byte的数组,用于缓冲

⊢FileInputStream

|构造:一个路径字符串,或是一个File的对象

|∟SocketInputStream

∟FilterInputStream.

构造:InputStream的实现类的对象

⊢BufferedInputStream

构造:InputStream的实现类的对象,或另加缓冲大小

⊢DataInputStream

构造:InputStream的实现类的对象 ∟InflaterInputStream

构造:InputStream的实现类的对象

∟ZipInputStream

构造:InputStream的实现类的对象,或另加一个字符类型

OutStream框架

OutputStream(抽象类)

⊢ObjectOutputStream

|构造:一个OutputStream的实现类的对象

⊢PipedOutputStream

|构造:PipedInputStream对象

⊢ByteArrayOutputStrea

|构造:数组的长度

⊢FileOutputStream

|构造:file的对象

|∟SocketInputStream

∟FilterOutputStream

构造:OutputStream的实现类对象

⊢BufferedOutputStream

构造:OutputStream的实现类对象

⊢DataOutputStream

构造:OutputStream的实现类对象

∟ZipOutputStream

构造:OutputStream的实现类对象或额外加一个字符

它们的每一个子类分别操作不同的操作类型。

「1」各种I/O可以叠加使用,比如:

 
 
 
 
 
 
 
 
1
public static void main(String[] args) throws IOException {
2
    OutputStream outputStream = new BufferedOutputStream(
3
   new FileOutputStream("index.txt"));
4
    outputStream.write(0);
5
}
 
 

「2」使用Output的时候,要了解最最终写到了哪里,磁盘还是网络。

字符操作

基于字符的输入和输出操作的接口是:Printer和Writer,分别表示输入和输出。

Reader框架

Reader (抽象类)

⊢InputStreamReader

|构造:InputStream的对象

|∟ FileReader

|构造: File对象或加一个字符

⊢ BufferedReader

|构造:Reader的实现类的对象

⊢CharArrayReader

|构造:一个字符型数组

⊢FilterReader

|构造:file或增加一个字符

⊢PipedReader

|构造:一个PipedWriter对象

∟StringReader

构造:一个字符串

Writer框架

Writer (抽象类)

⊢OutputStreamWriter

|构造:OutputStream的对象

|∟FileWriter

| 构造:File对象或加一个字符

⊢BufferedWriter

|构造:一个Writer的实现类的对象

⊢CharArrayWriter

|构造:空,或数组长度

⊢FilterWriter

|构造:一个Writer的实现类的对象

⊢PipedWriter

|构造:一个PipedReader对象

∟StringWriter

构造:空,或字符串长度

一个使用Printer和Writer输入输出的例子:

 
 
 
​x
 
 
 
 
1
2
3
import java.io.*;
4
5
import java.nio.charset.StandardCharsets;
6
7
8
9
//   @ author :zjxu     time:2018/12/1
10
11
public class charStreamDemo {
12
   public static void main(String[] args) throws IOException {
13
        Writer writer =
14
                new BufferedWriter(
15
                        new OutputStreamWriter(
16
                                new FileOutputStream("index.txt")));
17
18
        BufferedReader reader =
19
           new BufferedReader(
20
                new InputStreamReader(
21
                        new FileInputStream("index.txt"), StandardCharsets.*US_ASCII*));
22

23
        writer.append("xxx");
24
        writer.flush();
25
        String string = reader.readLine();
26
        System.out.println(string);
27
        reader.close();
28
        writer.close();
29
30
    }
31
32
}
 
 

字符与字节的转化接口

InputStreamReader类是从字节到字符转化的桥梁。

OutputStreamWriter类是从字符到子节转化的桥梁。

StreamEnCoder完成了编码的过程。

磁盘的I/O工作的机制

几种文件访问的方式

为了加快访问的效率使用了缓存的形式对磁盘中的文件进行访问。

「1」标准访问文件的方式

缓存结构:(两层缓存)

< 1 > read和write在用户地址空间的应用缓存中读取和写入。

< 2 > 磁盘对内核地址空间中的高速缓存页缓存中读取和写入。

< 3 > 内核地址空间中的高速页缓存和用户地址空间的应用缓存这两者之间相互写入和读取。

「2」直接I/O的方式不使用高速页缓存,磁盘直接和用户地址空间的应用缓存I/O

「3」同步访问文件的方式,同步操作。

「4」异步访问文件的操作

类似于多线程中的高并发的future模式,在给出访问的请求之后,线程会接着去处理别的内容,而不是阻塞等待。这样可以减少等待的时间,提高效率但是不是提高文件访问的效率,而是在等待的时间继续工作,提高时间利用率。

「5」内存映射的方式

将内存的某一区域和磁盘中的文件关联起来,当要访问内存中的一段数据的时候,转换为访问文件的某一段数据。

将内存中的缓存转化为文件,当要访问的时候,直接读取对应的文件就可以的想要的缓存的内容。

Java访问磁盘文件

File对象表示一个指向某个存在的路径的一个虚拟对象,并不代表这个文件。

将File文件传入FileInputStream,然后fileInput对象根据这个file对象的地址,去操作磁盘的文件。

Java的序列化技术

Java的序列化就是将一个对象转化成一串二进制表示的字节数组,通过保存或转移这些字节数组来达到持久化的目的。

网络I/O的工作机制

TCP状态的转换

「1」CLOSED:起始点,在超时或者是连接关闭的时候进入这个状态

「2」LISTEN:server端在等待连接时的状态,server端为此调用Socket、bind、listen函数,就能进入这个状态。

「3」SYN-SENT:客户端发起连接,发送SYN给服务端。

影响网络传输的因素

「1」宽带网络:一条无力链路在1s内能传输的最大bit数,不是byte数。

「2」传输距离:光在光纤中是有传输时间的,这个距离越长,延时就越大。

「3」TCP拥塞控制:TCP是一个“停-等-停-等”的协议,传输方要和接收方步调一致,这样的同步要受到拥塞控制。

Socket的工作机制

可以看作是一个应用程序和TCP/UDP端口的一个桥梁,使用Socket将应用程序和TCP/UDP端口连接起来。使用socket指定端口,再通过IP和无力链路实现网络数据交换。

建立通信链路

客户端的Socket

「1」客户端建立socket实例。操作系统分配一个没有被使用的本地端口号,并创建一个包含本地地址、远程地址和端口号的套接字的数据结构,连接关闭删除。

「2」创建socket返回之前,实现TCP的三次握手,TCP握手协议完成之后,Socket完成创建。否则抛出IOException错误。

服务端的Socket

服务器端的ServerSocket创建比较简单。

操作系统也会为ServerSocket创建一个数据结构,这个结构里面包含一个端口号和监听地址的通配符‘*’,即监听所有的地址。

当调用accept方法的时候,进入阻塞状态,等待客户端的请求。

当请求到来的时候,为这个连接创建一个新的套接字数据结构,这个数据结构包含地址和端口信息并关联到serverSocket的数据结构中。

完成三次握手之后,创建客户端的Socket。

数据传输

每一个socket都有outputstrem 和inputstream ,通过它们 来交换数据。网络通道是使用字节通道来谈书数据的。在初三书数据的时候,会给OS 和 IS分配一个缓存区,读写都是通过缓存区完成的。

NIO的工作方式

BIO带来的挑战

BIO就是阻塞的IO,无论是磁盘还是网络,在IS 和OS的时候,都有可能发生阻塞。一旦阻塞,线程就失去的CPU的控制权。基于这样的考虑,我们需要一种非阻塞的IO机制。

NIO的工作机制

NIO的核心类有三个Buffer、Channel、Selector,是NIO中最重要的类。

将Selector比作一个车站的调度系统,负责监控每一个交通工具的运行状态。

将Channel比作拥有多个座位的交通工具,它会受到Selector的调度。

Buffer是一个缓存区。

Channel

是一个通道,InputStream 和 OutputStream相似,也是一个传输数据的通道。但是不同的是,在传统的意义上来说,无论是output和input,都是一个单向的通道。但是channel是一个双向的通道,input和ouput都能完成。

Buffer

是一个缓存区域,在NIO中读取和写入的数据都只能先暂时存放在缓存区Buffer中。

Buffer是一个顶层父类,基本的八种数据类型都有Buffer的类。如:IntBuffer、ByteBuffer、CharBuffer ······

对于网络的读写,使用的最广泛的是ByteBuffer。

Selector

轮询每一个注册的Channel,一旦发现有事件发生的话,就获取事件,进行处理。

Selector是NIO的核心类,Selector能够检测多个注册的通道上面的是否有事件发生,如果有事件发生,获取这个事件,然后处理这个事件。使用一个Selector来检测多个Channel,这样可以花费少量的资源控制大量的传输通道,并且只有在有事件发生的时候,才会调用函数处理这个事件。

client ---> Buffer ---> Channel <===> Channel ---> Buffer ---> server

箭头的指向为数据传输的方向

Buffer的工作方式

secket监测到通道有数据IO请求时,通过select方法取得,SocketChannel,将数据读取或写入buffer。

buffer是一个基本数据类型的元素列表。通过几个变量来保存这个数据的当前位置,也就是说有四个index。

「1」capacity:缓冲区数字的总长度。

「2」pasition:下一个要操作的数据元素的位置。

「3」limit:缓冲区不可操作的下一个位置的位置。

「4」mark:记录position前一个位置,default:0。

「1」创建方法:ByteBuffer.allocate(n) //创建一个长度为n的Byte的缓冲区。

这个时候的 capacity 和 limit的大小都是数组的长度;

position的大小是0,数组的首端。

「2」在写入了数据之后,position会变为数组没有存储数据的位置的一个位置。

「3」使用byteBuffer.flip方法,limit = position,position = 0,然后就可以正确的读取这鞋数据,并且将数据发送出去。

「4」然后使用 byteBuffer.clear方法,将会到刚刚创建的状态。

关于 mark 方法 ,使用mark方法的时候,mark会记录position - 1 的数据大小。当再次使用reset的时候,position将不会还原,会回到mark的值。

NIO数据的访问方式

在文件访问方面,NIO有两种优化方法:

FileChannel.transferTo & FileChannel.transferFrom 、FileChannel.map。

FileChannel.TransferXXX

传统的方面,物理硬盘和内核空间里面的高速缓存交互,但是是读写独立成块的,在高速内存里面并没有交流,它们都和应用的缓存单向数据交换。

使用FileChannel.TransferXXX的方法,就是在内核地址空间内,原本属于读写的两块区域可以在内核空间里面进行数据的交换。

FileChannel.map

这歌方法将文件按照一定的大小映射一段区域,当文件需要对这个文件进行操作的时候,直接对这个内存区域进行访问、操作就行了,不需要花费大量的时间对这个文件从内核空间向用户空间进行复制。

*尤其适合大文件的MD5 校验。

I/O调优

2.5.1 磁盘I/O调优

2.5.2 TCP网络参数调优

2.5.3 网络I/O优化

准则:减少网络交互的次数、减少数据传输量的大小。、尽量坚守编码。

设计方式:同步&异步、阻塞&非阻塞、两种方式结合

同步&异步

这里的同步和并发中的同步和异步还是有不一样的地方的。

同步指的是后一个任务需要依赖前一个任务的完成,这样的机制,保证了前后任务都完成。

异步指的是前一个任务在运行,通知后一个任务需要完成什么工作,这时候前后两个个任务同时运行,但是前一个任务对后一个任务的成功情况并不关心。

阻塞&非阻塞

阻塞就是说CPU会等待操作的完成,再执行别的任务。

非阻塞指的是CPU在等待操作的完成的时候,同时会执行别的操作。

非阻塞的操作可以提高CPU的工作效率, 但是,这样的机制会涉及到频繁的线程切换,这是额外的损耗。

基于同步&异步、阻塞&非阻塞,一共有四种排列组合的方式。

设计模式之适配器模式

适配器模式的结构

Target(目标接口):所需要转换的所期待的接口。

Adaptee(源角色):需要适配的接口。

Adapter(适配器):将目标接口配置成可以引用源角色的接口:继承目标接口,实现对源角色的引用。

适配器举例

InputStreamReader 和 OutputStreamWriter 分别继承了 Reader 和 Writer 接口。

但是在构造它们的时候,需要传入一个InputStream 和 OutputStream。

InputStreamReader 和 OutputStreamWriter的作用也就是将InputStream 和OutputStream的对象适配到 Reader 和 Writer 。

继承的是:目标接口;传入引用的是源角色。

在这个例子里面:

适配器是InputStreamReader;

源角色是InputStream;

目标接口就是Reader;

其实本质就是,目标接口可以实现的某些功能,在某些情况下,我的源角色也需要使用那些功能,这个时候就要将源角色的对象传入某个类中,并且要求这个类可以实现目标接口的功能。那么这个类就是适配器类。就是说目标接口带着源角色做目标接口才能做的事,这样的实现类就是适配器类。

设计模式之装饰器模式

装饰器模式的结构

Component(抽象组件):定义组件的功能。

ConcreteComponent(实现抽象组件):实现组件的功能。

(我的理解是上面这个部分和装饰器模式并没有关系,这是装饰器的对立面,即直接实现。)

Decorator(装饰器角色):持有一个对抽象组件的引用,并且实现了装饰器的接口。

ConcreteDecorator(实现装饰器):装饰器的实现者。

装饰器举例

InputStream:抽象组件;(抽象类)

FileInputStream:具体组件;(class)

FilterInputStream:装饰器角色;(class)

BufferedInputStream:装饰器实现者;(class)

在FilterInputStream里,引用了InputStream的对象,并且实现了InputStream的功能,它的作用是为所有的字节装饰类提供一个标准的借口。

BufferedInputStream是FilterInputStream的具体实现者,也就是说按照装饰器角色的标准,实现了这个装饰器,并且给InputStream添加了功能:将数据缓存在内存中。(其他的装饰器有别的不同的附加的功能)

适配器模式和装饰器模式

适配器指某个类的对象想实现某个接口的类。然后构建起这样的一个类,实现了该接口,并且将这个对象传入这个类,让这个对象也可以实现这个接口的方法。

而装饰器模式就是说,抽象组件需要一个统一的标准,在同一个基础类的条件下,对抽象组件的扩展。

Java IO与网络编程笔记的更多相关文章

  1. Java IO、网络编程、NIO、Netty、Hessian、RPC、RMI的学习路线

    好久没看Java IO这块的内容,感觉都快忘得差不多了.平成编程也没有设计到太多的Java基础知识,所以这里希望可以抽点时间回顾一下,让艾宾浩斯记忆曲线不要下降的太快. 回顾这个主要还是以总结为主,能 ...

  2. Java学习之网络编程实例

    转自:http://www.cnblogs.com/springcsc/archive/2009/12/03/1616413.html 多谢分享 网络编程 网络编程对于很多的初学者来说,都是很向往的一 ...

  3. 黑马程序员:Java基础总结----网络编程

    黑马程序员:Java基础总结 网络编程   ASP.Net+Android+IO开发 . .Net培训 .期待与您交流! 网络编程 网络通讯要素 . IP地址 . 网络中设备的标识 . 不易记忆,可用 ...

  4. Java进阶之网络编程

    网络编程 网络编程对于很多的初学者来说,都是很向往的一种编程技能,但是很多的初学者却因为很长一段时间无法进入网络编程的大门而放弃了对于该部分技术的学习. 在 学习网络编程以前,很多初学者可能觉得网络编 ...

  5. 第84节:Java中的网络编程(中)

    第84节:Java中的网络编程(中) 实现客户端和服务端的通信: 客户端需要的操作,创建socket,明确地址和端口,进行键盘录入,获取需要的数据,然后将录入的数据发送给服务端,为socket输出流, ...

  6. 第78节:Java中的网络编程(上)

    第78节:Java中的网络编程(上) 前言 网络编程涉及ip,端口,协议,tcp和udp的了解,和对socket通信的网络细节. 网络编程 OSI开放系统互连 网络编程指IO加网络 TCP/IP模型: ...

  7. 第62节:探索Java中的网络编程技术

    前言 感谢! 承蒙关照~ 探索Java中的网络编程技术 网络编程就是io技术和网络技术的结合,网络模型的定义,只要共用网络模型就可以两者连接.网络模型参考. 一座塔有七层,我们需要闯关. 第一层物理层 ...

  8. 20165324 Java实验五 网络编程与安全

    20165324 Java实验五 网络编程与安全 一.实验报告封面 课程:Java程序设计 班级:1653班 姓名:何春江 学号:20165324 指导教师:娄嘉鹏 实验日期:2018年5月28日 实 ...

  9. 2018-2019-2-20175323 java实验五 网络编程与安全

    20175323 java实验五 网络编程与安全 任务一 ①编写MyBC.java实现中缀表达式转后缀表达式的功能 ②编写MyDC.java实现从上面功能中获取的表达式中实现后缀表达式求值的功能 基本 ...

随机推荐

  1. [OPENCV] 第一个程序 识别颜色

    它可以鉴别出图像中含有给定颜色的所有像素,该算法输入的是图像以及颜色,并返回表示含有指定颜色的像素的二值图像.该算法还需要指定另外一个参数,即对颜色偏差的容忍度. 实现效果 实现后 #include ...

  2. flash小游戏在Kongregate上线——BasketBall Master(篮球大师)

    小游戏地址,欢迎上去留言评论.游戏完成度没有达到期望水平,只能算完成了核心玩法吧,一些其他构想来不及实现. BasketBall Master(篮球大师) 这个小游戏很早之前就基本做好了,只因有些细节 ...

  3. Python+selenium自动化脚本编辑过程中遇到的问题和小技巧

    应该也不算是问题和技巧,算是实践中学习到的Python,记录下,也不定时更新 1.通过截取url判断 实例: self.assertEqual(self.broswer.current_url[sel ...

  4. Java优化之输出十万以内的质数

    (1)未经优化时所耗费的时间: public class PrimeNumber { public static void main(String[] args) { long start = Sys ...

  5. P1027 木瓜地

    /*=========================================================== 描述 Description Bessie不小心游荡出Farmer John ...

  6. Hadoop它——跑start-all.sh时间namenode不启动

    转载请注明出处:http://blog.csdn.net/l1028386804/article/details/46353211 近期遇到了一个问题,运行start-all.sh的时候发现JPS一下 ...

  7. [C++STDlib基础]关于C标准输入输出的操作——C++标准库头文件&lt;cstdio&gt;

    网上实例 总结 /* _STD_BEGIN using _CSTD clearerr; using _CSTD fclose; using _CSTD feof; using _CSTD ferror ...

  8. 关于对vector3及其衍生变量的理解

    关于对vector3,vector2类及其衍生变量的理解 vector3简单来讲即表示向量和点的系统类,这个结构用于处理向量和点,也包含许多做向量运算的函数. 而vector2即少一维向量的类,用于处 ...

  9. C# .net 填充无效,无法被移除 微信小程序解密失败的解决办法

    微信小程序获取用户信息诸如unionId的时候需要解密,如果遇到偶然的解密失败(填充无效,无法被移除),原因很有可能是session_key错误, 也是就你用作解密的session_key并不是微信用 ...

  10. cat查看文件以及sed查看指定行数

    https://unix.stackexchange.com/questions/288521/with-the-linux-cat-command-how-do-i-show-only-certai ...