Debug中内部类的表现形式匿名内部类的使用场景

Debug中内部类的表现形式

在debug的时候经常会看到一些HashMap$EntrySet，这样的类型，看到的时候一脸疑惑，这到底是什么东西？

通过查询资料与debug的了解，EntrySet是HashMap中的一个内部类，那么可想而知，HashMap$EntrySet的意思

EntrySet在HashMap中的位置.png

匿名内部类的使用场景

场景一：

在写冒泡排序（从小到达）的时候，有没有想过，让里后的顺序颠倒呢，把if中的判断条件改一下就行了，虽然这个想法很好，但是如果我们把冒泡排序的方法封装起来，只给调用；此时，为了从大到小，是不是还要写一个方法，只因为一个符号，这样代码就太冗余了。还有没有其他更加好的方法？这里就用到了匿名内部类了！

上代码（冒泡排序）：

正常的冒泡排序：

public static void main(String[] args) {
    // 冒泡排序
    int [] arr = {43,2,3,43,1,5,23};

    for (int i = 0; i < arr.length-1; i++) {
        for (int j = 0; j < arr.length-i-1; j++) {
            if(arr[j]>arr[j+1]) {
                // 交换位置
                int temp = arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    }
    for (int i = 0; i < arr.length; i++) {
        System.out.print(arr[i]+" ");
    }
}

输出结果

1 2 3 5 23 43 43

逆向，就把判断条件改一下就行了

public static void main(String[] args) {
    // 冒泡排序
    int [] arr = {43,2,3,43,1,5,23};

    for (int i = 0; i < arr.length-1; i++) {
        for (int j = 0; j < arr.length-i-1; j++) {
            if(arr[j]<arr[j+1]) {
                // 交换位置
                int temp = arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    }
    for (int i = 0; i < arr.length; i++) {
        System.out.print(arr[i]+" ");
    }
}

上代码（匿名内部类-冒泡排序）：

这里使用到了接口的多态，在冒泡排序方法中添加Comparator c接口属性，在调用的时候，使用匿名内部类，通过Comparator 接口中的compare方法，自定义排序规则，这样就方便很多

public static void main(String[] args) {
    int[] arr = {12, 34, 3, 4, 5, 2, 6, 17, 33};
    bubble(arr, new Comparator() {
        @Override
        public int compare(Object o1, Object o2) {
            int i1 = (Integer) o1;
            int i2 = (Integer) o2;
            return i2 - i1;
        }
    });
    for (int i : arr) {
        System.out.print(i + " ");
    }
}

// sort面向接口变成的界定因素就是c.compare(arr[j], arr[j+1])>0 当传入的参数大于0是冒泡排序，反
//之排序相反
public static void bubble(int[] arr, Comparator c) {
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - 1 - i; j++) {
            if (c.compare(arr[j], arr[j + 1]) > 0) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

场景二：

在使用TreeSet、TreeMap集合时，虽然说它们是有序的，但我们在集合中插入数据的时候发现，直接打印输出的结果不是有序的，是乱序的，这就有点迷糊。

原来，在这两个集合中都提供了以Comparator 接口为参数的构造器

TreeMap

public TreeMap(Comparator<? super K> comparator) {
    this.comparator = comparator;
}

TreeSet

public TreeSet(Comparator<? super E> comparator) {
    this(new TreeMap<>(comparator));
}

所以当我们调用TreeSet、TreeMap集合的Comparator 接口为属性的构造器时，它们是有序的，可以根据自然顺序进行排序，也可以根据Comparator 提供的compare方法自定义排序。下面就试一试

TreeMap自定义排序

       TreeMap treeMap = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                // 自定义根据长度进行排序，如果长度相同就认为是同一个元素，那么会替换先前的val
                //值，从大到小
                return ((String) o2).length() - ((String) o1).length();
            }
        });
        treeMap.put("jack", "杰克");
        treeMap.put("tom", "汤姆");
        treeMap.put("kristina", "克瑞斯提诺");
        treeMap.put("smith", "斯密斯");
        treeMap.put("hsp", "韩老师");//加入不了
        System.out.println("treemap=" + treeMap);

结果

treemap={kristina=克瑞斯提诺, smith=斯密斯, jack=杰克, tom=韩老师}

TreeSet自定义排序

  TreeSet treeSet = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
//  根据String 的 compareTo 方法进行字符串大小比较
			return ((String) o2).compareTo((String) o1);
//                return ((String) o1).length() - ((String) o2).length();
            }
        });
        treeSet.add("tom");//3
        treeSet.add("sp");
        treeSet.add("a");
        treeSet.add("abc");//3
        System.out.println("treeSet=" + treeSet);