Ajuda para resolver o problema com função recursiva

[savoine]

Boa noite a todos,

Estou com o seguinte problema, tenho 3 listas e preciso uni-las em 1 unica lista, e para isso criei uma função com recursividade, porem eu tenho um campo chamado (ENABLE_INPUT) que tem condição “0” ou “1” e que pode estar em qualquer um dos níveis, quando for “0” em qualquer dos níveis mesmo que seja no primeiro nível, toda linha gerada deve permanecer com a condição “0”, porem não consigo resolver isso, não consigo sair do lugar…

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class Test
{
	private static List<Object> level1 = new ArrayList<Object>() {{
		add(new ArrayList<Object>() {{      
          add(new HashMap<String, Object>() {{
              put("CALMONTH", "201901");	
              put("ENABLE_INPUT", "1");
          }});
          add(new HashMap<String, Object>() {{
              put("CALMONTH", "201902");	
              put("ENABLE_INPUT", "1");
          }});
        }});   
    }};

private static List<Object> level2 = new ArrayList<Object>() {{
  	add(new ArrayList<Object>() {{ 
		add(new HashMap<String, Object>() {{
			put("VERSION", "REAL");	
			put("ENABLE_INPUT", "0");
		}});
		add(new HashMap<String, Object>() {{
			put("VERSION", "PLANNING");	
			put("ENABLE_INPUT", "1");
		}});      
	}});          
}};

private static List<Object> level3 = new ArrayList<Object>() {{
  	add(new ArrayList<Object>() {{ 
		add(new HashMap<String, Object>() {{
			put("INDICATOR", "IND0001");	
      		put("ENABLE_INPUT", "1");
		}});
		add(new HashMap<String, Object>() {{
			put("INDICATOR", "IND0002");	
      		put("ENABLE_INPUT", "1");
		}});      
	}});          
}};

private static HashMap<Integer, List<Object>> levelResult = new HashMap<Integer, List<Object>>() {{
	put(1, level1);
	put(2, level2);
	put(3, level3);  
}};


public static void main(String[] args)
{
	System.out.print(level1);
  	System.out.print(level2);
  	System.out.print(level3);
  	System.out.print(levelResult);
	
	System.out.print("--------------------------------------------------------------------");
	List<Object> test = returnResultList(levelResult, null, 1, 3, null);
	System.out.print("size: " + test.size());			
	for(Object item: test ) {			
		System.out.print((HashMap<String, Object>)item);
	}
}

public static List<Object> returnResultList(HashMap<Integer, List<Object>> levelList, HashMap<String, Object> currentLevel, Integer iCurrent, Integer iMax, List<Object> result){
	if(result == null) {
		result = new ArrayList<Object>();
	}
	try {						
		List<Object> levelItem = levelList.get(iCurrent);
		for (int i = 0; i < levelItem.size(); i++) {
			List<Object> list = (List<Object>) levelItem.get(i);
			for (int j = 0; j < list.size(); j++) {
				HashMap<String, Object> nivel = (HashMap<String, Object>) list.get(j);
				
				if(currentLevel == null) {
					currentLevel = new HashMap<String, Object>();
				}
				
				HashMap<String, Object> previousLevel = new HashMap<String, Object>();
				previousLevel = returnHash(previousLevel, currentLevel);
				currentLevel = returnHash(currentLevel, nivel);

				if (iCurrent == iMax){
					result.add(currentLevel);
					currentLevel = new HashMap<String, Object>();						
					currentLevel = returnHash(currentLevel, previousLevel);
				}
				
				if(iCurrent < iMax) {			
					HashMap<String, Object> lowerLevel = new HashMap<String, Object>();
					lowerLevel = returnHash(lowerLevel, currentLevel);
					returnResultList(levelList, lowerLevel, iCurrent + 1, iMax, result);
				}					
			}
		}			
	} catch (Exception e) {
		System.out.print("returnResultList: " + e);
	}
	return result;
}  

public static HashMap<String, Object> returnHash (HashMap<String, Object> previousLevel, HashMap<String, Object> nextLevel){
	HashMap<String, Object> result = previousLevel;
	try {			
		for(String key : nextLevel.keySet() ) {
			if (result.get(key) == null) {
				result.put(key, nextLevel.get(key));	
			} else {			
				result.replace(key, nextLevel.get(key));	
			}						
		}
	} catch (Exception e) {
		System.out.print("returnHash: " + e);
	}
	return result;
}  
}

Resultado gerado através do codigo acima--------------------------------------------------------------------
size: 8
{CALMONTH=201901, VERSION=REAL, INDICATOR=IND0001, ENABLE_INPUT=1}
{CALMONTH=201901, VERSION=REAL, INDICATOR=IND0002, ENABLE_INPUT=1}
{CALMONTH=201901, VERSION=PLANNING, INDICATOR=IND0001, ENABLE_INPUT=1}
{CALMONTH=201901, VERSION=PLANNING, INDICATOR=IND0002, ENABLE_INPUT=1}
{CALMONTH=201902, VERSION=REAL, INDICATOR=IND0001, ENABLE_INPUT=1}
{CALMONTH=201902, VERSION=REAL, INDICATOR=IND0002, ENABLE_INPUT=1}
{CALMONTH=201902, VERSION=PLANNING, INDICATOR=IND0001, ENABLE_INPUT=1}
{CALMONTH=201902, VERSION=PLANNING, INDICATOR=IND0002, ENABLE_INPUT=1}

Precisaria que ficasse com o seguinte resultado

---

size: 8
{CALMONTH=201901, VERSION=REAL, INDICATOR=IND0001, ENABLE_INPUT=0}
{CALMONTH=201901, VERSION=REAL, INDICATOR=IND0002, ENABLE_INPUT=0}
{CALMONTH=201901, VERSION=PLANNING, INDICATOR=IND0001, ENABLE_INPUT=1}
{CALMONTH=201901, VERSION=PLANNING, INDICATOR=IND0002, ENABLE_INPUT=1}
{CALMONTH=201902, VERSION=REAL, INDICATOR=IND0001, ENABLE_INPUT=0}
{CALMONTH=201902, VERSION=REAL, INDICATOR=IND0002, ENABLE_INPUT=0}
{CALMONTH=201902, VERSION=PLANNING, INDICATOR=IND0001, ENABLE_INPUT=1}
{CALMONTH=201902, VERSION=PLANNING, INDICATOR=IND0002, ENABLE_INPUT=1}

[SamuelLira99]

Bom dia.

Não tem como, por exemplo, a 1ª matriz printar:
{CALMONTH=201901, VERSION=REAL, INDICATOR=IND0001, ENABLE_INPUT=0}
{CALMONTH=201901, VERSION=REAL, INDICATOR=IND0002, ENABLE_INPUT=0}

porque no você colocou:
put("ENABLE_INPUT", "1");

sem verificar nenhuma condição.

voce pode fazer uma verificação antes:

if (condição) {
    put("ENABLE_INPUT", "0");
} else {
    put("ENABLE_INPUT", "1");
}

ou implementar uma lógica que atribua 1 o 0 a uma variável e então atribuí-la ao método add():

private static List<Object> level1(int variavel) { // o método recebe um marâmetro do tipo int
ArrayList<Object> obj = new ArrayList<>(); // O ArrayList "pai" fica em uma variável 
    ...
    sua lógica
    ...
    obj.add( /********** os ArrayList "filhos" são adicionados ao pai **********/
    new ArrayList<Object>() {{      
        add(new HashMap<String, Object>() {{
            put("CALMONTH", "201901");	
            put("ENABLE_INPUT", variavel); // O valor passado como parâmetro e tratado pela lógica é adicionado à sua String
    	}});

    // Aplicar novamente a lógica, se necessário

        add(new HashMap<String, Object>() {{
            put("CALMONTH", "201902");	
            put("ENABLE_INPUT", variavel); // O valor passado como parâmetro e tratado pela lógica é adicionado à sua String
        }});
    }});
}

o mesmo se aplica às outras listas, você está adicionando o valor {1 ou 0} diretamente

[savoine]

Samuel bom dia,

O problema não é esse, posso ter 1 nivel como 5 niveis (exemplo) e em cada nivel eu tenho uma condição pro ENABLE_INPUT e caso de algum nivel que possua o “0” ele deve aplicar para todos os niveis depois dele.

[SamuelLira99]

Ok, eu entendi errado. analisando melhor percebi que level1, level2 e level3 são variáveis do tipo List<> e o seu método recursivo é o returnResultList()

Coloquei um println() para iCurrent, iMax e currentLevel, porém não consegui entender com clareza este códico e algumas variáveis

Se puder, explique a sua intenção com cada variável

também com um println() em:
if (result.get(key) == null)

quase sempre é null, analise se deveria ser isto mesmo.

coloque println() onde for necessário para saber o que está chegando em cada parte do seu programa

[savoine]

Então ele funciona da seguinte forma, é um gerador de layout, pensa da seguinte forma através dessa lista eu monto um grid para atualização de valores.

Abaixo segue um conceito de como seria

Nivel1: Dimensão de Período seus valores e em qual período eu posso atualizar ou não os valores
{PERIODO: 201901, ENABLE_INPUT: 1}
{PERIODO: 201902, ENABLE_INPUT: 1}

Nivel2: Dimensão de Versão:
{VERSAO: REALIZADO, ENABLE_INPUT: 0}
{VERSAO: PLANEJAMENTO, ENABLE_INPUT: 1}

Nivel3: Dimensão de Indicador:
{INDICADOR: IND_RECEITA, ENABLE_INPUT: 1}
{INDICADOR: IND_DESPESA, ENABLE_INPUT: 1}

Com os 3 niveis ele vai me gerar um resultado, porem como a função é recursiva eu não consegui tratar o “ENABLE_INPUT” incluse nem existe nada no código, porque os vários testes que fiz, não sai do lugar…

Ele ja gera a lista conforme o esperado, porem eu não consegui resolver o problema do “ENABLE_INPUT” quando a condição é zero.

{PERIODO: 201901, ENABLE_INPUT: 0, VERSAO: REALIZADO, INDICADOR: IND_RECEITA}
{PERIODO: 201901, ENABLE_INPUT: 0, VERSAO: REALIZADO, INDICADOR: IND_DESPESA}
{PERIODO: 201901, ENABLE_INPUT: 1, VERSAO: PLANEJAMENTO, INDICADOR: IND_RECEITA}
{PERIODO: 201901, ENABLE_INPUT: 1, VERSAO: PLANEJAMENTO, INDICADOR: IND_DESPESA}
{PERIODO: 201902, ENABLE_INPUT: 0, VERSAO: REALIZADO, INDICADOR: IND_RECEITA}
{PERIODO: 201902, ENABLE_INPUT: 0, VERSAO: REALIZADO, INDICADOR: IND_DESPESA}
{PERIODO: 201902, ENABLE_INPUT: 1, VERSAO: PLANEJAMENTO, INDICADOR: IND_RECEITA}
{PERIODO: 201902, ENABLE_INPUT: 1, VERSAO: PLANEJAMENTO, INDICADOR: IND_DESPESA}

[SamuelLira99]

Consegui ter acesso ao atributo “ENABLE_INPUT” e modificá-lo, porém tive que dividir a variável em partes:

//Level 1
private static List<Object> level1 = new ArrayList<>();
private static ArrayList<Object> subList1 = new ArrayList<>();
private static HashMap<String, String> hm1_1 = new HashMap<>();
private static HashMap<String, Object> hm1_2 = new HashMap<>();

// A mesma lógica se aplica para o level2 e level3



public static void main(String[] args) {

hm1_1.put("CALMONTH", "201901");
hm1_1.put("ENABLE_INPUT", "1");

hm1_2.put("CALMONTH", "201902");
hm1_2.put("ENABLE_INPUT", "1");

level1.add(hm1_1);
level1.add(hm1_2);

...
...
...


System.out.println("--------------------------------------------------------------------");

    List<Object> test = returnResultList(levelResult, null, 1, 3, null);
...
...
...
System.out.println("HashMap1_1 (antes)=>  " + hm1_1);
hm1_1.put("ENABLE_INPUT", "0"); //Atribui um novo valor
System.out.println("HashMap1_1 (depois) =>  " + hm1_1);
...
...
...

}

Porém será necessário que você adapte esta nova “estrutura” dentro do seu método recursivo.