- 浏览: 235980 次
- 性别:
- 来自: 深圳
文章分类
最新评论
-
wahahachuang8:
GoEasy 实时推送支持IE6-IE11及大多数主流浏览器的 ...
服务器推送技术 java -
mahuanjian:
[flash=200,200][/flash]
服务器推送技术 java -
wenjundiandian:
下面有网页编辑器的话还是会被隐藏.
ext中消息框、提示框、确认框显示在最前面的解决方法 -
天塔上的猫:
/**
* JAVA常见的权限控制算法的实现
*
* ...
JAVA常见的权限控制算法的实现
- package sort;
- import java.util.Random;
- /**
- * 排序测试类
- *
- * 排序算法的分类如下: 1.插入排序(直接插入排序、折半插入排序、希尔排序); 2.交换排序(冒泡泡排序、快速排序);
- * 3.选择排序(直接选择排序、堆排序); 4.归并排序; 5.基数排序。
- *
- * 关于排序方法的选择: (1)若n较小(如n≤50),可采用直接插入或直接选择排序。
- * 当记录规模较小时,直接插入排序较好;否则因为直接选择移动的记录数少于直接插人,应选直接选择排序为宜。
- * (2)若文件初始状态基本有序(指正序),则应选用直接插人、冒泡或随机的快速排序为宜;
- * (3)若n较大,则应采用时间复杂度为O(nlgn)的排序方法:快速排序、堆排序或归并排序。
- *
- */
- /**
- * @corporation 北京环亚
- * @author HDS
- * @date Nov 19, 2009 10:43:44 AM
- * @path sort
- * @description JAVA排序汇总
- */
- public class SortTest {
- // //////==============================产生随机数==============================///////////////////
- /**
- * @description 生成随机数
- * @date Nov 19, 2009
- * @author HDS
- * @return int[]
- */
- public int[] createArray() {
- Random random = new Random();
- int[] array = new int[10];
- for (int i = 0; i < 10; i++) {
- array[i] = random.nextInt(100) - random.nextInt(100);// 生成两个随机数相减,保证生成的数中有负数
- }
- System.out.println("==========原始序列==========");
- printArray(array);
- return array;
- }
- /**
- * @description 打印出随机数
- * @date Nov 19, 2009
- * @author HDS
- * @param data
- */
- public void printArray(int[] data) {
- for (int i : data) {
- System.out.print(i + " ");
- }
- System.out.println();
- }
- /**
- * @description 交换相邻两个数
- * @date Nov 19, 2009
- * @author HDS
- * @param data
- * @param x
- * @param y
- */
- public void swap(int[] data, int x, int y) {
- int temp = data[x];
- data[x] = data[y];
- data[y] = temp;
- }
- /**
- * 冒泡排序----交换排序的一种
- * 方法:相邻两元素进行比较,如有需要则进行交换,每完成一次循环就将最大元素排在最后(如从小到大排序),下一次循环是将其他的数进行类似操作。
- * 性能:比较次数O(n^2),n^2/2;交换次数O(n^2),n^2/4
- *
- * @param data
- * 要排序的数组
- * @param sortType
- * 排序类型
- * @return
- */
- public void bubbleSort(int[] data, String sortType) {
- if (sortType.equals("asc")) { // 正排序,从小排到大
- // 比较的轮数
- for (int i = 1; i < data.length; i++) { // 数组有多长,轮数就有多长
- // 将相邻两个数进行比较,较大的数往后冒泡
- for (int j = 0; j < data.length - i; j++) {// 每一轮下来会将比较的次数减少
- if (data[j] > data[j + 1]) {
- // 交换相邻两个数
- swap(data, j, j + 1);
- }
- }
- }
- } else if (sortType.equals("desc")) { // 倒排序,从大排到小
- // 比较的轮数
- for (int i = 1; i < data.length; i++) {
- // 将相邻两个数进行比较,较大的数往后冒泡
- for (int j = 0; j < data.length - i; j++) {
- if (data[j] < data[j + 1]) {
- // 交换相邻两个数
- swap(data, j, j + 1);
- }
- }
- }
- } else {
- System.out.println("您输入的排序类型错误!");
- }
- printArray(data);// 输出冒泡排序后的数组值
- }
- /**
- * 直接选择排序法----选择排序的一种 方法:每一趟从待排序的数据元素中选出最小(或最大)的一个元素,
- * 顺序放在已排好序的数列的最后,直到全部待排序的数据元素排完。 性能:比较次数O(n^2),n^2/2 交换次数O(n),n
- * 交换次数比冒泡排序少多了,由于交换所需CPU时间比比较所需的CUP时间多,所以选择排序比冒泡排序快。
- * 但是N比较大时,比较所需的CPU时间占主要地位,所以这时的性能和冒泡排序差不太多,但毫无疑问肯定要快些。
- *
- * @param data
- * 要排序的数组
- * @param sortType
- * 排序类型
- * @return
- */
- public void selectSort(int[] data, String sortType) {
- if (sortType.endsWith("asc")) {// 正排序,从小排到大
- int index;
- for (int i = 1; i < data.length; i++) {
- index = 0;
- for (int j = 1; j <= data.length - i; j++) {
- if (data[j] > data[index]) {
- index = j;
- }
- }
- // 交换在位置data.length-i和index(最大值)两个数
- swap(data, data.length - i, index);
- }
- } else if (sortType.equals("desc")) { // 倒排序,从大排到小
- int index;
- for (int i = 1; i < data.length; i++) {
- index = 0;
- for (int j = 1; j <= data.length - i; j++) {
- if (data[j] < data[index]) {
- index = j;
- }
- }
- // 交换在位置data.length-i和index(最大值)两个数
- swap(data, data.length - i, index);
- }
- } else {
- System.out.println("您输入的排序类型错误!");
- }
- printArray(data);// 输出直接选择排序后的数组值
- }
- /**
- * 插入排序 方法:将一个记录插入到已排好序的有序表(有可能是空表)中,从而得到一个新的记录数增1的有序表。 性能:比较次数O(n^2),n^2/4
- * 复制次数O(n),n^2/4 比较次数是前两者的一般,而复制所需的CPU时间较交换少,所以性能上比冒泡排序提高一倍多,而比选择排序也要快。
- *
- * @param data
- * 要排序的数组
- * @param sortType
- * 排序类型
- */
- public void insertSort(int[] data, String sortType) {
- if (sortType.equals("asc")) { // 正排序,从小排到大
- // 比较的轮数
- for (int i = 1; i < data.length; i++) {
- // 保证前i+1个数排好序
- for (int j = 0; j < i; j++) {
- if (data[j] > data[i]) {
- // 交换在位置j和i两个数
- swap(data, i, j);
- }
- }
- }
- } else if (sortType.equals("desc")) { // 倒排序,从大排到小
- // 比较的轮数
- for (int i = 1; i < data.length; i++) {
- // 保证前i+1个数排好序
- for (int j = 0; j < i; j++) {
- if (data[j] < data[i]) {
- // 交换在位置j和i两个数
- swap(data, i, j);
- }
- }
- }
- } else {
- System.out.println("您输入的排序类型错误!");
- }
- printArray(data);// 输出插入排序后的数组值
- }
- /**
- * 反转数组的方法
- *
- * @param data
- * 源数组
- */
- public void reverse(int[] data) {
- int length = data.length;
- int temp = 0;// 临时变量
- for (int i = 0; i < length / 2; i++) {
- temp = data[i];
- data[i] = data[length - 1 - i];
- data[length - 1 - i] = temp;
- }
- printArray(data);// 输出到转后数组的值
- }
- /**
- * 快速排序 快速排序使用分治法(Divide and conquer)策略来把一个序列(list)分为两个子序列(sub-lists)。 步骤为:
- * 1. 从数列中挑出一个元素,称为 "基准"(pivot), 2.
- * 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分割之后,该基准是它的最后位置。这个称为分割(partition)操作。
- * 3. 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。
- * 递回的最底部情形,是数列的大小是零或一,也就是永远都已经被排序好了。虽然一直递回下去,但是这个算法总会结束,因为在每次的迭代(iteration)中,它至少会把一个元素摆到它最后的位置去。
- *
- * @param data
- * 待排序的数组
- * @param low
- * @param high
- * @see SortTest#qsort(int[], int, int)
- * @see SortTest#qsort_desc(int[], int, int)
- */
- public void quickSort(int[] data, String sortType) {
- if (sortType.equals("asc")) { // 正排序,从小排到大
- qsort_asc(data, 0, data.length - 1);
- } else if (sortType.equals("desc")) { // 倒排序,从大排到小
- qsort_desc(data, 0, data.length - 1);
- } else {
- System.out.println("您输入的排序类型错误!");
- }
- }
- /**
- * 快速排序的具体实现,排正序
- *
- * @param data
- * @param low
- * @param high
- */
- private void qsort_asc(int data[], int low, int high) {
- int i, j, x;
- if (low < high) { // 这个条件用来结束递归
- i = low;
- j = high;
- x = data[i];
- while (i < j) {
- while (i < j && data[j] > x) {
- j--; // 从右向左找第一个小于x的数
- }
- if (i < j) {
- data[i] = data[j];
- i++;
- }
- while (i < j && data[i] < x) {
- i++; // 从左向右找第一个大于x的数
- }
- if (i < j) {
- data[j] = data[i];
- j--;
- }
- }
- data[i] = x;
- qsort_asc(data, low, i - 1);
- qsort_asc(data, i + 1, high);
- }
- }
- /**
- * 快速排序的具体实现,排倒序
- *
- * @param data
- * @param low
- * @param high
- */
- private void qsort_desc(int data[], int low, int high) {
- int i, j, x;
- if (low < high) { // 这个条件用来结束递归
- i = low;
- j = high;
- x = data[i];
- while (i < j) {
- while (i < j && data[j] < x) {
- j--; // 从右向左找第一个小于x的数
- }
- if (i < j) {
- data[i] = data[j];
- i++;
- }
- while (i < j && data[i] > x) {
- i++; // 从左向右找第一个大于x的数
- }
- if (i < j) {
- data[j] = data[i];
- j--;
- }
- }
- data[i] = x;
- qsort_desc(data, low, i - 1);
- qsort_desc(data, i + 1, high);
- }
- }
- /**
- * 二分查找特定整数在整型数组中的位置(递归) 查找线性表必须是有序列表
- *
- * @paramdataset
- * @paramdata
- * @parambeginIndex
- * @paramendIndex
- * @returnindex
- */
- public int binarySearch(int[] dataset, int data, int beginIndex,
- int endIndex) {
- int midIndex = (beginIndex + endIndex) >>> 1; // 相当于mid = (low + high)
- // / 2,但是效率会高些
- if (data < dataset[beginIndex] || data > dataset[endIndex]
- || beginIndex > endIndex)
- return -1;
- if (data < dataset[midIndex]) {
- return binarySearch(dataset, data, beginIndex, midIndex - 1);
- } else if (data > dataset[midIndex]) {
- return binarySearch(dataset, data, midIndex + 1, endIndex);
- } else {
- return midIndex;
- }
- }
- /**
- * 二分查找特定整数在整型数组中的位置(非递归) 查找线性表必须是有序列表
- *
- * @paramdataset
- * @paramdata
- * @returnindex
- */
- public int binarySearch(int[] dataset, int data) {
- int beginIndex = 0;
- int endIndex = dataset.length - 1;
- int midIndex = -1;
- if (data < dataset[beginIndex] || data > dataset[endIndex]
- || beginIndex > endIndex)
- return -1;
- while (beginIndex <= endIndex) {
- midIndex = (beginIndex + endIndex) >>> 1; // 相当于midIndex =
- // (beginIndex +
- // endIndex) / 2,但是效率会高些
- if (data < dataset[midIndex]) {
- endIndex = midIndex - 1;
- } else if (data > dataset[midIndex]) {
- beginIndex = midIndex + 1;
- } else {
- return midIndex;
- }
- }
- return -1;
- }
- // /////////////////////===================================测试====================//////////////////
- public static void main(String[] args) {
- SortTest ST = new SortTest();
- int[] array = ST.createArray();
- System.out.println("==========冒泡排序后(正序)==========");
- ST.bubbleSort(array, "asc");
- System.out.println("==========冒泡排序后(倒序)==========");
- ST.bubbleSort(array, "desc");
- array = ST.createArray();
- System.out.println("==========选择排序后(正序)==========");
- ST.selectSort(array, "asc");
- System.out.println("==========选择排序后(倒序)==========");
- ST.selectSort(array, "desc");
- array = ST.createArray();
- System.out.println("==========插入排序后(正序)==========");
- ST.insertSort(array, "asc");
- System.out.println("==========插入排序后(倒序)==========");
- ST.insertSort(array, "desc");
- array = ST.createArray();
- System.out.println("==========快速排序后(正序)==========");
- ST.quickSort(array, "asc");
- ST.printArray(array);
- System.out.println("==========快速排序后(倒序)==========");
- ST.quickSort(array, "desc");
- ST.printArray(array);
- System.out.println("==========数组二分查找==========");
- System.out.println("您要找的数在第" + ST.binarySearch(array, 74)+ "个位子。(下标从0计算)");
- }
- }
package sort; import java.util.Random; /** * 排序测试类 * * 排序算法的分类如下: 1.插入排序(直接插入排序、折半插入排序、希尔排序); 2.交换排序(冒泡泡排序、快速排序); * 3.选择排序(直接选择排序、堆排序); 4.归并排序; 5.基数排序。 * * 关于排序方法的选择: (1)若n较小(如n≤50),可采用直接插入或直接选择排序。 * 当记录规模较小时,直接插入排序较好;否则因为直接选择移动的记录数少于直接插人,应选直接选择排序为宜。 * (2)若文件初始状态基本有序(指正序),则应选用直接插人、冒泡或随机的快速排序为宜; * (3)若n较大,则应采用时间复杂度为O(nlgn)的排序方法:快速排序、堆排序或归并排序。 * */ /** * @corporation 北京环亚 * @author HDS * @date Nov 19, 2009 10:43:44 AM * @path sort * @description JAVA排序汇总 */ public class SortTest { // //////==============================产生随机数==============================/////////////////// /** * @description 生成随机数 * @date Nov 19, 2009 * @author HDS * @return int[] */ public int[] createArray() { Random random = new Random(); int[] array = new int[10]; for (int i = 0; i < 10; i++) { array[i] = random.nextInt(100) - random.nextInt(100);// 生成两个随机数相减,保证生成的数中有负数 } System.out.println("==========原始序列=========="); printArray(array); return array; } /** * @description 打印出随机数 * @date Nov 19, 2009 * @author HDS * @param data */ public void printArray(int[] data) { for (int i : data) { System.out.print(i + " "); } System.out.println(); } /** * @description 交换相邻两个数 * @date Nov 19, 2009 * @author HDS * @param data * @param x * @param y */ public void swap(int[] data, int x, int y) { int temp = data[x]; data[x] = data[y]; data[y] = temp; } /** * 冒泡排序----交换排序的一种 * 方法:相邻两元素进行比较,如有需要则进行交换,每完成一次循环就将最大元素排在最后(如从小到大排序),下一次循环是将其他的数进行类似操作。 * 性能:比较次数O(n^2),n^2/2;交换次数O(n^2),n^2/4 * * @param data * 要排序的数组 * @param sortType * 排序类型 * @return */ public void bubbleSort(int[] data, String sortType) { if (sortType.equals("asc")) { // 正排序,从小排到大 // 比较的轮数 for (int i = 1; i < data.length; i++) { // 数组有多长,轮数就有多长 // 将相邻两个数进行比较,较大的数往后冒泡 for (int j = 0; j < data.length - i; j++) {// 每一轮下来会将比较的次数减少 if (data[j] > data[j + 1]) { // 交换相邻两个数 swap(data, j, j + 1); } } } } else if (sortType.equals("desc")) { // 倒排序,从大排到小 // 比较的轮数 for (int i = 1; i < data.length; i++) { // 将相邻两个数进行比较,较大的数往后冒泡 for (int j = 0; j < data.length - i; j++) { if (data[j] < data[j + 1]) { // 交换相邻两个数 swap(data, j, j + 1); } } } } else { System.out.println("您输入的排序类型错误!"); } printArray(data);// 输出冒泡排序后的数组值 } /** * 直接选择排序法----选择排序的一种 方法:每一趟从待排序的数据元素中选出最小(或最大)的一个元素, * 顺序放在已排好序的数列的最后,直到全部待排序的数据元素排完。 性能:比较次数O(n^2),n^2/2 交换次数O(n),n * 交换次数比冒泡排序少多了,由于交换所需CPU时间比比较所需的CUP时间多,所以选择排序比冒泡排序快。 * 但是N比较大时,比较所需的CPU时间占主要地位,所以这时的性能和冒泡排序差不太多,但毫无疑问肯定要快些。 * * @param data * 要排序的数组 * @param sortType * 排序类型 * @return */ public void selectSort(int[] data, String sortType) { if (sortType.endsWith("asc")) {// 正排序,从小排到大 int index; for (int i = 1; i < data.length; i++) { index = 0; for (int j = 1; j <= data.length - i; j++) { if (data[j] > data[index]) { index = j; } } // 交换在位置data.length-i和index(最大值)两个数 swap(data, data.length - i, index); } } else if (sortType.equals("desc")) { // 倒排序,从大排到小 int index; for (int i = 1; i < data.length; i++) { index = 0; for (int j = 1; j <= data.length - i; j++) { if (data[j] < data[index]) { index = j; } } // 交换在位置data.length-i和index(最大值)两个数 swap(data, data.length - i, index); } } else { System.out.println("您输入的排序类型错误!"); } printArray(data);// 输出直接选择排序后的数组值 } /** * 插入排序 方法:将一个记录插入到已排好序的有序表(有可能是空表)中,从而得到一个新的记录数增1的有序表。 性能:比较次数O(n^2),n^2/4 * 复制次数O(n),n^2/4 比较次数是前两者的一般,而复制所需的CPU时间较交换少,所以性能上比冒泡排序提高一倍多,而比选择排序也要快。 * * @param data * 要排序的数组 * @param sortType * 排序类型 */ public void insertSort(int[] data, String sortType) { if (sortType.equals("asc")) { // 正排序,从小排到大 // 比较的轮数 for (int i = 1; i < data.length; i++) { // 保证前i+1个数排好序 for (int j = 0; j < i; j++) { if (data[j] > data[i]) { // 交换在位置j和i两个数 swap(data, i, j); } } } } else if (sortType.equals("desc")) { // 倒排序,从大排到小 // 比较的轮数 for (int i = 1; i < data.length; i++) { // 保证前i+1个数排好序 for (int j = 0; j < i; j++) { if (data[j] < data[i]) { // 交换在位置j和i两个数 swap(data, i, j); } } } } else { System.out.println("您输入的排序类型错误!"); } printArray(data);// 输出插入排序后的数组值 } /** * 反转数组的方法 * * @param data * 源数组 */ public void reverse(int[] data) { int length = data.length; int temp = 0;// 临时变量 for (int i = 0; i < length / 2; i++) { temp = data[i]; data[i] = data[length - 1 - i]; data[length - 1 - i] = temp; } printArray(data);// 输出到转后数组的值 } /** * 快速排序 快速排序使用分治法(Divide and conquer)策略来把一个序列(list)分为两个子序列(sub-lists)。 步骤为: * 1. 从数列中挑出一个元素,称为 "基准"(pivot), 2. * 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分割之后,该基准是它的最后位置。这个称为分割(partition)操作。 * 3. 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。 * 递回的最底部情形,是数列的大小是零或一,也就是永远都已经被排序好了。虽然一直递回下去,但是这个算法总会结束,因为在每次的迭代(iteration)中,它至少会把一个元素摆到它最后的位置去。 * * @param data * 待排序的数组 * @param low * @param high * @see SortTest#qsort(int[], int, int) * @see SortTest#qsort_desc(int[], int, int) */ public void quickSort(int[] data, String sortType) { if (sortType.equals("asc")) { // 正排序,从小排到大 qsort_asc(data, 0, data.length - 1); } else if (sortType.equals("desc")) { // 倒排序,从大排到小 qsort_desc(data, 0, data.length - 1); } else { System.out.println("您输入的排序类型错误!"); } } /** * 快速排序的具体实现,排正序 * * @param data * @param low * @param high */ private void qsort_asc(int data[], int low, int high) { int i, j, x; if (low < high) { // 这个条件用来结束递归 i = low; j = high; x = data[i]; while (i < j) { while (i < j && data[j] > x) { j--; // 从右向左找第一个小于x的数 } if (i < j) { data[i] = data[j]; i++; } while (i < j && data[i] < x) { i++; // 从左向右找第一个大于x的数 } if (i < j) { data[j] = data[i]; j--; } } data[i] = x; qsort_asc(data, low, i - 1); qsort_asc(data, i + 1, high); } } /** * 快速排序的具体实现,排倒序 * * @param data * @param low * @param high */ private void qsort_desc(int data[], int low, int high) { int i, j, x; if (low < high) { // 这个条件用来结束递归 i = low; j = high; x = data[i]; while (i < j) { while (i < j && data[j] < x) { j--; // 从右向左找第一个小于x的数 } if (i < j) { data[i] = data[j]; i++; } while (i < j && data[i] > x) { i++; // 从左向右找第一个大于x的数 } if (i < j) { data[j] = data[i]; j--; } } data[i] = x; qsort_desc(data, low, i - 1); qsort_desc(data, i + 1, high); } } /** * 二分查找特定整数在整型数组中的位置(递归) 查找线性表必须是有序列表 * * @paramdataset * @paramdata * @parambeginIndex * @paramendIndex * @returnindex */ public int binarySearch(int[] dataset, int data, int beginIndex, int endIndex) { int midIndex = (beginIndex + endIndex) >>> 1; // 相当于mid = (low + high) // / 2,但是效率会高些 if (data < dataset[beginIndex] || data > dataset[endIndex] || beginIndex > endIndex) return -1; if (data < dataset[midIndex]) { return binarySearch(dataset, data, beginIndex, midIndex - 1); } else if (data > dataset[midIndex]) { return binarySearch(dataset, data, midIndex + 1, endIndex); } else { return midIndex; } } /** * 二分查找特定整数在整型数组中的位置(非递归) 查找线性表必须是有序列表 * * @paramdataset * @paramdata * @returnindex */ public int binarySearch(int[] dataset, int data) { int beginIndex = 0; int endIndex = dataset.length - 1; int midIndex = -1; if (data < dataset[beginIndex] || data > dataset[endIndex] || beginIndex > endIndex) return -1; while (beginIndex <= endIndex) { midIndex = (beginIndex + endIndex) >>> 1; // 相当于midIndex = // (beginIndex + // endIndex) / 2,但是效率会高些 if (data < dataset[midIndex]) { endIndex = midIndex - 1; } else if (data > dataset[midIndex]) { beginIndex = midIndex + 1; } else { return midIndex; } } return -1; } // /////////////////////===================================测试====================////////////////// public static void main(String[] args) { SortTest ST = new SortTest(); int[] array = ST.createArray(); System.out.println("==========冒泡排序后(正序)=========="); ST.bubbleSort(array, "asc"); System.out.println("==========冒泡排序后(倒序)=========="); ST.bubbleSort(array, "desc"); array = ST.createArray(); System.out.println("==========选择排序后(正序)=========="); ST.selectSort(array, "asc"); System.out.println("==========选择排序后(倒序)=========="); ST.selectSort(array, "desc"); array = ST.createArray(); System.out.println("==========插入排序后(正序)=========="); ST.insertSort(array, "asc"); System.out.println("==========插入排序后(倒序)=========="); ST.insertSort(array, "desc"); array = ST.createArray(); System.out.println("==========快速排序后(正序)=========="); ST.quickSort(array, "asc"); ST.printArray(array); System.out.println("==========快速排序后(倒序)=========="); ST.quickSort(array, "desc"); ST.printArray(array); System.out.println("==========数组二分查找=========="); System.out.println("您要找的数在第" + ST.binarySearch(array, 74)+ "个位子。(下标从0计算)"); } }
参考文献:http://www.blogjava.net/yaozhongping/archive/2009/11/18/302832.html
来源:http://www.iteye.com/topic/548520
发表评论
-
利用 Heritrix 构建特定站点爬虫
2011-01-12 13:42 896Heritrix 是一个由 java 开 ... -
java解析xml文件四种方式
2011-01-10 16:23 7671.介绍 1)DOM(JAXP Crims ... -
Spring AOP的两种实现方式
2010-12-10 09:16 907来源:http://javacrazyer.iteye.com ... -
详解Java解析XML的四种方法
2010-12-09 22:31 851来源:http://mengsina.iteye.co ... -
(转载)手写压缩软件,超详细解释(哈夫曼实现)
2010-12-07 11:17 1099转载自:http://stchou.iteye.com/b ... -
java通过包装器防SQL注入
2010-01-29 11:04 1252定义包装器对request进行 ... -
comparable 与comparator的区别
2010-01-29 09:12 956Comparable & Comparator 都是用 ... -
Java经典问题算法大全
2010-01-28 20:52 3041/*【程序1】题目:古典 ... -
Java各种排序算法
2010-01-28 20:50 928/*** 排序测试类* * 排序算法的分类如下:* 1.插入排 ... -
Java细节总结
2010-01-28 20:46 708TURE、FALSE、NULL等都不是Java关键字; 数组 ... -
设计异常管理系统
2010-01-28 20:37 849——针对有效的错误处理设计异常管理系统 作者:Jean-Pie ... -
使用Filter快速对网页资源进行缓存
2010-01-28 20:18 899使用Filter快速对网页资源进行缓存,在网页资源没有改变的情 ... -
详解ThreadLocal与synchronized
2010-01-28 20:14 801Java良好的支持多线程。使用java,我们可以很轻松的编程一 ... -
在有多个选择路径的情况下,利用Switch可以使程序更加简洁有效。但由于其只能对整数选择因子进行判断,所以限制了其在其他类型尤其是String的使用,本文利用J
2010-01-28 20:04 888在有多个选择路径的情况下,利用Switch可以使程序更加简洁有 ... -
java优化编程37条
2010-01-28 20:00 7131.JVM管理两种类型的内 ... -
服务器推送技术 java
2009-12-28 12:11 6291下面介绍在ARP之上的一个非常热门的技术实现:服务器推送技术。 ... -
3DES加密解密调用示例
2009-12-15 10:02 995在java中调用sun公司提供的3DES加密解密算法时,需要使 ... -
java货币 Locale Currency NumberFormat
2009-12-04 18:14 2387使用java currency配合Locale,NumberF ... -
Deque 作为堆栈使用(ArrayDeque)
2009-12-04 18:09 2813package code.jdk; imp ... -
Random类
2009-12-04 14:00 1042Random类 (java.util) ...
相关推荐
以上三个知识点总结了关于 Java 排序的一些基本应用,包括基础的冒泡排序算法、使用标准库 `Collections.sort()` 进行排序以及使用 `RuleBasedCollator` 实现国际化排序等。这些技术对于编写高效、可维护的 Java ...
根据提供的文件信息,我们可以归纳出以下关于Java排序的相关知识点: ### 一、文件基本信息 - **文件名**:`java排序.txt` - **文件描述**:该文本文件主要介绍了几种常用的Java排序算法,并通过示例代码展示了...
在Java编程语言中,排序是数据处理中非常基础且重要的操作。本文将全面解析Java中的各种排序算法,帮助你理解并掌握它们的核心概念、实现方式以及适用场景。 1. 冒泡排序(Bubble Sort) 冒泡排序是最简单的排序...
在Java编程语言中,对包含中文、数字和字母的数据进行排序是一项常见的任务。这个场景下,我们关注的是如何实现一个自定义的排序规则,按照数字、字母和汉字的顺序进行排列。以下是对这一主题的详细解释。 首先,...
【JAVA排序汇总】Java编程语言中,排序是数据处理中非常基础且重要的操作。本文将对几种经典的排序算法进行简要介绍和分析。 1. **插入排序**: 插入排序分为直接插入排序和折半插入排序。直接插入排序是将每个...
Java排序是程序开发中常见的一种任务,主要用于对数据集合进行有序排列。在Java中,有多种内置和自定义的排序算法可供选择,每种都有其特定的适用场景和性能特点。下面将详细介绍几种常见的Java排序方法。 1. **...
【面向对象Java排序包】是基于Java编程语言设计的一个专门用于处理排序问题的软件组件。这个包充分体现了面向对象的设计原则,将数据结构、算法和业务逻辑封装在独立的对象中,提高了代码的可读性和可维护性。它不仅...
根据给定文件中的标题“Java排序代码大全”以及描述与标签中的关键词如“Java排序”、“排序大全”和“算法”,本文将详细解读文件中所包含的几种排序算法的实现方式,并结合具体代码进行深入分析。 ### 快速排序...
### Java 中文姓氏排序详解 #### 一、引言 在处理中文数据时,我们经常需要对含有中文姓名的数据进行排序。Java 提供了多种方式进行排序,包括使用 `Collections.sort()` 方法配合自定义比较器(`Comparator`)。...
Java ip 地址排序Java ip 地址排序Java ip 地址排序Java ip 地址排序
Java排序算法是编程中基础且重要的概念,它们用于组织数组或列表中的元素,使其按照特定顺序排列。在本文中,我们将探讨几种常见的排序算法的Java实现,包括插入排序、冒泡排序、选择排序、Shell排序、快速排序、...
Java 排序算法使用及场景说明 本文档主要介绍了 Java 排序算法的使用和场景说明,包括了五个实践场景的解决方案。 Scenario 1: 找出两个文件共同的 URL 在这个场景中,我们有两个文件 a 和 b,每个文件中存放了 ...
java排序算法大全 为了便于管理,先引入个基础类: 一 插入排序 二 冒泡排序 三,选择排序 四 Shell排序 五 快速排序 六 归并排序 等等
Java 中实现排序算法通常涉及到多种方法,每种算法都有其特定的适用场景和性能特点。下面将详细介绍标题和描述中提到的一些常见排序算法,并提供Java实现。 1. 插入排序(Insertion Sort) 插入排序是一种简单直观...
Java排序可视化页面是一种用于教学和理解排序算法的强大工具。它通过图形化的方式展示了排序过程,使得用户能够直观地看到冒泡排序、选择排序和插入排序这三种基础排序算法的工作原理。接下来,我们将深入探讨这些...
Java排序算法实现 Java排序算法实现 Java排序算法实现
Java排序算法大全是一份专为Java开发者准备的学习资源,涵盖了各种经典的排序算法,旨在帮助初学者和有经验的程序员深入理解排序的原理和实现。排序是计算机科学中的基础且重要的概念,它在数据处理、数据库操作、...
【Java排序算法详细整理】 在计算机科学中,排序算法是用于对一组数据进行排列的算法。在Java中,实现各种排序算法有助于理解数据结构和算法的原理,同时也能提高编程能力。以下是对Java中常见的几种排序算法的详细...
### Java排序方法面试知识点详解 在Java编程领域中,排序算法是面试中常见的技术考察点之一。本篇文章将深入分析几种基本的排序算法,并通过具体的Java代码示例来阐述每种算法的特点及其应用场景。 #### 1. 插入...