Coverter String em Color ? [resolvido]

String cor = ""+JCcor.getColor().getRGB();

JCcor.setColor(Integer.parseInt(cor));

class TEMPO{
	public static void main(String[] args) {
		Color c1 = Color.ORANGE;
		Color c2 = shabbyFromString(c1.toString());
		Color c3 = fancyFromString(c2.toString());
		System.out.println("c1: " + c1);
		System.out.println("c2: " + c2);
		System.out.println("c3: " + c3);
		System.out.println("c1.equals(c2): " + c1.equals(c2));
		System.out.println("c1.equals(c3): " + c1.equals(c3));
		System.out.println("c2.equals(c3): " + c2.equals(c3));
	}
	
	public static Color shabbyFromString(String colorString) {
		/*
		 * Algumas constantes interessantes... Utilizadas para indexar o 
		 * vetor que armazenará os valores obtidos de colorString
		 */
		final int
			/*
			 * RED começa com o valor 1 porque 0, no vetor, vai ter um String
			 * vazio. Estude mais o método split da classe String para entender
			 * isso melhor...
			 */
			RED = 1,
			GREEN = 2,
			BLUE = 3
		;
		
		/*
		 * Troca no String tudo que não for número por espaço
		 */
		colorString = colorString.replaceAll("\D", " ");
		/*
		 * Troca no String todos espaços replicados por um único espaço 
		 */
		colorString = colorString.replaceAll(" {2,}", " ");
		/*
		 * Quebra o String a cada espaço encontrado, criando assim um vetor
		 * de objetos String
		 */
		String[] colorValues = colorString.split(" ");
		/*
		 * Cria um objeto Color utilizando os valores armazenados nas posições
		 * do vetor colorValues
		 */
		Color result = new Color(
			Integer.parseInt(colorValues[RED]),
			Integer.parseInt(colorValues[GREEN]),
			Integer.parseInt(colorValues[BLUE])
		);
		/*
		 * Retorna a cor sintetizada
		 */
		return result;
	}
	
	public static Color fancyFromString(String colorString) {
		/*
		 * Cria um padrão de expressão regular - regex - para identificar apenas 
		 * strings com 1 ou mais caracteres numéricos
		 */
		Pattern padrao = Pattern.compile("\d+");
		/*
		 * Cria um casador(argh!!!) que utiliza o padrão de regex criado 
		 * anteriormente para fazer buscas em um determinado objeto 
		 * CharSequence (String é filha de CharSequence), que no nosso caso é 
		 * o String que queremos converter pra Color
		 */
		Matcher casador = padrao.matcher(colorString);
		/*
		 * Cria um vetor de inteiros com três posições, uma para cada componente
		 * de cor
		 */
		int[] rgb = new int[3];
		/*
		 * Constantes para indexar o vetor rgb
		 */
		final int
			RED = 0,
			GREEN = 1,
			BLUE = 2
		;
		
		for(int c = 0; c < rgb.length; c++) {
			/*
			 * Busca dentro de colorString algum trecho que "case" com a regex
			 * definida pelo Pattern padrao. Retorna true ou false.
			 * Chamadas subsequentes do método find, fará com que o casador 
			 * continue buscando por um novo trecho que case com a regex, só que
			 * começando do fim do trecho encontrado anteriormente. 
			 */
			if(casador.find()) {
				int
					/*
					 * O método start de Matcher retornará um inteiro indicando 
					 * a posição, dentro de colorString, do primeiro caractere do 
					 * trecho que casa com nossa regex.
					 * 
					 */
					inicioValor = casador.start(),
					/*
					 * O método end de Matcher retornará um inteiro indicando, 
					 * dentro de colorString, a posição seguinte ao último 
					 * caractere do trecho que casa com nossa regex 
					 */
					fimValor = casador.end()
				;
				/*
				 * Extraímos o valor do String, convertemos-o em inteiro e 
				 * armazenamos-o no vetor rgb
				 */
				rgb[c] = Integer.parseInt(
					colorString.substring(inicioValor, fimValor)
				);
			}
		}
		
		/*
		 * Retornamos o objeto Color representado pelo string colorString
		 */
		return new Color(rgb[RED], rgb[GREEN], rgb[BLUE]);
	}
}

Pattern p = Pattern.compile("\d+");
Matcher m = p.matcher("java.awt.Color[r=153,g=255,b=255]");
		
		
while (m.find()){
	System.out.println(m.group());
}