Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JDK 17 java.base.jmod - Base Module
JDK 17 java.base.jmod is the JMOD file for JDK 17 Base module.
JDK 17 Base module compiled class files are stored in \fyicenter\jdk-17.0.5\jmods\java.base.jmod.
JDK 17 Base module compiled class files are also linked and stored in the \fyicenter\jdk-17.0.5\lib\modules JImage file.
JDK 17 Base module source code files are stored in \fyicenter\jdk-17.0.5\lib\src.zip\java.base.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ java/io/CharArrayReader.java
/* * Copyright (c) 1996, 2021, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package java.io; import java.nio.CharBuffer; import java.util.Objects; /** * This class implements a character buffer that can be used as a * character-input stream. * * @author Herb Jellinek * @since 1.1 */ public class CharArrayReader extends Reader { /** The character buffer. */ protected char[] buf; /** The current buffer position. */ protected int pos; /** The position of mark in buffer. */ protected int markedPos = 0; /** * The index of the end of this buffer. There is not valid * data at or beyond this index. */ protected int count; /** * Creates a CharArrayReader from the specified array of chars. * @param buf Input buffer (not copied) */ public CharArrayReader(char[] buf) { this.buf = buf; this.pos = 0; this.count = buf.length; } /** * Creates a CharArrayReader from the specified array of chars. * * <p> The resulting reader will start reading at the given * {@code offset}. The total number of {@code char} values that can be * read from this reader will be either {@code length} or * {@code buf.length-offset}, whichever is smaller. * * @throws IllegalArgumentException * If {@code offset} is negative or greater than * {@code buf.length}, or if {@code length} is negative, or if * the sum of these two values is negative. * * @param buf Input buffer (not copied) * @param offset Offset of the first char to read * @param length Number of chars to read */ public CharArrayReader(char[] buf, int offset, int length) { if ((offset < 0) || (offset > buf.length) || (length < 0) || ((offset + length) < 0)) { throw new IllegalArgumentException(); } this.buf = buf; this.pos = offset; this.count = Math.min(offset + length, buf.length); this.markedPos = offset; } /** Checks to make sure that the stream has not been closed */ private void ensureOpen() throws IOException { if (buf == null) throw new IOException("Stream closed"); } /** * Reads a single character. * * @throws IOException If an I/O error occurs */ public int read() throws IOException { synchronized (lock) { ensureOpen(); if (pos >= count) return -1; else return buf[pos++]; } } /** * Reads characters into a portion of an array. * * <p> If {@code len} is zero, then no characters are read and {@code 0} is * returned; otherwise, there is an attempt to read at least one character. * If no character is available because the stream is at its end, the value * {@code -1} is returned; otherwise, at least one character is read and * stored into {@code cbuf}. * * @param cbuf {@inheritDoc} * @param off {@inheritDoc} * @param len {@inheritDoc} * * @return {@inheritDoc} * * @throws IndexOutOfBoundsException {@inheritDoc} * @throws IOException {@inheritDoc} */ public int read(char[] cbuf, int off, int len) throws IOException { synchronized (lock) { ensureOpen(); Objects.checkFromIndexSize(off, len, cbuf.length); if (len == 0) { return 0; } if (pos >= count) { return -1; } int avail = count - pos; if (len > avail) { len = avail; } if (len <= 0) { return 0; } System.arraycopy(buf, pos, cbuf, off, len); pos += len; return len; } } @Override public int read(CharBuffer target) throws IOException { synchronized (lock) { ensureOpen(); if (pos >= count) { return -1; } int avail = count - pos; int len = Math.min(avail, target.remaining()); target.put(buf, pos, len); pos += len; return len; } } /** * Skips characters. If the stream is already at its end before this method * is invoked, then no characters are skipped and zero is returned. * * <p>The {@code n} parameter may be negative, even though the * {@code skip} method of the {@link Reader} superclass throws * an exception in this case. If {@code n} is negative, then * this method does nothing and returns {@code 0}. * * @param n {@inheritDoc} * * @return {@inheritDoc} * * @throws IOException {@inheritDoc} */ public long skip(long n) throws IOException { synchronized (lock) { ensureOpen(); long avail = count - pos; if (n > avail) { n = avail; } if (n < 0) { return 0; } pos += n; return n; } } /** * Tells whether this stream is ready to be read. Character-array readers * are always ready to be read. * * @throws IOException If an I/O error occurs */ public boolean ready() throws IOException { synchronized (lock) { ensureOpen(); return (count - pos) > 0; } } /** * Tells whether this stream supports the mark() operation, which it does. */ public boolean markSupported() { return true; } /** * Marks the present position in the stream. Subsequent calls to reset() * will reposition the stream to this point. * * @param readAheadLimit Limit on the number of characters that may be * read while still preserving the mark. Because * the stream's input comes from a character array, * there is no actual limit; hence this argument is * ignored. * * @throws IOException If an I/O error occurs */ public void mark(int readAheadLimit) throws IOException { synchronized (lock) { ensureOpen(); markedPos = pos; } } /** * Resets the stream to the most recent mark, or to the beginning if it has * never been marked. * * @throws IOException If an I/O error occurs */ public void reset() throws IOException { synchronized (lock) { ensureOpen(); pos = markedPos; } } /** * Closes the stream and releases any system resources associated with * it. Once the stream has been closed, further read(), ready(), * mark(), reset(), or skip() invocations will throw an IOException. * Closing a previously closed stream has no effect. This method will block * while there is another thread blocking on the reader. */ public void close() { synchronized (lock) { buf = null; } } }
⏎ java/io/CharArrayReader.java
Or download all of them as a single archive file:
File name: java.base-17.0.5-src.zip File size: 8883851 bytes Release date: 2022-09-13 Download
2023-09-26, 44570👍, 1💬
Popular Posts:
Guava is a suite of core and expanded libraries that include utility classes, google's collections, ...
JDK 17 java.base.jmod is the JMOD file for JDK 17 Base module. JDK 17 Base module compiled class fil...
Where to find answers to frequently asked questions on Downloading and Using JDK (Java Development K...
Apache Log4j IOStreams is a Log4j API extension that provides numerous classes from java.io that can...
How to download and install Apache XMLBeans-2.6.0.zip? If you want to try the XMLBeans Java library,...