JavaDay17
创建不可变集合
import java.util.Iterator;
import java.util.List;public class Test {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("aa");
// list.set("aa");
import java.util.Iterator;
import java.util.Set;public class Test {public static void main(String[] args) {/*创建不可变的Set集合* "张三","李四","王五","赵六"* 细节: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("王五");}
}
import java.util.Map;
import java.util.Set;public class Test {public static void main(String[] args) {/*创建Map的不可变集合* "张三","南京","李四","北京,"王五","上海","赵六","广州","赵六"**"广州","孙七","深圳","周八","杭州"*细节:键是不能重复的*细节:Map里面的of方法,参数是有上限的,最多只能传递20个参数,10个键值对*细节:如果我们要传递多个键值对对象 数量大于10个 在Map接口中还有一个方法*ofEntries** */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("------------------------------");}//如果我想让这个方法能够接受多个键和值//解决方案://键 可变参数 值:可变参数//类型不确定:泛型方法//一个形参里面的可变参数要写在后面 而且参数里面最多只有一个可变参数
// public static<K,V> void of(K...keys,V...values){
// //不能这样设置
// }
}
import java.util.HashMap;
import java.util.Map;public class Demo1 {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("1","11");hm.put("2","22");hm.put("3","33");hm.put("4","44");hm.put("5","55");hm.put("6","66");//2.利用上面的数据来获取一个不可变的集合// //获取到所有的键值对对象(Entry对象)
// Set<Map.Entry<String, String>> entries = hm.entrySet();
// //把entries变成一个数组
// //Map.Entry[] arr = entries.toArray(new Map.Entry[0]);
//
// Object[] objects = entries.toArray();
//for (Object object : objects) {System.out.println(object);}//但是类型是object
//
// //数组指定类型
// Map.Entry[] arr1 = new Map.Entry[0];//
// //toArray方法在底层会比较集合的长度跟数组的长度两者大小
// //如果集合的长度>数组的长度:数据在数组中放不下,此时会根据实际数据的个数,重新创建数组
// //如果集合的长度<=数组的长度:数据在数组中放的下 不会创建新的数组 直接用
//
// Map.Entry[] arr2 = entries.toArray(arr1);
// //不可变的map集合
// Map map = Map.ofEntries(arr2);//简化代码
// Map<Object, Object> map = Map.ofEntries(hm.entrySet().toArray(new Map.Entry[0]));
// map.put("bbb","222");//copyOf - JDK10Map<String, String> map = Map.copyOf(hm);}
}
Stream流
public class Test {public static void main(String[] args) {ArrayList<String> list1 = new ArrayList<>();list1.add("张无忌");list1.add("周芷若");list1.add("赵敏");list1.add("张强");list1.add("张三丰");list1.stream().filter(name->name.startsWith("张")).filter(name->name.length()==3).forEach(name-> System.out.println(name));// //把所有以张开头的放到新的集合
// ArrayList<String> list2 = new ArrayList<>();
//
// for (String name : list1) {
// if (name.startsWith("张")) {
// list2.add(name);
// }
// }
// //System.out.println(list2);
//
// //把"张"开头的,长度为3的元素再存储到新集合中
// ArrayList<String> list3 = new ArrayList<>();
// for (String name : list2) {
// if (name.length() == 3) {
// list3.add(name);
// }
// }
// //3.遍历打印最终的结果
// for (String name : list3) {
// System.out.println(name);
// }
//}
}
单列集合
import java.util.ArrayList;
import java.util.Collections;public class Test {public static void main(String[] args) {//1.单列集合获取Stream流ArrayList<String>list =new ArrayList<>();Collections.addAll(list,"a","b","c","d","e");//获取一条流水线 并把集合中的数据放到流水线上
// Stream<String> stream1 = list.stream();
// //使用终结方法打印一下流水线上面的数据
// stream1.forEach(new Consumer<String>() {
// @Override
// public void accept(String s) {
// //s:依次表示流水线上的每一个数据
// System.out.println(s);
// }
// });list.stream().forEach(s-> System.out.println(s));}
}
双列集合
import java.util.HashMap;public class Test {public static void main(String[] args) {//双列集合//1.创建双列集合HashMap<String,Integer>hm = new HashMap<>();//2.添加数据hm.put("aaa",111);hm.put("bbb",222);hm.put("ccc",333);hm.put("ddd",444);//3.第一种获取stream流hm.keySet().stream().forEach(s-> System.out.println(s));//4.第二种获取hm.entrySet().stream().forEach(s-> System.out.println(s));}
}
数组
public class Test {public static void main(String[] args) {//1.创建数组int[] arr ={1,2,3,4,5,6,7,8,9,10};//2.获取stream流Arrays.stream(arr).forEach(s-> System.out.println(s));String[] arr2 ={"a","b","c"};Arrays.stream(arr2).forEach(s-> System.out.println(s));}
}
一堆零散数据
import java.util.stream.Stream;public class Test {public static void main(String[] args) {//一堆零散数据Stream.of(1,2,3,4,5).forEach(s-> System.out.println(s));Stream.of("a","b","c","d","e").forEach(s-> System.out.println(s));//注意://stream接口中静态方法of的细节//方法的形参是一个可变参数 可以传递一堆零散的数据 也可以传递数组//但是数组必须是引用数据类型的 如果传递基本数据类型 是把整个数组当做//一个元素 放到stream流}
}
import java.util.ArrayList;
import java.util.Collections;public class Test {public static void main(String[] args) {ArrayList<String>list = new ArrayList<>();Collections.addAll(list,"111","222","333","444","555","666");//filter 过滤
// list.stream().filter(new Predicate<String>() {
// @Override
// public boolean test(String s) {
// //如果返回值为true 表示当前数据留下
// //如果返回值为false 表示当前数据舍弃不要
//
// return s.startsWith("6");
// }
// }).forEach(s -> System.out.println(s));//666// list.stream().filter(s->s.startsWith("6")).forEach(s-> System.out.println(s));
// System.out.println(list);// list.stream().limit(3).forEach(s-> System.out.println(s));// list.stream().skip(4).forEach(s-> System.out.println(s));//获取444 555 666list.stream().limit(6).skip(3).forEach(s-> System.out.println(s));}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.stream.Stream;public class Test {public static void main(String[] args) {ArrayList<String>list1 = new ArrayList<>();Collections.addAll(list1,"111","111","222","333","444","555","666");ArrayList<String>list2=new ArrayList<>();Collections.addAll(list2,"999","888");list1.stream().distinct().forEach(s-> System.out.println(s));//元素去重 一来(HashCode和equals方法)Stream.concat(list1.stream(),list2.stream()).forEach(s-> System.out.println(s));}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;public class Test {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();Collections.addAll(list, "张-11", "杨-19", "李-29", "咩-23");//只获取里面的年龄并且打印//String->int//第一个数据类型:流中原本的数据类型//第二个数据类型:要转成的类型//apply的形参s:依次表示流里面的每一个数据//返回值:表示转换之后的数据//当map方法执行完毕后 流上的数据变成了整数//所以当下面的forEach当中 s依次表示流里的每一个数据,这个数据现在就是整数了list.stream().map(new Function<String, Integer>() {@Overridepublic Integer apply(String s) {String[] arr = s.split("-");String ageString = arr[1];int age =Integer.parseInt(ageString);return age;}}).forEach(s-> System.out.println(s));list.stream().map(s->Integer.parseInt(s.split("-")[1])).forEach(s-> System.out.println(s));}
}
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;public class Test {public static void main(String[] args) {ArrayList<String>list=new ArrayList<>();Collections.addAll(list,"111","222","333","444","555");//遍历 -底层是函数式接口 -要改成Lambda表达式//Consumer的泛型:表示流中数据的类型//accept方法的形参s:依次表示流里面的每一个数据//方法体:对每一天数据的处理操作(打印)
// list.stream().forEach(new Consumer<String>() {
// @Override
// public void accept(String s) {
// System.out.println(s);
// }
// });//list.stream().forEach(s-> System.out.println(s));//count// long count = list.stream().count();
// System.out.println(count);//toArray 手机流中的数据 放到数组中
// Object[] arr1 = list.stream().toArray();
// System.out.println(Arrays.toString(arr1));//InFunction的泛型:具体类型的数组//apply的形参:流中数据的个数,要跟数组的长度保持一致//apply的返回值:具体类型的数组//方法体:创建数组//toArray方法的参数的作用,负责创建一个指定类型的数组//toArray方法的底层,会依次得到流里面的每一个数据 并把数据放到数组当中//toArray方法的返回值:是一个装着流里面所有数据的数组
// String[] arr = list.stream().toArray(new IntFunction<String[]>() {
// @Override
// public String[] apply(int value) {
// return new String[value];
// }
// });
// System.out.println(Arrays.toString(arr));String[] arr2 = list.stream().toArray(value -> new String[value]);System.out.println(Arrays.toString(arr2));}
}
import java.util.*;
import java.util.stream.Collectors;public class Test {public static void main(String[] args) {ArrayList<String>list=new ArrayList<>();Collections.addAll(list,"111-男-yjy","222-男-yyy","333-女-sss","444-男-ppp","555-男-nnn");//收集List当中 所有的男性//s:依次表示流水线上面的数据List<String> newList = list.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toList());//System.out.println(newList);//收集到set集合当中Set<String> newList2 = list.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toSet());//System.out.println(newList2);//搜集到List和set有什么区别?set->去重//收集到Map当中//谁作为键,谁作为值.//把所有男性手机起来//键:姓名 值:年龄/** toMap:参数一:键的生成规则* 参数二:表示值的生成规则* 参数一:Function泛型一:表示流中每一个数据的类型* 泛型二:表示Map集合中键的数据类型* 方法:apply形参:依次表示流里面的每一个数据** //方法体:生成键的代码'* 返回值:已经生成的键** 参数二:* Function泛型一:表示流中每一个数据的类型* 泛型二:表示Map集合中值的数据类型*** 方法:apply形参:依次表示流里面的每一个数据** //方法体:生成值的代码'* 返回值:已经生成的值*** */
// Map<String, Integer> map = list.stream().filter(s -> "男".equals(s.split("-")[1]))
// .collect(Collectors.toMap(new Function<String, String>() {
// @Override
// public String apply(String s) {
// return s.split("-")[0];
//
// }
// },
// new Function<String, Integer>() {
// @Override
// public Integer apply(String s) {
// return Integer.parseInt(s.split("-")[2]);
//
// }
// }));
//
//
// System.out.println(map);Map<String,Integer> map = list.stream().filter(s->"男".equals(s.split("-")[1])).collect(Collectors.toMap(s->s.split("-")[0],s->Integer.parseInt(s.split("-")[2])));System.out.println(map);}
}
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;public class Test {public static void main(String[] args) {ArrayList<Integer>list=new ArrayList<>();list.add(1);list.add(2);list.add(3);list.add(4);list.add(5);list.add(6);list.add(7);list.add(8);list.add(9);list.add(10);//Collections.addAll(list,1,2,3,4,5,6,7,8,9,10);List<Integer> newList = list.stream().filter(n -> n % 2 == 0).collect(Collectors.toList());System.out.println(newList);}
}
import java.util.ArrayList;
import java.util.Map;
import java.util.stream.Collectors;public class Test {public static void main(String[] args) {ArrayList<String>list=new ArrayList<>();list.add("zhangsan,23") ;list.add("lisi,24");list.add("wangwu,25");//System.out.println(list);// list.stream().filter(s->Integer.parseInt(s.split(",")[1])>=24)
// .collect(Collectors.toMap(new Function<String, String>() {
// @Override
// public String apply(String s) {
// return s.split(",")[0];
// }
// }, new Function<String, Integer>() {
// @Override
// public Integer apply(String s) {
// return Integer.parseInt(s.split(",")[1]);
// }
// }));Map<String, Integer> map = list.stream().filter(s -> Integer.parseInt(s.split(",")[1]) >= 24).collect(Collectors.toMap(s -> s.split(",")[0], s -> Integer.parseInt(s.split(",")[1])));System.out.println(map);}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class Test {public static void main(String[] args) {//1.创建两个集合ArrayList<String>manList=new ArrayList<>();ArrayList<String>womenList=new ArrayList<>();//添加数据Collections.addAll(manList,"言热额,12","叶的的,22","李人,44","得到,14","隐覆盖,99");Collections.addAll(womenList,"赵,35","杨1,37","高,54","张,84","杨2,90");//男演员只要名字为三个字的前两个Stream<String> stream1 = manList.stream().filter(s -> s.split(",")[0].length() == 3).limit(2);//女演员只要姓杨的 且不要第一个Stream<String> stream2 = womenList.stream().filter(s -> s.split(",")[0].startsWith("杨")).skip(1);//把过滤后的两个流和在一起//演员信息封装成为actor对象(类型转换)//Actor里面有姓名和年龄
// Stream.concat(stream1,stream2).map(new Function<String, Actor>() {
// @Override
// public Actor apply(String s) {
// String name = s.split(",")[0];
// int age = Integer.parseInt(s.split(",")[1]);
// return new Actor(name,age);
//
// }
// }).forEach(s-> System.out.println(s));List<Actor> LIST = Stream.concat(stream1, stream2).map(s -> new Actor(s.split(",")[0], Integer.parseInt(s.split(",")[1]))).collect(Collectors.toList());System.out.println(LIST);}
}
方法引用
import java.util.Arrays;public class Test {public static void main(String[] args) {//需求:创建一个数组,进行倒序排列Integer[] arr ={3,5,4,1,6,2};//匿名内部类
// Arrays.sort(arr, new Comparator<Integer>() {
// @Override
// public int compare(Integer o1, Integer o2) {
// return o2-o1;
// }
// });//System.out.println(Arrays.toString(arr));//Lambda表达式//因为第二个参数的类型是Comparator是一个函数式接口
// Arrays.sort(arr,(Integer o1, Integer o2)->{
// return o2-o1;
// });//Lambda表达式简化格式Arrays.sort(arr,(o1,o2)->o2-o1);//方法引用//1.引用处必须是函数式接口//2.被引用的方法需要已经存在//3.被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致//4.被引用的方法的功能需要满足当前的要求//表示引用Test类里面Substraction方法//把这个方法当做抽象方法的方法体Arrays.sort(arr,Test::Substraction);System.out.println(Arrays.toString(arr));}//静态方法要用类名调用//可以是Java已经写好的 也可以是一些第三方的工具类public static int Substraction(int num1,int num2){return num2-num1;}}
import java.util.ArrayList;
import java.util.Collections;public class Test {public static void main(String[] args) {//创建集合并添加元素ArrayList<String>list=new ArrayList<>();Collections.addAll(list,"1","2","3","4","5");//常规方法
// ArrayList<Integer>list2=new ArrayList<>();
// for (String s : list) {
// int i=Integer.parseInt(s);
// list2.add(i);
// }// list.stream().map(new Function<String, Integer>() {
// @Override
// public Integer apply(String s) {
// int i = Integer.parseInt(s);
// return i;
// }
// }).forEach(s-> System.out.println(s));list.stream().map(Integer::parseInt).forEach(s-> System.out.println(s));}}
import java.util.ArrayList;
import java.util.Collections;public class Test {public static void main(String[] args) {//1.创建集合ArrayList<String>list = new ArrayList<>();//2.添加数据Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰");//3.过滤数据("张"开头 而且名字是3个字的)//list.stream().filter(s->s.startsWith("张")).filter(s->s.length()==3).forEach(s-> System.out.println(s));// list.stream().filter(new Predicate<String>() {
// @Override
// public boolean test(String s) {
// return s.startsWith("张")&&s.length()==3;
// }
// }).forEach(s-> System.out.println(s));// list.stream().filter(new StringOperation()::StringJudge).forEach(s-> System.out.println(s));//静态方法中是没有this的 所以这里不能写thislist.stream().filter(new Test()::stringJudge).forEach(s-> System.out.println(s));}public boolean stringJudge(String s){return s.startsWith("张")&&s.length()==3;}}
package Day17;import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;public class Test {public static void main(String[] args) {//引用构造方法//1.创建集合对象ArrayList<String> list = new ArrayList<>();//添加对象Collections.addAll(list, "张无忌,15", "周芷若,14", "赵敏,13");
// //封装成Student对象并收集到List集合当中
// List<Student> newList = list.stream().map(new Function<String, Student>() {
// @Override
// public Student apply(String s) {
// String[] arr = s.split(",");
// String name = arr[0];
// int age = Integer.parseInt (arr[1]);
// return new Student(name, age);
// }
// }).collect(Collectors.toList());
//
// System.out.println(newList);
// }List<Student> newList2 = list.stream().map(Student::new).collect(Collectors.toList());System.out.println(newList2);}}
import java.util.ArrayList;
import java.util.Collections;public class Test {public static void main(String[] args) {/*方法引用的规则:* 1.需要有函数式接口* 2.被引用的方法必须已经存在* 3.被引用方法的形参,需要跟抽象方法的第二个形参保持一致,返回值需要保持一致.* 4.被引用方法的功能需要满足当前的需求* * 抽象方法形参的详解:* 第一个参数:表示引用方法的调用者,决定了可以引用哪些类中的方法* 在Stream流当中 第一个参数一般都表示流里面的每一个数据* 假设流里面的数据都是字符串,那么使用这种方式进行方法引用,只能引用String这个类中的方法* * 第二个参数到最后一个参数,跟被引用方法的形参保持一致,如果没有第二个参数 说明被应用的方法需要无参的成员方法* * 局限性:* 不能引用所有类中的成员方法* 是跟抽象方法的第一个参数有关 这个参数是什么类型的 那么就只能引用这个类中的方法* *///类名引用成员方法//1.创建集合对象ArrayList<String>list = new ArrayList<>();Collections.addAll(list,"aaa","bbb","ccc","ddd");
// list.stream().map(new Function<String, String>() {@Overridepublic String apply(String s) {return s.toUpperCase();}}).forEach(s-> System.out.println(s));//方法引用list.stream().map(String::toUpperCase).forEach(s-> System.out.println(s));}
}
相关文章:

JavaDay17
创建不可变集合 import java.util.Iterator; import java.util.List;public class Test {public static void main(String[] args) {/*创建不可变的List集合* "张三" "李四" "王五" "赵六*///一旦创建之后 是无法进行修改的 在下面的代码…...

Python爬取酷我音乐
🎈 博主:一只程序猿子 🎈 博客主页:一只程序猿子 博客主页 🎈 个人介绍:爱好(bushi)编程! 🎈 创作不易:喜欢的话麻烦您点个👍和⭐! 🎈…...
项目实战第四十七讲:易宝支付对接详解(保姆级教程)
易宝支付对接(保姆级教程) 为了实现项目的支付需求,公司选择了易宝支付进行对接,本文是项目实战第四十七讲,详解易宝支付对接。 文章目录 易宝支付对接(保姆级教程)1、需求背景2、流程图3、技术方案4、相关接口4.1、入驻相关(商户入网)4.2、账户相关接口(充值、提现、…...

python的websocket方法教程
WebSocket是一种网络通信协议,它在单个TCP连接上提供全双工的通信信道。在本篇文章中,我们将探讨如何在Python中使用WebSocket实现实时通信。 websockets是Python中最常用的网络库之一,也是websocket协议的Python实现。它不仅作为基础组件在…...
Qt处理焦点事件(获得焦点,失去焦点)
背景: 我只是想处理焦点动作,由于懒,上网一搜,排名靠前的一位朋友,使用重写部件的方式实现。还是因为懒,所以感觉复杂了。于是又花了一分钟解决了一下。 所以记录下来,以免以后忘了。 思路&a…...

SiteGround如何设置WordPress网站自动更新
SiteGround Autoupdate功能会自动帮我们更新在他们这里托管的所有WordPress网站,这样做是为了保证网站安全,并且让它们一直保持最新状态。他们会根据我们选择的设置自动更新不同版本的WordPress,包括主要版本和次要版本。在每次自动更新之前&…...
http代理和SOCK5代理谁更安全?
在这个网络化的时代,我们常常听到HTTP代理和SOCKS5代理这两个名词,不过很多人并不了解是什么意思。今天,我们将揭开这两种代理的神秘面纱,看看到底HTTP代理和SOCKS5代理哪个更安全? HTTP代理:高效通信的“枢…...
Kotlin关键字二——constructor和init
在关键字一——var和val中最后提到了构造函数,这里就学习下构造函数相关的关键字: constructor和init。 主要构造(primary constructor) kotlin和java一样,在定义类时就自动生成了无参构造 // 会生成默认的无参构造函数 class Person{ }与java不同的是…...

java的long类型超过9位报错:the literal 987654321000 of type int is out of range
java的long类型超过9位报错 1、报错提示2、报错截图3、解决办法4、参考文章 1、报错提示 the literal 987654321000 of type int is out of range 2、报错截图 3、解决办法 long类型是一种用于表示较大整数的数据类型,范围比int类型更广泛。然而,即使…...
【Java期末复习资料】(4)模拟卷
有不会的题可以后台问我的哦,看见了就会回。 本文章主要是模拟卷,知识点例题简答题已经发过了,可以在主页专栏Java中找一下 一、单项选择题 1. 编译 Java Application 源程序文件将产生相应的字节码文件,这些字节码文件的扩展名为…...

【计算机网络】UDP报文详解
目录 一. UDP协议概述 二. UDP报文格式 首部 三. UDP的缓冲区 一. UDP协议概述 UDP——用户数据报协议,是传输层的一个重要协议 基于UDP的应用层协议有:DNS,TFTP,SNMP,NTP 协议全称默认端口号DNSDomain Name Se…...
排序算法——归并排序
归并排序(Merge Sort)是计算机科学中非常重要的排序算法之一。它不仅高效、稳定,而且是许多高级排序技术和算法思想的基础。在本文中,我们将深入探讨归并排序的原理、实现方法,以及它的优缺点。 1. 归并排序的原理 归…...
2023 年安徽省职业院校技能大赛高职组“软件测试”赛项样题
2023 年安徽省职业院校技能大赛 高职组“软件测试”赛项样题 目录 任务一:功能测试(45 分) 1、测试计划(5 分) 2、测试用例(15 分) 3、Bug 清单(20 分) 4、测试报告&…...
Mysql8和Oracle实际项目中递归查询树形结构
背景: 项目升级,引入MySQL数据库,之前一直用的是Oracle数据,在做用户登录单位维护的时候,需要返回该用户所属单位下的所有子单位。下边是模拟项目数据实践的过程。 数据准备: 准备一张单位表,…...

docker mysql8 设置不区分大小写
docker安装Mysql8.0的坑之lower_case_table_names_docker mysql lower_case_table_names-CSDN博客https://blog.csdn.net/p793049488/article/details/108365929 docker run ‐di ‐‐nametensquare_mysql ‐p 33306:3306 ‐e MYSQL_ROOT_PASSWORD123456 mysql...
Audio Siganl (MATLAB) 代码学习—常见问题3
问题描述 生成信号y1: 8000个样本,1000个周期,幅度为0.85的余弦信号。若信号的持续时间为1s,则采样频率和信号频率为多少。生成信号y2: 持续时间为1s,幅度为0.7,频率为500Hz,相位为 π / 4 \pi/4 π/4生成信号y:y_1+y_2绘制前200ms的y信号示意图计算y的DFT绘制频域示意图…...
【PTA题目】7-8 矩阵运算 分数 10
7-8 矩阵运算 分数 10 全屏浏览题目 切换布局 作者 C课程组 单位 浙江大学 给定一个nn的方阵,本题要求计算该矩阵除副对角线、最后一列和最后一行以外的所有元素之和。副对角线为从矩阵的右上角至左下角的连线。 输入格式: 输入第一行给出正整数n(…...
Ubuntu20.04创建并挂在zfs池
Ubuntu 下使用 ZFS [适用于中高级用户] 主磁盘上清洁安装带有ZFS的Ubuntu后,可以开始体验其特性。 所有ZFS配置过程都需要命令行。 我不知道有GUI工具。 创建一个 ZFS 池 本节仅适用于具有多个磁盘的系统。 如果只有一个磁盘,Ubuntu会在安装时自动创建…...
x的平方根算法(leetcode第69题)
题目描述: 给你一个非负整数 x ,计算并返回 x 的 算术平方根 。由于返回类型是整数,结果只保留 整数部分 ,小数部分将被 舍去 。注意:不允许使用任何内置指数函数和算符,例如 pow(x, 0.5) 或者 x ** 0.5 。…...
打破空间限制,畅享真实生活
直播已经成为了当今社会中非常流行的一种娱乐方式,也是人们获取信息和互动的重要渠道之一。而无绿幕直播,则是近年来兴起的一种特殊形式,它打破了以往直播的空间限制,让观众们能够更贴近主播,更真实地感受到直播背后的…...

观成科技:隐蔽隧道工具Ligolo-ng加密流量分析
1.工具介绍 Ligolo-ng是一款由go编写的高效隧道工具,该工具基于TUN接口实现其功能,利用反向TCP/TLS连接建立一条隐蔽的通信信道,支持使用Let’s Encrypt自动生成证书。Ligolo-ng的通信隐蔽性体现在其支持多种连接方式,适应复杂网…...

7.4.分块查找
一.分块查找的算法思想: 1.实例: 以上述图片的顺序表为例, 该顺序表的数据元素从整体来看是乱序的,但如果把这些数据元素分成一块一块的小区间, 第一个区间[0,1]索引上的数据元素都是小于等于10的, 第二…...

RocketMQ延迟消息机制
两种延迟消息 RocketMQ中提供了两种延迟消息机制 指定固定的延迟级别 通过在Message中设定一个MessageDelayLevel参数,对应18个预设的延迟级别指定时间点的延迟级别 通过在Message中设定一个DeliverTimeMS指定一个Long类型表示的具体时间点。到了时间点后…...
pam_env.so模块配置解析
在PAM(Pluggable Authentication Modules)配置中, /etc/pam.d/su 文件相关配置含义如下: 配置解析 auth required pam_env.so1. 字段分解 字段值说明模块类型auth认证类模块,负责验证用户身份&am…...
2024年赣州旅游投资集团社会招聘笔试真
2024年赣州旅游投资集团社会招聘笔试真 题 ( 满 分 1 0 0 分 时 间 1 2 0 分 钟 ) 一、单选题(每题只有一个正确答案,答错、不答或多答均不得分) 1.纪要的特点不包括()。 A.概括重点 B.指导传达 C. 客观纪实 D.有言必录 【答案】: D 2.1864年,()预言了电磁波的存在,并指出…...

基于当前项目通过npm包形式暴露公共组件
1.package.sjon文件配置 其中xh-flowable就是暴露出去的npm包名 2.创建tpyes文件夹,并新增内容 3.创建package文件夹...
聊一聊接口测试的意义有哪些?
目录 一、隔离性 & 早期测试 二、保障系统集成质量 三、验证业务逻辑的核心层 四、提升测试效率与覆盖度 五、系统稳定性的守护者 六、驱动团队协作与契约管理 七、性能与扩展性的前置评估 八、持续交付的核心支撑 接口测试的意义可以从四个维度展开,首…...

Java面试专项一-准备篇
一、企业简历筛选规则 一般企业的简历筛选流程:首先由HR先筛选一部分简历后,在将简历给到对应的项目负责人后再进行下一步的操作。 HR如何筛选简历 例如:Boss直聘(招聘方平台) 直接按照条件进行筛选 例如:…...

Android 之 kotlin 语言学习笔记三(Kotlin-Java 互操作)
参考官方文档:https://developer.android.google.cn/kotlin/interop?hlzh-cn 一、Java(供 Kotlin 使用) 1、不得使用硬关键字 不要使用 Kotlin 的任何硬关键字作为方法的名称 或字段。允许使用 Kotlin 的软关键字、修饰符关键字和特殊标识…...

【VLNs篇】07:NavRL—在动态环境中学习安全飞行
项目内容论文标题NavRL: 在动态环境中学习安全飞行 (NavRL: Learning Safe Flight in Dynamic Environments)核心问题解决无人机在包含静态和动态障碍物的复杂环境中进行安全、高效自主导航的挑战,克服传统方法和现有强化学习方法的局限性。核心算法基于近端策略优化…...