第12章_IO流

最新推荐文章于 2024-09-13 14:24:07 发布
最新推荐文章于 2024-09-13 14:24:07 发布
阅读量208 收藏
点赞数
分类专栏： Java学习笔记 文章标签： p2p linq wpf
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/M_Jaydy/article/details/122051734
版权

第12章_IO流

File类

引入

对文件操作

package com.ymj.test11IO;

import java.io.File;
import java.io.IOException;

public class Test01 {
    public static void main(String[] args) throws IOException {

        File f = new File("d:\\test.txt");
        File f1 = new File("d:/test.txt");
        //File.separator 属性可以帮助获取当前操作系统的路径拼接符号
        File f2 = new File("d:" + File.separator + "test.txt");
        //常用方法
        if (f.exists()){
            f.delete();
        }else{
            f.createNewFile();
        }
        System.out.println(f == f1);//比较地址
        System.out.println(f.equals(f1));//比较路径
        //路径：绝对路径:f.getAbsolutePath()，相对路径：f.getPath()，f.toString (相对路径）
    }
}

对目录操作

包含文件的方法

跟目录相关的方法

package com.ymj.test11IO;

import java.io.File;
import java.io.IOException;

public class Test01 {
    public static void main(String[] args) throws IOException {

        File f = new File("d:\\test.txt");
        File f1 = new File("d:/test.txt");
        //File.separator 属性可以帮助获取当前操作系统的路径拼接符号
        File f2 = new File("d:" + File.separator + "test.txt");
        //常用方法
        if (f.exists()) {
            f.delete();
        } else {
            f.createNewFile();
        }
        System.out.println(f == f1);//比较地址
        System.out.println(f.equals(f1));//比较路径
        //路径：绝对路径:f.getAbsolutePath()，相对路径：f.getPath()，f.toString (相对路径）

        File file = new File("D:\\a\\b\\c");
//        创建目录
        file.mkdir();
        file.mkdirs();

        //删除：如果是删除目录的话，只会删除一层，并且前提：这层目录是空的，里面没有内容，如果内容就不会被删除
        file.delete();
        //查看
        String[] list = file.list();
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println("===============");
        File[] files = file.listFiles();//作用更加广泛
        for (File fi :
                files) {
            System.out.println(fi.getName() + "," + fi.getAbsolutePath());
        }

    }
}

IO流

引入

  1. File类：封装文件/目录的各种信息，对目录/文件进行操作，但不可以获取到文件/目录中的内容。
  2. 引入：IO流

I/O ：Input/Output的缩写，用于处理设备之间的数据传输

  1. 形象理解

  1. IO流的体系结构

读取文件内容FileReader

一个字符一个字符的将文件中的内容读取到程序中了

package com.ymj.test11IO;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Test02 {
    public static void main(String[] args) throws IOException {
        //文件 -> 程序
        //1.有一个文件： -> 创建一个File类的对象
        File f = new File("d:\\Test.txt");
        //2.利用FileReader这个流，接入源文件上 -> 创建一个FileReader流对象
        FileReader fr = new FileReader(f);
//        3.进行读取动作
        //到了文件结尾，读取的地址为-1
        int n = fr.read();
        while (n != -1) {
            System.out.println(n);
            n = fr.read();
        }

        int n1;
        while ((n1 = fr.read()) != -1) {
            System.out.println(n1);
        }
        //4.关闭流
        //流，数据库，网络资源，靠jvm本身无法关闭，必须手动关闭；
        fr.close();
    }
}

一次性读取五个字符

利用缓冲数组

package com.ymj.test11IO;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class Test03 {
    public static void main(String[] args) throws IOException {
        //文件 -> 程序
        //1.有一个文件： -> 创建一个File类的对象
        File f = new File("d:\\Test.txt");
        //2.利用FileReader这个流，接入源文件上 -> 创建一个FileReader流对象
        FileReader fr = new FileReader(f);
//        3.进行读取动作
        //到了文件结尾，读取的地址为-1
       char[] ch = new char[5];
       int len = fr.read(ch);//一次性读取五个，返回该数组的有效长度
        while(len!=-1){
            for (int i = 0; i < len; i++) {
                System.out.println(ch[i]);
            }
//            方式2：
            String str = new String(ch,0,len);
            System.out.println(str);
            len = fr.read(ch);
        }
        //4.关闭流
        //流，数据库，网络资源，靠jvm本身无法关闭，必须手动关闭；
        fr.close();
    }
}

FileWriter

      

 File f1 = new File("d:\\Demo.txt");
        FileWriter fw = new FileWriter(f1, false);//默认false，覆盖原内容，true为追加内容
        String str = "Hello Java !@";
        for (int i = 0; i < str.length(); i++)
            fw.write(str.charAt(i));
//        fw.write(str);
        fw.close();

利用FileReader、FileWriter文件复制

package com.ymj.test11IO;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Test04 {
    public static void main(String[] args) throws IOException {
        //源文件
        File f1 = new File("d:\\Test.txt");
        //目标文件
        File f2 = new File("d:\\Test02.txt");
        //Input流
        FileReader fr = new FileReader(f1);
        //Out流
        FileWriter fw = new FileWriter(f2);
        //复制
        //[1] 一个一个字符复制
        int n = fr.read();//n为读取的ASC码
        while (n != -1) { //文件末尾ASC码=-1；
            fw.write(n);
            n = fr.read();
        }
        //[2] 利用缓冲字符数组
        char[] ch = new char[5];
        int len = fr.read(ch);//返回值是ch的有效长度
        while(len!=-1){//读取到最后，文件末尾len = -1
            fw.write(ch,0,len);
            len = fr.read(ch);
        }
        //[3] 利用缓冲字符数组,转为字符串
        char[] ch1 = new char[5];
        int len1 = fr.read(ch);
        while(len1!=-1){
            String s = new String(ch1,0,len1);
            fw.write(s);
            len1 = fr.read(ch1);
        }
        //6.关闭流，倒着关闭
        fw.close();
        fr.close();
    }
}

利用try-catch-final解决异常

package com.ymj.test11IO;

import java.io.*;

public class Test05 {
    public static void main(String[] args) {
        //源文件
        File f1 = new File("d:\\Test.txt");
        //目标文件
        File f2 = new File("d:\\Test02.txt");
        //Input流
        FileReader fr = null;
        FileWriter fw = null;
        try {
            fr = new FileReader(f1);
            //Out流
            fw = new FileWriter(f2);
            //复制
            //[1] 一个一个字符复制
            //n为读取的ASC码
            int n = fr.read();
            while (n != -1) {
                fw.write(n);
                n = fr.read();
            }
            //[2] 利用缓冲字符数组
            char[] ch = new char[5];
            int len = fr.read(ch);
            while (len != -1) {
                fw.write(ch, 0, len);
                len = fr.read(ch);
            }
            //[3] 利用缓冲字符数组,转为字符串
            char[] ch1 = new char[5];
            int len1 = fr.read(ch1);
            while (len1 != -1) {
                String s = new String(ch1, 0, len1);
                fw.write(s);
                len1 = fr.read(ch1);

            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //6.关闭流，倒着关闭
            try {
                if (fw != null)
                    fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fr != null)
                    fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
}

FileStreamReader读取文件

注意：

  1. 文件是UTF-8存储的，英文字符占1个字节，中文字符占3个字节；如果用字节流读取的话，1个中文字符会读取出三个ASC码；
  2. 文件是文本文件，那么就不要使用字节流读取了，建议使用字符流
  3. read()读取一个字节，但返回值是int类型，而不是byte类型
    1. read（）方法底层做了处理，让返回的数据都是“正数”
    2. 就是为了避免如果字节返回的是-1的话，无法判断是读入的字节还是文件结尾。

利用字节流读取非文本文件

缓冲字节流（处理流）BufferedInputStream

  1. 利用缓冲区

想要完成上面的效果，单纯的靠FileInputStream，FileOutputStream是不可以完成的，这个时候就需要功能的加强，需要引入新的流（在FileInputStream,FileOutputStream外面再套一层流）：BufferedInputStream，BufferedOutputStream -> 处理流

package com.ymj.test11IO;

import java.io.*;

public class Test06 {
    public static void main(String[] args) throws IOException {
        File f1 = new File("d:\\lol.png");
        File f2 = new File("d:\\lol2.png");
//        FileInputStream fi = new FileInputStream(f1);
//        FileOutputStream fo = new FileOutputStream(f2);
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(f1));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(f2));
        byte[] bt = new byte[1024 * 6];
        int len = bis.read(bt);
        while (len != -1) {
            bos.write(bt,0,len);
//            bos.flush(); //底层 调用fushBuffer()方法 自动刷新缓冲区
            len = bis.read(bt);
        }
        //关闭流时，高级流包含低级流时，当高级流关闭了，其包含的流也会自动关闭
        bos.close();
        bis.close();
    }
}

三个方法复制非文本文件的效率

  1. 读一个字节，写入一个字节

复制完成时间：2147

  1. 利用缓冲字节数组

2

  1. 利用缓冲区

1

缓冲字符流（处理流）-BufferReader、BufferWriter

package com.ymj.test11IO;

import java.io.*;

public class Test07 {
    public static void main(String[] args) throws IOException {
        File f1 = new File("d:\\Test.txt");
        File f2 = new File("d:\\Demo.txt");
        BufferedReader br = new BufferedReader(new FileReader(f1));
        BufferedWriter bw = new BufferedWriter(new FileWriter(f2));
//方式2;
//        char[] ch = new char[1024];
//        int n = br.read(ch);
//        while (n!=-1){
//            bw.write(ch,0,n);
//            n = br.read(ch);
//        }
        //方式3：读取String，每次读取文本文件中一行，返回字符串
        String str = br.readLine();
        while (str!=null){
            bw.write(str);
            bw.newLine();//新启动一行
            str = br.readLine();
        }

        bw.close();
        br.close();
    }
}

转换流InputStreamReader、OutputStreamWriter

  1. 转换流：作用，将字节流和字符流进行转换。
  2. 属于字符流（看结尾）
    1. InputStreamReader：字节输入流 -> 字符输入流
    2. OutputStreamWriter：字符输出流 -> 字节输出流
  3. 图解：
  4. 将输入的字节流转换为输入的字符流，然后完成文件

package com.ymj.test11IO;

import java.io.*;

public class Test08 {
    public static void main(String[] args) throws IOException {
        //将字节流FileInputStream转换为字符流InputStreamReader
        InputStreamReader isr = new InputStreamReader(new FileInputStream(new File("d:\\Test.txt")), "utf-8");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(new File("d:\\Demo.txt")), “gbk”);
        char[] ch = new char[1024];
        int len = isr.read(ch);
        while (len!=-1){
            osw.write(ch,0,len);
            len = isr.read(ch);
        }
        osw.close();
        isr.close();
    }
}

System类对IO流的支持

  1. System.in 标准流

package com.ymj.test11IO;

import org.junit.Test;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;

public class Test09 {
    public static void main(String[] args) throws IOException {
//        //标准的输入流：从键盘输入
//        InputStream in = System.in;
//        int n = in.read();//等待键盘的录入，该方法是一个阻塞方法
//        System.out.println(n);
//
//        //以前案例：从键盘录入一个int类型数据
//        //System.in管子，怼到键盘上，从键盘录入的恶化，就从这个官到程序中了
//        //Scanner的作用，扫描器，起到扫描作用，扫键盘的从这根管出来的数据
//        Scanner sc = new Scanner(System.in);
//        System.out.println(sc.nextInt());
        //Scanner也可以扫描其他管的内容
        Scanner sc1 = new Scanner(new FileInputStream("d:\\Test.txt"));
        while(sc1.hasNext()){
            System.out.println(sc1.next());
        }
    }
}

  1. System.out PrintStream

PrintStream out = System.out;
out.println("hello");

练习：键盘录入内容输出到文件中

键盘录入的 System.in 是字节流，输入的有中文和英文，所以需要先转换为字符流

  1. 解决思路

  1. 代码

package com.ymj.test11IO;

import java.io.*;

public class Test10 {
    public static void main(String[] args) throws IOException {
        //1、先准备输入方向
        //键盘录入
        InputStream in = System.in;//字节流
        //字节流转换为字符流
        InputStreamReader isr = new InputStreamReader(in);
        //在isr上套一个缓冲流
        BufferedReader br = new BufferedReader(isr);

        //2、再准备输出方向
        //准备目标文件
        File f = new File("d:\\Demo2.txt");
        //写入流
        FileWriter fw = new FileWriter(f);
        //套一个缓冲流
        BufferedWriter bw = new BufferedWriter(fw);

        //3.开始动作
        String s = br.readLine();
        while (!s.equals("exit")){
            bw.write(s);
            bw.newLine();
            s = br.readLine();
        }
        //4.关闭流
        bw.close();
        br.close();
    }
}

数据流DataInputStream、DataOutputStream

package com.ymj.test11IO;

import java.io.*;

public class Test11 {
    public static void main(String[] args) throws IOException {
        //将内存中的基本数据类型和字符串的变量 写成 文件中
        DataOutputStream dos = new DataOutputStream(new FileOutputStream(new File("d:\\Demo2.txt")));
        //向外将变量写到文件中
        dos.writeUTF("你好");
        dos.write(1);
        dos.close();

        DataInputStream dis = new DataInputStream(new FileInputStream(new File("d:\\Demo2.txt")));
        System.out.println(dis.readUTF());
        System.out.println(dis.readInt());
        dis.close();
    }
}

写出的类型和读入的类型顺序 要 匹配！

对象流-ObjectInputStream，ObjectOutputStream

实现Serializable接口

操作自定义类的对象

自定义的Person类：

package com.ymj.test11IO.serializabletest;

public class Person {
    private int age;
    private String name;


    private String sex;
    public Person() {
    }

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

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

测试类：

package com.ymj.test11IO.serializabletest;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class Test13 {
    public static void main(String[] args) throws IOException {
        //序列化：将内存中对象 -》 文件：
        //有一个对象
        Person p = new Person(36,"ryan","boy");
        //有对象流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("d:\\Demo4.txt")));
        //想外写
        oos.writeObject(p);
        //关闭流
        oos.close();
        //将对象
    }

}

运行时异常：

出现异常的原因：

想要序列化的对象对应的类，必须实现一个接口：

public interface Serializable {
}

接口内部，什么都没有，这种接口叫标识接口。

起到标识作用，只要实现这个接口的类的对象才能序列化，否则不可以。

解决方法：将Person实现这个标识接口就可以：

package com.ymj.test11IO.serializabletest;

import java.io.Serializable;

public class Person implements Serializable {
    private int age;
    private String name;


    private String sex;
    public Person() {
    }

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

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

测试：发现序列化成功，Person具备了序列化的能力

二进制数据，用程序实现反序列化操作，将对象恢复到内存总来：（？没有成功->序列化的文件不能修改，最好重新序列化一遍，再进行反序列化操作）解决：serialVersionUID变化，原对象修改了代码，未增加serialVersionUID，解决方法，加一个serialVersionUID；

package com.ymj.test11IO.serializabletest;

import java.io.*;

public class Test14 {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InvalidClassException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("D:\\Demo4.txt")));
        //读入内存
        Person p = (Person) (ois.readObject());
        System.out.println(p.toString());
//        System.out.println(o/*.toString()*/);
        ois.close();
    }
}

反序列化成功 将二进制 -> 内存

serialVersionUID

在Person类中加入toString方法后，反序列化会报错：

解决方法：给这个类加入一个序列版本号 serialVersionUID

IDEA中配置序列版本号

序列化细节

  1. 被序列化的类内部的所有属性，必须是可序列化的（基本数据类型都是可序列化的）
  2. static transient修饰的属性不可以被序列化（transient 保护的字段，例如密码）

 

For Dre@m~|
关注
专栏目录
java filewriter_Java基础篇：什么是FileWriter
weixin_39990401的博客
02-22 293
FileWriter 创建一个可以写文件的Writer 类。它最常用的构造函数如下：FileWriter(String filePath)FileWriter(String filePath, boolean append)FileWriter(File fileObj)它们可以引发IOException或SecurityException异常。这里，filePath是文件的完全路径，fileOb...
使用FileReader和FileWriter读取写入文件内容
热门推荐
I love fish
03-02 6万+
java 中的字节流不能直接操作Unicode字符，要想直接操作字符输入/输出要使用几个字符输入/输出类。字符流层次结构的顶层是Reader和Writer抽象类。1、Reader    Reader是定义java的流式字符输入模式的抽象类。错误异常为IOException。    主要方法有：    abstract  void  close() 关闭输入流，关闭后读取将会产生IOExceptio
JAVA I/O流 超详细解读(小白通读版)
不骄不躁，如此甚好
07-07 465
本文基于马士兵视频https://www.bilibili.com/video/BV1Ff4y147WP?p=257&spm_id_from=pageDriver撰写 一、File类的引入 在java中操纵文件/目录？怎么办？ java中最典型的特点就是面向对象，JAVA最擅长的也是操作对象，所以我们要把磁盘上的文件和文件夹封装成对象，对象属于File类的对象，有了这个对象，我们的程序就能直接操作文件了，还能对文件进行创建和删除。 二、File对文件的操作 public st...
java学习笔记_08_Java IO
xczzmn的专栏
08-05 601
java.io File类 Java.io.File类主要是完成了文件夹管理的命名、查询文件属性和处理目录等不进行文件夹内容的读取操作。 构造方法： File(String directoryPath) File(String directoryPath,Strin
Java基础篇之IO流（2）
weixin_43657820的博客
04-07 241
字节缓冲区流概述与使用： 字节缓冲流 : BufferedOutputStream:字节缓冲输出流 BufferedInputStream:字节缓冲输入流 BufferedOutputStream（OutputStream out） 使用这种构造方法，它提供了一个默认的缓冲区大小，所以一般我们使用默认缓冲区 为什么构造方法传递的是一个：OutputStream,而不是具体的文件或者路...
java io流练习题_io流课后练习题(最新整理)
weixin_32601635的博客
02-24 1261
《io流课后练习题(最新整理)》由会员分享，可在线阅读，更多相关《io流课后练习题(最新整理)(3页珍藏版)》请在人人文库网上搜索。1、一、选择题第十一章 io 流练习题1. 以下关于 File 类说法正确的是(B.C )：A: 一个 File 对象代表了操作系统中的一个文件或者文件夹B: 可以使用 File 对象创建和删除一个文件C: 可以使用 File 对象创建和删除一个文件夹D: 当一个 F...
第十章：Java_IO流
Jaybo
02-14 465
Java IO流 1.java.io包下 File类：java程序中的此类的一个对象，就对应着硬盘中的一个文件或网络中的一个资源。 File file1 = new File(“d:\io\helloworld.txt”); File file2 = new File(“d:\io\io1”); File既可以表示一个文件（.doc .xls .mp3
第十五章、 Io流
qq_64226679的博客
08-29 1067
节点流是直接从特定数据源读写数据的流，它们是I/O系统中的基础流，提供了最基本的读写功能。节点流通常与具体的数据源（如文件、网络连接等）直接相关联，如FileReader、FileWriter。分类字节输入流字节输出流字符输入流字符输出流抽象基类ReaderWriter访问文件FileReaderFlieWriter访问数组访问管道访问字符串处理流是对节点流的包装，它们提供了更高级的功能，如缓冲、行处理、转换等。
java io ppt_第10章JAVA_IO.ppt
weixin_35725389的博客
03-06 128
《第10章JAVA_IO.ppt》由会员分享，可在线阅读，更多相关《第10章JAVA_IO.ppt(30页珍藏版)》请在人人文库网上搜索。1、第10章 JAVA I/O系统,教学内容,输入输出类库 标准输入输出 文件操作,引入,什么是数据流？ 字节流和字符流的基类各是什么？,10.1 输入输出类库,10.1.1 流 几个概念：流 输入流/输出流 位流/字符流,10.1.2 输入输出流类,Input...
DeepLearning深度学习教程_第十二章_网络搭建及训练.pdf
08-23
"深度学习教程_第十二章_网络搭建及训练" 深度学习是一种机器学习技术，旨在通过模拟人类大脑的学习过程来实现自动学习和智能化。该技术的核心是神经网络，它是一种由多层节点组成的模型，每个节点对输入信号进行...
第十二章_网络搭建及训练1
08-03
【第十二章 网络搭建及训练】 在深度学习领域，网络搭建和训练是核心环节，本章主要探讨了三种流行的深度学习框架——TensorFlow、PyTorch和Caffe，以及网络搭建的原则和训练技巧。 1. **TensorFlow** ...
C++程序设计第11章C++的IO流类库.ppt
11-06
本章主要探讨了C++的IO流库，包括流的概念、格式化输入输出、磁盘文件的I/O以及字符串流和错误处理。 首先，流是C++中用于输入输出的一组类，分为文本流和二进制流。文本流处理的是以字符为单位的数据，而二进制流...
Java SE完整版精品优质课件 自学入门必看的优秀Java基础知识培训教案 第12章_Java常用类(共42页).rar
09-29
2. **IO流**：Java的IO流处理是进行输入输出操作的关键。包括字节流（InputStream/OutputStream）和字符流（Reader/Writer）两大类，以及它们的缓冲流、转换流、对象流等子类。此外，NIO（New IO）提供了一种更高效...
JL6107S 7端口管理型MAC（1*RGMII+1*SGMII）千兆以太网交换机芯片P2P替代RTL8367S
芯片代理商，AI视觉从业者
09-10 1350
system, the J儿L6107S supports smart management such as function and cloud management. The JL6107S also allows RTOS to run upper-layer software protocols.需要更多SDK，开发资料请联系！
Kafka面试题
最新发布
Jack章臣的博客
09-13 400
总的来说，如果你的系统需求是大数据处理和实时流分析，Kafka 是更好的选择；如果你关注的是消息可靠性、多种消息协议支持或需要良好的管理界面，RabbitMQ 可能更适合；而 ActiveMQ 则在需要 JMS 完整支持和更多的高级特性时成为了首选。选择合适的消息系统需要考虑不同的技术需求和业务目标，如消息吞吐量、数据持久性、系统扩展性和开发资源。在做决策时，要仔细权衡每种队列管理系统的优势和局限，并充分理解其在不同场景下表现的差异。
Kafka原理剖析之「Topic创建」
sjzsylkn的专栏
09-07 1437
Kafka提供了高性能的读写，而这些读写操作均是操作在Topic上的，Topic的创建就尤为关键，其中涉及分区分配策略、状态流转等，而Topic的新建语句非常简单--bootstrap-server localhost:9092 \ // 需要写入endpoints--create --topic topicA // 要创建的topic名称--partitions 10 // 当前要创建的topic分区数。
Ribbon (WPF)
jyl_sh的专栏
09-13 911
快速访问工具栏是一个小的、可自定义的工具栏，它提供了对常用命令的访问，与选择哪个Ribbon选项卡无关。如果你刚刚开始使用Ribbon，或者需要关于Ribbon UI的一般信息，请参阅Windows用户体验交互指南中的Ribbon主题。微软的Ribbon 是Windows Presentation Foundation (WPF)是一个WPF一个组件，它包含了所有基本Ribbon的特性和功能，包括选项卡、组、控件、快速访问工具栏、与窗口标题栏的集成，以及通过动态布局调整大小。
自定义WPF滑块样式-Slider
shanshan2099的专栏
09-13 639
滑动过的部分（DecreaseRepeatButton）是一个蓝色的矩形（Rectangle）。未滑动过的部分（IncreaseRepeatButton）是一个透明的矩形（Rectangle）。这样，我们就得到了一个自定义样式的滑块：滑动过的部分是蓝色的，滑块本身是一个白色的圆形，滑块的背景是灰色的，未滑动过的部分是透明的，而且滑块只能在刻度上移动，不能在刻度之间移动。滑块的当前值会显示在滑块的右侧。这就是XAML的艺术，通过自定义样式，我们可以改变控件的外观和行为，使其更符合我们的设计需求。
Winform中引入WPF控件后键盘输入无响应
weixin_42253874的博客
09-10 555
Winform中如何引入WPF控件的教程很多，对于我们直接通过ElementHost引入的直接显示控件，它是可以响应键盘输入消息的，但对于在WFP中弹出的窗体来说，此时是无法响应我们的键盘输入的。我们需要给它使能键盘输入。
Java第12章：IO流与数据持久化技术详解
总结来说，本章Java第十二章主要讲解了如何使用IO流进行数据操作以及数据持久化在实际项目中的应用，包括数据库连接、文件操作的API和常见用法。熟练掌握这些内容有助于编写高效且可维护的Java程序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值