用四種方法實現了將陣列元素迴圈右移k個位置，相關的解釋作為註釋放在程式碼裡面了。

package movearrayelement;

import java.util.BitSet;

public class MoveArrayElement {
	/**
	 * 每次把陣列中所有元素移動一個位置，移動k輪
	 * @param array
	 * @param k
	 */
	public static void moveArrayElement(int[] array, int k) {
		int length = array.length;
		// 右移newk + n * length個位置，和右移newk個位置效果是一樣的
		int newk = k % length;
		int temp = 0;
		for(int i = 0; i < newk; i++) {
			temp = array[length - 1];
			for(int j = length - 2; j >= 0; j--) {
				array[j+1]=array[j];
			}
			array[0]=temp;
		}
	}
	
	/**
	 * 開闢一個新陣列，把舊陣列中的元素直接放在新陣列中正確的位置
	 * @param array
	 * @param k
	 * @return
	 */
	public static int[] moveArrayElement1(int[] array, int k) {
		int length = array.length;
		// 右移newk + n * length個位置，和右移newk個位置效果是一樣的
		int newk = k % length;
		int[] newArray = new int[length];
		// 重複length次把元素從舊位置移到新位置
		for(int i = 0; i < length; i++) {
			// 求出元素新的位置
			int newPosition = (i + newk) % length;
			newArray[newPosition] = array[i];
		}
		return newArray;
	}
	
	/**
	 * 1.把一個元素放在一個正確的位置，再把被佔位置的元素放到它應該在的正確的位置，一直
	 * 重複下去，直到陣列的所有元素都放在了正確的位置；
	 * 2.但是必須考慮環形的情況，比如十個元素的陣列，右移5個位置，這時，位置0的元素應該放在位置5，
	 * 位置5的元素應該放在位置0，這樣，完全通過1的迭代就不能得到 正確的結果
	 * @param array
	 * @param k
	 */
	public static void moveArrayElement2(int[] array, int k) {
		int length = array.length;
		
		BitSet bitSet = new BitSet(length);
		boolean flag = false;
		// 保證最多隻移動count=length次位置
		int count = 0;
		for(int j = 0; j < length; j++) {
			if (flag) {
				break;
			}
			if (!bitSet.get(j)) {
				// 右移newk + n * length個位置，和右移newk個位置效果是一樣的
				int newk = k % length;
				// 舊位置
				int oldPosition = j;
				// 儲存舊位置的值
				int oldValue = array[oldPosition];
				// 臨時值
				int temp = 0;
				// 重複length次把元素從舊位置移到新位置
				for(int i = 0; i < length; i++) {
					// 求出元素新的位置
					int newPosition = (oldPosition + newk) % length;
					// 如果新位置已經放置了對得值，就不要往新位置再次放入值了
					if (bitSet.get(newPosition)) {
						break;
					}
					// 臨時儲存新位置(也就是新的舊位置)的值
					temp = array[newPosition];
					// 移動元素到新位置
					array[newPosition] = oldValue;
					// 又一個位置放置了正確的值
					count++;
					if (count == length) {
						flag = true;
						break;
					}
					// 新位置放置了正確的值
					bitSet.set(newPosition);
					// 永久儲存舊位置的值
					oldValue = temp;
					// 新位置變為舊位置
					oldPosition = newPosition;
				}
			}
		}
		System.out.println(count);
	}
	
	/**
	 * 經典方法，三次倒置陣列中對應位置的元素;
	 * 簡單說一下原理：陣列元素右移k個位置的結果是，原來在
	 * 後面的k個元素跑到了陣列前面，原來在前面的length-k
	 * 個元素，跑到了陣列的後面，並且前後兩部分元素各自的順序和
	 * 移動前一致，而倒置整個陣列元素就是讓後面k個元素跑到前面去，
	 * 讓前面length-k個元素跑到後面去，但是倒置之後前後兩部分
	 * 元素的順序跟移動之前不一樣了，倒置了，所以要把兩部分的元素
	 * 倒置回來
	 * @param array
	 * @param k
	 */
	public static void moveArrayElement3(int[] array, int k) {
		// 倒置所有元素
		reverse(array);
		// 倒置前k個元素
		reverse(array, 0, k - 1);
		// 倒置後length - k個元素
		reverse(array, k, array.length - 1);
	}
	
	/**
	 * 倒置陣列中begin和end之間的元素，包括begin和end
	 * @param array
	 * @param begin
	 * @param end
	 */
	private static void reverse(int[] array, int begin, int end) {
		int length = end - begin + 1;
		int half = length / 2;
		for(int i = 0; i < half; i++) {
			int temp = array[begin];
			array[begin] = array[end];
			array[end] = temp;
			begin++;
			end--;
		}
		
	}
	
	/**
	 * 倒置陣列中begin和end之間的元素，包括begin和end
	 * @param array
	 * @param begin
	 * @param end
	 */
	private static void reverse(int[] array) {
		reverse(array, 0, array.length - 1);
	}
}