精华内容
参与话题
问答
  • 这几天在项目里面碰到了一个很恼火的问题,是关于函数的传递值和返回值的问题 现描述下问题所在:1.我在一个类A中有个容器类,想要想要把初始化延迟到其他类中去处理,于是我便将类B的构造方法中加入参数,作为类B...

    这几天在项目里面碰到了一个很恼火的问题,是关于函数的传递值和返回值的问题

    现描述下问题所在:1.我在一个类A中有个容器类,想要想要把初始化延迟到其他类中去处理,于是我便将类B的构造方法中加入参数,作为类B的内部变量,在类B中对这个传入的参数进行初始化,然后回到类A的执行中,去使用个这个容器类。以上逻辑一切都看起来很合理是吧?

     


    类似的思路如题所示可以吧?

    但是实际上说,a仍然是空的?你会问了?说好的传入地址值呢?是的,我们是传入了地址值,可是,其实传入地址值也是传入值啊,记得C语言中经典的交换参数的函数了吗?对,那个问题我们用指针就可以了。但是,请记住,我们得到地址值,在函数压堆栈的时候,也是拷贝了一个副本的,不过是因为是个地址值,也就是说,上图的fun_2()b,也是一个副本,你可以通过b去访问a容器内部的值,也可以去修改,但是,如果你对b赋值,那就和C语言中的问题一样了,你仍然是对副本赋值。所以,请注意,一定要认真对待函数的参数,他始终是副本!

    还有就是,java的数组是

    接下来说下函数的返回值的问题:

    Java的内存空间大致这样分:

    1、栈区(stack— 由编译器自动分配释放 ,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。
    2、堆区(heap — 一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事,分配方式倒是类似于链表,呵呵。
    3、全局区(静态区)(static,全局变量和静态变量的存储是放在一块的,初始化的全局变量和静态变量在一块区域, 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放 
    4、文字常量区常量字符串就是放在这里的。 程序结束后由系统释放
    5、程序代码区存放函数体的二进制代码。

     

    以下是函数的返回值的一些例子:

          一般的来说,函数是可以返回局部变量的。 局部变量的作用域只在函数内部,在函数返回后,局部变量的内存已经释放了。因此,如果函数返回的是局部变量的值,不涉及地址,程序不会出错。但是如果返回的是局部变量的地址(指针)的话,程序运行后会出错。因为函数只是把指针复制后返回了,但是指针指向的内容已经被释放了,这样指针指向的内容就是不可预料的内容,调用就会出错。准确的来说,函数不能通过返回指向栈内存的指针(注意这里指的是栈,返回指向堆内存的指针是可以的)

        下面以函数返回局部变量的指针举几个典型的例子来说明:

    1

    [cpp] view plaincopy

    1. #include <stdio.h>   

    2. char *returnStr()   

    3. {   

    4.     char *p="hello world!";   

    5.     return p;   

    6. }   

    7. int main()   

    8. {   

    9.     char *str;   

    10.     str=returnStr();   

    11.     printf("%s\n", str);   

    12.     return 0;   

    13. }  

    这个没有任何问题,因为"hello world!"是一个字符串常量,存放在只读数据段,把该字符串常量存放的只读数据段的首地址赋值给了指针,所以returnStr函数退出时,该该字符串常量所在内存不会被回收,故能够通过指针顺利无误的访问。

    2

    [html] view plaincopy

    1. #include <stdio.h>   

    2. char *returnStr()   

    3. {   

    4.     char p[]="hello world!";   

    5.     return p;   

    6. }   

    7. int main()   

    8. {   

    9.     char *str;   

    10.     str=returnStr();   

    11.     printf("%s\n", str);   

    12.     return 0;   

    13. }   

    "hello world!"是局部变量存放在栈中。当returnStr函数退出时,栈要清空,局部变量的内存也被清空了,所以这时的函数返回的是一个已被释放的内存地址,所以有可能打印出来的是乱码。 

    3:

    [html] view plaincopy

    1. int func()  

    2. {  

    3.       int a;  

    4.       ....  

    5.       return a;    //允许  

    6. }                     

    7.   

    8. int * func()  

    9. {  

    10.       int a;  

    11.       ....  

    12.       return &a;    //无意义,不应该这样做  

    13. }   

    局部变量也分局部自动变量和局部静态变量,由于a返回的是值,因此返回一个局部变量是可以的,无论自动还是静态,

    因为这时候返回的是这个局部变量的值,但不应该返回指向局部自动变量的指针,因为函数调用结束后该局部自动变量

    被抛弃,这个指针指向一个不再存在的对象,是无意义的。但可以返回指向局部静态变量的指针,因为静态变量的生存

    期从定义起到程序结束。

    4:如果函数的返回值非要是一个局部变量的地址,那么该局部变量一定要申明为static类型。如下:

    [html] view plaincopy

    1. #include <stdio.h>   

    2. char *returnStr()   

    3. {   

    4.     static char p[]="hello world!";   

    5.     return p;   

    6. }   

    7. int main()   

    8. {   

    9.     char *str;   

    10.      str=returnStr();   

    11.     printf("%s\n", str);   

    12.   

    13.     return 0;   

    14. }   

    5: 数组是不能作为函数的返回值的,原因是编译器把数组名认为是局部变量(数组)的地址。返回一个数组一般用返回指向这个数组的指针代替,而且这个指针不能指向一个自动数组,因为函数结束后自动数组被抛弃,但可以返回一个指向静态局部数组的指针,因为静态存储期是从对象定义到程序结束的。如下:

    [html] view plaincopy

    1. int* func( void )  

    2. {  

    3.     static int a[10];  

    4.     ........  

    5.     return a;  

    6. }   

    6:返回指向堆内存的指针是可以的

    [html] view plaincopy

    1. char *GetMemory3(int num)  

    2. {  

    3. char *p = (char *)malloc(sizeof(char) * num);  

    4. return p;  

    5. }  

    6. void Test3(void)  

    7. {  

    8. char *str = NULL;  

    9. str = GetMemory3(100);  

    10. strcpy(str, "hello");  

    11. cout<< str << endl;  

    12. free(str);  

    13. }  

    程序在运行的时候用 malloc 申请任意多少的内存,程序员自己负责在何时用 free释放内存。动态内存的生存期由程序员自己决定,使用非常灵活。 

     

    以上是C语言中比较经典的问题,那么,java中存在哪些呢?其实java中的数组都是如6例子所示,函数只在栈中保存数组的头地址,但是,数组的实际空间的是在堆空间的中的分配的,此外,javaString变量也是放在数据段中的,所以你在函数中给字符串赋值,然后返回,是不会被系统清掉的,尽管使用就好

     

     

    展开全文
  • Java中能否利用函数参数来返回值

    万次阅读 2017-04-10 23:17:38
    甚至这两个返回值都不属于同一种类型,这种情况下在C或C++中可以轻易的使用一个引用的参数来将想要返回的值作为参数传入函数,等函数执行完毕后就可以得到你想要的“返回值”了。 但是这种情况在Java中可能就没有...

    我们在写代码时通常会遇到一种情况,就是我们可能希望在一个函数操作完成后返回两个值,这两个值互不关联并且不希望以数组的形式返回,甚至这两个返回值都不属于同一种类型,这种情况下在C或C++中可以轻易的使用一个引用的参数来将想要返回的值作为参数传入函数,等函数执行完毕后就可以得到你想要的“返回值”了。
    但是这种情况在Java中可能就没有那么轻易了,我们知道Java语言最大的一项改变就是隐藏了类似C或C++中的指针操作,这给开发者带来了极大的好处,开始时不用在为调皮的指针头疼了,但是同样的,在某些场景下也会产生某些局限性,接下来我们来看看如果我们利用Java来完成C或C++中的通过函数来改变传入实参的值会出现哪些状况。
    首先,我们先来试试最最基本的int型变量,看如下代码:

    package testCase;
    
    public class testCase {
    
        public static void main(String[] args) {
            int a = 0, b = 1;
    
            System.out.println("Before swap: a is " + a + " b is " + b);
    
            swap(a, b);
    
            System.out.print("After swap: a is " + a + " b is " + b);
        }
    
        static void swap(int a, int b) {
            int tmp;
    
            tmp = a;
            a = b;
            b = tmp;
        }
    }

    如上所示,这是一个最基本的交换值的操作,在C或C++中我们可以很简单的利用swap(int &a, int &b)来完成相关的操作,但是在Java中我们看看这个程序的运行结果如下:

    int交换结果图

    我们不得不遗憾的发现类似于这样的基本类型想要通过函数参数来改变在Java中是不可能实现的,我们不禁想到,基本类型不行我们可以使用对象啊,对象在Java中确实传递的是地址,但是这个地址也有些微妙所在,我们看下面这个例子,仍然使用我们的神奇的交换函数,代码如下:

    package testCase;
    
    public class testCase {
    
        public static void main(String[] args) {
            StringBuffer a = new StringBuffer("hello a"), b = new StringBuffer("hello b");
    
            System.out.println("Before swap: a is " + a + " b is " + b);
    
            swap(a, b);
    
            System.out.print("After swap: a is " + a + " b is " + b);
        }
    
        static void swap(StringBuffer a, StringBuffer b) {
            StringBuffer tmp;
    
            tmp = a;
            a = b;
            b = tmp;
        }
    }

    这个程序的运行结果是怎样的呢?结果如下所示:

    StringBuffer交换结果图

    这是为什么呢?我们要理解一个概念,那就是我们传地址实际上也是值传递,我们把实参存储的地址通过拷贝给了形参,在函数中传递参数后(还未做交换操作时)实参a与形参a的指向情况如下:

    交换前实参形参指向

    如上图所示,在传入参数时实参a将其存储的地址(@32,我们假设这个值是字符串”hello a”的地址)拷贝给了形参a,这时这两个对象均指向”hello a”。
    之后我们进行交换操作,交换操作完成后的指向如下所示:

    交换后实参指向

    此时我们发现我们仅仅是将形参的指向改变了,根本未能交换两个实参的指向,oh,no,到头来一场空。

    我们试试下面的用法,具体程序如下:

    package testCase;
    
    public class testCase {
    
        public static void main(String[] args) {
            StringBuffer a = new StringBuffer("hello a");
    
            System.out.println("Before change: a is " + a);
    
            change(a);
    
            System.out.print("After change: a is " + a);
        }
    
        static void change(StringBuffer a) {
            a.append(" hello world");
        }
    }
    

    这里我们通过形参来改变实参指向的内容的值试试,运行结果如下:

    改变后实参内容

    嘿嘿,是不是还有点用,说到这里我们就明白了吧,我们改变指向是没用的,但我们去改变指向的内容的值是会生效的。

    接下来我们不禁想到我们是不是可以用基础类型的封装类型来操作一波,封装类型是对象啊,这是毋庸置疑的,我们来看如下代码:

    package testCase;
    
    public class testCase {
    
        public static void main(String[] args) {
            Integer a = Integer.valueOf(0);
    
            System.out.println("Before change: a is " + a);
    
            change(a);
    
            System.out.print("After change: a is " + a);
        }
    
        static void change(Integer a) {
            a = Integer.valueOf(1);
        }
    }

    来看看运行结果吧,如下所示:

    封装类型改变后实参内容

    是不是一脸懵逼,百思不得其解,接下来我们看看Integer的源码吧,代码如下:

    public static Integer valueOf(int i) {
            assert IntegerCache.high >= 127;
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
        }

    继续往下看,Integer(int i)的定义如下:

    public Integer(int value) {
            this.value = value;
        }

    这个value是怎么定义的呢,我们看看,value定义如下:

        /**
         * The value of the {@code Integer}.
         *
         * @serial
         */
        private final int value;

    明白了吧,这个value它是个final类型的,简直坑爹,类似的封装类型都是这种调调,完全用不鸟,我们关于对象的举例为什么用了StringBuffer而不用String呢?因为String类型也是不会生效的,具体原因是为什么呢?我们就不再追代码了,实际上String虽然是一个对象类型,但其实它也是对char[]的封装,所以它也可以看作一个封装类型,因此,它也是不会生效的。
    好了,关于Java能否做到类似C语言改变传入实参的值的分析就到这里了,经过上述的分析,我们大致了解了其实对于Java来说这个用法其实并不怎么好用,还不如定义一个自己的数据类型来返回来的自由愉快,希望大家能够从我的这篇博客中学到新的知识,欢迎大家留言一起讨论。

    展开全文
  • java 函数返回类型

    千次阅读 2019-06-09 18:27:20
    在学习工厂模式时看到函数的返回类型声明为父类(抽象类),返回类型却可以是其子类(具体类)?

    在学习工厂模式时看到函数的返回类型声明为父类(抽象类),返回类型却可以是其子类(具体类)?

    展开全文
  • java返回值的使用

    千次阅读 2018-11-13 16:22:04
    java返回值的使用 一、返回一般数据类型 八大基本数据类型之一(byte,char,short,int,long,float,double,boolean) Object Object是java中所有类的始祖,所有类都默认继承了Object。Object类型的变量可以指向...

    java返回值的使用

    一、返回一般数据类型

    八大基本数据类型之一(byte,char,short,int,long,float,double,boolean)

    Object

    java.lang.Object

    Object是java中所有类的始祖,所有类都默认继承了Object。Object类型的变量可以指向任意类型的对象,但Object类型的变量只能作为实际对象的持有者,若要对对象的内容进行具体操作必须明确该对象的原始类型并进行相应的类型转换。

    方法

    Object 类中的equals 方法:

     public boolean equals(Object obj) {
            return (this == obj);
        }

      在Java规范中,对 equals 方法的使用必须遵循以下几个原则:

      ①、自反性:对于任何非空引用值 x,x.equals(x) 都应返回 true。

      ②、对称性:对于任何非空引用值 x 和 y,当且仅当 y.equals(x) 返回 true 时,x.equals(y) 才应返回 true。 

      ③、传递性:对于任何非空引用值 x、y 和 z,如果 x.equals(y) 返回 true,并且 y.equals(z) 返回 true,那么 x.equals(z) 应返回 true。

      ④、一致性:对于任何非空引用值 x 和 y,多次调用 x.equals(y) 始终返回 true 或始终返回 false,前提是对象上 equals 比较中所用的信息没有被修改

      ⑤、对于任何非空引用值 x,x.equals(null) 都应返回 false。

     == 比较两个对象在栈内存中的引用地址是否相等。

    getClass()在 Object 类中如下,作用是返回对象的运行时类。

    public final native Class<?> getClass();

    这里详细的介绍 getClass 方法返回的是一个对象的运行时类对象,这该怎么理解呢?Java中还有一种这样的用法,通过 类名.class 获取这个类的类对象 ,这两种用法有什么区别呢?

    public class Parent {}
    
    
    public class Son extends Parent{}
    
    
    public void testClass(){
        Parent p = new Son();
        System.out.println(p.getClass());
        System.out.println(Parent.class);
    }
    
    

    结论:class 是一个类的属性,能获取该类编译时的类对象,而 getClass() 是一个类的方法,它是获取该类运行时的类对象。

      还有一个需要大家注意的是,虽然Object类中getClass() 方法声明是:public final native Class<?> getClass();返回的是一个 Class<?>,但是如下是能通过编译的:

    Class<? extends String> c = "".getClass();

    也就是说类型为T的变量getClass方法的返回值类型其实是Class<? extends T>而非getClass方法声明中的Class<?>。

    hashCode 在 Object 类中定义如下:

    public native int hashCode();

    通过 equals 方法判断集合中的每一个元素是否重复,但是如果集合中有10000个元素了,但我们新加入一个元素时,那就需要进行10000次equals方法的调用,这显然效率很低。于是,Java 的集合设计者就采用了 哈希表 来实现。

    哈希算法也称为散列算法,是将数据依特定算法产生的结果直接指定到一个地址上。这个结果就是由 hashCode 方法产生。这样一来,当集合要添加新的元素时,先调用这个元素的 hashCode 方法,就一下子能定位到它应该放置的物理位置上。

    两个对象相等,其 hashCode 一定相同;

    两个对象不相等,其 hashCode 有可能相同;

    hashCode 相同的两个对象,不一定相等;

    hashCode 不相同的两个对象,一定不相等;

    对于 Map 集合,我们可以选取Java中的基本类型,还有引用类型 String 作为 key,因为它们都按照规范重写了 equals 方法和 hashCode 方法。但是如果你用自定义对象作为 key,那么一定要覆写 equals 方法和 hashCode 方法,不然会有意想不到的错误产生。

    toString 方法

      public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }

    getClass().getName()是返回对象的全类名(包含包名),Integer.toHexString(hashCode()) 是以16进制无符号整数形式返回此哈希码的字符串表示形式。

    打印某个对象时,默认是调用 toString 方法,比如 System.out.println(person),等价于 System.out.println(person.toString())

    java.lang.Integer、

    public final class Integer extends Number implements Comparable<Integer>{}

    Integer 是用 final 声明的常量类,不能被任何类所继承。并且 Integer 类继承了 Number 类和实现了 Comparable 接口。 Number 类是一个抽象类,8中基本数据类型的包装类除了Character 和 Boolean 没有继承该类外,剩下的都继承了 Number 类,该类的方法用于各种数据类型的转换。Comparable 接口就一个  compareTo 方法,用于元素之间的大小比较

     int 类型在 Java 中是占据 4 个字节,所以其可以表示大小的范围是 -2 31——2 31 -1即 -2147483648——2147483647,我们在用 int 表示数值时一定不要超出这个范围了。

    返回基本类型的数据

    
    
    <select id="getByParentId" parameterType="java.lang.Integer" resultType="java.lang.Integer">
            SELECT COUNT(*) FROM se_install_check_item WHERE installCheckId = #{deviceInstallCheckId}
    </select>
    
    Integer getByParentId(@RequestParam(value = "deviceInstallCheckId", required = false)Integer deviceInstallCheckId);
    
    Map<String, Object> getByParentId(Integer ovId);
    
    	@Override
    	public Map<String, Object> getByParentId(Integer ovId) {
    		// TODO Auto-generated method stub
    		Map<String, Object> map = new HashMap<>();
    		Integer  counts = mapper.getByParentId(ovId);
    		map.put("counts", counts);
    		return map;
    	}
    
    
    	@PostMapping("/queryByParentId")
    	public AssembleJSON installcheckItem(String ids){
    		
    		if(null!=ids&&ids.length()>0) {
    			for(int i =0;i<ids.split(",").length;i++) {
    				Map<String, Object> counts = service.getByParentId(Integer.parseInt(ids.split(",")[i]));
    				Object object = counts.get("counts");
    			}
    		}
    		
    		return AssembleJSON.SUCCESS(ids);
    	}
    
    
    var ids = "";
    	$.each(rows, function (k, j) {
    		ids += (ids == "" ? j[$id] : "," + j[$id]);
    	});
    	var paras = { ids: ids };
     	$.post("security/installitcheck/queryByParentId", paras, function (data) {
            if (data.code == "0") {
       		$Core.UI.message.error("未录入设备,不可提交!");
        		}
        		});
    

    二、返回 JavaBean 类型

    
    $.fn.serializeObject = function()
    {
        var o = {};
        var a = this.serializeArray();
        $.each(a, function() {
            if (o[this.name]) {
                if (!o[this.name].push) {
                    o[this.name] = [o[this.name]];
                }
                o[this.name].push(this.value || '');
            } else {
                o[this.name] = this.value || '';
            }
        });
        return o;
    };
    
        $("#btnSave").click(function () {
        	debugger;
            if ($("#submit_form").form("validate")) {
                var url = "security/userContacts/add";
                if ($("#id").val() != "")
                    url = "security/userContacts/upd";
                var paras = {
                    list:[],
                    publicServicesUser:{}
                };
                paras.publicServicesUser = $("#submit_form").serializeObject();
    
                for (var i= 14;i <= index; i++) {
                    var obj = {
                        contactsType: "",
                        contactsName:"",
                        contactsPhone:""
                    };
                    var row = $("#submit_table tr:eq(" + i + ")");
                    obj.contId = row.find("#contId").val();
                    obj.contactsType = row.find("#contactsType").combo("getValue");
                    obj.contactsName = row.find("#contactsName").textbox("getValue");
                    obj.contactsPhone = row.find("#contactsPhone").textbox("getValue");
                    paras.list.push(obj)
                }
                $.ajax({
                    type: "POST",
                    url: url,
                    contentType: "application/json; charset=utf-8",
                    data: JSON.stringify(paras),
                    dataType: "json",
                    success: function (message) {
                        if (message.code == 0) {
                            $Core.UI.message.success(message.msg);
                        }else{
                            $Core.UI.message.warning(message.msg);
                        }
                    }
                });
            }
        });
    
    

    	@PostMapping("upd")
    	public AssembleJSON update(@RequestBody UserContacts userContacts) {
    		PublicServicesUser publicServicesUser = userContacts.getPublicServicesUser();
    
    		SessionData sessionData =getCurrUserData();
    
    		publicServicesUser.setUpdateUser(sessionData.getUserId());
    		publicServicesUser.setUpdateUserName(sessionData.getUserName());
    		if (publicServicesUser.getUpdateTime() == null) {
    			publicServicesUser.setUpdateTime(new Date());
    		}
    
    		Map<Object, Object> objectObjectMap = MapUtil.object2Map(publicServicesUser);
    		String str = JSONArray.toJSONString(userContacts.getList());
    		PublicServicesUserTemp publicServicesUserTemp = MapUtil.map2Object(objectObjectMap, PublicServicesUserTemp.class);
    		publicServicesUserTemp.setContactsStr(str);
    		publicServicesUserTemp.setApproveState("0");
    		publicServicesUserTemp.setUpdateTime(new Date());
    		publicServicesUserTempService.insert(publicServicesUserTemp);
    
    		PublicServicesUser publicServicesUser1 = new PublicServicesUser();
    		publicServicesUser1.setId(publicServicesUser.getId());
    		publicServicesUser1.setApproveState("0");
    		publicServicesUser1.setUpdateTime(new Date());
    		userContacts.setPublicServicesUser(publicServicesUser1);
    		userContacts.setList(null);
    		return AssembleJSON.SUCCESS(userContactsService.updateContactsSelective(userContacts));
    	}
    

    --------------------------------------------------------------

        //保存按钮
        $("#btnAdd").click(function () {
        	debugger;
            if ($submit_form.form("validate")) {
                var url = add_url;
                if (key){
                    url = upd_url;
                }
                var paras = $submit_form.serializeArray();
                var rows2 = $("#dglist2").gridsub("getRows");
                var p2 = [];
                var flag=true;
                $.each(rows2, function (k, j) {
                    var temp2 = { deviceId: j.deviceId, deviceName: j.deviceName, deviceNumber: j.deviceNumber, assetsNumber: j.assetsNumber, deviceSpec: j.deviceSpec, propertyAscription: j.propertyAscription, company: j.company, number: j.number, installMoney: j.installMoney, total: j.total, installCheckId: key,unitMoney:j.unitMoney};
                    if(j.company==null){
                    	$Core.UI.message.error("请输入单位");
                    	flag=false;
                    	return;
                    }else if(j.number==null){
                    	$Core.UI.message.error("请输入数量");
                    	flag=false;
                    	return;
                    }else if(j.installMoney==null){
                    	$Core.UI.message.error("请输入安装费用");
                    	flag=false;
                    	return;
                    }else if(j.total==null){
                    	$Core.UI.message.error("请输入合计");
                    	flag=false;
                    	return;
                    }
                    
                    p2.push(temp2);
                });
                paras.push({ 'name': "acceptdetails", value: JSON.stringify(p2) });
                if(flag){
                	//已填写物资数量
                    $("#btnSave").attr("disabled", "disabled");
                    //    console.log(paras); return false;
    
                    $.post(url, paras, function (data) {
                        $("#btnAdd").removeAttr("disabled");
                        if (data.code == 0) {
                        	$Core.UI.message.success("操作成功!");
                        	 $('#btnAdd').attr('disabled',"true");
     
                        }
                        else {
                            $Core.UI.message.error(data.msg);
                        }
                    });
                }
    
            }
        });

    	@PostMapping("/update")
    	public AssembleJSON update(InstallCheck entity,String acceptdetails) {
    		SessionData sessionData =getCurrUserData();
    		entity.setUpdateUser(sessionData.getUserId());
    		entity.setUpdateUserName(sessionData.getUserName());
    		entity.setUpdateTime(new Date());
    		InstallCheck installCheck=service.update(entity,acceptdetails);
    		return AssembleJSON.SUCCESS(installCheck);
    		
    	}
    	@Override
    	public InstallCheck update(InstallCheck entity, String acceptdetails) {
    		mapper.updateByPrimaryKeySelective(entity);
    		
    		/*先删除字表*/
    		InstallCheckItem installCheckItem = new InstallCheckItem();
    		installCheckItem.setInstallCheckId(entity.getDeviceInstallCheckId());
    		List<InstallCheckItem> list = installCheckItemMapper.select(installCheckItem);
    		for(InstallCheckItem item : list) {
    			installCheckItemMapper.delete(item);
    		}
    		/*再新增*/
    		if(StringUtil.isNotEmpty(acceptdetails)) {
    			List<InstallCheckItem> InstallCheckItemdetails = JSONArray.parseArray(acceptdetails, InstallCheckItem.class);
    			for (InstallCheckItem detail : InstallCheckItemdetails) {
    				detail.setInstallCheckId(entity.getDeviceInstallCheckId());
    				installCheckItemMapper.insert(detail);
    			}	
    		}
    		return entity;
    	}
    

     

    三、返回Map类型

     $.get(form_url + key, function (data) {
    		    	debugger;
    		        $submit_form.form("load", data.data.installCheckVo	);
    		        $("#dglist2").datagrid({ data: data.data.deviceUserList });
    });

    Map<String, Object> getUid(Integer ovId);
    
    	@Override
    	public Map<String, Object> getUid(Integer ovId) {
    		// TODO Auto-generated method stub
    		Map<String, Object> map = new HashMap<>();
    		InstallCheckVo  installCheckVo = mapper.selectByPrimaryKey(ovId);
    		map.put("installCheckVo", installCheckVo);
    		
    		//明细
    		InstallCheckItem installCheckItem = new InstallCheckItem();
    		installCheckItem.setInstallCheckId(ovId);
    		List<InstallCheckItem> removeApplyItems = installCheckItemMapper.select(installCheckItem);
    		map.put("deviceUserList", removeApplyItems);
    		return map;
    	}
    
    
    
    
    
    

     

    根据id判断有无数据

    	@PostMapping("/queryByParentId")
    	public AssembleJSON installcheckItem(String ids){
    		
    		if(null!=ids&&ids.length()>0) {
    			for(int i =0;i<ids.split(",").length;i++) {
    				Map<String, Object> counts = service.getByParentId(Integer.parseInt(ids.split(",")[i]));
    				Object object = counts.get("counts");
    				if(""!=object&&"0".equals(object.toString())) {
    					return AssembleJSON.FAILURE;
    				}
    			}
    		}
    		
    		return AssembleJSON.SUCCESS(ids);
    	}
    Integer getByParentId(@RequestParam(value = "deviceInstallCheckId", required = false)Integer deviceInstallCheckId);
    	@Override
    	public Map<String, Object> getByParentId(Integer ovId) {
    		// TODO Auto-generated method stub
    		Map<String, Object> map = new HashMap<>();
    		Integer  counts = mapper.getByParentId(ovId);
    		map.put("counts", counts);
    		return map;
    	}
    <select id="getByParentId" parameterType="java.lang.Integer" resultType="java.lang.Integer">
            SELECT COUNT(*) FROM se_install_check_item WHERE installCheckId = #{deviceInstallCheckId}
    </select>
                	$.post("security/installitcheck/queryByParentId", param, function (data) {
                		
            			if (data.code != "0") {
            				$Core.UI.message.error("未录入设备,不可提交!");
            				return false;
            			}
                      }

    四、返回List类型

    public class UserVo {
         
        private List<User> userList;
        public List<User> getUserList() {
            return userList;
        }
        public void setUserList(List<User> userList) {
            this.userList = userList;
        }
    }
    
    @RequestMapping("selectAllUserAndList")
        public ModelAndView selectAllUserAndList(){
            List<User> listUser = userService.selectAllUser();
            ModelAndView mv = new ModelAndView();
            mv.addObject("listUser", listUser);
            mv.setViewName("list.jsp");
            return mv;
        }
    }

    由于我们在 JSP 页面 input 输入框定义的name属性名是 userList[${status.index}].id 这种形式的,这里我们直接用 UserVo 就能获取页面批量提交的 User信息

    public class UserContacts{
    
    	private PublicServicesUser publicServicesUser;
    
    	private List<Contacts> list;
    }
    
    	@Override
    	public UserContacts getById(Integer id) {
    		UserContacts userContacts = new UserContacts();
    		PublicServicesUser publicServicesUser = publicServicesUserMapper.selectByPrimaryKey(id);
    		Contacts contacts = new Contacts();
    		contacts.setUserId(id);
    		List<Contacts> list = contactsMapper.select(contacts);
    		List<Contacts> contactsList = new ArrayList<>();
    		for (Contacts contacts1 : list) {
    			if (contacts1.getContactsType() != 11 && contacts1.getContactsType() != 12 && contacts1.getContactsType() != 13 && contacts1.getContactsType() != 14) {
    				contactsList.add(contacts1);
    			}
    		}
    		userContacts.setPublicServicesUser(publicServicesUser);
    		userContacts.setList(contactsList);
    		return userContacts;
    	}
    
    	@GetMapping("/getById/{id}")
    	public AssembleJSON getById(@PathVariable Integer id) {
    		UserContacts userContacts = userContactsService.getById(id);
    		return AssembleJSON.SUCCESS(userContacts);
    	}
    
    
    
     $.get("security/PublicServicesUserTemp/getById/" + key, function (data) {
                	debugger;
                    _this.getMainData = data;
                    $("#submit_form").form("load", data.data.publicServicesUser);
                    var list = data.data.list;
     });

    有时候我们列表根据大标题和小标题及小标题下的文章的层级进行遍历。一次性获取的数据不能满足只遍历子标题下的文章会同时把大标题也遍历。这时候就需要我们用到集合数据类型,只遍历参数类型为集合的实体对象。

    定义实体对象

    
    	private static final long serialVersionUID = -8715592713023165170L;
    	
    	private String subjectClassifyId;
    	private String classifyName;
    	private String classifyIsShow;
    	private String classifyIsShowName;
    	private String classifyOrder;
    	private String subjectId;
    	
    	List<CheckAdvice> adviceList;

    后台封装集合参数

            @RequestMapping(value = "/gateway/subDetail")
    	public String getSubDataDetailById(Model model, HttpServletRequest request, String dataId) {
    		List<SubjectMgtClassify> dataList = gateWayService.getSubjectClassfiyAndAdviceList(dataId);
    		model.addAttribute("PROFILELIST",dataList);
    		return pathffix + "/subArticle";   
    	}
    
    
    	public List<SubjectMgtClassify> getSubjectClassfiyAndAdviceList(String dataId)
    	{
    		List<SubjectMgtClassify> subjectMgtClassify = getSubjectMgtClassify(dataId);
    		if(CollectionUtils.isEmpty(subjectMgtClassify))
    		{
    			return null;
    		}
    		for(SubjectMgtClassify subClass:subjectMgtClassify) {
    			List<CheckAdvice> adviceList = getAdviceByClassify(subClass.getSubjectClassifyId());
    			subClass.setAdviceList(adviceList);
    		}
    		return  subjectMgtClassify;
    	}
    
    
      	<select id="getAdviceByClassify" parameterType="com.model.SubjectMgtClassify" resultType="com.model.CheckAdvice">
    	select b.CHECK_ADVICE_ID as adviceId,b.TITLE as title,cta.attachment_id from (select a.*
    	from PB_CHECK_ADVICE a
    	where a.CHECK_ADVICE_ID in
    	(select t.advice_id
    	from pb_classify_rel_advice t
    	where t.subject_classify_id = #{subjectClassifyId,jdbcType=VARCHAR}) and
    	a.is_work=1) b
    	left join ct_attachment cta on cta.entity_id = b.CHECK_ADVICE_ID and
    	cta.is_delete=0 
      	</select>

    前台分开遍历只遍历子标题下的文章

    <div class="wrap main">
      <div class="wraper zt">
         
         <div class="cont">
           <div class="tit">
             <ul>
               <li>导读</li>
             </ul>
           </div>
           <div class="zt_con">
             <p style="text-indext:2em;">
               <#if HEADLIST??>
               ${HEADLIST.subjectBrief!''}
                </#if>
                <#if HEADLIST.attachmentId?exists>
     				<input id="headPicture" src="${rc.contextPath}/attach/download?attachmentId=${HEADLIST.attachmentId!''}" type="hidden">
    		    </#if>
             </p>
           </div>
           <#if PROFILELIST??&& PROFILELIST?size gt 0>
    		   <#list PROFILELIST as profile>
    		    <div class="tit">
             	<ul>
               <li> ${profile.classifyName!''}</li>
             	</ul>
               </div>
    		   <#if profile.adviceList?? &&  ( profile.adviceList?size>0)>
    		    <ul class="listTW">
    		    <#list profile.adviceList as profileItem>
    		    <li>
    			   	 
    		         <#if profileItem.useLink?? && profileItem.useLink == '1' && profileItem.oriLink??>
    		         	<h2><a href="${profileItem.oriLink!''}" target="_blank">${profileItem.title!''}</a></h2>
    		         <#else>
    		            <h2><a href="${rc.contextPath}/detail?dataId=${profileItem.adviceId!''}" target="_blank">${profileItem.title!''}</a></h2>
    		         </#if>
    		         <#if profileItem.attachmentId?exists>
     				    <img src="${rc.contextPath}/attach/download?attachmentId=${profileItem.attachmentId!''}">
    		         </#if>
    	          </li>
    		    </#list>
    		    </ul>
    		   </#if>
    		   </#list>
           </#if>
           
           
    
         </div>
      </div>
    </div>

    四、返回List<Map<String,Object>>类型

    public class AssembleJSON implements Serializable {
    	private static final long serialVersionUID = 1L;
    	
    	private Integer code;
    	private String msg;
    	private Object data;
    	/**
    	 * 获得返回数据
    	 * @return 数据
    	 */
    	public Object getData(){
    		return this.data;
    	}
    
    	public AssembleJSON() {
    	}
    
    	public AssembleJSON(Integer _status, String _message, Object _data){
    		this.code = _status;
    		this.msg = _message;
    		this.data = _data;
    	}
    	
    	/**
    	 * 返回成功(默认)
    	 */
    	public static AssembleJSON SUCCESS = new AssembleJSON(Constant.SUCCESS, Constant.REQUEST_SUCCESS_STRING, null);
    	public static AssembleJSON FAILURE = new AssembleJSON(Constant.FAILED, Constant.REQUEST_FAILED_STRING, null);
    	
    	/**
    	 * 返回成功JSON 状态码默认是 0
    	 * @param _data 数据
    	 * @return JSON对象
    	 */
    	public static AssembleJSON SUCCESS(Object _data){
    		return new AssembleJSON(Constant.SUCCESS, Constant.REQUEST_SUCCESS_STRING, _data);
    	}
    	
    	/**
    	 * 返回失败JSON 状态码默认是 -1000
    	 * @param _message 失败信息
    	 * @return JSON对象
    	 */
    	public static AssembleJSON FAILURE(String _message){
    		return new AssembleJSON(Constant.FAILED, _message, null);
    	}
    	
    	/**
    	 * 返回失败JSON,传入data 状态码默认是 0
    	 * @param _message 失败信息
    	 * @return JSON对象
    	 */
    	public static AssembleJSON FAILURE(String _message,Object _data){
    		return new AssembleJSON(Constant.FAILED, _message, _data);
    	}
    	/**
    	 * 返回成功JSON,
    	 * @param _code 返回的状态码
    	 * @param _message 返回的自定义信息
    	 * @param _data 返回的数据
    	 * */
    	public static AssembleJSON SUCCESS(Integer _code, String _message,Object _data){
    		return new AssembleJSON(_code, _message, _data);
    	}
    	/**
    	 * 返回成功JSON,
    	 * @param _code 返回的状态码
    	 * @param _message 返回的自定义信息
    	 * */
    	public static AssembleJSON SUCCESS(Integer _code, String _message){
    		return new AssembleJSON(_code, _message, null);
    	}
    }
    
    	@Override
    	public Map<String, Object> getUid(Integer installAcceptId) {
    		AssembleJSON json = dicService.getDicItem("installAcceptProject");
    		List<Map<String,Object>> items = (List<Map<String, Object>>) json.getData();
    		map.put("items", items);
    		
    		return map;
    	}
    
    

     

     

     $.get("security/installcompletevo/getUid/" + key, function (data) {
    $.each(data.data.items, function (k, j) {	 
                     		var addNum = ++a;
                    		var deviceName = j.deviceName;
                    		var checkIsRight = j.checkIsRight;
                    		var appendRow ="<tr> <td>"+addNum+
                    		"</td><td>"+j.itemName+
                    		"</td><td>"+
                    		"</td> <td>"+
                    		"</td> <td>"+
                    		"</td><td>"+
                    		"</td> <td>"+
                    		"</td><td>"+
                    		"</td> <td>"+j.checkIsRight+
                    		"</td></tr>"
                    		$("#dicItem").after(appendRow);
                    	});
    });

    返回 Hash<string,List<>>

    返回list里面包含list的,可以转换为多个list ,前台js进行拼装

    SELECT
      DISTINCT d.timestamp,d.`tag_value` AS tagValue,d.`device_code` AS deviceCode,CEIL(d.`tag_value`) AS tagCode
    FROM
      pr_scada_data d
    WHERE
      d.device_code = 'N64A749'
    AND d.tag_name LIKE '%出口压力'
    AND SUBSTRING(d.`timestamp`,1,11) = (SELECT SUBSTRING(m.`timestamp`,1,11) AS TIMESTAMP FROM (SELECT MAX(TIMESTAMP) AS TIMESTAMP FROM pr_scada_data WHERE device_code = 'N64A749') m)
    ORDER BY d.`timestamp` DESC

    	SELECT
    	DISTINCT d.timestamp,d.`tag_value` AS tagValue,d.`device_code` AS
    	deviceCode,CEIL(d.`tag_value`) AS tagCode
    	FROM
    	pr_scada_data d
    	WHERE
    	d.device_code = #{deviceCode,jdbcType=VARCHAR}
    	AND d.tag_name LIKE '%出口压力'
    	AND SUBSTRING(d.`timestamp`,1,11) = (SELECT SUBSTRING(m.`timestamp`,1,11)
    	AS TIMESTAMP FROM (SELECT MAX(TIMESTAMP) AS TIMESTAMP FROM
    	pr_scada_data WHERE device_code = #{deviceCode,jdbcType=VARCHAR}) m)
    	ORDER BY d.`timestamp`

    	public Map<String, List<String>> getRadarChartName(String deviceCode)
    	{
    		Map<String, List<String>> maps = new HashMap<String, List<String>>();
    		List<String> datalist = new ArrayList<String>();
    		List<String> textlist = new ArrayList<String>();
    		List<String> maxlist = new ArrayList<String>();
    		List<String> comparelist = new ArrayList<String>();
    		List<ScadaVO> radarCeilTime = prPreStationMapper.getRadarCeilTime(deviceCode);
    		List<ScadaVO> radarRecordChartName = prPreStationMapper.getRadarRecordChartName(deviceCode);
    		List<ScadaVO> newRadarRecordChartName = new ArrayList<ScadaVO>();
    		
    		ScadaVO firstScada = radarRecordChartName.get(0);
    		
    		for(ScadaVO scadaVO:radarCeilTime) {
    			comparelist.add(scadaVO.getTimestamp());
    		}
    		
    		newRadarRecordChartName.add(firstScada);
    		for(int i=radarRecordChartName.size()-1;i>0;i--) {
    			newRadarRecordChartName.add(radarRecordChartName.get(i));
    		}
    		
    		for(ScadaVO scadaVO:newRadarRecordChartName) {
    			datalist.add(scadaVO.getTagValue());
    			maxlist.add(scadaVO.getTagCode());
    			if(comparelist.contains(scadaVO.getTimestamp())) {
    				textlist.add(scadaVO.getTimestamp().substring(11, 13));
    			}else {
    				textlist.add("");
    			}
    			
    		}
    		
    		maps.put("datalist", datalist);
    		maps.put("textlist", textlist);
    		maps.put("maxlist", maxlist);
    		return maps;
    	}
    		var names = ["0:00","1:23","2:22","3:21","4:20","5:19","6:18","7:17","8:16","9:15","10:14","11:13","12:12","13:11","14:10","15:09","16:08","17:07","18:06","19:05","20:04","21:03","22:02","23:01"];
    		var url = CONTEXT_PATH +"/cusviews/dev/getRadarChartName";
    		var param = {
    				deviceCode:deviceCode
    		}
    		var retData = $.getData(url,param)
    		if(0==retData.datalist.length||0==retData.textlist.length||0==retData.maxlist.length){
    			return;
    		}
    		
    		var rlt = {
    				"data" : []
    			};
    		var rltdata = [];
    		
    		for(var i = 0, len = names.length; i < len; i++){
    			debugger;
    			var flag = false;
    			for(var key in retData.textlist){
    				var nItem = names[i], noKey = nItem.split(":")[0], nVal = nItem.split(":")[1];
    				if(nVal==retData.textlist[key]){
    					flag = true;
    					var obj = {};
    					obj.text = retData.textlist[key],obj.max = retData.maxlist[key];
    					rlt.data.push(obj);
    				}
    				if(!flag){
    					
    				}
    			}
    		}

     

    Map集合用于排序问题

    	public Map<String, Object>getRadarChartData(String deviceCode)
    	{
    		//每点的数据
    		List<ScadaVO> radarCeilTime = prPreStationMapper.getRadarCeilTime(deviceCode);
    		if(CollectionUtils.isEmpty(radarCeilTime))
    		{
    			return null;
    		}
    		String[] dateString = {"00","23","22","21","20","19","18","17","16","15","14","13","12","11","10","09","08","07","06","05","04","03","02","01"};
    		Map<String, Object> radarData = new HashMap<String,Object>(1);
    		for(int i=0;i<dateString.length;i++)
    		{
    			radarData.put(dateString[i], "0");
    		}
    		for(ScadaVO sc:radarCeilTime)
    		{
    			if(radarData.containsKey(sc.getTimestamp().substring(11, 13)))
    			{
    				radarData.put(sc.getTimestamp().substring(11, 13), sc.getTagValue());
    			}
    		}
    		return radarData;
    	}
    		var names = ["0:00","1:23","2:22","3:21","4:20","5:19","6:18","7:17","8:16","9:15","10:14","11:13","12:12","13:11","14:10","15:09","16:08","17:07","18:06","19:05","20:04","21:03","22:02","23:01"];
    		var url = CONTEXT_PATH +"/cusviews/dev/getRadarChartName";
    		var param = {
    				deviceCode:deviceCode
    		}
    		var retData = $.getData(url,param)
    		if(1000!=retData.status){
    			return;
    		}
    		var data = retData.data;
    		
    		var rlt = {
    				"data" : []
    			};
    		var rltdata = [];
    		var dataList = new Array();;
    		for(key in data){
    			var obj = {};
    			obj.text = key,obj.max = 3;
    			rlt.data.push(obj);
    			dataList.push(data[key]);
    		}

    通过map集合排序算法进行排序

    通过map进行数据的排序,list进行前台数据的封装

    	SELECT
    	DISTINCT d.timestamp,d.`tag_value` AS tagValue,d.`device_code` AS
    	deviceCode,CEIL(d.`tag_value`) AS tagCode
    	FROM
    	pr_scada_data d
    	WHERE
    	d.device_code = 'N53A295'
    	AND d.tag_name LIKE '%出口压力'
    	AND SUBSTRING(d.`timestamp`,1,11) = (SELECT SUBSTRING(m.`timestamp`,1,11)
    	AS TIMESTAMP FROM (SELECT MAX(TIMESTAMP) AS TIMESTAMP FROM
    	pr_scada_data WHERE device_code = 'N53A295') m)
    	ORDER BY d.`timestamp`

    	SELECT MAX(m.tagValue) AS tagValue FROM(SELECT MIN(b.`timestamp`) AS TIMESTAMP,CEIL(b.`tag_value`) AS tagValue
    	FROM
    	(SELECT
    	DISTINCT d.timestamp,d.`tag_value`,d.`device_code`
    	FROM
    	pr_scada_data d
    	WHERE
    	d.device_code = 'N53A295'
    	AND d.tag_name LIKE '%出口压力'
    	AND SUBSTRING(d.`timestamp`,1,11) = (SELECT SUBSTRING(m.`timestamp`,1,11)
    	AS TIMESTAMP FROM (SELECT MAX(TIMESTAMP) AS TIMESTAMP FROM
    	pr_scada_data WHERE device_code = 'N53A295') m)
    	ORDER BY d.`timestamp` DESC)
    	b GROUP BY SUBSTRING(b.`timestamp`,12,2)) m
    	public Map<String, List<String>> getRadarChartData(String deviceCode)
    	{
    		Map<String, List<String>> maps = new HashMap<String, List<String>>();
    		//统计整点的最大数据
    		String radarCeilTime = prPreStationMapper.getRadarCeilTime(deviceCode);
    		//数据库已有的真实的数据
    		List<ScadaVO> radarRecordChartName = prPreStationMapper.getRadarRecordChartName(deviceCode);
    		if(StringUtil.isEmpty(radarCeilTime))
    		{
    			return null;
    		}
    		if(CollectionUtils.isEmpty(radarRecordChartName)) {
    			return null;
    		}
    		String radarMaxTime = prPreStationMapper.getRadarMaxTiem(deviceCode);
    
    		String[] dateString = {radarMaxTime+"00:00",radarMaxTime+"23:00",radarMaxTime+"22:00",radarMaxTime+"21:00",radarMaxTime+"20:00",radarMaxTime+"19:00",radarMaxTime+"18:00",radarMaxTime+"17:00",radarMaxTime+"16:00",radarMaxTime+"15:00",radarMaxTime+"14:00",radarMaxTime+"13:00",radarMaxTime+"12:00",radarMaxTime+"11:00",radarMaxTime+"10:00",radarMaxTime+"09:00",radarMaxTime+"08:00",radarMaxTime+"07:00",radarMaxTime+"06:00",radarMaxTime+"05:00",radarMaxTime+"04:00",radarMaxTime+"03:00",radarMaxTime+"02:00",radarMaxTime+"01:00"};
    		
    		Map<String, Object> radarData = new HashMap<String,Object>(1);
    
    		//设置整点默认值,以最接近整点的数据最大的整数值设置,如果没有当前整点,则统一默认设置其他整点
    	
    			for(int i=0;i<dateString.length;i++)
    			{
    				radarData.put(dateString[i], radarCeilTime);
    			}
    
    		//查询真实数据
    		for(ScadaVO sc:radarRecordChartName)
    		{
    			radarData.put(sc.getTimestamp().substring(0, 16), sc.getTagValue());	
    		}
    		
    	      Map<String, Object> map = new TreeMap<String, Object>(
    	                new Comparator<String>() {
    	                    public int compare(String obj1, String obj2) {
    	                        // 降序排序
    	                        return obj2.compareTo(obj1);
    	                    }
    	                });
    	              for (Map.Entry<String, Object> entry : radarData.entrySet()) {
    	            	  map.put(entry.getKey(), entry.getValue());
                       }
    	              
    	      //map转为list,否则前台获取object 通过for in获取的数据是无序的
    	      List<String> listKey = new ArrayList<String>();
    	      List<String> listValue = new ArrayList<String>();
    	      List<String> dataKey = new ArrayList<String>();
    			
    		  //echarts顺时针展示
    	      String zeroTime = radarMaxTime+"00:00";
    	      Object firstMap = map.get(zeroTime);
    	      listKey.add(zeroTime);
    	      listValue.add(String.valueOf(firstMap));
    		  if(!radarCeilTime.equals(String.valueOf(map.get(zeroTime)))) {
    			  dataKey.add(String.valueOf(firstMap));
    	       }else {
    	    	   dataKey.add("");
    	       }
    	      Iterator<String> it = map.keySet().iterator();
    	       while (it.hasNext()) {
    	       String key = it.next().toString();
    	       if(!zeroTime.equals(key)) {
    		       listKey.add(key);
    		       listValue.add(radarCeilTime);
    		       if(!radarCeilTime.equals(String.valueOf(map.get(key)))) {
    		    	   dataKey.add(String.valueOf(map.get(key)));
    		       }else {
    		    	   dataKey.add("");
    		       }
    	        }
    	       }
    	       
    	       maps.put("textlist", listKey);
    	       maps.put("maxlist", listValue);
    	       maps.put("datalist", dataKey);
    		   return maps;
    	}

    	showRadarChart:function(deviceCode){
    		debugger;
    		var names = ["0:00","1:23","2:22","3:21","4:20","5:19","6:18","7:17","8:16","9:15","10:14","11:13","12:12","13:11","14:10","15:09","16:08","17:07","18:06","19:05","20:04","21:03","22:02","23:01"];
    		var url = CONTEXT_PATH +"/cusviews/dev/getRadarChartName";
    		var param = {
    				deviceCode:deviceCode
    		}
    		var retData = $.getData(url,param)
    		if(1000!=retData.status){
    			return;
    		}
    		var data = retData.data;
    		if(null==data){
    			return;
    		}
    		
    		var rlt = {
    				"data" : []
    			};
    		var rltdata = [];
    		var dataList = new Array();
    		
    		$.each(data.textlist,function(j,k){
    			let obj = {};
    			obj.text = k;
    			obj.max = data.maxlist[j];
    			rlt.data.push(obj);
    		})
    
    		var myChart = echarts.init(document.getElementById("radarChart"));
    		var option = {
    			    title : {
    			        text: '出口压力',
    			        subtext: ''
    			    },
    			    tooltip : {
    			       /* trigger: 'axis',*/
    			    	extraCssText:'width:120px;height:80px;',
    			    	textStyle:'8'
    			    },
    			    legend: {
    			        orient : 'vertical',
    			        x : 'right',
    			        y : 'bottom',
    			        data:[{
    			            name: '出口压力 ',
    			            // 强制设置图形为圆。
    			            icon: 'circle',
    			            // 设置文本为红色
    			            textStyle: {
    			                color: '#FF0000'
    			            }
    			        }]
    			    },
    			    toolbox: {
    			        show : true,
    			        feature : {
    			            mark : {show: true},
    			            dataView : {show: true, readOnly: false},
    			            restore : {show: true},
    			            saveAsImage : {show: true}
    			        }
    			    },
    			    polar : [
    			       {   
    	                   name:{
                               show: true, // 是否显示工艺等文字
                               formatter: null, // 工艺等文字的显示形式
                               textStyle: {
                                 color:'#a3a5b6' // 工艺等文字颜色
                               }
                            },
    			           indicator : rlt.data
    			        	   /*[
    			               { text: 0, max: 6000},
    			               { text: 5, max: 16000},
    			               { text: 4, max: 30000},
    			               { text: 3, max: 38000},
    			               { text: 2, max: 52000},
    			               { text: 1, max: 25000}
    			            ]*/
    			        }
    			    ],
    			    calculable : true,
    			    series : [
    			        {
    			            name: '出口压力 ',
    			            type: 'radar',
    			            data : [
    			                 {
    			                   /* value : [5000, 14000, 28000, 31000, 42000, 21000],*/
    			                	 value : data.datalist,
    			                    name : '出口压力',
    			                    itemStyle: {
    			                        normal: {
    			                            color: '#FF0000',
    			                            lineStyle: {
    			                                color: '#FF0000',
    			                            }
    			                        },
    			                    },
    			                }
    			            ]
    			        }
    			    ]
    			};
    		myChart.setOption(option);

    Map<String,List<ScadaVO>>

    	public Map<String,List<ScadaVO>> getScadaAirDataList()
    	{
    		List<ScadaVO> list = scadaMapper.getScadaAirDataList();
    		if(CollectionUtils.isEmpty(list))
    		{
    			return null;
    		}
    		Map<String,List<ScadaVO>> result = new HashMap<String,List<ScadaVO>>(1);
    		for(ScadaVO scada:list)
    		{
    			if(result.containsKey(scada.getTagCode()))
    			{
    				result.get(scada.getTagCode()).add(scada);
    			}
    			else
    			{
    				List<ScadaVO> dataList = new ArrayList<ScadaVO>(1);
    				dataList.add(scada);
    				result.put(scada.getTagCode(), dataList);
    			}
    			
    		}
    		return result;
    	}

    	var result = {};
    	var url = CONTEXT_PATH + '/cusviews/scada/getScadaAirData';
    	var retData = $.getData(url,null);
    	if(1000 != retData.status){
    		return;
    	}
    	var data = retData.data;
    	if(null == data || undefined == data){
    		return;
    	}
    	function getGasList(tagCode){
    		if($.isEmptyArray(data[tagCode])){
    			return;
    		}
    		var gasList = new Array();
    		for(var i=0;i<data[tagCode].length;i++){
    			debugger;
    			var obj = new Object();
    			obj.name = data[tagCode][i].timestamp;
    			var arr =  new Array();
    			arr.push(data[tagCode][i].timestamp)
    			arr.push(data[tagCode][i].tagValue);
    		    obj.value = arr;
    		    gasList.push(obj);
    		}
    		return gasList;
    	}
    	result["xijiaoList"] = getGasList("FRQA001A.PV");
    	result["ciquList"] = getGasList("FRQB003A.PV");

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • 我们可以将数组作为参数,传入到函数中,其实就像我们main函数中 public void main(String [] args){};就是用数组作为函数参数; 又如, [java] view plain copy public class ArrayPar { ...
  • java函数返回类型

    千次阅读 2016-03-28 15:26:16
    Java有8种基本类型,均可以作为函数的返回类型,除此之外还可以返回特殊类型——类。如下面的代码: public static ClassA getObject(){  ClassA newObject = new ClassA();  newObject.value+= 10;  
  • java函数--返回多个值

    万次阅读 2017-10-07 17:21:50
    在开发过程中,经常会有这种情况,就是一个函数需要返回多个值,这是一个问题!! 网上这个问题的解决方法: 1、【使用集合类】使用map返回值;这个方法问题是,你并不知道如何返回值的key是什么,只能通过doc或者...
  • 下面是我遇到的问题: ![图片说明](https://img-ask.csdn.net/upload/201505/25/1432536028_829378.png)
  • 我们可以将数组作为参数,传入到函数中,其实就像我们main函数中 public void mian
  • Java函数不接受返回值调用

    千次阅读 2013-10-23 15:03:44
    public static void main(String[] args) { test(); System.out.println(s); } public static String s = null; public static String test(){ s = "kk";...这里的test函数虽然有返
  • Java数组作为函数返回值

    千次阅读 2019-04-23 14:48:07
    import java.util.List; public class Wai { public static void main(String[] args) { int[] ai=wan(new int[] {1,2,3,4,5,6,7}); for(int s:ai) { System.out.println(s); } } public static int[] ...
  • 2.如果接下来我在main函数中去调用的时候:(会出现一些异常) 看到了吧,就是这种诡异的现象出来了,所以大家记好了:return 语句不可返回指向“栈内存” (这是禁止的,也是没有任何意义的哦!各位亲们...
  • Java 返回值为空和void

    千次阅读 2018-09-19 17:42:29
    Java 返回值为空和void class Extends { public static void main(String[] args) { //System.out.println(“Hello World!”); Zi z = new Zi(); z.Fu(); z.Zi(); } } class Fu{ static { System.out....
  • 方法的返回值:(有两种情况) 1、如果方法就有返回值,方法中必须使用关键字return返回该值,返回类型为该方法的类型 2、 如果方法没有返回值,返回类型为void。 示例代码: package com.jredu.ch09; import java....
  • Java方法返回值前面的是什么?

    千次阅读 2018-08-26 18:26:19
    Java方法返回值前面的&amp;amp;lt;T&amp;amp;gt;是什么? 它的作用是“定义泛型” 一段简单的代码 class Show&amp;amp;lt;T&amp;amp;gt; { public void print1(T t) { System.out.println...
  • 输出返回值

    2018-08-08 19:05:47
    1.比较语句返回值的输出  bollean b = p2.compare(p1);  System.out.println(b); 在学习过程中遇到这个问题,借此分享 2.直接把函数调用的代码放到打印语句中...
  • 看下述例子 public class myTest<T> { private <T> T method1(List<T> data) { ...// 输入的T类型可以随意 } private T method2(List<T> data) { ...// 输入的T类型受到主类......
  • JAVA 方法的返回值类型解析

    千次阅读 2020-02-02 16:20:36
    方法的返回值类型解析 1.基本类型 2.数组 3.字符串 4.自定义的类 public class MethodReturn { public static void main(String[] args) { int result1= method1(); System.out.println(result1);//100 ...
  • 函数返回值原理

    千次阅读 2018-07-05 17:02:02
    举例说明int func(a1, b1) { int max1; if (a1 &gt; b1) max1 = a1; else max1 = b1; return max1; } void main() { int a = 2; int b = 3; int max = func(a, b); ...
  • 刚看了下c++,他的main函数必须返回int值,用来作为一个状态指示器,java提供了类似的功能没啊,void作为返回值什么用意呢? 在Java中,main()方法是Java应用程序的入口方法,也就是说,程序在运行的时候,第一个...

空空如也

1 2 3 4 5 ... 20
收藏数 296,343
精华内容 118,537
关键字:

java函数返回值

java 订阅