stream42 = Stream.generate(Math::random); // 串行流 limit(long maxSize) 截断,使其元素不超过给定数量 filter(Predicate predicate) 过滤,从流中过滤出想要的元素 skip(long n) 忽略,跳过前n个元素,若流中元素不足n个,则返回空 distinct() 去重,通过元素 hashCode() 和 equals() 去除重复元素 map(Funcation mapper) 映射,函数会被应用到每个元素上,并将其映射成一个新的元素 flatMap(Function mapper) 映射,将流中的每个值都换成一个流,然后把所有流连接成一个流 sorted(Comparator comparator) 排序,定制排序 stream = Stream.generate(Math::random) // double 无限流 .limit(20) // 截断,取前 20 个 .filter(x -> x > 0.3) // 过滤,取大于 0.3 的元素 .skip(1) // 忽略,丢弃第一个元素 .distinct() // 去重 .map(x -> x * 10) // 映射,将每个元素扩大 10 倍 .sorted(); // 对 double 流进行排序 // 终止操作,只有执行终止操作才会执行全部。即：延迟加载 stream.forEach(System.out::println); // 中间操作：flatMap 接收一个函数作为参数,将流中的每个值都换成一个流,然后把所有流连接成一个流 List list = Arrays.asList("aaa", "bbb", "ccc", "ddd"); list.stream().flatMap((e) -> filterCharacter(e)).forEach(System.out::println); //如果使用map则需要这样写 list.stream().map((e) -> filterCharacter(e)).forEach((e) -> { e.forEach(System.out::println); }); public Stream filterCharacter(String str){ List list = new ArrayList<>(); for (Character ch : str.toCharArray()) { list.add(ch); } return list.stream(); } allMatch(Predicate predicate) 检查是否匹配所有元素 anyMatch(Predicate predicate) 检查是否至少匹配所有元素 noneMatch(Predicate predicate) 检查是否没有匹配所有元素 findFirst() 返回第一个元素 findAny() 返回当前流中任意元素 count() 返回流中元素总个数 comparator) min(Comparator comparator) 返回流中最小值
2.3.2 规约 - 将流中元素结合在一起,返回一个值 ） reduce（BinaryOperator） 没有起始值,有可能结果为空,所以返回的值会被封装到Optional中 list = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10); Integer sum = list.stream().reduce(0, (x, y) -> x + y); // 求和,没有起始值,则有可能结果为空,所以返回的值会被封装到Optional中 List list = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10); Optional sum = list.stream().reduce(Integer :: sum); Collectors.toList() 将流转换成List Collectors.toSet() 将流转换为Set Collectors.toCollection(Supplier supplier) 将流转换为其他类型的集合 Collectors.counting() 元素个数 Collectors.averagingInt/Long/Double(Function function) 平均数,不同之处在于传入得参数类型不同,返回值都为Double Collectors.summingInt/Long/Double(Function function) 求和,不同之处在于传入得参数类型不同,返回值为Integer, Double, Long Collectors.maxBy(Comparator comparator) 最大值 Collectors.minBy(Comparator comparator) 最小值 function) Collectors.partitioningBy(Predicate predicate) 分区,传入函数返回true和false 分成两个区,返回Map
3 并行流 { private long start; // 起始数字 private long end; // 结束数字 public ForkJoin(long start, long end) { this.start = start; this.end = end; } // 拆分的最小区间 private static final long THRESHOLD = 10000L; @Override protected Long compute() { // 当区间小于最小区间时,直接计算累加 if (end - start <= THRESHOLD) { long sum = 0; for (long i = start; i < end; i++) { sum += i; } return sum; } else { // 否则,将区间一分为二,分给两个不同的线程去计算 // 注意这里,如果有问题,会抛出java.lang.NoClassDefFoundError: Could not initialize class java.util.concurrent.locks.AbstractQueuedSynchronizer$Node 异常 long middle = start + (end - start) / 2; ForkJoin left = new ForkJoin(start, middle); // 递归,直到分解到最小区间后,开始计算 left.fork(); // 拆分子任务,压入线程队列 ForkJoin right = new ForkJoin(middle, end); // 递归,直到分解到最小区间后,开始计算 right.fork(); // 拆分子任务,压入线程队列 // 合并两部分计算的值 return left.join() + right.join(); } } public static void main(String[] args) { // 开始时间 Instant start = Instant.now(); // 这里需要一个线程池的支持 ForkJoinPool pool = new ForkJoinPool(); // 累加到 1 亿 ForkJoinTask task = new ForkJoin(0, 100000000L); long sum = pool.invoke(task); // 结束时间 Instant end = Instant.now(); System.out.println(String.format("累加到1亿的计算时间为：%s 毫秒,值：%s", Duration.between(start, end).toMillis(), sum)); } } MapReduce 是 Google 大数据处理的三驾马车之一,另外两个是 GFS 和 Bigtable。它在倒排索引、PageRank 计算、网页分析等搜索引擎相关的计数中都有大量的应用。
1. 简介
说一说关于synchronized关键字的理解
最左边是原始图片,中间是canvas内容,右边是将canvas内容导出到img标签中
canvas绘图时,确定图片的原始尺寸,不是显示的dom大小,需要创建元素后获得
如果使用dom大小的话,会在绘制时只能绘制出一部分
canvas目前的感觉是分为绘图层和展示层
旋转和移动的是绘图层的中心
展示层呈现内容,大小也是展示层的大小
Title 旋转 在开发过程中,通常会对一段业务代码不断地修改测试,在修改之后往往需要重启服务,有些服务需要加载很久才能启动成功,这种不必要的重复操作极大的降低了程序开发效率。为此,Spring Boot框架专门提供了进行热部署的依赖启动器,用于进行项目热部署,而无需手动重启项目 演示： 1．添加spring-boot-devtools热部署依赖启动器** 在Spring Boot项目进行热部署测试之前,需要先在项目的pom.xml文件中添加spring-boot-devtools热部署依赖启动器: ```xml org.springframework.boot spring-boot-devtools ``` 由于使用的是IDEA开发工具,添加热部署依赖后可能没有任何效果,接下来还需要针对IDEA开发工具进行热部署相关的功能设置 **2. IDEA工具热部署设置** 选择IDEA工具界面的【File】->【Settings】选项,打开Compiler面板设置页面选择Build下的Compiler选项,在右侧勾选“Build project automatically”选项将项目设置为自动编译,单击【Apply】→【OK】按钮保存设置 在项目任意页面中使用组合快捷键“Ctrl+Shift+Alt+/”打开Maintenance选项框,选中并打开Registry页面,具体如图1-17所示 列表中找到“compiler.automake.allow.when.app.running”,将该选项后的Value值勾选,用于指定IDEA工具在程序运行过程中自动编译,最后单击【Close】按钮完成设置 这些内容,是从拉勾教育的《Java工程师高薪训练营》里学到的,课程内容非常全面,还有拉勾的内推大厂服务,推荐你也看看。
将mybatis全局配置文件对应的DOM转换为XNODE对象 ... /** * 根据表达式解析Document对象获取对应的节点 * * @param expression Xpath地址表达式 * @return XNode */ public XNode evalNode(String expression) { // 从document对象解析出指定的节点 return evalNode(document, expression); }
消费者也期待小型跨境电商零售商提供与大型跨境电商零售商（如亚马逊）相同的服务,这些服务包括加急运输,当日交货,退货简单,实时库存可见性以及清单。一套好的ERP系统能够让小型跨境电商卖家为客户提供更好的服务。那么跨境电商ERP系统能够带来哪些好处呢？
public class TestThreadlocal { private static ThreadLocal local = new ThreadLocal(){ @Override protected Integer initialValue() { return 1; } }; public static void main(String[] args) { for (int j = 0; j < 5; j++) { new Thread(() -> { Integer i = local.get(); local.set(i+=5); System.out.println(Thread.currentThread().getName() + "-" + local.get()); }).start(); } } } > { /** The value associated with this ThreadLocal. */ Object value; Entry(ThreadLocal k, Object v) { super(k); value = v; } }
1.bean copy package com.qimh.springbootfiledemo.utils; import org.apache.poi.ss.formula.functions.T; import java.lang.reflect.Field; /** * @author * bean 复制 */ public class BeanCopy { /** * bean 的拷贝 * @param srcBean--原始bean * @param destClazz--目标class对象 * 这个 T 表示的是返回值T是泛型 * T是一个占位符,用来告诉编译器,这个东西先给我留着,等我编译的时候,告诉你。 * https://www.cnblogs.com/jpfss/p/9929108.html */ public static T beanCopy(Object srcBean,Class destClazz) throws IllegalAccessException, InstantiationException, NoSuchFieldException { if (null != srcBean && null != destClazz){ //获取目标bean的实例 T destBean = destClazz.newInstance(); //获取目标bean所有字段 Field[] fields = destClazz.getDeclaredFields(); for (int i = 0;i < fields.length;i++){ Field field = fields[i]; Object value = BeanEquals.getClassValue(srcBean,field.getName()); //获取目标类的字段 Field destField = destClazz.getDeclaredField(field.getName()); //可访问私有属性 destField.setAccessible(true); //给目标类属性设置值 destField.set(destBean,value); } return destBean; } return null; } } map = new HashMap(); map = (HashMap) source; for (String key : map.keySet()) { if (target instanceof Map) { HashMap tarMap = new HashMap(); tarMap = (HashMap) target; if(tarMap.get(key)==null){ rv = false; break; } if (!map.get(key).equals(tarMap.get(key))) { rv = false; break; } } else { String tarValue = getClassValue(target, key) == null ? "" : getClassValue(target, key).toString(); if (!tarValue.equals(map.get(key))) { rv = false; break; } } } return rv; } /** * 源目标为非MAP类型时 * @param source * @param target * @param rv * @return */ private static boolean classOfSrc(Object source, Object target, boolean rv) { Class srcClass = source.getClass(); Field[] fields = srcClass.getDeclaredFields(); for (Field field : fields) { String nameKey = field.getName(); if (target instanceof Map) { HashMap tarMap = new HashMap(); tarMap = (HashMap) target; String srcValue = getClassValue(source, nameKey) == null ? "" : getClassValue(source, nameKey) .toString(); if(tarMap.get(nameKey)==null){ rv = false; break; } if (!tarMap.get(nameKey).equals(srcValue)) { rv = false; break; } } else { if (nameKey.equals("carts")){ System.out.println("field:" + nameKey); } if (nameKey.equals("friends")){ System.out.println("field:" + nameKey); } //数组类型 if (!StringUtils.isEmpty(getClassValue(source, nameKey)) && getClassValue(source, nameKey) instanceof Object[]){ rv = Arrays.equals((Object[])getClassValue(source, nameKey),(Object[])getClassValue(target, nameKey)); break; } String srcValue = getClassValue(source, nameKey) == null ? "" : getClassValue(source, nameKey) .toString(); String tarValue = getClassValue(target, nameKey) == null ? "" : getClassValue(target, nameKey) .toString(); if (!srcValue.equals(tarValue)) { rv = false; break; } } } return rv; } /** * 根据字段名称取值 * @param obj * @param fieldName * @return */ public static Object getClassValue(Object obj, String fieldName) { if (obj == null) { return null; } try { Class beanClass = obj.getClass(); Method[] ms = beanClass.getMethods(); for (int i = 0; i < ms.length; i++) { // 非get方法不取 if (!ms[i].getName().startsWith("get")) { continue; } Object objValue = null; try { objValue = ms[i].invoke(obj, new Object[] {}); } catch (Exception e) { logger.info("反射取值出错：" + e.toString()); continue; } if (objValue == null) { continue; } if (ms[i].getName().toUpperCase().equals(fieldName.toUpperCase()) || ms[i].getName().substring(3).toUpperCase().equals(fieldName.toUpperCase())) { return objValue; } else if (fieldName.toUpperCase().equals("SID") && (ms[i].getName().toUpperCase().equals("ID") || ms[i].getName().substring(3).toUpperCase() .equals("ID"))) { return objValue; } } } catch (Exception e) { // logger.info("取方法出错！" + e.toString()); } return null; } public static void main(String args[]) { Person person1 = new Person(); person1.setName("张三"); person1.setAge(20); JSONObject carts = new JSONObject(); carts.put("bmw","宝马"); carts.put("audi","奥迪"); person1.setCarts(carts); person1.setFriends(new String[]{"tom","jim"}); Person person2 = new Person(); person2.setName("张三"); person2.setAge(20); JSONObject carts2 = new JSONObject(); carts2.put("bmw","宝马"); carts2.put("audi","奥迪"); person2.setCarts(carts2); person2.setFriends(new String[]{"tom","jim2"}); System.out.println(domainEquals(person1,person2)); } }
敏捷软件开发是从1990年代开始逐渐引起广泛关注的一种新型软件开发方法,是能够应对快速变化的需求的一种软件开发能力,它作为一种新型的开发模式,被越来越多地应用到软件项目中。
内存管理可以说是任何基于 C/C++ 的系统程序的基石,需要谨慎对待。
今天和大家聊一聊关于如何设计测试用例,以及如何提高测试用例的覆盖度？
1. 应用测试的介绍
一般我们在写完代码之后,代码的测试是会给专门的测试人员来测试的,如果一个测试跑到你的工位上对你说,你的代码好像有Bug,你肯定会不爽,反正我就是这样的🙃。所以为了显示自己的代码质量高一点,在功能提交给测试之前,我们会自己测试一下,接下来给大家介绍一下 Spring Boot Test 应用测试框架。
Spring Boot Test 其实就是Spring Test,只是在Spring Boot 中集成变得更简单了,像我们开发自己测试,一般都是单元测试Junit测试,不出bug就谢天谢地啦,Spring Test与JUnit结合起来提供了高效便捷的测试解决方案,而Spring Boot Test是在Spring Test之上增加了切片测试并增强了Mock能力。
Spring Boot Test支持的测试种类,主要分为以下三类： 单元测试,面向方法的测试,常用注解有@Test。(一般都是用这个) 功能测试,面向业务的测试,同时也可以使用切面测试中的Mock能力,常用的注解有@RunWith,@SpringBootTest等。(这个也用得多) 切片测试,面向难于测试的边界功能,介于单元测试和功能测试之间,常用注解有@RunWith,@WebMvcTest等。
测试过程中的关键要素及支撑方式如下： 测试运行环境,通过@RunWith和@SpringBootTest启动Spring容器。 Mock能力,Mockito提供Mock能力。 断言能力,AssertJ、Hamcrest、JsonPath提供断言能力。
接下来我带领大家学习如何简单使用Spring Boot Test框架。
2. Spring Boot Test 的使用 2.1 引入依赖
在Spring Boot中开启测试只需要引入spring-boot-starter-test依赖,使用@RunWith和@SpringBootTest注解就可以开始测试。我们就简单测试一下接口,首先我们引入pom依赖：
pom.xml ：
org.springframework.boot spring-boot-starter-parent 2.2.2.RELEASE org.springframework.boot spring-boot-starter-web 2.2.2.RELEASE org.mybatis.spring.boot mybatis-spring-boot-starter 2.1.0 mysql mysql-connector-java 8.0.18 org.projectlombok lombok 1.18.10 org.springframework.boot spring-boot-test junit junit 4.12 test org.springframework spring-test 5.2.2.RELEASE test org.springframework.boot spring-boot-maven-plugin org.apache.maven.plugins maven-compiler-plugin -parameters 2.2 代码编写
测试代码我们一般都写在与main文件夹平级的test文件夹下,建议文件夹的名称和main文件夹下的文件夹对应好,测试类的名称也要对应好,就像下面这样,当然这只是建议。
Spring Boot 的启动类我就不再写了,没有加什么特别的内容,直接上测试类吧。
StudentServiceTest.java :
对了,这里测试的每一个方法都和 StudentService.java 这个服务类的方法名对应着的,建议大家也是这样。 package com.butterflytri.service; import com.butterflytri.TestApplication; import com.butterflytri.entity.Student; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.test.context.junit4.SpringRunner; import javax.annotation.Resource; import java.util.List; /** * @author: WJF * @date: 2020/5/23 * @description: StudentServiceTest */ /** * {@link SpringBootTest}：配置文件属性的读取。读取classes标志的启动类的配置文件和运行环境,并加载。 * {@link RunWith}：'RunWith'注解就是一个运行器,加载value的Class测试环境。 */ @SpringBootTest(classes = TestApplication.class) @RunWith(SpringRunner.class) public class StudentServiceTest { @Resource private StudentService studentService; @Test public void findAllTest() { List
list = studentService.findAll(); for (Student student : list) { System.out.println(student); } } @Test public void findOneTest() { Student student = studentService.findOne(1L); System.out.println(student); } @Test public void findByStudentNoTest() { Student student = studentService.findByStudentNo("G030511"); System.out.println(student); } } 闭包是一个很有意思的东西,理解起来很绕,但是理解后很简单,网上的讲解也朦朦胧胧的.根据自己的理解解释一番:
当你想查询一下火车票信息的时候,你还在上12306官网吗？或是打开你手机里的APP？ Options: -h,--help 显示帮助菜单 -g 高铁 -d 动车 -t 特快 -k 快速 -z 直达 Example: tickets 南京 北京 2016-07-01 tickets -dg 南京 北京 2016-07-01 """ from docopt import docopt def cli(): """command-line interface""" arguments = docopt(__doc__) print(arguments) if __name__ == '__main__': cli() ': '2016-07-01', '': '上海', '': '北京'} ']) to_station = stations.get(arguments['']) date = arguments[''] # 构建URL url = 'https://kyfw.12306.cn/otn/lcxxcx/query?purpose_codes=ADULT&queryDate={}&from_station={}&to_station={}'.format( date, from_staion, to_station )
pyenv
在 IntelliJ 中选择 File > Project Structure > Platform Settings > SDKs
缓存设计
1. 前言
在写代码的时候缓存可以说是用的比较多了,主要还是用来缓存已经查询出的一些数据方便下一次能够更加快速的获取对应的结果,比如同一条sql或者以及比较复杂的sql等等,其中比较出名的就是redis缓存了,因为基于内存操作且是分布式的缓存所以项目中用的比较多了,但是一般的框架也会实现本地缓存,在现在分布式项目下,本地缓存无法跨过服务器所以用处被降低,但是大多数项目还是会设置本地缓存,毕竟不可能让别人使用你的框架还得先开启一个redis才能使用,这样不合理也没必要,所以想根据市面上框架的缓存设计进行学习和总结以便加深自己对缓存的了解。
1.1 技术选型
首先要有点基本概念,就是怎么考虑一个缓存,第一个就是缓存的存储类,毕竟缓存,缓存总得有个类来存,第二个就是缓存的操作,可以往容器中添加,那第三个就是容器了,用来存储我们的缓存对象。不过其实用HashMap作为底层也ok,就平常我们学spring框架,BeanFactory是工厂的基础操作类,而BeanDefiniton才是真正的对象包装类,看上去的关系就如下。
目前所研究的框架主要有以下几个 google.guava /** * key-value的缓存形式,存储到缓存中直到被手动释放或者驱逐 * 该接口的实现是线程安全的并且可以由多个线程并发安全的访问 */ @Beta @GwtCompatible public interface Cache < K , V > { /** * 返回与Key关联的值,如果没有缓存该key则返回null */ @Nullable V getIfPresent ( Object key ); /** * 返回此缓存将指定键映射到的值,并在必要时从{@code valueLoader}获取该值。 此方法为常规的“如果已缓存,则返回；否则创建,缓存并返回”模式提供了简单的替代方法。 * 如果可能的话,实现应确保加载操作是同步的,以便在同时访问同一键的情况下,仅调用一次指定的{@code valueLoader}。 */ V get ( K key , Callable valueLoader ) throws ExecutionException ; ImmutableMap < K , V > getAllPresent ( Iterable keys ); void put ( K key , V value ); void putAll ( Map m ); /** * 清除该键的所有缓存之 */ void invalidate ( Object key ); /** * 清除该键的所有缓存之 * * @since 11.0 */ void invalidateAll ( Iterable keys ); /** * 清除所有键 */ void invalidateAll (); /** * 返回该缓存的entries数量hk; */ long size (); /** * 返回此缓存的累积统计信息的当前快照。 所有统计信息均初始化为零,并在缓存的整个生命周期内单调增加。 */ CacheStats stats (); /** * 以线程安全映射的形式返回存储在此缓存中的entries的视图。 对map的修改将直接影响缓存。 */ ConcurrentMap < K , V > asMap (); /** * 执行缓存所需的所有暂挂维护操作。 究竟要执行的活动（如果有）取决于实现。 */ void cleanUp (); } spring-context /** * 通用的接口操作工具类 * *
Note: 推荐允许存储null值,比如方法返回null */ public interface Cache { String getName (); /** * 返回底层native缓存提供程序。 */ Object getNativeCache (); @Nullable ValueWrapper get ( Object key ); /** * 将返回值转换成指定的type类型 */ @Nullable < T > T get ( Object key , @Nullable Class < T > type ); /** * 返回此缓存将指定键映射到的值,并在必要时从{@code valueLoader}获取该值。 此方法为常规的“如果已缓存,则返回；否则创建,缓存并返回”模式提供了简单的替代方法。 * 如果可能的话,实现应确保加载操作是同步的,以便在同时访问同一键的情况下,仅调用一次指定的{@code valueLoader}。 */ @Nullable < T > T get ( Object key , Callable < T > valueLoader ); void put ( Object key , @Nullable Object value ); /** * 先从缓存获取,如果不存在则进行插入 *
* ValueWrapper existingValue = cache.get(key); * if (existingValue == null) { * cache.put(key, value); * } */ default ValueWrapper putIfAbsent ( Object key , @Nullable Object value ) { ValueWrapper existingValue = get ( key ); if ( existingValue == null ) { put ( key , value ); } return existingValue ; } /** * 清除指定key */ void evict ( Object key ); /** * 委托给evict执行,如果没有或者不确定之前存在该key,则返回false */ default boolean evictIfPresent ( Object key ) { evict ( key ); return false ; } /** * 清除所有映射 */ void clear (); /** * 清除所有映射 * {@code true} 如果之前有缓存映射 * {@code false} 如果没有或者无法确定之前是否存在entries */ default boolean invalidate () { clear (); return false ; } /** * 缓存包装对象 */ @FunctionalInterface interface ValueWrapper { /** * 返回真实值 */ @Nullable Object get (); } /** * 值加载程序回调失败而引起异常 * */ class ValueRetrievalException extends RuntimeException { @Nullable private final Object key ; public ValueRetrievalException ( @Nullable Object key , Callable loader , Throwable ex ) { super ( String . format ( "Value for key '%s' could not be loaded using '%s'" , key , loader ), ex ); this . key = key ; } @Nullable public Object getKey () { return this . key ; } } } shiro-cache /** * 此接口在基础缓存框架的缓存实例（例如JCache,Ehcache,JCS,OSCache,JBossCache,TerraCotta,Coherence,GigaSpaces等）之上提供了一个抽象（包装器）API,从而允许Shiro用户配置任何 他们选择的缓存机制。 */ public interface Cache < K , V > { public V get ( K key ) throws CacheException ; public V put ( K key , V value ) throws CacheException ; public V remove ( K key ) throws CacheException ; public void clear () throws CacheException ; public int size (); public Set < K > keys (); public Collection < V > values (); } ibatis /** * SPI用于缓存提供程序。 * 将为每个名称空间创建一个缓存实例。 *缓存实现必须具有一个构造函数,该构造函数将缓存ID作为String参数接收。 * MyBatis将把名称空间作为ID传递给构造函数。 * public MyCache(final String id) { * if (id == null) { * throw new IllegalArgumentException("Cache instances require an ID"); * } * this.id = id; * initialize(); * } */ public interface Cache { /** * 获取缓存id */ String getId (); void putObject ( Object key , Object value ); Object getObject ( Object key ); Object removeObject ( Object key ); void clear (); int getSize (); default ReadWriteLock getReadWriteLock () { return null ; } * @param * @return */ < K , V > Cache < K , V > getCache ( String name ); /** * 获取所有的Cache名称 * @return */ Collection < String > getCacheNames (); } package com . zxw . cache . support ; import com . zxw . cache . Cache ; import com . zxw . cache . CacheManager ; import java . util . Collection ; import java . util . Collections ; import java . util . Set ; import java . util . concurrent . ConcurrentHashMap ; /** * @author zxw * @date 2020/5/31 13:34 */ public abstract class AbstractCacheManager implements CacheManager { private final ConcurrentHashMap < String , Cache > cacheMap ; private volatile Set < String > cacheNames ; public AbstractCacheManager () { this ( new ConcurrentHashMap <> ( 16 )); } public AbstractCacheManager ( ConcurrentHashMap < String , Cache > cacheMap ) { this ( cacheMap , Collections . emptySet ()); } public AbstractCacheManager ( ConcurrentHashMap < String , Cache > cacheMap , Set < String > cacheNames ) { this . cacheMap = cacheMap ; this . cacheNames = cacheNames ; } @Override public < K , V > Cache < K , V > getCache ( String name ) { Cache cache = this . cacheMap . get ( name ); // 如果存在该cache,则直接返回 if ( cache != null ) { return cache ; } // 如果cache不存在,则创建一个cache Cache missingCache = getMissingCache ( name ); if ( missingCache == null ) { synchronized ( this . cacheMap ) { cache = this . cacheMap . get ( name ); if ( cache == null ) { cache = CreateCache ( name ); cacheMap . putIfAbsent ( name , cache ); } } } return cache ; } public abstract Cache CreateCache ( String name ); protected abstract Collection loadCaches (); @Override public Collection < String > getCacheNames () { return cacheNames ; } public Cache getMissingCache ( String name ) { return null ; } } cacheMap; 软件开发的是一项系统的工程,就像盖房子一样其分工也是很明确的,比如写前端的,后端编程的,写底层的。。。等等。
Python--从集合中随机取出一个元素
Python--报错RecursionError: maximum recursion depth exceeded in comparison
关于Python的就业方向,如果你还在学习还没开始找工作,这篇文章绝对会对你有所帮助。
前几天小编分别利用 Python正则表达式 、 BeautifulSoup 、 Xpath 分别爬取了京东网商品信息,今天小编利用CSS选择器来为大家展示一下如何实现京东商品信息的精准匹配~~
>作者 谢恩铭,公众号「 程序员联盟 」。 转载请注明出处。 原文： https://www.jianshu.com/p/49fdba563d53
== 等于 > 大于 < 小于 >= 大于等于 != 不等于
>判断“等于”需要两个等号（ == ）！ 一个很常见的错误是只写一个等号,在 C语言中一个等号和两个等号具有不同的含义。一个等号表示赋值,两个等号才是判断是否相等。 int main(int argc, char *argv[]) { int age = 20; if (age >= 18) { printf("你成年了!n"); } return 0; } && 逻辑与 ! 逻辑非 int main(int argc, char *argv[]) { int age = 25; int adult = 0; adult = age >= 18; printf("adult 的值是 : %dn", adult); return 0; } int main(int argc, char *argv[]) { int choiceMenu; printf("=== 菜单 ===nn"); printf("1. 北京烤鸭n"); printf("2. 锅包肉n"); printf("3. 地三鲜n"); printf("4. 梅菜扣肉n"); printf("n您的选择是 ? "); scanf("%d", &choiceMenu); printf("n"); switch (choiceMenu) { case 1: printf("您选了北京烤鸭。这是本店的招牌菜!"); break; case 2: printf("您选了锅包肉。您是东北人吧?"); break; case 3: printf("您选了地三鲜。实惠好吃,就是油有点多."); break; case 4: printf("您选了梅菜扣肉。嗯,那个味道很棒!"); break; default: printf("您没有选择餐单上的数字,难道您要饿肚子吗 ?"); break; } printf("n"); return 0; } 题目 > levelOrderBottom(TreeNode root) { List> ans = new ArrayList<>(); if (root == null) { return ans; } Queue q = new LinkedList<>(); q.add(root); while (!q.isEmpty()) { List tmp = new ArrayList<>(); int len = q.size(); for (int i = 0; i < len; i++) { TreeNode node = q.poll(); tmp.add(node.val); if (node.left != null) { q.add(node.left); } if (node.right != null) { q.add(node.right); } } // 在索引 0 的位置加入一维数组 tmp // 每次新的数组进来都会被放在开始的位置 ans.add(0, tmp); } return ans; } }
一、观察者模式的概念 观察者模式（又被称为发布-订阅（Publish/Subscribe）模式,属于行为型模式的一种,它定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时,会通知所有的观察者对象,使他们能够自动更新自己。 observers; public EngineOffEvent() { observers = new ArrayList(); } // 注册观察者 public void registerObserver(Observer ob) { observers.add(ob); } // 移除观察者 public void removeObserver(Observer ob) { int index = observers.indexOf(ob); if (index >= 0) observers.remove(index); } // 发生变化进行通知 public void notifyObservers(String data) { // 通知全部观察者 for (Observer ob : observers) { ob.update(data); } } } // 使用 public class Client { public static void main(String[] args) { Subject subject = new EngineOffEvent(); subject.registerObserver(new LocaltionObserver()); subject.registerObserver(new NotificationObserver()); subject.registerObserver(new TripObserver()); subject.notifyObservers("京A88888熄火"); } } //京A88888熄火：更新位置。 //京A88888熄火：发送通知。 //京A88888熄火：生成行程。 ,在发生变化后,循环调用List中的对象的方法,确保都通知到,并且可以对List进行添加和删除。
求：
给定一个包含 n + 1 个整数的数组 nums,其数字都在 1 到 n 之间（包括 1 和 n）,可知至少存在一个重复的整数。假设只有一个重复的整数,找出这个重复的数。
示例 1:
输入: [1,3,4,2,2]
输出: 2
示例 2:
输入: [3,1,3,4,2]
输出: 3
说明：
不能更改原数组（假设数组是只读的）。
只能使用额外的 O(1) 的空间。
时间复杂度小于 O(n2) 。
数组中只有一个重复的数字,但它可能不止重复出现一次。
解：
思路：使用常规的数组遍历方法很容易获得答案,但是时间复杂度是O(N^2),而题目要求时间复杂度小于O(N^2)。我们也容易想到使用哈希表存储数字出现的次数,但这违反了只能使用O(1)的额外空间的约束。因此本题得到的算法,我们可以认为并不要求时间复杂度最优,而是使用部分时间换取空间,在时空效率上达到一个相对的平衡。（实际生产中时间换空间是少见的,本题具有特殊性）
常规方法如下：
int findDuplicate( int * nums, int numsSize){ int i,j; for (i= 0 ;i
因此我们进一步进行优化,我们先假设没有重复数,设cnt[i]为小于等于i的个数,那么对区间[1,N]上的每一个数,均出现一次,均满足：cnt[i]=i。现在我们假设在区间[1,N]中的某个位置（设为target）加入一个重复的数。加入重复的数后,对任意i=target,cnt[i]=i+1>i。以上假设target对应的数仅重复了一次,如果我们让这个数重复多次,那么可以认为我们使用target位置上的数去对其他位置的数进行了若干次替换。如果替换的数小于target,那么对ii。 因此我们可以得到,如果target是我们的目标结果,则对itarget,总是有cnt[i]>i。因此我们使用二分查找的方法,令low=0,high=numsSize-1,每次取区间中值mid,遍历原数组后如果cnt[mid]<=mid,说明结果在[mid+1,high]的分支中,更新low为mid+1,继续查找。如果cnt[mid]>mid,说明结果在[low,mid-1]的分支中,更新high为mid-1,记录当前的i,继续查找直到low==high。返回此时的i,即为所求的target。 int findDuplicate( int * nums, int numsSize){ int i,mid,ret; int low = 1 ; int high = numsSize- 1 ; while (low<=high){ int count = 0 ; mid = (low+high)>> 1 ; for (i= 0 ;i 状态模型
一.相关介绍
C++ 九阴真经之单例模式 class Singleton : public noncopyable { public: static T & get_instance() { static T ins; do_nothing(instance); return ins; } private: static T & instance; static void do_nothing(T const &) {} }; template T & Singleton< T >::instance = Singleton< T >::get_instance(); m_val; }; using TestAgent = Singleton; int main() { std::cout << "开始" << std::endl; TestAgent::get_instance().a = 10; std::cout << "value:" << TestAgent::get_instance().a << std::endl; return 0; }
题目 > triangle) { // 特判 if (triangle == null || triangle.size() == 0) { return 0; } // dp中记录了求第i行时,第i+1的最小路径和 int[] dp = new int[triangle.size() + 1]; for (int i = triangle.size() - 1; i >= 0; i--) { List rows = triangle.get(i); for (int j = 0; j < rows.size(); j++) { dp[j] = Math.min(dp[j], dp[j + 1]) + rows.get(j); } } return dp[0]; }
支付对账,即检查第三方支付与数据库中账单是否一一对应,涉及到微信对账单的处理,成功时,微信账单接口返回数据以文本表格的方式返回,第一行为表头,后面各行为对应的字段内容,字段内容跟查询订单或退款结果一致,具体字段说明可查阅相应接口。
一、概述
.png)
大数据引擎.png)
大数据应用.png)
大数据底层技术.png)
ForeSpider软件
.png)
采集服务.png)
软件学习.png)
智能分析.png)
特征提取.png)
智能计算.png)
数据可视化.png)
数据分析应用.png)
系统集成服务.png)
代码工具.png)
金融方案.png)
制造业&物流.png)
企业数字化.png)
医疗方案.png)
政务方案.png)
实时监测.png)
智能分析.png)
数据智能挖掘.png)
全网自动采集.png)
场景智慧采集.png)
主题识别采集
022-2345 2937
185 2247 0110
business@forenose.com
022-2345 2937
185 2247 0110
business@forenose.com
前嗅大数据
津公网安备12010102001008号