Java 笔记（01）之 FileReader FileInputStream InputStreamReader BufferedReader 作用与区别

最新推荐文章于 2024-04-24 22:50:14 发布
最新推荐文章于 2024-04-24 22:50:14 发布
阅读量2.1k 收藏 15
点赞数 3
分类专栏： Java学习线索 文章标签： 字符流 java string class
ava.io下面有两个抽象类：InputStream和Reader
InputStream是表示字节输入流的所有类的超类
Reader是用于读取字符流的抽象类
InputStream提供的是字节流的读取，而非文本读取，这是和Reader类的根本区别。
即用Reader读取出来的是char数组或者String ，使用InputStream读取出来的是byte数组。
弄清了两个超类的根本区别，再来看他们底下子类的使用，这里只对最常用的几个说明

InputStream 
   | __FileInputStream 


FileInputStream 从文件系统中的某个文件中获得输入字节。
构造方法摘要  
FileInputStream (File  file) 
          通过打开一个到实际文件的连接来创建一个 FileInputStream ，该文件通过文件系统中的 File 对象 file 指定。 
FileInputStream (FileDescriptor  fdObj) 
          通过使用文件描述符 fdObj 创建一个 FileInputStream ，该文件描述符表示到文件系统中某个实际文件的现有连接。 
FileInputStream (String  name) 
          通过打开一个到实际文件的连接来创建一个 FileInputStream ，该文件通过文件系统中的路径名 name 指定。 
 
 
Reader

   |——BufferedReader 
   |___InputStreamReader 
         |__FileReader 


BufferedReader : 从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
 
构造方法摘要  
BufferedReader (Reader  in) 
          创建一个使用默认大小输入缓冲区的缓冲字符输入流。 
BufferedReader (Reader  in, int sz) 
          创建一个使用指定大小输入缓冲区的缓冲字符输入流。 
BufferedReader (Java Platform SE 6) 
BufferedReader的最大特点就是缓冲区的设置。通常Reader 所作的每个读取请求都会导致对底层字符或字节流进行相应的读取请求， 如果没有缓冲，则每次调用 read() 或 readLine() 都会导致从文件中读取字节，并将其转换为字符后返回，而这是极其低效的。  
使用BufferedReader可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。 
因此，建议用 BufferedReader 包装所有其 read() 操作可能开销很高的 Reader（如 FileReader 和InputStreamReader）。例如， 
 BufferedReader in
   = new BufferedReader(new FileReader("foo.in"));
 将缓冲指定文件的输入。 
InputStreamReader (Java Platform SE 6) 
InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。 
 
构造方法摘要  
InputStreamReader (InputStream  in) 
          创建一个使用默认字符集的 InputStreamReader。 
InputStreamReader (InputStream  in, Charset  cs) 
          创建使用给定字符集的 InputStreamReader。 
InputStreamReader (InputStream  in, CharsetDecoder  dec) 
          创建使用给定字符集解码器的 InputStreamReader。 
InputStreamReader (InputStream  in, String  charsetName) 
          创建使用指定字符集的 InputStreamReader。 
 
每次调用 InputStreamReader 中的一个 read() 方法都会导致从底层输入流读取一个或多个字节。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节，使其超过满足当前读取操作所需的字节。 
为了达到最高效率，可要考虑在 BufferedReader 内包装 InputStreamReader。例如： 
 BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
InputStreamReader最大的特点是可以指转换的定编码格式
，这是其他类所不能的，从构造方法就可看出，
这一点在读取中文字符时非常有用

FileReader
1）FileReader类介绍：
InputStreamReader类的子类，所有方法（read（）等）都从父类InputStreamReader中继承而来；
2）与InputStreamReader类的区别：
构造方法摘要  
FileReader (File  file) 
          在给定从中读取数据的 File 的情况下创建一个新 FileReader 。 
FileReader (FileDescriptor  fd) 
          在给定从中读取数据的 FileDescriptor 的情况下创建一个新 FileReader 。 
FileReader (String  fileName) 
          在给定从中读取数据的文件名的情况下创建一个新 FileReader  

该类与它的父类InputStreamReader的主要不同在于构造函数，主要区别也就在于构造函数！
从InputStreamReader的构造函数中看到，参数为InputStream和编码方式，可以看出，
当要指定编码方式时，必须使用InputStreamReader
类；而FileReader构造函数的参数与FileInputStream同，为File对象或表示path的String，可以看出，当要根据File对象或者String读取一个文件时，用FileReader；
我想FileReader子类的作用也就在于这个小分工吧。该类与它的父类InputStreamReader
的主要不同在于构造函数，主要区别也就在于构造函数！
从InputStreamReader
的构造函数中看到，参数为InputStream和编码方式，可以看出，
当要指定编码方式时，必须使用InputStreamReader
类；而FileReader构造函数的参数与FileInputStream
同，为File对象或表示path的String，可以看出，当要根据File对象或者String读取一个文件时，用FileReader；
我想FileReader子类的作用也就在于这个小分工吧。
二 联系与区别 
（1）字符与字节： 
FileInputStream 类以二进制输入/输出，I/O速度快且效率搞，但是它的read（）方法读到的是一个字节（二进制数据），很不利于人们阅读，而且无法直接对文件中的字符进行操作，比如替换，查找（必须以字节形式操作）；
而Reader类弥补了这个缺陷，可以以文本格式输入/输出，非常方便；比如可以使用while((ch = filereader.read())!=-1 )循环来读取文件；可以使用BufferedReader的readLine()方法一行一行的读取文本。
（2）编码
InputStreamReader ，它是字节转换为字符的桥梁。 你可以在构造器重指定编码的方式，如果不指定的话将采用底层操作系统的默认编码方式，例如GBK等。 
FileReader与InputStreamReader 涉及编码转换(指定编码方式或者采用os默认编码)，可能在不同的平台上出现乱码现象！而FileInputStream 以二进制方式处理，不会出现乱码现象. 
因此要指定编码方式时，必须使用InputStreamReader 类，所以说它是字节转换为字符的桥梁；
(3) 缓存区
    BufferReader类用来包装所有其 read() 操作可能开销很高的 Reader（如 FileReader 和InputStreamReader）。
（4）规范用法
总结以上内容，得出比较好的规范用法： 
1） File file = new File ("hello.txt"); 
FileInputStream in=new FileInputStream (file); 
2） File file = new File ("hello.txt"); 
FileInputStream in=new FileInputStream (file); 
InputStreamReader inReader=new InputStreamReader (in,"UTF-8"); 
BufferedReader bufReader=new BufferedReader(inReader); 
3） File file = new File ("hello.txt"); 
FileReader fileReader=new FileReader(file); 

BufferedReader bufReader=new BufferedReader(fileReader);


一、BufferedReader类

. 所属类库：

         java.lang.Object  

              java.io.Reader  

                         java.io.BufferedReader

. 基本概念 ：

           public class BufferedReader    extends Reader

从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值足够大。

通常， Reader 所作的每个读取请求都会导致对底层字符或字节流进行相应的读取请求。因此，建议用 BufferedReader 包装所有其 read() 操作可能开销很高的 Reader（如 FileReader 和 InputStreamReader ）。

BufferedReader 流能够读取文本行 , 通过向 BufferedReader 传递一个 Reader 对象, 来创建一个 BufferedReader 对象 , 之所以这样做是因为 FileReader 没有提供读取文本行的功能 .

. Demo ：

通过 Bufferedreader 捕获所输入的语句 ：

import java.io.*;
class BufferedReaderDemo{
  public static void main(String[] args)throws IOException { 
    BufferedReader bufferedReader =new BufferedReader(
        new InputStreamReader(System.in));
 
    System.out.print("请输入一系列文字，可包括空格："); 
    String text =bufferedReader.readLine(); 
    System.out.println("请输入文字："+text);
  } 
}
  
注解：

throws IOException   抛出异常

InputStreamReader 是字节流通向字符流的桥梁

二、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);//将读取到的字符存到数组中。返回读取的字符数。

. Demo ：

import java.io.*;
class InputStreamReaderDemo {
  public static void transReadNoBuf() throws IOException {
    /**
     * 没有缓冲区，只能使用read()方法。
     */
    //读取字节流
    //InputStream in = System.in;//读取键盘的输入。
    InputStream in = new FileInputStream("D:\\demo.txt");//读取文件的数据。
    //将字节流向字符流的转换。要启用从字节到字符的有效转换，
    //可以提前从底层流读取更多的字节.
    InputStreamReader isr = new InputStreamReader(in);//读取
    //综合到一句。
    //InputStreamReader isr = new InputStreamReader(
    //new FileInputStream("D:\\demo.txt"));
      
    char []cha = new char[1024];
    int len = isr.read(cha);
    System.out.println(new String(cha,0,len));
    isr.close();

  }
  public static void transReadByBuf() throws IOException {
    /**
     * 使用缓冲区 可以使用缓冲区对象的 read() 和  readLine()方法。
     */
    //读取字节流
    //InputStream in = System.in;//读取键盘上的数据
    InputStream in = new FileInputStream("D:\\demo.txt");//读取文件上的数据。
    //将字节流向字符流的转换。
    InputStreamReader isr = new InputStreamReader(in);//读取
    //创建字符流缓冲区
    BufferedReader bufr = new BufferedReader(isr);//缓冲
    //BufferedReader bufr = new BufferedReader(
    //new InputStreamReader(new FileInputStream("D:\\demo.txt")));可以综合到一句。
      /*int ch =0;
    ch = bufr.read();
    System.out.println((char)ch);
    */
    String line;
    while((line = bufr.readLine())!=null){
      System.out.println(line);
    }
    isr.close();
  }
}

三、InputStreamReader、BufferedReader真实案例（非编码集）

import java.io.*;
class UtilResource {
  private void initializeResource() {
    try {

      //读取文件，并且以utf-8的形式写出去
      BufferedReader bufread;
      String read;
      bufread = new BufferedReader(new InputStreamReader(ResourceHelper
          .getResourceInputStream("pinyin.txt")));
      while ((read = bufread.readLine()) != null) {
        System.out.println(read);
      }
      bufread.close();
    } catch (FileNotFoundException ex) {
      ex.printStackTrace();
    } catch (IOException ex) {
      ex.printStackTrace();
    }
  }
}

注：其中 pinyin.txt 放于项目的根目录下 

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
class ResourceHelper {
  /**
   * @param resourceName
   * @return 
   * @return 
   */
  static BufferedInputStream getResourceInputStream(String resourceName) {
    try {
      return new BufferedInputStream(new FileInputStream(resourceName));
    } catch (FileNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    return null;
  }
}

.InputStream、OutputStream

处理字节流的抽象类

InputStream 是字节输入流的所有类的超类,一般我们使用它的子类,如FileInputStream等.

OutputStream是字节输出流的所有类的超类,一般我们使用它的子类,如FileOutputStream等.

2.InputStreamReader  OutputStreamWriter

处理字符流的抽象类

InputStreamReader 是字节流通向字符流的桥梁,它将字节流转换为字符流.

OutputStreamWriter是字符流通向字节流的桥梁，它将字符流转换为字节流.

3.BufferedReader BufferedWriter

BufferedReader 由Reader类扩展而来，提供通用的缓冲方式文本读取，readLine读取一个文本行，

从字符输入流中读取文本，缓冲各个字符，从而提供字符、数组和行的高效读取。

BufferedWriter  由Writer 类扩展而来，提供通用的缓冲方式文本写入， newLine使用平台自己的行分隔符，

将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

InputStream能从來源处读取一個一個byte,
所以它是最低级的，
例：

[java]  view plain copy
  1. import java.io.*;    
  2. public class Main {    
  3.     public static void main(String[] args) {    
  4.             
  5.         try {    
  6.             FileInputStream fis=new FileInputStream("d://desktop//test.txt");    
  7.             int i;    
  8.                 
  9.             try {    
  10.                 while((i=fis.read()) != -1){    
  11.                     System.out.println(i);    
  12.                 }    
  13.                 /*假設test.txt檔裡頭只有一個文字 "陳" ,且其編碼為 utf8 
  14.                  * 輸出 
  15.                  *  233 
  16.                     153 
  17.                     179 
  18.                  */   
  19.             } catch (IOException e) {    
  20.                 // TODO Auto-generated catch block    
  21.                 e.printStackTrace();    
  22.             }    
  23.                 
  24.                 
  25.         } catch (FileNotFoundException e) {    
  26.             // TODO Auto-generated catch block    
  27.             e.printStackTrace();    
  28.         }    
  29.                     
  30.     }    
  31. }  

[java]  view plain  copy
  1. import java.io.*;     
  2. public class Main {     
  3.     public static void main(String[] args) {     
  4.              
  5.         try {     
  6.             FileInputStream fis=new FileInputStream("d://desktop//test.txt");     
  7.             int i;     
  8.                  
  9.             try {     
  10.                 while((i=fis.read()) != -1){     
  11.                     System.out.println(i);     
  12.                 }     
  13.                 /*假設test.txt檔裡頭只有一個文字 "陳" ,且其編碼為 utf8   
  14.                  * 輸出   
  15.                  *  233   
  16.                     153   
  17.                     179   
  18.                  */    
  19.             } catch (IOException e) {     
  20.                 // TODO Auto-generated catch block     
  21.                 e.printStackTrace();     
  22.             }     
  23.                  
  24.                  
  25.         } catch (FileNotFoundException e) {     
  26.             // TODO Auto-generated catch block     
  27.             e.printStackTrace();     
  28.         }     
  29.                      
  30.     }     
  31. }   

InputStreamReader
InputStreamReader封裝了InputStream在里头,
它以较高级的方式,一次读取一个一个字符,
下例是假设有一个编码为utf8的文档,
其內容只有一个中文字 "陳"

[java]  view plain copy
  1. import java.io.*;    
  2. public class Main {    
  3.     public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {    
  4.                     
  5.             FileInputStream fis=new FileInputStream("d://desktop//test.txt");    
  6.             try {    
  7.                 InputStreamReader isr=new InputStreamReader(fis,"utf8");    
  8.                 int i;    
  9.                 while((i=isr.read()) != -1){    
  10.                     System.out.println((char)i);  //輸出  陳    
  11.                 }    
  12.             } catch (Exception e) {    
  13.                 // TODO Auto-generated catch block    
  14.                 e.printStackTrace();    
  15.             }                                           
  16.                     
  17.     }    
  18. }   

[java]  view plain  copy
  1. import java.io.*;     
  2. public class Main {     
  3.     public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {     
  4.                      
  5.             FileInputStream fis=new FileInputStream("d://desktop//test.txt");     
  6.             try {     
  7.                 InputStreamReader isr=new InputStreamReader(fis,"utf8");     
  8.                 int i;     
  9.                 while((i=isr.read()) != -1){     
  10.                     System.out.println((char)i);  //輸出  陳     
  11.                 }     
  12.             } catch (Exception e) {     
  13.                 // TODO Auto-generated catch block     
  14.                 e.printStackTrace();     
  15.             }                                            
  16.                      
  17.     }     
  18. }    

BufferedReader
BufferedReader则是比InputStreamReader更高级,
它封裝了StreamReader类,
一次读取取一行的字符

[java]  view plain copy print ?
  1. import java.io.*;    
  2. public class Main {    
  3.     public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {    
  4.                     
  5.             FileInputStream fis=new FileInputStream("d://desktop//test.txt");    
  6.                 
  7.             try {    
  8.                 InputStreamReader isr=new InputStreamReader(fis,"utf8");                    
  9.                 BufferedReader br=new BufferedReader(isr);    
  10.                     
  11.                 String line;    
  12.                 while((line=br.readLine()) != null){    
  13.                     System.out.println(line);    
  14.                 }    
  15.             } catch (Exception e) {    
  16.                 // TODO Auto-generated catch block    
  17.                 e.printStackTrace();    
  18.             }                                           
  19.                     
  20.     }    
  21. }   

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

12.4  转换流--OutputStreamWriter类与InputStreamReader类

整个IO包实际上分为字节流和字符流，但是除了这两个流之外，还存在一组字节流-字符流的转换类。

OutputStreamWriter：是Writer的子类，将输出的字符流变为字节流，即将一个字符流的输出对象变为字节流输出对象。

InputStreamReader：是Reader的子类，将输入的字节流变为字符流，即将一个字节流的输入对象变为字符流的输入对象。

如果以文件操作为例，则内存中的字符数据需要通过OutputStreamWriter变为字节流才能保存在文件中，读取时需要将读入的字节流通过InputStreamReader变为字符流，转换步骤如图12-7所示。

 

（点击查看大图）图12-7  转换步骤

从图12-7中可以清楚地发现，不管如何操作，最终全部是以字节的形式保存在文件中。



chenzxapple
关注
  • 3
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaIO流精讲上
06-29
本阶段课程是《零基础学Java》课程第10阶段的课程内容，本阶段主要讲解了JAVA IO流章节的知识点。该课程延续了之前课程的授课风格！内容经过精心雕琢，细致设计，能够做到讲解深入浅出、通俗易懂！可以真正让学员学有所获！课程内容主要有：File类概述、File类功能讲解、JAVA IO流概述、字节流、字符流、缓冲流、InputStream、OutputStream、Reader、Writer、FileInputStream、FileOutputStream、InputStreamReader、OutputStreamWriter、FileReader、FileWriter、BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter的讲解。
java.io 包 File、InputStream、OutputStream、Reader、Writer
lercent的博客
06-24 486
1. File类 构造函数： File(File parent, String child) 根据父抽象路径名和子路径名字符串创建一个新的File实例。 File(String pathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。 File(String parent, String child) 根据父路径名字符串和子路径名字符串创建一个新的File实例。 File API： boolean exists() 测试此抽象路径名表示的文件或目录是否存在。 boolean
BufferedReader与FileReader及FileInputStream
xuanzeticai的专栏
07-02 697
BufferedReader 是缓冲字符输入流。它继承于Reader。 BufferedReader 的作用是为其他字符输入流添加一些缓冲功能。
Java 基础 InputStreamReader介绍&代码实现
毛毛虫会长大
04-04 855
package demo6; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStreamReader; /* * java.io.InputStreamReader extends Reader * InputStreamReader:是字节流向字符流的桥梁，它使用指定的cha...
Java读取文件-BufferedReader/FileReader/InputStreamReader/FileInputStream的关系和区别
初来乍到
06-10 1367
一、Java读取和存储文件数据流 Java读取文件，实际是将文件中的字节流转换成字符流输出到屏幕的过程 这里面涉及到两个类：InputStreamReader和OutputStreamWriter InputStreamReader：将字节流转换成字符流 OutputStreamWriter：将字符流转换成字节流 InputStreamReader继承Reader类 OutputStreamWriter继承Writer类 二、BufferedReader/FileRead...
JAVA基础知识之InputStreamReader流
热门推荐
咕噜是个胖子
07-20 11万+
一、InputStreamReader类     API文档说明：InputStreamReader类是从字节流到字符流的桥接器：它使用指定的字符集读取字节并将它们解码为字符。 它使用的字符集可以通过名称指定，也可以明确指定，或者可以接受平台的默认字符集。每次调用一个InputStreamReader的read（）方法都可能导致从底层字节输入流中读取一个或多个字节。 为了实现字节到字符的有效转换...
InputStreamReader的使用 [Java]
m0_57001006的博客
12-31 2798
InputStreamReader的使用 InputStream就是将字节输入流转换为字符输入流 也就相当于进行了一个解码 这里我们通过一个例子来理解InputStreamReader的使用 package IO流.转换流; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStreamReader; public class Demo { public static void ma
InputStreamReader介绍&使用
weixin_44664432的博客
09-16 1万+
InputStreamReader类： java.io.InputStreamReader extends Reader InputStreamReader:是字节流通向字符流的桥梁：他使用指定的charset读取字节并将其解码为字符。(解码：把看不懂的变为能看懂的) 继承自父类的共性成员方法： int read() 读取单个字符并返回 int read(char[] cbuf) 一次读取多个字符，经字符读入数组中 void close() 关闭该流并释放与之关联的所有资源 构造方
java InputStreamReader
笔生花的博客
04-23 859
java底层从计算机读取的统统都是二进制，所以一开始我们读取的时候都是先简历连接通道，然后将文件数据以字节流的形式读取进入通道。 #建立连接 File file =new File("a.txt"); #二进制流的通道。 FileInputStream fileInputStream = new FileInputStream(file); #你想啊，fileInputStr...
InputStreamReader的使用
兴趣是最好的老师
03-14 6674
package csdn.java3; import org.junit.Test; import java.io.*; /** * 处理流之二：转换流的使用 * 1.转换流：属于字符流 * InputStreamReader：将一个字节的输入流转换为字符的输入流 * OutputStreamWriter：将一个字符的输出流转换为字节的输出流 * * 2.作用：提供字节...
Java文件读写操作函数实现
04-27
* ,来创建一个BufferedReader对象,之所以这样做是因为FileReader没有提供读取文本行的功能. * * 二、InputStreamReader类 * * InputStreamReader 将字节流转换为字符流。是字节流通向字符流的桥梁。如果不...
JAVA IO流缓冲字节流缓冲字符流等流经典代码示例加注释总结.rar
11-30
FileWriter、FileReader、CharArrayReader、CharArrayWriter、CharSequence、OutputStreamWriter、FileOutputStream、InputStreamReader、PrintWriter、BufferedReader、InputStream、FileInputStream、OutputStream...
跟汤老师学Java（第15季）：I/O输入输出流
06-13
 Reader：FileReader、BufferedReader、InputStreamReader  Writer：FileWriter、BufferedWriter / PrintWriter、OutputStreamWriter 6.随机读写流  RandomAccessFile 教学全程采用笔记+代码案例的形式讲解，...
java编程基础,应用与实例
04-11
13.2.2　FileInputStream类与FileOutputStream类　184 13.3　filter stream　186 13.4　字符流(character streams)　190 13.4.1　InputStreamReader、OutputStreamWriter　191 13.4.2　BufferedReader与...
string模拟实现
m0_73969414的博客
04-23 1204
c++中string的模拟实现，面试必会知识点
【1524】java投票管理系统Myeclipse开发mysql数据库web结构java编程计算机网页项目
qq_251836457的博客
04-18 940
2、开发环境为TOMCAT7.0,Myeclipse8.5开发，数据库为Mysql5.0，使用java语言开发。(5)投票选项管理：对投票选项信息进行添加、删除、修改和查看。(6)投票记录管理：对投票记录信息进行添加、删除、修改和查看。(1)管理员管理：对管理员信息进行添加、删除、修改和查看。(2)用户管理：对用户信息进行添加、删除、修改和查看。(3)公告管理：对公告信息进行添加、删除、修改和查看。(4)投票管理：对投票信息进行添加、删除、修改和查看。4）投票浏览查看、查看投票、投票记录。
javaweb-SpringBoot基础
kussm_的博客
04-20 1143
Spring的官网(Spring的简介：Spring makes Java simple。Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。创建一个子包controller。
MSE实现全链路灰度实践
最新发布
云计算、数据库、大数据、深度学习、NLP、Python
04-24 132
待更新。
Web前端 Javascript笔记5
cycyzh的博客
04-18 1010
script>'console.log("哈哈哈佳人们好困")'}, 3000)​let t1 = setTimeout('console.log("你们看到这句话的时候我早已身价百万！！")', 4000)​</script>3秒，四秒后出来的东西，出现前会返回计时器编号。
FileInputStream InputStreamReader
08-19
- *2* [Java 之 FileReader FileInputStream InputStreamReader BufferedReader 作用与区别](https://blog.csdn.net/qq_35203425/article/details/84893708)[target="_blank" data-report-click={"spm":"1018.2226....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值