Java SE 学习笔记02 代码

数组相关API

 

Java代码

1. /**
2. * 测试Arrays类
3. */
4. package org.sean.module02;
5. import java.util.Arrays;
6. /**
7. * @author 不落的太阳(Sean Yang)
8. */
9. public class TestArrays {
10. /**
11. * 整型数组输出
12. *
13. * @param array
14. */
15. public static void iterator(int[] array) {
16. if (array != null) {
17. for (int i = 0; i < array.length; i++) {
18. System.out.print(array[i] + " ");
19. }
20. }
21. System.out.println();
22. }
23. public static void main(String[] args) {
24. /** 填充整个数组 */
25. int[] array0 = new int[10];
26. Arrays.fill(array0, 5);
27. iterator(array0);
28. /** 填充数组的指定位置 */
29. Arrays.fill(array0, 3, 8, 10);
30. iterator(array0);
31. /** 数组的排序 */
32. int[] array1 = { 7, 8, 4, 5, 1, 12, 9 };
33. System.out.print("排序前");
34. iterator(array1);
35. Arrays.sort(array1);
36. System.out.print("排序后");
37. iterator(array1);
38. /** 数组内容的比较 */
39. char[] array2 = { 'a', 'b', 'c' };
40. char[] array3 = { 'a', 'b', 'c' };
41. System.out.println(Arrays.equals(array2, array3));
42. String str1 = new String(array2);
43. String str2 = new String(array3);
44. System.out.println(str1.equals(str2));
45. /**
46. * 使用二分法在数组中查找指定元素 如果找到返回该元素的下标，如果不存在则返回负数
47. *
48. * 使用二分法查找的数组必须经过排序
49. */
50. System.out.println(Arrays.binarySearch(array1, 4));
51. /**
52. * 数组拷贝
53. *
54. * arraycopy(源数组, 源数组的起始位置, 目标数组, 目标数组的起始位置, 拷贝几个元素);
55. */
56. int[] array4 = { 1, 2, 3, 4, 5 };
57. int[] array5 = new int[5];
58. System.arraycopy(array4, 1, array5, 0, 3);
59. iterator(array5);
60. /**
61. * JDK6.0数组拷贝
62. */
63. int[] array6 = new int[7];
64. array6 = Arrays.copyOf(array4, array4.length);
65. iterator(array6);
66. }
67. }

/**
 * 测试Arrays类
 */
package org.sean.module02;

import java.util.Arrays;

/**
 * @author 不落的太阳(Sean Yang)
 */
public class TestArrays {

	/**
	 * 整型数组输出
	 * 
	 * @param array
	 */
	public static void iterator(int[] array) {
		if (array != null) {
			for (int i = 0; i < array.length; i++) {
				System.out.print(array[i] + " ");
			}
		}
		System.out.println();
	}

	public static void main(String[] args) {
		/** 填充整个数组 */
		int[] array0 = new int[10];
		Arrays.fill(array0, 5);
		iterator(array0);
		/** 填充数组的指定位置 */
		Arrays.fill(array0, 3, 8, 10);
		iterator(array0);

		/** 数组的排序 */
		int[] array1 = { 7, 8, 4, 5, 1, 12, 9 };
		System.out.print("排序前");
		iterator(array1);
		Arrays.sort(array1);
		System.out.print("排序后");
		iterator(array1);

		/** 数组内容的比较 */
		char[] array2 = { 'a', 'b', 'c' };
		char[] array3 = { 'a', 'b', 'c' };
		System.out.println(Arrays.equals(array2, array3));
		String str1 = new String(array2);
		String str2 = new String(array3);
		System.out.println(str1.equals(str2));

		/**
		 * 使用二分法在数组中查找指定元素 如果找到返回该元素的下标，如果不存在则返回负数
		 * 
		 * 使用二分法查找的数组必须经过排序
		 */
		System.out.println(Arrays.binarySearch(array1, 4));

		/**
		 * 数组拷贝
		 * 
		 * arraycopy(源数组, 源数组的起始位置, 目标数组, 目标数组的起始位置, 拷贝几个元素);
		 */
		int[] array4 = { 1, 2, 3, 4, 5 };
		int[] array5 = new int[5];
		System.arraycopy(array4, 1, array5, 0, 3);
		iterator(array5);
		
		/**
		 * JDK6.0数组拷贝
		 */
		int[] array6 = new int[7];
		array6 = Arrays.copyOf(array4, array4.length);
		iterator(array6);
	}
}

 

约瑟夫问题使用数组解决

 

 

Java代码

1. /**
2. * 约瑟夫问题
3. */
4. package org.sean.module02;
5. /**
6. * @author 不落的太阳(Sean Yang)
7. */
8. public class Count3Quit {
9. /**
10. * 首先判断数组里面的元素是否为true，即人员是否在圈中，如果为true则继续计数，计数器累加
11. * 当计数器到达3的时候，首先计数器要归零，，然后boolean数组中该位置的元素要置为false， 同时总数减少一个，索引下标增加一个
12. * 由于多人首尾相连，所以当到达最后一个元素的时候，索引要归零
13. *
14. * @param array
15. * 要检测的数组
16. */
17. public static void count3Quit(boolean[] array) {
18. for (int i = 0; i < array.length; i++) {
19. array[i] = true;
20. }
21. // 计数器
22. int counter = 0;
23. // 剩余人数
24. int leftCount = array.length;
25. // 索引
26. int index = 0;
27. while (leftCount > 1) {
28. if (array[index] == true) {
29. counter++;
30. if (counter == 3) {
31. counter = 0;
32. array[index] = false;
33. leftCount--;
34. }
35. }
36. index++;
37. if (index == array.length) {
38. index = 0;
39. }
40. }
41. for (int i = 0; i < array.length; i++) {
42. if (array[i] == true) {
43. System.out.println("剩余人员的位置是" + (i + 1));
44. }
45. }
46. }
47. public static void main(String[] args) {
48. boolean[] array = new boolean[500];
49. count3Quit(array);
50. }
51. }

/**
 * 约瑟夫问题
 */
package org.sean.module02;

/**
 * @author 不落的太阳(Sean Yang)
 */
public class Count3Quit {

	/**
	 * 首先判断数组里面的元素是否为true，即人员是否在圈中，如果为true则继续计数，计数器累加
	 * 当计数器到达3的时候，首先计数器要归零，，然后boolean数组中该位置的元素要置为false， 同时总数减少一个，索引下标增加一个
	 * 由于多人首尾相连，所以当到达最后一个元素的时候，索引要归零
	 * 
	 * @param array
	 *            要检测的数组
	 */
	public static void count3Quit(boolean[] array) {
		for (int i = 0; i < array.length; i++) {
			array[i] = true;
		}

		// 计数器
		int counter = 0;
		// 剩余人数
		int leftCount = array.length;
		// 索引
		int index = 0;

		while (leftCount > 1) {
			if (array[index] == true) {
				counter++;
				if (counter == 3) {
					counter = 0;
					array[index] = false;
					leftCount--;
				}
			}
			index++;
			if (index == array.length) {
				index = 0;
			}
		}

		for (int i = 0; i < array.length; i++) {
			if (array[i] == true) {
				System.out.println("剩余人员的位置是" + (i + 1));
			}
		}
	}

	public static void main(String[] args) {
		boolean[] array = new boolean[500];
		count3Quit(array);
	}
}