IO流快速入门通俗易懂

最新推荐文章于 2022-01-08 17:15:00 发布
最新推荐文章于 2022-01-08 17:15:00 发布
阅读量295 收藏 4
点赞数 2
分类专栏： # Java基础二 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ShawnAndLove/article/details/112168004
版权

本章File内容知识主要来自B站孙探老师的讲解外加一点点个人的理解,传送门-biu

IO流

概述

  • 流是一种抽象概念，它代表了数据的无结构化传递。按照流的方式进行输入输出，数据被当成无结构的字节序或字符序列。从流中取得数据的操作称为提取操作，而向流中添加数据的操作称为插入操作。用来进行输入输出操作的流就称为IO流。换句话说，IO流就是以流的方式进行输入输出 ------百度百科
  • 图1:
    在这里插入图片描述

IO流是什么?

仔细看过上图中的朋友们一定对Io流有了略微的一点认知!
IO:Input输入流和Output输出流

  • 那么输入输出流又是什么意思?
    • 就是Java程序进行数据传输的管道
    • 流 就是管道的意思!

从图一可知,Io流主要是用来传输文件的(也就是文件的上传下载 可能不太恰当)

文件(类 File)又是什么呢?

概述:

  • 在计算机中所有数据都是以文件的格式存储的
  • 在Java中认为文件是一个对象
  • Java认为所有的东西都是对象

构造方法:

  • File (String Pathname) :根据一个路径得到File对象
  • File (String parent,String child):根据一个目录和一个子文件/目录得到File对象
  • File(File parent，String child):根据一个父File对象和一个子文件/目录得到File对象
  • 实例:
        public class FileTest {
      //File类的构造方法:
      public static void main(String[] args) {
          //第一种
          File file1 = new File("D:\\123\\123.text");
          //第二种
          File file2 = new File("D:\\123","123.text");
          //第三种
          File file = new File("D:\\123");
          File file3 = new File(file,"123.txt");
      }
  	}

成员方法:

创建功能,删除功能,重命名功能,判断功能,获取功能

创建功能
  • public boolean createNewFile():创建文件,如果存在这样的文件，就不创建了
  • public boolean mkdir ( ):创建文件夹,如果存在这样的文件夹，就不创建了(make dirctory)
  • public boolean mkdirs () :创建文件夹,如果父文件夹不存在，会帮你创建出来
  • 实例:
    public class FileTest2 {
    //File类的构造方法:
    public static void main(String[] args) throws Exception {
        /**
         * public boolean createNewFile():创建文件,如果存在这样的文件，就不创建了
         */
        File file = new File("D:\\123\\b.txt");
        boolean b = file.createNewFile();
        System.out.println(b);
        //如果没有指明创建路径,那么该文件是在项目路径下创建的!
        File file2 = new File("b.txt");
        file2.createNewFile();
        /**
         * public boolean mkdir ( ):创建文件夹,如果存在这样的文件夹，就不创建了(make dirctory)
         * 该方法不能创建多层文件夹
         */
        File file3 = new File("D:\\123\\123456");
        boolean mkdir = file3.mkdir();
        System.out.println(mkdir);
        /**
         * public boolean mkdirs () :创建文件夹,如果父文件夹不存在，会帮你创建出来
         * 该方法可以创建多层文件夹
         */
        File file4 = new File("D:\\123\\123\\123");
        boolean mkdirs = file4.mkdirs();
        System.out.println(mkdirs);
    }
}
删除功能
  • public boolean delete():可以用来删除文件和文件夹
  • delete删除的文件夹下面不能有文件或文件夹!!!
    实例:
    
public class FileTest3 {
    public static void main(String[] args) throws Exception {
        //注意:delete删除的文件夹下面不能有文件或文件夹
        File file = new File("D:\\123");
        File file2 = new File("D:\\123.txt");
        file.delete();
        file2.delete();
    }
}
重命名功能
  • public boolean renameTo(File dest):可以给文件或者文件夹改名字
  • 如果File改名的路径是在同一路径下,就是重命名
  • 如果File改名的路径不是在同一路径下,就是重命名并移动!
    实例:
    public class FileTest4 {
    public static void main(String[] args) throws Exception {
        //把"D:\123"文件夹的名字改为"D:\12345"
        File file = new File("D:\\123");
        File file2 = new File("D:\\12345");
        file.renameTo(file2);
        //把"D:\123.txt"的的名字改为"12345.txt"
        File file3 = new File("D:\\123.txt");
        file3.renameTo(new File("D:\\12345.txt"));
        //改名并移动
        File file5 = new File("D:\\12345.txt");
        file5.renameTo(new File("D:\\12345\\123456.txt"));
    }
}
判断功能
  • public boolean isDirectory():判断是否是目录
  • public boolean isFile():判断是否是文件
  • public boolean exists ()∶判断是否存在
  • public boolean canRead():判断是否可读
  • public boolean canwrite():判断是否可写
  • public boolean isHidden ():判断是否隐藏
    实例:
    public class FileTest5 {
    public static void main(String[] args) throws Exception {
        //判断是否是文件
        File file1 = new File("D:\\12345");
        boolean file = file1.isFile();
        System.out.println(file);
        //判断是否是文件夹
        File file2 = new File("D:\\12345\\123456.txt");
        boolean directory = file2.isDirectory();
        System.out.println(directory);
        //判断为文件是否存在
        boolean exists = file2.exists();
        System.out.println(exists);
        //判断是否可读
        boolean b = file2.canRead();
        System.out.println(b);
        //判断是否可写
        boolean b1 = file2.canWrite();
        System.out.println(b1);
        //判断是否隐藏
        boolean hidden = file2.isHidden();
        System.out.println(hidden);
    }
}
获取功能
  • public string getAbsolutePath ():获取绝对路径
  • public string getPath():获取相对路径
  • public string getName () :获取名称
  • public long length ():获取长度。字节数
  • public long lastModified():获取最后一次的修改时间，毫秒值

相对路径:从当前文件/文件夹所在的位置开始，一直到你想去的某个文件/文件夹下就叫做相对路径。
绝对路径:文件在系统磁盘上的路径，从盘符开始，一直到文件/文件夹的名称就叫做绝对路径。

  • public string[] list():获取指定目录下的所有文件或者文件夹的名称数组
  • public File[] listFiles():获取指定目录下的所有文件或者文件夹的File数组

实例:

public class FileTest6 {
    public static void main(String[] args) throws Exception {
        File file = new File("D:\\12345\\123456.txt");
        //获取绝对路径
        String absolutePath = file.getAbsolutePath();
        System.out.println(absolutePath);
        //获取相对路径
        String path = file.getPath();
        System.out.println(path);
        //获取名称
        String name = file.getName();
        System.out.println(name);
        //获取长度。字节数
        long length = file.length();
        System.out.println(length);
        //获取最后一次的修改时间 精确到毫秒
        long l = file.lastModified();
        Date date = new Date(l);
        System.out.println(date.toLocaleString());

        //获取指定目录下的所有文件或者文件夹的名称数组
        File files = new File("D:\\12345");
        String[] list = files.list();
        for (String s : list) {
            System.out.println(s);
        }
        //获取指定目录下的所有文件或者文件夹的File数组
        File[] files1 = files.listFiles();
        for (File fil2:files1) {
            System.out.println(fil2.getAbsolutePath());
        }
    }
}

File说完了再回到IO流

IO流的分类:

根据流向可以分为:(不管是输入流还是输出流都是根据你当前的程序而言的)

  • 输入流:(读read) input
  • 输出流:(写write) output

根据传输的内容分为:

  • 字节数据: 图片,视频,音频

    • 字节输入流:InputStream
    • 字节输出流:OutputStream

  • 字符数据:abcd

    • 字符输入流:Reader
    • 字符输出流:Writer

  • 不管是字符流还是字节流,底层流动的都是字节!

图解:
在这里插入图片描述
这里主要来看InputStream和OutputStream

字节流InputStream

概念
  • InputStream是所有字节输入流的顶层父类，是一个抽象类。如果要用，需要使用子类。(FileInputStream)
    • FileInputStream流被称为文件字节输入流，意思指对文件数据以字节的形式进行读取操作如读取图片视频等

换句话说呢就是不用管 InputStream 是干嘛的,只需要知道他的子类FileInputStream很有用就行,而他的子类怎么用呢,看下面 :

FileInputStream构造方法：
  1. FileInputStream​(File file)： 传递一个File类型的文件
  2. FileInputStream​(String name)： 传递一个String类型的文件路径
    推荐使用下面这种方法:

FileInputStream inputStream = new FileInputStream(“a.txt”);

  1. public FileOutputStream(File file, boolean append)
  2. public FileOutputStream(String name, boolean append)

创建一个FileinputStream对象，并绑定一个数据源文件
如果文件不存在，则会抛出异常（File Not Found Exception）

构造方法实例:

  •   public class FileInputStreamTest1 {
      public static void main(String[] args) throws FileNotFoundException {
          //使用file对象创建流对象
          File file =  new File("D:\\12345\\123.mp4");
          FileInputStream fileInputStream = new FileInputStream(file);
          //使用文件名称创建流对象
          FileInputStream fileInputStreams = new FileInputStream("D:\\12345\\123.mp4");
      }
  }
FileInputStream读取字节数据：
  • 1.读取字节:read()方法,每次可以读取一个字节的数据，提升为int类型，读取到文件末尾,返回-1
    • 实例:
          public class FileInputStreamTest2 {
      public static void main(String[] args) throws IOException {
          //使用read()方法,读取一个字节的数据
          //使用文件名称创建流对象
          FileInputStream fileInputStream = new FileInputStream("D:\\12345\\123456.txt");
          int read = fileInputStream.read();
          System.out.println((char)read);
          read = fileInputStream.read();
          System.out.println((char)read);
          read = fileInputStream.read();
          System.out.println((char)read);
          read = fileInputStream.read();
          System.out.println((char)read);//已经读不到数据了
          System.out.println(read);//读取到最后没有信息了会返回-1
          fileInputStream.close();//关闭资源
      }
  }
  • 2.使用字节数组读取:***read(byte[] b)***,每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1
    • 实例:
        public class FileInputStreamTest3 {
     public static void main(String[] args) throws IOException {
          //使用read(byte[] b)方法,读取数据
          //使用文件名称创建流对象
          FileInputStream fileInputStream = new FileInputStream("D:\\12345\\123456.txt");
          int len;
          byte[] b = new byte[2];
          while ((len=fileInputStream.read(b))!=-1){
              System.out.println(new String(b));
          }
          fileInputStream.close();//关闭资源
      }
  }

字节流OutputStream

概念
  • OutputStream是所有字节输出流的顶层父类，是一个抽象类，如果要用，需要使用子类。 常用的子类FileOutputStream 文件输出流
  • 字节输出流的基本共性功能方法:
    • public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
    • public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
    • public void write(byte[] b)：将 b.length个字节从指定的字节数组写入此输出流。
    • public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。 也就是说从off个字节数开始读取一直到len个字节结束
    • public abstract void write(int b) ：将指定的字节输出流。

以上五个方法则是字节输出流都具有的方法，由父类OutputStream定义提供，子类都会共享以上方法

FileOutputStream构造方法
  • FileOutputStream​(File file)： 传递File类型的文件。
  • FileOutputStream​(String name)： 传递一个字符串类型的文件路径。
    推荐下面这种写法

FileOutputStream outputStream = new FileOutputStream(“abc.txt”);

注意:创建输出流对象的时候，系统会自动去对应位置创建对应文件，而创建输出流对象的时候，文件不存在则会报FileNotFoundException异常，也就是系统找不到指定的文件异常。

  • 当你创建一个流对象时，必须直接或者间接传入一个文件路径。在该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。
    实例:
      public class FileOutputStreamTest1 {
      public static void main(String[] args) throws FileNotFoundException {
          //使用FIle对象创建流对象
          File file = new File("D:\\12345\\123456.txt");
          FileOutputStream fileOutputStream = new FileOutputStream(file);
          //使用文件名创建流对象
          FileOutputStream fileOutputStream2 = new FileOutputStream("D:\\12345\\123456.txt");
  
      }
  }
FileOutputStream导出字节数据

使用FileOutputStream写出字节数据主要通过Write方法，而write方法分如下三种:

  • public void write(int b)
  • public void write(byte[] b)
  • public void write(byte[] b,int off,int len) //从off索引开始，len个字节
1.写出字节,write(int b) 方法，每次可以写出一个字节数据

实例:

	class FileOutputStreamTest2 {
	    public static void main(String[] args) throws IOException {
	        //使用FIle对象创建流对象
	        FileOutputStream fos = new FileOutputStream("D:\\12345\\123456.txt");
	        //写出数据
	        fos.write(97);
	        fos.write(98);
	        fos.write(99);
	        fos.close();
	    }
	}

虽然参数为int类型四个字节，但是只会保留一个字节的信息写出。
流操作完毕后，必须释放系统资源，调用close方法，千万记得。

2.写出字节数组 ,write(byte[] b)，每次可以写出数组中的数据

实例:

class FileOutputStreamTest3 {
    public static void main(String[] args) throws IOException {
        //使用FIle对象创建流对象
        FileOutputStream fos = new FileOutputStream("D:\\12345\\123456.txt");
        //字符串转换为数组
        byte[] b = "一给我里GIAO".getBytes();
        //写出字节组数据
        fos.write(b);
        //关闭资源
        fos.close();
    }
}
3.写出指定长度字节数组:write(byte[] b, int off, int len) ,每次写出从off索引开始，len个字节

实例:

class FileOutputStreamTest4 {
    public static void main(String[] args) throws IOException {
        //使用FIle对象创建流对象
        FileOutputStream fos = new FileOutputStream("D:\\12345\\123456.txt");
        //字符串转换为数组
        byte[] b = "qwertyuiop".getBytes();
        //写出字节组数据
        fos.write(b,2,2);
        //关闭资源
        fos.close();
    }
}

字节流在这就告一段落了,更深一点的方法也不说了(我也不会,还在学 hhhh~)，再说一说字符流：

什么时候用字符流,什么时候用字节流呢?
答案很简单:
如果处理纯文本数据的情况,优先考虑字符流!而处理图片,音频,视频...使用字节流比较好

字符流(Reader,Writer)

Reader字符输入流
  • java.io.Reader抽象类是字符输入流的所有类的超类（父类），可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。
FileReader类
  • java.io.FileReader类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
构造方法
  • FileReader(File file)： 创建一个新的 FileReader ，给定要读取的File对象。
  • FileReader(String fileName)： 创建一个新的 FileReader ，给定要读取的文件的字符串名称。

实例:

public class ReaderTest1 {
    public static void main(String[] args) throws FileNotFoundException {
        //使用file对象创建流对象
        File file = new File("D:\\12345\\123456.txt");
        FileReader fileReader = new FileReader(file);
        //使用文件名称创建流对象
        FileReader fileReader1 = new FileReader("D:\\12345\\123456.txt");
    }
}
FileReader读取字符数据
  • 读取字符：read方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回-1，循环读取

实例:

public class ReaderTest2 {
    public static void main(String[] args) throws IOException {
        //使用文件名称创建流对象
        FileReader file = new FileReader("D:\\12345\\123456.txt");
        // 定义变量，保存数据
        int b;
        // 循环读取
        while ((b = file.read())!=-1) {
            System.out.println((char)b);
        }
        // 关闭资源
        file.close();
    }
}
Writer字符输出流
  • java.io.Writer抽象类是字符输出流的所有类的超类（父类），将指定的字符信息写出到目的地。它同样定义了字符输出流的基本共性功能方法。
字符输出流的基本共性功能方法：
  • void write(int c) 写入单个字符。
  • void write(char[] cbuf)写入字符数组。
  • abstract void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
  • void write(String str)写入字符串。
  • void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
  • void flush()刷新该流的缓冲。
  • void close() 关闭此流，但要先刷新它。
FileWriter类
  • java.io.FileWriter类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
构造方法
  • FileWriter(File file)： 创建一个新的 FileWriter，给定要读取的File对象。
  • FileWriter(String fileName)： 创建一个新的 FileWriter，给定要读取的文件的名称。

实例:

public class WriterTest1 {
    public static void main(String[] args) throws IOException {
        //使用file对象创建流对象
        File file = new File("D:\\12345\\123456.txt");
        FileWriter fileWriter = new FileWriter(file);
        //使用文件名称创建流对象
        FileWriter fileWriter2 = new FileWriter("D:\\12345\\123456.txt");
    }
}
写出数据
  • 写出字符：write(int b) 方法，每次可以写出一个字符数据
    public class WriterTest2 {
    public static void main(String[] args) throws IOException {
        //使用文件名称创建流对象
        FileWriter fw = new FileWriter("D:\\12345\\123456.txt");
        //写出数据
        fw.write(97); //写出第一个字符
        fw.write('b');//写出第二个字符
        fw.write('c');//写出第三个字符

        //关闭资源时,与FileOutputStream不同。 如果不关闭,数据只是保存到缓冲区，并未保存到文件
        fw.close();
    }
}

关闭资源时,与FileOutputStream不同。 如果不关闭,数据只是保存到缓冲区，并未保存到文件

关闭close和刷新flush
  • 因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据的。如果我们既想写出数据，又想继续使用流，就需要flush 方法了。
  • flush ：刷新缓冲区，流对象可以继续使用。
  • close:先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。
    实例:
    public class WriterTest3 {
    public static void main(String[] args) throws IOException {
        //源   也就是输入流【读取流】 读取a.txt文件
        FileReader fr=new FileReader("D:\\12345\\123456.txt");  //必须要存在123456.txt文件，否则报FileNotFoundException异常
        //目的地  也就是输出流
        FileWriter fw=new FileWriter("D:\\12345\\123.txt");  //系统会自动创建123.txt，因为它是输出流！
        int len;
        while((len=fr.read())!=-1){
            fw.write(len);
        }
        fr.close();
        fw.flush();
        fw.close();
    }
}

IO流中的压缩

  • 压缩压缩,肯定是将数据压缩成压缩包,这就是输出流.因为不确定数据是什么类型,纯文本啊,还是音视频之类的.所以建议直接就写成字节流
  • 实例:
      public class ZipTest1 {
      public static void main(String[] args) throws Exception {
      	//使用文件名称创建流对象
          FileOutputStream fos = new FileOutputStream("D:\\12345\\123456789.zip") ;
          ZipOutputStream zos= new ZipOutputStream(fos) ;
          //写入一个条目，我们需要给这个条目起个名字，相当于起一个文件名称
          zos.putNextEntry(new ZipEntry("qwe"));
          //往这个条目中写入一定的数据
          zos.write("QQQ".getBytes());
          //关闭条目
          zos.closeEntry();
  
          zos.putNextEntry(new ZipEntry("asd"));
          zos.write("WWW".getBytes());
          zos.closeEntry();
  
          zos.putNextEntry(new ZipEntry("zxc"));
          zos.write("EEE".getBytes());
          zos.closeEntry();
          zos.close();
      }
  }
  • 解压!
      public class UnZipTest {
      public static void main(String[] args) throws Exception {
          FileInputStream fis = new FileInputStream("D:\\12345\\123456789.zip");
          ZipInputStream zis = new ZipInputStream(fis);
          ZipEntry entry = null ;
          byte[] buf = new byte[1024] ;
          int len = 0 ;
          //此处我们需要判断是否zis流中存在条目，你可以理解为是否存在文件内容
          while((entry = zis.getNextEntry()) != null){
              //此处我们获取条目名称
              String name = entry.getName();
              System.out.println(name);
              //我们将每一个条目进行解压，我们需要指定一个输出路径
              FileOutputStream fos = new FileOutputStream("D:\\12345\\"+ name) ;
              while((len = zis.read(buf)) != -1){
                  fos.write(buf , 0 , len);
              }
              fos.close();
          }
          zis.close();
          fis.close();
      }
  }

IO流的转换

编码

  • InputStreamReader 继承于Reader，是字节流通向字符流的桥梁，可以把字节流按照指定编码 解码 成字符流。

实例:

public class InputStreamReaderTest {
    public static void main(String[] args) throws IOException {
        File file = new File("D:\\12345\\123456.txt");
        String haha="i like you too";
        //1.创建通道
        FileOutputStream fileOutputStream=new FileOutputStream(file);
        //2.创建转换流
        OutputStreamWriter writer=new OutputStreamWriter(fileOutputStream,"UTF-8");
        //3.写入数据
        writer.write(haha);
        //4.刷新缓冲区
        writer.flush();
        //5.关闭通道
        writer.close();
        //6.关闭转换流
        fileOutputStream.close();
    }
}

解码

  • InputStreamReader 继承于Reader，是字节流通向字符流的桥梁，可以把字节流按照指定编码 解码 成字符流。

实例:

public class InputStreamWriter {
    public static void main(String[] args) throws IOException {
        File file = new File("D:\\12345\\123456.txt");
        FileInputStream fileInputStream = new FileInputStream(file);
        InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream,"UTF-8");
        char[] cbuf=new char[2];
        int len;
        StringBuilder sb=new StringBuilder();
        while((len=inputStreamReader.read(cbuf))!=-1){
            sb.append(cbuf, 0, len);
        }
        System.out.println(sb.toString());
    }
}

本节完
文中借鉴内容摘抄自:
https://www.cnblogs.com/yichunguo/p/11775270.html
https://www.cnblogs.com/luojack/p/10823365.html

ShawnAndLove
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Node.js快速入门视频课程（通俗易懂）【2020版】
06-18
本课程以通俗易懂的方式讲解 Node.js 技术，帮您快速入门！ 课程内容包括： 1.Node.js简介 2.Node.js环境搭建 3.模块化简介 4.模块化的导出和导入 5.npm简介 6.npm常用命令和使用 7.全局模块nrm 8.第三方模块的安装...
Python入门视频精讲
06-10
Python入门视频培训课程以通俗易懂的方式讲解Python核心技术，Python基础，Python入门。适合初学者的教程，让你少走弯路！课程内容包括：1.Python简介和安装 、2.第一个Python程序、PyCharm的使用 、3.Python基础、4...
初识 Elasticsearch7.16.x（二）
有天你会让我妒忌的.
01-08 1347
一个索引就是一个拥有几分相似的文档的集合。 比如说，你可以有一个商品数据的索引，一个订单数据的索引，还有一个用户数据的索引。一个索引由一个名字来标识（必须全都是小写字母的），并且当我们要对这个索引中的文档进行索引、搜索、更新和删除的时候，都要使用到这个名字。...
Elasticsearch: API 响应的一些常用选项
Elastic 中国社区官方博客
01-01 1722
我们可以点击Elasticsearch API以获取所需的响应，但是如果要修改API响应，以便我们更改显示格式或过滤掉某些字段，然后我们可以将这些选项与查询一起应用。 有一些常见的选项可以适用于API，在下面我们来介绍一些常用的选项。 准备数据 我们首先使用Bulk API来把我们的文档导入到Elasticsearch中： POST _bulk { "index" : { "_ind...
第六章 ES高级搜索—聚集查询（上）
hankin的博客
07-21 2664
聚集查询(Aggregation)提供了针对多条文档的统计运算功能，它不是针对文 档本身内容的检索，而是要将它们聚合到一起运算某些方面的特征值。 聚集查询与SQL语言中的聚集函数非常像，聚集函数在Elasticsearch中相当于是聚集查询的一种聚集类型。比如在SQL中的avg函数用于求字段平均值， 而在Elasticsearch中要实现相同的功能可以使用avg聚集类型。 聚集查询也是通过_search接口执行，只是在执行聚集查询时使用的参数是aggregations或aggs。所以_search接口可
elasticsearch（es）在用户画像业务上的应用【elasticsearch（es）性能调优】
老艮头的后知后觉
12-24 4891
1、关于用户画像 用户画像是以用户为中心，从不同角度抽取信息，抽象成标签。这些标签一般都会很多，针对不同的业务需求、应用场景会刻画不同的标签。可以通过标签来圈选适合的人群，来进行精准投放。广告系统、活动营销、内容推荐都可以是基于用户画像的应用。 2、标签到底能有多少 这个和业务体量、业务流程、产品形态都有密切关系。 互联网行业的用户规模往往千万乃至上亿，那么可能各区域、各行业、各阶层、各年龄段都能覆盖，用户的天然属性就可以抽象的维度就会很多。再加上和业务相关的各种属性，比如用户的浏览行为、购买行为、售后行为
python操作elasticsearch
Python热爱者的博客
11-09 2601
一、基本查询 from elasticsearch import Elasticsearch # 建立连接 es = Elasticsearch( hosts={'192.168.0.120', '192.168.0.153'}, # 地址 timeout=3600 # 超时时间 ) es.search(index='pv23') # index：选择数据库 此方法是默认查询，由于没有任何筛选条件，会默认显示前10条数据的所有信息 二、filter_path 添加过滤路径。通
flink入门到精通视频教程
07-15
2.生动形象，化繁为简，讲解通俗易懂。 3.结合工作实践及分析应用，培养解决实际问题的能力。 4.每一块知识点, 都有配套案例, 学习不再迷茫。 课程内容： 1.Flink框架简介 2.Flink集群搭建运维 3.Flink Dataset开发 ...
OpenSceneGraph快速入门指导
01-09
Don 将这一文档开发工作转交给Paul Martz，而Robert 则建议第一 本OSG 的书籍应当是免费且通俗易懂的。因此，《OpenSceneGraph 快速入门指 导》诞生了。这本书是一个简短的编程指南，它介绍了基本和核心的OSG ...
FactoryIO输送线汇流仿真实验程序 使用简单的梯形图编写，逻辑清晰，通俗易懂，写有详细注释，起到抛砖引玉的作用，比较适合有
05-24
使用简单的梯形图编写，逻辑清晰，通俗易懂，写有详细注释，起到抛砖引玉的作用，比较适合有动手能力的入门初学者 软件环境： 1、西门子编程软件：TIA Portal V16（博图V16） 2、西门子仿真软件：PLCSIM V16 3、...
Elasticsearch：使用 Path Hierarchy Tokenizer 搜索层次结构
Elastic 中国社区官方博客
09-27 668
本文介绍了如何解决一个常见问题，该问题通常通过使用 Elasticsearch 中称为路径层次结构 tokenizer的功能来查看不同的解决方案，从而通过父/子关系或递归关系来解决。 你可以用这个覆解决什么用例？ 在我们深入研究之前，让我们先了解一下使用案例！ 有两个常见的用例，我立即想到了 - 我相信还有更多！ 第一个是关于对文件系统建模，文件路径如下所示： /home/alr/devel/spinscale.de/website /home/alr/devel/spinscale.de/w.
IO流 (汇总--＞通俗易懂版)
weixin_42960873的博客
07-17 153
File文件类: 创建file对象并关联文件/文件夹 File f = new File(路径/名称); File f = new File(路径, 名称) (File对象只是关联文件/文件夹, 并不会创建) 路径是字符串 file对象就是名称 file对象 要么是文件 要么是文件夹 打印file对象 显示名称所在位置 有盘符的是绝对路径, 具有唯一性 / 没盘符的是相对路径 File对象.getName(): 获取名称 File对象.isFile(): 文件格式 File对象.isDirectory():
在知乎看到的解释io流非常通俗的文章，记下来以后自己看
qq_41464399的博客
08-17 198
作者：大概是条废咸鱼 链接：https://www.zhihu.com/question/67535292/answer/1248887503 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 初学者觉得复杂是很正常的，归根结底是因为没有理解JavaIO框架的设计思想： 可以沿着这条路想一想： 1，学IO流之前，我们写的程序，都是在内存里自己跟自己玩。比如，你声明个变量，创建个数组，创建个集合，写一个排序算法，模拟一个链表，使用一些常用API，现在回想一下，是不是在只是
一文搞懂IO流
pipi蛋
06-19 435
前言 io流在Java的知识体系中，属于很杂的那种了，主要是涉及的类太多，输入流、输出流、文件输入流、文件输出流、字节输入流和输出流、字符输入流和输出流等等，经常把人弄晕。但是它的用途却非常广泛，文件的操作、网络的操作等都离不开它，本文通过平时常用操作来梳理一下io流中涉及的重要类及方法。 什么是流 在Java中，文件一般不是单独处理的，而是视为输入输出设备的一种，Java使用一个统一的概念来处理所有的输入输出，包括键盘输入和网络输入输出等。这个统一的概念就是流，流又分为输入流和输出流，InputStrea
如何快速理解Java的IO流
欢迎光临
05-28 362
初学者觉得IO流复杂是很正常的，归根结底是没有理解JavaIO框架的设计思想：可以沿着这条路想一想： 1，学IO流之前，我们写的程序，都是在内存里自己跟自己玩。比如，你声明个变量，创建个数组，创建个集合，模拟一个链表，使用一些常用API，现在回想一下，是不是在只是自己在内存里玩一玩？计算机组成包括运算器，控制器，存储器，输入设备，输出设备。那么你前面的工作，仅仅够你的程序和内存以及CPU打交道，如果你需要操作外部设备呢？比如键盘，显示器，再比如，最常见的外设：硬盘？ 2，所以程序设计语言必须要提供程序与外部
通俗易懂讲解IO模型
w
08-09 468
Java I/O模型 所谓的I/O就是计算机内存与外部设备之间拷贝数据的过程，因此CPU是先把外部设备的数据读到内存里，然后再进行处理。 对于一个网络I/O通信过程，比如网络数据读取，会涉及两个对象，一个是调用这个I/O操作的用户线程，另外一个就是操作系统内核。一个进程的地址空间分为用户空间和内核空间，用户线程不能直接访问内核空间。 当用户线程发起I/O操作后，网络数据读取操作会经历两个步骤： 用户线程等待内核将数据从网卡（外部设备）拷贝到内核空间。 内核将数据从内核空间拷贝到用户空间。 各种I/O模型
java面经通俗易懂
最新发布
03-03
Java面经是指在面试过程中常被问到的与Java相关的问题和知识点。下面是一些常见的Java面经问题及其解答： 1. Java的特点是什么？ Java是一种面向对象的编程语言，具有跨平台性、简单性、可靠性、安全性和高性能等特点。 2. 什么是Java虚拟机（JVM）？ JVM是Java程序运行的环境，它负责将Java源代码编译成字节码，并在不同的操作系统上执行。 3. 什么是面向对象编程（OOP）？ 面向对象编程是一种编程范式，它将数据和操作数据的方法封装在一起，通过创建对象来实现程序的功能。 4. Java中的四种访问修饰符分别是什么？ Java中的四种访问修饰符分别是public、protected、default和private，用于控制类、方法和变量的访问权限。 5. 什么是Java中的异常处理机制？ 异常处理机制是Java中用于处理程序运行过程中出现的异常情况的一种机制，通过try-catch-finally语句块来捕获和处理异常。 6. 什么是Java中的多线程？ 多线程是指在一个程序中同时执行多个线程，每个线程都可以独立执行不同的任务，提高程序的并发性和效率。 7. 什么是Java中的集合框架？ 集合框架是Java中用于存储和操作一组对象的类库，包括List、Set、Map等常用的数据结构和算法。 8. 什么是Java中的反射机制？ 反射机制是指在运行时动态地获取和操作类的信息，可以通过反射来创建对象、调用方法和访问属性等。 9. 什么是Java中的IO流？ IO流是Java中用于输入和输出数据的一种机制，包括字节流和字符流，用于读取和写入文件、网络等数据源。 10. 什么是Java中的设计模式？ 设计模式是一种解决常见软件设计问题的经验总结，包括单例模式、工厂模式、观察者模式等常用的设计模式。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值