精华内容
下载资源
问答
  • 高压油泵柱塞的油过程如图3所示,凸轮驱动柱塞上下运动,凸轮边缘曲线与角度的关系见附件1。柱塞向上运动时压缩柱塞腔内的燃油,当柱塞腔内的压力大于高压油管内的压力时,柱塞腔与高压油管连接的单向阀开启,燃油...

    亲身参加了这次数学建模,感觉那三天真的很急躁。指导老师不管我们,我和两队友自力更生、三个臭皮匠顶个诸葛亮,选择了A题。

     

    睡觉都是在椅子上睡的,虽然过的很艰苦,但结果总是美好的。由于时间问题,没有完整的做出第三问是最大的遗憾。

     

    这个中秋很难忘,嘿嘿。

     

    获奖结果出来了,省级三等,虽然有点小小的失望,但是还是很有意义的一次回忆。

     

    上题

                     2019高教社杯全国大学生数学建模竞赛题目

                                                        (请先阅读“全国大学生数学建模竞赛论文格式规范”)


                                            A   高压油管的压力控制

    燃油进入和喷出高压油管是许多燃油发动机工作的基础,图1给出了某高压燃油系统的工作原理,燃油经过高压油泵从A处进入高压油管,再由喷口B喷出。燃油进入和喷出的间歇性工作过程会导致高压油管内压力的变化,使得所喷出的燃油量出现偏差,从而影响发动机的工作效率。

    1 高压油管示意图

    问题1. 某型号高压油管的内腔长度为500mm,内直径为10mm,供油入口A处小孔的直径为1.4mm,通过单向阀开关控制供油时间的长短,单向阀每打开一次后就要关闭10ms。喷油器每秒工作10次,每次工作时喷油时间为2.4ms,喷油器工作时从喷油嘴B处向外喷油的速率如图2所示。高压油泵在入口A处提供的压力恒为160 MPa,高压油管内的初始压力为100 MPa。如果要将高压油管内的压力尽可能稳定在100 MPa左右,如何设置单向阀每次开启的时长?如果要将高压油管内的压力从100 MPa增加到150 MPa,且分别经过约2 s5 s10 s的调整过程后稳定在150 MPa,单向阀开启的时长应如何调整?

    2 喷油速率示意图

    问题2. 在实际工作过程中,高压油管A处的燃油来自高压油泵的柱塞腔出口,喷油由喷油嘴的针阀控制。高压油泵柱塞的压油过程如图3所示,凸轮驱动柱塞上下运动,凸轮边缘曲线与角度的关系见附件1。柱塞向上运动时压缩柱塞腔内的燃油,当柱塞腔内的压力大于高压油管内的压力时,柱塞腔与高压油管连接的单向阀开启,燃油进入高压油管内。柱塞腔内直径为5mm,柱塞运动到上止点位置时,柱塞腔残余容积为20mm3。柱塞运动到下止点时,低压燃油会充满柱塞腔(包括残余容积),低压燃油的压力为0.5 MPa。喷油器喷嘴结构如图4所示,针阀直径为2.5mm、密封座是半角为的圆锥,最下端喷孔的直径为1.4mm。针阀升程为0时,针阀关闭;针阀升程大于0时,针阀开启,燃油向喷孔流动,通过喷孔喷出。在一个喷油周期内针阀升程与时间的关系由附件2给出。在问题1中给出的喷油器工作次数、高压油管尺寸和初始压力下,确定凸轮的角速度,使得高压油管内的压力尽量稳定在100 MPa左右。

    某型号高压油管的内腔长度为500mm,内直径为10mm,高压油管内的初始压力为100 MPa。喷油器每秒工作10

     

    3 高压油管实际工作过程示意图

    4 喷油器喷嘴放大后的示意图

    问题3. 在问题2的基础上,再增加一个喷油嘴,每个喷嘴喷油规律相同,喷油和供油策略应如何调整?为了更有效地控制高压油管的压力,现计划在D处安装一个单向减压阀(图5)。单向减压阀出口为直径为1.4mm的圆,打开后高压油管内的燃油可以在压力下回流到外部低压油路中,从而使得高压油管内燃油的压力减小。请给出高压油泵和减压阀的控制方案。

    5 具有减压阀和两个喷油嘴时高压油管示意图

     

    1. 燃油的压力变化量与密度变化量成正比,比例系数为,其中ρ为燃油的密度,当压力为100 MPa时,燃油的密度为0.850 mg/mm3E为弹性模量,其与压力的关系见附件3

     

    2. 进出高压油管的流量为Q=CA2ΔPρ,其中Q为单位时间流过小孔的燃油量(mm3/ms),C=0.85为流量系数,A为小孔的面积(mm2),ΔP为小孔两边的压力差(MPa),ρ为高压侧燃油的密度(mg/mm3)。

     

    附件1:凸轮边缘曲线

    附件2:针阀运动曲线

    附件3:弹性模量与压力的关系

     

     

    我和队友努力的优秀论文链接:

    链接:https://pan.baidu.com/s/13OsvWAomWgi4kG_VOhgcXg
    链接已过期

     

    嘿嘿嘿,我们写的当然是最优秀的啦!(疯狂自夸)

    展开全文
  • 这同时也增加了智能发射信号的复杂性,向终产品设计提出了新的挑战。系统设计人员面临着一种直接挑战,也就是既要融合额外的智能、功能和诊断能力,同时又要开发出能够在4-20mA的环路所提供的有限功率范围内有效...
  • 当运算放大的输入电压超过额定输入电压范围,或者在极端情况下,超过放大的电源电压时,放大可能发生故障甚至受损。... 精密放大常常是传感器测量信号中的个器件,因而容易受到过故障的影响。选择精密放大
  • 移相是移相干涉仪中的重要部件,电式移相由于分辨力高、响应快、控制容易而被大量采用。但压电陶瓷的非线性误差与位移量小,一直影响其应用范围的扩大。针对该问题,从电式移相机构与扩展方法入手,设计了具有...
  • 这个例子主要是演示了JNI在实际开发中的开发流程。在实际开发中,android工程师只需要从C/C++工程师那里 拿到底层的一些逻辑代码,整合到jni目录下的.c文件即可 代码的链接地址:...

    这个例子主要是演示了JNI在实际开发中的开发流程。在实际开发中,android工程师只需要从C/C++工程师那里

    拿到底层的一些逻辑代码,整合到jni目录下的.c文件即可


    代码的链接地址:http://download.csdn.net/detail/caihongshijie6/6651355

    一、原理图



    二、效果图




    三、代码实现

    1、MyView

    1. package com.njupt.monitor;  
    2.   
    3. import android.content.Context;  
    4. import android.graphics.Canvas;  
    5. import android.graphics.Paint;  
    6. import android.view.View;  
    7.   
    8. public class MyView extends View {  
    9.   
    10.     private int bottom;  
    11.     private Paint paint;  
    12.       
    13.     public MyView(Context context,int bottom,int color) {  
    14.         super(context);  
    15.           
    16.         this.bottom = bottom;  
    17.         paint = new Paint();  
    18.         paint.setColor(color);  
    19.         paint.setStrokeWidth(10);  
    20.     }  
    21.       
    22.     /** 
    23.      * android下所有的view控件的显示其实都是通过onDraw() 
    24.      * canvas 代表的是屏幕的画布... 
    25.      */  
    26.     @Override  
    27.     protected void onDraw(Canvas canvas) {  
    28.           
    29.         //bottom值 需要根据锅炉的压力 动态确定  
    30.         canvas.drawRect(2020,30,bottom,paint);  
    31.         super.onDraw(canvas);  
    32.     }  
    33.   
    34.       
    35. }  


    2、MainActivity

    1. package com.njupt.monitor;  
    2.   
    3. import java.util.Timer;  
    4. import java.util.TimerTask;  
    5.   
    6. import android.os.Bundle;  
    7. import android.os.Handler;  
    8. import android.os.Message;  
    9. import android.app.Activity;  
    10. import android.graphics.Color;  
    11. import android.view.Menu;  
    12. import android.widget.TextView;  
    13.   
    14. public class MainActivity extends Activity {  
    15.   
    16.     public native int getPressure();  
    17.     private Timer timer;  
    18.     private TimerTask task;  
    19.     private Handler handler = new Handler(){//消息机制的模板代码。。。在主线程中更新界面  
    20.         public void handleMessage(android.os.Message msg) {  
    21.             int pressure = (Integer) msg.obj;  
    22.             int color = getColor(pressure);  
    23.             if(color == 404){  
    24.                 TextView tv = new TextView(MainActivity.this);  
    25.                 tv.setTextColor(Color.RED);  
    26.                 tv.setTextSize(30);  
    27.                 tv.setText("锅炉快爆炸了...快跑吧~~~~~");  
    28.                   
    29.                   
    30.                 setContentView(tv);  
    31.                 timer.cancel();  
    32.                   
    33.                 return ;  
    34.             }  
    35.               
    36.               
    37.             MyView myView = new MyView(MainActivity.this, pressure, color);  
    38.             setContentView(myView);//****这里需要注意,这时不再是通过.xml文件来画界面  
    39.             super.handleMessage(msg);  
    40.         };  
    41.     };  
    42.       
    43.       
    44.     static{  
    45.         System.loadLibrary("Hello");  
    46.     }  
    47.       
    48.       
    49.     @Override  
    50.     protected void onCreate(Bundle savedInstanceState) {  
    51.         super.onCreate(savedInstanceState);  
    52.         //获取锅炉压力 ,根据压力显示不同的内容  
    53.         timer = new Timer();  
    54.         task = new TimerTask() {  
    55.               
    56.             @Override  
    57.             public void run() {  
    58.                 int pressure = getPressure()%300;  
    59.                 System.out.println("压力: " + pressure);  
    60.                   
    61.                 //把压力显示到UI界面上  
    62.                 Message msg = new Message();  
    63.                 msg.obj = pressure;  
    64.                 handler.sendMessage(msg);  
    65.             }  
    66.         };  
    67.           
    68.         timer.schedule(task, 1000,2000);  
    69.     }  
    70.   
    71.     /**  
    72.      * 根据锅炉压力,获取应该显示的颜色  
    73.      * @param pressure  
    74.      * @return  
    75.      */  
    76.     public int getColor(int pressure){  
    77.         if(pressure < 100){  
    78.             return Color.GREEN;  
    79.         }else if(pressure < 200){  
    80.             return Color.YELLOW;  
    81.         }else if(pressure < 260){  
    82.             return Color.RED;  
    83.         }else{  
    84.             return 404;  
    85.         }  
    86.     }  
    87.     @Override  
    88.     public boolean onCreateOptionsMenu(Menu menu) {  
    89.         // Inflate the menu; this adds items to the action bar if it is present.  
    90.         getMenuInflater().inflate(R.menu.main, menu);  
    91.         return true;  
    92.     }  
    93.   
    94. }  


    3、Hello.c

    1. #include <stdio.h>  
    2. #include <jni.h>  
    3. #include <stdlib.h>  
    4. #include "com_njupt_monitor_MainActivity.h"  
    5.   
    6. #include <android/log.h>//include  D:\android-ndk-r7b\platforms\android-8\arch-arm\usr\include\android下的log.h这个目录  
    7. #define LOG_TAG "System.out"  
    8. #define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)  
    9. #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)  
    10.   
    11. /** 
    12.  * getpressure()的代码由C/C++工程师提供 
    13.  */  
    14. int getpressure(){  
    15.   // c语言中的随机数  
    16.     return rand();  
    17. }  
    18.   
    19. JNIEXPORT jint JNICALL Java_com_njupt_monitor_MainActivity_getPressure  
    20.   (JNIEnv * env, jobject obj){  
    21.     return getpressure();  
    22. }  


    4、Android.mk

    1. LOCAL_PATH := $(call my-dir)  
    2.   
    3.   include $(CLEAR_VARS)  
    4.   
    5.   LOCAL_MODULE    := Hello     
    6.   LOCAL_SRC_FILES := Hello.c  
    7.   LOCAL_LDLIBS += -llog  
    8.     
    9.   include $(BUILD_SHARED_LIBRARY)  


    5、在此过程中需要用到的命令请参考上一篇博客。。。。


    展开全文
  • 当运算放大的输入电压超过额定输入电压范围,或者在极端情况下,超过放大的电源电压时,放大可能发生故障甚至受损。... 精密放大常常是传感器测量信号中的第一个器件,因而最容易受到过故障的影响。选
  • 顺源新推出压力信号变送IC欢迎使用Markdown编辑新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、...

    顺源新研制的GRS系列低成本小体积宽电压输入隔离高压模块电源,是一款业界领先高隔离稳压型DC-DC高电压转换器,可在宽范围波动的不稳定电压输入环境中运行,通过模块的内部调整电路可以生成隔离稳压的直流高电压输出。GRS系列新产品采用SIP 7Pin(单排7脚)超小体积模块化设计,低成本集成技术方案使产品具有较高的DC/DC转换效率,产品内部宽爬电距离及新隔离材料技术方案设计,使这款高压模块电源具备输入与输出6000VDC高隔离特性及自恢复过载短路保护稳压输出功能。模块电源采用的高隔离技术方案设计,能有效隔离来自一次端设备带来的共模干扰对控制系统影响,也可以有效隔离一次端与二次端的地线环流或系统中地线端高压电势差对设备和人员的安全影响。产品广泛用于医疗设备的血液分析仪器、实验仪器、超声仪器、石油化工、通信设施等领域中,良好的直流高电压输出特性及高耐压隔离设计技术可以解决用户大部分应用难题。

    顺源新研制的GRS系列低成本超小体积宽电压输入隔离高压模块电源产品可用在以下仪器仪表设备中:加速器、3D打印、X光射线管、X 射线分析、能量色散、波长色散、X射线荧光分析仪、化学分析电子光谱仪、自动测试设备、电容充放电、色谱仪 、质谱仪、二氧化碳激光器、阴极射线管、显示器、飞行模拟实验 、探测器、射线、微通道板、光电倍增管、绝缘击穿试验、电子束曝光、毛细管凝胶电泳 、蛋白质提取、DNA测序、静电吸盘、复印机、涂层、静电植绒、静电除尘器、油烟净化、空气净化、静电喷涂(喷塑、喷漆)、图象增强器、工业彩印、行李检查、食品检查、放射、PCB检测、无损检测、测厚仪、试管、光罩修补用聚焦离子束显微镜、离子注入 、碎石、医疗成像PET, MRI 、医学肿瘤、X射线医疗CT、骨密度测试、胸透、磁控管、速调管、中子发生器、核检测仪器、仪表、海洋供电设备、电子显微镜 、医疗血液分析、PM2.5环境监测、光谱仪、农业除雾除露增产、压力测试、表面分析、水净化设备……。目前顺源科技公司正在加大力度不断完善隔离型高压电源产品线,以满足日益增长的医疗、工业、科研行业需求。

    顺源科技以“客户的成功,我们的价值”为经营理念,按照ISO 2012质量技术管理体系的要求,坚持开展改进、改善、创新工作,不断提高产品质量、降低生产成本、拓展产品应用范围、推陈出新研发新品。以适应当前电子信息技术前日新月异发展的形势及满足客户产品研发创新和升级换代的需求。

    顺源科技在DC-DC模块电源、隔离放大器变送器、数据采集器、二线制变送表产品上有18年的设计、生产和应用经验。公司专业的工程师团队在更深入的理解和设计知识方面,相对于同行业竞争者有绝对的优势。为需要解决信号干扰、信号负载匹配、地线隔离、电源转换、数据采集、信号隔离、AD/DA转换等用户提供了大量解决方案。顺源的每个产品所用器件原材料都超出所预定的规格来设计生产出高稳定性的产品,这些保证了产品在各种恶劣环境运行过程中展现良好的性能。

    GRS系列产品详细技术资料
    http://www.szsunyuan.net/index.php?m=content&c=index&a=show&catid=65&id=190

    其他DC高压电源模块产品资料参考
    1、血球分析仪/血液分析仪专用DC/DC模块电源:GRB系列
    http://www.szsunyuan.net/index.php?m=content&c=index&a=show&catid=65&id=15

    2、双回路6KV高隔离高压模块电源:GRE系列
    http://www.szsunyuan.net/index.php?m=content&c=index&a=show&catid=65&id=186

    3、医疗设备6KV高隔离直流高压电源模块:GRF系列
    http://www.szsunyuan.net/index.php?m=content&c=index&a=show&catid=65&id=185

    4、10KV高隔离抗静电DC-DC模块电源:WHB 系列
    http://www.szsunyuan.net/index.php?m=content&c=index&a=show&catid=65&id=176

    5、低成本6KV高隔离高压输出模块电源:GRC系列
    http://www.szsunyuan.net/index.php?m=content&c=index&a=show&catid=65&id=188

    在这里插入图片描述

    展开全文
  • LVDS 是一种低压、差分信号传输方案,主要用于高速数据传输。...这种标准只对适合于 LVDS 应用的驱动和接收机电气特性进行了规定。因此,它只是一种电气标准,常被一些更高级的协议标准当作其接口或物理层。
  • 目前我国国内现有的矿用大功率(855 k W以上)刮板输送机的驱动系统大部分采用电动机、减速箱、液粘离合组合或电动机、减速箱、CST可控液力偶合组合进行启动,使用一段时间后,随着机械磨损的增加,维修量及维修费用...
  • 时,ADC提供最佳性能。但在许多应用中,最大可用信号 与额定电压不同,可能需要调整。用于满足这一要求的器件之 一是可变增益放大(VGA)。了解VGA如何影响ADC的性能, 将有助于优化整个信号的性能。 本文...
  • 电式移相及其在全息干涉计量术中的应用,让我们共同了解一下。1、电式移相移相是移相干涉仪中非常重要的部件,电式移相由于分辨率高、响应速度快、易于控制、性能稳定,因此被广泛使用。但压电陶瓷也...
  • Micrel公司新推出的2A低压降(LDO)稳压MIC68200,专门适用于如FPGA或ASIC核电,需要高的启动电流但具有低的操作电流的功率应用,包括工业、电信和高端消费应用。 MIC68200具有很宽的输入电压范围1.65V至5.5V,...
  • 当今许多应用中的恶劣环境要求集成电路能承受高电压和高电流。 系统设计师需要选择高性能IC,以便用于...如果在信号接口传感器及真实信号前方的运算放大输入端,意外施加了大信号或静电放电(ESD),结果会怎样...
  • 文章目录一、map 映射: list.map(fun)二、高阶函数的使用三、集合的平:list.flatMap(fun)四、集合的过滤: list.filter(fun)五、简化:`list.reduceLeft(fun)` `list.reduceRight(fun)` `list.reduce(fun)`四、...

    一、map 映射: list.map(fun)

    /**
     * foreach 的作用: 遍历数组、集合
     * map 的作用: 调整数据类型, 它返回的集合长度不会增加也不会减少
     */
    def main(args: Array[String]): Unit = {
       val list1 = List(1,2,3,4,5,6,7)
       val list2: List[Int] = list1.map(x =>  (x * 2))
       println(s"list2: ${list2.mkString(", ")}")
    }
    

    先看一个实际需求:将 List(3,5,7,9) 中所有的元素都 * 2,将结果放到一个新的集合中并返回

    /**
     * 将 List(3,5,7) 中所有的元素都 * 2, 将其结果放到一个新的集合中返回
     */
    def main(args: Array[String]): Unit = {
        def multiple(n: Int): Int = {
            println("multiple 被调用~")
            2 * n
        }
    
        val list1 = List(3,5,7,9)
        /**
          * 说明 list.map(multiple) 做了什么
          *
          * 1. 将 list 这个集合的元素 依次遍历
          * 2. 将各个元素传递给 multiple 函数 => 新 Int
          * 3. 将得到的新 Int, 放入到一个新的集合并返回
          * 4. 因此 multiple 函数调用了 3次
          */
        val list2: List[Int] = list1.map(multiple)
        println(list2) // 9, 25, 49
    }
    

    map映射深刻理解-模拟实现

    package com.kino.scala.day04.work.high
    
    /**
      * @author kino
      * @date 2019/9/8 20:58
      * @version 1.0.0
      */
    object MapOperateDemo2 {
        /**
          * 将 List(3,5,7,9)中的所有元素都 * 2, 并将结果放到一个新的集合中返回
          */
        def main(args: Array[String]): Unit = {
            def multiple(n: Int): Int = {
                println("multiple 被调用~")
                2 * n
            }
    
            val list1 = List(3,5,7,9)
            /**
              * 说明 list.map(multiple) 做了什么
              *
              * 1. 将 list 这个集合的元素 依次遍历
              * 2. 将各个元素传递给 multiple 函数 => 新 Int
              * 3. 将得到的新 Int, 放入到一个新的集合并返回
              * 4. 因此 multiple 函数调用了 3次
              */
            val list2: List[Int] = list1.map(multiple)
            println(list2) // 9, 25, 49
    
            // 深刻理解 map 映射函数的机制-模拟实现
            val myList = MyList()
            val myList2: List[Int] = myList.map(multiple)
            println(s"myList2: ${myList2}")
    
        }
    }
    
    class MyList {
        val list1 = List(3, 5, 7, 9)
        //新的集合
        val list2: List[Int] = List[Int]()
    
        def map(f: Int => Int): List[Int] ={
            for (elem <- this.list1) {
                //过滤, 扁平化
                list2 :+ f(elem)
            }
            list2
        }
    }
    
    object MyList {
        def apply(): MyList = new MyList()
    }
    

    二、高阶函数的使用

    对于一个函数来说,能接受函数或者返回函数,就称之为高阶函数
    两个实例:

    def main(args: Array[String]): Unit = {
    
       def myPrint(): Unit = {
            println("hello, world")
        }
    
        //在 scala中, 可以把一个函数直接赋给一个变量, 但是不执行函数
        val f1 = myPrint _
        f1() //执行
    
        //1. test 就是一个高阶函数
        //2. f: Double => Double 表示一个函数, 该函数可以接受一个 Double, 返回一个 Double
        //3. n1: Double 普通参数
        //4. f(n1) 在 test 函数中, 指定 你传入进来的函数
        def test(f: Double => Double, n1: Double) = {
            f(n1)
        }
    
        //普通的函数, 可以接受一个 Double, 返回 Double
        def sum2(d: Double): Double = {
            println("sum2 被调用")
            d + d
        }
    
        //使用高阶函数
        val res = test(sum2 _, 3.5)
        println(s"res ${res}")
    }
    
    def main(args: Array[String]): Unit = {
        test2(sayOK)
    }
    
    //test2 是一个 高阶函数, 可以接受一个 没有输入, 返回为 Unit 的函数
    def test2(f:() => Unit) ={
        f()
    }
    
    def sayOK() = {
        println("sayOKKK...")
    }
    
    def sub(n1: Int): Unit = {
    
    }
    

    三、集合的压平:list.flatMap(fun)

    说明:效果就是将集合中的每个元素的子元素映射到某个函数并返回新的集合

    /**
      * 扁平化说明:
      * flatMap: flat 即压扁, 压平, 扁平化, 效果就是将集合中的每个元素的子元素映射到某个函数并返回新的集合
      */
    def main(args: Array[String]): Unit = {
        val names = List("Alice", "Bon", "Nick")
    
        //需求是将 List 集合中的所有元素, 进行扁平化的操作, 即把所有的元素打散
        val names2: Any = names.flatMap(upper)
        println(s"names2: ${names2}")
    
        val list1 = List("hello world", "kino hello", "hello hello hello")
        //val list2: List[List[String]] = list1.map(x => x.split(" ").toList)
        val list2: List[String] = list1.flatMap(x => x.split(" "))
        println(s"list2: ${list2}")
    }
    
    def upper(s: String): String = {
        s.toUpperCase()
    }
    

    运行结果:

    names2: List(A, L, I, C, E, B, O, N, N, I, C, K)
    list2: List(hello, world, kino, hello, hello, hello, hello)
    

    示例二:

    /**
      * 将 val names = List("Alice", "Bon", "Nick") 中所有的单词, 全部转为大写字母, 并返回新的 List
      */
    def main(args: Array[String]): Unit = {
        val names = List("Alice", "Bon", "Nick")
        val list1: List[String] = names.map(x => x.toUpperCase)
        println(s"list1: ${list1}")
    
        val list2: List[String] = names.map(upperCase)
        println(s"list2: ${list2}")
    }
    
    def upperCase(s: String): String = {
        s.toUpperCase
    }
    

    运行结果:

    list1: List(ALICE, BON, NICK)
    list2: List(ALICE, BON, NICK)
    

    四、集合的过滤: list.filter(fun)

    说明: 将符合要求的数据(筛选)放置到新的集合中

    /**
     * filter -> 元素的过滤: 将符合要求的数据(筛选)放置到新的集合中
     */
    def main(args: Array[String]): Unit = {
        //将 List("Alice", "Bob", "Nick") 集合中的首字母为 'A' 的筛选到新的集合
        val names = List("Alice", "Bob", "Nick")
        val names2: Any = names.filter(x => x.startsWith("A"))
        println(s"names2: ${names2}")
    
        /**
          * 将 List() 中, Int 类型的字符过滤出来并且 + 1
          */
        val list1 = List(1, 2, 3, "2l1l", 102.1, 'A', 40)
        val list2: List[Any] = list1
                                .filter(_.isInstanceOf[Int])
                                .map(_.asInstanceOf[Int])
                                .map(_ + 1)
        println(s"list2: ${list2}")
    }
    

    运行结果:

    names2: List(Alice)
    list2: List(2, 3, 4, 41)
    

    五、简化:list.reduceLeft(fun) list.reduceRight(fun) list.reduce(fun)

    两片代码段示例:

    /**
      * 简化:
      * List(1,20,30,4,5) 求 list 的和
      */
    def main(args: Array[String]): Unit = {
        //使用简化的方式来计算 list 集合的和
        val list1 = List(1,20,30,4,5)
        val res = list1.reduceLeft(sum) //reduce/reduceLeft/reduceRight
    
        /*
        ① (1 + 20)
        ② (1 + 20) + 30
        ③ ((1 + 20) + 30) + 4
        ④ (((1 + 20) + 30) + 4) + 5 = 60
         */
    
        println(s"res: ${res}")
    }
    
    def sum(n1: Int, n2: Int): Int = {
        println("sum 被调用~~~")
        n1 + n2
    }
    

    运行结果:

    sum 被调用~~~
    sum 被调用~~~
    sum 被调用~~~
    sum 被调用~~~
    res: 60
    
    def main(args: Array[String]): Unit = {
       val list = List(1,2,3,4,5)
    
        def minus(n1: Int, n2: Int): Int = {
            n1 - n2
        }
    
        // ((((1-2)-3)-4)-5
        println(s"reduceLeft: ${list.reduceLeft(minus)}") // -13
        // 1-(2-(3-((4-5))))
        println(s"reduceRight: ${list.reduceRight(minus)}") // 3
        //reduce 等价于 reduceLeft
        println(s"reduce: ${list.reduce(minus)}") // -13
    
    }
    
    def min(n1: Int, n2: Int): Int = {
        if(n1 > n2) n2 else n1
    }
    

    运行结果:

    reduceLeft: -13
    reduceRight: 3
    reduce: -13
    

    六、折叠: list.foldLeft(fun) 等价 /: list.LeftRight(fun) 等价 :\

    /**
     * 折叠
     */
    def main(args: Array[String]): Unit = {
        val list = List(1,2,3,4)
    
        def minus(n1: Int, n2: Int): Int = {
            n1 -n2
        }
    
        //说明
        //1. 折叠的理解和简化的运行机制几乎一样
        //理解 list.foldLeft(5)(minus) 理解成 list(5,1,2,3,4) list.reduceLeft(minus)
    
        //步骤 (5-1)
        //步骤 ((5-1) - 2
        //步骤 (((5-1) - 2) - 3
        //步骤 ((((5-1) - 2) - 3) -4
        println(list.foldLeft(5)(minus)) // 函数的柯里化 -> -5
    
        //和Left 对比, 就是反着来
        //步骤 (4 - 5)
        //步骤 (3 - (4 -5))
        //步骤 (2 - (3 - (4 - 5)))
        //步骤 1 - (2 - (3 - (4 - 5)))) = 3
        println(list.foldRight(5)(minus)) // 函数的柯里化 -> 3
    
        //foldLeft 和 LeftRight 缩写方法分别是: /: 和 :\
        val list2 = List(1,9)
    
        println((1 /: list2) (minus)) //=> list2.foldLeft(1)(minus) -> -9
        println((100 /: list2) (minus)) //=> list2.foldLeft(100)(minus) -> 90
        println((list2 :\ 10) (minus)) //=> list2.foldLeft(1)(minus) -> 2
    
    }
    

    运行结果:

    -5
    3
    -9
    90
    2
    

    七、 扫描: list.scanLeft(fun) scanRight(fun)

    说明:对某个集合的所有元素做 fold 操作, 但是会把产生的所有终检结果放置于一个集合中保存

    /**
      * 扫描:
      *     对某个集合的所有元素做 fold 操作, 但是会把产生的所有终检结果放置于一个集合中保存
      */
    def main(args: Array[String]): Unit = {
        //普通函数
        def minus(n1: Int, n2: Int): Int = {
            n1 - n2
        }
    
        // 5 (1,2,3,4,5) => (5,4,2,-1,-5,-10)
        //步骤 -> 5 = 5
        //步骤 -> 5 - 1 = 4
        //步骤 -> 4 - 2 = 2
        //步骤 -> 2 - 3 = -1
        //步骤 -> ....
        println((1 to 5).scanLeft(5)(minus)) // -> Vector(5, 4, 2, -1, -5, -10)
    
        //普通函数
        def add(n1: Int, n2: Int): Int = {
            n1 + n2
        }
    
        //(1,2,3,4,5) 5 => (20, 19, 17, 14, 10, 5)
        println((1 to 5).scanRight(5)(add)) // -> Vector(20, 19, 17, 14, 10, 5)
    }
    

    运行结果:

    Vector(5, 4, 2, -1, -5, -10)
    Vector(20, 19, 17, 14, 10, 5)
    

    八、拉链(合并): list1.zip(list2) list1.zipAll(list2, n1, n2) list.zipWithIndex list.unzip

    说明:拉链的本质就是两个集合的合并操作, 合并后, 每个元素是一个 对偶元组(二维元组)

    /**
      * 拉链: 拉链的本质就是两个集合的合并操作, 合并后, 每个元素是一个 对偶元组(二维元组)
      *
      * 1. 如果两个集合的个数不对应, 会造成数据丢失
      * 2. 集合不限于 List, 也可以是其他的集合, 例如: Array
      * 3. 如果要取出合并后的各个对偶元组的数据, 可以遍历
      */
    def main(args: Array[String]): Unit = {
        val list1 = List(30, 50, 70, 60, 10, 20, 100, 200)
        val list2 = List(3, 5, 7, 6, 1, 2)
    
        //Zip 将来得到的集合长度, 以少的为主
        val list3: List[(Int, Int)] = list1.zip(list2)
        println(s"list3: ${list3}") // List((30,3), (50,5), (70,7), (60,6), (10,1), (20,2))
    
        //以多的为主
        val list4: List[(Int, Int)] = list1.zipAll(list2, -1, -2)
        println(s"list4: ${list4}") // List((30,3), (50,5), (70,7), (60,6), (10,1), (20,2), (100,-2), (200,-2))
    
        //元素和下标进行拉链
        val list5: List[(Int, Int)] = list1.zipWithIndex
        println(s"list5: ${list5}") // List((30,0), (50,1), (70,2), (60,3), (10,4), (20,5), (100,6), (200,7))
    
        //取下标为整数的集合数
        val list6: List[Int] = list5.filter(_._2 % 2 == 1).map(_._1)
        println(list6)
    
        //把拉链拉开 -> 分解为 元组, 包含两个集合
        val unzip: (List[Int], List[Int]) = list5.unzip
        println(s"unzip: ${unzip}")
    }
    

    运行结果:

    list3: List((30,3), (50,5), (70,7), (60,6), (10,1), (20,2))
    list4: List((30,3), (50,5), (70,7), (60,6), (10,1), (20,2), (100,-2), (200,-2))
    list5: List((30,0), (50,1), (70,2), (60,3), (10,4), (20,5), (100,6), (200,7))
    List(50, 60, 20, 200)
    unzip: (List(30, 50, 70, 60, 10, 20, 100, 200),List(0, 1, 2, 3, 4, 5, 6, 7))
    

    九、迭代器

    通过 iterate 方法从集合获得一个迭代器,该迭代器仅能进行一次遍历

    /**
      * 迭代器:
      *     通过 iterate 方法从集合获得一个迭代器,
      *     通过 while 循环或 for 表达式对集合进行遍历
      */
    def main(args: Array[String]): Unit = {
        val iterator: Iterator[Int] = List(1,2,3,4,5,6).iterator
        println("--------------遍历方式一: while---------------")
        while (iterator.hasNext) {
            println(s"while遍历: ${iterator.next()}")
        }
        val iterator1: Iterator[Int] = List(1,2,3,4,5,6).iterator
        println("--------------遍历方式二: for---------------")
        for (elem <- iterator1) {
            println(s"for遍历: ${elem}")
        }
        val iterator2: Iterator[Int] = List(1,2,3,4,5,6).iterator
        println("--------------遍历方式三: foreach---------------")
        iterator2.foreach(println(_))
    }
    

    运行结果

    --------------遍历方式一: while---------------
    while遍历: 1
    while遍历: 2
    while遍历: 3
    while遍历: 4
    while遍历: 5
    while遍历: 6
    --------------遍历方式二: for---------------
    for遍历: 1
    for遍历: 2
    for遍历: 3
    for遍历: 4
    for遍历: 5
    for遍历: 6
    --------------遍历方式三: foreach---------------
    1
    2
    3
    4
    5
    6
    

    十、分组:list.group(fun)

    说明:根据条件, 对 集合、数组 的数据进行分组(按条件归纳成多个Map)

    /**
     * group: 根据条件, 对 集合、数组 的数据进行分组(按条件归纳成多个Map)
     */
    def main(args: Array[String]): Unit = {
        val list1: ListBuffer[Int] = ListBuffer(30, 50, 7, 6, 1, 20)
        val map: Map[Boolean, ListBuffer[Int]] = list1.groupBy(x => x % 2 == 1)
        println(s"map: ${map}")
    
        //worldCount 案例
        val list2: List[String] = List("hello world", "hello hello", "kino kino hello")
        val map2: Map[String, Int] = list2.flatMap(_.split(" ")).groupBy(x => x).map(kv => (kv._1, kv._2.length))
        println(s"map2: ${map2}")
    
        val list3: List[(String, Int)] = List("hello" -> 2, "hello" -> 3, "kino" -> 4)
        val groupMap: Map[String, List[(String, Int)]] = list3.groupBy(_._1)
        val temp1: Map[String, Int] = groupMap.map(kv => {
            val word = kv._1
            word -> kv._2.map(_._2).sum
        })
        println(temp1)
    }
    

    运行结果:

    map: Map(false -> ListBuffer(30, 50, 6, 20), true -> ListBuffer(7, 1))
    map2: Map(world -> 1, kino -> 2, hello -> 4)
    Map(kino -> 4, hello -> 5)
    
    展开全文
  • 由于电子器件的小型化,分布式计算在微处理上得到了迅速的发展。图形处理单元(GPU)的出现以及由此产生的超集成基础设施就是证明。 现在,IT部门正在将传统标准化服务器的成本效益与进入市场的创新产品与边际...
  • 链条的调整实际的操作并不难,但需要注意一些细节,调整时左右的刻度一定要一致,而调整好以后,先需要锁紧后柱螺帽,然后再依次锁紧紧链器,这样链条的松紧度就不会随着紧链器而发生变化。链条的清洗操作起来...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 491
精华内容 196
关键字:

压链器