2021-09-11

最新推荐文章于 2025-05-28 23:38:48 发布
最新推荐文章于 2025-05-28 23:38:48 发布
阅读量143 收藏
点赞数
文章标签： java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_54336887/article/details/120238133
版权

IO流（1）

上一篇太乱了，所以好好整理了一下

1.Java I/O是什么？

   Java中I/O是以流为基础进行数据的输入输出的，所有数据被串行化(所谓串行化就是数据要按顺序进行输入输出)写入流，并输出。通俗点讲就是通过java通过数据流方式和外部设备进行通讯。

   Java I/O中对数据的操作是通过流的方式，我们可以把数据流看成水流一样，他可以从一个源头端流入到另一个目的端，且水流不是一次全部到达，而且连续的（串行化）的流入目的端。I是指从外部设备的数据流流入java程序中的流。O是指从java程序中把数据流输出到其他设备中的流。

2.Java I/O的应用？

  在Java类库中，IO部分的内容是很庞大的，因为它涉及的领域很广泛:标准输入输出，文件的操作，网络上的数据流，字符串流，对象流，zip文件流。

 例子1：比如你用java开发的程序需要从网上下载图片，图片就是通过流的方式从网络上流入到你程序中，然后再从你的程序中流出到你的硬盘中。

例子2：你要用java程序把本地的一个文件从d盘拷贝到e盘。这个过程我们也用到了Java 的I/O。首先程序会去d盘找你指定的源端文件，并把文件的数据通过java的输入流串行化的读取到程序中，然后把程序中依次读入的数据流数据通过输出流串行化的输出到e盘的指定文件中，直到所有数据传输完成。这样就把d盘指定文件拷贝到了e盘。
原文链接：https://blog.youkuaiyun.com/fubo1990/article/details/82861228

3.什么是数据源

数据源Data Source, 提供数据的原始媒介。常见的数据源有：数据库，文件，其他程序，内存，网络，IO设备。

数据源分为：源设备，目标设备。

​ 源设备：为程序提供数据，一般对应输入流

​ 目标设备：程序数据的目的地，一般对应输出流

4. 什么是流？

流是一个抽象的概念。当Java程序需要从数据源读取数据时，会开启一个到数据源的流，数据源可以是文件、内存或者网络等。同样，当程序需要输出数据到目的地时也一样会开启一个流，数据目的地也可以使文件、内存或者网络等。流的创建是为了更方便地处理数据的输入输出。

5. java io_四大抽象类

InputStream 字节输入流的父类
OutputStream 字节输出流的父类
Reader 字符输入流的父类
Writer 字符输出流的父类

FileInputStream流被称为文件字节输入流，意思指对文件数据以字节的形式进行读取操作如读取图片视频等

如果不会使用IDEA自动导包，就看(https://www.bilibili.com/video/BV1Tf4y157Xs?spm_id_from=333.999.0.0)，下面的代码都没有导包。

字符输出不是文本

public class FirstDemo_01 {
    public static void main(String[] args) {
//        创建字节输入流对象
//        文件中只有abc三个字母
        FileInputStream fls = null;
        try{
            fls = new FileInputStream("E:\\a.txt");
            int s1 = fls.read();
            int s2 = fls.read();
            int s3 = fls.read();
            int s4 = fls.read();
            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s3);
            System.out.println(s4);//读取完毕返回-1

        }catch (Exception e){
            e.printStackTrace();

        }finally {
            if(fls != null) {
                try{
                    fls.close();

                }catch(Exception e) {
                    e.printStackTrace();

                }
            }
        }

    }
}

改造

public class SecondDemo_02 {
    public static void main(String[] args) {
        FileInputStream fls = null;
        try{
            fls = new FileInputStream("E:\\a.txt");
            StringBuffer sb = new StringBuffer();
            /*
            输出Unicode值，并返回多对应的字母
             */
            int temp = 0;
            while ((temp = fls.read()) != -1){
                System.out.println(temp);
                sb.append(temp);
            }
            System.out.println(sb);

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                if (fls !=  null) {
                    fls.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

File文件的基本使用

public class DirectoryDemo {
    public static void main(String[] args) {
        File file = new File("E:\\j\\k\\l");
//        创建一个目录
//        System.out.println(file.mkdir());
//        创建多级目录
//        System.out.println(file.mkdirs());
//        判断是否指向一个文件
//        System.out.println(file.isFile());
//        判断是否为一个目录
//        System.out.println(file.isDirectory());
//        System.out.println(file.exists());
//        返回父级目录的名字  （返回值就不同啊。getParentFile()的返回值是File型的。而getParent() 的返回值是String型的）
//        System.out.println(file.getParentFile().getName());
//        返回父级目录名字
//        System.out.println(file.getParent());
//        获取E盘下面的所有文件
        File file2 = new File("E:\\");
//          以数组的方式展现出来
//        String[] arr = file2.list();
//        for (String s : arr) {
//            System.out.println(s);
//        }
//        带绝对路径的所有文件
        File[] arr2 = file2.listFiles();
        for (File o : arr2) {
            System.out.println(o);

        }
    }
}

public class FileDemo_03 {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\\b.txt");
//        创建一个文件
//        System.out.println(file.createNewFile());
//        删除一个文件
//        System.out.println(file.delete());
//        判断一个文件是否存在
//        System.out.println(file.exists());
//        绝对路径
//        System.out.println(file.getAbsolutePath());
//        相对路径
//        System.out.println(file.getPath());
//        获取文件名字
//        System.out.println(file.getName());
//        是不是一个隐藏文件
//        System.out.println(file.isHidden());

    }
}

图片所对应的字节转换文

public class FileStreamDemo {
    public static void main(String[] args) {
        FileInputStream fis = null;

        try{
//            创建文件字节流输入对象
            fis = new FileInputStream("E:\\tu.JPG");

            int temp = 0;
            while ((temp = fis.read()) != -1){
                System.out.println(temp);
            }

        }catch(Exception e){
            e.printStackTrace();

        }finally {
            try{
                if (fis != null){
                    fis.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }

    }
}

文件字节输出流（高端复制图片）

public class FileStreamDemo_01_05 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;

        try{
//            创建文件字节流输入对象
            fis = new FileInputStream("E:\\tu.JPG");
//            创建文件字节流输入对象
            fos = new FileOutputStream("E:\\pi.JPG");
            int temp = 0;
            while ((temp = fis.read()) != -1){
               fos.write(temp);
            }
//            数据将内存写入磁盘中
            fos.flush();

        }catch(Exception e){
            e.printStackTrace();

        }finally {
            try{
                if (fis != null){
                    fis.close();
                }
                if (fos != null) {
                    fos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }

    }
}

通过缓冲区读写效率

public class FileStreamBuffedDemo_06 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;

        try{
//            创建文件字节流输入对象
            fis = new FileInputStream("E:\\tu.JPG");
//            创建文件字节流输入对象
            fos = new FileOutputStream("E:\\pi.JPG");
//            创建一个缓存区，提高读写效率
            byte[] buff = new byte[1024];
            int temp = 0;
            while ((temp = fis.read(buff)) != -1){
                fos.write(buff,0,temp);
            }
//            数据将内存写入磁盘中
            fos.flush();

        }catch(Exception e){
            e.printStackTrace();

        }finally {
            try{
                if (fis != null){
                    fis.close();
                }
                if (fos != null) {
                    fos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }

    }
}

图片小适用，不是太大不是太小

public class FileStreamBuffer2Demo_07 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;

        try{
//            创建文件字节流输入对象
            fis = new FileInputStream("E:\\tu.JPG");
//            创建文件字节流输入对象
            fos = new FileOutputStream("E:\\pio.JPG");
//            创建一个缓存区，提高读写效率
            byte[] buff = new byte[fis.available()];
            fis.read(buff);
//            数据将内存写入磁盘中
            fos.write(buff);

            fos.flush();

        }catch(Exception e){
            e.printStackTrace();

        }finally {
            try{
                if (fis != null){
                    fis.close();
                }
                if (fos != null) {
                    fos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

通过字节缓冲流提高读写效率

public class FileStreamBuffered03Demo {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
//            缓冲区中，byte数组长度默认为8192
            fis = new FileInputStream("E:\\tu.JPG");
            bis = new BufferedInputStream(fis);
            fos = new FileOutputStream("E:\\uji.JPG");
            bos = new BufferedOutputStream(fos);
            int temp = 0;
            while ((temp = bis.read()) != -1){
                bos.write(temp);
            }
            bos.flush();

        }catch (Exception e){
            e.printStackTrace();

        }finally {
            try {
                if (bis != null){
                    bis.close();
                }
                if (fis != null){
                    fis.close();
                }
                if (bos != null){
                    bos.close();
                }
                if (fos != null){
                    fos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

定义文件拷贝工具类

public class FileCopyTools_9 {
    public static void main(String[] args) {
        copyFile("E:\\tu.JPG","E:\\opw.JPG");

    }
    public static void copyFile(String src, String des){
        FileInputStream fis = null;
        BufferedInputStream bis = null;
        FileOutputStream fos =null;
        BufferedOutputStream bos = null;
        try{
            bis = new BufferedInputStream(new FileInputStream(src));
            bos = new BufferedOutputStream(new FileOutputStream(des));
            int temp = 0;
            while ((temp = bis.read()) != -1){
                bos.write(temp);
            }
            bos.flush();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (bis != null){
                    bis.close();
                }
                if (fis != null){
                    fis.close();
                }
                if (bos !=null){
                    bos.close();
                }
                if (fos != null){
                    fos.close();
                }

            }catch (Exception e){
                e.printStackTrace();
            }
        }

    }
}

文件字符输入流

public class FileReaderDemo_10 {
    public static void main(String[] args) {
        FileReader frd = null;
        try {
//            创建文件输入流对象
            frd = new FileReader("E:\\a.txt");
            int temp = 0;
            while ((temp = frd.read()) != -1){
                System.out.println((char) temp);
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (frd != null){
                    frd.close();
                }

            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

文件字节输出流

public class FileWriteDemo {
    public static void main(String[] args) {
        FileWriter fw = null;
        FileWriter fw1 = null;
        try {
            fw  = new FileWriter("E:\\h.txt");
            fw.write("你好未来的你\r\n");
            fw.write("希望你成功\r\n");
            fw.flush();
//           是否追加
            fw1 = new FileWriter("E:\\h.txt",true);
            fw1.write("你好过去的你\r\n");
            fw1.write("告诉你，你已经成功");
            fw1.flush();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                if (fw != null){
                    fw.close();
                }
                if (fw1 != null){
                    fw1.close();
                }

            }catch (Exception e){
                e.printStackTrace();
            }
        }

    }
}

使用字符流拷贝文本文件

public class FileCopyDemo02_11 {
    public static void main(String[] args) {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            fr = new FileReader("E:\\h.txt");
            fw = new FileWriter("E:\\lps.txt");
            int temp = 0;
            char[] buffer = new char[1024];
            while ((temp = fr.read(buffer)) != -1){
                fw.write(buffer,0,temp);

            }
            fw.flush();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (fr != null){
                    fr.close();
                }
                if (fw != null){
                    fw.close();
                }

            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

字符缓冲流

public class BufferedReaderDemo_14 {
    public static void main(String[] args) {
        FileReader fr = null;
        BufferedReader br = null;
        try {
            fr = new FileReader("E:\\h.txt");
            br = new BufferedReader(fr);
            String temp = "";
            while ((temp = br.readLine()) != null){
                System.out.println(temp);

            }

        }catch(Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (br != null){
                    br.close();
                }
                if (fr != null){
                    fr.close();
                }

            }catch (Exception e ){
                e.printStackTrace();
            }
        }

    }
}

字符输出缓冲流

public class BufferedWriteDemo_15 {
    public static void main(String[] args) {
        FileWriter fw = null;
        BufferedWriter bw = null;
        try {
            fw = new FileWriter("E:\\h1.txt");
            bw = new BufferedWriter(fw);
            bw.write("加油自己");
            bw.write("不能失败");
            bw.newLine();
            bw.write("为了自己");
            bw.write("绝不后退");
            bw.flush();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (bw != null){
                    bw.close();
                }
                if (fw != null){
                    fw.close();
                }

            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

通过字符缓冲流实现文本文件的拷贝

public class FileCopyTools_16 {
    public static void main(String[] args) {
        copyFile("E:\\a.txt","E:\\hwcsdx.txt");

    }
    public static void copyFile(String src,String des){
        BufferedReader br = null;
        BufferedWriter bw = null;
        try{
            br = new BufferedReader(new FileReader(src));
            bw = new BufferedWriter(new FileWriter(des));
            String temp = "";
            while ((temp = br.readLine()) != null){
                bw.write(temp);
                bw.newLine();
            }
            bw.flush();

        }catch (Exception e){
            e.printStackTrace();

        }finally {
            try {
                if (br != null){
                    br.close();
                }
                if (bw != null){
                    bw.close();
                }

            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

通过字符缓冲流为文件中的内容添加行号

public class LineNumberDemo_17 {
    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try{
            br = new BufferedReader(new FileReader("E:\\hwcsdx.txt"));
            bw = new BufferedWriter(new FileWriter("E:\\hwcsdxdwqw.txt"));
            String temp = "";
            int i = 1;
            while ((temp = br.readLine()) != null){
                bw.write(i+","+temp);
                bw.newLine();
                i++;
            }
            bw.flush();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (bw != null){
                    bw.close();
                }
                if (br != null){
                    br.close();
                }

            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

通过转化流实现键盘输入屏幕输出

public class CovertStream {
    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            bw = new BufferedWriter(new OutputStreamWriter(System.out));

            while (true) {
                bw.write("请输入");
                bw.flush();
                String input = br.readLine();
                if ("exit".equals(input)){
                    break;
                }
                bw.write("你输入的是"+input);
                bw.newLine();
                bw.flush();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (bw != null){
                    bw.close();
                }
                if (br != null){
                    br.close();
                }

            }catch (Exception e){
                e.printStackTrace();
            }
        }

    }
}

通过字节流读取文本文件并添加行号

public class LineNumberDem_19 {
    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try{
            br = new BufferedReader(new InputStreamReader(new FileInputStream("E:\\hwcsdx.txt")));
            bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("E:\\hwcsdxdwads.txt")));
            String temp = "";
            int i = 1;
            while ((temp = br.readLine()) != null){
                bw.write(i+","+temp);
                bw.newLine();
                i=i+1;
            }
            bw.flush();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                if (bw != null){
                    bw.close();
                }
                if (br != null){
                    br.close();
                }

            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

字符输出流

public class LineNumberDemo_20 {
    public static void main(String[] args) {
        BufferedReader br = null;
        PrintWriter pw = null;
        try {
            br = new BufferedReader(new InputStreamReader(new FileInputStream("E:\\hwcsdx.txt")));
            pw = new PrintWriter("E:\\xu.txt");
            String temp = "";
            int i = 1;
            while ((temp = br.readLine()) != null){
                pw.println(i+","+temp);
                i++;
            }
            
        }catch (Exception e){

        }finally {
            try {
                if (pw != null){
                    pw.close();
                }
                if (br != null){
                    br.close();
                }

            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

字节数组流

ByteArrayInputStream和ByteArrayOutputStream经常用在需要流和数组之间转化的情况

public class ByteInputStreamDemo_21 {
    public static void main(String[] args) {
        byte[] arr = "abcdefg".getBytes();
        ByteArrayInputStream bis = null;
        StringBuilder sb = new StringBuilder();

        try {
            bis = new ByteArrayInputStream(arr);
            int temp = 0;
            while ((temp = bis.read()) != -1){
                sb.append((char) temp);

            }
            System.out.println(sb.toString());


        }finally {

            try {
                bis.close();
            }catch (Exception e){
                e.printStackTrace();

            }
        }
    }
}

字节数组输出流

ByteArrayOutputStream流对象是将流中的数据写入到字节数组中

public class ByteArrayOutputDemo_22 {
    public static void main(String[] args) {
        ByteArrayOutputStream bos = null;

        try {
            StringBuilder sb = new StringBuilder();
            bos =new ByteArrayOutputStream();
            bos.write('a');
            bos.write('b');
            bos.write('c');
            byte[] arr = bos.toByteArray();
            for (int i = 0; i < arr.length; i++) {
//                System.out.println(arr[i]);
                sb.append((char) arr[i]);
            }
            System.out.println(sb.toString());

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (bos != null){
                    bos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

数据流 DataInputStream和DataOutStream

public class DataOutputDemo {

    public static void main(String[] args) {
        DataOutputStream dos = null;

        try {
            dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("E:\\lio.txt")));
            dos.writeChar('a');
            dos.writeDouble(Math.random());
            dos.writeInt(123);
            dos.writeBoolean(true);
            dos.writeChars("未来的你加油");
            dos.flush();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (dos != null){
                    dos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

数据输入流

public class DataInputDemo_24 {
    public static void main(String[] args) {
        DataInputStream dis = null;
        try {
            dis = new DataInputStream(new BufferedInputStream(new FileInputStream("E:\\lio.txt")));
            System.out.println(dis.readChar());
            System.out.println(dis.readDouble());
            System.out.println(dis.readInt());
            System.out.println(dis.readBoolean());
//            System.out.println(dis.readUTF());

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (dis != null){
                    dis.close();
                }

            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

对象流：写出基本数据类型数据

public class ObjectOutputStreamBasicTypeDemo_25 {
    public static void main(String[] args) {
        ObjectOutputStream oss = null;
        try {
            oss = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("E:\\jik.txt")));
            oss.writeUTF("希望你成功");
            oss.writeInt(13);
            oss.writeDouble(Math.random());
            oss.flush();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (oss != null){
                    oss.close();
                }

            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

读取基本数据类型数据

public class ObjectInputStreamBasicTypeDemo_26 {
    public static void main(String[] args) {
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream("E:\\jik.txt")));
            System.out.println(ois.readUTF());
            System.out.println(ois.readInt());
            System.out.println(ois.readDouble());

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (ois != null){
                    ois.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

将对象序列化到文件中

public class ObjectOutputStreamObjectTypeDemo_27 {
    public static void main(String[] args) {
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("E:\\1.txt"));
            User_27 user = new User_27(1,"liu","23");
            oos.writeObject(user);
            oos.flush();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (oos != null){
                    oos.close();
                }

            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

随机访问流

RandomAccessFile可以实现两个作用：

  1. 实现对一个文件做读和写的操作
  2. 可以实现访问文件的任意位置，不像其他流只能按照先后顺序读取
public class RandomAccessFileDemo_28 {
    public static void main(String[] args) {
        RandomAccessFile raf = null;
        try {
            raf = new RandomAccessFile("E:\\1.txt","rw");
            int[] arr = new int[]{1,2,3,45,6,7,8,90,345,365,};
            for (int i = 0; i < arr.length; i++) {
                raf.writeInt(arr[i]);
                
            }
            raf.seek(4);
            System.out.println(raf.readInt());
//            跳一个读一个
            for (int i = 0; i < 10; i+=2) {
                raf.seek(i*4);
                System.out.print(raf.readInt()+"\t");
                
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {

            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

File类在IO中的作用

public class FileIoDemo_29 {
    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new FileReader(new File("E:\\jik.txt")));
            bw = new BufferedWriter(new FileWriter(new File("E:\\ik.txt")));
            String temp = "";
            int i = 0;
            while ((temp =br.readLine()) != null){
                bw.write(i+","+temp);
                bw.newLine();
                i++;
            }
            bw.flush();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (br != null){
                    br.close();
                }
                if (bw != null){
                    bw.close();
                }

            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}
etherealiu
关注
2021-11-04
m0_53575762的博客
11-20 7976
一、Linux命令和windows区别？ 1、Linux命令全部严格区分大小写；而windows命令大小写都识别。 2、Linux所有的文件都是没有扩展名的，而windows是文件是有扩展名的。 创建一个新用户 [root@localhost mxh]# useradd mxh2 # 创建一个user [root@localhost mxh]# password mxh2 #12345678 [root@localhost xxx]# gr...
Remake_save_2021-09-16T15.43 05.284Z.json
09-16
本人玩的修仙存档，固定天赋小盒子，重开129次，成就87个，事件50%，天赋75%。休闲次数大概7次，最多一次500岁，但是没渡劫。
eclipse 2021-09版本汉化--英化
qq_43804919的博客
10-26 2021
汉化 英文汉化为中文 help->install software,选择插入软件。 输入：https://download.eclipse.org/technology/babel/update-site/R0.19.1/2021-09/ 等待一会，选择简体中文，finish就ok！ 等待安装，安装后，重启eclipse就ok！ ...
vulfocus复现：log4j2-rce-2021-12-09
qq_22132931的博客
12-26 964
vulfocus复现：log4j2-rce-2021-12-09
2021-09-25
热门推荐
weixin_49696047的博客
09-25 2万+
Steam XSX/XBOX one s手柄驱动安装失败解决方法。 方法一：Win+R 输入services.msc ，在右侧列表找到Steam Client Service并设置为自动运行。然后再去steam设置里面自动装驱动。 方法二：Win+R 输入CMD，输入cd C:\Program Files (x86)\Common Files\Steam 回车， 然后再输steamxboxutil64 --install drivers\Windows10\x64 回车，重启电脑。done 撤销：Ctrl
2021-11-09
Fangtingkeji的博客
11-09 3291
古诗翻板小游戏 缘起 为自己的孩子写的古诗小游戏。帮助他记忆古诗。希望将来他的生活有诗相伴。 功能 目前功能很简单。有三个界面：目录，翻板游戏和提示信息。 目录 - 已有诗词列表点击可直接进入主界面玩翻板游戏。 主界面 - 需要按正确顺序点古诗的字完成该古诗。 提示 - 点击主界面黄色Tip字样可以短时间显示古诗原文。 版本记录 当前版：0.0 已知问题 无 版权 个人自己开发的小游戏。禁止转载引用。 Getting Support: email..
Eclipse 2021-09最新版安装图文教程（详细包会）
qq_53045284的博客
09-16 1万+
考虑到有同学的java课程要求，需要配置java环境和安装Eclipse开发工具，这里写一下Eclipse的安装过程，eclipse安装比较简单，但是还是记录一下吧，Eclipse使用前需要你配置java开发环境。 一、Eclipse下载 1、Eclipse官网下载地址Eclipse Downloads | The Eclipse Foundationhttps://www.eclipse.org/downloads/2、打开网址，会看到如下界面，这里我们点击黄色按钮Download x86_64。
海康摄像头CVE-2021-36260漏洞复现
heike_Ch的博客
06-25 2000
攻击者利用该漏洞可以用无限制的 root shell 来完全控制设备，即使设备的所有者受限于有限的受保护 shell（psh）。除了入侵 IP摄像头外，还可以访问和攻击内部网络。该漏洞的利用并不需要用户交互，攻击者只需要访问 http 或 HTTPS服务器端口（80/443）即可利用该漏洞，无需用户名、密码、以及其他操作。摄像头本身也不会检测到任何登录信息。
2021-01-18
weixin_54641072的博客
01-18 1983
找程序猿哥哥！！！！编制App或者小程序
网络攻防｜CVE-2021-42287、CVE-2021-42278域内提权
weixin_42282189的博客
12-20 2927
作者： r0n1n 免责声明：本文仅供学习研究，严禁从事非法活动，任何后果由使用者本人负责。 0x01 漏洞原理 Microsoft Windows Active Directory 域服务权限提升漏洞（CVE-2021-42278、CVE-2021-42287）攻击者可利用该漏洞将域内的普通用户权限提升到域管理员权限，造成风险和危害极大。 漏洞情报来源： 1、影响版本 CVE-2021-42278 ￮ Windows Server 2012 R2 ￮ Windows Server 2012 (S.
eclipse-java-2021-09-R-win32-x86_64.zip
10-25
这个版本“eclipse-java-2021-09-R-win32-x86_64.zip”是2021年9月发布的一个更新版，针对Windows x86_64架构进行了优化，这意味着它可以在64位的Windows操作系统上运行，充分利用多核处理器和大内存的优势。...
eclipse-jee-2021-09-R-linux-gtk-aarch64.tar.gz
10-25
Eclipse IDE for Enterprise Java and Web Developers （eclipse-jee-2021-09-R-linux-gtk-aarch64.tar.gz）适用于Linux AArch64
eclipse-jee-2021-12-R-win32-x86_64.zip
01-05
Eclipse IDE for Enterprise Java and Web Developers （eclipse-jee-2021-12-R-win32-x86_64.zip）适用于Windwos x86_64
eclipse-java-2021-09-R-linux-gtk-x86_64.tar.gz
10-25
本篇将详细解析"Eclipse IDE for Java Developers"，即2021年9月发布的版本，具体文件为“eclipse-java-2021-09-R-linux-gtk-x86_64.tar.gz”，针对Linux x86_64架构的系统。 首先，Eclipse Java版是专为Java开发者...
SpringBoot实战：高效获取视频资源
阿Q的小窝
05-28 6351
在短视频行业高速发展的背景下，海量内容数据日益增长，每天都有新的视频、评论、点赞、分享等数据涌现。如何高效、精准地获取并处理这些庞大的数据，已成为各大平台和开发者面临的核心挑战。
Netty 框架介绍
技术改变世界
05-28 172
Netty是一个基于 Java NIO（Non-blocking I/O）的异步事件驱动网络应用框架，旨在快速开发高性能、高可靠性的网络服务器和客户端。它简化了 TCP/UDP 等协议的编程，并提供了高度可定制的组件，适用于高并发场景（如游戏服务器、即时通讯、分布式系统等）。
软件开发MVC三层架构杂谈
小L的博客
05-24 1537
本文深入探讨了MVC（Model-View-Controller）架构及其在实际开发中的应用，特别是如何将Model层细分为Service层和DAO层，形成Controller、Service和DAO的三层架构。
Spring Boot项目中实现单点登录(SSO)完整指南
最新发布
wa_ka_ka的博客
05-28 831
单点登录(Single Sign-On, SSO)是一种身份验证机制，允许用户使用一组凭证(如用户名和密码)登录多个相关但独立的系统。
sql语句 字符串是2021-09-11，如何截取数据获得是字符串2021-09
11-02
SELECT SUBSTR('2021-09-11', INSTR('2021-09-11', '-') + 1, 7) AS 'YearMonth'; ``` INSTR()找到第一个"-"的位置，然后从那里开始取7个字符。 3. **SQL Server**: 使用PATINDEX()和LEFT() ```sql SELECT LEFT('...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值