Системы счисления

int ch = 433;int []rez=null;int i=0;
        while(true){
            if(ch<2) break;
            rez[i] = (ch%2);//выдает ошибку
            ch = ch/2;
            i++;
        }

int res = ch%2;

public static void ofDic(){
        int i=76; int j=0; int p=2;
        //i-это исходное число,
        //j- то что получиться,
        //P-система счисления
        int flag=1;
        while(true){
            if(i<p){
                j=j+(i-((int)(i/p))*p)*flag; break;
            }
            j=j+(i-((int)(i/p))*p)*flag;
            i=i/p;
            flag=flag*10;
        }
        System.out.println(j);
    }

public static void toDic(){
        int []mass = {1,2,1};
        int rez = 0;
        int j=0;
        for(int i=mass.length-1;i>=0;i--){
            rez += (int) (mass[j] * (Math.pow(3,i)));
            j++;
        }
        System.out.println(rez);
    }

import static java.lang.Math.*;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
public class NumeralSystem {
    private Integer[] chars;
    private int radix;
 
    public NumeralSystem(int value, int radix) {
        this.radix = radix;
        chars = transformFrom(value, radix);
    }
 
    protected Integer[] transformFrom(int from, int radix) {
        List<Integer> resultList = new ArrayList<Integer>();
        while (from != 0) {
            resultList.add(from % radix);
            from /= radix;
        }
        Collections.reverse(resultList);
        return resultList.toArray(new Integer[0]);
    }
 
    public int produceDecValue() {
        int result = 0;
        int tempvalue = 1;
        for (int i = chars.length - 1; i >= 0; i--) {
            result += chars[i] * tempvalue;
            tempvalue *= radix;
        }
        return result;
    }
 
}

import org.junit.Before;
import org.junit.Test;
 
import static org.junit.Assert.*;
 
public class NumeralSystemTest {
    NumeralSystem underTest;
    
    @Test
    public void shouldConvert()
    {
        underTest=new NumeralSystem(11, 2);
        Integer[] result=underTest.transformFrom(11, 8);
        Integer[] exptected=new Integer[]{1,3};
        assertArrayEquals(exptected, result);
        
    }
    
    @Test
    public void shouldDisplayCorrectValueForDec()
    {
        underTest=new NumeralSystem(11, 8);
        int result=underTest.produceDecValue();
        int expected=11;
        assertEquals(expected, result);
    }
    
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
public class NumeralSystem implements Comparable<NumeralSystem> {
    private final Integer[] chars;
    private final int radix;
 
    public NumeralSystem(int value, int radix) {
        this.radix = radix;
        chars = transformFrom(value, radix);
    }
 
    protected NumeralSystem(Integer[] chars, int radix) {
        this.chars = chars;
        this.radix = radix;
    }
 
    protected Integer[] transformFrom(int from, int radix) {
        List<Integer> resultList = new ArrayList<Integer>();
        while (from != 0) {
            resultList.add(from % radix);
            from /= radix;
        }
        Collections.reverse(resultList);
        return resultList.toArray(new Integer[0]);
    }
 
    public int produceDecValue() {
        int result = 0;
        int tempvalue = 1;
        for (int i = chars.length - 1; i >= 0; i--) {
            result += chars[i] * tempvalue;
            tempvalue *= radix;
        }
        return result;
    }
 
    public int getRadix() {
        return radix;
    }
 
    protected int compareBytes(Integer[] first, Integer[] second) {
        int result = Integer.valueOf(first.length).compareTo(second.length);
        if (result != 0)
            return result;
        for (int i = first.length - 1; i >= 0; i--) {
            result = first[i].compareTo(second[i]);
            if (result != 0)
                return result;
        }
        return 0;
    }
 
    private boolean validRadix(int radix) {
        return (this.radix == radix);
 
    }
 
    public NumeralSystem division(NumeralSystem anotherValue) {
        if (!validRadix(anotherValue.radix))
            throw new IllegalArgumentException("incorrect radix of devisior");
 
        return null;
    }
 
    public NumeralSystem multiply(NumeralSystem anotherValue) {
        if (!validRadix(anotherValue.radix))
            throw new IllegalArgumentException("incorrect radix of devisior");
 
        return null;
    }
 
    protected Integer[] multiplyBytes(Integer first[], Integer[] second) {
        return null;
    }
 
    protected Integer[] multiplyBytes(Integer[] first, Integer one, Integer shift) {
        return null;
    }
 
    public NumeralSystem add(NumeralSystem anotherValue) {
        if (!validRadix(anotherValue.radix))
            throw new IllegalArgumentException("incorrect radix of comparable");
        return null;
    }
 
    public Integer[] addIntegers(Integer[] first, Integer[] second) {
        return null;
    }
 
    @Override
    public int compareTo(NumeralSystem anotherValue) {
        if (!validRadix(anotherValue.radix))
            throw new IllegalArgumentException("incorrect radix of comparable");
        return compareBytes(chars, anotherValue.chars);
    }
 
}

import org.junit.Before;
import org.junit.Test;
 
import static org.junit.Assert.*;
 
public class NumeralSystemTest {
    NumeralSystem underTest;
 
    @Test
    public void shouldConvert() {
        underTest = new NumeralSystem(11, 2);
        Integer[] result = underTest.transformFrom(11, 8);
        Integer[] exptected = new Integer[] { 1, 3 };
        assertArrayEquals(exptected, result);
 
    }
 
    @Test
    public void shouldDisplayCorrectValueForDec() {
        underTest = new NumeralSystem(11, 8);
        int result = underTest.produceDecValue();
        int expected = 11;
        assertEquals(expected, result);
    }
 
    @Test
    public void shouldCompare() {
        underTest = new NumeralSystem(123, 8);
        NumeralSystem secondArg = new NumeralSystem(256, 8);
        int result = underTest.compareTo(secondArg);
        int expected = 1;
        assertEquals(expected, result);
 
        secondArg = new NumeralSystem(124, 8);
        result = underTest.compareTo(secondArg);
        expected = -1;
 
        assertEquals(expected, result);
 
        secondArg = new NumeralSystem(123, 8);
        result = underTest.compareTo(secondArg);
        expected = 0;
        assertEquals(expected, result);
 
    }
    
    @Test(expected=IllegalArgumentException.class)
    public void  shouldThrowOnCompareIncorrectRadix()
    {
        underTest = new NumeralSystem(11, 8);
        NumeralSystem secondArg = new NumeralSystem(256, 7);
        underTest.compareTo(secondArg);
    }
}