1 JAVA.IO 字节流

• LineNumberInputStream 和 StringBufferInputStream 官网倡议不再应用，举荐应用 LineNumberReader 和 StringReader 代替

• ByteArrayInputStream 和 ByteArrayOutputStream

  • 字节数组解决流，在内存中建设一个缓冲区作为流应用，从缓存区读取数据比从存储介质 (如磁盘) 的速率快

// 用 ByteArrayOutputStream 临时缓存来自其余渠道的数据
ByteArrayOutputStream data = new ByteArrayOutputStream(1024); //1024 字节大小的缓存区
data.write(System.in.read()); // 暂存用户输出数据

// 将 data 转为 ByteArrayInputStream
ByteArrayInputStream in = new ByteArrayInputStream(data.toByteArray());

• FileInputStream 和 FileOutputStream

  • 拜访文件，把文件作为 InputStream，实现对文件的读写操作

• ObjectInputStream 和 ObjectOutputStream

  • 对象流，构造函数须要传入一个流，实现对 JAVA 对象的读写性能；可用于序列化，而对象须要实现 Serializable 接口

//java 对象的写入
FileOutputStream fileStream = new FileOutputStream("example.txt");
ObjectOutputStream out = new ObjectOutputStream(fileStream);
Example example = new Example();
out.writeObject(example);

//java 对象的读取
FileInputStream fileStream = new FileInputStream("example.txt");
ObjectInputStream in = new ObjectInputStream(fileStream);
Example = (Example) in.readObject();

• PipedInputStream 和 PipedOutputStream

  • 管道流，实用在两个线程中传输数据，一个线程通过管道输入流发送数据，另一个线程通过管道输出流读取数据，实现两个线程间的数据通信

// 创立一个发送者对象
Sender sender = new Sender(); // 创立一个接收者对象
Receiver receiver = new Receiver(); // 获取输入管道流
// 获取输入输出管道流
PipedOutputStream outputStream = sender.getOutputStream(); 
PipedInputStream inputStream = receiver.getInputStream();
// 链接两个管道，这一步很重要，把输出流和输入流联通起来        
outputStream.connect(inputStream);
sender.start();// 启动发送者线程
receiver.start();// 启动接收者线程

• SequenceInputStream

  • 把多个 InputStream 合并为一个 InputStream，容许应用程序把几个输出流间断地合并起来

InputStream in1 = new FileInputStream("example1.txt");
InputStream in2 = new FileInputStream("example2.txt");
SequenceInputStream sequenceInputStream = new SequenceInputStream(in1, in2);
// 数据读取
int data = sequenceInputStream.read();

• FilterInputStream 和 FilterOutputStream 应用了装璜者模式来减少流的额定性能，子类结构参数须要一个 InputStream/OutputStream

ByteArrayOutputStream out = new ByteArrayOutputStream(2014);
// 数据写入，应用 DataOutputStream 装璜一个 InputStream
// 应用 InputStream 具备对根本数据的解决能力
DataOutputStream dataOut = new DataOutputStream(out);
dataOut.writeDouble(1.0);
// 数据读取
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
DataInputStream dataIn = new DataInputStream(in);
Double data = dataIn.readDouble();

• DataInputStream 和 DataOutputStream (Filter 流的子类)

  • 为其余流附加解决各种根本类型数据的能力, 如 byte、int、String

• BufferedInputStream 和 BufferedOutputStream (Filter 流的子类)

  • 为其余流减少缓冲性能

• PushBackInputStream (FilterInputStream 子类)

  • 推回输出流，能够把读取进来的某些数据从新回退到输出流的缓冲区之中

• PrintStream (FilterOutputStream 子类)

  • 打印流，性能相似 System.out.print

2 JAVA.IO 字符流

• 从字节流和字符流的导向图来，它们之间是互相对应的，比方 CharArrayReader 和 ByteArrayInputStream
• 字节流和字符流的转化：InputStreamReader 能够将 InputStream 转为 Reader,OutputStreamReader 能够将 OutputStream 转为 Writer

//InputStream 转为 Reader
InputStream inputStream = new ByteArrayInputStream("程序".getBytes());
InputStreamReader reader = new InputStreamReader(inputStream, StandardCharsets.UTF_8);
//OutputStream 转为 Writer
OutputStream out = new FileOutputStream("example.txt");
OutputStreamWriter writer = new OutputStreamWriter(out);
// 以字符为单位读写
writer.write(reader.read(new char[2]));

• 区别：字节流读取单位是字节，字符流读取单位是字符；一个字符由字节组成，如变字长编码 UTF- 8 是由 1~4 个字节示意

3 乱码问题和字符流

• 字符以不同的编码表示，它的字节长度（字长）是不一样的。如“程”的 utf- 8 编码格局，由 -25[-117]组成。而 ISO_8859_1 编码则是单个字节[63]
• 平时工作对资源的操作都是面向字节流的，然而数据资源依据不同的字节编码转为字节时，它们的内容是不一样，容易造成乱码问题

• 两种呈现乱码场景

  • encode 和 decode 应用的字符编码不统一：资源应用 UTF- 8 编码，而在代码里却应用 GBK 解码关上
  • 应用字节流读取字节数不合乎字符规定字长：字符是由字节组成的，比方“程”的 utf- 8 格局是三个字节；如果在 InputStream 里以每两个字节读取流，再转为 String（java 默认编码是 utf-8），此时会呈现乱码（半个中文，你猜是什么）

ByteArrayInputStream in = new ByteArrayInputStream("程序大法好".getBytes());
byte[] buf = new byte[2]; // 读取流的两个字节
in.read(buf); // 读取数据
System.out.println(new String(buf)); // 乱码
---result---- 
�  // 乱码

• 乱码场景 1，晓得资源的字符编码，就能够应用对应的字符编码来解码解决
• 乱码场景 2，能够一次性读取所有字节，再一次性编码解决。然而对于大文件流，这是不事实的，因而有了字符流的呈现
• 字节流应用 InputStreamReader、OutputStreamReader 转化为字符流，其中能够指定字符编码，再以字符为单位来解决，可解决乱码

InputStreamReader reader = 
      new InputStreamReader(inputStream, StandardCharsets.UTF_8);

4 字符集和字符编码的概念辨别

• 字符集和字符编码的关系，字符集是标准，字符编码是标准的具体实现；字符集规定了符号和二进制代码值的惟一对应关系，然而没有指定具体的存储形式；
• unicode、ASCII、GB2312、GBK 都是字符集；其中 ASCII、GB2312、GBK 既是字符集也是字符编码；留神不混同这两者区别；而 unicode 的具体实现有 UTF-8，UTF-16，UTF-32
• 最早呈现的 ASCII 码是应用一个字节（8bit）来规定字符和二进制映射关系，规范 ASCII 编码规定了 128 个字符，在英文的世界，是够用的。然而中文，日文等其余文字符号怎么映射呢？因而其余更大的字符集呈现了
• unicode（对立字符集），晚期时它应用 2 个 byte 示意 1 个字符，整个字符集能够包容 65536 个字符。然而依然不够用，于是扩大到 4 个 byte 示意一个字符，现反对范畴是 U +010000~U+10FFFF
• unicode 是两个字节的说法是谬误的；UTF- 8 是变字长的，须要用 1~4 个字节存储；UTF-16 个别是两个字节（U+0000~U+FFFF 范畴），如果遇到两个字节存不下，则用 4 个字节；而 UTF-32 是固定四个字节
• unicode 示意的字符，会用“U+”结尾，前面跟着十六进制的数字，如“字”的编码就是 U +5B57
• UTF-8 编码和 unicode 字符集

• 程序是分内码和外码，java 的默认编码是 UTF-8，其实指的是外码；内码偏向于应用定长码，和内存对齐一个原理，便于解决。外码偏向于应用变长码，变长码将罕用字符编为短编码，常见字符编为长编码，节俭存储空间与传输带宽
• JDK8 的字符串，是应用 char[]来存储字符的，char 是两个字节大小，其中应用的是 UTF-16 编码（内码）。而 unicode 规定的中文字符在 U +0000~U+FFFF 内，因而应用 char（UTF-16 编码）存储中文是不会呈现乱码的
• JDK9 后，字符串则应用 byte[]数组来存储，因为有一些字符一个 char 曾经存不了，如 emoji 表情字符，应用字节存储字符串更容易拓展
• JDK9，如果字符串的内容都是 ISO-8859-1/Latin- 1 字符（1 个字符 1 字节），则应用 ISO-8859-1/Latin- 1 编码存储字符串，否则应用 UTF-16 编码存储数组（2 或 4 个字节）

System.out.println(Charset.defaultCharset()); // 输入 java 默认编码
for (byte item : "程序".getBytes(StandardCharsets.UTF_16)) {System.out.print("[" + item + "]");
}
System.out.println("");
for (byte item : "程序".getBytes(StandardCharsets.UTF_8)) {System.out.print("[" + item + "]");
}
----result----
UTF-8       //java 默认编码 UTF-8
[-2][-1][122][11][94][-113] //UTF_16：6 个字节？[-25][-88][-117][-27][-70][-113] //UTF_8：6 个字节 失常

• “程序”的 UTF-16 编码竟是输入 6 个字节，多出了两个字节，这是什么状况？再试试一个字符的输入

for (byte item : "程".getBytes(StandardCharsets.UTF_16)) {System.out.print("[" + item + "]");
}
---result--
[-2][-1][122][11]

• 能够看出 UTF-16 编码的字节是多了 - 2 两个字节，十六进制是 0xFEFF。而它用来标识编码程序是 Big endian 还是Little endian。以字符 ’ 中 ’ 为例，它的 unicode 十六进制是 4E2D，存储时 4E 在前，2D 在后，就是 Big endian；2D 在前，4E 在后，就是 Little endian。FEFF 示意存储采纳 Big endian，FFFE 示意应用 Little endian
• 为什么 UTF- 8 没有字节序的问题呢？集体认识，因为 UTF- 8 是变长的，由第一个字节的头部的 0、110、1110、11110 判断是否需后续几个字节组成字符，应用 Big endian 易读取解决，反过来不好解决，因而强制用 Big endian
• 其实感觉 UTF-16 能够强制规定用 Big endian；但这其中历史问题。。。

5 URI 概念的简略介绍

• 既然有了 java.io 来操作资源流；然而对于网络的资源，该怎么关上，怎么定位呢？答 URI-URL
• URI 全称是Uniform Resource Identifier 对立资源标识符
• 艰深说，就是一个相似身份证号码的字符串，只不过它是用来标识资源(如：邮件地址，主机名，文件等)

• URI 具备特定的规定: [scheme]:[scheme-specific-part][#fragment]

  • 进一步细入划分可示意为[scheme]:[//authority][/path][?query][#fragment]，其中模式特定局部为 authority 和 path、query；而 authority 能够看做域名，如www.baidu.com
  • 终极细分则是[scheme]:[//host:port][/path][?query][#fragment]，和日常见到的地址链接一毛一样了

• 模式特定局部 (scheme-specific-part) 的模式取决于模式，而 URI 的罕用模式如下

  • ftp：FTP 服务器
  • file：本地磁盘上的文件
  • http：应用超文本传输协定
  • mailto：电子邮件的地址
  • telnet：基于 Telnet 的服务的连贯
  • Java 中还大量应用了一些非标准的定制模式，如 rmi、jar、jndi、doc、jdbc 等
• 在 java 中 URI 形象为 java.net.URI 类，上面列举几种罕用构造方法

// 依据 str 生成 URI
public URI(String str) throws URISyntaxException
public URI(String scheme, String authority,
       String path, String query, String fragment)throws URISyntaxException
public static URI create(String str) // 调用 URI(String str)   

• JAVA.URI 的罕用操作方法

public String getScheme()    // 获取模式
public String getSchemeSpecificPart()// 获取模式特定局部
public String getFragment()  // 获取片段标识符
// 以上三个办法是通用的
public String getAuthority() // 受权机构, 如 www.baidu.com
public String getHost()      // 获取主机局部, 如 127.0.0.1
public int getPort()         // 如 8080
public String getPath()      // 定位门路
public String getQuery()     // 查问条件

6 URL 概念及与 URL 的区别

• URL 全称是Uniform Resource Location，对立资源定位符
• URL 就是 URI 的子集，它除了标识资源，还提供找到资源的门路；在 Java 类库中，URI 类不蕴含任何拜访资源的办法，它惟一的作用就是解析，而 URL 类能够关上一个达到资源的流
• 同属 URI 子集的 URN(对立资源名称)，只标识资源名称，却不指定如何定位资源 ；如：mailto：clswcl@gmail.com 就是一种 URN，晓得这是个邮箱，却不晓得该怎么查找定位
• 艰深就是，URN 通知你有一个中央叫广州，但没有说怎么去，你能够搭动车，也能够搭飞机；URL 会通知你坐飞机去广州，而另一 URL 则说搭动车去
• URL 的个别语法规定

协定:// 主机名: 端口 / 门路? 查问 #片段
[protocol]:[//host:port][/path][?query][#fragment]

• URL 的构造方法、获取办法

// 基于 URL 模式结构 URL 实例
public URL(String spec) throws MalformedURLException
// 其中 file 相当于 path、query 和 fragment 三个局部组成
public URL(String protocol, String host, int port, String file) throws MalformedURLException

// 依据类加载器获取 URL
URL systemResource = ClassLoader.getSystemResource(String name)
Enumeration<URL> systemResources = ClassLoader.getSystemResources(String name)
URL resource = Main.class.getResource(String name)
Enumeration<URL> resources = Main.class.getClassLoader().getResources(String name)

• 通过 URL 获取资源数据的操作函数

public final InputStream openStream() throws java.io.IOException
public URLConnection openConnection() throws java.io.IOException
public final Object getContent() throws java.io.IOException

7 Spring 资源获取形式与 Resource

• 讲到资源，就得提下 Spring 获取资源形式，罕用的有两种

  • 通过 Resource 接口的子类获取资源
  • 通过 ResourceLoader 接口的子类获取资源
• 先介绍下 Resource 相干子类的应用
• 1 FileSystemResource：通过文件系统获取资源

Resource resource = new FileSystemResource("D:/example.txt");
File file= new File("example.txt");
Resource resource2 = new FileSystemResource(file);

• 2 ByteArrayResource：获取 byte 数组示意的资源

  • 基于 ByteArrayInputStream 和字节数组实现，利用场景相似 ByteArrayInputStream，缓存 byte[]资源
• 3 ClassPathResource：获取类门路下的资源

//ClassPathResource.java 的三个属性
private final String path;
// 应用 Class 或 ClassLoader 加载资源
private ClassLoader classLoader;
private Class<?> clazz;

--- 应用形式 ----
Resource resource = new ClassPathResource("test.txt");

• 4 InputStreamResource：接管一个 InputStream 对象，获取输出流封装的资源
• 5 ServletContextResourse：加载 ServletContext 环境下（绝对于 Web 利用根目录的）门路资源，获取的资源
• 6 UrlResource：通过 URL 拜访 http 资源和 FTP 资源等

8 ResourceLoader 获取资源介绍

• ResourceLoader 是为了屏蔽了 Resource 的具体实现，对立资源的获取形式。你即能从 ResourceLoader 加载 ClassPathResource，也能加载 FileSystemResource 等

public interface ResourceLoader {
  // 默认从类门路加载的资源 前缀: "classpath:"，获取 ClassPathResource
   String CLASSPATH_URL_PREFIX = ResourceUtils.CLASSPATH_URL_PREFIX;
  Resource getResource(String location)；

• ResourceLoader 接口默认对 classpath 门路上面的资源进行加载

public interface ResourcePatternResolver extends ResourceLoader {
  // 默认加载所有门路（包含 jar 包）上面的文件，"classpath*:"，获取 ClassPathResource
  String CLASSPATH_ALL_URL_PREFIX = "classpath*:";

• ResourcePatternResolver 默认会加载所有门路上面的文件，取得 ClassPathResource；classpath：只会在 class 类门路下查找；而 classpath*：会扫描所有 JAR 包及 class 类门路下呈现的文件

//Ant 格调表达式  com/smart/**/*.xml 
ResourcePatternResoler resolver = new PathMatchingResourcePatternResolver();
Resource resources[] = resolver.getResources("com/smart/**/*.xml");

// ApplicationContext ctx 
//FileSystemResource 资源
Resource template = ctx.getResource("file:///res.txt");
//UrlResource 资源
Resource template = ctx.getResource("https://my.cn/res.txt");

• ResourceLoader 办法 getResource 的 locationPattern 可设置资源模式前缀来获取非 ClassPathResource 资源，locationPattern 反对 Ant 格调

9 JAVA.Properties 理解一下

• Properties 是 java 自带的配置解决类；Properties 加载资源的两种形式

public class Properties extends Hashtable<Object,Object>{
    .... // 可依据 Reader 或者 InputStream 加载 properties 文件内容
    public synchronized void load(Reader reader) throws IOException
    public synchronized void load(InputStream inStream) throws IOException

• Properties 读取配置示例代码

//res.properties
username = root
password = password
------- 代码示例 -------------
InputStream input = ClassLoader.getSystemResourceAsStream("res.properties");
Properties prop = new Properties();
prop.load(inputStream); // 依据 inputStream 载入资源
String username = prop.getProperty("username");

10 yml 配置资源的读取

• 一般 java 我的项目如果须要读取 yml 可引入 jackson-dataformat-yaml，而 springboot 默认配置反对 yml 的读取

<dependency>
  <groupId>com.fasterxml.jackson.dataformat</groupId>
  <artifactId>jackson-dataformat-yaml</artifactId>
  <version>2.9.5</version>
</dependency>

• 基于 jackson-dataformat-yaml 对 yml 配置资源的读取

//res.yml 配置
name: chen
params:
  url:  http://www.my.com
  
---------- 代码示例 ---------------
InputStream input = ClassLoader.getSystemResourceAsStream("res.yml");
Yaml yml = new Yaml();
Map map = new Yaml().loadAs(input, LinkedHashMap.class);; // 依据 inputStream 载入资源
String name = MapUtils.getString(map,"name"); // chen
//url:  http://www.my.com
String url = MapUtils.getString((Map)map.get("params"),"url")

11 优雅地敞开资源，try-with-resource 语法和 lombok@Cleanup

• 资源的关上就须要对应的敞开，但咱们常会遗记敞开资源，或在多处代码敞开资源感到芜杂，有没有简洁的敞开办法呢？
• 主动敞开资源类需实现 AutoCloseable 接口和配和 try-with-resource 语法糖应用

public class YSOAPConnection implements AutoCloseable {
    private SOAPConnection connection;
    public static YSOAPConnection open(SOAPConnectionFactory soapConnectionFactory) throws SOAPException  {YSOAPConnection ySoapConnection = new YSOAPConnection();
        SOAPConnection connection = soapConnectionFactory.createConnection();
        ySoapConnection.setConnection(connection);
        return ySoapConnection;
    }
    public SOAPMessage call(SOAPMessage request, Object to) throws SOAPException {return connection.call(request, to); 
    }
    @Override
    public void close() throws SOAPException {if (connection != null) {connection.close(); }
    }
}

// 主动敞开的资源类应用示例
try (YSOAPConnection soapConnection=YSOAPConnection.open(soapConnectionFactory)){SOAPMessage soapResponse = soapConnection.call(request, endpoint);
    ...// 数据操作
} catch (Exception e) {log.error(e.getMessage(), e);
    ...
}

• lombok 注解 @Cleanup，对象生命周期完结时会调用public void close(); 对象需实现 AutoCloseable 接口

import lombok.Cleanup;
@Cleanup  // @Cleanup 的应用
YSOAPConnection soapConnection=YSOAPConnection.open(soapConnectionFactory)

12 资源不敞开，会导致什么最坏的后果

• JDK 的原生资源类不敞开，它也不会永远存在。JVM 会借助 finalize 主动敞开它，例如 FileInputStream

//FileInputStream.java - JDK8
//jdk8 的 FileInputStream 重写了 finalize，保障对象回收前开启的资源被敞开
protected void finalize () throws IOException {if (guard != null) {guard.warnIfOpen();
    }
    if ((fd != null) && (fd != FileDescriptor.in)) {close();
    }
}

• 在 JDK9 后，用 Cleaner 机制代替了 finalize 机制；Cleaner 机制主动回收的对象同样须要实现 AutoClose 接口；Cleaner 是基于 PhantomReference 实现的；对实现细节感兴趣的同学，可自行查阅下相干文档
• 然而应用 JDK 的提供的资源敞开机制的，那么资源的敞开比手动敞开时要延后很长时间的。据测试，应用 try-with-resources 敞开资源，并让垃圾回收器回收它的工夫在 12 纳秒。而应用 finalizer 机制，工夫减少到 550 纳秒
• 不及时敞开资源，就会占用资源，影响其余线程的执行；比方 linux 的文件资源，linux 过程默认能关上的最大文件数是 1024（有的是 2048，此数值是可配置的）；如果一个线程持有十几个文件资源，还要等 550 纳秒用 finalizer 机制开释资源，同过程的其余线程都等到花谢了

欢送指注释中谬误

关注公众号，一起交换

参考文章

• 从源码角度了解 Java 设计模式——装璜者模式
• Java 中的管道流
• InputStream 乱码问题的解决办法
• 未敞开的文件流会引起内存泄露么？
• char 类型与字符编码
• 联合 Java 详谈字符编码和字符集
• Cleaner 比照 finalize 比照 AutoCloseable