Все возможные комбинаций чисел из заданного размера массива

/*
 * Существует массив {1,2,3,4,5} — размер массива может быть
произвольным. Напишите программу которая выведет на экран все
возможные комбинации из этих цифр. Внимание повторений быть не
должно.
 */

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		System.out.println("В ведите пожалуйста массив целых чисел!");
		Scanner sc = new Scanner(System.in);
		int col;
		while (!sc.hasNextInt() || (col = sc.nextInt()) < 0) {
			System.out.println("Это не целое положительное число");
			sc.next();
		}

		int[] numerec = new int[col];
		String st = "";
		String end = "";

		for (int i = 0; i < col; i++) {
			numerec[i] = i + 1;
			st = st + (i + 1);
			end = (i + 1) + end;
		}
		System.out.println(st);
		for (int i = Integer.parseInt(st) + 1; i < Integer.parseInt(end); i++) {
			if (rezult(i) == true) {
				System.out.println(i);
			}
		}
		System.out.println(end);
	}

	public static boolean rezult(int i) {
		boolean otvet = true;
		boolean[] tnumerecs = new boolean[(int) (Math.log10(i) + 1)];
		for (int k = 0; k < tnumerecs.length; k++) {
			tnumerecs[k] = false;
		}

		int[] tnumerec = new int[(int) (Math.log10(i) + 1)];

		for (int k = tnumerec.length - 1; k >= 0; k--) {
			tnumerec[k] = (i % 10);
			i /= 10;
		}

		for (int k = 0; k < tnumerec.length; k++) {
			if (tnumerec[k] <= tnumerec.length && tnumerec[k] > 0) {
				tnumerecs[tnumerec[k]-1] = true;
			}
		}

		for (int k = 0; k < tnumerecs.length; k++) {
			if (tnumerecs[k] == false) {
				otvet = false;
			}
		}
		return otvet;
	}

}

Этот алгоритм делает не то что требует задача.
И еще, допустим, я хочу комбинации для 10 элементов

Ваше решение не верно. Так для массива из 12 элементов я просто получаю ошибку времени выполнения.

Добавил ограничение массива не больше 9 значений.

/*
 * Существует массив {1,2,3,4,5} — размер массива может быть
произвольным. Напишите программу которая выведет на экран все
возможные комбинации из этих цифр. Внимание повторений быть не
должно.
 */

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		System.out.println("В ведите пожалуйста массив целых чисел не болше 9!");
		Scanner sc = new Scanner(System.in);
		int col;
		while (!sc.hasNextInt() || (col = sc.nextInt()) < 0) {
			System.out.println("Это не целое положительное число");
			sc.next();
		}

		if (col > 9) {
			System.out.println("Это число болше 9");
		} else {
			int[] numerec = new int[col];
			String st = "";
			String end = "";

			for (int i = 0; i < col; i++) {
				numerec[i] = i + 1;
				st = st + (i + 1);
				end = (i + 1) + end;
			}
			System.out.println(st);
			for (int i = Integer.parseInt(st) + 1; i < Integer.parseInt(end); i++) {
				if (rezult(i) == true) {
					System.out.println(i);
				}
			}
			System.out.println(end);
		}
	}

	public static boolean rezult(int i) {
		boolean otvet = true;
		boolean[] tnumerecs = new boolean[(int) (Math.log10(i) + 1)];
		for (int k = 0; k < tnumerecs.length; k++) {
			tnumerecs[k] = false;
		}

		int[] tnumerec = new int[(int) (Math.log10(i) + 1)];

		for (int k = tnumerec.length - 1; k >= 0; k--) {
			tnumerec[k] = (i % 10);
			i /= 10;
		}

		for (int k = 0; k < tnumerec.length; k++) {
			if (tnumerec[k] <= tnumerec.length && tnumerec[k] > 0) {
				tnumerecs[tnumerec[k] - 1] = true;
			}
		}

		for (int k = 0; k < tnumerecs.length; k++) {
			if (tnumerecs[k] == false) {
				otvet = false;
			}
		}
		return otvet;
	}

}

Так по условию массив может быть любого размера. Откуда ограничение в 9 элементов взялось?

Немного доработал алгоритм обработки)))

/*
 * Существует массив {1,2,3,4,5} — размер массива может быть
произвольным. Напишите программу которая выведет на экран все
возможные комбинации из этих цифр. Внимание повторений быть не
должно.
 */

import java.util.Scanner;
import java.util.Arrays;

public class Main {

	public static void main(String[] args) {
		System.out.println("В ведите пожалуйста размерность массива!");
		Scanner sc = new Scanner(System.in);
		int col;
		while (!sc.hasNextInt() || (col = sc.nextInt()) < 0) {
			System.out.println("Это не целое положительное число");
			sc.next();
		}

		int[] numerec = new int[col];
		int cols = 1;
		int schet = 1;
		int maks_sum;
		int maks_sums = 0;

		for (int i = 1; i <= col; i++) {
			numerec[i - 1] = i;
			cols *= i;
			maks_sums += i;
		}
		System.out.println(Arrays.toString(numerec));
		while (schet < cols) {
			numerec = Arrays.copyOfRange(rezultp(numerec, numerec.length - 1, numerec.length), 0, numerec.length);
			maks_sum = 0;
			for (int k = 0; k < numerec.length; k++) {
				maks_sum += numerec[k];
			}
			if (maks_sum == maks_sums && rezult(numerec) == true) {
				System.out.println(Arrays.toString(numerec));
				schet += 1;
			}
		}
	}

	public static int[] rezultp(int[] tnumerec, int i, int k) {
		if (tnumerec[i] + 1 > k) {
			tnumerec[i] = 1;
			rezultp(tnumerec, i - 1, k);
		} else {
			tnumerec[i] += 1;
		}

		return tnumerec;
	}

	public static boolean rezult(int[] tnumerec) {
		boolean otvet = true;
		boolean[] tnumerecs = new boolean[(int) (tnumerec.length)];

		for (int k = 0; k < tnumerecs.length; k++) {
			tnumerecs[k] = false;
		}

		for (int k = 0; k < tnumerec.length; k++) {
			if (tnumerec[k] <= tnumerec.length) {
				tnumerecs[tnumerec[k] - 1] = true;
			}
		}

		for (int k = 0; k < tnumerecs.length; k++) {
			if (tnumerecs[k] == false) {
				otvet = false;
			}
		}
		return otvet;
	}

}

Не верно. Например

В ведите пожалуйста размерность массива!
20
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

И все. А где все возможные комбинации из элементов этого массива???

Изменил логику по количеству проходов

/*
 * Существует массив {1,2,3,4,5} — размер массива может быть
произвольным. Напишите программу которая выведет на экран все
возможные комбинации из этих цифр. Внимание повторений быть не
должно.
 */

import java.util.Scanner;
import java.util.Arrays;

public class Main {

	public static void main(String[] args) {
		System.out.println("В ведите пожалуйста размерность массива!");
		Scanner sc = new Scanner(System.in);
		int col;
		while (!sc.hasNextInt() || (col = sc.nextInt()) < 0) {
			System.out.println("Это не целое положительное число");
			sc.next();
		}

		int[] numerec = new int[col];
		int[] numerecs = new int[col];
		boolean flag = true;
		double maks_sum;
		double maks_sums = 0;

		for (int i = 1; i <= col; i++) {
			numerec[i - 1] = i;
			numerecs[col - i] = i;
			maks_sums += i;
		}
		System.out.println(Arrays.toString(numerec));
		do {
			flag = true;
			numerec = Arrays.copyOfRange(rezultp(numerec, numerec.length - 1, numerec.length), 0, numerec.length);
			maks_sum = 0;
			for (int k = 0; k < numerec.length; k++) {
				maks_sum += numerec[k];
				if (numerec[k] != numerecs[k]) {
					flag = false;
				}
			}
			if (maks_sum == maks_sums && rezult(numerec) == true) {
				System.out.println(Arrays.toString(numerec));
			}
		} while (flag == false);
	}

	public static int[] rezultp(int[] tnumerec, int i, int k) {
		if (tnumerec[i] + 1 > k) {
			tnumerec[i] = 1;
			rezultp(tnumerec, i - 1, k);
		} else {
			tnumerec[i] += 1;
		}

		return tnumerec;
	}

	public static boolean rezult(int[] tnumerec) {
		boolean otvet = true;
		boolean[] tnumerecs = new boolean[(int) (tnumerec.length)];

		for (int k = 0; k < tnumerecs.length; k++) {
			tnumerecs[k] = false;
		}

		for (int k = 0; k < tnumerec.length; k++) {
			if (tnumerec[k] <= tnumerec.length) {
				tnumerecs[tnumerec[k] - 1] = true;
			}
		}

		for (int k = 0; k < tnumerecs.length; k++) {
			if (tnumerecs[k] == false) {
				otvet = false;
			}
		}
		return otvet;
	}

}

Решение хоть и верное но настолько нерациональное, что для массивов больше 9 я бы его не использовал в принципе. Чтобы мое утверждение не было голословным вот небольшой замер производительности. Я взял массив из 9 элементов и сгенерировал все перестановки.

Ваша реализация - 13419394572 ns
Алгоритм Нарайаны - 40169098 ns

Итого простейший алгоритм работает в 300 раз быстрее вашей реализации.

Алгори́тм Нарайа́ны — не рекурсивный алгоритм, генерирующий по данной перестановке следующую за ней перестановку (в лексикографическом порядке). Придуман индийским математиком Пандитом Нарайаной в XIV веке.

Извините но Я не математик и стараюсь придумывать алгоритмы и программный код сам. Если Вы считаете что лучше найти его в интернете и выдать за свой, тогда основным талантом нужно обладать это хорошим поиском нета.

Не нужно выдавать его за свой. Просто сначала написали свой (если уж очень хочется), а потом посмотрели что уже сделали до вас. Сравнили работу, и если нужно реализовали или использовали более оптимальный вариант. Я например физик, но не собираюсь заново открывать законы Ньютона и Максвелла.