我们经常用容器来存放元素,通常而言我们是不关系容器中的元素是否有序,但有些场景可能要求容器中的元素是有序的,这个时候用ArrayList  LinkedList  Hashtable HashMap HashSet 这些容器本身存放的时候就没有办法做到了,这个时候我们有两种思路:第一种思路:对刚刚我们提到的容器类的元素从新排序后存放,就是后面我们要介绍的利用Collections.sort 方法进行排序,第二种思路:是容器在添加元素的时候就进行大小的比较从而来保证元素的排序。下面我开始来详细介绍本节内容。

一、排序概念

在讲解上面的知识点前,我们首先需要知道最基础的知识,即什么是排序?

排序:将一组数据按照某种规则进行排列顺序

1、规则:

  • 基本数据类型:如数据,就是日常的大小顺序
  • 引用数据类型:
  1. 内置类(String,Integer等):内部已经指定好规则,直接使用即可。
  2. 自定义的类:需要按业务规则排序。

2、顺序:

  • 升序:从小到大
  • 降序:从大到小

3、排列:算法,如:冒泡、选择、插入、shell、堆排序等等

二、冒泡排序

上面说到排序的时候算法有很多种,那么这里我们介绍最简单的一种,即:冒泡排序。

我们将会三个版本来进行演练:

  • 简易版:简单
  • 优化版:减少每趟次数
  • 最终版:考虑有序,减少趟数

简易版:

  1. import java.util.Arrays;
  2.  
  3. public class BubbleSort1 {
  4.  
  5. /**
  6. * @param args
  7. */
  8. public static void main(String[] args) {
  9. int[] arr ={9,8,7,6,5};
  10. sort(arr);
  11.  
  12. }
  13. //第一版本,很简单
  14. public static void sort(int[] arr){
  15. int len =arr.length;
  16. for(int j=0;j<len-1;j++){
  17. System.out.println("第"+(j+1)+"趟");
  18. for(int i=0;i<len-1;i++){
  19. System.out.print("第"+(i+1)+"次");
  20. if(arr[i]>arr[i+1]){
  21. int temp = arr[i];
  22. arr[i] =arr[i+1];
  23. arr[i+1] =temp;
  24. }
  25. System.out.println(Arrays.toString(arr));
  26. }
  27. }
  28. }
  29. public static void sortSecond(int[] arr){
  30. System.out.println("第一趟");
  31. for(int i=0;i<arr.length-1;i++){
  32. System.out.print("第"+(i+1)+"次");
  33. if(arr[i]>arr[i+1]){
  34. int temp = arr[i];
  35. arr[i] =arr[i+1];
  36. arr[i+1] =temp;
  37. }
  38. System.out.println(Arrays.toString(arr));
  39. }
  40. System.out.println("第二趟");
  41. for(int i=0;i<arr.length-1;i++){
  42. System.out.print("第"+(i+1)+"次");
  43. if(arr[i]>arr[i+1]){
  44. int temp = arr[i];
  45. arr[i] =arr[i+1];
  46. arr[i+1] =temp;
  47. }
  48. System.out.println(Arrays.toString(arr));
  49. }
  50. System.out.println("第三趟");
  51. for(int i=0;i<arr.length-1;i++){
  52. System.out.print("第"+(i+1)+"次");
  53. if(arr[i]>arr[i+1]){
  54. int temp = arr[i];
  55. arr[i] =arr[i+1];
  56. arr[i+1] =temp;
  57. }
  58. System.out.println(Arrays.toString(arr));
  59. }
  60. System.out.println("第四趟");
  61. for(int i=0;i<arr.length-1;i++){
  62. System.out.print("第"+(i+1)+"次");
  63. if(arr[i]>arr[i+1]){
  64. int temp = arr[i];
  65. arr[i] =arr[i+1];
  66. arr[i+1] =temp;
  67. }
  68. System.out.println(Arrays.toString(arr));
  69. }
  70.  
  71. }
  72.  
  73. public static void sortFirst(int[] arr){
  74. System.out.println("第一趟");
  75. for(int i=0;i<arr.length-1;i++){
  76. System.out.print("第"+(i+1)+"次");
  77. if(arr[i]>arr[i+1]){
  78. int temp = arr[i];
  79. arr[i] =arr[i+1];
  80. arr[i+1] =temp;
  81. }
  82. System.out.println(Arrays.toString(arr));
  83. }
  84.  
  85. /*
  86. //第一趟 第一次
  87. System.out.println("第一趟 第一次");
  88. int i=0;
  89. if(arr[i]>arr[i+1]){
  90. int temp = arr[i];
  91. arr[i] =arr[i+1];
  92. arr[i+1] =temp;
  93. }
  94. System.out.println(Arrays.toString(arr));
  95. System.out.println("第一趟 第二次");
  96. i++;
  97. if(arr[i]>arr[i+1]){
  98. int temp = arr[i];
  99. arr[i] =arr[i+1];
  100. arr[i+1] =temp;
  101. }
  102. System.out.println(Arrays.toString(arr));
  103.  
  104. System.out.println("第一趟 第三次");
  105. i++;
  106. if(arr[i]>arr[i+1]){
  107. int temp = arr[i];
  108. arr[i] =arr[i+1];
  109. arr[i+1] =temp;
  110. }
  111. System.out.println(Arrays.toString(arr));
  112.  
  113. System.out.println("第一趟 第四次");
  114. i++;
  115. if(arr[i]>arr[i+1]){
  116. int temp = arr[i];
  117. arr[i] =arr[i+1];
  118. arr[i+1] =temp;
  119. }
  120. System.out.println(Arrays.toString(arr));
  121.  
  122. */
  123. }
  124.  
  125. }

说明:即每个元素需要和后面的元素比较arr.length -1 次;那么arr.length 个元素,需要进行arr.length -1 趟比较,于是就有了上面的代码。

优化版本:

  1. package com.bjsxt.sort.bubble;
  2.  
  3. import java.util.Arrays;
  4.  
  5. public class BubbleSort2 {
  6.  
  7. /**
  8. * @param args
  9. */
  10. public static void main(String[] args) {
  11. int[] arr ={9,8,7,6,5};
  12. sort(arr);
  13. }
  14. //第二版本,减少每一趟的次数
  15. public static void sort(int[] arr){
  16. int len =arr.length;
  17. for(int j=0;j<len-1;j++){ //趟数
  18. System.out.println("第"+(j+1)+"趟");
  19. for(int i=0;i<len-1-j;i++){ //次数
  20. System.out.print("第"+(i+1)+"次");
  21. if(arr[i]>arr[i+1]){
  22. int temp = arr[i];
  23. arr[i] =arr[i+1];
  24. arr[i+1] =temp;
  25. }
  26. System.out.println(Arrays.toString(arr));
  27. }
  28. }
  29. }
  30.  
  31. }

说明:即在每一趟元素比较的时候,其和每个元素比较的次数应该是不需要去重复进行前面比较过的,因此需要减少每趟比较的次数,即:地刺循环的时候变成了arr.length-1-j.

最终版本:

  1. package com.bjsxt.sort.bubble;
  2.  
  3. import java.util.Arrays;
  4.  
  5. /**
  6. * 最终版本:考虑存在顺序
  7. * @author Administrator
  8. *
  9. */
  10. public class BubbleSort {
  11.  
  12. /**
  13. * @param args
  14. */
  15. public static void main(String[] args) {
  16. int[] arr ={1,2,9,3,4};
  17. sort1(arr);
  18.  
  19. System.out.println("==========final============");
  20. arr =new int[]{9,1,2,3,4};
  21. sortFinal(arr);
  22. }
  23. //第二版本,减少每一趟的次数
  24. public static void sortFinal(int[] arr){
  25. boolean sorted= true;
  26. int len =arr.length;
  27. for(int j=0;j<len-1;j++){ //趟数
  28. sorted =true; //假定有序
  29. for(int i=0;i<len-1-j;i++){ //次数
  30. if(arr[i]>arr[i+1]){
  31. int temp = arr[i];
  32. arr[i] =arr[i+1];
  33. arr[i+1] =temp;
  34. sorted =false; //假定失败
  35. }
  36. System.out.println(Arrays.toString(arr));
  37. }
  38. if(sorted){ //减少趟数
  39. break;
  40. }
  41. }
  42. }
  43.  
  44. //第二版本,减少每一趟的次数
  45. public static void sort1(int[] arr){
  46. int len =arr.length;
  47. for(int j=0;j<len-1;j++){ //趟数
  48. System.out.println("第"+(j+1)+"趟");
  49. for(int i=0;i<len-1-j;i++){ //次数
  50. System.out.print("第"+(i+1)+"次");
  51. if(arr[i]>arr[i+1]){
  52. int temp = arr[i];
  53. arr[i] =arr[i+1];
  54. arr[i+1] =temp;
  55. }
  56. System.out.println(Arrays.toString(arr));
  57. }
  58. }
  59. }
  60.  
  61. }

说明:即如果有序了,则不需要进行比较了。

三、TreeSet 和 TreeMap 

在讲解TreeSet 和 TreeMap 前,我们要先介绍Comparable接口:

  • “排序”的实体类都实现了java.lang.Comparable 接口,Comparable 接口中只有一个方法,即:public int compareTo(T o);   0 相等  正数 负数
  • 实现了Comparable接口的类通过实现了的compareTo 方法从而确定该类对象的排序方式。

1、内置类:

Integer:

  1. public final class Integer extends Number implements Comparable<Integer> {
  2. //......
  3.  
  4. public int compareTo(Integer anotherInteger) {
  5. int thisVal = this.value;
  6. int anotherVal = anotherInteger.value;
  7. return (thisVal<anotherVal ? -1 : (thisVal==anotherVal ? 0 : 1));
  8. }
  9.  
  10. }

Character:

  1. public final
  2. class Character extends Object implements java.io.Serializable, Comparable<Character> {
  3.  
  4. public int compareTo(Character anotherCharacter) {
  5. return this.value - anotherCharacter.value;
  6. }
  7.  
  8. }

String:

  1. public final class String
  2. implements java.io.Serializable, Comparable<String>, CharSequence{
  3.  
  4. public int compareTo(String anotherString) {
  5. int len1 = count;
  6. int len2 = anotherString.count;
  7. int n = Math.min(len1, len2);
  8. char v1[] = value;
  9. char v2[] = anotherString.value;
  10. int i = offset;
  11. int j = anotherString.offset;
  12.  
  13. if (i == j) {
  14. int k = i;
  15. int lim = n + i;
  16. while (k < lim) {
  17. char c1 = v1[k];
  18. char c2 = v2[k];
  19. if (c1 != c2) {
  20. return c1 - c2;
  21. }
  22. k++;
  23. }
  24. } else {
  25. while (n-- != 0) {
  26. char c1 = v1[i++];
  27. char c2 = v2[j++];
  28. if (c1 != c2) {
  29. return c1 - c2;
  30. }
  31. }
  32. }
  33. return len1 - len2;
  34. }
  35.  
  36. }

Date;

  1. public class Date
  2. implements java.io.Serializable, Cloneable, Comparable<Date>
  3. {
  4. public int compareTo(Date anotherDate) {
  5. long thisTime = getMillisOf(this);
  6. long anotherTime = getMillisOf(anotherDate);
  7. return (thisTime<anotherTime ? -1 : (thisTime==anotherTime ? 0 : 1));
  8. }
  9. }

总结:

  1. /**
  2. * 内置引用数据类型(常用)的比较
  3. * @author Administrator
  4. *
  5. */
  6. public class Demo01 {
  7.  
  8. /**
  9. * @param args
  10. */
  11. public static void main(String[] args) {
  12. Integer a ; //根据基本数据类型大小
  13. Character ch; //根据Unicode编码顺序
  14. String str="abc"; //如果其中一个是例外一个起始开始的子串,返回长度之差
  15. String str2 ="abcd123"; //否则返回第一个不相等的unicode码之差
  16. System.out.println(str.compareTo(str2));
  17. str ="abc";
  18. str2 ="aad";
  19. System.out.println(str.compareTo(str2));
  20.  
  21. java.util.Date d ; //根据日期的长整形数比较
  22. }
  23.  
  24. }

2、内置类集合数组排序

String:

  1. import java.util.Arrays;
  2.  
  3. public class Demo02 {
  4.  
  5. /**
  6. * @param args
  7. */
  8. public static void main(String[] args) {
  9. String[] arr ={"a","abcd","abc","def"};
  10. //从到小排序 降序
  11. boolean sorted= true;
  12. int len =arr.length;
  13. for(int j=0;j<len-1;j++){ //趟数
  14. sorted =true; //假定有序
  15. for(int i=0;i<len-1-j;i++){ //次数
  16. if(((Comparable)arr[i]).compareTo(arr[i+1])<0){
  17. String temp = arr[i];
  18. arr[i] =arr[i+1];
  19. arr[i+1] =temp;
  20. sorted =false; //假定失败
  21. }
  22. }
  23. if(sorted){ //减少趟数
  24. break;
  25. }
  26. }
  27.  
  28. System.out.println(Arrays.toString(arr));
  29. }
  30.  
  31. }

Date:

  1. import java.util.Arrays;
  2. import java.util.Date;
  3.  
  4. public class Demo03 {
  5.  
  6. /**
  7. * @param args
  8. */
  9. public static void main(String[] args) {
  10. Date[] arr =new Date[3];
  11. arr[0] =new Date();
  12. arr[1] =new Date(System.currentTimeMillis()-1000*60*60);
  13. arr[2] =new Date(System.currentTimeMillis()+1000*60*60);
  14. //降序
  15.  
  16. //从大到小排序 降序
  17. boolean sorted= true;
  18. int len =arr.length;
  19. for(int j=0;j<len-1;j++){ //趟数
  20. sorted =true; //假定有序
  21. for(int i=0;i<len-1-j;i++){ //次数
  22. if(((Comparable)arr[i]).compareTo(arr[i+1])<0){
  23. Date temp = arr[i];
  24. arr[i] =arr[i+1];
  25. arr[i+1] =temp;
  26. sorted =false; //假定失败
  27. }
  28. }
  29. if(sorted){ //减少趟数
  30. break;
  31. }
  32. }
  33.  
  34. System.out.println(Arrays.toString(arr));
  35. }
  36.  
  37. }

可以看到我们可以抽出工具类来,因为大部分代码是一样的,抽出工具类,则需要考虑可以放多种数据类型,因此会考虑到泛型和Object[] 来存放,工具类如下:

  1. import java.util.Comparator;
  2. import java.util.List;
  3.  
  4. /**
  5. * 排序
  6. * @author Administrator
  7. *
  8. */
  9. public class Utils {
  10. /**
  11. * List的排序+比较器
  12. * @param list
  13. * @param com
  14. */
  15. public static <T> void sort(List<T> list,Comparator<T> com){
  16. //第一步:转成数组
  17. Object[] arr =list.toArray();
  18. sort(arr,com);
  19. //第二步:改变容器中对应的值
  20. for(int i=0;i<arr.length;i++){
  21. list.set(i, (T)(arr[i]));
  22. }
  23. }
  24.  
  25. /**
  26. * 数组的排序 (降序)+Comparator接口
  27. * @param arr
  28. */
  29. public static <T> void sort(Object[] arr,Comparator<T> com){
  30. //从大到小排序 降序
  31. boolean sorted= true;
  32. int len =arr.length;
  33. for(int j=0;j<len-1;j++){ //趟数
  34. sorted =true; //假定有序
  35. for(int i=0;i<len-1-j;i++){ //次数
  36. if(com.compare((T)arr[i], (T)arr[i+1])<0){
  37. Object temp = arr[i];
  38. arr[i] =arr[i+1];
  39. arr[i+1] =temp;
  40. sorted =false; //假定失败
  41. }
  42. }
  43. if(sorted){ //减少趟数
  44. break;
  45. }
  46. }
  47. }
  48.  
  49. /**
  50. * 容器排序 (使用泛型方法)
  51. */
  52. public static <T extends Comparable<T>> void sort(List<T> list){
  53. //第一步:转成数组
  54. Object[] arr =list.toArray();
  55. sort(arr);
  56. //第二步:改变容器中对应的值
  57. for(int i=0;i<arr.length;i++){
  58. list.set(i, (T)(arr[i]));
  59. }
  60.  
  61. }
  62.  
  63. /**
  64. * 数组排序 (使用泛型方法)
  65. */
  66. public static <T extends Comparable<T>> void sort(T[] arr){
  67. //从大到小排序 降序
  68. boolean sorted= true;
  69. int len =arr.length;
  70. for(int j=0;j<len-1;j++){ //趟数
  71. sorted =true; //假定有序
  72. for(int i=0;i<len-1-j;i++){ //次数
  73. if(((Comparable)arr[i]).compareTo(arr[i+1])<0){
  74. T temp = arr[i];
  75. arr[i] =arr[i+1];
  76. arr[i+1] =temp;
  77. sorted =false; //假定失败
  78. }
  79. }
  80. if(sorted){ //减少趟数
  81. break;
  82. }
  83. }
  84. }
  85.  
  86. /**
  87. * 数组的排序 (降序)
  88. * @param arr
  89. */
  90. public static void sort(Object[] arr){
  91. //从大到小排序 降序
  92. boolean sorted= true;
  93. int len =arr.length;
  94. for(int j=0;j<len-1;j++){ //趟数
  95. sorted =true; //假定有序
  96. for(int i=0;i<len-1-j;i++){ //次数
  97. if(((Comparable)arr[i]).compareTo(arr[i+1])<0){
  98. Object temp = arr[i];
  99. arr[i] =arr[i+1];
  100. arr[i+1] =temp;
  101. sorted =false; //假定失败
  102. }
  103. }
  104. if(sorted){ //减少趟数
  105. break;
  106. }
  107. }
  108.  
  109. }
  110.  
  111. }

然后接下来,我们使用我们的工具类进行排序操作:

  1. import java.util.ArrayList;
  2. import java.util.Arrays;
  3. import java.util.Date;
  4. import java.util.List;
  5.  
  6. public class Demo04 {
  7.  
  8. /**
  9. * @param args
  10. */
  11. public static void main(String[] args) {
  12. Date[] arr =new Date[3];
  13. arr[0] =new Date();
  14. arr[1] =new Date(System.currentTimeMillis()-1000*60*60);
  15. arr[2] =new Date(System.currentTimeMillis()+1000*60*60);
  16. Utils.sort(arr); //降序
  17. System.out.println(Arrays.toString(arr));
  18.  
  19. //字符串
  20. String[] arr2 ={"a","abcd","abc","def"};
  21. Utils.sort(arr2);
  22. System.out.println(Arrays.toString(arr2));
  23.  
  24. System.out.println("==========List排序===========");
  25. //存放容器中
  26. List<String> list =new ArrayList<String>();
  27. list.add("a");
  28. list.add("abcd");
  29. list.add("abc");
  30. list.add("def");
  31. Utils.sort(list);
  32. System.out.println(list);
  33.  
  34. System.out.println("==========使用Comparator 排序数组===============");
  35. arr2 =new String[]{"a","abcd","abc","def"};
  36. Utils.sort(arr2,new StringComp());
  37. System.out.println(Arrays.toString(arr2));
  38.  
  39. System.out.println("==========List排序+比较器===========");
  40. list =new ArrayList<String>();
  41. list.add("a");
  42. list.add("abcd");
  43. list.add("abc");
  44. list.add("def");
  45. Utils.sort(list,new StringComp());
  46. System.out.println(list);
  47.  
  48. }
  49.  
  50. }
  1. /**
  2. * 排序规则的业务类
  3. * @author Administrator
  4. *
  5. */
  6. public class StringComp implements java.util.Comparator<String>{
  7.  
  8. /**
  9. * 按长度比较大小
  10. * 正数 >
  11. * 负数 <
  12. * 0 ==
  13. */
  14. @Override
  15. public int compare(String o1, String o2) {
  16. int len1 =o1.length();
  17. int len2 =o2.length();
  18. return -(len1-len2);
  19. }
  20.  
  21. }

上面我们使用的是自己定义的工具类,下面我们使用JDK 提供的工具类进行排序操作:

  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. import java.util.List;
  4.  
  5. /**
  6. * 使用Collections对容器的比较
  7. * 1、 public static <T> void sort(List<T> list, Comparator<? super T> c)
  8. * 2、public static <T extends Comparable<? super T>> void sort(List<T> list)
  9. * void sort(List<T> list)
  10. * @author Administrator
  11. *
  12. */
  13. public class Demo05 {
  14.  
  15. /**
  16. * @param args
  17. */
  18. public static void main(String[] args) {
  19. List<String> list =new ArrayList<String>();
  20. list.add("a");
  21. list.add("abcd");
  22. list.add("abc");
  23. list.add("def");
  24. Collections.sort(list,new StringComp());
  25. System.out.println(list);
  26.  
  27. list =new ArrayList<String>();
  28. list.add("a");
  29. list.add("abcd");
  30. list.add("abc");
  31. list.add("def");
  32. Collections.sort(list);
  33. System.out.println(list);
  34.  
  35. }
  36.  
  37. }

3、自定义类数据类型的排序

对于自定义的数据类型排序,两种方法:1.实体类 实现java.lang.Comparable + compareTo    2.业务排序类  实现java.util.Comparator + compare 方法

第二种方法,可以达到解耦的目的,比如实体类是一个calss 文件或者是其它部件提供的实体类等,可以通过定义业务排序类达到排序,更加灵活。

实例一:Comparable 实现排序

  1. import java.text.SimpleDateFormat;
  2. import java.util.Date;
  3.  
  4. /**
  5. * 新闻条目实体类
  6. * @author Administrator
  7. *
  8. */
  9. public class NewsItem implements java.lang.Comparable<NewsItem>{
  10. //标题
  11. private String title;
  12. //点击量
  13. private int hits;
  14. //时间
  15. private Date pubTime;
  16. public NewsItem() {
  17. }
  18.  
  19. public NewsItem(String title, int hits, Date pubTime) {
  20. super();
  21. this.title = title;
  22. this.hits = hits;
  23. this.pubTime = pubTime;
  24. }
  25.  
  26. public String getTitle() {
  27. return title;
  28. }
  29. public void setTitle(String title) {
  30. this.title = title;
  31. }
  32. public int getHits() {
  33. return hits;
  34. }
  35. public void setHits(int hits) {
  36. this.hits = hits;
  37. }
  38. public Date getPubTime() {
  39. return pubTime;
  40. }
  41. public void setPubTime(Date pubTime) {
  42. this.pubTime = pubTime;
  43. }
  44.  
  45. //时间降序 +点击量升序+标题降序
  46. @Override
  47. public int compareTo(NewsItem o) {
  48. int result =0;
  49. //比较 时间
  50. result =-this.pubTime.compareTo(o.pubTime); //降序
  51. if(0==result){ //时间相同
  52. //点击量
  53. result =this.hits-o.hits; //升序
  54. if(0==result){ //点击量相同
  55. //标题
  56. result=-this.title.compareTo(o.title);//降序
  57. }
  58. }
  59.  
  60. return result;
  61. }
  62.  
  63. @Override
  64. public String toString() {
  65. StringBuilder sb =new StringBuilder();
  66. sb.append("标题:").append(this.title);
  67. sb.append(",时间:").append(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(this.pubTime));
  68. sb.append(",点击量:").append(this.hits).append("\n");
  69. return sb.toString();
  70. }
  71.  
  72. }
  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. import java.util.Date;
  4. import java.util.List;
  5.  
  6. import com.bjsxt.sort.innerType.Utils;
  7.  
  8. /**
  9. * 使用Collections
  10. * @author Administrator
  11. *
  12. */
  13. public class NewsItemApp {
  14.  
  15. /**
  16. * @param args
  17. */
  18. public static void main(String[] args) {
  19. List<NewsItem> news=new ArrayList<NewsItem>();
  20. news.add(new NewsItem("美国后怕了,逃跑了悲剧了",50,new Date(System.currentTimeMillis()-1000*60*60)));
  21. news.add(new NewsItem("中国登上钓鱼岛了,全国欢呼了",100,new Date()));
  22. news.add(new NewsItem("小日本终于听话了,泪流满面笑了",60,new Date(System.currentTimeMillis()-1000*60*60)));
  23. System.out.println("排序前:"+news);
  24. //排序
  25. //Collections.sort(news);
  26. Utils.sort(news);
  27. System.out.println("排序后"+news);
  28.  
  29. }
  30.  
  31. }

实例二:Comparator 实现排序

  1. /**
  2. * 实体类
  3. * @author Administrator
  4. *
  5. */
  6. public class Goods {
  7. //商品名称
  8. private String name;
  9. //价格
  10. private double price;
  11. //收藏量
  12. private int fav;
  13. public Goods() {
  14. // TODO Auto-generated constructor stub
  15. }
  16.  
  17. public Goods(String name, double price, int fav) {
  18. super();
  19. this.name = name;
  20. this.price = price;
  21. this.fav = fav;
  22. }
  23.  
  24. public String getName() {
  25. return name;
  26. }
  27. public void setName(String name) {
  28. this.name = name;
  29. }
  30. public double getPrice() {
  31. return price;
  32. }
  33. public void setPrice(double price) {
  34. this.price = price;
  35. }
  36. public int getFav() {
  37. return fav;
  38. }
  39. public void setFav(int fav) {
  40. this.fav = fav;
  41. }
  42.  
  43. @Override
  44. public String toString() {
  45. return "商品名:"+name+",收藏量"+this.fav+",价格:"+this.price+"\n";
  46. }
  47. }
  1. /**
  2. * 按收藏量排序的业务类 (升序)
  3. * @author Administrator
  4. *
  5. */
  6. public class GoodsFavComp implements java.util.Comparator<Goods> {
  7.  
  8. @Override
  9. public int compare(Goods o1, Goods o2) {
  10. return o1.getFav()-o2.getFav();
  11. }
  12.  
  13. }
  1. /**
  2. * 按价格排序的业务类 (降序)
  3. * @author Administrator
  4. *
  5. */
  6. public class GoodsPriceComp implements java.util.Comparator<Goods> {
  7.  
  8. @Override
  9. public int compare(Goods o1, Goods o2) {
  10. return -(o1.getPrice()-o2.getPrice()>0?1:(o1.getPrice()==o2.getPrice()?0:-1));
  11. }
  12.  
  13. }
  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. import java.util.List;
  4.  
  5. public class GoodsApp {
  6.  
  7. /**
  8. * @param args
  9. */
  10. public static void main(String[] args) {
  11. List<Goods> list =new ArrayList<Goods>();
  12. list.add(new Goods("老马视频",100,2000));
  13. list.add(new Goods("老高视频",50,2000));
  14. list.add(new Goods("老裴视频",1000,1000));
  15. System.out.println("排序前:"+list);
  16. // Collections.sort(list,new GoodsPriceComp());
  17. Collections.sort(list,new GoodsFavComp());
  18. System.out.println("排序后:"+list);
  19. }
  20.  
  21. }

4、TreeSet  TreeMap

  • TreeMap:确保key可以排序或者提供灵活的比较器
  • TreeSet:确保元素实体可以排序或者提供灵活比较器

Treeset 数据中的元素是排序的并且不能够重复,也是实现了Set接口,但和实现了Set接口的HashSet的是不同的,HashSet 是无序,也不可重复。都是不可以重复,但是它们判断的条件是不一样的,HashSet 的前面我们说到过,其元素中的类型时一定要实现hashCode 和equals 的方法来达到去重的目的,但是TreeSet 不一定要实现这两个方法,是通过比较器来实现的去重,即要么Comparable  or  Comparator 当元素比较返回值为0 即相等重复。

样例;

  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. import java.util.List;
  4.  
  5. public class Person {
  6. private final String name;//名称
  7. private final int handsome;//帅气指数
  8.  
  9. public Person() {
  10. name =null;
  11. handsome =0;
  12. }
  13.  
  14. public Person(String name, int handsome) {
  15. super();
  16. this.name = name;
  17. this.handsome = handsome;
  18. }
  19.  
  20. public String getName() {
  21. return name;
  22. }
  23.  
  24. public int getHandsome() {
  25. return handsome;
  26. }
  27.  
  28. @Override
  29. public String toString() {
  30. return "姓名:"+this.name+",帅气指数:"+this.handsome+"\n";
  31. }
  32.  
  33. }
  1. import java.util.TreeSet;
  2. /**
  3. * 提供了 解耦的方式:业务排序类
  4. * @author Administrator
  5. *
  6. */
  7. public class TreeSetDemo {
  8.  
  9. /**
  10. * @param args
  11. */
  12. public static void main(String[] args) {
  13. Person p1 =new Person("您",100);
  14. Person p2 =new Person("刘德华",1000);
  15. Person p3 =new Person("梁朝伟",1200);
  16. Person p4 =new Person("老裴",50);
  17.  
  18. //依次存放到TreeSet容器中,使用排序的业务类(匿名内部类)
  19. TreeSet<Person> persons =new TreeSet<Person>(
  20. new java.util.Comparator<Person>(){
  21.  
  22. @Override
  23. public int compare(Person o1, Person o2) {
  24. return -(o1.getHandsome()-o2.getHandsome());
  25. }
  26.  
  27. }
  28. );
  29. persons.add(p1);
  30. //TreeSet 在添加数据时排序
  31. persons.add(p2);
  32. persons.add(p3);
  33. persons.add(p4);
  34.  
  35. System.out.println(persons);
  36.  
  37. /*
  38. //改变数据
  39. p4.setHandsome(100);
  40. p4.setName("您");
  41. */
  42. //p4 与p1 内容重复
  43. System.out.println(persons);
  44.  
  45. }
  46.  
  47. }

注意点:在添加数据的时候进行排序,数据更改不会影响到原来的顺序,不要改变数据,否则可能重复。

样例2;采用实体类实现了Comparable接口:

  1. public class Worker implements java.lang.Comparable<Worker> {
  2. //工种
  3. private String type;
  4. //工资
  5. private double salary;
  6. public Worker() {
  7. // TODO Auto-generated constructor stub
  8. }
  9.  
  10. public Worker(String type, double salary) {
  11. super();
  12. this.type = type;
  13. this.salary = salary;
  14. }
  15.  
  16. public String getType() {
  17. return type;
  18. }
  19. public void setType(String type) {
  20. this.type = type;
  21. }
  22. public double getSalary() {
  23. return salary;
  24. }
  25. public void setSalary(double salary) {
  26. this.salary = salary;
  27. }
  28.  
  29. /**
  30. * 按工资升序
  31. */
  32. @Override
  33. public int compareTo(Worker o) {
  34. return this.salary>o.salary?1:( this.salary==o.salary?0:-1);
  35. }
  36.  
  37. @Override
  38. public String toString() {
  39. return "工种:"+this.type+",工资:"+this.salary+"\n";
  40. }
  41.  
  42. }
  1. import java.util.TreeSet;
  2. /**
  3. * 实体类实现Comparable 接口的应用
  4. * @author Administrator
  5. *
  6. */
  7. public class TreeSetDemo2 {
  8.  
  9. /**
  10. * @param args
  11. */
  12. public static void main(String[] args) {
  13. Worker w1 =new Worker("垃圾回收员",12000);
  14. Worker w2 =new Worker("农民工",8000);
  15. Worker w3 =new Worker("程序猿",5000);
  16.  
  17. TreeSet<Worker> employees =new TreeSet<Worker>();
  18. employees.add(w1);
  19. employees.add(w2);
  20. employees.add(w3);
  21. System.out.println(employees);
  22.  
  23. }
  24.  
  25. }

最后TreeMap的演示:

  1. import java.util.Set;
  2. import java.util.TreeMap;
  3.  
  4. public class TreeMapDemo {
  5.  
  6. /**
  7. * @param args
  8. */
  9. public static void main(String[] args) {
  10. Person p1 =new Person("您",100);
  11. Person p2 =new Person("刘德华",1000);
  12. Person p3 =new Person("梁朝伟",1200);
  13. Person p4 =new Person("老裴",50);
  14.  
  15. TreeMap<Person,String> map =new TreeMap<Person,String>(new java.util.Comparator<Person>(){
  16.  
  17. @Override
  18. public int compare(Person o1, Person o2) {
  19. return -(o1.getHandsome()-o2.getHandsome());
  20. }
  21.  
  22. } );
  23. map.put(p1, "bjsxt");
  24. map.put(p2, "bjsxt");
  25. map.put(p3, "bjsxt");
  26. map.put(p4, "bjsxt");
  27.  
  28. //查看键
  29. Set<Person> persons =map.keySet();
  30. System.out.println(persons);
  31. }
  32.  
  33. }
  1. import java.util.TreeMap;
  2.  
  3. public class TreeMapDemo02 {
  4.  
  5. /**
  6. * @param args
  7. */
  8. public static void main(String[] args) {
  9. Worker w1 =new Worker("垃圾回收员",12000);
  10. Worker w2 =new Worker("农民工",8000);
  11. Worker w3 =new Worker("程序猿",5000);
  12.  
  13. TreeMap<Worker,String > employees =new TreeMap<Worker,String >();
  14. employees.put(w1,"bjsxt");
  15. employees.put(w2,"bjsxt");
  16. employees.put(w3,"bjsxt");
  17. System.out.println(employees.keySet());
  18. }
  19.  
  20. }

四、Collections 工具类

首先,此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。它包含在 collection 上操作的多态算法,即“包装器”,包装器返回由指定 collection 支持的新 collection,以及少数其他内容。

如果为此类的方法所提供的 collection 或类对象为 null,则这些方法都将抛出 NullPointerException

这个类提供了很多静态方法来辅助我们操作集合类,如:

方法摘要
static

<T> boolean
addAll(Collection<? super T> c, T... elements)
          将所有指定元素添加到指定 collection 中。
static

<T> Queue<T>
asLifoQueue(Deque<T> deque)

          以后进先出 (Lifo) Queue 的形式返回某个 Deque
的视图。
static

<T>
int
binarySearch(List<? extends Comparable<? super T>> list,
T key)

          使用二分搜索法搜索指定列表,以获得指定对象。
static

<T>
int
binarySearch(List<? extends
T> list, T key, Comparator<? super T> c)


          使用二分搜索法搜索指定列表,以获得指定对象。
static

<E> Collection<E>
checkedCollection(Collection<E> c, Class<E> type)

          返回指定 collection 的一个动态类型安全视图。
static

<E> List<E>
checkedList(List<E> list,
Class<E> type)


          返回指定列表的一个动态类型安全视图。
static

<K,V> Map<K,V>
checkedMap(Map<K,V> m, Class<K> keyType, Class<V> valueType)

          返回指定映射的一个动态类型安全视图。
static

<E> Set<E>
checkedSet(Set<E> s, Class<E> type)

          返回指定 set 的一个动态类型安全视图。
static

<K,V> SortedMap<K,V>
checkedSortedMap(SortedMap<K,V> m, Class<K> keyType, Class<V> valueType)

          返回指定有序映射的一个动态类型安全视图。
static

<E> SortedSet<E>
checkedSortedSet(SortedSet<E> s, Class<E> type)

          返回指定有序 set 的一个动态类型安全视图。
static

<T>
void
copy(List<? super
T> dest, List<? extends T> src)


          将所有元素从一个列表复制到另一个列表。
static boolean disjoint(Collection<?> c1, Collection<?> c2)

          如果两个指定 collection 中没有相同的元素,则返回 true
static

<T> List<T>
emptyList()

          返回空的列表(不可变的)。
static

<K,V> Map<K,V>
emptyMap()

          返回空的映射(不可变的)。
static

<T> Set<T>
emptySet()

          返回空的 set(不可变的)。
static

<T> Enumeration<T>
enumeration(Collection<T> c)

          返回一个指定 collection 上的枚举。
static

<T>
void
fill(List<? super
T> list, T obj)

          使用指定元素替换指定列表中的所有元素。
static int frequency(Collection<?> c, Object o)

          返回指定 collection 中等于指定对象的元素数。
static int indexOfSubList(List<?> source, List<?> target)

          返回指定源列表中第一次出现指定目标列表的起始位置;如果没有出现这样的列表,则返回 -1。
static int lastIndexOfSubList(List<?> source, List<?> target)

          返回指定源列表中最后一次出现指定目标列表的起始位置;如果没有出现这样的列表,则返回 -1。
static

<T> ArrayList<T>
list(Enumeration<T> e)

          返回一个数组列表,它按返回顺序包含指定枚举返回的元素。
static

<T extends Object & Comparable<? super T>>

T
max(Collection<? extends
T> coll)

          根据元素的自然顺序,返回给定 collection
的最大元素。
static

<T>
T
max(Collection<? extends T> coll,
Comparator<? super
T> comp)

          根据指定比较器产生的顺序,返回给定 collection 的最大元素。
static

<T extends Object & Comparable<? super T>>

T
min(Collection<? extends
T> coll)

          根据元素的自然顺序 返回给定 collection
的最小元素。
static

<T>
T
min(Collection<? extends T> coll,
Comparator<? super
T> comp)

          根据指定比较器产生的顺序,返回给定 collection 的最小元素。
static

<T> List<T>
nCopies(int n,
T o)

          返回由指定对象的 n 个副本组成的不可变列表。
static

<E> Set<E>
newSetFromMap(Map<E,Boolean> map)

          返回指定映射支持的 set。
static

<T>
boolean
replaceAll(List<T> list,
T oldVal, T newVal)

          使用另一个值替换列表中出现的所有某一指定值。
static void reverse(List<?> list)

          反转指定列表中元素的顺序。
static

<T> Comparator<T>
reverseOrder()

          返回一个比较器,它强行逆转实现了 Comparable 接口的对象 collection
自然顺序
static

<T> Comparator<T>
reverseOrder(Comparator<T> cmp)

          返回一个比较器,它强行逆转指定比较器的顺序。
static void rotate(List<?> list,
int distance)

          根据指定的距离轮换指定列表中的元素。
static void shuffle(List<?> list)

          使用默认随机源对指定列表进行置换。
static void shuffle(List<?> list,
Random rnd)


          使用指定的随机源对指定列表进行置换。
static

<T> Set<T>
singleton(T o)

          返回一个只包含指定对象的不可变 set。
static

<T> List<T>
singletonList(T o)

          返回一个只包含指定对象的不可变列表。
static

<K,V> Map<K,V>
singletonMap(K key,
V value)

          返回一个不可变的映射,它只将指定键映射到指定值。
static

<T extends Comparable<? super T>>

void
sort(List<T> list)

          根据元素的自然顺序 对指定列表按升序进行排序。
static

<T>
void
sort(List<T> list,
Comparator<? super T> c)


          根据指定比较器产生的顺序对指定列表进行排序。
static void swap(List<?> list,
int i, int j)

          在指定列表的指定位置处交换元素。
static

<T> Collection<T>
synchronizedCollection(Collection<T> c)

          返回指定 collection 支持的同步(线程安全的)collection。
static

<T> List<T>
synchronizedList(List<T> list)

          返回指定列表支持的同步(线程安全的)列表。
static

<K,V> Map<K,V>
synchronizedMap(Map<K,V> m)

          返回由指定映射支持的同步(线程安全的)映射。
static

<T> Set<T>
synchronizedSet(Set<T> s)
          返回指定
set 支持的同步(线程安全的)set。
static

<K,V> SortedMap<K,V>
synchronizedSortedMap(SortedMap<K,V> m)

          返回指定有序映射支持的同步(线程安全的)有序映射。
static

<T> SortedSet<T>
synchronizedSortedSet(SortedSet<T> s)

          返回指定有序 set 支持的同步(线程安全的)有序 set。
static

<T> Collection<T>
unmodifiableCollection(Collection<? extends
T> c)

          返回指定 collection 的不可修改视图。
static

<T> List<T>
unmodifiableList(List<? extends
T> list)

          返回指定列表的不可修改视图。
static

<K,V> Map<K,V>
unmodifiableMap(Map<? extends K,?
extends V> m)

          返回指定映射的不可修改视图。
static

<T> Set<T>
unmodifiableSet(Set<? extends
T> s)

          返回指定 set 的不可修改视图。
static

<K,V> SortedMap<K,V>
unmodifiableSortedMap(SortedMap<K,? extends
V> m)

          返回指定有序映射的不可修改视图。
static

<T> SortedSet<T>
unmodifiableSortedSet(SortedSet<T> s)

          返回指定有序 set 的不可修改视图。

其中最主要的一个方法,也是本节关注点,就是sort 排序,在对Java无序类集合,如List(ArrayList/LinkedList)、HashSet(TreeSet有序)、HashMap等排序时,Java中一个公共的类Collections,提供了对Java集合排序等很好的方法sort。 但是有一个要求是sort方法的参数为<List list>  或<List list, Comparator<? super T>  c>,即排序对象要求必须是List类型。

sort 方法的参数必须为List 的原因是,只有List可以定义排序的方法,让List中的元素改变在构建List时原始的相对位置(初始构建时,元素相对位置即为元素初始加入顺序)。HashSet、HashMap 在构建时,初始加入的元素已经按照元素的hashCode()方法的定义排好序。所以这里所说的HashSet 排序 和 HashMap 排序是指:将其中的元素导出到另一个集合中,对该载体集合排序。排序之后,原HashSet 和 HashMap 中元素顺序没有变。

故而对Java无序类集合的排序问题,基本思路就是:将HashSet 或 HashMap 中的元素取出放入 List 中,对List 用 Collections.sort() 方法排序,之后输出排序后List中的元素,即为对Set/Map 中元素排序后的结果。注意HashSet、HashMap 中元素位置没有改变,依然只和 初始构建时,元素本身自定义的hashCode() 方法有关

  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. import java.util.Comparator;
  4. import java.util.HashMap;
  5. import java.util.HashSet;
  6. import java.util.Iterator;
  7. import java.util.LinkedList;
  8. import java.util.Map;
  9.  
  10. public class Test {
  11. public static void main(String[] args){
  12. ArrayList<String> listTest = new ArrayList<String>();
  13. listTest.add("bbc");
  14. listTest.add("abc");
  15. listTest.add("acb");
  16.  
  17. HashSet<String> setTest = new HashSet<String>();
  18. setTest.add("bbc");
  19. setTest.add("abc");
  20. setTest.add("acb");
  21. System.out.println("HashSet BeforeSort:");
  22. for(String s : setTest)
  23. System.out.println(s);
  24.  
  25. HashMap<String, Integer> mapTest = new HashMap<String, Integer>();
  26. mapTest.put("bbc", 1);
  27. mapTest.put("abc", 2);
  28. mapTest.put("acb", 3);
  29. System.out.println("HashMap BeforeSort:");
  30. for(Map.Entry<String, Integer> entry : mapTest.entrySet())
  31. System.out.println(entry.getKey() + " " + entry.getValue());
  32.  
  33. /*
  34. * List
  35. */
  36. Collections.sort(listTest);
  37. Iterator<String> list_iter = listTest.iterator();
  38. while(list_iter.hasNext())
  39. System.out.println(list_iter.next());
  40.  
  41. /*
  42. * Set
  43. */
  44. LinkedList<String> setSort = new LinkedList<String>(setTest);
  45. //Collections.sort(setSort);
  46. Comparator<String> setComp = Collections.reverseOrder();
  47. Collections.sort(setSort, setComp);
  48. /*LinkedList<String> setSort = new LinkedList<String>();
  49. for(String s : setTest)
  50. setSort.add(s);*/
  51. for(String s : setTest)
  52. System.out.println(s);
  53. for(String s : setSort)
  54. System.out.println(s);
  55.  
  56. /*
  57. * Map
  58. */
  59. LinkedList<String> mapSort = new LinkedList<String>();
  60. mapSort.addAll(mapTest.keySet());
  61. //Collections.sort(mapSort);
  62. Comparator<String> mapComp = Collections.reverseOrder();
  63. Collections.sort(mapSort, mapComp);
  64. for(Map.Entry<String, Integer> entry : mapTest.entrySet())
  65. System.out.println(entry.getKey() + " " + entry.getValue());
  66. for(final Iterator<String> map_iter= mapSort.iterator(); map_iter.hasNext();)
  67. System.out.println(map_iter.next());
  68. /*
  69. LinkedList<Map.Entry<String, Integer>> mapEntry = new LinkedList<Map.Entry<String,Integer>>();
  70. mapEntry.addAll(mapTest.entrySet());
  71. Collections.sort(mapEntry, new Comparator<Map.Entry<String, Integer>>() {
  72. public int compare(Map.Entry<String, Integer> a, Map.Entry<String, Integer> b){
  73. if(a.getValue() > b.getValue())
  74. return -1;
  75. else
  76. return 1;
  77. }
  78. });
  79.  
  80. for(Map.Entry<String, Integer> entry : mapEntry)
  81. System.out.println(entry.getKey() + " " +entry.getValue());
  82. for(Map.Entry<String, Integer> entry : mapTest.entrySet())
  83. System.out.println(entry.getKey() + " " + entry.getValue());*/
  84. }
  85. }

结果;

  1. HashSet BeforeSort:
  2. abc
  3. acb
  4. bbc
  5. HashMap BeforeSort:
  6. abc 2
  7. acb 3
  8. bbc 1
  9. //List AfterSort
  10. abc
  11. acb
  12. bbc
  13. //HashSet AfterSort
  14. abc
  15. acb
  16. bbc
  17. //setSort AfterSort (setSort is means HashSet to LinkedList)
  18. bbc
  19. acb
  20. abc
  21. //HashMap AfterSort
  22. abc 2
  23. acb 3
  24. bbc 1
  25. //mapSort AfterSort (mapSort is means HashMap to LinkedList)
  26. bbc
  27. acb
  28. abc

小节:

  1. 一、按key值排序
  2. 假设HashMap存储的键-值对为(StringInteger),按key排序可以调用JDK函数sort(默认的按字典升序):
  3. Set<String> keySet = map.keySet();
  4. Collections.sort(keySet);
  5. for(Iterator<String> ite = keySet.iterator(); ite.hasNext();) {
  6. String temp = ite.next();
  7. System.out.println("key-value: "+temp+","+map.getValue(temp);
  8. }
  9. 如果想要按字典的降序排列,则需改写sort方法里面的比较器Comparator
  10. Collections.sort(keySet, new Comparator() {
  11. public int compare(Object o1, Object o2) {
  12. if(Integer.parseInt(o1.toString())>Integer.parseInt(o2.toString())
  13. return 1;
  14. if(Integer.parseInt(o1.toString())==Integer.parseInt(o2.toString())
  15. return 0;
  16. else
  17. return -1;
  18. }
  19. });
  20.  
  21. 二、按value值排序
  22. 1)方法一:用两个list链表实现
  23. List<String> keyList = new LinkedList<String>();
  24. keyList.addAll(map.keySet());
  25. List<Integer> valueList = new LinkedList<Integer>();
  26. valueList.addAll(map.values());
  27. for(int i=0; i<valueList.size(); i++)
  28. for(int j=i+1; j<valueList.size(); j++) {
  29. if(valueList.get(j)>valueList.get(i)) {
  30. valueList.set(j, valueList.get(i));
  31. valueList.set(i, valueList.get(j));
  32. //同样调整对应的key值
  33. keyList.set(j, keyList.get(i));
  34. keyList.set(i, kyeList.get(j));
  35. }
  36. 然后依次把key值和对应value值重新装入HashMap即可。
  37. 2)方法二:改写JDK提供的Comparator接口方法compare
  38. List<Map.Entry<String, Integer>> list = new LinkedList<Map.Entry<String, Integer>>();
  39. list.addAll(map.entrySet());
  40. Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
  41. public int compare(Map.Entry obj1, Map.Entry obj2) {//从高往低排序
  42.  
  43. if(Integer.parseInt(obj1.getValue().toString())<Integer.parseInt(obj2.getValue().toString()))
  44. return 1;
  45. if(Integer.parseInt(obj1.getValue().toString())==Integer.parseInt(obj2.getValue().toString()))
  46. return 0;
  47. else
  48. return -1;
  49. }
  50. });
  51. for(Iterator<Map.Entry<String, Integer>> ite = list.iterator(); ite.hasNext();) {
  52. Map.Entry<String, Integer> map = ite.next();
  53. System.out.println("key-value: " + map.getKey() + "," + map.getValue());
  54. }

Java提高十五:容器元素比较Comparable&Comparator深入分析的更多相关文章

  1. JAVA提高十九:WeakHashMap&EnumMap&LinkedHashMap&LinkedHashSet深入分析

    因为最近工作太忙了,连续的晚上支撑和上班,因此没有精力来写下这篇博客,今天上午正好有一点空,因此来复习一下不太常用的集合体系大家族中的几个类:WeakHashMap&EnumMap&L ...

  2. Java提高十六:TreeMap深入分析

    上一篇容器元素比较Comparable&Comparator分析的时候,我们提到了TreeMap,但没有去细致分析它,只是说明其在添加元素的时候可以进行比较,从而使得集合有序,但是怎么做的呢? ...

  3. “全栈2019”Java第九十五章:方法中可以定义静态局部内部类吗?

    难度 初级 学习时间 10分钟 适合人群 零基础 开发语言 Java 开发环境 JDK v11 IntelliJ IDEA v2018.3 文章原文链接 "全栈2019"Java第 ...

  4. “全栈2019”Java第十五章:Unicode与转义字符

    难度 初级 学习时间 10分钟 适合人群 零基础 开发语言 Java 开发环境 JDK v11 IntelliJ IDEA v2018.3 文章原文链接 "全栈2019"Java第 ...

  5. “全栈2019”Java第二十五章:流程控制语句中循环语句while

    难度 初级 学习时间 10分钟 适合人群 零基础 开发语言 Java 开发环境 JDK v11 IntelliJ IDEA v2018.3 文章原文链接 "全栈2019"Java第 ...

  6. JAVA提高十八:Vector&Stack深入分析

    前面我们已经接触过几种数据结构了,有数组.链表.Hash表.红黑树(二叉查询树),今天再来看另外一种数据结构:栈. 什么是栈呢,我们先看一个例子:栈就相当于一个很窄的木桶,我们往木桶里放东西,往外拿东 ...

  7. JAVA提高十:ArrayList 深入分析

    前面一章节,我们介绍了集合的类图,那么本节将学习Collection 接口中最常用的子类ArrayList类,本章分为下面几部分讲解(说明本章采用的JDK1.6源码进行分析,因为个人认为虽然JDK1. ...

  8. JAVA提高十二:HashMap深入分析

    首先想说的是关于HashMap源码的分析园子里面应该有很多,并且都是分析得很不错的文章,但是我还是想写出自己的学习总结,以便加深自己的理解,因此就有了此文,另外因为小孩过来了,因此更新速度可能放缓了, ...

  9. java提高篇(五)-----抽象类与接口

    接口和内部类为我们提供了一种将接口与实现分离的更加结构化的方法. 抽象类与接口是java语言中对抽象概念进行定义的两种机制,正是由于他们的存在才赋予java强大的面向对象的能力.他们两者之间对抽象概念 ...

随机推荐

  1. 【特效】给元素循环添加class

    经常会遇到给元素循环添加class的效果,例如下面这个图 每个模块的背景色和图标都不相同,但是呢,模块的数量又不确定,说不定有几十个,那我不能设计几十个图标吧,所以,可以做成每9个一循环,也就是第10 ...

  2. Android 添加水印, 以及屏幕存取

    /** * 获取水印 */ try { String s = CustomPreferences.getUserInfo().getAccountNo().substring(7,11); View ...

  3. MIRO做发票校验时实现替代功能的多种方式

    http://blog.sina.com.cn/s/blog_3f2c03e30100ngje.html MIRO做发票校验时,如果需要对产生的会计凭证做某些字段的替代,可有多种方法. 1.GGB1替 ...

  4. win10 3dmax 激活后反复激活和激活码无效问题

    我也是遇到这个问题在网上找答案,像什么断网,清理注册表,删除某个.dat文件 各种试了好多都没管用 弄这个弄了五六个小时才总算成功 心累 现在我总结一下这些方法  我是第一条成功的 其他的我试着都没用 ...

  5. win10 uwp 通知列表

    经常看到小伙伴问,问已经绑定列表,在进行修改时,不会通知界面添加或删除.这时问题就在,一般使用的列表不会在添加时通知界面,因为他们没有通知. 本文:知道什么是通知的列表,如何去写一个通知列表 在 C# ...

  6. Java IO(Properties/对象序列化/打印流/commons-io)

    Java IO(Properties/对象序列化/打印流/commons-io) Properties Properties 类表示了一个持久的属性集.Properties 可保存在流中或从流中加载. ...

  7. VS连接数据库的通用方法(SQL/MySql)

    在vs里面连接数据库的方法有很多,这里是通用的方法和基本操作 SQL /// <summary> /// 数据访问抽象基础类 /// Copyright (C) Maticsoft /// ...

  8. Django Web框架入门

    一.Django介绍 Django是一个开放源代码的Web应用框架,由Python写成,采用了MVC的框架模式.Django的主要目的是简便.快速的开发数据库驱动的网站.它强调代码复用,多个组件可以很 ...

  9. await和async更多的理解

    最近有不少网友提起await和async,呵呵,C# 5引进的语法糖. 这个语法糖还真不好吃,能绕倒一堆初学的朋友,在网上也有很多网友关于这块知识点的争论,有对有错,今天在这里把这个误区好好讲讲. 在 ...

  10. Azure环境中Nginx高可用性和部署架构设计

    前几篇文章介绍了Nginx的应用.动态路由.配置.在实际生产环境部署时,我们需要同时考虑Nginx的高可用性和部署架构. Nginx自身不支持集群以保证自身的高可用性,商业版本的Nginx+推荐: T ...