Loops, Lists, Sets, Maps, sObjects

//Demonstrando loop while com operadores de incremento/decremento

Integer i=0;
while(i<10){
  System.debug('Valor de i: '+i);
  // i = i + 2;
  i++;
  // i += 2;
}
System.debug('Fim do loop, conteúdo de i: '+i);
//************************************************************/
//Demonstrando loop while com operadores de incremento/decremento
Integer i=9;
while(i>=0){
  System.debug('Valor de i: '+i);
  // i = i - 2;
  // i -= 2;
  i--;
}
System.debug('Fim do loop');
//************************************************************/
//Demonstrando loop do while
Integer i=0;
do{
  System.debug('Valor de i: '+i);
  i++;
}while(i<10);

System.debug('Fim do loop, valor de i: '+i);
//************************************************************/
//Demonstrando funcionamento loop for com variável em escopo dentro do loop

for(Integer i=0;i<10;i++){
  System.debug('Valor de i: '+i);
}
//************************************************************/
//Demonstrando funcionamento loop for com variável em escopo maior
Integer i;
for(i=0;i<10;i++){
  System.debug('Valor de i: '+i);
}
  System.debug('Fim do loop, valor de i: '+i);
//************************************************************/
//Iterando Lista com loop while
List<Contact> listaContatos = [SELECT Name FROM Contact];
Integer i = 0;
System.debug('Tamanho da lista: '+listaContatos.size());
while(i<listaContatos.size()){
    System.debug(listaContatos[i]);
    i++;
}
//************************************************************/
//Iterando Lista com for
List<Contact> listaContatos = [SELECT Name FROM Contact];
System.debug('Tamanho da lista: '+listaContatos.size());
for(Integer i=0;i<listaContatos.size();i++){
    System.debug(listaContatos[i]);
}
//************************************************************/
//Iterando Lista com forEach
List<Contact> listaContatos = [SELECT Name FROM Contact];
for(Contact cadaContato:listaContatos){
    System.debug(cadaContato);
}
//************************************************************/
//Iterando Lista com forEach e pegando conteúdo dos campos separadamente
List<Contact> listaContatos = [SELECT Name, Phone, Email FROM Contact];
for(Contact cadaContato:listaContatos){
    System.debug('O contato '+cadaContato.Name+' tem o telefone '+cadaContato.Phone+ ' e o email é: '+cadaContato.Email);
}
//************************************************************/
List<Contact> listaContatos = [SELECT Name, Phone, Email FROM Contact];
for(Contact cadaContato:listaContatos){
    System.debug('O contato '+cadaContato.Name+' tem o telefone '+cadaContato.Phone+ ' e o email é: '+cadaContato.Email);
    String email = cadaContato.Email;
    System.debug(String.isBlank(email));
    System.debug(email == null);
    System.debug(cadaContato.Email == '');
}
//************************************************************/
//Não quero ver quem tem o telefone ou email nulo
List<Contact> listaContatos = [SELECT Name, Phone, Email FROM Contact];
for(Contact cadaContato:listaContatos){
  if(cadaContato.Phone != null || cadaContato.Email != null){
    System.debug('O contato '+cadaContato.Name+' tem o telefone '+cadaContato.Phone+ ' e o email é: '+cadaContato.Email);
  }
}
//************************************************************/
//Demonstrando listas dentro de listas
List<List<String>> palavras = new List<List<String>>{new List<String>{'mesa', 'cadeira'}, new List<String>{'banquinho', 'tapete'}};
System.debug(palavras[0][0]); //mesa
System.debug(palavras[0][1]); //cadeira
System.debug(palavras[1][0]); //banquinho
System.debug(palavras[1][1]); //tapete
palavras[1][1] = 'armario';
System.debug(palavras[1][1]); //tapete

//************************************************************/
//Criando array bidimensional com Lists e iterando com for

List<List<String>> palavras = new List<List<String>>{new List<String>{'mesa', 'cadeira'}, new List<String>{'banquinho', 'tapete'}};
for(Integer i=0;i<2;i++){
  for(Integer j=0;j<2;j++){
    System.debug(palavras[i][j]);
  }
}
System.debug('Fim do loop');
//************************************************************/
//Criando array bidimensional com Lists e iterando com forEach
List<List<String>> palavras = new List<List<String>>{new List<String>{'mesa', 'cadeira'}, new List<String>{'banquinho', 'tapete'}};
for(List<String> elementos:palavras){
  for(String palavra:elementos){
    System.debug(palavra);
  }
}
System.debug('Fim do loop');
//************************************************************/
//SET
//Não é ordenado (não possui index)
//Não aceita elementos repetidos

Set<String> palavras = new Set<String>{'mesa', 'cadeira', 'sofa', 'banquinho'};
for(String p:palavras){
  System.debug(p);
}
//************************************************************/
//SET
//Não é ordenado (não possui index)
//Não aceita elementos repetidos

Set<String> palavras = new Set<String>{'mesa', 'cadeira', 'sofa', 'banquinho', 'cadeira', 'armário'};
for(String p:palavras){
  System.debug(p);
}

//************************************************************/
//Convertendo uma Lista em um Set
List<String> palavrasList = new List<String>{'mesa', 'cadeira', 'mesa', 'sofa', 'banquinho', 'cadeira', 'armário'};
System.debug('Size: '+palavrasList.size());
palavrasList.set(3, 'televisão');
System.debug('Size: '+palavrasList.size());
palavrasList.clear();
palavrasList.add('pen-drive');
palavrasList.add('usb');
palavrasList.add('usb type-C');
palavrasList.remove(1);
System.debug('Item no índice 1: '+palavrasList.get(1));
for(String p:palavrasList){
  System.debug(p);
}
Set<String> palavrasSet = new Set<String>(palavrasList);
System.debug('Size: '+palavrasSet.size());
palavrasSet.add('abajour');
palavrasSet.add('abajour');
for(String p:palavrasSet){
  System.debug(p);
}

//************************************************************/
//Realizando ordenação com o método de List, sort()
List<String> palavrasList = new List<String>{'mesa', 'cadeira', 'mesa', 'sofa', 'banquinho', 'cadeira', 'armário'};
System.debug('Size: '+palavrasList.size());
palavrasList.set(3, 'televisão');
System.debug('Size: '+palavrasList.size());
System.debug('Palavras fora de ordem');
for(String p:palavrasList){
  System.debug(p);
}
palavrasList.sort();
System.debug('Palavras em ordem');
for(String p:palavrasList){
  System.debug(p);
}
//************************************************************/

//Demonstrando que não se adiciona elementos iguais aos já existentes num Set e que .sort() não funciona num Set
Set<String> palavrasSet = new Set<String>(palavrasList);
System.debug('Size: '+palavrasSet.size());
palavrasSet.add('abajour');
palavrasSet.add('abajour');
// palavrasSet.sort(); --Não funciona para o Set
System.debug('Set de palavras');
for(String p:palavrasSet){
  System.debug(p);
}
//************************************************************/
//Uso do método "contains" da classe List
List<String> palavrasList = new List<String>{'mesa', 'cadeira', 'mesa', 'sofa', 'banquinho', 'cadeira', 'armário'};
System.debug(palavrasList.contains('mesa')); //Retorna true se o elemento existe dentro da List

//************************************************************/
//Demonstrando adição de lista a um Map e pegando o valor retornado (Boolean) caso o set original tenha sofrido transformação
List<String> palavrasList = new List<String>{'mesa', 'cadeira', 'mesa', 'sofa', 'banquinho', 'cadeira', 'armário'};
System.debug('Tamanho da lista: '+palavrasList.size());
System.debug(palavrasList);
Set<String> conjunto = new Set<String>{'lâmpada', 'controle remoto', 'mesa', 'cadeira'};
System.debug('Exibindo o Set original');
System.debug(conjunto);
System.debug('Tamanho do Set antes do addAll: '+conjunto.size());
Boolean resultado = conjunto.addAll(palavrasList);
System.debug('Houve alteração?: '+resultado);
System.debug('Tamanho do Set após addAll: '+conjunto.size());
System.debug(conjunto);
//************************************************************/
//Adicionando um set em outro, porém demonstrando que não há alteração pela não existência de novos elementos
Set<String> conjunto = new Set<String>{'lâmpada', 'controle remoto', 'mesa', 'cadeira'};
Set<String> conjunto2 = new Set<String>{'lâmpada', 'controle remoto', 'mesa', 'cadeira'};
Boolean resultado = conjunto.addAll(conjunto2);
System.debug('Houve alteração?: '+resultado);
//************************************************************/
//Removendo um elemento de um Set
Set<String> conjunto = new Set<String>{'lâmpada', 'controle remoto', 'mesa', 'cadeira'};
System.debug(conjunto);
conjunto.remove('mesa');
System.debug(conjunto);
//************************************************************/
//REMOVENDO UM ÚNICO ELEMENTO QUE ESTEJA REPETIDO VÁRIAS VEZES (break)
List<String> palavrasList = new List<String>{'mesa', 'cadeira', 'mesa', 'sofa', 'banquinho', 'cadeira', 'armário'};

System.debug('Lista original: '+palavrasList);

for(Integer i=0; i<palavrasList.size(); i++) {
  if(palavrasList[i] == 'mesa') {
    palavrasList.remove(i);
    break;
  }
}
System.debug('Lista pós remoção: '+palavrasList);

//************************************************************/
/*
Exercício: Construir um método estático em que é passado como argumento uma lista de palavras, que contém palavras repetidas. O método deverá receber 2 argumentos, sendo o 1º essa lista, e o segundo, a palavra que se quer que sejam eliminadas as repetições.
*/
//************************************************************/
//Criando um map e visualizando o value a partir da chave
Map<String, String> mapa = new Map<String, String>();

mapa.put('nome', 'Airton');
mapa.put('idade', '46');
mapa.put('telefone', '19998766567');
System.debug(mapa);
System.debug('Obtendo o valor da chave "nome": '+mapa.get('nome'));
//************************************************************/
//Iterando um map pelas suas chaves
Map<String, String> mapa = new Map<String, String>();

mapa.put('nome', 'Airton');
mapa.put('idade', '46');
mapa.put('telefone', '19998766567');
for(String chave:mapa.keySet()){
  System.debug('A chave é '+chave+' para o valor -> '+mapa.get(chave));
}
System.debug(mapa);
System.debug('Obtendo o valor da chave "nome": '+mapa.get('nome'));
//************************************************************/
//Mostrando criação de Map e atribuindo chaves do map a um Set

Map<String, String> mapa = new Map<String, String>();

mapa.put('nome', 'Airton');
mapa.put('idade', '46');
mapa.put('telefone', '19998766567');
Set<String> chaves = mapa.keySet();
System.debug(chaves);
//************************************************************/
//Criando 10 oportunidades utilizando loop e inserindo em massa por meio da lista
//Convertendo a lista gravada em Map com chave = Id e value = sObject

List<Opportunity> listaOportunidades = new List<Opportunity>();
Date closeDate = Date.today().addDays(1);
for(Integer i=11;i<=20;i++){
  Opportunity op = new Opportunity(Name = 'Oportunidade nº '+String.valueOf(i));
  op.StageName = 'Prospecting';
  op.CloseDate = closeDate;
  listaOportunidades.add(op);
}
insert listaOportunidades;

Map<Id, Opportunity> oppMap = new Map<Id, Opportunity>(listaOportunidades);
for(Id chave:oppMap.keySet()){
  System.debug('Chave -> '+chave+' // Opp -> '+oppMap.get(chave));
}
Set<Id> setIdsOpps = new Set<Id>(oppMap.keySet());
  for(Id chave:setIdsOpps){
  System.debug('Id -> '+chave);
}
//************************************************************/
//Criando sobjects Filial__c utilizando dados das contas mães relacionadas
List<Account> listaContas = [SELECT Name, phone, Id FROM Account LIMIT 5];
List<Filial__c> listaFiliais = new List<Filial__c>();
for(Account a:listaContas){
    String email = a.Name.substringBefore(' ')+'_filial@'+a.Name.substringBefore(' ')+'.com.br';
    Filial__c f = new Filial__c();
    f.Name = 'Filial da conta '+a.Name;
    f.Phone__c = a.Phone;
    f.Email__c = email;
    f.Account__c = a.Id;

    listaFiliais.add(f);
}
insert listaFiliais;