* @param bound the upper bound (exclusive).  Must be positive.
     * @return the next pseudorandom, uniformly distributed {@code int}
     *         value between zero (inclusive) and {@code bound} (exclusive)
     *         from this random number generator's sequence
     * @throws IllegalArgumentException if bound is not positive
     * @since 1.2
     */
    public int nextInt(int bound) {
 

cuando haces nextInt(numOjos.length) en length retorna 2, y ese numero 2 se excluye, dando como resultado un numero entre el 0 y 1, sin decimales, y ese numero corresponde al subindice de ese array

e igualmente con un array de mayor tamaño como nivelArreglarCosas que consta de 5 posiciones, nextInt() en ese caso le tocaría un numero de entre 0 a 4 porque length retornara 5, pero este se excluye por lo tanto seria 4;

por lo tanto nivelArreglarCosas[secureRandom.nextInt(nivelArreglarCosas.length)] se podría traducir a nivelArreglarCosas[numero aleatorio entre 0 a 4]  

package foro;
import java.security.SecureRandom;
import java.util.Arrays;
import java.util.stream.IntStream;
 
public class Ayudantes {
 
    private int numOjos[] = {1,2};
    private String colorPiel[] = {"morado","amarillo"};
    private String altura[] = {"mediano","alto"};
    private int nivelCrearObjetos[] = {1,2,3,4,5};
    private int nivelArreglarCosas[] = {1,2,3,4,5};
    private int nivelDestruccion[] = {1,2,3,4,5};
 
    public Ayudantes() {
 
    }
 
    @Override
    public String toString() {
        final SecureRandom secureRandom = new SecureRandom();
        return "Ayudante {" +
                "numOjos=" +              (numOjos[secureRandom.nextInt(numOjos.length)]) +
                ", colorPiel=" +          (colorPiel[secureRandom.nextInt(colorPiel.length)]) +
                ", altura=" +             (altura[secureRandom.nextInt(altura.length)]) +
                ", nivelCrearObjetos=" +  (nivelCrearObjetos[secureRandom.nextInt(nivelCrearObjetos.length)]) +
                ", nivelArreglarCosas=" + (nivelArreglarCosas[secureRandom.nextInt(nivelArreglarCosas.length)]) +
                ", nivelDestruccion=" +   (nivelDestruccion[secureRandom.nextInt(nivelDestruccion.length)]) +
                '}';
    }
 
    public static void main(String ...blabla) {
        IntStream.rangeClosed(1,5)
                .forEach(numero -> System.out.println(numero+"- "+new Ayudantes().toString()));
    }
}
 

1- Ayudante {numOjos=1, colorPiel=amarillo, altura=mediano, nivelCrearObjetos=5, nivelArreglarCosas=3, nivelDestruccion=4}
2- Ayudante {numOjos=2, colorPiel=amarillo, altura=mediano, nivelCrearObjetos=3, nivelArreglarCosas=2, nivelDestruccion=3}
3- Ayudante {numOjos=1, colorPiel=morado, altura=mediano, nivelCrearObjetos=2, nivelArreglarCosas=2, nivelDestruccion=4}
4- Ayudante {numOjos=2, colorPiel=morado, altura=mediano, nivelCrearObjetos=1, nivelArreglarCosas=4, nivelDestruccion=1}
5- Ayudante {numOjos=2, colorPiel=amarillo, altura=alto, nivelCrearObjetos=4, nivelArreglarCosas=3, nivelDestruccion=2}
 
Process finished with exit code 0
 

private void iterates() {
        for(int f=0; f<5; f++) {
            System.out.println((f+1)+"- "+new Ayudantes().toString());
        }
 
        System.out.println("··········································");
        List<Ayudantes> ayudantes = new ArrayList<>();
        ayudantes.add(new Ayudantes());
        ayudantes.add(new Ayudantes());
        ayudantes.add(new Ayudantes());
        ayudantes.add(new Ayudantes());
        ayudantes.add(new Ayudantes());
        for(Ayudantes ayudante : ayudantes) {
            System.out.println(ayudante.toString());
        }
        System.out.println("··········································");
        IntStream.rangeClosed(1,5)
                .forEach(numero -> System.out.println(numero+"- "+new Ayudantes().toString()));
 
    }
 

private String fecha;
public ExecTimer(final String fecha) {
    this.fecha = fecha;
    initTask();
}
 

public void setFecha(final String fecha) {
    this.fecha = fecha;
}

private static final String FECHA_FUTURA = "00 30 6 ? * FRI";

Entonces refactorizando un poco crearemos nuestro builder para personalizar un poco homie, que se lo setearemos al método setTimeBean de la clase ExecTimer  

el método toString le hacemos override para adaptarlo a nuestras necesidades  , tanto day como month son requeridos sino la misma API de quartz atrapara el error en runtime XD

el string retornado es la expresión de cron

    @Override
    public String toString() {
        final StringBuilder stringBuilder = new StringBuilder()
                .append(sec)
                .append(" ")
                .append(min)
                .append(" ")
                .append(hour)
                .append(" ")
                .append(day) // requeridp
                .append(" ")
                .append(month) // requerido
                .append(" ")
                .append("?");// opcional el YEAR XD
        System.out.println("Expresion cron: "+stringBuilder.toString());
        return stringBuilder.toString();

package foro;
 
public final class TimeBean {
 
    private final int sec;
    private final int min;
    private final int hour;
    private final int day;
    private final int month;
 
    private TimeBean(final Builder builder) {
        this.sec = builder.sec;
        this.min = builder.min;
        this.hour = builder.hour;
        this.day = builder.day;
        this.month = builder.month;
    }
 
    public int getSec() {
        return sec;
    }
 
    public int getMin() {
        return min;
    }
 
    public int getHour() {
        return hour;
    }
 
    public int getDay() {
        return day;
    }
 
    public int getMonth() {
        return month;
    }
 
    @Override
    public String toString() {
        final StringBuilder stringBuilder = new StringBuilder()
                .append(sec)
                .append(" ")
                .append(min)
                .append(" ")
                .append(hour)
                .append(" ")
                .append(day)
                .append(" ")
                .append(month)
                .append(" ")
                .append("?");// opcional el YEAR XD
        System.out.println("Expresion cron: "+stringBuilder.toString());
        return stringBuilder.toString();
    }
 
   public static class Builder {
        private int sec;
        private int min;
        private int hour;
        private int day;
        private int month;
 
        public Builder withSec(final int sec) {
            this.sec = sec;
            return this;
        }
        public Builder withMin(final int min) {
            this.min = min;
            return this;
        }
        public Builder withHour(final int hour) {
            this.hour = hour;
            return this;
        }
        public Builder withDay(final int day) {
            this.day = day;
            return this;
        }
        public Builder withMonth(final int month) {
            this.month = month;
            return this;
        }
        public TimeBean build() {
            return new TimeBean(this);
        }
    }
 

package foro;
 
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
 
import java.util.Objects;
 
public class ExecTimer  {
 
    private JobDetail job;
    private Trigger trigger;
    private Scheduler scheduler;
 
    private TimeBean timeBean;
 
    public ExecTimer() {
 
    }
 
    public ExecTimer(final TimeBean timeBean) {
        this.timeBean = Objects.requireNonNull(timeBean,()->"TimeBean sin instanciar crear builder");
    }
 
    public void setTimeBean(final TimeBean timeBean) {
        this.timeBean = Objects.requireNonNull(timeBean,()->"TimeBean sin instanciar crear builder");
    }
 
    public void initTask() {
        try {
 
            job = JobBuilder.newJob(TimerClass.class)
                    .withIdentity("EnviarMail")
                    .build();
 
            trigger = TriggerBuilder.newTrigger()
                    .withIdentity("testing v1.1 para olimpico10", "group1")
                    .withSchedule(CronScheduleBuilder.cronSchedule(timeBean.toString()))
                    .build();
 
            scheduler = new StdSchedulerFactory().getScheduler();
            scheduler.start();
            scheduler.scheduleJob(job, trigger);
 
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
}
 

private final ZoneId zoneId = ZoneId.of("Europe/Madrid");
private final ZonedDateTime zonedDateTime = ZonedDateTime.ofInstant(Instant.now(),zoneId).plusSeconds(5);
 

 .plusSeconds(5);

package foro;
 
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
 
public class ExcuteTaskOnNext {
 
    private ExecTimer execTimer = new ExecTimer();
    private final ZoneId zoneId = ZoneId.of("Europe/Madrid");
    private final ZonedDateTime zonedDateTime = ZonedDateTime.ofInstant(Instant.now(),zoneId).plusSeconds(5);
 
    public ExcuteTaskOnNext() {
        init();
    }
 
    private void init() {
 
       final TimeBean timeBean = new TimeBean.Builder()
                .withSec(zonedDateTime.getSecond())
                .withMin(zonedDateTime.getMinute())
                .withHour(zonedDateTime.getHour())
                .withDay(zonedDateTime.getDayOfMonth())//el dia es requerido
                .withMonth(zonedDateTime.getMonthValue()) //el mes es requrido
                .build();
 
        execTimer.setTimeBean(timeBean);
        execTimer.initTask();
    }
 
    public static void main(String ...agaga) {
        new ExcuteTaskOnNext();
    }
}
 

Entonces vamos a lo siguiente tu me diras joderrr tiiioo, pero este chaval le digo mil veces que quiero mandar el fucking correo al mes siguiente  

solo te tocara añadir esto  

plusMonths(1)

//para crear una tarea mensual el builder es valido asi segun cronmaker
        final TimeBean timeBean = new TimeBean.Builder()
                .withDay(zonedDateTime.getDayOfMonth())//el dia es requerido
                .withMonth(zonedDateTime.getMonthValue()) //el mes es requrido
                .build();
 

consta que debería crear el proyecto en struc2   pero me da flojera quizás mañana, tu tienes que probar aunque sea mandando ese correo a los 5 segundos, pero no se como es tu código ahí

package com.example.javamail.executarnextmonth;
 
import com.example.javamail.util.GenericBuilder;
import com.example.javamail.util.ShowData;
import com.vaadin.spring.annotation.SpringComponent;
import com.vaadin.ui.Label;
import org.springframework.beans.factory.annotation.Autowired;
 
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
 
@SpringComponent
public class RunNextTask implements ShowData {
 
    @Autowired
    private ExecTimer execTimer;
    private ZonedDateTime zonedDateTime;
    private TimeBean timeBean;
 
 
    public void initTimeBuilder(final Tiempos tiposTiempos, final Integer valueTime, Label label) {
        try {
            switch (tiposTiempos) {
                case SEGUNDOS:
                    zonedDateTime = getZoneDateTime().plusSeconds(valueTime);
                    timeBean = getTimeBeanBuilder();
                    break;
                case MINUTOS:
                    zonedDateTime = getZoneDateTime().plusMinutes(valueTime);
                    timeBean = getTimeBeanBuilder();
                    break;
                case HORAS:
                    zonedDateTime = getZoneDateTime().plusHours(valueTime);
                    timeBean = getTimeBeanBuilder();
                    break;
                case MESES:
                    zonedDateTime = getZoneDateTime().plusMonths(valueTime);
                    timeBean = getTimeBeanBuilder();
                    break;
            }
        }catch (Exception ex){
            getLogger().error(null,ex);
        }
        execTimer.setTimeBean(timeBean);
        label.setValue("Expresión cron "+timeBean.toString());
        execTimer.initTask();
    }
 
    /**
     * Metodo de uso opcional
     */
    public void initTimeBeanMonth() {
        final ZoneId zoneId = ZoneId.of("Europe/Madrid");
        final ZonedDateTime zonedDateTime = ZonedDateTime.ofInstant(Instant.now(),zoneId).plusMonths(1);
        //para crear una tarea mensual el builder es valido asi segun cronmaker
 
        final TimeBean timeBean = GenericBuilder.of(TimeBean::new)
                .with(TimeBean::setDay,zonedDateTime.getDayOfMonth())
                .with(TimeBean::setMonth,zonedDateTime.getMonthValue())
                .build();
 
        execTimer.setTimeBean(timeBean);
        execTimer.initTask();
    }
 
    private ZonedDateTime getZoneDateTime() {
        return ZonedDateTime.ofInstant(Instant.now(),ZoneId.of("Europe/Madrid"));
    }
 
    private TimeBean getTimeBeanBuilder() {
        return GenericBuilder.of(TimeBean::new)
                .with(TimeBean::setSec,this.zonedDateTime.getSecond())
                .with(TimeBean::setMin,this.zonedDateTime.getMinute())
                .with(TimeBean::setHour,this.zonedDateTime.getHour())
                .with(TimeBean::setDay,this.zonedDateTime.getDayOfMonth())
                .with(TimeBean::setMonth,this.zonedDateTime.getMonthValue())
                .build();
    }
}

• El tipo de tiempo
• El retardo
• El label para mostrar la salida

@Autowired
private RunNextTask runNextTask;
 

runNextTask.initTimeBuilder(tiempo, valueTime, labelExpresionCron);

javac primerproyecto/PrimerProyecto.java

java primerproyecto/PrimerProyecto

package primerproyecto;
 
import java.util.function.Consumer;
/**
 *
 * @author SonnyCrockett
 */
public class PrimerProyecto {
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //System.out.println("Hola Mundo esto es Java8");
 
	java8(System.out::println,"esto si es java8 XD");
    }
 
    private static void java8(final Consumer<String> c, final String msg) {
        c.accept(msg);
    }
 
}

C:\Users\SonnyCrockett\Documents\NetBeansProjects\PrimerProyecto\src\primerproyecto>java -version

 con cd .. 

C:\Users\SonnyCrockett\Documents\NetBeansProjects\PrimerProyecto\src

java primerproyecto/PrimerProyecto

java -version 

javac -version