分类： java2014-07-01 15:30 815人阅读 评论(0) 收藏 举报
 

目录(?)[+]

 
 

一、InputStreamReader类

InputStreamReader 将字节流转换为字符流。是字节流通向字符流的桥梁。如果不指定字符集编码，该解码过程将使用平台默认的字符编码，如：GBK。

构造方法：

InputStreamReader isr = new InputStreamReader(InputStream in);//构造一个默认编码集的InputStreamReader类

InputStreamReader isr = new InputStreamReader(InputStream in,String charsetName);//构造一个指定编码集的InputStreamReader类。

参数 in对象通过 InputStream in = System.in;获得。//读取键盘上的数据。

或者    InputStream in = new FileInputStream(String fileName);//读取文件中的数据。可以看出FileInputStream 为InputStream的子类。

主要方法：int read();//读取单个字符。

int read(char []cbuf);//将读取到的字符存到数组中。返回读取的字符数。

  1. public static void transReadNoBuf() throws IOException {
  2. /**
  3. * 没有缓冲区，只能使用read()方法。
  4. */
  5. //读取字节流
  6. //      InputStream in = System.in;//读取键盘的输入。
  7. InputStream in = new FileInputStream("D:\\demo.txt");//读取文件的数据。
  8. //将字节流向字符流的转换。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节.
  9. InputStreamReader isr = new InputStreamReader(in);//读取
  10. //      InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\demo.txt"));//综合到一句。
  11. char []cha = new char[1024];
  12. int len = isr.read(cha);
  13. System.out.println(new String(cha,0,len));
  14. isr.close();
  15. }
  16. public static void transReadByBuf() throws IOException {
  17. /**
  18. * 使用缓冲区 可以使用缓冲区对象的 read() 和  readLine()方法。
  19. */
  20. //读取字节流
  21. //      InputStream in = System.in;//读取键盘上的数据
  22. InputStream in = new FileInputStream("D:\\demo.txt");//读取文件上的数据。
  23. //将字节流向字符流的转换。
  24. InputStreamReader isr = new InputStreamReader(in);//读取
  25. //创建字符流缓冲区
  26. BufferedReader bufr = new BufferedReader(isr);//缓冲
  27. //      BufferedReader bufr = new BufferedReader(new InputStreamReader(new FileInputStream("D:\\demo.txt")));可以综合到一句。
  28. /*  int ch =0;
  29. ch = bufr.read();
  30. System.out.println((char)ch);*/
  31. String line = null;
  32. while((line = bufr.readLine())!=null){
  33. System.out.println(line);
  34. }
  35. isr.close();
  36. }
  1. public static void transReadNoBuf() throws IOException {
  2. /**
  3. * 没有缓冲区，只能使用read()方法。
  4. */
  5. //读取字节流
  6. //      InputStream in = System.in;//读取键盘的输入。
  7. InputStream in = new FileInputStream("D:\\demo.txt");//读取文件的数据。
  8. //将字节流向字符流的转换。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节.
  9. InputStreamReader isr = new InputStreamReader(in);//读取
  10. //      InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\demo.txt"));//综合到一句。
  11. char []cha = new char[1024];
  12. int len = isr.read(cha);
  13. System.out.println(new String(cha,0,len));
  14. isr.close();
  15. }
  16. public static void transReadByBuf() throws IOException {
  17. /**
  18. * 使用缓冲区 可以使用缓冲区对象的 read() 和  readLine()方法。
  19. */
  20. //读取字节流
  21. //      InputStream in = System.in;//读取键盘上的数据
  22. InputStream in = new FileInputStream("D:\\demo.txt");//读取文件上的数据。
  23. //将字节流向字符流的转换。
  24. InputStreamReader isr = new InputStreamReader(in);//读取
  25. //创建字符流缓冲区
  26. BufferedReader bufr = new BufferedReader(isr);//缓冲
  27. //      BufferedReader bufr = new BufferedReader(new InputStreamReader(new FileInputStream("D:\\demo.txt")));可以综合到一句。
  28. /*  int ch =0;
  29. ch = bufr.read();
  30. System.out.println((char)ch);*/
  31. String line = null;
  32. while((line = bufr.readLine())!=null){
  33. System.out.println(line);
  34. }
  35. isr.close();
  36. }

二、OutputStreamWriter类

OutputStreamWriter 将字节流转换为字符流。是字节流通向字符流的桥梁。如果不指定字符集编码，该解码过程将使用平台默认的字符编码，如：GBK。

构造方法：

OutputStreamWriter osw = new OutputStreamWriter(OutputStream out);//构造一个默认编码集的OutputStreamWriter类

OutputStreamWriter osw = new OutputStreamWriter(OutputStream out,String charsetName);//构造一个指定编码集的OutputStreamWriter类。

参数 out对象通过 InputStream out = System.out;获得。//打印到控制台上。

或者    InputStream out = new FileoutputStream(String fileName);//输出到文件中。可以看出FileoutputStream 为outputStream的子类。

主要方法：void write(int c);//将单个字符写入。

viod write(String str,int off,int len);//将字符串某部分写入。

void flush();//将该流中的缓冲数据刷到目的地中去。

  1. public static void transWriteNoBuf() throws IOException {
  2. OutputStream out = System.out;//打印到控制台
  3. //      OutputStream out = new FileOutputStream("D:\\demo.txt");//打印到文件
  4. OutputStreamWriter osr = new OutputStreamWriter(out);//输出
  5. //      OutputStreamWriter osr = new OutputStreamWriter(new FileOutputStream("D:\\demo.txt"));//两句可以综合到一句。
  6. //      int ch = 97;//a
  7. //      int ch = 20320;//你
  8. //      osr.write(ch);
  9. String str = "你好吗？";//你好吗？
  10. osr.write(str);
  11. osr.flush();
  12. osr.close();
  13. }
  14. public static void transWriteByBuf() throws IOException {
  15. //      OutputStream out = System.out;//打印到控制台。
  16. OutputStream out = new FileOutputStream("D:\\demo.txt");//打印到文件。
  17. OutputStreamWriter osr = new OutputStreamWriter(out);//输出
  18. //      OutputStreamWriter osr = new OutputStreamWriter(new FileOutputStream("D:\\demo.txt"));//综合到一句。
  19. BufferedWriter bufw = new BufferedWriter(osr);//缓冲
  20. //      int ch = 97;//a
  21. //      int ch = 20320;//你
  22. //      osr.write(ch);
  23. String str = "你好吗？\r\n我很好！";//你好吗？
  24. bufw.write(str);
  25. bufw.flush();
  26. bufw.close();
  27. }
  1. public static void transWriteNoBuf() throws IOException {
  2. OutputStream out = System.out;//打印到控制台
  3. //      OutputStream out = new FileOutputStream("D:\\demo.txt");//打印到文件
  4. OutputStreamWriter osr = new OutputStreamWriter(out);//输出
  5. //      OutputStreamWriter osr = new OutputStreamWriter(new FileOutputStream("D:\\demo.txt"));//两句可以综合到一句。
  6. //      int ch = 97;//a
  7. //      int ch = 20320;//你
  8. //      osr.write(ch);
  9. String str = "你好吗？";//你好吗？
  10. osr.write(str);
  11. osr.flush();
  12. osr.close();
  13. }
  14. public static void transWriteByBuf() throws IOException {
  15. //      OutputStream out = System.out;//打印到控制台。
  16. OutputStream out = new FileOutputStream("D:\\demo.txt");//打印到文件。
  17. OutputStreamWriter osr = new OutputStreamWriter(out);//输出
  18. //      OutputStreamWriter osr = new OutputStreamWriter(new FileOutputStream("D:\\demo.txt"));//综合到一句。
  19. BufferedWriter bufw = new BufferedWriter(osr);//缓冲
  20. //      int ch = 97;//a
  21. //      int ch = 20320;//你
  22. //      osr.write(ch);
  23. String str = "你好吗？\r\n我很好！";//你好吗？
  24. bufw.write(str);
  25. bufw.flush();
  26. bufw.close();
  27. }

 流转换程序1：

  1. package IOtest;
  2. import java.io.BufferedReader;
  3. import java.io.BufferedWriter;
  4. import java.io.FileInputStream;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  7. import java.io.InputStream;
  8. import java.io.InputStreamReader;
  9. import java.io.OutputStream;
  10. import java.io.OutputStreamWriter;
  11. public class TransStreamtest {
  12. /**
  13. * 主要的类：    in1,    InputStream
  14. *                      创建对象 InputStream in = System.in;
  15. *              in2,    InputStreamReader  没有readLine()方法
  16. *                      主要方法：
  17. *                          read()读取单个字符，一个汉字也为一个字符。
  18. *                          read(char[] cbuf)将字符读入数组。
  19. *                          close().关闭此流和相关联资源。
  20. *              in3,    BufferedReader     有read(),readLine()方法。
  21. *              out1,   OutputStream
  22. *                      创建对象 OutputStream in = System.out;
  23. *              out2,   OutputStreamWriter
  24. *                      主要方法：
  25. *                          write(int c)//写入单个字符。
  26. *                          write(char[] cbuf,int off,int len)//写入数组的某一部分
  27. *                          write(String str,int off,int len)//写入字符串烦人某一部分。
  28. *                          flush();//刷新该流中的缓冲。
  29. *                          close();
  30. *              out3,   BufferedWriteer     有Write(int ch),newLine()方法。
  31. *
  32. *
  33. * @throws IOException
  34. */
  35. public static void main(String[] args) throws IOException {
  36. //      transReadByBuf();
  37. //      transReadNoBuf();
  38. transWriteNoBuf();
  39. //      transWriteByBuf();
  40. }
  41. public static void transWriteNoBuf() throws IOException {
  42. OutputStream out = System.out;//打印到控制台
  43. //      OutputStream out = new FileOutputStream("D:\\demo.txt");//打印到文件
  44. OutputStreamWriter osr = new OutputStreamWriter(out);//输出
  45. //      OutputStreamWriter osr = new OutputStreamWriter(new FileOutputStream("D:\\demo.txt"));//两句可以综合到一句。
  46. //      int ch = 97;//a
  47. //      int ch = 20320;//你
  48. //      osr.write(ch);
  49. String str = "你好吗？";//你好吗？
  50. osr.write(str);
  51. osr.flush();
  52. osr.close();
  53. }
  54. public static void transWriteByBuf() throws IOException {
  55. //          OutputStream out = System.out;//打印到控制台。
  56. OutputStream out = new FileOutputStream("D:\\demo.txt");//打印到文件。
  57. OutputStreamWriter osr = new OutputStreamWriter(out);//输出
  58. //          OutputStreamWriter osr = new OutputStreamWriter(new FileOutputStream("D:\\demo.txt"));//综合到一句。
  59. BufferedWriter bufw = new BufferedWriter(osr);//缓冲
  60. //      int ch = 97;//a
  61. //      int ch = 20320;//你
  62. //      osr.write(ch);
  63. String str = "你好吗？\r\n我很好！";//你好吗？
  64. bufw.write(str);
  65. bufw.flush();
  66. bufw.close();
  67. }
  68. public static void transReadNoBuf() throws IOException {
  69. /**
  70. * 没有缓冲区，只能使用read()方法。
  71. */
  72. //读取字节流
  73. //      InputStream in = System.in;//读取键盘的输入。
  74. InputStream in = new FileInputStream("D:\\demo.txt");//读取文件的数据。
  75. //将字节流向字符流的转换。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节.
  76. InputStreamReader isr = new InputStreamReader(in);//读取
  77. //      InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\demo.txt"));//综合到一句。
  78. char []cha = new char[1024];
  79. int len = isr.read(cha);
  80. System.out.println(new String(cha,0,len));
  81. isr.close();
  82. }
  83. public static void transReadByBuf() throws IOException {
  84. /**
  85. * 使用缓冲区 可以使用缓冲区对象的 read() 和  readLine()方法。
  86. */
  87. //读取字节流
  88. //      InputStream in = System.in;//读取键盘上的数据
  89. InputStream in = new FileInputStream("D:\\demo.txt");//读取文件上的数据。
  90. //将字节流向字符流的转换。
  91. InputStreamReader isr = new InputStreamReader(in);//读取
  92. //创建字符流缓冲区
  93. BufferedReader bufr = new BufferedReader(isr);//缓冲
  94. //      BufferedReader bufr = new BufferedReader(new InputStreamReader(new FileInputStream("D:\\demo.txt")));可以综合到一句。
  95. /*  int ch =0;
  96. ch = bufr.read();
  97. System.out.println((char)ch);*/
  98. String line = null;
  99. while((line = bufr.readLine())!=null){
  100. System.out.println(line);
  101. }
  102. isr.close();
  103. }
  104. }
  1. package IOtest;
  2. import java.io.BufferedReader;
  3. import java.io.BufferedWriter;
  4. import java.io.FileInputStream;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  7. import java.io.InputStream;
  8. import java.io.InputStreamReader;
  9. import java.io.OutputStream;
  10. import java.io.OutputStreamWriter;
  11. public class TransStreamtest {
  12. /**
  13. * 主要的类：    in1,    InputStream
  14. *                      创建对象 InputStream in = System.in;
  15. *              in2,    InputStreamReader  没有readLine()方法
  16. *                      主要方法：
  17. *                          read()读取单个字符，一个汉字也为一个字符。
  18. *                          read(char[] cbuf)将字符读入数组。
  19. *                          close().关闭此流和相关联资源。
  20. *              in3,    BufferedReader     有read(),readLine()方法。
  21. *              out1,   OutputStream
  22. *                      创建对象 OutputStream in = System.out;
  23. *              out2,   OutputStreamWriter
  24. *                      主要方法：
  25. *                          write(int c)//写入单个字符。
  26. *                          write(char[] cbuf,int off,int len)//写入数组的某一部分
  27. *                          write(String str,int off,int len)//写入字符串烦人某一部分。
  28. *                          flush();//刷新该流中的缓冲。
  29. *                          close();
  30. *              out3,   BufferedWriteer     有Write(int ch),newLine()方法。
  31. *
  32. *
  33. * @throws IOException
  34. */
  35. public static void main(String[] args) throws IOException {
  36. //      transReadByBuf();
  37. //      transReadNoBuf();
  38. transWriteNoBuf();
  39. //      transWriteByBuf();
  40. }
  41. public static void transWriteNoBuf() throws IOException {
  42. OutputStream out = System.out;//打印到控制台
  43. //      OutputStream out = new FileOutputStream("D:\\demo.txt");//打印到文件
  44. OutputStreamWriter osr = new OutputStreamWriter(out);//输出
  45. //      OutputStreamWriter osr = new OutputStreamWriter(new FileOutputStream("D:\\demo.txt"));//两句可以综合到一句。
  46. //      int ch = 97;//a
  47. //      int ch = 20320;//你
  48. //      osr.write(ch);
  49. String str = "你好吗？";//你好吗？
  50. osr.write(str);
  51. osr.flush();
  52. osr.close();
  53. }
  54. public static void transWriteByBuf() throws IOException {
  55. //          OutputStream out = System.out;//打印到控制台。
  56. OutputStream out = new FileOutputStream("D:\\demo.txt");//打印到文件。
  57. OutputStreamWriter osr = new OutputStreamWriter(out);//输出
  58. //          OutputStreamWriter osr = new OutputStreamWriter(new FileOutputStream("D:\\demo.txt"));//综合到一句。
  59. BufferedWriter bufw = new BufferedWriter(osr);//缓冲
  60. //      int ch = 97;//a
  61. //      int ch = 20320;//你
  62. //      osr.write(ch);
  63. String str = "你好吗？\r\n我很好！";//你好吗？
  64. bufw.write(str);
  65. bufw.flush();
  66. bufw.close();
  67. }
  68. public static void transReadNoBuf() throws IOException {
  69. /**
  70. * 没有缓冲区，只能使用read()方法。
  71. */
  72. //读取字节流
  73. //      InputStream in = System.in;//读取键盘的输入。
  74. InputStream in = new FileInputStream("D:\\demo.txt");//读取文件的数据。
  75. //将字节流向字符流的转换。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节.
  76. InputStreamReader isr = new InputStreamReader(in);//读取
  77. //      InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\demo.txt"));//综合到一句。
  78. char []cha = new char[1024];
  79. int len = isr.read(cha);
  80. System.out.println(new String(cha,0,len));
  81. isr.close();
  82. }
  83. public static void transReadByBuf() throws IOException {
  84. /**
  85. * 使用缓冲区 可以使用缓冲区对象的 read() 和  readLine()方法。
  86. */
  87. //读取字节流
  88. //      InputStream in = System.in;//读取键盘上的数据
  89. InputStream in = new FileInputStream("D:\\demo.txt");//读取文件上的数据。
  90. //将字节流向字符流的转换。
  91. InputStreamReader isr = new InputStreamReader(in);//读取
  92. //创建字符流缓冲区
  93. BufferedReader bufr = new BufferedReader(isr);//缓冲
  94. //      BufferedReader bufr = new BufferedReader(new InputStreamReader(new FileInputStream("D:\\demo.txt")));可以综合到一句。
  95. /*  int ch =0;
  96. ch = bufr.read();
  97. System.out.println((char)ch);*/
  98. String line = null;
  99. while((line = bufr.readLine())!=null){
  100. System.out.println(line);
  101. }
  102. isr.close();
  103. }
  104. }

 流转换程序2：

  1. package readKey;
  2. import java.io.FileInputStream;
  3. import java.io.FileOutputStream;
  4. import java.io.FileReader;
  5. import java.io.FileWriter;
  6. import java.io.IOException;
  7. import java.io.InputStreamReader;
  8. import java.io.OutputStreamWriter;
  9. public class TransStreamDemo3 {
  10. /**
  11. * @param args
  12. * @throws IOException
  13. */
  14. public static void main(String[] args) throws IOException {
  15. //      writeText_1();
  16. //      writeText_2();
  17. //      writeText_3();
  18. //      ReadTest_1();
  19. //      ReadTest_2();
  20. //      ReadTest_3();
  21. }
  22. public static void ReadTest_3() throws IOException {
  23. InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\utf-8.txt"),"UTF-8");
  24. char []ch = new char[20];
  25. int len = isr.read(ch);
  26. System.out.println(new String(ch,0,len) );
  27. isr.close();
  28. }
  29. public static void ReadTest_2() throws IOException {
  30. InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\utf-8.txt"),"GBK");
  31. char []ch = new char[20];
  32. int len = isr.read(ch);
  33. System.out.println(new String(ch,0,len) );
  34. isr.close();
  35. }
  36. public static void ReadTest_1() throws IOException {
  37. FileReader fr = new FileReader("D:\\demo.txt");
  38. char []ch = new char[20];
  39. int len = fr.read(ch);
  40. System.out.println(new String(ch,0,len) );
  41. fr.close();
  42. }
  43. public static void writeText_3() throws IOException {
  44. OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\utf-8.txt"),"UTF-8");
  45. osw.write("你好吗");
  46. osw.close();
  47. }
  48. public static void writeText_2() throws IOException {
  49. FileWriter fw = new FileWriter("D:\\gbk1.txt");
  50. fw.write("你好啊");
  51. fw.close();
  52. }
  53. public static void writeText_1() throws IOException {
  54. OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\gbk.txt"),"GBK");
  55. /*
  56. *和上面的等同
  57. * FileWriter fw = new FileWriter("D:\\gbk1.txt");
  58. * 操作文件的字节流 + 默认的编码表
  59. */
  60. osw.write("你好吗");
  61. osw.close();
  62. }
  63. }

I/O流之--转换流：InputStreamReader 和InputStreamWriter的更多相关文章

  1. Java IO流之转换流

    一.转换流 1.在IO包中,实际上就是分为字节流和字符流,但是除了这两个流之外,还存在了一组字节流-字符流的转换流 2.转换流用于在字节流和字符流之间转换 3.转换流本身是字符流 二.两种转换流 Ou ...

  2. 我爱Java系列之《JavaEE学习笔记day12》---【缓冲流、转换流、序列/反序列化流、打印流】

    [缓冲流.转换流.序列/反序列化流.打印流] 一.缓冲流 1.字节缓冲输出流 java.io.BufferedOutputStream extends OutputStream 高效字节输出流 写入文 ...

  3. Java-IO流之转换流的使用和编码与解码原理

    一.理论: 1.字符流和字节流区别是什么? 字符流=字节流+编码集,在实际读取的时候其实字符流还是按照字节来读取,但是会更具编码集进行查找编码集字典解析相应的字节,使得一次读取出一个字符: 2.什么是 ...

  4. 10缓冲流、转换流、序列化流、Files

    十.流 10.1 缓冲流 10.1.1 概述                 缓冲流是对4个基本的FileXxx流的增强,所以也是4个流,按照数据类型进行分类                     ...

  5. IO流之转换流

    转换流 OutputStreamWriter类 查阅OutputStreamWriter的API介绍,OutputStreamWriter 是字符流通向字节流的桥梁:可使用指定的字符编码表,将要写入流 ...

  6. javaSE学习笔记（15） ---缓冲流、转换流、序列化流

    javaSE学习笔记(15) ---缓冲流.转换流.序列化流 缓冲流 昨天复习了基本的一些流,作为IO流的入门,今天我们要见识一些更强大的流.比如能够高效读写的缓冲流,能够转换编码的转换流,能够持久化 ...

  7. 01 语言基础+高级：1-8 File类与IO流_day10【缓冲流、转换流、序列化流】

    day10[缓冲流.转换流.序列化流] 主要内容 缓冲流 转换流 序列化流 打印流 教学目标 能够使用字节缓冲流读取数据到程序 能够使用字节缓冲流写出数据到文件 能够明确字符缓冲流的作用和基本用法 能 ...

  8. java ->IO流_转换流

    转换流 在学习字符流(FileReader.FileWriter)的时候,其中说如果需要指定编码和缓冲区大小时,可以在字节流的基础上,构造一个InputStreamReader或者OutputStre ...

  9. 383 day10缓冲流、转换流、序列化流

    day10[缓冲流.转换流.序列化流] 主要内容 缓冲流 转换流 序列化流 打印流 教学目标 [ ] 能够使用字节缓冲流读取数据到程序 [ ] 能够使用字节缓冲流写出数据到文件 [ ] 能够明确字符缓 ...

随机推荐

  1. Linux学习第六天

    学习Linux环境下的挂载命令. 什么是挂载命令? 1.Windows下,mount挂载,就是给磁盘分区提供一个盘符(C,D,E,...).比如插入U盘后系统自动分配给了它I:盘符其实就是挂载,退优盘 ...

  2. Nginx 入门及基本命令行操作

    Nginx 介绍 Nginx 是一个高性能的 Web 服务器,从 2001 年发展至今,由于 Nginx 对硬件和操作系统内核特性的深度挖掘,使得在保持高并发的同时还能够保持高吞吐量.Nginx 还采 ...

  3. java虚拟机学习记录（内存划分、垃圾回收、类加载等机制）

    一直以来觉得虚拟机是Java最难的一部分,涉及最底层的原理,学起来难度很大,而且工作中基本上用不到这些原理,所以对这部分“敬而远之”.现如今工作五年了,从Java基础到算法.数据结构.网络.数据库.设 ...

  4. Journal of Proteome Research | 人类牙槽骨蛋白的蛋白质组学和n端分析:改进的蛋白质提取方法和LysargiNase消化策略增加了蛋白质组的覆盖率和缺失蛋白的识别 | (解读人：卜繁宇)

    文献名:Proteomic and N-Terminomic TAILS Analyses of Human Alveolar Bone Proteins: Improved Protein Extr ...

  5. javaweb_HTML

    第一章:网页的构成 1.1概念:b/s与c/s 1.1.1 现在的软件开发的整体架构主要分为B/S架构与C/S架构: b/s:浏览器/服务器 c/s:客户端/服务器 客户端:需要安装在系统里,才可使用 ...

  6. Redis 【常识与进阶】

    Redis 简介 Redis 是完全开源免费的,遵守BSD协议,是一个高性能的key-value数据库. Redis 与其他 key - value 缓存产品有以下三个特点: Redis支持数据的持久 ...

  7. 图解Java设计模式之模板模式

    图解Java设计模式之模板模式 豆浆制作问题 模板方法模式基本介绍 模板方法模式原理类图 模板方法模式解决豆浆制作问题 模板方法模式的钩子方法 模板方法模式在Spring框架中的源码分析 模板方法模式 ...

  8. dfs 例题皇后问题

    题目描述 一个如下的 6 \times 66×6 的跳棋棋盘,有六个棋子被放置在棋盘上,使得每行.每列有且只有一个,每条对角线(包括两条主对角线的所有平行线)上至多有一个棋子. 上面的布局可以用序列  ...

  9. IdentityServer4源码解析_4_令牌发放接口

    目录 identityserver4源码解析_1_项目结构 identityserver4源码解析_2_元数据接口 identityserver4源码解析_3_认证接口 identityserver4 ...

  10. 图-最短路-dijkstra-0/1BFS-1368. 使网格图至少有一条有效路径的最小代价

    2020-03-01 22:59:59 问题描述: 给你一个 m x n 的网格图 grid . grid 中每个格子都有一个数字,对应着从该格子出发下一步走的方向. grid[i][j] 中的数字可 ...