C# 转成java 一个算法

[lele_nancy]

第一次写java，C#的程序写好了，搞了一天还是做不出来，各位帮忙。

class Program
    {
        static int iData = 0;
        static int iGetLen = 0;
        static StringBuilder sb = new StringBuilder();
        static Dictionary<int, List<string>> dicNums = new Dictionary<int, List<string>>();
        static int SetLen = 0;
        static void Main(string[] args)
        {
            int n;
            while (int.TryParse(Console.ReadLine(), out n) == false)
            {
 
            }
            SetLen = n;
            DateTime startDt = DateTime.Now;

            PrintData(SetLen);
            TimeSpan ts = DateTime.Now - startDt;
            Console.WriteLine(ts.TotalMilliseconds);
            //Console.Read();
            //if (iData == iGetLen)
            //{
                foreach (KeyValuePair<int, List<string>> kvp in dicNums)
                {
                    foreach (string strdata in kvp.Value)
                    {
                        Console.WriteLine(strdata);
                    }
                }
                Console.WriteLine(string.Format("N({0}) = {0} * ({0} -1) +1)", n));
            //}
            //else
            //{ Console.WriteLine("解答不可"); }
             ts = DateTime.Now - startDt;
            Console.WriteLine(ts.TotalMilliseconds );
            Console.Read();
            
        }


        private static void PrintData(int iLen)
        {
            iData = iLen * (iLen - 1) + 1;
            var b = new int[iLen];
            var C = new List<int>();
            for(int i = 1;i<= iLen ;i++)
            {
                b[i-1] = i;
                C.Add(i);
            }
            for (int j = 1; j <= iLen; j++)
            {
                WriteCombinations<int>(b, j);
            }
        }

        static void WriteCombinations<T>(T[] array, int length)
        {
            var combinations = new Combinations<T>(array, length);
            List<string> lstNum = new List<string>();
            foreach (var oneCom in combinations)
            {
                //if (Utility.CheckData<T>(oneCom) == false) continue;
                string strData = Utility.GetString<T>(oneCom);
                //Console.WriteLine(strData);
                lstNum.Add(strData);
            }
            dicNums.Add(length, lstNum);
            iGetLen += lstNum.Count;
            //Console.WriteLine(combinations.ToString());
            //Console.WriteLine();
        }

        

        public static class Utility
        {
            /// <summary>
            /// IList(T)の要素を文字列化したものすべてを連結した文字列を取得します。
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="list"></param>
            /// <returns></returns>
            public static string GetString<T>(IList<T> list)
            {
                var sb = new StringBuilder();
                var isum = 0;
                foreach (T item in list)
                {
                    sb.Append(item.ToString() + "+");
                    isum += Convert.ToInt32(item);
                }

                if (sb.Length > 0) sb.Remove(sb.Length - 1, 1);
                sb.Append("=" + isum.ToString());
                return sb.ToString();
            }
          }

        public class Combinations<T>
        {
            #region メンバ
            private IList<T> _items;
            private int _length;
            private List<IList<T>> _combinations;
            private int[] _finalIndices;
            #endregion

            #region コンストラクタ
            public Combinations(IList<T> items) : this(items, items.Count) { }
            public Combinations(IList<T> items, int select)
            {
                if (select < 0)
                    throw new ArgumentException("選択要素数は、0以上でなくてはなりません。");
                if (items.Count < select)
                    throw new ArgumentException("選択要素数は、対象要素数以下でなくてはなりません。");

                _items = items;
                _length = select;
                _combinations = new List<IList<T>>();

                if (select == 0) return;

                _finalIndices = GetFinalIndices(select);
                ComputeCombination();
            }
            #endregion

            /// <summary>
            /// 選択要素数に応じた組み合わせとなる最後の値を取得します。(終端の確定)
            /// </summary>
            /// <param name="select"></param>
            /// <returns></returns>
            private int[] GetFinalIndices(int select)
            {
                var finalindices = new int[select];

                int j = select - 1;
                for (var i = _items.Count - 1; i > _items.Count - 1 - select; i--)
                {
                    finalindices[j] = i;
                    j--;
                }
                return finalindices;
            }

            #region プロパティ
            /// <summary>
            /// 組み合わせの要素数を取得します。
            /// </summary>
            public int Count
            {
                get { return _combinations.Count != 0 ? _combinations.Count : 1; }
            }
            #endregion

            /// <summary>
            /// 条件をもとに組み合わせを求めます。
            /// </summary>
            private void ComputeCombination()
            {
                if (_finalIndices.Length == 0) return;

                var indices = Enumerable.Range(0, _length).ToArray();
                _combinations.Add(GetCurrentCombination(indices));

                //while (NextCombination(indices))
                //{
                //    _combinations.Add(GetCurrentCombination(indices));
                //}
                while (indices[0] != _finalIndices [0])
                {
                    if (NextCombination(indices))
                        _combinations.Add(GetCurrentCombination(indices));
                }
            }

            /// <summary>
            /// 現在の組み合わせを取得します。
            /// </summary>
            /// <param name="indices"></param>
            /// <returns></returns>
            private T[] GetCurrentCombination(int[] indices)
            {
                T[] oneCom = new T[_length];
                for (var k = 0; k < _length; k++)
                {
                    oneCom[k] = _items[indices[k]];
                }
                return oneCom;
            }

            /// <summary>
            /// 次の組み合わせへ
            /// </summary>
            /// <param name="indices"></param>
            /// <returns></returns>
            private bool NextCombination(int[] indices)
            {
                for (var j = _finalIndices.Length - 1; j > -1; j--)
                {
                    if (indices[j] < _finalIndices[j])
                    {
                        indices[j]++;
                        for (var k = 1; j + k < _finalIndices.Length; k++)
                        {
                            indices[j + k] = indices[j] + k;
                        }
                        //if (indices[j] == _finalIndices[j])
                        break;
                    }
                    if (j == 0) return false;
                }
                List<List<int>> isUnable = indices.Aggregate(
                   new List<List<int>>(),    // TAccumulate（集計結果）の初期化
                   (accumulate, value) =>
                   {
                       if (accumulate.Count == 0)
                       {
                           accumulate.Add(new List<int>() { value });
                       }
                       else
                       {
                           var currentList = accumulate.Last();
                           var preValue = currentList.Last();
                           if (value - preValue == 1)
                           {
                               currentList.Add(value);
                           }
                           else
                           {
                               accumulate.Add(new List<int>() { value });
                           }
                       }

                       return accumulate;
                   });
                    //.Select(l => string.Join(", ", l))
                    //.ToList().ForEach(x => Console.WriteLine(x));
                if (isUnable.Count > 2)
                {
                    return false; 
                }
                else if (isUnable.Count == 2)
                {
                    if (isUnable[0].First() == 0 && isUnable[1].Last() == (_items.Count-1))
                        return true;
                    else
                        return false;
                }
                else { return true; }
            }

            /// <summary>
            /// イテレータ
            /// </summary>
            /// <returns></returns>
            public IEnumerator<IList<T>> GetEnumerator()
            {
                foreach (var item in _combinations) yield return item;
            }

            /// <summary>
            /// ToString
            /// </summary>
            /// <returns></returns>
            public override string ToString()
            {
                return string.Format("{0}C{1} Of [{2}] - {3}通り"
                        , _items.Count
                            , _length
                            , Utility.GetString<T>(_items)
                            , this.Count);
            }

        }
    }