public void extract(JSONPath path, DefaultJSONParser parser, Context context) {
            JSONLexerBase lexer = (JSONLexerBase) parser.lexer;

            if (deep && context.object == null) {
                context.object = new JSONArray();
            }

            if (lexer.token() == JSONToken.LBRACKET) {
                if ("*".equals(propertyName)) {
                    return;
                }

                lexer.nextToken();
                JSONArray array;

                if (deep) {
                    array =(JSONArray) context.object;
                } else {
                    array = new JSONArray();
                }
                for (;;) {
                    switch (lexer.token()) {
                        case JSONToken.LBRACE: {
                            if (deep) {
                                extract(path, parser, context);
                                break;
                            }
                            int matchStat = lexer.seekObjectToField(propertyNameHash, deep);
                            if (matchStat == JSONLexer.VALUE) {
                                Object value;
                                switch (lexer.token()) {
                                    case JSONToken.LITERAL_INT:
                                        value = lexer.integerValue();
                                        lexer.nextToken();
                                        break;
                                    case JSONToken.LITERAL_STRING:
                                        value = lexer.stringVal();
                                        lexer.nextToken();
                                        break;
                                    default:
                                        value = parser.parse();
                                        break;
                                }

                                array.add(value);
                                if (lexer.token() == JSONToken.RBRACE) {
                                    lexer.nextToken();
                                    continue;
                                } else {
                                    lexer.skipObject(false);
                                }
                            } else if (matchStat == JSONLexer.NOT_MATCH) {
                                continue;
                            } else {
                                if (deep) {
                                    throw new UnsupportedOperationException(lexer.info());
                                } else {
                                    lexer.skipObject(false);
                                }
                            }
                            break;
                        }
                        case JSONToken.LBRACKET:
                            if (deep) {
                                extract(path, parser, context);
                            } else {
                                lexer.skipObject(false);
                            }
                            break;
                        case JSONToken.LITERAL_STRING:
                        case JSONToken.LITERAL_INT:
                        case JSONToken.LITERAL_FLOAT:
                        case JSONToken.LITERAL_ISO8601_DATE:
                        case JSONToken.TRUE:
                        case JSONToken.FALSE:
                        case JSONToken.NULL:
                            lexer.nextToken();
                            break;
                        default:
                            break;
                    }

                    if (lexer.token() == JSONToken.RBRACKET) {
                        lexer.nextToken();
                        break;
                    } else if (lexer.token() == JSONToken.COMMA) {
                        lexer.nextToken();
                        continue;
                    } else {
                        throw new JSONException("illegal json : " + lexer.info());
                    }
                }

                if (!deep) {
                    if (array.size() > 0) {
                        context.object = array;
                    }
                }
                return;
            }

            if (!deep) {
                int matchStat = lexer.seekObjectToField(propertyNameHash, deep);
                if (matchStat == JSONLexer.VALUE) {
                    if (context.eval) {
                        Object value;
                        switch (lexer.token()) {
                            case JSONToken.LITERAL_INT:
                                value = lexer.integerValue();
                                lexer.nextToken(JSONToken.COMMA);
                                break;
                            case JSONToken.LITERAL_FLOAT:
                                value = lexer.decimalValue();
                                lexer.nextToken(JSONToken.COMMA);
                                break;
                            case JSONToken.LITERAL_STRING:
                                value = lexer.stringVal();
                                lexer.nextToken(JSONToken.COMMA);
                                break;
                            default:
                                value = parser.parse();
                                break;
                        }

                        if (context.eval) {
                            context.object = value;
                        }
                    }
                }
                return;
            }

            // deep
            for (;;) {
                int matchStat = lexer.seekObjectToField(propertyNameHash, deep);
                if (matchStat == JSONLexer.NOT_MATCH) {
                    break;
                }

                if (matchStat == JSONLexer.VALUE) {
                    if (context.eval) {
                        Object value;
                        switch (lexer.token()) {
                            case JSONToken.LITERAL_INT:
                                value = lexer.integerValue();
                                lexer.nextToken(JSONToken.COMMA);
                                break;
                            case JSONToken.LITERAL_FLOAT:
                                value = lexer.decimalValue();
                                lexer.nextToken(JSONToken.COMMA);
                                break;
                            case JSONToken.LITERAL_STRING:
                                value = lexer.stringVal();
                                lexer.nextToken(JSONToken.COMMA);
                                break;
                            default:
                                value = parser.parse();
                                break;
                        }

                        if (context.eval) {
                            if (context.object instanceof List) {
                                List list = (List) context.object;
                                if (list.size() == 0 && value instanceof List) {
                                    context.object = value;
                                } else {
                                    list.add(value);
                                }
                            } else {
                                context.object = value;
                            }
                        }
                    }
                } else if (matchStat == JSONLexer.OBJECT || matchStat == JSONLexer.ARRAY) {
                    extract(path, parser, context);
                }
            }
        }
@since 1.2.51
@param json
@param path
@return
src/main/java/com/alibaba/fastjson/JSONPath.java