javaSE----IO流

最新推荐文章于 2022-07-16 08:46:10 发布
最新推荐文章于 2022-07-16 08:46:10 发布
阅读量244 收藏 1
点赞数
分类专栏： javaSE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45785893/article/details/106007231
版权

OI流

1. File类

概念：文件名或者目录名的一种抽象表示形式，简单来说就是表示目录或者文件名的

构造方法

public File (String pathname):直接指定当前路径，创建一个File对象
	File file = new File ("F:\\test\\a.txt"); 
public File (String parent ,String child):指定一个父目录，child文件或者文件夹，创建一个File对象
	File file1 = new File ("F\\demo","\\a.txt"); 
public File(File parent,String child):创建一个File对象 
		参数一：File文件对象，描述某个父目录
		参数二：子目录或者子文件夹

创建功能

public boolean createNewFile() throws IOException:创建一个文件，如果存在，不会创建

public boolean mkdir(): 创建一个目录，如果存在，目录不会创建，返回false，如果不存在，创建，返回true
			注意事项：一次只能创建单个目录，如果要创建多级目录，必须父目录存在，否则false
			
public boolean mkdirs():创建目录，一次创建多个目录，如果当前目录不存在，就会自动创建
	如果没有指定路径，默认在当前路径下创建文件以及文件夹

删除功能

public boolean delete () 删除此抽象路径名表示的文件或者目录，如果此路径名表示一个目录，则该目录必须为空才能删除

重命名功能

	public boolean renameTo (File dest);
	参数：指定的文件路径
	1.如果两次表达dest路径一致的话，仅仅是改名字
	2.如果两次表单路径不一致的话，改名并剪切到指定路径 如果是多级目录，父目录必须存在；
	File f1 = new File("杨桃.jpg") ;
	File f2 = new File("e:\\高圆圆.jpg") ;  
	System.out.println("renamteTo():"+f1.renameTo(f2));

判断功能

public boolean isDirectory() :判断是否是文件夹
public boolean isFile() ：判断是否是文件  
public boolean exists()	：判断是否存在
public boolean canRead()  ：判断是否可读 只能读取内容
public boolean canWrite() ：判断是否是可写 可写 可以修改和删除里面内容
public boolean isHidden() ：是否是隐藏的文件或者文件夹

获取功能

public String getAbsolutePath()	：绝对路径
public String getPath()	：相对路径
public String getName() ：获取File对象的名称
public long length()	：获取长度（此抽象路径名表示的文件的长度，以字节为单位）
public long lastModified()：最后一次操作当前文件或者目录的时间戳  返回值是一个时间毫秒值

		File f =new File ("bean.txt");
System.out.println(f.getAbsolutePath()); //D:\wangchao\com.wangchao.oi\bean.txt
System.out.println(f.getPath());   //bean.txt
System.out.println(f.getName());	//bean.txt
		File f =new File ("E:\\bean.txt"); （nihao吗？）
System.out.println(f.getAbsolutePath());  //E:\bean.txt
System.out.println(f.getPath());   //  E:\bean.txt
System.out.println(f.length());   // 8  返回当前文件中内容的字符长度

File的高级获取功能

public File[] listRoots():列出可用的文件系统根 即列出计算机磁盘的盘符；
public String [] list();返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录
	列出文件名
public File[] listFiles():返回的是一个File数组，这些路径名表示此抽象路径名表示的目录中的文件
	列出文件的绝对路径  返回的是一个File类的引用 它具有类的所有属性和方法

2. io流

流的分类：按照数据类型划分
字节流 
	字节输入流  inputStream 读取数据
	字节输出流  outputStream 写出数据
字符流
	字符输入流  Reader
	字节输出流  Writer
		
按照流向划分 ：
	输入流：都是将数据读取出来（控制体输出/读取到服务器端）输入流是指从外围设备流向主机（包括CPU和内存）的数据流。
	输出流：将数据写出到指定位置（将服务器读取到的数据写到客户端）

2.1 节点流

2.1.1 字节流
1 .字节输入流
/**
 * @Author 
 * @Date 
 * FileInputStream的基本测试
 */
public class InPutStreamTest01 {
    public static void main ( String[] args ) {
        try {
            File file = new File("hello.txt");
            FileInputStream fileInputStream = new FileInputStream(file);
//            一次读取一个字节
            int by;
            while ((by = fileInputStream.read())!=-1){
                System.out.print((char)by);
            }
//            一次读取一个字节数组
            byte [] bytes = new byte[1024];
            int len;
            while ((len=fileInputStream.read(bytes))!=-1){
                System.out.print(new String(bytes,0,len));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
2.字节输出流
/**
 * @Author 
 * @Date 
 *FileOutputStream的基本测试
 */
public class OutputStreamTest {

    public static void main ( String[] args ) throws Exception {
//        目标文件
       File srcFile = new File("hello.txt");
//       写入流写入的文件
        File desFile = new File("world.txt");
//        获取输入 输出流
        FileInputStream inputStream = new FileInputStream(srcFile);
        FileOutputStream outputStream = new FileOutputStream(desFile);
//        一次写入一个字节数组
        byte [] bytes = new byte[1024];
        int len;
        while ((len=inputStream.read(bytes))!=-1){
            outputStream.write(bytes,0,len);
        }
        outputStream.close();
        inputStream.close();
    }
}
2.2.2字符流
1. 字符输入流
/**
 * @Author xiaoqi
 * @Date 
 * FileReader的一个基本测试
 */
public class ReaderTest001 {

    public static void main ( String[] args ) throws IOException {
        File file = new File("hello.txt");
        FileReader reader = new FileReader(file);
//        这里有一次读取一个字符和一个字符数组，与字节输入流类似，这里以一次读取一个字符数组为例
        char [] chars = new char[1024];
        int len;
        while ((len=reader.read(chars))!=-1){
            System.out.print(new String(chars,0,len));
        }
    }
}
2.字符输出流
/**
 * @Author xiaoqi
 * @Date 
 * FileWriter类的一个基本测试
 */
public class FileWriterTest001 {
    public static void main ( String[] args ) throws Exception {
        File srcFile = new File("hello.txt");
        File desFile = new File ("java.txt");
        FileReader reader = new FileReader(srcFile);
        FileWriter writer = new FileWriter(desFile);
        char [] chars = new char[1024];
        int len;
        while((len=reader.read(chars))!=-1){
            writer.write(chars,0,len);
            writer.flush();
        }
        writer.close();
        reader.close();
    }
}

2.2 缓冲流

BufferedOutputStream:字节缓冲输出流
public BufferedOutputStream(OutputStream out):创建缓冲输出流对象,缓冲区默认的(使用居多,缓冲大小足够大!)
public BufferedOutputStream(OutputStream out,int size):创建缓冲输出流对象并且指定缓冲大小
  
BufferedInPutStream：字节缓冲输入流
public BufferedInPutStream(InputStream in);创建缓冲输入流对象，缓冲区默认无限大
public BufferedInPutStream(InPutStream in , int size)创建缓冲输入流对象，并且指定大小
 
BufferedReader：字符缓冲输入流
BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流。 
BufferedReader(Reader in, int sz)  创建一个指定缓冲大小
读取的特有功能:public String readLine() :一次读取一行内容
  
BufferedWriter：字符缓冲输出流  
public BufferedWriter(Writer out):提供默认缓冲区大小的字符缓冲输出流,默认缓冲区足够大
public BufferedWriter(Writer out,int size):指定缓冲大小的
BufferedWriter的特有功能 ：public void newLine():写入一个新的行分隔符
  
处理流的作用： 提高流的读取，写入速度，原因：内部提供了一个缓冲区
2.2.1 字节缓冲流的使用
/**
 * @Author xiaoqi
 * @Date 
 * 字节流的图片复制 的使用
 */
public class BufferedTest001 {
    BufferedInputStream bs;
    BufferedOutputStream bo;

    @Test
    public void copyPhoto()  {
        try {
//            声明字节缓冲流
           bs =  new BufferedInputStream(new FileInputStream("D:\\360downloads\\298277.jpg"));
           bo =  new BufferedOutputStream(new FileOutputStream("F:\\123.jpg"));
//            创建字节数组
            byte [] bytes = new byte[1024];
            int len;
//            进行复制操作
            while((len = bs.read(bytes)) != -1){
                bo.write(bytes,0,len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
//            关闭资源，先创建的后关闭
            if (bo!= null){
                try {
                    bo.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bs!= null){
                try {
                    bs.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}
2.2.2字符缓冲流的使用
/**
 * @Author xiaoqi
 * @Date 
 * 字符缓冲流的复制操作，使用缓冲流的特有API
 */
public class BufferedTest002 {

    BufferedReader bd;
    BufferedWriter bw;
    @Test
    public void copyTxtByBuffered(){
        try {
//            获取字符缓冲流
         bd = new BufferedReader(new FileReader("hello.txt"));
         bw = new BufferedWriter(new FileWriter("hello1.txt"));
//         利用字符缓冲流提供的特有方法来进行复制操作
            String str;
//            bd.readLine() 一次读取一行数据
            while ((str = bd.readLine())!= null){
                bw.write(str);
                bw.newLine();   //换行
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if (bw != null){
                    bw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (bd != null){
                    bd.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

2.3 转换流

OutputStreamWriter:字符转换输出流
	构造方法
 	public OutputStreamWriter(OutputStream out):使用默认的编码格式创建字符流对象
	public OutputStreamWriter(OutputStream out,Charset cs):指定编码格式创建字符流对象

InputStreamReader:字符转换输入流
	构造方法
	InputStreamReader(InputStream in) 创建一个使用默认字符集的 InputStreamReader。对象
	InputStreamReader(InputStream in, Charset cs)  :创建指定字符集的字符流对象
	使用当前字符转换流:
		输出和读取数据,要保证编码格式一致!
          
转换流： 其实就是字符流与字节流之间的一个桥梁
/**
 * @Author xiaoqi
 * @Date 
 * 需求：将UTF-8编码的文件复制时变成GBK编码的文件
 */
public class ConvertTest {
    InputStreamReader isr;
    OutputStreamWriter osw;

    @Test
    public void copyOfConvert(){
        try {
//            获取字符转换流，并指定相应的编码
         isr = new InputStreamReader(new FileInputStream("hello.txt"),"utf-8");
         osw = new OutputStreamWriter(new FileOutputStream("123.txt"),"GBK");
//         进行复制操作,与字符流的复制操作相同
            char [] chars = new char[1024];
            int len;
            while((len = isr.read(chars))!= -1){
                osw.write(chars,0,len);
                osw.flush();
            }

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
//            关闭资源
            try {
                if (osw != null){
                    osw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (isr != null){
                    isr.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

2.4 标准的输入输出流

/**
 * @Author xiaoqi
 * @Date 
 * 标准的输入输出流的测试
 * System.in :标准的输入流，默认从键盘输入
 * System.out ：标准的输出流，默认从控制台输出
 */
/**
 * 需求：键盘录入数据，如果是exit则退出
 */
public class StandardFlow {

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

//        键盘录入
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        while (true) {
            System.out.println("请输入字符串");
//            一次读取一行数据
            String str = br.readLine();
//            忽略大小写比较
            if (str.equalsIgnoreCase("exit")) {
                System.out.println("结束");
                break;
            }
//            将输入的字符串大写输出
            String string = str.toUpperCase();
            System.out.println(string);
        }
    }
}

2.5 打印流

 /* 打印流：
 * PrintStream  PrintWriter
 System.out的返回值就是PrintSream
 */
public class PrintTest {
    public static void main ( String[] args ) throws FileNotFoundException {
        PrintStream out = System.out;
        out.print("nihaoa");
    }
}

2.6 数据流

// DataInputStream 针对基本类型数据操作和String类型的
// DataOutputStream
/**
 * @Author xiaoqi
 * @Date 
 * 数据流的操作：
 * 注意；在读取的时候，要按照顺序进行，不然会出现以下异常
 * EOFException： 输入流的读取过程 中，程序意外的读取到末尾
 */
public class DataTest001 {

    //    将数据写入文件
    @Test
    public void writeTest() throws Exception {
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
        dos.writeUTF("wangzi");
        dos.write(20);
        dos.writeDouble(120000.89);
        dos.writeBoolean(true);
    }
//    从文件中读取数据，按照顺序进行读取
    @Test
    public void readTest() throws Exception {
        DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
        String s = dis.readUTF();
        int i = dis.read();
        double d = dis.readDouble();
        boolean b1 = dis.readBoolean();
        System.out.println(s);
        System.out.println(i);
        System.out.println(d);
        System.out.println(b1);
    }
}

2.7 对象流(序列化流)

实体类

@Data    				//get/set方法  (使用这三个注解需要导入lombok包)
@AllArgsConstructor  	//全参构造
@NoArgsConstructor		//无参构造
public class User implements Serializable{
//	这个常量是java运行时环境根据类的内部细节自动生成的，如果类的实例变量做了修改，这个常量也会发生改变，因此一般建议显示声明
  // 这个常量就是一个序列化版本的标识符，在进行反序列化的时候，要把流中的版本标识符与相应的实体类的版本标识符进行比较，相同则反序列化，如果不同，则抛出异常
    private static final long serialVersionUID = 6739406330338108087L;
    private int id;
    private String name;
    private String pass;
}

对象流的测试类

/**
 * @Author xiaoqi
 * @Date 
 *ObjectOutputStream序列化:将Java对象以流数据的方式在(网络,设备..)数据的传输
 * ObjectInputStream反序列化:(还原) 需要将流数据以java对象的方式保存
 * 如果一个类要进行序列化实现,那么该类必须实现序列化接口,否则出现序列化异常!
 */
public class ObjectflowTest {

//    将java对象保存在user.txt文件中
    @Test
    public void writeTest() throws Exception {
//        1.获取序列化流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user.txt"));
//        写入
        oos.writeObject(new User(1,"wangzi","123"));
//        刷新
        oos.flush();
        oos.close();
    }
    /**
     * 这个方法是反序列化的方法，即将流数据读取出来
     */
    @Test
    public void readTest() throws Exception{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user.txt"));
        User user = (User) ois.readObject();
        System.out.println(user);
    }
}

2.8 随机访问流

/**
 * @Author xiaoqi
 * @Date 
 * RandomAccessFile 随机访问流，他继承自Object类
 * 既可以作为一个输入流，也可以作为一个输出流
 */

/**
 * 现在有这样一个需求，程序运行3次以后就不能再运行了
 * 解决方案：使用随即流，创建一个文件，在文件里面写入运行的次数，因为随机流写入时会覆盖
 * 原来文件，每运行一次，重新写入还能运行的次数
 */
public class RandomTest001 {

    RandomAccessFile raf;
    @Test
    public void randomTest(){
//        获取一个随机访问流，  “rw”表示可读可写
        try {
            raf = new RandomAccessFile("a.txt", "rw");
//            读取文件中的数据
            String s = raf.readLine();
//           -1 是程序已经运行一次，后面需要将这个数据写入a.txt文件
               int i = Integer.parseInt(s) - 1;
            if (i > 0){
                System.out.println("还有"+i+"次机会");
//                在文件中写入剩余次数
                raf.seek(0); //指针重新指向开头
              // 这里要用字节写入
                raf.write((i+"").getBytes());
            }else {
                System.out.println("你已经没有机会了");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if (raf != null){
                    raf.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

2.9 合并流

/**
 * @Author xiaoqi
 * @Date 
 * 合并流
 */
public class SequenceDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        FileOutputStream fos = null;
        SequenceInputStream scs = null;
        //创建InputStream 对象
        try {
            FileInputStream fis1 = new FileInputStream("a.txt");
            FileInputStream fis2 = new FileInputStream("Aa.txt");
            //创建合并流读取对象
            scs = new SequenceInputStream(fis1,fis2);
            //创建合写出对象
            fos = new FileOutputStream("h.txt");
            byte [] bytes = new byte [1024];
            int len = 0;
            while ((len = scs.read(bytes))!= -1) {
                fos.write(bytes,0,len);
            }

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if (scs != null) {
                try {
                    scs.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }

    }

}

2.10 内存操作流

/**
 * @Author xiaoqi
 * @Date 
 * 内存操作流
    主要内存中的一些数组(临时变量)进行操作
    在Socket编程中(使用套接字流的一种)，可以使用内存操作输入流给服务器端发送文件(针对小文件发送)
 */
public class BytearrayTest {
    @Test
    public void byteTest() throws IOException {
//        获取输出流，然后将数据写入流中
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        bos.write("我是内存操作流".getBytes());
        byte[] byteArray = bos.toByteArray();
//        获取输入流，将流中数据读取出来
        ByteArrayInputStream bis = new ByteArrayInputStream(byteArray);
        byte [] bytes = new byte[1024];
        int len ;
        while ((len = bis.read(bytes))!= -1){
            System.out.println(new String(bytes,0,len));
        }
    }
}
明朝即长路
关注
专栏目录
javase-file.zip
05-15
Java SE中的`File`类是处理文件和目录的核心工具，位于`java.io`包下。在Java编程中，当我们需要与文件系统进行交互，如创建、读取、写入、删除文件或目录时，都会用到`File`类。本压缩包`javase-file.zip`可能包含...
Java基础-File类
yirenyuan的博客
09-25 201
一、概述 java.io.File 类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作。 File 类是一个与系统无关的类，任何的操作系统都可以使用这个类中的方法。 关键单词： 1. file：文件 2. directory：文件夹/目录 3. path：路径 二、File 类的静态成员变量 static String pathSeparator // 与系统有关的路径分隔符。为了方便，它被表示为一个字符串。 s...
java 输出流_Java中输入输出流方法总结
weixin_39850062的博客
02-12 151
4.如果你创建了一个文件对象,你可以使用下面的方法来获得文件的相关信息,对文件进行操作。1)文件名的操作public String getName()；返回文件对象名字符串，串空时返回nullpublic String toString()；返回文件名字符串public String getParent()；返回文件对象父路径字符串，不存在时返回nullpublic File getPath()；...
Java基础
qq_43694194的博客
07-16 1387
公共静态不可变,即publicstaticfinal修饰的变量就是我们所说的编译期常量.这里的public可选的.实际上这些变量在编译时会被替换掉,因为编译器明确的能推断出这些变量的值(如果你熟悉C++,那么这里就相当于宏替换).编译器常量虽然能够提升性能,但是也存在一定问题你使用了一个内部的或第三方库中的公有编译时常量,但是这个值后面被其他人改变了,但是你的客户端没有重新编译,这意味着你仍然在使用被修改之前的常量值....
java 文件操作
Walker_YAM
03-22 394
在我的前面几篇文章中，我们介绍了流的概念，使用流我们可以任意读取写入文件中的内容，而对于文件的操作来说，更多的是对文件的存储进行操作，创建文件再磁盘上，移动文件到指定位置上，更改文件的文件名等。这些操作更多的是和操作系统以及文件系统打交道。首先我们看File类。      一个File类对象可以存放的是目录，也可以是文件。实际上在java 7开始，引进了Files类，集合Path接口实现了对整个文
Java学习笔记（10）---JavaIO超详细带实例笔记总结！！！看这一篇就够啦！！
深藏的是波光粼粼
08-15 437
JavaIO -BIO（阻塞式IO）、基于抽象类的 Java.IO包下 NIO：非阻塞式IO 核心掌握五个类（File、OutPutStream、InPutStream、Reader、Writer）+一个接口（Serializable） 1、File文件操作 既可以描述具体文件也可以描述文件夹 File是唯一一个与文件本身操作（创建、删除、取得信息）有关的程序类。 产生File对象： pub...
JavaSE进阶-06-IO流1
08-03
`File` 类是 Java IO 包中的一个重要类，用于表示文件和目录路径名的抽象表示。它可以用来创建、删除、重命名文件，以及获取文件的相关信息。 总结： Java 中的流体系结构非常丰富，提供了多种类型的流来适应不同的...
JavaSE专题-IO流重点总结(必读).doc
06-03
Java SE专题中的IO流是Java编程中非常重要的一个部分，主要用于数据的输入和输出操作。在Java中，异常处理是程序稳定性和健壮性的重要保障。对于IO流操作，异常处理通常采用`try-catch-finally`结构。当在`try`块中...
javase与javaee-api
10-24
在学习JavaSE时，掌握Java语言基础、类库使用、异常处理、IO流操作、集合框架的使用以及多线程编程是至关重要的。Java集合框架包括List、Set、Map等接口，以及ArrayList、LinkedList、HashSet、HashMap等实现类，...
commons-io-2.11.0.jar
11-25
Apache Commons IO是Java开发中的一个关键组件，其最新版本2.11.0提供了丰富的IO操作工具类和实用方法，大大简化了对输入/输出流的处理。这个小巧而强大的库广泛应用于各种Java应用程序和框架中，为开发者提供了高效...
[零基础学JAVA]Java SE应用部分-27.Java IO操作（01）
weixin_33681778的博客
02-24 81
JAVA IO操作目标 本季知识点 1、File类 2、RandomAccessFile类 File类 在JAVA中所有的IO操作全部存放在java.io包中。 File是唯一一个与文件本身有关的操作。 在使用File类的构造方法处必须加入一个完整的路径。 要求一：可以在F盘上建立一个新的文件：demo.txt文件。 public boolean createNewF...
5116-微信小程序电影院订票选座系统设计及实现+ssm（源码+数据库+lun文）.zip
09-15
本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。
JavaScript 中的 `Array.prototype.filter` 方法全解析
09-15
在 JavaScript 编程中，处理数组是一项基本而重要的任务。数组的过滤操作是其中的一个常见需求，Array.prototype.filter 方法为此提供了强大的支持。本文将深入探讨 Array.prototype.filter 方法的工作原理、使用场景、代码示例以及与其他数组方法的比较。 Array.prototype.filter 是 JavaScript 中处理数组的强大工具，它允许开发者以声明式的方式轻松筛选出符合特定条件的元素。通过结合使用 Array.prototype.filter 和其他数组方法，可以解决各种复杂的数据筛选问题。 通过本文的详细介绍和示例代码，你应该能够掌握 Array.prototype.filter 的工作原理，并能够在实际开发中灵活运用它来处理数组数据。此外，了解其与 Array.prototype.map 和 Array.prototype.reduce 的结合使用，可以帮助你更好地编写高效且易于维护的代码。
5108-微信小程序的书橱+ssm（源码+数据库+lun文）.zip
09-15
本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。
5046-微信小程序校园二手交易平台的小程序+ssm（源码+数据库+lun文）.zip
09-15
本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。
SMT小型视觉贴片机控制系统源码源代码图纸 DI
09-15
SMT小型视觉贴片机控制系统源码源代码图纸 DI
图书馆自动化管理系统.zip
09-15
这是一个基于Apache kafka、Docker Compose、MongoDB和Flask技术的图书馆自动化管理系统。该项目旨在实现图书馆的各项服务自动化，包括图书借阅、预约和搜索功能。通过Flask构建REST API，使用MongoDB存储和管理图书、用户、借阅记录、罚款和预约等相关数据。apache Kafka用于系统各组件之间的消息通信，确保消息传递的可靠性和可扩展性。项目还实现了用户认证和授权功能，通过JWT进行安全认证和授权。每个对系统服务的请求都需要使用JWT进行验证。项目提供了全面的文档，解释了系统架构、数据库模式和API端点。同时，项目明确了所有依赖关系，并提供了环境搭建指南，便于其他开发者轻松复制环境。此外，项目还包含测试用例，以确保关键功能的正常运行。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。
【前景培训教材】第九章4G和5G信令流程.pdf
最新发布
09-15
以下是对提供的参考资料的总结，按照要求结构化多个要点分条输出： 4G/5G无线网络优化与网规案例分析： NSA站点下终端掉4G问题：部分用户反馈NSA终端频繁掉4G，主要因终端主动发起SCGfail导致。分析显示，在信号较好的环境下，终端可能因节能、过热保护等原因主动释放连接。解决方案建议终端侧进行分析处理，尝试关闭节电开关等。 RSSI算法识别天馈遮挡：通过计算RSSI平均值及差值识别天馈遮挡，差值大于3dB则认定有遮挡。不同设备分组规则不同，如64T和32T。此方法可有效帮助现场人员识别因环境变化引起的网络问题。 5G 160M组网小区CA不生效：某5G站点开启100M+60M CA功能后，测试发现UE无法正常使用CA功能。问题原因在于CA频点集标识配置错误，修正后测试正常。 5G网络优化与策略： CCE映射方式优化：针对诺基亚站点覆盖农村区域，通过优化CCE资源映射方式（交织、非交织），提升RRC连接建立成功率和无线接通率。非交织方式相比交织方式有显著提升。 5G AAU两扇区组网：与三扇区组网相比，AAU两扇区组网在RSRP、SINR、下载速率和上传速率上表现不同，需根据具体场景选择适合的组网方式。 5G语音解决方案：包括沿用4G语音解决方案、EPS Fallback方案和VoNR方案。不同方案适用于不同的5G组网策略，如NSA和SA，并影响语音连续性和网络覆盖。 4G网络优化与资源利用： 4G室分设备利旧：面对4G网络投资压减与资源需求矛盾，提出利旧多维度调优策略，包括资源整合、统筹调配既有资源，以满足新增需求和提质增效。 宏站RRU设备1托N射灯：针对5G深度覆盖需求，研究使用宏站AAU结合1托N射灯方案，快速便捷地开通5G站点，提升深度覆盖能力。 基站与流程管理： 爱立信LTE基站邻区添加流程：未提供具体内容，但通常涉及邻区规划、参数配置、测试验证等步骤，以确保基站间顺畅切换和覆盖连续性。 网络规划与策略： 新高铁跨海大桥覆盖方案试点：虽未提供详细内容，但可推测涉及高铁跨海大桥区域的4G/5G网络覆盖规划，需考虑信号穿透、移动性管理、网络容量等因素。 总结： 提供的参考资料涵盖了4G/5G无线网络优化、网规案例分析、网络优化策略、资源利用、基站管理等多个方面。 通过具体案例分析，展示了无线网络优化中的常见问题及解决方案，如NSA终端掉4G、RSSI识别天馈遮挡、CA不生效等。 强调了5G网络优化与策略的重要性，包括CCE映射方式优化、5G语音解决方案、AAU扇区组网选择等。 提出了4G网络优化与资源利用的策略，如室分设备利旧、宏站RRU设备1托N射灯等。 基站与流程管理方面，提到了爱立信LTE基站邻区添加流程，但未给出具体细节。 新高铁跨海大桥覆盖方案试点展示了特殊场景下的网络规划需求。
5040-微信小程序私家车位共享系统+ssm（源码+数据库+lun文）.zip
09-15
本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值