Десериализация массива

@Override
    public List<String>deserialize(JsonParser jsonParser, DeserializationContext deserializationContext)
            throws IOException {
        JsonNode node = jsonParser.getCodec().readTree(jsonParser);
        if(node.get("users")!=null)
            node = node.get("users");
 
        return node.get("names") ?????;
    }

 String s = "{ \"users\":{\n" +
                "            \"names\": [\"name1\", \"name2\"]\n" +
                " \n" +
                "}\n" +
                "        }";
        JsonFactory factory = new JsonFactory();
        JsonParser parser = factory.createParser(s);
 
        while (!parser.isClosed()) {
            JsonToken jsonToken = parser.nextToken();
            if (JsonToken.START_ARRAY.equals(jsonToken)) {
                while (!JsonToken.END_ARRAY.equals(parser.nextToken())){
                    System.out.println(parser.getValueAsString());
                }
            }
        }

ObjectCodec oc = jsonParser.getCodec();
if (oc instanceof ObjectMapper) {
  ObjectReader reader =((ObjectMapper) oc).readerFor(new TypeReference<List<String>>() {});
  List<String> list = reader.readValue(json.findValue("names"));
}

/**
     * можно воспользоваться обжект маппером чтобы велосипед не изобретать
     * у json  есть ясный и понятный формат всё что в фигурных скобках - это объект
     * поля обозначаются так "names":name
     * массивы обозначаются квадратными скобками, итак давайте попробуем создать объект
     * Users и посмотрим что получится
     *

import java.util.ArrayList;
 
public class Users {
 
    public ArrayList<String> getNames() {
        return names;
    }
 
    public void setNames(ArrayList<String> names) {
        this.names = names;
    }
 
    private ArrayList<String> names = new ArrayList<>();
}

 @Test
    public void testJson() throws IOException {
        Users users = new Users();
        users.getNames().add("names1");
        users.getNames().add("names2");
        //выведем в консоль для наглядности
        System.out.println(new ObjectMapper().writeValueAsString(users));
        //оттестируем
        assertThat(new ObjectMapper().writeValueAsString(users), is("{\"names\":[\"names1\",\"names2\"]}"));
        //оттестируем в обратном направлении создадим объект из стринга
        Users usertest = new ObjectMapper().readValue("{\"names\":[\"names1\",\"names2\"]}", Users.class);
        assertThat(usertest.getNames().get(0), is("names1"));
        assertThat(usertest.getNames().get(1), is("names2"));
    }

 /**
     * и так мы разобрались как запихать массив {"names":["names1","names2"]} в объект
     * и как потом обратиться к элементам
     * но у нас же ещё есть users? {"users":{"names": ["name1", "name2"]}}
     * тут вообще проще некуда создаём класс и помещаем объект в юзерс в поле класса назавём этот класс маппером
     */

public class Maper {
    private Users users;
 
    public Users getUsers() {
        return users;
    }
 
    public void setUsers(Users users) {
        this.users = users;
    }
}

 @Test
    public void maperTest() throws IOException {
        Maper users1 = new ObjectMapper().readValue("{\"users\":{\"names\": [\"name1\", \"name2\"]" + "}" + "}", Maper.class);
        System.out.println(users1.getUsers().getNames()); //т.е. когда мы сказали getNames  мы дёнуи список [name1, name2]
        assertThat(users1.getUsers().getNames().toString(), is("[name1, name2]"));
    }

 /**
     * если ты спросишь что делать если у тебя большой подобный список через запятуюнапример:
     * [{"users":{"names":["name1","name2"]}},{"users":{"names":["name1","name2"]}}] и т.д.
     * то можно его также запихать
     */

   @Test
    public void maperTestList() throws IOException {
        Maper[] maperList = new ObjectMapper().readValue("[{\"users\":{\"names\":[\"name1\",\"name2\"]}},{\"users\":{\"names\":[\"name3\",\"name4\"]}}]", Maper[].class);
        System.out.println(maperList[0].getUsers().getNames()); //т.е. дёрнули имена первого пользователя
        System.out.println(maperList[1].getUsers().getNames()); //т.е. дёрнули имена второго пользователя
        assertThat(maperList[0].getUsers().getNames().toString(), is("[name1, name2]"));
        assertThat(maperList[1].getUsers().getNames().toString(), is("[name3, name4]"));
    }

/**
     * подводим итог: создав два простых класса описанных выше
     * мы можем получить массив имён в одну строчку
     */
    @Test
    public void refMapper() throws IOException {
        System.out.println(new ObjectMapper().readValue("{\"users\":{\"names\":[\"name1\",\"name2\"]}}", Maper.class).getUsers().getNames());
    }

HashMap<String, String> mapa = new ObjectMapper().readValue("{\"@type\":\"type\"}", HashMap.class);
        System.out.println(mapa);

  //или также без создания класов из твоего первого вороса можо было также воспользоваться мапой, 
        //но я думаю было бы не так понятно 
        HashMap<String, HashMap<String, ArrayList<String>>> mapa2 = new ObjectMapper().readValue("{\"users\":{\"names\":[\"name1\",\"name2\"]}}", HashMap.class);
        System.out.println(mapa2);
        //чисто имена
        System.out.println(mapa2.get("users").get("names"));

public List<String>deserialize(JsonParser jsonParser, DeserializationContext deserializationContext)
    throws IOException {
       List<String> nameList = new ArrayList<>();
       JsonNode tree = jsonParser.getCodec().readTree(jsonParser);
       if(tree.get("users")!=null) {
         JsonNode users = tree.get("users");
         ArrayNode names = (ArrayNode) users.get("names");
         for(JsonNode node : names) {
            nameList.add(node.toString());
         }
       }
       return nameList;
  }