Integer[] w ArrayList - problem z odczytem

Hej,
Funkcja findPairs(List<Integer>integers,Integer sum) sprawdza warunek A+B=C i gdy jest spełniony zapisuje pary integerow A i B do tablicy typu Integer[], a nastepnie tablice do listy, którą ta funkcja zwraca. Niestety nie potrafię odczytac ani dostać się do zapisanych par integerow w tej liscie. Czy ktoś pomoże?

public class Main {
  
  public static void main(String[] args) {
      List<Integer>list=new ArrayList<>(20);
      list=generateArrayListOfIntegers(-20,20,50);
      List<Integer[]> listofPairs=new ArrayList<>();
      //for(Integer i:list){
      //    System.out.println(i);
     // }
      //System.out.println(findPairs(list, 10)); nie dziala
      listofPairs=findPairs(list,10);
  
  
     for( Integer[] pairs : listofPairs) {
        //System.out.println(Arrays.toString(pairs));//pokazuje zle dane
        }
  }
  public static List<Integer> generateArrayListOfIntegers(int minimumValue,int maxValue,int size){
      List<Integer> ListOfIntegers=new ArrayList<>(size);
      Random rand=new Random();
      Integer randomNum;
      for(int i=0;i<size;i++){
          randomNum=minimumValue+rand.nextInt((maxValue-minimumValue)+1);
          ListOfIntegers.add(randomNum);
      }
      return ListOfIntegers;
  }
  public static List<Integer[]> findPairs(List<Integer>integers,Integer sum){
      Integer[]pair=new Integer[2];
     
      List<Integer[]> listOfPairs=new ArrayList<>();
      for(int i=0;i<integers.size();i++){
          if(sum<integers.get(i)){
              continue;
          } else {
              pair[0]=integers.get(i);
              for(int j=i+1;j<integers.size();j++){
                  if(pair[0]+integers.get(j)==sum){
                      pair[1]=integers.get(j);
                      listOfPairs.add(pair);
                      continue;
                  }
              }
          }
      }
      return listOfPairs;
  }
}

Grantuser napisał(a):

     for( Integer[] pairs : listofPairs) {
        //System.out.println(Arrays.toString(pairs));//pokazuje zle dane

"Złe" to znaczy jakie konkretnie?

Grantuser napisał(a):

Na przykład pokazuje 10 linijek tej samej pary, powiedzmy [1,18] a warunek jest A+B=10. Sprawdzilem tez dzialanie tej funkcji, tj zmienilem tym zwracany na void i dodalem sout wenwatrz funkcji i pokazalo prawidlowo.

Używasz i modyfikujesz jeden array, zamiast robić nowy.

Jeśli chcesz mieć 10 elementów w List<Integer[]>, to musisz mieć 10 tablic. Jednak masz tylko jedną, tutaj:

public static List<Integer[]> findPairs(List<Integer>integers,Integer sum){
   Integer[]pair=new Integer[2];

Zadeklaruj i stwórz swój array w miejscu gdzie go używasz, czyli w piętli

public static List<Integer[]> findPairs(List<Integer>integers,Integer sum){
    // Integer[]pair=new Integer[2];  nie tu
   
    List<Integer[]> listOfPairs=new ArrayList<>();
    for(int i=0;i<integers.size();i++){
        if(sum<integers.get(i)){
            continue;
        } else {
            Integer[]pair=new Integer[2];  // <!--------- tutaj
            pair[0]=integers.get(i);
            for(int j=i+1;j<integers.size();j++){
                if(pair[0]+integers.get(j)==sum){
                    pair[1]=integers.get(j);
                    listOfPairs.add(pair);
                    continue;
                }
            }
        }
    }
    return listOfPairs;
}

Grantuser napisał(a):

Cały czas zle pokazuje.

U mnie działa

import java.util.List;
import java.util.ArrayList;
import java.util.Random;
import java.util.Arrays;

public class Main {
  public static void main(String[] args) {
      List<Integer>list = generateArrayListOfIntegers(-20,20,50);

      for( Integer[] pairs : findPairs(list, 10)) {
        System.out.println(Arrays.toString(pairs));//pokazuje zle dane
      }
  }
  
  public static List<Integer> generateArrayListOfIntegers(int minimumValue,int maxValue,int size){
      List<Integer> ListOfIntegers=new ArrayList<>(size);
      Random rand=new Random();
      for(int i=0;i<size;i++){
          Integer randomNum=minimumValue+rand.nextInt((maxValue-minimumValue)+1);
          ListOfIntegers.add(randomNum);
      }
      return ListOfIntegers;
  }
  
  public static List<Integer[]> findPairs(List<Integer>integers,Integer sum){
      List<Integer[]> listOfPairs=new ArrayList<>();
      for(int i=0;i<integers.size();i++){
          if(sum<integers.get(i)){
              continue;
          }     
          Integer[]pair=new Integer[2];
          pair[0]=integers.get(i);
          for (int j=i+1;j<integers.size();j++){
              if (pair[0]+integers.get(j)==sum) {
                  pair[1]=integers.get(j);
                  listOfPairs.add(pair);
                  continue;
              }
          }
        
      }
      return listOfPairs;
  }
}

@Grantuser: A swoją drogą, to zamiast Integer[] do tych par liczb, lepiej zrobić obiekt pod to

public class Pair {
  public final int x, y;

  public Pair(int x, int y) {
    this.x = x;
    this.y = y;
  }
}

i potem

Pair pair = new Pair(12, 4);
pair.x // 12
pair.y // 4

Od nowszej javy możesz też zrobić record.

Cały ten kod jest bez sensu. Tworzysz tam zmienne których nie używasz, nadpisujesz non stop tą samą tablicę. Dramat.

import io.vavr.Tuple;
import io.vavr.Tuple2;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Pary {
    public static List<Integer> generateArrayListOfIntegers(int minimumValue, int maxValue, int size) {
        Random rand = new Random();
        return IntStream.range(0, size)
                .mapToObj(index -> minimumValue + rand.nextInt((maxValue - minimumValue) + 1))
                .collect(Collectors.toList());
    }

    public static void main(String[] args) {
        List<Integer> list = generateArrayListOfIntegers(-20, 20, 50);
        List<Tuple2<Integer, Integer>> listOfPairs = findPairs(list, 10);
        listOfPairs.forEach(System.out::println);
    }

    public static List<Tuple2<Integer, Integer>> findPairs(List<Integer> integers, Integer sum) {
        List<Tuple2<Integer, Integer>> listOfPairs = new ArrayList<>();
        for (int i = 0; i < integers.size(); i++) {
            int x = integers.get(i);
            if (x < sum) {
                for (int j = i + 1; j < integers.size(); j++) {
                    int y = integers.get(j);
                    if (x + y == sum) {
                        listOfPairs.add(Tuple.of(x, y));
                    }
                }
            }
        }
        return listOfPairs;
    }
}

edit: A można sprytniej:

public static List<Tuple2<Integer, Integer>> findPairs(List<Integer> integers, Integer sum) {
    List<Tuple2<Integer, Integer>> listOfPairs = new ArrayList<>();
    Set<Integer> numbers = new HashSet<>(integers);
    for (int x : integers) {
        if (numbers.contains(sum - x)) {
            listOfPairs.add(Tuple.of(x, sum - x));
        }
    }
    return listOfPairs;
}

edit2: I idąc dalej:

public static List<Tuple2<Integer, Integer>> findPairs(List<Integer> integers, Integer sum) {
    Set<Integer> numbers = new HashSet<>(integers);
    return integers
            .stream()
            .filter(number -> numbers.contains(sum - number))
            .map(number -> Tuple.of(number, sum - number))
            .toList();
}

tylko tutaj może się trafić że znajdziemy np. parę 5,5 a input zawierał tylko jedną 5.

edit3: Można to naprawić np. tak:

public static List<Tuple2<Integer, Integer>> findPairs(List<Integer> integers, Integer sum) {
    Map<Integer, Long> numbers = integers
            .stream()
            .collect(Collectors.groupingBy(
                    Function.identity(),
                    Collectors.counting()
            ));
    return integers
            .stream()
            .filter(number -> hasPair(number, numbers, sum))
            .map(number -> Tuple.of(number, sum - number))
            .collect(Collectors.toList());
}

private static boolean hasPair(Integer number, Map<Integer, Long> numbers, Integer sum) {
    int needed = sum - number;
    if (number != needed) {
        return numbers.containsKey(sum - number);
    } else {
        return numbers.containsKey(sum - number) && numbers.get(needed) > 1;
    }
}