json对象的值为数组，怎么获取数组某项的值（注意不是json数组）

package com;

import javautilList;

import comKensouPerson;

import comalibabafastjsonJSON;

public class Yuma

{

public static void main(String[] args)

{

String result =

        "{\"data1\":[{\"name\":\"aa\",\"age\":\"12\"},{\"name\":\"bb\",\"age\":\"13\"}],\"data2\":{\"nowpage\":1,\"pagesize\":2}}";

Kensou ps = JSONparseObject(result, Kensouclass);

Systemoutprintln(ps);

List<Person> data1 = psgetData1();

for(int i = 0; i < data1size(); i++)

{

Person p = data1get(i);

Systemoutprintln(p);

}

Person data2 = psgetData2();

Systemoutprintln(data2);

}

}

/

  模型对象不需要构造函数， 至少只需要setter方法<br>

  Person类可以是内嵌类，也可以是外部类 <br>

  Kensou类只能是外部类<br>

  集合类可以是数组或者List类型<br>

  <p>

  使用的是<font color="red">fastjson-1136jar</font>

 /

class Kensou

{

private List<Person> data1;

private Person data2;

public List<Person> getData1()

{

return data1;

}

public void setData1(List<Person> data1)

{

thisdata1 = data1;

}

public Person getData2()

{

return data2;

}

public void setData2(Person data2)

{

thisdata2 = data2;

}

@Override

public String toString()

{

return Stringformat("Kensou [data1=%s, data2=%s]", data1, data2);

}

class Person

{

private String name;

private int age;

private int nowpage;

private int pagesize;

public String getName()

{

return name;

}

public void setName(String name)

{

thisname = name;

}

public int getAge()

{

return age;

}

public void setAge(int age)

{

thisage = age;

}

public int getNowpage()

{

return nowpage;

}

public void setNowpage(int nowpage)

{

thisnowpage = nowpage;

}

public int getPagesize()

{

return pagesize;

}

public void setPagesize(int pagesize)

{

thispagesize = pagesize;

}

@Override

public String toString()

{

return Stringformat("Person [name=%s, age=%s, nowpage=%s, pagesize=%s]", name, age, nowpage, pagesize);

}

}

}

C语言调用Java，还有Java调用C，都使用到JNI技术，C语言调用需要创建Java虚拟机，可查看函数JNI_CreateJavaVM、DestroyJavaVM的资料，函数声明在jnih头文件（JDK）中。需注意参数类型转换，两种语言的参数类型和传递有讲究，有多个返回的话，必须传递对象参数进行处理。

1首先需要写三个类，这个类和json中对象的数据结构应该是对应的，这里的例子可能忽略了部分属性和数据类型，仅供参考：

//Json数据的对象结构

public class MyJson

{

public List<MyTreeNodeBean> beanList

}

//树形结构中的对象结构

public class MyBean

{

public string id

public string title

public string note

public MyImage image

public string maxid

public string fold

public string putright

public List<MyTreeNodeBean> children

public MyBean()

{

}

}

//对象里面Image的结构

public class MyImage

{

public string url

public string border

public string height

public string width

}

2因为json是树形结构的数据，所以需要递归遍历去寻找对应ID的对象

//这个类负责按照ID寻找对象

public class MyHelper

{

//FindById函数的重载函数，用来第一次调用

public static MyBean FindById(string id, string jsonString)

{

return FindById(id, jsonString, null);

}

//FindById递归寻找函数

public static MyBean FindById(string id, string jsonString, List<MyBean> beanList)

{

if (beanList == null) {

//第一次调用的时候，寻找的列表是最高层的根底下的对象列表

//将json数据转换成C#对应类型(用了NewtonsoftJson)

MyJson json = JavaScriptConvertDeserializeObject<MyJson>(jsonString);

beanList = jsonbeanList;

}

//遍历对象列表，寻找对应ID的对象

MyBean returnBean = null;

foreach (MyBean bean in beanList) {

if (beanid == id) {

//找到了

returnBean = bean;

} else {

//递归寻找：

//如果不是，就寻找此对象的children列表

returnBean = FindById(id, jsonString, beanchildren);

}

//如果找到，就跳出寻找

if (returnBean != null) {

break;

}

}

return returnBean;

}

}

3使用实例：

//假设json的字符串在变量jsonString中

MyBean bean = MyHelperFindById("33", jsonString);

if (bean != null) {

//使用查找出来的bean

}

写在最后：

以上代码仅供参考，没有经过编译测试、有可能存在书写错误。但是逻辑清晰、没有任何冗余内容。请楼主阅读以后自己在理解的基础上进行修改、改进再使用。

另外楼主如果想给分就请直接给，请不要马马虎虎把大家的回答投票，比较反感，最后祝你早日搞定这个问题~~~

#include <jnih>   

#include "com_test_Testh"  

#include <stdioh>   

#include <stdlibh>   

#include <stringsh>   

//获取字符串   

JNIEXPORT void JNICALL Java_com_test_Test_sayHello(JNIEnv  env, jobject obj,   

  jstring s) {   

 char  str = (char ) (env)->GetStringUTFChars(env, s, 0);   

 printf("\n c-string: hello - %s", str);   

}   

//获取，返回int   

JNIEXPORT jint JNICALL Java_com_test_Test_add(JNIEnv  env, jobject obj,   

  jint a, jint b) {   

 int i = a;   

 int j = b;   

 printf("\n c-int: %d - %d", i, j);   

 char str[256];   

 sprintf(str, "%d", i + j);   

 return (jint) i + j;   

}   

//获取，返回float   

JNIEXPORT jfloat JNICALL Java_com_test_Test_getFloat(JNIEnv  env, jobject obj,   

  jfloat f) {   

 float fl = f;   

 printf("\n c-float: %3f", fl);   

 fl = 200555;   

 return (jfloat) fl;   

}   

//获取，返回 double   

JNIEXPORT jdouble JNICALL Java_com_test_Test_getDouble(JNIEnv  env,   

  jobject obj, jdouble dou) {   

 double d = dou;   

 printf("\n c-double: %3f", d);   

 d = 80088;   

 return (jdouble) d;   

}   

//获取，返回boolean   

JNIEXPORT jboolean JNICALL Java_com_test_Test_getBoolean(JNIEnv  env,   

  jobject obj, jboolean bool) {   

 unsigned char b = bool;   

 printf("\n c-boolean: %lu  ", b);   

 if (b) {   

  printf("true");   

 } else {   

  printf("false");   

 }   

 b = 1;   

 return (jboolean) b;   

}   

//获取，返回 string   

JNIEXPORT jstring JNICALL Java_com_test_Test_getString(JNIEnv  env,   

  jobject obj, jstring s) {   

 char  st = (char ) (env)->GetStringUTFChars(env, s, 0);   

 printf("\n c-string:  %s", st);   

 char  str = "hello wang wu!";   

 jstring rtn;   

 rtn = (env)->NewStringUTF(env, str);   

 return rtn;   

}   

//获取，返回 string []   

JNIEXPORT jobjectArray JNICALL Java_com_test_Test_getStringArray(JNIEnv  env,   

  jobject obj, jobjectArray arr) {   

 int len = (env)->GetArrayLength(env, arr);   

 printf("\n c-stringArray :");   

 int i = 0;   

 for (i = 0; i < len; i++) {   

  jobject obj = (env)->GetObjectArrayElement(env, arr, i);   

  jstring str = (jstring) obj;   

  const char  szStr = (env)->GetStringUTFChars(env, str, 0);   

  printf(" %d-%s ", i, szStr);   

  (env)->ReleaseStringChars(env, str, szStr);   

 }   

 //-----返回----   

 jstring str;   

 jobjectArray args = 0;   

 jsize size = 5;   

 char sa[] = { "Hello,", "world!", "zhang", "san", "yuang" };   

 int j = 0;   

 jclass objClass = (env)->FindClass(env, "java/lang/String");   

 args = (env)->NewObjectArray(env, size, objClass, 0);   

 for (j = 0; j < size; j++) {   

  str = (env)->NewStringUTF(env, sa[j]);   

  (env)->SetObjectArrayElement(env, args, j, str);   

 }   

 return args;   

}   

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

下面是Testjava   

package comtest;   

public class Test {   

 private native void sayHello(String str);   

 private native int add(int a, int b);   

 private native float getFloat(float f);   

 private native double getDouble(double d);   

 private native boolean getBoolean(boolean b);   

 private native String getString(String str);   

 private native String[] getStringArray(String[] sa);   

 static {   

  SystemloadLibrary("Test");   

 }   

 public static void main(String[] args) {   

  Test test = new Test();   

  testsayHello("zhang san");   

  Systemoutprintln("int     --> " + testadd(10, 20));   

  Systemoutprintln("float   --> " + testgetFloat((float) 20123));   

  Systemoutprintln("double  --> " + testgetDouble(100369));   

  Systemoutprintln("boolean --> " + testgetBoolean(true));   

  Systemoutprintln("string  --> " + testgetString("wang Wu"));   

  String[] ss = { "hello", "-", "zhang", "san" };   

  Object[] obj = testgetStringArray(ss);   

  Systemoutprint("string[]-->  ");   

  for (Object object : obj) {   

   Systemoutprint(object + " ");   

  }   

 }   

}

1、接口定义确定MVCGET或者POST式

由于我整Web API平台基于MVC基础进行API发整Web API接口定义候般需要显示声明接口[>

对于本地函数

JNIEXPORT void JNICALL Java_video1_TestNative_sayHello(JNIEnv env, jobject obj)

{

cout<<"Hello Native Test !"<<endl;

}

JNIEnv类型代表Java环境。通过这个JNIEnv指针，就可以对Java端的代码进行 *** 作。如，创建Java类得对象，调用Java对象的方法，获取Java对象的属性等。

JNIEnv的指针会被JNI传送到本地方法的实现函数中来对Java端的代码进行 *** 作

JNIEnv类中的函数：

NewObject/NewString/New<TYPE>Array ：new新对象

Get/Set<TYPE>Field：获取属性

Get/SetStatic<TYPE>Field ：获取静态属性

Call<TYPE>Method/CallStatic<TYPE>Method

以上就是关于json对象的值为数组，怎么获取数组某项的值（注意不是json数组）全部的内容，包括:json对象的值为数组，怎么获取数组某项的值（注意不是json数组）、如何在c++中调用java代码、C# 用Newtonsoft.Json 修改 添加 JSON等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！