首页 > 其他分享 >IO流

IO流

时间：2025-01-18 22:55:08浏览次数：1  
标签：String IO System File println public out

IO流

异常

异常：
Throwable:
- Error【非常严重的错误，我们自己解决不了】
- Exception【自己能处理的异常】
- RuntimeException【运行时期异常】
- 除了RuntimeException【编译时期异常】

常见的异常：
空指针异常
索引越界异常
ClassCastException

public class ExceptionDemo1 {
    public static void main(String[] args) {
//        String s1 = null;
////        System.out.println(s1.length()); // jvm默认处理异常的方式是抛出错误，程序停止，后续代码不执行
//
//        if(s1!=null){
//            System.out.println(s1.length()); // NullPointerException
//        }else {
//            System.out.println("字符串为null");
//        }
//
//        System.out.println("over");

        int[] arr = {11,22,33};
        System.out.println(arr[6]); // ArrayIndexOutOfBoundsException


    }
}

异常处理的方式：

​ 1、try...catch...【最终的处理方式】
​ 2、throws【仅为了程序能够通过编译】

注意：
1、try中的代码只要遇到异常，try中的其他代码不执行，直接进入到匹配catch的过程
2、如果没有对应的catch能够匹配，那么就说明该异常没有被处理，就由jvm默认处理了。
3、新版本的新写法，可以直接写一个catch，将多个异常类型使用|分割，缺点：多种异常的处理方案统一
4、只要是XxxException.一定是Exception子类,新版本的新写法中，异常类之间，不能存在继承关系
5、若写多个catch接收的话，异常类可以存在继承关系，但是父类必须写在后面
6、如果一个运行过程出现的问题，大概率是运行时期异常父类中一定会继承RuntimeException
而一般情况下，运行时期异常都是由于代码不够严谨导致的，可以通过提高代码逻辑严谨进行规避
也可以使用try...catch处理运行时期异常
7、如果一段代码，还没运行，就直接报错了，大概率是编译时期异常，父类直接继承自Exception
而编译时期异常必须要使用try...catch...进行处理

public class ExceptionDemo2 {
    public static void main(String[] args) {
        int[] arr = {11, 22, 33};
        try {
            System.out.println(arr[6]); // ArrayIndexOutOfBoundsException
            String s = null;
            System.out.println(s.length()); // NullPointerException
        }catch (ArrayIndexOutOfBoundsException e){ //ArrayIndexOutOfBoundsException e = new ArrayIndexOutOfBoundsException()
            System.out.println("出错啦！！数组索引越界异常");
        }catch (NullPointerException e){ // NullPointerException e = new NullPointerException();
            System.out.println("出错啦！！空指针异常");
        }

        try {
            System.out.println(arr[1]); // ArrayIndexOutOfBoundsException
            String s = null;
            System.out.println(s.length()); // NullPointerException
        }catch (NullPointerException | ArrayIndexOutOfBoundsException e){ //ArrayIndexOutOfBoundsException e = new ArrayIndexOutOfBoundsException()
            System.out.println("出错啦！！");
        }
        try {
            System.out.println(arr[1]); // ArrayIndexOutOfBoundsException
            String s = null;
            System.out.println(s.length()); // NullPointerException
        }catch (Exception e){ //Exception e = new ArrayIndexOutOfBoundsException()
            System.out.println("出错啦！！");
        }
        try {
            System.out.println(arr[6]); // ArrayIndexOutOfBoundsException
            String s = null;
            System.out.println(s.length()); // NullPointerException
        } catch (ArrayIndexOutOfBoundsException e) { //ArrayIndexOutOfBoundsException e = new ArrayIndexOutOfBoundsException()
            System.out.println("出错啦！！数组索引越界异常");
        } catch (NullPointerException e) { // NullPointerException e = new NullPointerException();
            System.out.println("出错啦！！空指针异常");
        } catch (Exception e){
            System.out.println("其他错误！！");
        }
//        编译时期异常，代码无法通过编译，必须通过try..catch处理
//        FileInputStream fis = new FileInputStream("");
        try {
            FileInputStream fis1 = new FileInputStream("");
        }catch (Exception e){
            System.out.println("出错啦");
        }
        System.out.println("over");
    }
}

try...catch...finally...

1、无论try中的代码是否报错，finally中的代码都会执行，以后的开发中finally中一般编写释放资源代码
2、有一种情况，finally不会执行，在执行finally之前，整个程序意外中止

public class ExceptionDemo3 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4};

        try {
            System.out.println(arr[1]);
            System.exit(0);
        }catch (Exception e){
            System.out.println("出错啦！");
        }finally {
            System.out.println("好好学习");
        }



        System.out.println("over");
    }
}

throws

throws在方法上抛出异常类，表示一种可能性

public class ExceptionDemo5 {
    public static void main(String[] args) throws Exception{

//       try {
//           fun1();
//       }catch (Exception e){
//           e.printStackTrace();
//       }
        fun1();

        System.out.println("over");
    }

    public static void fun1() throws Exception{
        FileInputStream fileInputStream = new FileInputStream("");
    }
}

throw，throws try...catch区别

  • throws
    用在方法声明后面，跟的是异常类名
    可以跟多个异常类名，用逗号隔开
    表示抛出异常，由该方法的调用者来处理
    throws表示出现异常的一种可能性，并不一定会发生这些异常

  • throw
    用在方法体内，跟的是异常对象名
    只能抛出一个异常对象名
    表示抛出异常，由方法体内的语句处理
    throw则是抛出了异常，执行throw则一定抛出了某种异常

  • 原则:如果该功能内部可以将问题处理,用try,如果处理不了,交由调用者处理,这是用throws
    区别:

  • 后续程序需要继续运行就try
    后续程序不需要继续运行就throws
    举例:
    感冒了就自己吃点药就好了,try
    吃了好几天药都没好结果得了新冠，那就的得throws到医院
    如果医院没有特效药就变成Error了

public class ExceptionDemo6 {
    public static void main(String[] args) {
        try {
            fun1();
        }catch (Exception e){
            e.printStackTrace();
        }

        System.out.println("over");
    }

    public static void fun1() throws ArithmeticException{
        int a = 10;
        int b = 0;
        if(b==0){
            throw new ArithmeticException();
        }else {
            System.out.println(a/b);
        }

    }
}

File

File:可以使用该类的对象描述一个文件夹的路径，将来调用File类中的方法，可以 操作 改路径的文件夹或者文件。

路径：

  • 绝对路径【完整路径】：带有盘符的路径
  • 相对路径：相对一个项目来说

构造方法：

public File(String pathname)

public File(String parent,Stirng child )

public File(File parent,String child)

public class FileDemo1 {
    public static void main(String[] args) {

        //完整路径
//        File file = new File("F:\\projects\\IDEAProjects\\bigdata33-java\\bigdata33-java\\src\\shujia\\day12\\ketang\\b.txt");
//        //相对路径
//        File file1 = new File("src/shujia/day12/a.txt");

        //public File(String parent,String child)
//        File file1 = new File("src/shujia/day12","a.txt");

        //public File(File parent,String child)
        File file = new File(getPathname());
        File file1 = new File(file, "a.txt");


    }
    private static String getPathname() {
        return "src/shujia/day12";
    }
}

创建、删除、重命名功能

创建功能

public boolean createNewFile()
public boolean mkdir()
public boolean mkdirs()

删除功能
public boolean delete()

重命名功能
public boolean renameTo(File dest)

public class FileDemo2 {
    public static void main(String[] args) throws Exception{
        File file1 = new File("src/shujia/day12/ketang/a.txt");

        // public boolean createNewFile() 创建一个新的文件
//        System.out.println(file1.createNewFile());

        // public boolean mkdir() 创建单极文件夹
//        System.out.println(file1.mkdir());
        File file2 = new File("src/shujia/day12/ketang/aaa/bbb/ccc");
//        System.out.println(file2.mkdir());


        //public boolean mkdirs() 创建多极文件夹
//        System.out.println(file2.mkdirs());

        //public boolean delete() 删除一个文件夹或者文件
//        file1.delete();
//        file2.delete();

        File file3 = new File("src/shujia/day12/ketang/aaa");
//        file3.delete(); // 无法直接删除一个非空文件夹


        // public boolean renameTo(File dest) 重命名一个文件夹或者文件
        File file4 = new File("src/shujia/day12/ketang/张成阳.txt"); // 需要先将目标封装成File对象
        file1.renameTo(file4);

    }
}

判断功能

​ public boolean isDirectory()
​ public boolean isFile()
​ public boolean exists()
​ public boolean canRead()
​ public boolean canWrite()
​ public boolean isHidden()

public class FileDemo3 {
    public static void main(String[] args) {
        File file = new File("src/shujia/day12/ketang/张成阳.txt");

        //public boolean isDirectory() 判断目标是否是一个文件夹
        System.out.println(file.isDirectory());

        // public boolean isFile() 判断目标是否是一个文件
        System.out.println(file.isFile());

        // public boolean exists() 判断目标是否存在
        System.out.println(file.exists());

        // public boolean canRead() 判断目标是否可读
        System.out.println(file.canRead());
        System.out.println(file.canWrite());
        // public boolean isHidden() 判断目标是否被隐藏
        System.out.println(file.isHidden());

    }
}

获取功能

基本获取功能
public String getAbsolutePath()
public String getPath()
public String getName()
public long length()
public long lastModified()
高级获取功能
public String[] list() 列出当前目录下所有文件以及文件夹的名字组成的字符串数组
public File[] listFiles() 列出当前目录下所有文件以及文件夹的对应的File对象组成的File对象数组

public class FileDemo4 {
    public static void main(String[] args) {
        File file = new File("src/shujia/day12/ketang/张成阳.txt");

        // public String getAbsolutePath() 获取完整路径
//        System.out.println(file.getAbsolutePath());

        System.out.println(file.getAbsoluteFile());
        // public String getPath() 获取相对路径
//        System.out.println(file.getPath()); // src\shujia\day12\ketang\张成阳.txt
        System.out.println(file.getPath());
        // public String getName() 获取目标的名字
        System.out.println(file.getName());

        // public long length() 获取的目标中的字节数
        System.out.println(file.length());

        // public long lastModified() 获取目标最后一次修改的时间戳
        System.out.println(DateUtil.getTime(file.lastModified()));
        System.out.println(file.lastModified());
        System.out.println("-----------------------------------");
        File file2 = new File("src/shujia/day12/ketang");

        String[] nameList = file2.list();
        System.out.println(nameList);
        System.out.println(Arrays.toString(nameList));
        
        File[] fileArray = file2.listFiles();
        System.out.println(Arrays.toString(fileArray));
    }
}

需求

/*
    判断E盘目录下是否有后缀名为.jpg的文件，如果有，就输出此文件名称
    先获取所有的File对象，再从其中过滤出符合条件的。
 */
public class FileTest1 {
    public static void main(String[] args) {

        File file = new File("E:\\");

        File[] files = file.listFiles();

        if(files!=null){
            for (File file1 : files) {
                if(file1.isFile() && file1.getName().endsWith(".jpg")){
                    System.out.println(file1.getName());
                }
            }
        }
    }
}

public class FileTest2 {
    public static void main(String[] args) {
        File file = new File("E:\\");

        File[] files = file.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                // 这里返回是true还是false需要自己编写代码逻辑
//                return true;
                return pathname.isFile() && pathname.getName().endsWith(".jpg");
            }
        });

//        File[] files = file.listFiles(pathname -> pathname.isFile() && pathname.getName().endsWith(".jpg"));

        System.out.println(Arrays.toString(files));
    }
}

IO: 输入输出流

根据流向：
输入流：外部数据 -> java程序
输出流：java程序 -> 外部数据

根据种类：
字节流【万能流】：计算机中所有的文件格式数据都是以字节的方式存储的，可以读写任意一种任意类型的文件
字节输出流：OutputStream【抽象类】

                 - FileOutputStream【子类】
            字节输入流：InputStream
​    字符流 = 字节流+编码表：使用计算机自带的记事本打开能看懂
    ​        字符输出流：
    ​        字符输入流：

FileOutputStream

FileOutputStream的构造方法：
FileOutputStream(File file) 创建文件输出流以写入由指定的 File对象表示的文件。
FileOutputStream(String name) 创建文件输出流以指定的名称写入文件。

public class FileOutputStreamDemo1 {
    public static void main(String[] args) throws Exception{
//        File file = new File("src/shujia/day12/ketang/a1.txt");
//        //FileOutputStream(File file) 写数据，目标文件若不存在，会自动创建
//        FileOutputStream fos = new FileOutputStream(file);


        //FileOutputStream(String name)
        FileOutputStream fos =newFileOutputStream("src/shujia/day12/ketang/a2.txt");


        // 释放资源
        fos.close();
    }
}

往一个文本文件中写一句话："helloworld"

FileOutputStream中的写数据方法

  • public void write(int b)

  • public void write(byte[] b)

  • public void write(byte[] b,int off,int len)

public class FileOutputStreamDemo2 {
    public static void main(String[] args)  {

        FileOutputStream fos = null;
        try {
            //创建字节输出流对象
            fos = new FileOutputStream("src/shujia/day12/ketang/a3.txt");

            //public void write(int b) 一次写一个字节
//            fos.write(97);
//            fos.write(98);
//            fos.write(99);

            // public void write(byte[] b) 一次写一个字节数组
            byte[] bytes = {100,101,102,103};
            
//            fos.write(bytes);

            // public void write(byte[] b,int off,int len) 一次写字节数组的一部分
            fos.write(bytes,2,2);

            // 使用字节输出流写数据的时候，写字符串时，需要将字符串转字节数组再进行写入，因为字节输出流没有直接写字符串的方法
            fos.write("shujia666".getBytes());
            

            //TODO:思考：1、如何写10行helloworld?   2、如何实现追加写？

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

加密解密

加密：字符串 -> 字节数组
解密：字节数组 -> 字符串

public class BianMaDemo {
    public static void main(String[] args) throws Exception{
        String s1 = "数加科技sjkj";
        // 加密
//        byte[] bytes1 = s1.getBytes();
        byte[] bytes1 = s1.getBytes();
        System.out.println(Arrays.toString(bytes1));

        // 解密
//        String res1 = new String(bytes1);
        //public String(byte bytes[], String charsetName)
        String res1 = new String(bytes1);
        System.out.println(res1);


    }
}

FileInputStream

IO流：
根据流向划分：
输入流
输出流
根据种类划分：
字节流【万能流】：
字节输出流：OutputStream

​ FileOutputStream

​ 字节输入流：InputStream

​ FileInputStream

​ 字符输出流
​ 字符输入流

FileInputStream(File file) 通过打开与实际文件的连接创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
FileInputStream(String name) 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

对于读取数据而言，要求，目标路径一定要存在

字节输入流读取数据的方式：
public int read() 一次读取一个字节
public int read(byte[] b) 一次读取一个字节数组

 */
public class FileInputStreamDemo1 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try{
            //FileInputStream(File file)
//            File file = new File("src/shujia/day13/a2.txt");
//            fis = new FileInputStream(file);

            //FileInputStream(String name)
            fis = new FileInputStream("src/shujia/day13/a1.txt");

//            System.out.print( (char)fis.read());
//            System.out.print((char) fis.read());
//            System.out.print((char) fis.read());
//            System.out.print((char) fis.read());
//            System.out.print((char) fis.read());
//            System.out.print((char) fis.read());

            // 使用while循环读取字节
            // 通过api发现，FileInputStream读取到文件末尾的时候返回-1
//            int i = 0;
//            while ((i = fis.read())!=-1){
//                System.out.print((char) i);
//            }

            //public int read(byte[] b)
//            byte[] bytes = new byte[2];
//            int length = fis.read(bytes); //返回实际读取到的字节数，读取到的数据在字节数组中
//            String s = new String(bytes, 0, length);
//            System.out.print(s);

//            int length2 = fis.read(bytes); //返回实际读取到的字节数，读取到的数据在字节数组中
//            String s2 = new String(bytes, 0, length2);
//            System.out.print(s2);
            byte[] bytes = new byte[1024]; // 字节数组大小，一般来说，是1024的倍数
            int length = 0;
            while ((length = fis.read(bytes))!=-1){
                String s2 = new String(bytes, 0, length);
                System.out.print(s2);
            }


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

BufferedOutputSream

/*
    IO流：
        根据流向划分：
            输入流
            输出流
        根据种类划分：
            字节流【万能流】：
                字节输出流：OutputStream
                            - FileOutputStream
                            - BufferedOutputStream 【加入了缓冲区，写数据要更快】
                字节输入流：InputStream
                            - FileInputSteam
                            - BufferedInputStream   【加入了缓冲区，读取数据要更快】
            字符流=字节流+编码表：
                字符输出流
                字符输入流

public class BufferedOutputStreamDemo1 {
    public static void main(String[] args) throws Exception{
        //BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
        //创建字节缓冲输出流对象
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("src/shujia/day13/a2.txt",true));

        // 一次写一个字节
        bos.write(101);
        // 一次写一个字节数组
        byte[] bytes = {101,102,103,104};
        bos.write(bytes);
        // 一次写一个字节数组的一部分
        bos.write(bytes,1,2);


        bos.flush();
        //释放资源
        bos.close(); // 底层关闭之前，做了一次刷新操作，将内存缓冲区中的数据刷到了磁盘中
//        bos.write(102);
//        bos.flush();
    }
}

BufferedOutputStream

/*
    IO流：
        根据流向划分：
            输入流
            输出流
        根据种类划分：
            字节流【万能流】：
                字节输出流：OutputStream
                            - FileOutputStream
                            - BufferedOutputStream 【加入了缓冲区，写数据要更快】
                字节输入流：InputStream
                            - FileInputSteam
                            - BufferedInputStream   【加入了缓冲区，读取数据要更快】
            字符流=字节流+编码表：
                字符输出流
                字符输入流

public class BufferedInputStreamDemo1 {
    public static void main(String[] args) throws Exception{
        //BufferedInputStream(InputStream in) 创建一个 BufferedInputStream并保存其参数，输入流 in ，供以后使用。
        //创建字节缓冲输入流对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("src/shujia/day13/a2.txt"));

        // 一次读取一个字节
//        int i = 0;
//        while ((i=bis.read())!=-1){
//            System.out.print((char) i);
//        }

        // 一次读取一个字节数组
        byte[] bytes = new byte[1024];
        int length = 0;
        while ((length = bis.read(bytes))!=-1){
            String s = new String(bytes, 0, length);
            System.out.print(s);
        }


        // 释放资源
        bis.close();
    }
}

字符输出流Write

字符流 = 字节流 + 编码表：
    字符输出流：Writer【抽象类】
                - OutputStreamWriter
    字符输入流：Reader


OutputStreamWriter构造方法：
    OutputStreamWriter(OutputStream out) 创建一个使用默认字符编码的OutputStreamWriter。
    OutputStreamWriter(OutputStream out, String charsetName) 创建一个使用命名字符集的OutputStreamWriter。

Writer字符输出流写数据的方式：
    public void write(int c)
    public void write(char[] cbuf)
    public void write(char[] cbuf,int off,int len)
    public void write(String str)
    public void write(String str,int off,int len)

注意:
    只要是字符流写数据，将来都需要进行flush操作

public class OutputStreamWriterDemo1 {
    public static void main(String[] args) throws Exception{
        //OutputStreamWriter(OutputStream out) 使用平台默认的编码写字符数据到文本文件中
//        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("src/shujia/day13/b1.txt"));
        //OutputStreamWriter(OutputStream out, String charsetName) 指定编码创建字符输出流对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("src/shujia/day13/b1.txt"),"GBK");

        //public void write(int c) 一次写一个字符
//        osw.write(101);
//        osw.flush();

        //public void write(char[] cbuf) 一次写一个字符数组
//        char[] chars = {'我','爱','中','国'};
//        osw.write(chars);
//        osw.flush();

        // public void write(char[] cbuf,int off,int len) 一次写字符数组的一部分
//        osw.write(chars,2,2);
//        osw.flush();

        //public void write(String str) 直接写一个字符串
        osw.write("张是世界上最帅的男人！");
        osw.flush();

        //public void write(String str,int off,int len) 写字符串的一部分
//        osw.write("张是世界上最帅的男人！", 4,3);
//        osw.flush();

        // 释放资源
        osw.close();
    }
}

BufferedWrite

BufferedReader

  java针对字符输出流和输入流提供了对应的简化写法：
    字符流 = 字节流 + 编码表：
        字符输出流：Writer【抽象类】
                    - OutputStreamWriter
                        - FileWriter
                    - BufferedWriter 特有功能：newLine()

        字符输入流：Reader【抽象类】
                    - InputStreamReader
                        - FileReader
                    - BufferedReader  特有功能：readLine()

 */
public class BufferedWriterDemo1 {
    public static void main(String[] args) throws Exception{
        // BufferedWriter(Writer out) 创建使用默认大小的输出缓冲区的缓冲字符输出流。
        // 创建字符缓冲输出流对象
//        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("src/shujia/day13/b2.txt")));
        // 简化写法
        BufferedWriter bw = new BufferedWriter(new FileWriter("src/shujia/day13/b2.txt"));
        bw.write("好好学习，天天向上！");
//        bw.write("\r\n");
        bw.newLine(); // 自动根据当前所处的系统环境生成一个换行符
        bw.write("好好学习，天天向上！");
        bw.flush();


        //创建字符缓冲输入流对象
        //BufferedReader(Reader in) 创建使用默认大小的输入缓冲区的缓冲字符输入流。
//        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("src/shujia/day13/b2.txt")));
        // 简化写法
        BufferedReader br = new BufferedReader(new FileReader("src/shujia/day13/斗罗大陆-第一章.txt"));

        // 一次读取一个字符
        // 一次读取一个字符数组

        // 一次读取一行 readLine()
        //注意：readLine()方法无法读取到换行符
//        System.out.print(br.readLine());
//        System.out.print(br.readLine());
//        String line = null;
//        while ((line = br.readLine())!=null){
//            System.out.print(line);
//            System.out.println();
//        }
        String line=null;;
        while ((line=br.readLine())!=null){
            System.out.println(line);
            System.out.println();
        }


        //释放资源
//        bw.close();
    }
}

标签：String,IO,System,File,println,public,out
From： https://www.cnblogs.com/lanzhi666/p/18678994

相关文章

  • 用Shell检查iOS字符串文件通配符
    #!/bin/shrow_number=0cat$1|whilereadrowdoletrow_number+=1running_output="${row_number}:${row}"printf"\r%-80s""${running_output:0:80}"#echo$row#row_number=`echo$row|awk'{printNR}�......
  • 在 nuget 私服 BaGet 中应用https 以及 gitea action runner 自动打包
    最近赋闲，想起之前工作中代码管理的一点经历，就是在打包项目的时候，类库的版本号几乎没变过，一个项目运行多少年了，版本号还是1.0.0。......
  • 【AI论文】Diffusion模型的推理时缩放：超越降噪步骤的缩放策略
    摘要：生成模型在各个领域产生了重大影响，这主要得益于它们能够在训练过程中通过增加数据、计算资源和模型规模来进行扩展，这一现象被称为扩展定律。最近的研究已经开始探索大型语言模型（LLMs）在推理时间的扩展行为，揭示了如何通过增加推理过程中的计算来进一步提升性能。与LLMs不同，D......
  • "moduleResolution": "node"的作用
    "moduleResolution":"node"是TypeScript编译选项之一，它指定了模块解析策略，具体来说是指定如何查找和解析模块。当你的项目中使用了import或require语句来导入其他模块时，TypeScript编译器需要知道去哪里寻找这些模块以及如何解析它们的路径。设置"moduleResolution":"no......
  • CF 265B.Roadside Trees (Simplified Edition)(Java实现)
    题目分析    松鼠的起点在第一棵树的0位置，它的行动轨迹为到达顶端，吃坚果，到另一棵树的同位置，到达顶端，吃坚果。思路分析    根据题目分析，我们需要有一个不断更新的起始位置，单次循环内的时间=到达顶端的距离+吃坚果+跳跃=顶端-起始+1+1代码        ......
  • JAVA-Exploit编写(1)--HttpURLConnection库使用
    目录1.HttpURLConnection简介2.创建HttpURLConnection请求.2.1HttpURLConnection的属性2.2设置相关的请求属性2.3 设置请求头参数3使用GET方法进行请求4.POST方法进行请求4.1常规使用4.2单独调用 5. 设置代理5.1 直接设置代理5.2 配置Proxy代理类 6.......
  • k8s集成MinIo
    本篇文章分享一下在k8s怎么集成 minio做存储，并实现PersistentVolume(PV)、PersistentVolumeClaim(PVC)、动态存储卷StorageClass，以及演示让pod使用这些存储卷的完整流程。一、理论1、PV概念PV是对K8S存储资源的抽象，PV一般由运维人员创建和配置，供容器申请使用。没有PV......
  • Resolve 01 Solution
    SolutionsT1P6571[BalticOI2017]PoliticalDevelopment看到数据范围，复杂度应该是$O(nk\cdot2^k)$。简化题面就是给一个图，满足对于任意点导出子图，存在一个节点的度数小于$k$，求原图的最大团。最大团，参考OIWiki，得到这是一个NP算法。说明这道题肯定有Trick。首先，这道题......
  • Permutation Swaps
    PermutationSwaps传送门题目理解第一个操作：把第i个数移到位置p[i](1<=i<=n)​发现：这个操作其实就是循环移位，有Teleporter的经验在前，此操作可用倍增\(\log_{2}^{n}\)实现，同时可 以推出此操作可以叠加，所以用一个sum记录操作次数，查询时一次解决​第二个操作：交换两个位置，此操作......
  • Cisco ISR 1000 Series IOS XE Release 17.16.1a ED
    CiscoISR1000SeriesIOSXERelease17.16.1aED思科1000系列集成多业务路由器IOSXE系统软件请访问原文链接：https://sysin.org/blog/cisco-isr-1000/查看最新版。原创作品，转载请保留出处。作者主页：sysin.org思科1000系列集成多业务路由器可靠性、安全性和性能......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99