day20_io流02(字符流-转换流-对象操作流-Properities集合)

最新推荐文章于 2024-07-18 16:29:57 发布
最新推荐文章于 2024-07-18 16:29:57 发布
阅读量63 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42929213/article/details/128474218
版权

文章目录

1、字符流

1.1、为什么会出现字符流

  • 字符流介绍
    • 由于字节流操作中文不是特别的方便，所以Java就提供字符流
    • 字符流=字节流+编码表
  • 中文的字节存储方式
    • 用字节流复制文本文件时，文本文件也会有中文，但是没有问题，原因是最终底层操作会自动进行字节拼接成中文，如何识别是中文的呢？
    • 汉字在存储的时候，无论选择哪种编码存储，第一个字节都是负数

1.2、编码表

  • 什么是字符集
    • 是一个系统支持的所有字符的集合，包括各国文字、标点符号 、图形符号、数字等
    • 计算机要准确的存储和识别各种字符集符号，就需要进行字符编码，一套字符集必然至少有一套字符编码。
    • 常见的字符集有ASCII字符集、GBXXX字符集、Unicode字符集等
  • 常见的字符集
    • ASCII字符集：
      • ASCII：是基于拉丁字母的一套电脑编码系统，用于显式现代英语，主要包括控制字符（回车键、退格、换行键等）和可显式字符（英文大小写字符、阿拉伯数字和西文符号）
      • 基本的ASCII字符集，使用7位表示一个字符，共128字符。ASCII的扩展字符集使用8位表示一个字符，共256字符，方便支持欧洲常用字符。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等
    • GBXXX字符集
      • GBK：最常用的中文码表。是在GB2312标注基础上的扩展规范，使用了双字节编码方案，共收录了12003个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等
    • Unicode字符集：
      • UTF-8编码：可以用来表示Unicode标注中任意字符，他是电子邮件、网页及其他存储或传送文字的应用中，优先采用的编码，互联网工程工作小组（IETF）要求所有互联网协议都必须支持UTF-8编码，它使用1至4个字节为每个字符编码
      • 编码规则
        • 128个US-ASCII字符，只需一个字节编码
        • 拉丁文等字符，需要两个字节编码
        • 大部分常用字（含中文），使用三个字节编码
        • 其他极少是哟共的Unicode辅助字符，使用四字节编码

1.3、字符串中的编码解码问题

  • 相关方法
方法名说明
byte[] getBytes()使用平台的默认字符集将该String编码为一系列字节
byte[] getBytes(String charseName)使用指定的字符集将该String编码为一系列字节
String(byte[] bytes)使用平台默认字符集编码指定的字节数组来创建字符串
String(byte[] bytes,String charseName)通过指定的字符集编码指定的字节数组来创建字符串
  • 代码演示
public class StringDemo {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //定义一个字符串
        String s = "中国";
        //byte[] bys = s.getBytes();//[-28, -72, -83, -27, -101, -67]
        //byte[] bys = s.getBytes("UTF-8");//[-28, -72, -83, -27, -101, -67]
        byte[] bys = s.getBytes("GBK");//[-42, -48, -71, -6]
        System.out.println(Arrays.toString(bys));

        //String ss = new String(bys);
        //String ss = new String(bys,"utf-8");
        String ss = new String(bys,"gbk");
        System.out.println(ss);
    }
}

1.4、字符流写数据

  • 介绍
    • writer:用于写入字符流的抽象父类
    • FileWriter:用于写入字符流的常用子类
  • 构造方法
方法名说明
FileWriter(File file)根据给定的File对象构造一个FileWriter对象
FileWriter(File file,boolean append)根据给定的File对象构造一个FileWtriter对象
FileWriter(String fileName)根据给定的文件名构造一个FileWtriter对象
FileWriter(String fileName,boolean append)根据给定的文件名以及指示是否附加写入数据的boolean值来构造FileWriter对象
  • 成员方法
方法名说明
void writer(int c)写一个字符
void writer(char[] cbuf)写一个字符数组
void writer(char[] cbuf,int off,int len)写入字符数组的一部分
void writer(String str)写一个字符串
void writer(String str,int off,int len)写一个字符串的一部分
  • 刷新和关闭的方法
方法名说明
flush()刷新流，之后还可以继续写数据
close()关闭流，释放资源，但是在关闭之前会先刷新流，一旦关闭，就不能再写数据
  • 代码演示
public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("a.txt");

        //void write(int c):写一个字符
//        fw.write(97);
//        fw.write(98);
//        fw.write(99);

        //void write(char[] cbuf):写一个字符数组
//        char[] chs = {'a', 'b', 'c', 'd', 'e'};
//        fw.write(chs);

        //void write(char[] cbuf,int off,int len):写入字符数组的一部分
//        fw.write(chs,0,chs.length);
//        fw.write(chs,1,3);

        //void write(String str):写一个字符串
        fw.write("abcde");
        //void write(String str,int off,int len):写一个字符串的一部分
        fw.write("abcde",0,"abcde".length());
        //释放资源
        fw.close();
    }
}

1.5、字符流读数据

  • 介绍
    • Reader：用于读取字符流的抽象父类
    • FileReader：用于读取字符流的常用子类
  • 构造方法
方法名说明
int read()一次读取一个字符数据
int read(char[] cbuf)一次读取一个字符数组数据
  • 代码演示
public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("b.txt");

        //int read():一次读取一个字符数据
//        int ch;
//        while ((ch = fr.read()) != -1) {
//            System.out.print((char)ch);
//        }
        //int read(char[] cbuf):一次读取一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while((len = fr.read(chs))!=-1){
            System.out.print(new String(chs,0,len));
        }
        //释放资源
        fr.close();
    }
}

1.6、字符流用户注册案例

  • 案例需求：将键盘录入的用户名和密码保存到本地实现永久化存储
  • 实现步骤
    • 获取用户输入的用户名和密码
    • 将用户输入的用户名和密码写入到本地文件中
    • 关闭释放资源
  • 代码实现
public class CharStreamDemo08 {
    public static void main(String[] args) throws IOException {
        //需求：将键盘录入的用户名和密码保存到本地实现永久化存储
        //要求：用户名独占一行，密码独占一行
        //分析
        //1、实现键盘录入，把用户名和密码录入进来
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名:");
        String usernname = sc.next();
        System.out.println("请输入密码:");
        String password = sc.next();
        FileWriter fw = new FileWriter("c.txt");
        //将用户名和密码写到文件中
        fw.write(usernname);
        //表示写出一个回车换行符windows \r\n MacOS \r Linux \n
        fw.write("\r\n");
        fw.write(password);
        //刷新流
        fw.flush();
        //关流，释放资源
        fw.close();
    }
}

1.7、字符缓冲流

  • 字符缓冲流介绍
    • BufferedWriter:将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小，默认值足够大，可以用于大多数用途
    • BufferedReader:从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默然大小，默认值足够大，可以用于大多数用途
  • 构造方法
方法名说明
BufferedWriter(Writer out)创建字符缓冲输出流对象
BufferedReader(Reader in)创建字符缓冲输入流对象
  • 代码演示
public class BufferedStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //BufferedWriter(Writer out)
        BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
        bw.write("hello\r\n");
        bw.write("world\r\n");
        bw.close();
        //BufferedReader(Reader in)
        BufferedReader br = new BufferedReader(new FileReader("bw.txt"));
        //一次读取一个字符
//        int ch;
//        while ((ch = br.read())!=-1){
//            System.out.print((char)ch);
//        }
        //一次读取一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len = br.read(chs)) != -1) {
            System.out.print(new String(chs,0,len));
        }
        br.close();
    }
}

1.8、字符缓冲流的特有功能

  • 方法介绍
    BufferWriter:
方法名说明
void newLine()写一行行分隔符，行分隔符字符串由系统属性定义

BufferedReader:

方法名说明
String readLine()读一行文字。结果包含行的内容的字符串，不包括任何行终止字符如果流的结尾已经到达，则为null
  • 代码演示
public class BufferedStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("bw1.txt"));
        //写数据
        for (int i = 0; i < 10; i++) {
            bw.write("hello" + i);
            bw.newLine();
            bw.flush();
        }
        //释放资源
        bw.close();
        //创建字符缓冲输入流
        BufferedReader br = new BufferedReader(new FileReader("bw1.txt"));
        String line;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
        br.close();
    }
}

1.9、字符缓冲流操作文件中数据排序案例

  • 案例需求：使用字符缓冲流读取文件中的数据，排序后再次写到本地文件
  • 实现步骤
    • 将文件中的数据读取到程序中
    • 对读取到的数据进行处理
    • 将处理后的数据添加到集合中
    • 对集合中的数据进行排序
    • 将排序后的集合中的数据写入到文件中
  • 代码实现
public class CharStreamDemo14 {
    public static void main(String[] args) throws IOException {
        //需求：读取文件中的数据，排序后再次写入到本地文件
        //分析
        //1、要把文件中的数据读取出来
        BufferedReader br = new BufferedReader(new FileReader("sort.txt"));
        //输出流不一定要写到这里，因为会清空文件中的内容
        //BufferedWriter bw = new BufferedWriter(new FileWriter("sort.txt));
        String line = br.readLine();
        System.out.println("读取到的数据为:" + line);
        br.close();
        //2、按照空格进行切割
        String[] split = line.split(" ");
        //3、把字符串类型的数组变成int类型
        int[] arr = new int[split.length];
        //遍历split数组，可以进行类型转换
        for (int i = 0; i < split.length; i++) {
            String smallstr = split[i];
            //类型转换
            int number = Integer.parseInt(smallstr);
            //把转换后的结果存入到arr中
            arr[i] = number;
        }
        //排序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        //5、把排序后的结果写回到本地
        BufferedWriter bw = new BufferedWriter(new FileWriter("sort.txt",true));
        //写出
        bw.newLine();
        for (int i = 0; i < arr.length; i++) {
            bw.write(arr[i] + " ");
            bw.flush();
        }
        //释放资源
        bw.close();
    }
}

1.10、IO流小结

  • io流小结
    在这里插入图片描述

2、转换流

2.1、字符流中和编码解码问题相关的两个类

  • InputStreamReader:是从字节流到字符流的桥梁，父类是Reader
    • 它读取字节并使用指定的编码将其解码为字符
    • 他使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集
  • OutputStreamWriter:是从字符流到字节流的桥梁，父类是Writer
    • 是从字符流到字节流的桥梁，使用指定的编码将写入的字符编码为字节
    • 他使用的是字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集

2.2、转换流读写数据

  • 构造方法
方法名说明
InputStreamReader(InputStream in)使用默认字符编码创建InputStreamReader对象
InputStreamReader(InputStream in,String chatset)使用指定的字符编码创建InputStreamReader对象
OutputStreamWriter(OutStream out)使用默认的字符编码创建OutputStreamWriter对象
OutputStreamWriter(OutputStream out,String charset)使用指定的字符编码创建OutputStreamWriter对象
  • 代码演示
public class ConversionStreamDemo {
    public static void main(String[] args) throws IOException {
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"));
        osw.write("中国");
        osw.close();
        InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"));
        //一次读取一个字符数据
        int ch;
        while ((ch=isr.read())!=-1){
            System.out.print((char)ch);
        }
        isr.close();
    }
}

3、对象操作流

3.1、对象序列化流

  • 对象序列化介绍
    • 对象序列化：就是将对象保存到磁盘中，或者在网络中传输对象
    • 这种机制就是使用一个字节序列表示一个对象，该字节序列包含：对象的类型、对象的数据和对象中存储的属性等信息
    • 字节序列写到文件之后，相当于文件中持久保存了一个对象的信息
    • 反之，该字节序列还可以从文件中读取出来，重构对象，对他进行反序列化
  • 对象序列化流：ObjectOutputStream
    • 将Java对象的原始数据类型和图形写入OutputStream。可以使用ObjectInputStream读取（重构）对对象。可以通过使用流的文件来实现对象的持久存储。如果流是网络套接字流，则可以在另一个主机上另一个进程中重构对象
  • 构造方法
方法名说明
ObjectOutputStream(OutputStream out)创建一个写入指定的OutputStream的ObjectOutputStream
  • 序列化对象的方法
方法名说明
void writeObject(Object obj)将指定的对象写入ObjectOutputStream
  • 示例代码
    学生类
public class Student implements Serializable {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

测试类

public class ObjectOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //ObjectOutputStream(OutputStream out):创建一个写入指定的OutputStream的ObjectOutputStream
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt"));
        //创建对象
        Student s = new Student("佟丽娅", 30);
        //void writeObject(Object obj):将指定的对象写入ObjectOutputStream
        oos.writeObject(s);
        //释放资源
        oos.close();
    }
}
  • 注意事项
    • 一个对象要想被序列化，该对象所属的类必须实现Serializable接口
    • Serializable是一个标记接口，实现该接口，不需要重写任何方法

3.2、对象反序列化流

  • 对象反序列化流：ObjectInputStream
    • ObjectInputStream:反序列化先前使用ObjectOutputStream编写的原始数据和对象
  • 构造方法
方法名说明
ObjectInputStream(InputStream in)创建从指定的InputStream读取的ObjectInputStream
  • 反序列化对象的方法
方法名说明
Object readObject()从ObjectInputStream读取一个对象
  • 示例代码
public class ObjectInputStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //ObjectInputStream(InputStream in):创建从指定的InputStream读取的ObjectInputStream
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos.txt"));
        //Object readObject():从ObjectInputStream读取一个对象
        Object obj = ois.readObject();
        Student s = (Student)obj;
        System.out.println(s.getName() + ", " + s.getAge());
        ois.close();
    }
}

3.3、serialVersionUID&transient

  • serialVersionUID
    • 用对象序列化流序列化了一个对象后，假如我们修改了对象所属的类文件，读取数据会不会出问题呢？
      • 会出问题，会抛出InvalidClassException异常
    • 如果出问题了，如何解决呢？
      • 重新序列化
      • 给对象所属的类加一个serialVersionUID
        • private static fial long seriVersionUID = 42L;
  • transient
    • 如果一个对象中的某个成员变量的值不想被序列化，又该如何实现呢？
      • 给该成员变量加transient关键字，该关键字标记的成员变量不参与序列化过程
  • 实例代码
    学生类
public class Student implements Serializable {
    private static final long serialVersionUID = 42L;
    private String name;
//    private int age;
    private transient int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

测试类

public class ObjectStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        write();
        read();
    }
    //反序列化
    private static void read() throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos1.txt"));
        Object obj = ois.readObject();
        Student s = (Student)obj;
        System.out.println(s.getName() + ", " + s.getAge());
        ois.close();
    }

    //序列化
    private static void write() throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos1.txt"));
        Student s = new Student("张瑶",29);
        oos.writeObject(s);
        oos.close();
    }
}

3.4对象操作流练习

  • 案例需求：创建多个学生类对象写到文件中，再次读取到内存中
  • 实现步骤：
    • 创建序列化流对象
    • 创建多个学生对象
    • 将学生对象添加到集合中
    • 将集合对象序列化到文件中
    • 创建反序列化流对象
    • 将文件中的对象数据读取到内存中
  • 代码实现
    学生类
public class Student implements Serializable {
    private static final long serialVersionUID = 2L;
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static long getSerialVersionUID() {
        return serialVersionUID;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

测试类

public class Demo {
    /*
        read():读取到文件末尾返回值是-1
        readLine():读取文件末尾返回值是null
        readObject():读取到文件末尾直接抛出异常
        如果要序列化对象有多个，不建议直接将多个对象序列化到文件中，因为反序列化时容易出异常
        建议：将要序列化的多个对象存储到集合中，然后将集合序列化到文件中
     */
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //序列化
        //1、创建序列化流对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos2.txt"));
        ArrayList<Student> arrayList = new ArrayList<>();
        //2、创建多个学生对象
        Student s1 = new Student("磨人精", 28);
        Student s2 = new Student("哼哼怪", 29);
        //3、将学生对象添加到集合中
        arrayList.add(s1);
        arrayList.add(s2);
        //4、将集合对象序列化到文件中
        oos.writeObject(arrayList);
        oos.close();
        //反序列化
        //5、创建反序列化流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos2.txt"));
        //6、将文件中的对象数据，读取到内存中
        Object obj = ois.readObject();
        ArrayList<Student> arrayList1 = (ArrayList)obj;
        ois.close();
        for (Student s : arrayList1) {
            System.out.println(s.getName() + ", " + s.getAge());
        }
    }
}

4、Properties集合

4.1、Properties作为Map集合的使用

  • Properties介绍
    • 是一个Map体系的集合类
    • Properties可以保存到流中或从流中加载
    • 属性列表中的每个键及其对应的值都是一个字符串
  • Properties的基本使用
public class PropertiesDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        //Properties<String,String> prop = new Peoperties<>();//错误
        Properties prop = new Properties();
        //存储元素
        prop.put("itheima001","磨人精");
        prop.put("itheima002","哼哼怪");
        prop.put("itheima003","大喇叭");
        //遍历集合
        Set<Object> keySet = prop.keySet();
        for (Object key : keySet) {
            Object value = prop.get(key);
            System.out.println(key + ", " + value);
        }
    }
}

4.2、Properties作为Map集合的特有方法

  • 特有方法
方法名说明
Object setProperty(String key,String value)设置集合的键和值，都是String类型，底层调用Hashtable方法put
String getProperty(String key)使用此属性列表中指定的键搜索属性
set stringPropertyNames()从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串
  • 示例代码
public class PropertiesDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Properties prop = new Properties();
        //Objcet setProperty(String key,String value):设置集合的键和值，都是String类型
        prop.setProperty("itheima001","佟丽娅");
        prop.setProperty("itheima002","赵丽颖");
        prop.setProperty("itheima003","刘诗诗");
        //String getProperty(String key):使用此属性列表中指定的键搜索属性
        System.out.println(prop.getProperty("itheima001"));
        System.out.println(prop.getProperty("itheima0011"));
        System.out.println(prop);
        //set<String> StringPropertyName():从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串
        Set<String> names = prop.stringPropertyNames();
        for (String key : names) {
            System.out.println(key);
            String value = prop.getProperty(key);
            System.out.println(key + ", " + value);
        }
    }
}

4.3、Properties和io流相结合的方法

  • 和io流结合的方法
方法名说明
void load(Reader reader)从输入字符流读取属性列表（键和元素对）
void store(Writer writer,String comments)从此属性列表（键和元素对）写入此Properties表中，以适合使用load(Reader)方法的格式写入输出字符流
  • 示例代码
public class PropertiesDemo03 {
    public static void main(String[] args) throws IOException {
        //把集合中的数据保存到文件
        myStore();
        //把文件加载集合中
        myLoad();
    }

    private static void myLoad() throws IOException {
        Properties prop = new Properties();
        //void load(Reader reader)
        FileReader fr = new FileReader("fw.txt");
        prop.load(fr);
        fr.close();
        System.out.println(prop);
    }

    private static void myStore() throws IOException {
        Properties prop = new Properties();
        prop.setProperty("itheima001","佟丽娅");
        prop.setProperty("itheima002","赵丽颖");
        prop.setProperty("itheima003","刘诗诗");
        //void store(Writer writer,String comments)
        FileWriter fw = new FileWriter("fw.txt");
        prop.store(fw,null);
        fw.close();
    }
}

4.4、Properties集合练习

  • 案例需求：在Properties文件中手动写上姓名和年龄，读取到集合中，将该数据封装成学生对象，写到本地文件
  • 实现步骤
    • 创建Properties集合，将本地文件中的数据加载到集合中
    • 获取集合中的键值对数据，封装到学生对象中
    • 创建序列化流对象，将学生对象序列化到本地文件中
  • 代码实现
    学生类
public class Student implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static long getSerialVersionUID() {
        return serialVersionUID;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

测试类

public class Test {
    public static void main(String[] args) throws IOException {
        //创建Properties集合，将本地文件中的数据加载到集合中
        Properties prop = new Properties();
        FileReader fr = new FileReader("prop.properties");
        prop.load(fr);
        fr.close();
        //获取集合中的键值对数据，封装到学生对象中
        String name = prop.getProperty("name");
        int age = Integer.parseInt(prop.getProperty("age"));
        Student s = new Student(name, age);
        System.out.println(s);
        //创建序列化流对象，将学生对象序列化到本地文件中
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("d.txt"));
        oos.writeObject(s);
        oos.close();
    }
一人一只猫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Matlab课程设计大作业-基于和风天气API开发天气管理查询系统+项目说明.7z
12-16
由于天气查询过程中使用了和风天气API（和风天气开发服务 ~ 强大、丰富的天气数据服务 (qweather.com)），web请求过程中需要用到和风天气个人账号的key，我在代码中将其设为空值，具体是46行app的properities设置...
log4j.properities和logj.xml
08-18
在IT行业中，日志记录是系统开发和维护过程中的重要环节，它可以帮助开发者追踪程序运行状态，定位错误和异常，从而提升软件的可维护性和稳定性。Log4j是一款广泛使用的Java日志框架，它提供了丰富的配置选项来控制...
WinSpy（WinSpy++ ？WinSpy17 ？）
10-07
功能虽然不算强大，但涉及到很多windows api，是了解windows api的一个有用工具，是一个非常好的查看Windows操作系统的窗口、消息、进程、线程信息的工具，简单易用，功能强大。拖拽瞄准镜图标获取窗口的HWND，核心...
myeclipse2014和PowerDesigner16.5破解工具
05-15
myeclipse2014和PowerDesigner16.5破解工具，双资源破解工具，亲测有用使用详情和网络上的 使用方式一样
MyEclipse10破解补丁
06-04
4. 点击“自动替换类包”按钮或选择“操作”->“自动替换类包”选项，在弹出对话框中选择myeclipse的Common->plugins文件夹，程序会自动在这个目录下查找并替换相关的类包。 5. 点击“保存注册信息”按钮或选择...
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 834
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 905
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 1026
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 835
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
Java 线程池详解
qq_41591215的博客
07-13 966
线程池是一组已经初始化并等待执行任务的线程集合。通过使用线程池，我们可以避免频繁地创建和销毁线程，从而节省资源和减少系统开销。线程池的核心思想是通过复用线程来提高性能。
【JAVA】相关程序组件
qq_44077764的博客
07-15 162
【JAVA】相关程序组件
【Java算法】前缀和 下
最新发布
2302_79806056的博客
07-18 880
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
liangzai215的专栏
07-15 501
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 520
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。
深入剖析 Java 中 Spring Bean 的生命周期
weixin_42545951的博客
07-12 709
在 Java 开发中，Spring 框架是广泛使用的企业级应用开发框架。理解 Spring Bean 的生命周期对于开发者来说至关重要，这也是面试中经常会被问到的重要知识点。
构建自动化的精粹：Gradle任务依赖性与执行顺序控制
liuxin33445566的博客
07-15 539
本文以"构建自动化的精粹：Gradle任务依赖性与执行顺序控制"为题，详细介绍了任务依赖性的重要性、基本配置、多个任务的依赖性、条件依赖性、错误处理、高级用法、多项目构建中的任务依赖性。随着Gradle的不断发展，我们可以预见到更多关于任务依赖性和构建自动化的高级特性的出现，这将进一步扩展Gradle的构建能力，满足更复杂的项目构建需求。任务依赖性定义了任务之间的执行关系，确保了在构建过程中，任务能够按照预期的顺序执行。任务是一个特殊的任务，它默认依赖于所有没有显式排除的任务。方法来指定任务的依赖性。
从零手写实现 nginx-27-return 指令
07-14 671
大家好，我是老马。很高兴遇到你。我们为 java 开发者实现了 java 版本的 nginx如果你想知道 servlet 如何处理的，可以参考我的另一个项目：手写从零实现简易版 tomcatminicat。
Java实验2
qq_64727229的博客
07-16 514
类的封装、继承、多态和接口（1）有理数四则运算（2）最终得分
Java：ThreadPoolExecutor线程池知识体系
彭世瑜的博客
07-15 411
ThreadPoolExecutor的构造方法。固定大小线程数的线程池。
mysql 流水字段名
09-13
根据引用，在MySQL中，流水字段名是指通过语法分析和语义...在给定的SQL语句select name, age, address from user_properities where age > 15 and name like '张%' order by id;中，流水字段名为name, age, address。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值