пары значений arraylists в java

Question

У меня есть эта проблема, что я не знаю, как подойти. У меня есть два списка массива, один, который содержит строку, а другой, содержащий целые числа, например:

* Utah   5 
* Nevada   6 
* California 12 
* Oregon  8 
* Utah   9 
* California 10 
* Nevada  4 
* Nevada  4 
* Oregon  17 
* California 6 

и мне нужно, чтобы получить результат, как это в списках массива: Юта [5, 9] Невада [6 , 4, 4] California [12, 10, 6].

Я честно не знаю, как подойти к этому, и я ищу совет о том, как это сделать.

Мне было предложено использовать arraylist Arraylist, и это то, что у меня есть до сих пор.

int i=0; 
     ArrayList<ArrayList<Integer>> values = new ArrayList<ArrayList<Integer>>(); 

     while (i<categories.size()) 
     { 
      String cat=categories.get(i); 
      i++; 
      for (int r = 0; r < column1.size();r++) { 
       if(column1.get(r)==cat) 
       { 
        int value = column2.get(r); 
        ArrayList<Integer> val=new ArrayList<Integer>(); 
        val.add(value); 
        values.add(val); 
       } 
     } 

Column1 = список состояний, column2 = список целых чисел и категории = список категорий.

Моя проблема в том, что цикл for, кажется, просто добавляет один и тот же массив снова и снова, пока цикл while не будет выполнен. Какие-либо предложения?

Answer 1

Вы можете решить эту проблему, используя следующий подход:

List<String> states = Arrays.asList(
     "Utah", "Nevada", "California", "Oregon", "Utah", 
     "California", "Nevada", "Nevada", "Oregon", "California" 
    ); 

List<Integer> values = Arrays.asList(5, 6, 12, 8, 9, 10, 4, 4, 17, 6); 


Map<String, List<Integer>> resultMap =HashMap<String, Arraylist<>>(); 

for(int i = 0; i < states.size(); i++) 
    { 
      if(resultMap.get(states.get(i))!=null){ 
       resultMap.get(states.get(i)).add(values.get(i)); 
      }else{ 
      List<Integer> valuelist = new ArrayList<>(); 
      valuelist.add(values.get(i)); 
      resultMap.put(states.get(i),valuelist); 
      } 
    } 

resultMap содержит ваш необходимый ответ.

Answer 2

Это кажется как вопрос домашнего задания уровня, и это довольно просто решить, используя списки Integer в Map шпонкой по String. Я отвечаю, чтобы игры с продемонстрировать некоторые из новых Java 8 функции:

List<String> states = Arrays.asList(
     "Utah", "Nevada", "California", "Oregon", "Utah", 
     "California", "Nevada", "Nevada", "Oregon", "California" 
    ); 
    List<Integer> values = Arrays.asList(
     5, 6, 12, 8, 9, 
     10, 4, 4, 17, 6 
    ); 
    assert states.size() == values.size(); 

    Map<String, List<Integer>> collated = new LinkedHashMap<>(); 
    for (int i = 0, len = states.size(); i < len; i++) { 
     String state = states.get(i); 
     Integer value = values.get(i); 
     collated.computeIfAbsent(state, x -> new ArrayList<>()).add(value); 
    } 
    collated.forEach((k,v) -> System.out.printf("%s %s%n", k, v)); 

Выход:

Utah [5, 9] 
Nevada [6, 4, 4] 
California [12, 10, 6] 
Oregon [8, 17] 

Answer 3

Вот еще один способ, чтобы вычислить это с Java 8 функций, но с потоками на этот раз. (Строительные леса от @William Price's answer)

List<String> states = Arrays.asList(
    "Utah", "Nevada", "California", "Oregon", "Utah", 
    "California", "Nevada", "Nevada", "Oregon", "California" 
); 
List<Integer> values = Arrays.asList(5, 6, 12, 8, 9, 10, 4, 4, 17, 6); 
assert states.size() == values.size(); 

Map<String, List<Integer>> collated = IntStream.range(0, states.size()).boxed().collect(
    Collectors.groupingBy(states::get, LinkedHashMap::new, 
     Collectors.mapping(values::get, Collectors.toList()))); 

collated.forEach((k,v) -> System.out.printf("%s %s%n", k, v)); 

Работа с несколькими источниками входного сигнала может быть неудобны в потоках, но с использованием потока индексов идеально подходит для этого «соответствующего списку» случае. groupingBy классифицирует индексы по их значению в списке states, mapping сопоставляет индексы с их значением в списке values и toList, ну и собирает их в список. Использование LinkedHashMap сохраняет порядок вставки.