javase__进阶 day13stream流和方法引用

1.不可变集合

1.1 什么是不可变集合

​ 是一个长度不可变，内容也无法修改的集合

1.2 使用场景

​ 如果某个数据不能被修改，把它防御性地拷贝到不可变集合中是个很好的实践。

​ 当集合对象被不可信的库调用时，不可变形式是安全的。

简单理解：

​ 不想让别人修改集合中的内容

比如说：

1，斗地主的54张牌，是不能添加，不能删除，不能修改的

2，斗地主的打牌规则：单张，对子，三张，顺子等，也是不能修改的

3，用代码获取的操作系统硬件信息，也是不能被修改的

1.3 不可变集合分类

  • 不可变的list集合
  • 不可变的set集合
  • 不可变的map集合

1.4 不可变的list集合

public class ImmutableDemo1 {public static void main(String[] args) {/*创建不可变的List集合"张三", "李四", "王五", "赵六"*///一旦创建完毕之后，是无法进行修改的，在下面的代码中，只能进行查询操作List<String> list = List.of("张三", "李四", "王五", "赵六");System.out.println(list.get(0));System.out.println(list.get(1));System.out.println(list.get(2));System.out.println(list.get(3));System.out.println("---------------------------");for (String s : list) {System.out.println(s);}System.out.println("---------------------------");Iterator<String> it = list.iterator();while(it.hasNext()){String s = it.next();System.out.println(s);}System.out.println("---------------------------");for (int i = 0; i < list.size(); i++) {String s = list.get(i);System.out.println(s);}System.out.println("---------------------------");//list.remove("李四");//list.add("aaa");list.set(0,"aaa");}
}

1.5 不可变的Set集合

public class ImmutableDemo2 {public static void main(String[] args) {/*创建不可变的Set集合"张三", "李四", "王五", "赵六"细节：当我们要获取一个不可变的Set集合时，里面的参数一定要保证唯一性*///一旦创建完毕之后，是无法进行修改的，在下面的代码中，只能进行查询操作Set<String> set = Set.of("张三", "张三", "李四", "王五", "赵六");for (String s : set) {System.out.println(s);}System.out.println("-----------------------");Iterator<String> it = set.iterator();while(it.hasNext()){String s = it.next();System.out.println(s);}System.out.println("-----------------------");//set.remove("王五");}
}

1.6 不可变的Map集合

1.6.1：键值对个数小于等于10
public class ImmutableDemo3 {public static void main(String[] args) {/*创建Map的不可变集合细节1：键是不能重复的细节2：Map里面的of方法，参数是有上限的，最多只能传递20个参数，10个键值对细节3：如果我们要传递多个键值对对象，数量大于10个，在Map接口中还有一个方法*///一旦创建完毕之后，是无法进行修改的，在下面的代码中，只能进行查询操作Map<String, String> map = Map.of("张三", "南京", "张三", "北京", "王五", "上海","赵六", "广州", "孙七", "深圳", "周八", "杭州","吴九", "宁波", "郑十", "苏州", "刘一", "无锡","陈二", "嘉兴");Set<String> keys = map.keySet();for (String key : keys) {String value = map.get(key);System.out.println(key + "=" + value);}System.out.println("--------------------------");Set<Map.Entry<String, String>> entries = map.entrySet();for (Map.Entry<String, String> entry : entries) {String key = entry.getKey();String value = entry.getValue();System.out.println(key + "=" + value);}System.out.println("--------------------------");}
}
1.6.2：键值对个数大于10
public class ImmutableDemo4 {public static void main(String[] args) {/*创建Map的不可变集合,键值对的数量超过10个*///1.创建一个普通的Map集合HashMap<String, String> hm = new HashMap<>();hm.put("张三", "南京");hm.put("李四", "北京");hm.put("王五", "上海");hm.put("赵六", "北京");hm.put("孙七", "深圳");hm.put("周八", "杭州");hm.put("吴九", "宁波");hm.put("郑十", "苏州");hm.put("刘一", "无锡");hm.put("陈二", "嘉兴");hm.put("aaa", "111");//2.利用上面的数据来获取一个不可变的集合
/*//获取到所有的键值对对象（Entry对象）Set<Map.Entry<String, String>> entries = hm.entrySet();//把entries变成一个数组Map.Entry[] arr1 = new Map.Entry[0];//toArray方法在底层会比较集合的长度跟数组的长度两者的大小//如果集合的长度 > 数组的长度 ：数据在数组中放不下，此时会根据实际数据的个数，重新创建数组//如果集合的长度 <= 数组的长度：数据在数组中放的下，此时不会创建新的数组，而是直接用Map.Entry[] arr2 = entries.toArray(arr1);//不可变的map集合Map map = Map.ofEntries(arr2);map.put("bbb","222");*///Map<Object, Object> map = Map.ofEntries(hm.entrySet().toArray(new Map.Entry[0]));Map<String, String> map = Map.copyOf(hm);map.put("bbb","222");}
}

2.Stream流

2.1体验Stream流【理解】

  • 案例需求

    按照下面的要求完成集合的创建和遍历

    • 创建一个集合，存储多个字符串元素
    • 把集合中所有以"张"开头的元素存储到一个新的集合
    • 把"张"开头的集合中的长度为3的元素存储到一个新的集合
    • 遍历上一步得到的集合

  • 原始方式示例代码

    public class MyStream1 {public static void main(String[] args) {//集合的批量添加ArrayList<String> list1 = new ArrayList<>(List.of("张三丰","张无忌","张翠山","王二麻子","张良","谢广坤"));//list.add()//遍历list1把以张开头的元素添加到list2中。ArrayList<String> list2 = new ArrayList<>();for (String s : list1) {if(s.startsWith("张")){list2.add(s);}}//遍历list2集合，把其中长度为3的元素，再添加到list3中。ArrayList<String> list3 = new ArrayList<>();for (String s : list2) {if(s.length() == 3){list3.add(s);}}for (String s : list3) {System.out.println(s);}      }
}

  • 使用Stream流示例代码

    public class StreamDemo {public static void main(String[] args) {//集合的批量添加ArrayList<String> list1 = new ArrayList<>(List.of("张三丰","张无忌","张翠山","王二麻子","张良","谢广坤"));//Stream流list1.stream().filter(s->s.startsWith("张")).filter(s->s.length() == 3).forEach(s-> System.out.println(s));}
}

  • Stream流的好处

    • 直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：获取流、过滤姓张、过滤长度为3、逐一打印
    • Stream流把真正的函数式编程风格引入到Java中
    • 代码简洁

2.2Stream流的常见生成方式【应用】

  • Stream流的思想

    在这里插入图片描述

  • Stream流的三类方法

    • 获取Stream流
      • 创建一条流水线,并把数据放到流水线上准备进行操作
    • 中间方法
      • 流水线上的操作
      • 一次操作完毕之后,还可以继续进行其他操作
    • 终结方法
      • 一个Stream流只能有一个终结方法
      • 是流水线上的最后一个操作

  • 生成Stream流的方式

    • Collection体系集合

      使用默认方法stream()生成流， default Stream stream()

    • Map体系集合

      把Map转成Set集合，间接的生成流

    • 数组

      通过Arrays中的静态方法stream生成流

    • 同种数据类型的多个数据

      通过Stream接口的静态方法of(T… values)生成流

  • 代码演示

    public class StreamDemo {public static void main(String[] args) {//Collection体系的集合可以使用默认方法stream()生成流List<String> list = new ArrayList<String>();Stream<String> listStream = list.stream();Set<String> set = new HashSet<String>();Stream<String> setStream = set.stream();//Map体系的集合间接的生成流Map<String,Integer> map = new HashMap<String, Integer>();Stream<String> keyStream = map.keySet().stream();Stream<Integer> valueStream = map.values().stream();Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();//数组可以通过Arrays中的静态方法stream生成流String[] strArray = {"hello","world","java"};Stream<String> strArrayStream = Arrays.stream(strArray);//同种数据类型的多个数据可以通过Stream接口的静态方法of(T... values)生成流Stream<String> strArrayStream2 = Stream.of("hello", "world", "java");Stream<Integer> intStream = Stream.of(10, 20, 30);}
}

2.3Stream流中间操作方法【应用】

  • 概念

    中间操作的意思是,执行完此方法之后,Stream流依然可以继续执行其他操作

  • 常见方法

    方法名说明
    Stream filter(Predicate predicate)用于对流中的数据进行过滤
    Stream limit(long maxSize)返回此流中的元素组成的流，截取前指定参数个数的数据
    Stream skip(long n)跳过指定参数个数的数据，返回由该流的剩余元素组成的流
    static Stream concat(Stream a, Stream b)合并a和b两个流为一个流
    Stream distinct()返回由该流的不同元素（根据Object.equals(Object) ）组成的流

  • filter代码演示

    public class MyStream3 {public static void main(String[] args) {
//        Stream<T> filter(Predicate predicate)：过滤
//        Predicate接口中的方法	boolean test(T t)：对给定的参数进行判断，返回一个布尔值ArrayList<String> list = new ArrayList<>();list.add("张三丰");list.add("张无忌");list.add("张翠山");list.add("王二麻子");list.add("张良");list.add("谢广坤");//filter方法获取流中的 每一个数据.//而test方法中的s,就依次表示流中的每一个数据.//我们只要在test方法中对s进行判断就可以了.//如果判断的结果为true,则当前的数据留下//如果判断的结果为false,则当前数据就不要.
//        list.stream().filter(
//                new Predicate<String>() {
//                    @Override
//                    public boolean test(String s) {
//                        boolean result = s.startsWith("张");
//                        return result;
//                    }
//                }
//        ).forEach(s-> System.out.println(s));//因为Predicate接口中只有一个抽象方法test//所以我们可以使用lambda表达式来简化
//        list.stream().filter(
//                (String s)->{
//                    boolean result = s.startsWith("张");
//                        return result;
//                }
//        ).forEach(s-> System.out.println(s));list.stream().filter(s ->s.startsWith("张")).forEach(s-> System.out.println(s));}
}

  • limit&skip代码演示

    public class StreamDemo02 {public static void main(String[] args) {//创建一个集合，存储多个字符串元素ArrayList<String> list = new ArrayList<String>();list.add("林青霞");list.add("张曼玉");list.add("王祖贤");list.add("柳岩");list.add("张敏");list.add("张无忌");//需求1：取前3个数据在控制台输出list.stream().limit(3).forEach(s-> System.out.println(s));System.out.println("--------");//需求2：跳过3个元素，把剩下的元素在控制台输出list.stream().skip(3).forEach(s-> System.out.println(s));System.out.println("--------");//需求3：跳过2个元素，把剩下的元素中前2个在控制台输出list.stream().skip(2).limit(2).forEach(s-> System.out.println(s));}
}

  • concat&distinct代码演示

    public class StreamDemo03 {public static void main(String[] args) {//创建一个集合，存储多个字符串元素ArrayList<String> list = new ArrayList<String>();list.add("林青霞");list.add("张曼玉");list.add("王祖贤");list.add("柳岩");list.add("张敏");list.add("张无忌");//需求1：取前4个数据组成一个流Stream<String> s1 = list.stream().limit(4);//需求2：跳过2个数据组成一个流Stream<String> s2 = list.stream().skip(2);//需求3：合并需求1和需求2得到的流，并把结果在控制台输出
//        Stream.concat(s1,s2).forEach(s-> System.out.println(s));//需求4：合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复Stream.concat(s1,s2).distinct().forEach(s-> System.out.println(s));}
}

2.4Stream流终结操作方法【应用】

  • 概念

    终结操作的意思是,执行完此方法之后,Stream流将不能再执行其他操作

  • 常见方法

    方法名说明
    void forEach(Consumer action)对此流的每个元素执行操作
    long count()返回此流中的元素数

  • 代码演示

    public class MyStream5 {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();list.add("张三丰");list.add("张无忌");list.add("张翠山");list.add("王二麻子");list.add("张良");list.add("谢广坤");//method1(list);//        long count()：返回此流中的元素数long count = list.stream().count();System.out.println(count);}private static void method1(ArrayList<String> list) {//  void forEach(Consumer action)：对此流的每个元素执行操作//  Consumer接口中的方法void accept(T t)：对给定的参数执行此操作//在forEach方法的底层,会循环获取到流中的每一个数据.//并循环调用accept方法,并把每一个数据传递给accept方法//s就依次表示了流中的每一个数据.//所以,我们只要在accept方法中,写上处理的业务逻辑就可以了.list.stream().forEach(new Consumer<String>() {@Overridepublic void accept(String s) {System.out.println(s);}});System.out.println("====================");//lambda表达式的简化格式//是因为Consumer接口中,只有一个accept方法list.stream().forEach((String s)->{System.out.println(s);});System.out.println("====================");//lambda表达式还是可以进一步简化的.list.stream().forEach(s->System.out.println(s));}
}

2.5Stream流的收集操作【应用】

  • 概念

    对数据使用Stream流的方式操作完毕后,可以把流中的数据收集到集合中

  • 常用方法

    方法名说明
    R collect(Collector collector)把结果收集到集合中

  • 工具类Collectors提供了具体的收集方式

    方法名说明
    public static Collector toList()把元素收集到List集合中
    public static Collector toSet()把元素收集到Set集合中
    public static Collector toMap(Function keyMapper,Function valueMapper)把元素收集到Map集合中

  • 代码演示

    // toList和toSet方法演示 
public class MyStream7 {public static void main(String[] args) {ArrayList<Integer> list1 = new ArrayList<>();for (int i = 1; i <= 10; i++) {list1.add(i);}list1.add(10);list1.add(10);list1.add(10);list1.add(10);list1.add(10);//filter负责过滤数据的.//collect负责收集数据.//获取流中剩余的数据,但是他不负责创建容器,也不负责把数据添加到容器中.//Collectors.toList() : 在底层会创建一个List集合.并把所有的数据添加到List集合中.List<Integer> list = list1.stream().filter(number -> number % 2 == 0).collect(Collectors.toList());System.out.println(list);Set<Integer> set = list1.stream().filter(number -> number % 2 == 0).collect(Collectors.toSet());System.out.println(set);
}
}
/**
Stream流的收集方法 toMap方法演示
创建一个ArrayList集合，并添加以下字符串。字符串中前面是姓名，后面是年龄
"zhangsan,23"
"lisi,24"
"wangwu,25"
保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值
*/
public class MyStream8 {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();list.add("zhangsan,23");list.add("lisi,24");list.add("wangwu,25");Map<String, Integer> map = list.stream().filter(s -> {String[] split = s.split(",");int age = Integer.parseInt(split[1]);return age >= 24;}//   collect方法只能获取到流中剩余的每一个数据.//在底层不能创建容器,也不能把数据添加到容器当中//Collectors.toMap 创建一个map集合并将数据添加到集合当中// s 依次表示流中的每一个数据//第一个lambda表达式就是如何获取到Map中的键//第二个lambda表达式就是如何获取Map中的值).collect(Collectors.toMap(s -> s.split(",")[0],s -> Integer.parseInt(s.split(",")[1]) ));System.out.println(map);}
}

2.6Stream流综合练习【应用】

  • 案例需求

    现在有两个ArrayList集合，分别存储6名男演员名称和6名女演员名称，要求完成如下的操作

    • 男演员只要名字为3个字的前三人
    • 女演员只要姓林的，并且不要第一个
    • 把过滤后的男演员姓名和女演员姓名合并到一起
    • 把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据

    演员类Actor已经提供，里面有一个成员变量，一个带参构造方法，以及成员变量对应的get/set方法

  • 代码实现

    演员类

    public class Actor {private String name;public Actor(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}
}

    测试类

    public class StreamTest {public static void main(String[] args) {//创建集合ArrayList<String> manList = new ArrayList<String>();manList.add("周润发");manList.add("成龙");manList.add("刘德华");manList.add("吴京");manList.add("周星驰");manList.add("李连杰");ArrayList<String> womanList = new ArrayList<String>();womanList.add("林心如");womanList.add("张曼玉");womanList.add("林青霞");womanList.add("柳岩");womanList.add("林志玲");womanList.add("王祖贤");//男演员只要名字为3个字的前三人Stream<String> manStream = manList.stream().filter(s -> s.length() == 3).limit(3);//女演员只要姓林的，并且不要第一个Stream<String> womanStream = womanList.stream().filter(s -> s.startsWith("林")).skip(1);//把过滤后的男演员姓名和女演员姓名合并到一起Stream<String> stream = Stream.concat(manStream, womanStream);// 将流中的数据封装成Actor对象之后打印stream.forEach(name -> {Actor actor = new Actor(name);System.out.println(actor);}); }
}

3.方法引用

3.1体验方法引用【理解】

  • 方法引用的出现原因

    在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿参数做操作

    那么考虑一种情况：如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑呢？答案肯定是没有必要

    那我们又是如何使用已经存在的方案的呢？

    这就是我们要讲解的方法引用，我们是通过方法引用来使用已经存在的方案

  • 代码演示

    public interface Printable {void printString(String s);
}public class PrintableDemo {public static void main(String[] args) {//在主方法中调用usePrintable方法
//        usePrintable((String s) -> {
//            System.out.println(s);
//        });//Lambda简化写法usePrintable(s -> System.out.println(s));//方法引用usePrintable(System.out::println);}private static void usePrintable(Printable p) {p.printString("爱生活爱Java");}
}

3.2方法引用符【理解】

  • 方法引用符

    :: 该符号为引用运算符，而它所在的表达式被称为方法引用

  • 推导与省略

    • 如果使用Lambda，那么根据“可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式，它们都将被自动推导
    • 如果使用方法引用，也是同样可以根据上下文进行推导
    • 方法引用是Lambda的孪生兄弟

3.3引用类方法【应用】

​ 引用类方法，其实就是引用类的静态方法

  • 格式

    类名::静态方法

  • 范例

    Integer::parseInt

    Integer类的方法：public static int parseInt(String s) 将此String转换为int类型数据

  • 练习描述

    • 定义一个接口(Converter)，里面定义一个抽象方法 int convert(String s);
    • 定义一个测试类(ConverterDemo)，在测试类中提供两个方法
      • 一个方法是：useConverter(Converter c)
      • 一个方法是主方法，在主方法中调用useConverter方法

  • 代码演示

    public interface Converter {int convert(String s);
}public class ConverterDemo {public static void main(String[] args) {//Lambda写法useConverter(s -> Integer.parseInt(s));//引用类方法useConverter(Integer::parseInt);}private static void useConverter(Converter c) {int number = c.convert("666");System.out.println(number);}
}

  • 使用说明

    Lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数

3.4引用对象的实例方法【应用】

​ 引用对象的实例方法，其实就引用类中的成员方法

  • 格式

    对象::成员方法

  • 范例

    “HelloWorld”::toUpperCase

    String类中的方法：public String toUpperCase() 将此String所有字符转换为大写

  • 练习描述

    • 定义一个类(PrintString)，里面定义一个方法

      public void printUpper(String s)：把字符串参数变成大写的数据，然后在控制台输出

    • 定义一个接口(Printer)，里面定义一个抽象方法

      void printUpperCase(String s)

    • 定义一个测试类(PrinterDemo)，在测试类中提供两个方法

      • 一个方法是：usePrinter(Printer p)
      • 一个方法是主方法，在主方法中调用usePrinter方法

  • 代码演示

    public class PrintString {//把字符串参数变成大写的数据，然后在控制台输出public void printUpper(String s) {String result = s.toUpperCase();System.out.println(result);}
}public interface Printer {void printUpperCase(String s);
}public class PrinterDemo {public static void main(String[] args) {//Lambda简化写法usePrinter(s -> System.out.println(s.toUpperCase()));//引用对象的实例方法PrintString ps = new PrintString();usePrinter(ps::printUpper);}private static void usePrinter(Printer p) {p.printUpperCase("HelloWorld");}
}

  • 使用说明

    Lambda表达式被对象的实例方法替代的时候，它的形式参数全部传递给该方法作为参数

3.5引用类的实例方法【应用】

​ 引用类的实例方法，其实就是引用类中的成员方法

  • 格式

    类名::成员方法

  • 范例

    String::substring

    public String substring(int beginIndex,int endIndex)

    从beginIndex开始到endIndex结束，截取字符串。返回一个子串，子串的长度为endIndex-beginIndex

  • 练习描述

    • 定义一个接口(MyString)，里面定义一个抽象方法：

      String mySubString(String s,int x,int y);

    • 定义一个测试类(MyStringDemo)，在测试类中提供两个方法

      • 一个方法是：useMyString(MyString my)
      • 一个方法是主方法，在主方法中调用useMyString方法

  • 代码演示

    public interface MyString {String mySubString(String s,int x,int y);
}public class MyStringDemo {public static void main(String[] args) {//Lambda简化写法useMyString((s,x,y) -> s.substring(x,y));//引用类的实例方法useMyString(String::substring);}private static void useMyString(MyString my) {String s = my.mySubString("HelloWorld", 2, 5);System.out.println(s);}
}

  • 使用说明

    ​ Lambda表达式被类的实例方法替代的时候
    ​ 第一个参数作为调用者
    ​ 后面的参数全部传递给该方法作为参数

3.6引用构造器【应用】

​ 引用构造器，其实就是引用构造方法

  • l格式

    类名::new

  • 范例

    Student::new

  • 练习描述

    • 定义一个类(Student)，里面有两个成员变量(name,age)

      并提供无参构造方法和带参构造方法，以及成员变量对应的get和set方法

    • 定义一个接口(StudentBuilder)，里面定义一个抽象方法

      Student build(String name,int age);

    • 定义一个测试类(StudentDemo)，在测试类中提供两个方法

      • 一个方法是：useStudentBuilder(StudentBuilder s)
      • 一个方法是主方法，在主方法中调用useStudentBuilder方法

  • 代码演示

    public class Student {private String name;private int age;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}public interface StudentBuilder {Student build(String name,int age);
}public class StudentDemo {public static void main(String[] args) {//Lambda简化写法useStudentBuilder((name,age) -> new Student(name,age));//引用构造器useStudentBuilder(Student::new);}private static void useStudentBuilder(StudentBuilder sb) {Student s = sb.build("林青霞", 30);System.out.println(s.getName() + "," + s.getAge());}
}

  • 使用说明

    Lambda表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/diannao/1121.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

大厂面试精华面试刷题

大厂面试精华面试刷题

1.自定义unshift实现相同效果 2.数组去重 用vs2019来写这种练习题可以更直观的查看代码执行的效果&#xff0c;最后的代码是控制控制台执行完毕后不自动关闭 use strict;let arr [1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 8, 9, 10] //1.//查重最简单的方法for循环结合splice从数组中…
阅读更多...
【C++】飞机大战项目记录

【C++】飞机大战项目记录

源代码与图片参考自《你好编程》的飞机大战项目&#xff0c;这里不进行展示。 本项目是仅供学习使用的项目 飞机大战项目记录 飞机大战设计报告1 项目框架分析1.1 敌机设计&#xff1a;1.2 玩家飞机控制&#xff1a;1.3 子弹发射&#xff1a;1.4 游戏界面与互动&#xff1a;1.5…
阅读更多...
解决Linux根分区空间不足的方法：利用Home分区进行扩容

解决Linux根分区空间不足的方法：利用Home分区进行扩容

前言 在进行系统安装时&#xff0c;一个常见的困扰是默认分区设置可能导致home分区拥有过多的空间&#xff0c;而root分区却显得十分紧缺。这种情况下&#xff0c;用户往往会陷入无法继续安装软件或存储文件的困境。本文将向您展示如何通过合理的调整&#xff0c;将home分区中多…
阅读更多...
【6】mysql查询性能优化-关联子查询

【6】mysql查询性能优化-关联子查询

【README】 0. 先说结论&#xff1a;一般用inner join来改写in和exist&#xff0c;用left join来改写not in&#xff0c;not exist&#xff1b;&#xff08;本文会比较内连接&#xff0c;包含in子句的子查询&#xff0c;exist的性能 &#xff09; 1. 本文总结自高性能mysql 6…
阅读更多...
Python 面向对象——1.基本概念

Python 面向对象——1.基本概念

本章学习链接如下&#xff1a; 基本概念与语法 类&#xff08;Class&#xff09;&#xff1a;定义了一组对象共有的属性和方法的蓝图。类是创建对象的模板。 对象&#xff08;Object&#xff09;&#xff1a;类的实例。对象包含实际的数据和操作数据的方法。 属性&#xff0…
阅读更多...
NLP_知识图谱_三元组实战

NLP_知识图谱_三元组实战

文章目录 三元组含义如何构建知识图谱模型的整体结构基于transformers框架的三元组抽取baselinehow to use预训练模型下载地址训练数据下载地址 结构图代码及数据bertconfig.jsonvocab.txt datadev.jsonschemas.jsontrain.jsonvocab.json 与bert跟data同个目录model.pytrain.py…
阅读更多...
原型和原型链--图解

原型和原型链--图解

https://juejin.cn/post/7255605810453217335 prototype是函数的属性&#xff08;一个对象&#xff09;&#xff0c;不是对象的属性&#xff0c;普通函数和构造函数的prototype属性是空对象&#xff5b;&#xff5d;&#xff08;其实有2个属性&#xff0c;一个是constructor&a…
阅读更多...
Vue3： toRefs与toRef的基本使用

Vue3： toRefs与toRef的基本使用

一、前言 本文主要介绍toRefs与toRef的基本使用。 二、内容 1、基本概念 作用: toRefs与toRef可以将一个响应式对象中的每一 个属性&#xff0c;转换为ref对象&#xff1b;不同 toRefs与toRef功能一致&#xff0c;但toRefs可以批量转换。 2、toRefs 如果把reactive定义的…
阅读更多...
记录交叉编译环境配置--海思开发板的 嵌入式nginx和 php的移植

记录交叉编译环境配置--海思开发板的 嵌入式nginx和 php的移植

嵌入式 lnmp搭建的记录 一些交叉编译的配置环境思路分享&#xff1a;P&#xff1a;php编译PHP可能遇到的问题configure阶段&#xff1a;Makefile-make阶段&#xff1a;Makefile-make install阶段&#xff1a; N&#xff1a;Nginx 文章比较水&#xff0c;并没有没解决什么实际问…
阅读更多...
二维码门楼牌管理应用平台建设：助力场所整改与消防安全

二维码门楼牌管理应用平台建设：助力场所整改与消防安全

文章目录 前言一、二维码门楼牌管理应用平台的构建背景二、二维码门楼牌管理应用平台在场所整改中的作用三、二维码门楼牌管理应用平台的意义与价值四、二维码门楼牌管理应用平台的未来展望 前言 随着城市管理的日益精细化&#xff0c;二维码门楼牌管理应用平台的建设成为了提…
阅读更多...
C++ - STL详解（七）— stack和queue的介绍及使用

C++ - STL详解（七）— stack和queue的介绍及使用

目录 一. stack 1.1 stack的介绍 1.2 stack的定义 1.3 stack的使用 ​编辑 二. queue 2.1 queue的介绍 2.2 queue的定义 2.3 queue的使用 一. stack 1.1 stack的介绍 stack是一种容器适配器&#xff0c;专门用在具有后进先出操作的上下文环境中&#xff0c;其删除…
阅读更多...
如何通过Postgres的日志进行故障排查？

如何通过Postgres的日志进行故障排查？

文章目录 一、配置日志记录二、查看和分析日志三、使用日志进行故障排查的示例四、总结 在进行数据库管理和维护时&#xff0c;日志分析是一项至关重要的技能。PostgreSQL的日志记录功能可以帮助我们追踪数据库的运行状态&#xff0c;定位问题&#xff0c;以及优化性能。下面&a…
阅读更多...
【Java】如何获取客户端IP地址

【Java】如何获取客户端IP地址

在项目中往往涉及到“获取客户端IP地址”&#xff0c;常见到下面这样子的代码&#xff1a; package com.utils;import cn.hutool.core.util.StrUtil; import lombok.extern.slf4j.Slf4j; import org.springframework.http.server.reactive.ServerHttpRequest; import java.net…
阅读更多...
逻辑运算符

逻辑运算符

一 介绍 用于连接多个条件&#xff08; 多个关系表达式&#xff09; &#xff0c; 最终的结果也是一个 boolean 值。 &&#xff1a;逻辑与&&&#xff1a;短路与|&#xff1a;逻辑或||&#xff1a;短路或&#xff01; 取反^&#xff1a;异或 二 逻辑运算规则 a&a…
阅读更多...
K210基础实验——独立按键中断

K210基础实验——独立按键中断

前言 学习K210开发板的独立按键和中断功能 一、涉及到的外设资源是K210开发板上的BOOT按键和RGB灯 二、BOOT按键按下&#xff0c;MCU上连接BOOT的IO口变为低电平&#xff0c;松开后为高电平 三、引脚对应关系 BOOT : IO16 RGB灯&#xff1a; R:IO6 G:IO7 B:IO8 四、在…
阅读更多...
【linux】多路径|Multipath I/O 技术

【linux】多路径|Multipath I/O 技术

目录 简略 详细 什么是多路径? Multipath安装与使用 安装 使用 Linux下multipath软件介绍 附录 配置文件说明 其他解 简略 略 详细 什么是多路径? 普通的电脑主机都是一个硬盘挂接到一个总线上&#xff0c;这里是一对一的关系。 而到了分布式环境&#xff0c;主机和存储网络连…
阅读更多...
UDP协议深度解析：从原理到应用全面剖析

UDP协议深度解析：从原理到应用全面剖析

⭐小白苦学IT的博客主页⭐ ⭐初学者必看&#xff1a;Linux操作系统入门⭐ ⭐代码仓库&#xff1a;Linux代码仓库⭐ ❤关注我一起讨论和学习Linux系统 前言 随着互联网的蓬勃发展&#xff0c;网络通信协议成为了支撑其稳定运行的关键。UDP协议作为网络通信协议中的重要一员&…
阅读更多...
华为ensp中rip和ospf路由重分发 原理及配置命令

华为ensp中rip和ospf路由重分发 原理及配置命令

作者主页&#xff1a;点击&#xff01; ENSP专栏&#xff1a;点击&#xff01; 创作时间&#xff1a;2024年4月20日20点21分 路由重分发&#xff08;Route Redistribution&#xff09;是指路由器将从一种路由协议学习到的路由信息&#xff0c;通过另一种路由协议通告出去的功…
阅读更多...
现货白银保证金交易要先分析趋势

现货白银保证金交易要先分析趋势

现货白银是保证金交易品种&#xff0c;买卖过程中可能会涉及数十倍的资金杠杆&#xff0c;所以它对投资者的分析水平和交易水平的要求都比较高&#xff0c;所以在进入这个市场之前&#xff0c;投资者需要先学习一些基本的分析方法&#xff0c;当中可以分为基本面和技术面两大流…
阅读更多...
C++智能指针（二十）

C++智能指针（二十）

一.RAII&#xff08;Resource Acquisition Is Initialization&#xff09; RAII资源获取即初始化&#xff0c;RAII的思想就是在构造时初始化资源&#xff0c;或者托管已经构造的资源。在析构的时候释放资源。一般不允许复制或赋值&#xff0c;并且提供若干的资源访问的方法。比…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023