精华内容
下载资源
问答
  • 在组合查询的窗体李面有两个窗体的选项带时间和日期的输入,但是时间和日期的输入都需要一定的格式才能被数据库所识别,那么怎样才能让用户直接就能方便的输入数据而又不违反格式规定呢?  在组合窗体的内容项上,...

                 在组合查询的窗体李面有两个窗体的选项带时间和日期的输入,但是时间和日期的输入都需要一定的格式才能被数据库所识别,那么怎样才能让用户直接就能方便的输入数据而又不违反格式规定呢?

            在组合窗体的内容项上,我添加了DTpiker的这个控件,从而就可以实现规范输入了,但是要怎么使用呢?

    首先把窗体建好后,插入日期控件

    然后把大小调整的和查询框一样大覆盖

    然后就是代码的工作了:

    在属性里把控件的可见性设为否

    然后在字段选择的combo框的click事件里写下如下代码

        If CombField(Index).Text = "上机时间" Or CombField(Index).Text = "下机时间" Then
            DTPicker1(Index).Visible = True
            DTPicker1(Index).Format = dtpTime   <span style="color:#009900;">'时间的格式</span>
            txtInquir(Index).Text = DTPicker1(Index).Value
        End If
        
         If CombField(Index).Text = "上机日期" Or CombField(Index).Text = "下机日期" Then
            DTPicker1(Index).Visible = True
            DTPicker1(Index).Format = dtpShortDate     <span style="color:#009900;">'日期的格式</span>
            txtInquir(Index).Text = DTPicker1(Index).Value
        End If

    实现了在输入日期的时候显示日期控件

    然后是日期控件的代码

    Private Sub DTPicker1_Change(Index As Integer)
        txtInquir(Index).Text = DTPicker1(Index).Value
    End Sub

    然后就实现可选择式输入时间了


    展开全文
  • 怎样用Java 8优雅的...日期和时间API项目地址参考 函数式编程 匿名函数 λ演算 流式编程 基本原理 在Java中流式编程的基本原理有两点。 构建流 数据流转(流水线) 规约 IntStream.rangeClosed(1, 100) // 1. 构建流

    怎样用Java 8优雅的开发业务

    函数式编程

    匿名函数

    λ演算

    流式编程

    基本原理

    Java中流式编程的基本原理有两点。

    1. 构建流
    2. 数据流转(流水线)
    3. 规约
    IntStream.rangeClosed(1, 100) // 1. 构建流
        .mapToObj(String::valueOf)// 2. 数据流转(流水线)
        .collect(joining());      // 3. 规约
    

    案例

    • 英雄的主位置一共有几类,分别是什么
    @Test
    fun t1() {
        // 英雄的主位置一共有几类,分别是什么
        // 映射
        val roleMains = heroes.map(Hero::getRoleMain)
            // 过滤为空的数据
            .filter(Objects::nonNull)
            // 去重
            .distinct()
        println(roleMains.size)
        println(roleMains)
    }
    
    @Test
    public void t1() {
        // 英雄的主位置一共有几类,分别是什么
        List<String> roleMains = heroes.stream()
                // 映射
                .map(Hero::getRoleMain)
                // 过滤为空的数据
                .filter(Objects::nonNull)
                // 去重
                .distinct()
                // 收集列表
                .collect(toList());
        System.out.println(roleMains.size());
        System.out.println(roleMains);
    }
    

    • 英雄按主次位置分组后,输出每个分组有多少英雄,其中:近战英雄有多少位,远程英雄有多少位
    @Test
    fun t2() {
        // 英雄按主次位置分组后,输出每个分组有多少英雄,其中:近战英雄有多少位,远程英雄有多少位
    
        // 主次位置分组的英雄数量
        val groupHeroCount = heroes.groupingBy {
            Pair.of(it.roleMain, it.roleAssist)
        }.eachCount()
    
        // 主次分组后,再按攻击范围分组的英雄数量
        val groupThenGroupCount = heroes.groupBy {
            Pair.of(it.roleMain, it.roleAssist)
        }.map {
            val value = it.value.groupingBy(Hero::getAttackRange).eachCount()
            Pair.of(it.key, value)
        }.associateBy({ it.left }, { it.value })
    
        // 遍历输出
        groupThenGroupCount.forEach { (groupKey, groupValue) ->
            val groupingCount = groupHeroCount[groupKey]
            print("英雄分组key为:$groupKey;英雄数量:$groupingCount;")
            groupValue.forEach { (countKey, countValue) ->
                print("英雄攻击范围:$countKey;英雄数量:$countValue;")
            }
            println()
        }
    }
    
    @Test
    public void t2() {
        // 英雄按主次位置分组后,输出每个分组有多少英雄,其中:近战英雄有多少位,远程英雄有多少位
    
        // 主次位置分组的英雄数量
        Map<Pair<String, String>, Long> groupHeroCount = heroes.stream()
                .collect(groupingBy(hero -> Pair.of(hero.getRoleMain(), hero.getRoleAssist()), counting()));
    
        // 主次分组后,再按攻击范围分组的英雄数量
        Map<Pair<String, String>, Map<String, Long>> groupThenGroupCount = heroes.stream()
                .collect(groupingBy(hero -> Pair.of(hero.getRoleMain(), hero.getRoleAssist()),
                        groupingBy(Hero::getAttackRange, counting())));
    
        // 遍历输出
        groupThenGroupCount.forEach((groupKey, groupValue) -> {
            Long groupingCount = groupHeroCount.get(groupKey);
            System.out.print("英雄分组key为:" + groupKey + ";英雄数量:" + groupingCount + ";");
            groupValue.forEach((countKey, countValue) -> System.out.print("英雄攻击范围:" + countKey + ";英雄数量:" + countValue + ";"));
            System.out.println();
        });
    }
    

    • 求近战英雄HP初始值的加总
    @Test
    fun t3() {
        // 求近战英雄HP初始值的加总
        val sum = heroes.filter { "近战" == it.attackRange }
            .map(Hero::getHpStart)
            .filter(Objects::nonNull)
            .reduce(BigDecimal::add)
        println("近战英雄HP初始值的加总为:$sum")
    }
    
    @Test
    public void t3() {
        // 求近战英雄HP初始值的加总
        BigDecimal sum = heroes.stream()
                .filter(hero -> "近战".equals(hero.getAttackRange()))
                .map(Hero::getHpStart)
                .filter(Objects::nonNull)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
        System.out.println("近战英雄HP初始值的加总为:" + sum);
    }
    

    • 通过最小列表收集器获取最小列表
    @Test
    public void t4() {
        // 通过最小列表收集器获取最小列表
        List<BigDecimal> minAttackGrowth = heroes.stream()
                .map(Hero::getAttackGrowth)
                .collect(new MinListCollector<>());
        System.out.println(minAttackGrowth);
        List<Hero> minHero = heroes.stream()
                .collect(new MinListCollector<>());
        System.out.println(minHero);
    }
    
    import java.util.*;
    import java.util.concurrent.atomic.AtomicReference;
    import java.util.function.BiConsumer;
    import java.util.function.BinaryOperator;
    import java.util.function.Function;
    import java.util.function.Supplier;
    import java.util.stream.Collector;
    import java.util.stream.Collectors;
    
    import static java.util.stream.Collector.Characteristics.*;
    
    /**
     * 最小列表收集器
     *
     * @author switch
     * @since 2020/8/18
     */
    public class MinListCollector<T extends Comparable<? super T>> implements Collector<T, List<T>, List<T>> {
        /**
         * 收集器的特性
         *
         * @see Characteristics
         */
        private final static Set<Characteristics> CHARACTERISTICS = Collections.unmodifiableSet(EnumSet.of(IDENTITY_FINISH));
        private final static int ZERO = 0;
    
        /**
         * 最小值
         */
        private final AtomicReference<T> min = new AtomicReference<>();
    
        @Override
        public Supplier<List<T>> supplier() {
            // supplier参数用于生成结果容器,容器类型为A
            return ArrayList::new;
        }
    
        @Override
        public BiConsumer<List<T>, T> accumulator() {
            // accumulator用于消费元素,也就是归纳元素,这里的T就是元素,它会将流中的元素一个一个与结果容器A发生操作
            return (list, element) -> {
                // 获取最小值
                T minValue = min.get();
                if (Objects.isNull(minValue)) {
                    // 第一次比较
                    list.add(element);
                    min.set(element);
                } else if (element.compareTo(minValue) < ZERO) {
                    // 发现更小的值
                    list.clear();
                    list.add(element);
                    min.compareAndSet(minValue, element);
                } else if (element.compareTo(minValue) == ZERO) {
                    // 与最小值相等
                    list.add(element);
                }
            };
        }
    
        @Override
        public BinaryOperator<List<T>> combiner() {
            // combiner用于两个两个合并并行执行的线程的执行结果,将其合并为一个最终结果A
            return (left, right) -> {
                // 最小值列表合并
                List<T> leftList = getMinList(left);
                List<T> rightList = getMinList(right);
                leftList.addAll(rightList);
                return leftList;
            };
        }
    
        private List<T> getMinList(List<T> list) {
            return list.stream()
                    .filter(element -> element.compareTo(min.get()) == ZERO)
                    .collect(Collectors.toList());
        }
    
        @Override
        public Function<List<T>, List<T>> finisher() {
            // finisher用于将之前整合完的结果R转换成为A
            return Function.identity();
        }
    
        @Override
        public Set<Characteristics> characteristics() {
            // characteristics表示当前Collector的特征值,这是个不可变Set
            return CHARACTERISTICS;
        }
    }
    
    

    优雅的空处理

    file

    import org.junit.Test;
    
    import java.util.Optional;
    
    /**
     * @author switch
     * @since 2020/8/18
     */
    public class OptionalTests {
        @Test
        public void t1() {
            // orElse
            System.out.println(Optional.ofNullable(null).orElse("张三"));
            System.out.println(Optional.ofNullable(null).orElseGet(() -> "李四"));
            System.out.println(Optional.ofNullable("王五").orElseThrow(NullPointerException::new));
        }
    
        @Test
        public void t2() {
            // isPresent
            Optional<String> name = Optional.ofNullable("张三");
            if (name.isPresent()) {
                System.out.println(name.get());
            }
        }
    
        @Test
        public void t3() {
            // map
            Optional<Integer> number = Optional.of("123456").map(Integer::valueOf);
            if (number.isPresent()) {
                System.out.println(number.get());
            }
        }
    
        @Test
        public void t4() {
            // flatMap
            Optional<Integer> number = Optional.of("123456").flatMap(s -> Optional.of(Integer.valueOf(s)));
            if (number.isPresent()) {
                System.out.println(number.get());
            }
        }
    
        @Test
        public void t5() {
            // 过滤
            String number = "123456";
            String filterNumber = Optional.of(number).filter(s -> !s.equals(number)).orElse("654321");
            System.out.println(filterNumber);
        }
    }
    
    

    新的并发工具类CompletableFuture

    file

    单机批处理多线程执行模型

    该模型适用于百万级量级的任务。超过千万数据,可以考虑分组,多机器并行执行。
    基本流程:

    1. 从数据库获取Id列表
    2. 拆分成n个子Id列表
    3. 通过子Id列表获取关联数据(注意:都需要提供批量查询接口)
    4. 映射到需要处理的Model(提交到CompletableFuture)->处理数据->收集成list)(java 8流式处理)
    5. 收集的list进行join操作
    6. 收集list
    模型

    模型原理:Stream+CompletableFuture+lambda

    简要解释:

    • CompletableFuture是java8提供的一个工具类,主要是用于异步处理流程编排的。
    • Stream是java8提供的一个集合流式处理工具类,主要用于数据的流水线处理。
    • lambda在java中是基于内部匿名类实现的,可以大幅减少重复代码。
    • 总结:在该模型中Stream用于集合流水线处理、CompletableFuture解决异步编排问题(非阻塞)、lambda简化代码。
    • 数据流动
    List<List<String>> -> 
    Stream<List<String>> -> 
    Stream<List<Model>> -> 
    Stream<CompletableFuture<List<Model>>> -> 
    Stream<CompletableFuture<List<映射类型>>> -> 
    List<CompletableFuture<Void>>
    
    案例
    • ThreadPoolUtil
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
    
    import java.util.concurrent.ThreadPoolExecutor;
    
    public final class ThreadPoolUtil {
        public static ThreadPoolTaskExecutor getDefaultExecutor(Integer poolSize, Integer maxPoolSize, Integer queueCapacity) {
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            executor.setAllowCoreThreadTimeOut(true);
            executor.setWaitForTasksToCompleteOnShutdown(true);
            executor.setCorePoolSize(poolSize);
            executor.setMaxPoolSize(maxPoolSize);
            executor.setQueueCapacity(queueCapacity);
            executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
            return executor;
        }
    }
    
    • ThreadPoolConfig
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
    
    @Configuration
    public class ThreadPoolConfig {
        /**
         * 计算规则:N(thread) = N(cpu) * U(cpu) * (1 + w/c)
         * N(thread):线程池大小
         * N(cpu):处理器核数
         * U(cpu):期望CPU利用率(该值应该介于0和1之间)
         * w/c:是等待时间与计算时间的比率,比如说IO操作即为等待时间,计算处理即为计算时间
         */
        private static final Integer TASK_POOL_SIZE = 50;
        private static final Integer TASK_MAX_POOL_SIZE = 100;
        private static final Integer TASK_QUEUE_CAPACITY = 1000;
    
        @Bean("taskExecutor")
        public ThreadPoolTaskExecutor taskExecutor() {
            return ThreadPoolUtil.getDefaultExecutor(TASK_POOL_SIZE, TASK_MAX_POOL_SIZE, TASK_QUEUE_CAPACITY);
        }
    }
    
    • #getFuturesStream
    public Stream<CompletableFuture<List<Model>>> getFuturesStream(List<List<String>> idSubLists) {
        return idSubLists.stream()
            .map(ids -> 
                CompletableFuture.supplyAsync(() -> modelService.listByIds(ids), taskExecutor)
            );
    }
    
    • #standardisation
    public void standardisation() {
        List<CompletableFuture<Void>> batchFutures = getFuturesStream(idSubLists)
                .map(future -> future.thenApply(this::listByNormalize))
                .map(future -> future.thenAccept(modelService::batchUpdateData))
                .collect(Collectors.toList());
        List<Void> results = batchFutures.stream()
                .map(CompletableFuture::join)
                .collect(Collectors.toList());
    }
    

    调整线程池的大小

    《Java并发编程实战》一书中,Brian Goetz和合著者们为线程池大小的优化提供了不少中肯的建议。这非常重要,如果线程池中线程的数量过多,最终它们会竞争稀缺的处理器和内存资源,浪费大量的时间在上下文切换上。反之,如果线程的数目过少,正如你的应用所面临的情况,处理器的一些核可能就无法充分利用。Brian Goetz建议,线程池大小与处理器的利用率之比可以使用下面的公式进行估算:
    Nthreads=NCPUUCPU(1+WC)N_{threads} = N_{CPU} * U_{CPU} * (1 + \frac{W}{C})

    其中:

    • NCPUN_{CPU}是处理器的核的数目,可以通过Runtime.getRuntime().availableProcessors()得到
    • UCPUU_{CPU}是期望的CPU利用率(该值应该介于0和1之间)
    • WC\frac{W}{C}是等待时间与计算时间的比率,比如说IO操作即为等待时间,计算处理即为计算时间

    并行——使用流还是CompletableFutures?

    对集合进行并行计算有两种方式:要么将其转化为并行流,利用map这样的操作开展工作,要么枚举出集合中的每一个元素,创建新的线程,在CompletableFuture内对其进行操作。后者提供了更多的灵活性,可以调整线程池的大小,而这能帮助确保整体的计算不会因为线程都在等待I/O而发生阻塞。

    使用这些API的建议如下:

    • 如果进行的是计算密集型的操作,并且没有I/O,那么推荐使用Stream接口,因为实现简单,同时效率也可能是最高的(如果所有的线程都是计算密集型的,那就没有必要创建比处理器核数更多的线程)。
    • 反之,如果并行的工作单元还涉及等待I/O的操作(包括网络连接等待),那么使用CompletableFuture灵活性更好,可以依据等待/计算,或者WC\frac{W}{C}的比率设定需要使用的线程数。这种情况不使用并行流的另一个原因是,处理流的流水线中如果发生I/O等待,流的延迟特性很难判断到底什么时候触发了等待。

    日期和时间API

    file

    使用指南:https://www.yuque.com/docs/share/ee5ef8a7-d261-4593-bd08-2a7a7d2c11ca?#(密码:gtag) 《时区工具类使用指南》

    项目地址

    GitHub:java8-fluent

    参考

    展开全文
  • Excel甘特图模板

    热门讨论 2012-12-04 18:34:41
    2.左右拖动滚动条可以调整甘特图显示的日期范围。 3.受Excel本身所限,显示的时间范围最多可以达到48周。 帮助: Q1: 怎样才能让任务2在任务1结束后启动? A:在任务2的开始时间处输入以下公式: =EndDate+1 ...
  • 当商品名称太多,按系统提供的菜单或查询方式不方便,怎样能简化缩短时间。 #22.在录各种单据,对商品名称的录入,本系统提供模糊查询录入方式。如需填入商品:“长虹彩电2919”时,可在“商品名称”处,填入“长虹...
  • word使用技巧大全

    热门讨论 2011-03-18 20:37:53
    ★在Word中插入当前的日期和时间 13 ★锁定插入的日期和时间 13 ★利用合并字符功能设置上下标 13 ★使用⑩以上的数字序号 14 ★使用格式刷重复复制格式 14 ★利用拖放的方式复制网页 14 ★利用不间断空格使两个单词...
  • delphi 开发经验技巧宝典源码

    热门讨论 2010-08-12 16:47:23
    第6章 日期和时间 121 0185 获得系统当前时间 122 0186 获得系统当前日期 122 0187 将日期时间格式化为指定格式 122 0188 计算两个日期之间相差的天数 123 0189 根据指定日期返回星期几 123 0190 将...
  • 第6章 日期和时间 121 0185 获得系统当前时间 122 0186 获得系统当前日期 122 0187 将日期时间格式化为指定格式 122 0188 计算两个日期之间相差的天数 123 0189 根据指定日期返回星期几 123 0190 将...
  • 第6章 日期和时间 121 0185 获得系统当前时间 122 0186 获得系统当前日期 122 0187 将日期时间格式化为指定格式 122 0188 计算两个日期之间相差的天数 123 0189 根据指定日期返回星期几 123 0190 将...
  • 第6章 日期和时间 121 0185 获得系统当前时间 122 0186 获得系统当前日期 122 0187 将日期时间格式化为指定格式 122 0188 计算两个日期之间相差的天数 123 0189 根据指定日期返回星期几 123 0190 将...
  • 第6章 日期和时间 121 0185 获得系统当前时间 122 0186 获得系统当前日期 122 0187 将日期时间格式化为指定格式 122 0188 计算两个日期之间相差的天数 123 0189 根据指定日期返回星期几 123 0190 将...
  • 第6章 日期和时间 121 0185 获得系统当前时间 122 0186 获得系统当前日期 122 0187 将日期时间格式化为指定格式 122 0188 计算两个日期之间相差的天数 123 0189 根据指定日期返回星期几 123 0190 将...
  • 6.5 获取用户输入的日期和时间 126 6.6 向用户显示信息 127 6.6.1 使用ProgressBar指示进度 128 6.6.2 使用SeekBar指示和调整进度 130 6.6.3 使用RatingBar指示和调整评分 130 6.6.4 使用Chronometer...
  • visio教程PDF

    热门讨论 2010-05-17 23:56:22
    第16章 调整大小、定位复制图形 16.1 使用Size&Position窗口 16.1.1 研究Size&Position窗口 16.1.2 一个Size&Position窗口的例子 16.1.3 改变Size&Position窗口位置 16.2 改变图形大小 ...
  • Visio 2000 技术大全

    2010-05-01 13:38:29
    第16章 调整大小、定位复制图形 16.1 使用Size&Position窗口 16.1.1 研究Size&Position窗口 16.1.2 一个Size&Position窗口的例子 16.1.3 改变Size&Position窗口位置 16.2 改变图形大小 ...
  • 看看已经出版的一些好书,许多都是关于“怎样构造编译器”的,还有一些是关于“怎样建立数据库”的。但是,没有一本书是关.. 查看前言 【序言】 Internet的爆炸式发展还在继续。五年前当这部书的第三版在写作时,...
  • 9.1 选择日期和时间 75 9.2 时钟 78 9.3 进度条 79 9.4 滑动选择 79 9.5 选项卡 80 9.5.1 构建 80 9.5.2 规则 80 9.5.3 使用 81 9.5.4 增强 83 9.5.5 IntentView 84 9.6 翻转 85 9.6.1 ...
  • 上架时间:2010-6-2 出版日期:2010 年6月 开本:16开 页码:1033 版次:1-1 所属分类:计算机 > 数据库 > Oracle 内容简介  本书针对大多数日常的oracle database 11g数据库管理任务,全面覆盖dba行业知识,并将...
  • dreamweaver上PHP网站开发相关插件

    热门讨论 2009-09-01 14:40:19
    把一张图片作为背景铺满整个浏览器,可随浏览大小的变化自动调整。 URL into layer.mxp 在你的网页里面插入一个层,并且在这个层里面导入另一个页面的URL。 Transition.mxp 设置网页背景转换效果 Save Password...
  • “在如今这个有太多数据太少时间的时代,本书非常专业地提供了内容丰富的数据透视表教程,让我们可以更高效地利用自己的数据和时间。”  ——德勒咨询公司高级经理,Kameron Yu  本书集中了数据透视表所有优秀的...
  • “在如今这个有太多数据太少时间的时代,本书非常专业地提供了内容丰富的数据透视表教程,让我们可以更高效地利用自己的数据和时间。”  ——德勒咨询公司高级经理,Kameron Yu  本书集中了数据透视表所有优秀的...
  • “在如今这个有太多数据太少时间的时代,本书非常专业地提供了内容丰富的数据透视表教程,让我们可以更高效地利用自己的数据和时间。”  ——德勒咨询公司高级经理,Kameron Yu  本书集中了数据透视表所有优秀的...
  • “在如今这个有太多数据太少时间的时代,本书非常专业地提供了内容丰富的数据透视表教程,让我们可以更高效地利用自己的数据和时间。”  ——德勒咨询公司高级经理,Kameron Yu  本书集中了数据透视表所有优秀的...
  • C#编程经验技巧宝典

    热门讨论 2008-06-01 08:59:33
    102 <br>0163 如何限制文本框密码输入长度 102 <br>0164 数据输入为空提示 103 <br>0165 如何设置文本框光标到末尾 103 <br>0166 输入法调整技巧 103 <br>0167 锁定文本框内的文本 103 ...
  • 5.2.1 编译时间和参数化 185 5.2.2 索引化 189 5.2.3 基数和开销估算 191 5.3 故障排查 192 5.3.1 诊断 192 5.3.2 控制 198 5.4 最佳实践 208 5.4.1 使用面向集合的编程模型 209 5.4.2 提供约束和...
  • 5.2.1 编译时间和参数化 185 5.2.2 索引化 189 5.2.3 基数和开销估算 191 5.3 故障排查 192 5.3.1 诊断 192 5.3.2 控制 198 5.4 最佳实践 208 5.4.1 使用面向集合的编程模型 209 5.4.2 提供约束和...
  • 出口退税管理:可以输入每票外销业务的实际退税金额退税日期,并有导入接口,可以 直接导入退税部门的退税数据 2.所有报表单证均可以预览时动态修改 ---在预览窗口中,鼠标左键双击页面,就可调出调整窗口用户可以...
  • 在本书第1版出版时隔4年后,Thomas Kyte及时了解了大家的这一迫切需求,根据他的实战经验以及人们最关心的问题对这本书做了全面补充和调整,以涵盖11g最受关注的多项特性。例如11g引入dbms_parallel_execute包来帮助...
  • [日期:2010-02-20] 来源:中国云计算 作者:龚传 [字体:大 中 小] 下列论文归类: 1、云计算设施管理 监测 2,34 负载均衡 33,35 数据管理 32 能耗管理 29 安全管理 25 2、云计算平台实例 虚拟机 27,31 存储平台 ...
  • PHP动态网站开发插件

    2013-06-18 22:47:24
    把一张图片作为背景铺满整个浏览器,可随浏览大小的变化自动调整。 URL into layer.mxp Download 点击下载 在你的网页里面插入一个层,并且在这个层里面导入另一个页面的URL。 Transition.mxp 设置网页背景转换效果...
  • 测试培训教材

    2014-04-01 12:10:48
    把“调用”的测试步骤调整到第一步 查看需求覆盖率 -- Linking Requiremnets to a Test 将需求链接到测试Cruise Booking 注:由于Cruise Booking的测试是由Cruise Booking的需求转化而成的,所以需求覆盖中...

空空如也

空空如也

1 2 3 4
收藏数 63
精华内容 25
关键字:

怎样调整时间和日期