关于快速排序的思考和改进

2020-05-16

快速排序java实现

最近看《算法》看到了快速排序，书上原始的切分算法是这样的

private static int partition(Comparable[] a, int lo, int hi) {
    int i = lo;
    int j = hi + 1;
    Comparable v = a[lo];// bad！
    while (true) { 

        // find item on lo to swap
        while (less(a[++i], v)) {
            if (i == hi) break;
        }

        // find item on hi to swap
        while (less(v, a[--j])) {
            if (j == lo) break;      // redundant since a[lo] acts as sentinel
        }

        // check if pointers cross
        if (i >= j) break;

        exch(a, i, j);
    }

    // put partitioning item v at a[j]
    exch(a, lo, j);

    // now, a[lo .. j-1] <= a[j] <= a[j+1 .. hi]
    return j;
}

这个算法存在许多的问题：

其选用的是数组的第一个元素作为切分元素。看一个极端情况：数组已是有序的。这时候切分元素每次取的都是最小的元素，每次只移除一个元素，这会导致一个大数组需要切分很多次，时间复杂度变为平方级别。
数组较小时，快速排序的效率低于插入排序。

算法的改进

对于第一个问题，可以使用取中位数法。
对于第二个问题，可以在数组元素低于某个值时，采用插入排序。

改进后的快速排序完整代码如下

public class QuickSort implements Sort {
    @Override
    public void sort(Comparable[] a) {
        if(a == null) return;
        int N = a.length;
        sort(a,0,N-1);
    }

    public void sort(Comparable[] a,int lo,int hi){//递归调用
        if(hi<=lo+3) {Insertion.sort(a,lo,hi);return;}//数组小时采用插入
        int j = partition(a,lo,hi);
        sort(a,lo,j-1);
        sort(a,j+1,hi);
    }

    private int partition(Comparable[] a,int lo,int hi){//切分算法
        Comparable v = select(a,lo,hi);
        int i = lo,j = hi - 1;
        while(true){
            while(Sort.less(a[++i],v)) {}
            while(Sort.less(v,a[--j])) {}
            if(i < j) Sort.exch(a,i,j);
            else break;
        }
        Sort.exch(a,i,hi-1);
        return i;
    }

    private Comparable select(Comparable[] a,int lo,int hi){//取中位数
        int mid = (hi+lo)/2;
        if(Sort.less(a[mid],a[lo])){
            Sort.exch(a,mid,lo);
        }
        if(Sort.less(a[hi],a[lo])){
            Sort.exch(a,hi,lo);
        }
        if(Sort.less(a[hi],a[mid])){
            Sort.exch(a,hi,mid);
        }
        Sort.exch(a,mid,hi-1);//将其放置在倒数第二个位置充当哨兵
        return a[hi-1];
    }
}

Sort接口

public interface Sort {
    void sort(Comparable[] a);

    static boolean less(Comparable v,Comparable w){//判断小于
        return v.compareTo(w)<0;
    }

    static boolean lesse(Comparable v,Comparable w){//小于等于
        return ((v.compareTo(w)<0)||(v.compareTo(w)==0));
    }

    static void exch(Comparable[] a,int i,int j){//交换元素
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

    static void show(Comparable[] a){//打印数组
        for(int i = 0;i<a.length;i++){
            System.out.println(a[i]+" ");
            System.out.println();
        }
    }

    static boolean isorted(Comparable[] a){//判断数组是否有序
        for(int i = 1;i<a.length;i++){
            if(less(a[i],a[i-1])) return false;
        }
        return true;
    }
}

插入排序算法

public static void sort(Comparable[] a,int lo,int hi){
    for(int i = lo+1;i < hi+1;i++){//注意是hi+1
        Comparable temp = a[i];
        int j;
        for(j = i;j > 0&&Sort.less(temp,a[j-1]);j--){
            a[j] = a[j-1];
        }
        a[j] = temp;
    }
}

含大量重复元素的数组

当给定的数组中含有大量的重复元素时，原来的快速排序算法设定的是即使切分元素和比较元素相等时也会进行交换。虽然交换的次数较多，但是时间复杂度仍然保持在NlogN。原因是：

该算法每次排序会将相等元素数组平均分为两份，因此时间复杂度仍然为NlogN。

不过可以使用三向切分的快速排序来讲其复杂度降为N级别，代码如下

public class Quick3way {
    public static void sort(Comparable[] a) {
        StdRandom.shuffle(a);//因为要取第一个元素为切分元素，先将其打乱
        sort(a, 0, a.length - 1);
    }

    private static void sort(Comparable[] a, int lo, int hi) { 
        if (hi <= lo) return;
        int lt = lo, gt = hi;
        Comparable v = a[lo];
        int i = lo + 1;
        while (i <= gt) {
            int cmp = a[i].compareTo(v);
            if      (cmp < 0) exch(a, lt++, i++);
            else if (cmp > 0) exch(a, i, gt--);
            else              i++;
        }
        sort(a, lo, lt-1);
        sort(a, gt+1, hi);
    }

这个算法的解决方案基于数组的从左到右传递，该数组保持指针lt使得a [lo..lt-1]小于v，指针gt使得a [gt + 1..hi ]大于v，并且指针i使得a [lt.i-1]等于v，而a [i..gt]尚未检查。

Quicksort 3路分区概述
从i等于lo开始，我们使用Comparable接口给出的三向比较处理a [i]来处理三种可能的情况：
在这里插入图片描述
a [i]小于v：与a [i]交换a [lt]并同时增加lt 和i
a [i]大于v：将a [i]与a [gt]交换并减少gt
a [i]等于v：递增i

三向切分快速排序仅在数组中有大量重复元素时效率才高于普通的快速排序！

展开全文 >>

java集合

2020-05-01

1. collection接口
- 1.1. 迭代器
- 1.2. 实现foreach循环
- 1.3. 泛型实用方法
1. 集合框架中的接口
- 2.1. List接口
- 2.2. 散列集
- 2.3. 树集
- 2.4. 队列与双端队列
- 2.5. 优先队列
1. 映射
- 3.1. 基本映射操作
- 3.2. 更新映射条目
- 3.3. 映射视图
- 3.4. 弱散列映射
- 3.5. 连接散列集和映射
- 3.6. 标识散列映射
1. 视图与包装器
- 4.1. 小集合
- 4.2. 子范围
- 4.3. 不可修改的视图
- 4.4. 检查型视图
1. 算法
- 5.1. 排序与混排
- 5.2. 二分查找
- 5.3. 批操作
- 5.4. 集合与数组的转换

1. collection接口

在java类库中，集合类的基本接口是Collection接口。这个接口有两个基本方法：

public interface Collection<E>{
	boolean add(E element);//用于添加对象
	Iterator<E> iterator();//返回一个实现了Iterator接口的对象，迭代器。
	...//还有其他方法
}

1.1. 迭代器

Iterator接口包含4个方法

public interface Iterator<E> {
    boolean hasNext();

    E next();

    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);

        while(this.hasNext()) {
            action.accept(this.next());
        }

    }
}

调用next方法可以访问集合的下一个元素，但在此之前需要调用hasNext方法确定是否还有下一个元素，否则会抛出一个异常。
java的迭代器和c++不同，c++是根据数组索引建模的；而java迭代器可以看成位于两个元素中间，当调用next方法，迭代器就越过下一个元素，并返回刚刚越过的那个元素的引用。
Iterator的remove方法会删除上一次调用next方法时返回的元素，如果在调用next方法之前没有调用next，会抛出异常，即remove对next有依赖性。

1.2. 实现foreach循环

要想使用foreach循环，需要实现Iterable接口

public interface Iterable<T> {
    Iterator<T> iterator();//实现该方法
    ...
}

接口中的方法返回一个实现类的迭代器，因此还必须先实现这个迭代器，下面以自己实现的LIFO栈为例

public class stack<T> implements Iterable<T> {
    private T st[];//栈数组
    private int top;//栈顶
    private int N;//栈的容量

    public stack(int cap){
        this.N = cap;
        st = (T[]) new Object[cap];
        this.top = -1;
    }
    
    ...
    
    @Override
    public Iterator<T> iterator() {//返回迭代器,实现Iterable接口中的方法
        return new ReverseIterator();
    }

    public class ReverseIterator implements Iterator<T>{//实现一个迭代器，能够使用foreach循环遍历栈（后进先出遍历）
        private int i = top;//内部类可以访问私有字段

        @Override
        public boolean hasNext() {
            return i>-1;
        }

        @Override
        public T next() {
            return st[i--];
        }
    }
}

在该类中，我编写了实现了Iterator接口的内部类，其能够按照后进先出的顺序遍历堆栈。Iterable中的方法返回该类的引用，因此foreach循环能够调用此迭代器来遍历堆栈。

Collection接口扩展了Iterable接口，因此对于标准库中的任何集合都能够使用foreach循环。

总之，对于自己实现的类，要想使用foreach循环，要经历以下步骤：

实现一个适用于该类的迭代器。
实现Iterable接口并重写其方法，返回你所写的迭代器。

1.3. 泛型实用方法

Colllection接口中还有其他实用的方法

public interface Collection<E> extends Iterable<E> {
    int size();

    boolean isEmpty();

    boolean contains(Object var1);//检查是否包含某个元素

    Iterator<E> iterator();

    Object[] toArray();

    <T> T[] toArray(T[] var1);//转换为数组

    default <T> T[] toArray(IntFunction<T[]> generator) {
        return this.toArray((Object[])generator.apply(0));
    }

    boolean add(E var1);

    boolean remove(Object var1);

    boolean containsAll(Collection<?> var1);

    boolean addAll(Collection<? extends E> var1);

    boolean removeAll(Collection<?> var1);

    default boolean removeIf(Predicate<? super E> filter) {
        Objects.requireNonNull(filter);
        boolean removed = false;
        Iterator each = this.iterator();

        while(each.hasNext()) {
            if (filter.test(each.next())) {
                each.remove();
                removed = true;
            }
        }

        return removed;
    }

    boolean retainAll(Collection<?> var1);

    void clear();

    boolean equals(Object var1);

    int hashCode();

    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, 0);
    }

    default Stream<E> stream() {
        return StreamSupport.stream(this.spliterator(), false);
    }

    default Stream<E> parallelStream() {
        return StreamSupport.stream(this.spliterator(), true);
    }
}

所有的实现类都必须要提供这些方法，这会非常麻烦，因此java类库中有一个AbstractCollection类，其实现Collection接口中大部分的方法。但是仍保持size和iterator仍为抽象方法。

因此具体集合类能够扩展AbstractCollection类，只需提供size方法和iterator方法即可。

2. 集合框架中的接口

集合有两个基本接口：Collection和Map。第二个为映射。

图片转载自网络
在这里插入图片描述

在这里插入图片描述

因为映射包含键值对，因此在映射中插入对象要用put方法：

1	V put(K key,V value)

要从集合中读取元素，可以使用迭代器访问元素。不过，从映射中读取值则需要使用get方法：

1	V get(K key)

2.1. List接口

List是个有序集合，继承自Collection。元素会增加到容器中的特定位置。可以采用两种方式访问元素：

使用迭代器访问。
使用一个整数索引来访问，该方式为随机访问。

List接口定义了多个用于随机访问的方法：

void add(int index,E element)
void remove(int index)
E get(int index)
E set(int index,E element)

它也有个抽象类AbstractList,其实现了List接口中的大部分方法。

实现类中最常用的是数组列表(ArrayList)和链表(LinkList)，第一个是以数组为基准实现的，而第二个是基于双向链表实现的。

链表的插入和删除效率高于数组，但是查找元素的效率却很低。链表中的get和set方法的效率是非常低的，并不推荐使用，因此有一个专门用于链表的迭代器——listIterator,可以使用listIterator()方法返回

1 2	LinkedList linkedList = new LinkedList(); ListIterator listIterator = linkedList.listIterator();

ListIterator接口中提供了许多有用的方法：

public interface ListIterator<E> extends Iterator<E> {
    boolean hasNext();

    E next();

    boolean hasPrevious();

    E previous();//反向遍历链表

    int nextIndex();//返回下一次调用next方法时返回元素的索引

    int previousIndex();

    void remove();

    void set(E var1);

    void add(E var1);//添加到迭代器当前位置之前
}

注意：集合中的remove方法不能连续调用，需要调用一次next或previous在进行remove操作。如果上一次操作是previous，remove会删除右侧的元素。

如果一个迭代器发现它的集合被另一个迭代器修改了，或是被该集合自身的某个方法修改了，就会抛出一个异常。
因此，为了避免并发修改异常，请遵循这样一个原则：

可以根据需要为一个集合关联多个迭代器，前提是这些迭代器只能读取集合，或者可以在关联一个能同时读写的迭代器。

2.2. 散列集

先看一下散列表的概念：

有一种数据结构可以用于快速的查找对象，这就是散列表。
散列表为每个对象计算一个整数，称为散列码，散列码是由对象的实例字段得出的一个整数，有不同数据的对象将产生不同的散列码。
Object类中有一个hashCode方法来产生一个散列码，如果定义自己的类，需要重写hashCode，使之与equals方法相容(即两个相同的对象产生的散列码也要相同)
在java中，散列表用链表数组实现，每个列表称为桶。要想查找表中对象的位置，就要先计算它的散列码，然后与桶的总数取余，所得到的结果就是保存这个元素的桶的索引。

java集合类库中提供了一个HashSet类，它实现了基于散列表的集（set）。

而对于Set接口，其等同于Collection接口，但是它的add方法不允许增加重复的元素，并且不在意元素之间的顺序，只要两个集具有相同的元素，就可以认为他们是相等的。

HashSet只是不保证有序，并不是保证无序！！！

      HashSet<String> strings = new HashSet<>();
      strings.add("shit");
      strings.add("fuck");
      strings.add("dog");
      for(String s:strings){
          System.out.println(s);
      }
      //shit
//fuck
//dog   这是有序的！

2.3. 树集

TreeSet类与散列集十分类似，不过树集是一个有序集合。

可以将任意顺序的元素插入到集合中。在对集合进行遍历时，值将自动地按照排序后的顺序呈现。

TreeSet<String> strings = new TreeSet<>();
strings.add("b");
strings.add("a");
strings.add("c");
for(String st:strings){
    System.out.println(st);
}//a b c

排序是用红黑树完成的，因此将一个数据元素添加到树中要比添加到散列表中慢。

2.4. 队列与双端队列

双端队列不同于队列，其允许在头部和尾部都高效地添加或删除元素，不支持在队列中间添加元素。如果要使用双端队列，需要实现Deque接口。

ArrayDeque和LinkedList类都实现了这个接口，因此能在队头和队尾进行操作。

Deque中的方法

public interface Deque<E> extends Queue<E> {
    void addFirst(E var1);//添加到队头

    void addLast(E var1);//添加到队尾

    boolean offerFirst(E var1);//同上

    boolean offerLast(E var1);

    E removeFirst();//移除队头

    E removeLast();//移除队尾

    E pollFirst();

    E pollLast();

    E getFirst();

    E getLast();

    E peekFirst();

    E peekLast();

    boolean removeFirstOccurrence(Object var1);

    boolean removeLastOccurrence(Object var1);

    boolean add(E var1);

    boolean offer(E var1);

    E remove();//删除队头

    E poll();//同上

    E element();//返回队头的元素

    E peek();

    boolean addAll(Collection<? extends E> var1);

    void push(E var1);

    E pop();

    boolean remove(Object var1);

    boolean contains(Object var1);

    int size();

    Iterator<E> iterator();

    Iterator<E> descendingIterator();
}

2.5. 优先队列

优先队列(PriorityQueue)中的元素可以按照任意的顺序插入，但会按照有序的顺序进行检索。无论何时调用remove方法，总会获得当前优先队列中最小的元素。

但是：优先队列并没有对所有的元素进行排序！ 其只是使用了堆这个数据结构来找出最小的元素。

3. 映射

映射用来存放键值对。如果提供了键，就能找到值。

3.1. 基本映射操作

java类库为映射提供了两个通用的实现：HashMap和TreeMap，这两个类都实现了Map接口。

每当往映射中添加一个对象时，必须同时提供一个键。在这里键是String对象，对应的值为Integer对象。

1
2
3

HashMap<Integer, String> hash = new HashMap<>();
hash.put(1,"小明");
hash.put(2,"小张");

要想检索一个对象，必须使用键！

1	System.out.println(hash.get(1));//输出小明

如果映射中没有存储与给定键对应的信息，get将返回null。可以使用默认值来代替null。

1 2	System.out.println(hash.getOrDefault(3,"空缺"));//第二个参数为默认值 //输出空缺

键必须是唯一的！ 不能对同一个键存放两个值，如果对同一个键调用两次put方法，第二个值就会取代第一个值。但是put会返回第一个值。

1 2	System.out.println(hash.put(1,"小王"));//输出小明 //小王取代了小明

3.2. 更新映射条目

如果要统计一个单词在文件中的出现数目，看到一个单词时计数器加1

1	counts.put(word,counts.get(word)+1);//counts是一个映射，键为单词，值为出现数

但是在第一次看见这个单词时，其数目为null，对null操作会产生一个异常。

有三种方法来更新这个值：

使用默认值

1	counts.put(word,counts.getOrDefault(word,0)+1);

putIfAbsent方法

1 2	counts.putIfAbsent(word,0);//如果word不存在或与null关联，则将其与0关联 counts.put(word,counts.get(word)+1);

merge方法

1
2
3

counts.merge(word,1,Integer::sum);
//如果键原先不存在，该方法会将word和1相关联，否则使用Integer::sum函数
//组合原值和1

3.3. 映射视图

集合框架不认为映射本身是一个集合。不过，可以得到映射的视图(view)——这是实现了Collection接口或某个子接口的对象。

有三种视图：

键集
值集合（不是一个集）
键/值对集

下面的方法会返回上面所列的视图

1
2
3

Set<K> KeySet()//键集
Collection<V> values()//值集合
Set<Map.Entry<K,V>> entrySet()//键值对集

其中KeySet不是HashSet或TreeSet，而是实现了Set接口的另外类的对象。

由于都扩展了Collection接口，所以他们都可以用foreach循环来遍历

      HashMap<Integer, String> hash = new HashMap<>();
      hash.put(1,"小明");
      hash.put(2,"小张");
      Set<Map.Entry<Integer, String>> entries = hash.entrySet();
      for (Map.Entry<Integer,String> en:entries) {
          System.out.println(en);
      }
      /*
      1=小明
2=小张
      */

注意：

如果在视图上删除某个值或者键，映射中的键值对都会被删除！
不能向视图中添加元素！

3.4. 弱散列映射

如果有一个值，其对应的键已经不再在程序中的任何地方使用，因为没有任何途径可以引用这个值的对象，所以无法从映射中删除这个这个键值对。而垃圾回收器也不会回收它(其中所有的桶是活动的)。因此，需要程序负责从长期存活的映射表中删除那些无用的值。

或者使用WeakHashMap。

WeakHashMap使用弱引用保存键，对于这种类型的对象，垃圾回收器会回收。

3.5. 连接散列集和映射

LinkedHashSet 和 LinkedHashMap 类会记住插入元素项的顺序。这样就可以避免散列表中的项看起来顺序是随机的。

3.6. 标识散列映射

类IdentityHashMap 有特殊的用途。在这个类中，键的散列值不是用hashCode计算的，而是用System.IdentityHashCode方法计算的。这是根据对象的内存地址计算散列码时所使用的方法。而且，在对两个对象进行比较时，其使用”==”而不是equals。

4. 视图与包装器

4.1. 小集合

java9中引入了一些静态方法，可以生成给定的元素的集或列表，以及给定键值对的映射。

1
2
3

List<String> names = List.of("a","b","c");
Set<Integer> numbers = Set.of(2,3,5);
Map<String,Integer> scores = Map.of("a",2,"b",3,"c",5);

会分别生成包含3个元素的一个列表、一个集和一个映射。

Map接口有一个静态方法ofEntries，能接受任意多个Map.Entry<K,V>对象。

Map<String, Integer> s = Map.ofEntries(
        Map.entry("a", 1)
        Map.entry("b", 2)
);

这些集合对象都是不可修改的！ 如果需要一个可更改的集合，可以把这个不可修改的集合传递到构造器：

List<String> hello = List.of("hello", "java");
ArrayList<String> strings = new ArrayList<>(hello);
//或者ArrayList<String> strings = new ArrayList<>(List.of("hello", "java"));
strings.add("!");
for(String st:strings){
    System.out.println(st);
}

4.2. 子范围

可以为很多集合建立子范围视图。

ArrayList<Integer> integers = new ArrayList<>();
integers.add(1);
integers.add(2);
integers.add(3);
List<Integer> in = integers.subList(0, 2);
for(int a:in){
    System.out.println(a);
}//1 2

第一个索引包含在内，第二个则不包含。这与String类的substring操作中的参数情况相同。

可以对子范围应用任何操作，而且操作会自动反映到整个列表！

对于有序集合映射，可以使用排序顺序而不是元素位置建立子范围。具体在SortedSet接口中。

4.3. 不可修改的视图

Collections类（不是Collection接口）有几个可以生成不可修改视图的方法

public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c) {
    return new Collections.UnmodifiableCollection(c);
}

public static <T> Set<T> unmodifiableSet(Set<? extends T> s) {
    return new Collections.UnmodifiableSet(s);
}

public static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s) {
    return new Collections.UnmodifiableSortedSet(s);
}

public static <T> NavigableSet<T> unmodifiableNavigableSet(NavigableSet<T> s) {
    return new Collections.UnmodifiableNavigableSet(s);
}

public static <T> List<T> unmodifiableList(List<? extends T> list) {
    return (List)(list instanceof RandomAccess ? new Collections.UnmodifiableRandomAccessList(list) : new Collections.UnmodifiableList(list));
}

public static <K, V> Map<K, V> unmodifiableMap(Map<? extends K, ? extends V> m) {
    return new Collections.UnmodifiableMap(m);
}

public static <K, V> SortedMap<K, V> unmodifiableSortedMap(SortedMap<K, ? extends V> m) {
    return new Collections.UnmodifiableSortedMap(m);
}

public static <K, V> NavigableMap<K, V> unmodifiableNavigableMap(NavigableMap<K, ? extends V> m) {
    return new Collections.UnmodifiableNavigableMap(m);
}

每个方法都定义处理一个接口。例如，Collections.unmodifiableList处理ArrayList、LinkedList或者实现了List接口的其他类。这个方法会返回一个实现了List接口的类对象，他们是不可更改的。

4.4. 检查型视图

将错误的类型混入泛型集合中的情况极有可能发生

1
2
3

ArrayList<String> strings = new ArrayList<>();
ArrayList a = strings;
a.add(new Date());//no error

这个错误的命令在运行时检查不出来，这时候可以用检查型视图，如果插入的对象不属于指定的类，就会抛出一个ClassCastException异常

ArrayList<String> strings = new ArrayList<>();
List<String> safeStrings = Collections.checkedList(strings, String.class);
ArrayList a = (ArrayList) safeStrings;
a.add(new Date());//抛出异常ClassCastException

5. 算法

在java集合框架中还有一些有用的算法。

5.1. 排序与混排

Collections类的sort方法实现了对List接口的集合进行排序，这个方法假定列表元素实现了Comparable接口。

1
2
3

var staff = new LinkedList<String>();
....
Collections.sort(staff);

或者可以使用List接口的sort方法，不过这个方法需要传进一个Comparator对象。

1	staff.sort(Comparator a);

如果想按降序对列表进行排序，可以使用静态的遍历方法Collections.reverseOrder()。这个方法将返回一个比较器

1	staff.sort(Comparator.reverseOeder());

注意：集合类库中的排序不是快速排序！

Collections类中还有一个算法shuffle，其会打乱集合中的顺序，作用与排序相反。

5.2. 二分查找

Collections类中还有个二分查找的方法，不过只适用于随机访问的集合，而对于链表，它会自动地退化为线性查找

Collections类中还有许多简单算法，例如求最大值，最小值，拷贝，交换位置等等。

5.3. 批操作

很多操作会“成批”复制或删除元素。

a.removeAll(b); 会从a中删除b中出现的所有元素
a.retainAll(b); 会从a中删除所有未在b中出现的元素

上面的方法是定义在Collection接口中的，Map中没有此方法，不过可以对Map的视图进行操作。

5.4. 集合与数组的转换

如果需要把一个数组转换为一个集合，可以使用List.of

1 2	String[] values = ...; var staff = new HashSet<>(List.of(values));

将一个集合转换为数组会麻烦一些，需要使用toArray方法

1	staff.toArray(new String[0]);

展开全文 >>

java泛型

2020-04-21

1. 定义简单的泛型类
1. 泛型方法
- 2.1. 类型变量的限定
1. 泛型代码和虚拟机
- 3.1. 类型擦除
- 3.2. 转换泛型表达式
- 3.3. 转换泛型方法
1. 限制与局限性
1. 泛型类的继承规则
1. 通配符类型
- 6.1. 统配符的限定
- 6.2. 通配符限定的行为差异
- 6.3. 无限定通配符
- 6.4. 通配符捕获
1. 反射和泛型

泛型程序设计

在java增加泛型类之前，泛型程序设计使用继承实现的（Object），当获取一个值时还需进行强制类型转换，很不方便。泛型提供了一个更好的解决方案：类型参数。

1	var files = new ArrayList<String>();

他会让程序更易读，更安全。

1. 定义简单的泛型类

泛型类就是有一个或多个类型变量的类。

下面定义了一个泛型类

public class Pair<T> {
    private T first;
    private T secend;

    public Pair(T first, T secend) {
        this.first = first;
        this.secend = secend;
    }

    public Pair() {
        first = null;
        secend = null;
    }

    public T getFirst() {
        return first;
    }

    public void setFirst(T first) {
        this.first = first;
    }

    public T getSecend() {
        return secend;
    }

    public void setSecend(T secend) {
        this.secend = secend;
    }

    public void show(T value){
        System.out.println(value);
    }
}

Pair类引进了一个类型变量T，用尖括号括起来，放在类名的后面。泛型类可以有多个类型变量：

1	public class Pair<T,U>{....}

类型变量在整个类定义中用于指定方法的返回类型以及字段和局部变量的类型，例如

1	private T first;

可以使用具体的类型替换类型变量来实例化泛型类型

1	Pair<String>

2. 泛型方法

不仅可以定义泛型类，还可以定义泛型方法

class ArrayAlg{
	public static <T>T getMiddle(T... a){
		return a[a.length/2];
	}
}

这是在普通类中定义的泛型方法，也可以在泛型类中定义。
注意：类型变量放在类型修饰符的后面，返回类型的前面

当调用一个泛型方法时，可以把具体类型包围在尖括号中，放在方法名前面

1	String middle = ArrayAlg.<String>getMiddle("j","x");

大多时候可以省略具体类型。

2.1. 类型变量的限定

用关键字extends对类型变量进行限定

1	<T extends BoundingType>

表示T是限定类型BoundingType的子类型。他们可以是类，也可以是接口

一个类型变量或通配符可以有多个限定，用”&”分隔，而逗号用于分隔类型变量

1	<T extends Comparable & Serializable,U>

3. 泛型代码和虚拟机

虚拟机没有泛型类型对象———所有对象都属于普通类。虚拟机会擦除类型参数

3.1. 类型擦除

无论何时定义一个泛型类型，都会自动提供一个相应的原始类型，这个原始类型的名字就是去掉类型参数后的泛型类型名。

在虚拟机中，类型变量会被擦除，并替换为其限定类型，无限定类型的变量则替换为Object

上面的Pair类的原始类型如下形式

public class Pair{
	private Object first;
    private Object secend;

    public Pair(Object first, Object secend) {
        this.first = first;
        this.secend = secend;
    }
    ...
}

T是一个无限定的变量，直接用Object替换掉

对于有限定的类型变量，会被替换为第一个限定,例如：


class demo<T extends Comparable & Serializable>{
	private T lower;
	...
	public demo(T first,T second){
		...
	}
}

//替换过后的原始类型，用第一个限定来替代
class demo{
	private Comparable lower;
	...
	public demo(Comparable first,Comparable second){
		...
	}
}

3.2. 转换泛型表达式

编写一个泛型方法调用时，如果擦除了返回类型，编译器会加入强制类型转换

1
2
3

Pair<Employee> buddies = ....;
Employee buddy = buddies.getFirst();//源类型为Object
//Employee buddy = (Employee)buddies.getFirst();

虚拟机会把这个方法调用转换为两条虚拟机指令

对原始方法Pair.getFirst 的调用。
对返回类的Object类型强制转换为Employee类型。

当访问一个泛型字段时也要加入强制类型转换，和调用泛型方法时一样。

3.3. 转换泛型方法

当一个类继承自一个泛型类，并重写泛型类中的方法

public class brige extends Pair<String> {
    @Override
    public void show(String value) {//重写show方法
        System.out.println(value);
    }
}

这时可能会产生一些问题，当类型擦除过后，Pair类中的show方法的参数会被替换成为Object

1 2	public void show(Object value){...}//父类方法 public void show(String value){...}//子类重写的方法

则此时父类中方法的参数和子类重写方法中的参数不一致！类型擦除和多态产生了冲突，在使用多态的时候会产生问题。

为了解决这个问题，编译器会在子类中生成一个桥方法来保持多态，我们使用反射来看一下子类（brige）中生成的桥方法

public class brigeDemo {
    public static void main(String[] args) {
        Class<brige> bc = brige.class;
        Method[] declaredMethods = bc.getDeclaredMethods();
        for (Method m:declaredMethods) {
            System.out.println(m);
        }
        /*
        public void generic.brige.show(java.lang.String)
        public void generic.brige.show(java.lang.Object)  生成了桥方法
        */
    }
}

可以看见，在brige类中增加了一个参数为Object的方法，这个方法即为桥方法，必要时也会加入强制类型转换。

总之，对于java泛型的转换，需要记住以下几个事实：

虚拟机中没有泛型，只有普通的类和方法。
所有的类型参数都会替换成为它们的限定类型或Object。
会合成桥方法来保持多态。
为保持类型安全性，必要时会插入强制类型转换。

4. 限制与局限性

下面讨论下使用泛型的限制

不能用基本类型替代类型参数，可以使用他们的包装器类型。
运行时的类型查询(instanceof)只适用于原始类型,使用强制类型转换转换为一个泛型类时，会得到一个警告。
getClass方法总是返回原始类型，来验证一下

Pair<String> pair = new Pair<>();
Pair<Integer> a = new Pair<>();
System.out.println(pair.getClass() == a.getClass());//true
//getClass方法总是返回原始类型

不能创建参数化类型的数组，但可以声明带泛型的数组引用。

1 2	ArrayList<String>[] arr = new ArrayList[5];//OK ArrayList<String>[] array = new ArrayList<String>[5]; //error不能创建泛型数组对象

不能实例化类型变量,不过可以通过反射来构造泛型对象。

public static <T>T makePair(Class<T> cl) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    //T t = new T();  类型变量不能被实例化
    return cl.getConstructor().newInstance();//使用反射实例化类型变量
}

不能构造泛型数组。T[] t = new T[5]//error

泛型类的静态上下文中类型变量无效,静止使用带有类型变量的静态字段和方法。（在泛型类中）

    public static T makePair(Class<T> cl) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        return cl.getConstructor().newInstance();
}//error

private static T singleInstance;//error

不能抛出或捕获泛型类的实例。泛型类甚至不嫩扩展Throwable类。
可以利用泛型取消对检查型异常的检查。（参数类型为RuntimeException）
注意擦除后的冲突。如果两个接口类是同一接口的不同参数化，一个类或类型变量就不能同时作为这两个接口类型的子类。

class Employee implements Comparable<Employee>{...}
class Manager extends Employee implements Comparable<Manager>{...}
//error
//Manager实现了Comparable<Employee>和Comparable<Manager>

5. 泛型类的继承规则

现在有一个类Manager继承自Employee，那么Pair< Manager>和Pair< Employee>有什么关系呢？
答案是没有关系。

不过泛型类可以扩展或实现其他的泛型类。
从泛型类派生子类需要注意以下几点：

子类也是泛型类，子类和父类的泛型类型要一致。

1	public class brige<T> extends Pair<T>{...}

子类不是泛型类，父类要明确泛型的数据类型。

1	public class brige extends Pair<String>{...}

6. 通配符类型

在通配符类型中，允许类型参数发生变化。例如，通配符类型

1	Pair<? extends Employee> p

表示任何泛型Pair类型，它的类型参数是Employee的子类，如
Pair< Manager>,但不是Pair< String>。

类型Pair< Manager>是Pair<? extends Employee>的子类型。

6.1. 统配符的限定

通配符的限定有超类型限定(super),也有子类型限定(extends)。

超类型限定super

1	Pair<? super Manager> p

这个通配符限制为Manager的所有超类型。包括Object。

子类型限定extends，与超类型限定相反。

1	Pair<? extends Employee> p

6.2. 通配符限定的行为差异

超类型限定和子类型限定在使用方法时有一些差异：

超类型限定可以为方法提供参数，但不能使用返回值。
子类型限定的行为与超类型限定相反。

下面来看一组代码来加深理解

public static void show(Pair<? extends Employee> p){//子类型限定
        Employee first = p.getFirst();
//        p.setFirst(first);    error  通配符上限不能写入，此时泛型类中的数据类型为Employee的子类，
//        传进去的数据类型为泛型类中数据类型的父类，子类引用不能指向父类对象 Manager = new Employee(); error
        System.out.println(first.getName());
    }

    public static void show2(Pair<? super Manager> p ){//超类型限定
        Object first = p.getFirst();
        Manager m = new Manager(1,1," ");
        p.setFirst(m);//通配符下限可以写入，因为此时泛型类中数据类型肯定为Manager的父类，
        // 父类引用可以指向子类对象,Employee = new Manager(); OK
    }

总之：

带有超类型限定的通配符允许你写入一个泛型对象，能写入类型为super关键字之后的类型，在这为Manager，它一定是通配符类型的子类。
而带有子类型限定的通配符允许你读取一个泛型对象，读取出的对象只能赋给extends关键字之后的类型或其父类，在这为Employee,它一定是通配符类型的父类。
理解以上的关键点是父类引用能指向子类对象，而子类引用不能指向父类对象。
6.3. 无限定通配符
还可以使用根本无限定的通配符，例如Pair<?>。
该类型既不能读取也不能写入，可以用在不需要实际类型的方法之中，如：

1
2
3

public static boolean hasNulls(Pair<?> p){
	return p.getFirst() == null||p.getSecond == null;
}

6.4. 通配符捕获

有以下两个方法

1 2	public static void swap(Pair<?> p){swapHelper(p);} public static <T> void swapHelper(Pair<T> p){}

第一个方法调用第二个方法，第二个方法的参数T会捕获通配符。

7. 反射和泛型

Class类也是泛型类，可以利用这个来免除类型转换。

1
2
3

Class<Pair> pairClass = Pair.class;
Constructor<Pair> constructor = pairClass.getConstructor();
Pair pair1 = constructor.newInstance();

其中构造实例的返回类型直接是Pair，不需要再进行强制类型转换。

展开全文 >>

java异常、断言和日志

2020-04-16

1. 异常
- 1.1. 异常分类
- 1.2. 声明检查型异常
- 1.3. 抛出异常的情况
- 1.4. 如何抛出异常
- 1.5. 创建异常类
- 1.6. 捕获异常
- 1.7. 再次抛出异常与异常链
- 1.8. finally子句
- 1.9. try-with-Resources语句
- 1.10. 使用异常的技巧
1. 断言
1. 日志
- 3.1. 基本日志
- 3.2. 日志级别
- 3.3. 日志技巧

1. 异常

异常对象都是派生于Throwable类的一个类实例

1.1. 异常分类

graph LR
A[Throwable]  --> B[Error]
A --> C[Exception]
C --> D[RuntimeException]
C --> E[IOException]

Error类层次结构描述了java运行时系统的内部错误和资源耗尽错误。你对此无能为力。
Exception层次又分为两个分支：一个分支派生于RuntimeException;另一分支包含其他异常。
由编程错误导致的异常属于RuntimeException（数组越界，访问null指针，错误的强制类型转换）
如果程序本身没有问题，但由于像I/O错误这类问题导致的异常属于其他异常（如文件不存在，试图超越文件末尾继续读取数据等）

Java语言将派生于Error类或RuntimeException类的所有异常称为非检查型异常，所有的其他的异常称为检查型异常。

检查型异常编译期必须进行处理（捕获或者声明），否则程序不能通过编译；而非检查型异常可以通过编译（如数组越界）

1.2. 声明检查型异常

当调用了一个抛出检查型异常的方法时，需要在方法首部中添加throws子句，声明检查型异常

class NyAnimation
{
	...
	public Image loadImage(String s)Throws FileNotFFoundException
	{
		...
	}
}

它指出这个方法可能抛出一个异常

不需要声明非检查型异常（虽然也可以声明）

class NyAnimation
{
	...
	public Image loadImage(String s)Throws ArrayIndexOutOfBoundsException//bad style
	{
		...
	}
}

总之，一个方法必须声明所有可能抛出的检查型异常，而不应该声明非检查型异常。

如果一个异常继承自Error或RuntimeException类，则无需处理，如果是继承自Exception类，则必须处理。

1.3. 抛出异常的情况

调用了一个抛出检查型异常的方法
检测到一个错误，并且利用throw语句抛出一个检查型异常
程序出现错误（如数组越界）
java虚拟机或运行时库出现内部错误

1.4. 如何抛出异常

找到一个合适的异常类。（查文档）
创建这个类的一个对象。
将对象抛出。

1	throw new 异常类();//如果是检查型异常还需声明或者放在try块中，否则不能通过编译

一旦方法抛出了异常，这个方法就不会返回调用者。

1.5. 创建异常类

当你的代码可能遇到任何标准异常类都无法描述清楚的问题时，可以创建自己的异常类。

可以定义一个派生于Exception类或其子类的异常类(为检查型异常)，这个类应该包含两个构造器，一个是默认的构造器，一个是包含详细信息的构造器。

public class ErrorTest extends Exception {
    public ErrorTest() {
    }

    public ErrorTest(String message) {
        super(message);
    }
}

现在可以抛出自定义的异常类了

public class ExceptionDemo {
    public static void main(String[] args) throws ErrorTest {
        if(true) throw new ErrorTest();
        /*
        Exception in thread "main" exception.ErrorTest
	at exception.ExceptionDemo.main(ExceptionDemo.java:20)
        */
    }
}

其中带参构造方法能够输出信息

       if(true) throw new ErrorTest("但参构造");
       /*
       Exception in thread "main" exception.ErrorTest: 带参构造
at exception.ExceptionDemo.main(ExceptionDemo.java:20)
       */

1.6. 捕获异常

如果发生了某个异常，但没有在任何地方捕获这个异常，程序就会终止。

public class ExceptionDemo {
    public static void main(String[] args) throws ErrorTest {
        int[] arrs = new int[]{1, 2, 3};
        show(arrs);
        System.out.println("y");
        /*
        Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
	at exception.ExceptionDemo.show(ExceptionDemo.java:23)
	at exception.ExceptionDemo.main(ExceptionDemo.java:18)
        */
        //数组越界异常
    }
    public static void show(int[]arr){
        System.out.println(arr[3]);
    }

尽管在之后有一条输出语句，但是没有执行，因为程序发现有异常后就终止了，但是捕获了这个异常之后程序就不会终止。

public class ExceptionDemo {
    public static void main(String[] args) throws ErrorTest {
        int[] arrs = new int[]{1, 2, 3};
        try {
                show(arrs);
        }catch (ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }
        System.out.println("y");//会输出y
    }
    public static void show(int[]arr){
        System.out.println(arr[3]);
    }
}
/*
java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
	at exception.ExceptionDemo.show(ExceptionDemo.java:21)
	at exception.ExceptionDemo.main(ExceptionDemo.java:10)
y
*/

要想捕获一个异常，需要用try catch语句块，如果try语句块中的任何代码抛出了catch子句中指定的一个异常类，那么

程序将跳过try语句块的其余代码
程序将执行catch子句中的处理器代码

请注意：

如果try语句块中的代码没有抛出任何异常，那么程序将跳过catch子句。
如果方法中的任何代码抛出了catch子句中没有声明的一个异常类型，那么这个方法就会立即退出。

如果调用了一个抛出检查型异常的方法，就必须处理这个异常(try)，或传递这个异常(throws)。

1.7. 再次抛出异常与异常链

可以在catch子句中继续抛出一个异常

try{
....
}catch(Exception e){
	throw new ...;//新异常
}

还可以将原始异常设置为新异常的“原因”

        try {
                show(arrs);//产生异常，停止try块中的执行
        }catch (ArrayIndexOutOfBoundsException e){
            ErrorTest errorTest = new ErrorTest();
            errorTest.initCause(e);//设置e为errorTest的原因
            throw errorTest;
        }
        /*
        Exception in thread "main" exception.ErrorTest
	at exception.ExceptionDemo.main(ExceptionDemo.java:16)
Caused by: java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
	at exception.ExceptionDemo.show(ExceptionDemo.java:23)
	at exception.ExceptionDemo.main(ExceptionDemo.java:10)
        */
        //其中原因用caused by给出

当捕获到这个异常时，可以使用下面这条语句获取原始异常

....
catch (ErrorTest er){
            Throwable cause = er.getCause();//得到原始异常
            cause.printStackTrace();
        }

使用这种包装技术可以在抛出高层异常时不会丢失原始异常

1.8. finally子句

不管异常有没有被捕获，finally子句中的代码都会执行
finally语句主要用于清理资源。

1.9. try-with-Resources语句

对于以下代码模式

//open a resource
try{
	//work with the resource
}finally{
	//close the resource
}

如果资源属于一个实现了AutoCloseable接口的类，这个类中提供了这样的一个方法

1
2
3

public interface AutoCloseable {
    void close() throws Exception;
}

那么就可以使用另一种快捷方式

1
2
3

try(Resource res = ...){
	//work with res
}

try块自动退出时会调用res.close()来关闭资源。对于读取文件等资源流，就可以使用这种方式，在其完成后会自动关闭资源流

如果try块抛出一个异常，而close方法也抛出一个异常，则close方法的异常会被抑制。

1.10. 使用异常的技巧

异常不能代替简单的测试，只在异常情况下使用异常。
不要过分地细化异常，即不要将每一条语句都分装在一个独立的try块中，而是将正常处理和错误处理分开。
充分利用异常层次结构，不要只适用Throwable。
不要压制异常。
不要羞于传递异常。如果调用了一个抛出异常的方法，最好继续传递这个异常，而不是自己捕获。（throws）

2. 断言

断言机制允许在测试期间向代码中插入一些检查，而在生产代码中会自动删除这些检查。
使用关键字assert来使用断言，语法类似于if

1 2	assert i>0; ...

如果为真，继续执行下面的语句，如果为假则抛出一个AssertionError异常。

一般情况下断言是禁用的，需要用-ea去启动断言

3. 日志

平常我在进行调试时都会在代码中插入一些System.out.println语句来观察程序的行为，但是调试完后删起来很麻烦。因此可以用日志来代替，可以很容易地取消全部日志或者取消某个级别以下的日志。

3.1. 基本日志

要生成简单的日志记录，可以使用全局日志记录器并调用其info方法

//生成基本日志
      Logger.getGlobal().info("log");
      /*
      4月 14, 2020 3:48:45 下午 exception.loggerDemo main
      信息: log
       */

在适当的地方（如main的最前面）调用下面语句即可以取消所有的日志

1	Logger.getGlobal().setLevel(Level.OFF);

3.2. 日志级别

可以使用getLogger方法来创建或获取日志记录器：

1	Logger logger = Logger.getLogger(LoggerDemo.class.getName());

通常有七个日志级别

SEVERE
WARNING
INFO
CONFIG
FINE
FINER
FINEST

在默认情况下只记录前三个级别。

也可以设置一个不同的级别

1	logger.setLevel(Level.ALL);//所有的级别都会被记录

所有的级别都有日志记录方法

1	logger.finest("message");

但是即使开启了所有的记录级别，仍然不会再控制台输出INFO以下级别的信息，此时需要修改配置信息或者构建一个新的控制台处理器

		Logger logger = Logger.getLogger(LoggerDemo.class.getName());//默认不输出INFO以下的日志，需要修改配置文件
        ConsoleHandler handler = new ConsoleHandler();//也可以采用这种方式,构造一个新的控制台处理器
        handler.setLevel(Level.ALL);
        logger.addHandler(handler);
        logger.setLevel(Level.ALL);
        logger.finest("message");
        /*
        4月 16, 2020 11:08:41 下午 exception.LoggerDemo main
非常详细: message
        */

3.3. 日志技巧

对于一个简单的应用，选择一个日志记录器。可以把日志记录器命名为与主应用包一样的名字。
默认的日志配置会把级别等于或高于INFO的所有消息记录的控制台。

高级日志有部分为略读

展开全文 >>

java接口、lambda表达式与内部类

2020-04-12

1. 接口
- 1.1. 接口的属性
- 1.2. 接口与抽象类
1. 接口中的其他方法
- 2.1. 静态方法
- 2.2. 私有方法
- 2.3. 默认方法
- 2.4. 解决默认方法冲突
1. 对象克隆
1. lambda表达式
- 4.1. 函数式接口
1. 方法引用
- 5.1. 变量作用域
1. 内部类
- 6.1. 匿名内部类
- 6.2. 静态内部类

接口、lambda表达式与内部类

接口用来描述类应该做什么，而不指定它们具体应该如何实现。
通过使用lambda表达式，可以用一种精妙而简洁的方式使用回调或可变行为的代码。
内部类定义在另一个类的内部，它们的方法可以访问包含它们的外部类的字段。

1. 接口

定义一个接口需要使用interface关键字

public interface English {
    void studyen();//接口中的方法
    ....
}

对于接口，有下面几点需要注意：

接口中所有的方法都自动是public方法（在实现接口时必须把方法声明为public）
接口不会有实例字段。

一个类可以实现一个或多个接口，使用implements关键字来实现一个接口，这个类还必须对接口中的所有方法提供定义。（默认方法可以不用）

public class pingpongCoach extends coach implements English {
    @Override
    public void studyen() {//对接口方法的实现
        System.out.println(getName()+" coach study English!");
    }
    .....
}

从上面可以看见，一个类在实现接口的同时可以继承另一个类。
提供实例字段和方法实现的任务应该由实现接口的那个类来完成！ 因此可以将接口看作没有实例字段的抽象类。

1.1. 接口的属性

接口不是类，不能用new运算符实例化一个接口。

1	x = new English();//error

但是可以声明接口的变量，对接口使用多态(引用实现了这个接口的类对象)

1	English en = new pingpongCoach(...);//ok

也可以用instanceof 检查一个对象是否实现了某个特定的接口。

1	if(anObject instanceof English)

接口可以继承另一个接口

1
2
3

public interface Orallanguage extends English{
....
}

接口中虽然不能包含实例字段，却可以包含常量。接口中的字段会被自动设置为public static final

public interface English {
    int num = 30;//public static final int num = 30;
    ....
}

1.2. 接口与抽象类

抽象类和接口的成员区别

抽象类：变量、常量；有构造方法，抽象方法，非抽象方法
接口：常量，抽象方法

一个类只能扩展一个类，但是能够实现多个接口

类和类之间能够多层继承，而接口和接口之间能够多继承

public interface English extends a,b{
//接口的多继承
}
public class English extends a,b//error

抽象类是对事物的抽象，而接口是对行为的抽象。（如运动员类，说英语方法）

2. 接口中的其他方法

接口中还允许有静态方法、私有方法和默认方法

2.1. 静态方法

接口中的静态方法只能通过接口名调用，静态方法能够拥有方法体。

1
2
3

static void ask(){
    System.out.println("do you like English?");
}

静态方法只能调用静态方法！

2.2. 私有方法

私有方法可以为静态方法或实例方法，仅限于在接口本身的方法中使用，只能用作其他方法的辅助方法。

2.3. 默认方法

可以为接口方法提供一个默认方法实现，用default修饰符标记这样一个方法

1
2
3

default void studyen(){
    System.out.println("study English");
}

接口的实现可以不用覆盖这个方法（很少），并且可以调用默认方法。

默认方法还可以调用其他方法（静态、私有）

2.4. 解决默认方法冲突

如果先在一个接口中将一个方法定义为默认方法，然后又在超类或另一个接口中定义同样的方法，在java中解决的方法如下：

超类优先，如果超类提供了一个具体方法，同名而且有相同参数类型的默认方法会被忽略。
接口冲突。如果一个接口中提供了一个默认方法，另一个接口提供了一个同名而且参数类型相同的方法，必须覆盖这个方法来解决冲突。

interface Person{
	default String getName(){return " "};
}
interface Named{
	default String getName(){return getClass().getName()+"_"+hashcode();}
}

class Student implements Person,Named{
	public String getName(){
		return Person.super.getName();
	}//选择两个冲突方法中的一个，或者覆盖这个方法
}//该类实现了上述两个接口

如果至少有一个接口提供了实现，编译器就会报告错误，程序员必须解决这个二义性。

如果两个接口都没有提供默认实现，则只需实现这个方法或者都不实现（该类为抽象类）

3. 对象克隆

为一个包含对象引用的变量建立副本时，原变量和副本都是引用的同一个对象，任何一个变量改变都会影响另一个变量。

public class demo {
    public static void main(String[] args) {
        CloneClass c1 = new CloneClass("mike",15);
        CloneClass c2 = c1;

        c2.setName("jack");
        System.out.println(c1.getName());//jack
    }
}

如果希望得到一个新对象，则需要使用clone方法，并且使用clone方法的类要实现Cloneable接口

1
2
3

CloneClass c2 = (CloneClass) c1.clone();
System.out.println(c1.getName());//mike

默认的clone方法是浅拷贝（被复制对象的所有值属性都含有与原来对象的相同，而所有的对象引用属性仍然指向原来的对象）
如果需要，可以提供深拷贝。

要小心使用clone，尽量使用new

4. lambda表达式

lambda表达式是一个可传递的代码块，可以在以后执行一次或多次。

lambda运算符：所有的lambda表达式都是用新的lambda运算符 “ -> “,可以叫他，“转到”或者 “成为”。运算符将表达式分为两部分，左边指定输入参数，右边是lambda的主体。

1	(String s) -> s.length()

如果方法只有一个参数，而且这个参数的类型可以推倒得出，那么甚至还可以省略小括号：

1	s -> s.length()

即使lambda表达式没有参数，仍需提供空括号

1	() -> System.out.println()

无须指定返回值

4.1. 函数式接口

对于只有一个抽象方法的接口，需要这种接口的对象时，就可以提供一个lambda表达式，这种接口称为函数式接口。

1
2
3

public interface lami {//只有一个抽象方法的接口为函数式接口
    int show(String s);
}

如何用lambda表达式来表示这个接口呢，看如下代码

public class lamc {
    public void showtest(String s,lami la){
        System.out.println(la.show(s));
    }
}

public class LambdaDemo {
    public static void main(String[] args) {
        lamc lam = new lamc();
        lam.showtest("demo",s -> s.length());//lambda表达式是一个接口的实现
        //第二个参数为一个函数式接口
    }
}

这时的lambda表达式实际为一个实现了该接口的类的实例对象，箭头右边是对接口中抽象方法的实现。

既然lambda表达式可以看做实现了接口的对象的话，那么以下方式也是可以的

1 2	lami la = s->s.length(); //接口lami中的抽象方法被实现为return s.length;

5. 方法引用

当lambda表达式只是执行一个方法调用时，可直接使用方法引用

1 2	lami la = s->s.length();//lambda表达式只是调用了String类的length方法 lami la = String::length;//用方法引用来进行简化

方法引用的格式为 类名::方法，方法也包括静态方法

方法引用和lambda表达式一样不能独立存在，总是转换为函数式接口的实例。

5.1. 变量作用域

lambda表达式有三个部分

一个代码块
参数
自由变量的值，这里指非参数而且不在代码中定义的变量

lambda表达式可以捕获外围变量的值，但是只能引用值不会改变的变量

1
2
3

for(int i = 0;i<9;i++){
    lami lb = s-> s+i;//error,i是可变的
}

即lambda表达式中捕获的变量实际上是事实最终变量。

另外还需注意一点，在lambda表达式中声明与一个局部变量同名的参数或局部变量是不合法的

6. 内部类

把类定义在另一个类的内部，该类就被称为内部类。

public class Outer {
    private int num = 10;
    final static int n = 1;
    public class inner{//内部类
        public void show(){
            System.out.println(num);//内部类可以直接访问外部类的数据成员（包括私有）
        }
    }

内部类方法可以访问定义在这个类作用域中的数据，包括私有数据，而外部类要访问内部类的成员要创建对象。

    public void method(){
        //show();//报错，不能直接访问内部类的成员
        inner in = new inner();
        in.show();//外部类访问内部类的成员需要创建对象
}

对于成员内部类，外界可以访问，不过需要特殊的格式

格式:外部类名.内部类名对象名 = 外部类对象.内部类对象

public class demo {
    public static void main(String[] args) {
        //创建内部类对象并调用方法
        Outer.inner in = new Outer().new inner();
        in.show();
        ...
}

对于局部内部类，外界不能访问；局部内部类还可以访问局部变量！

public class Outer {
    public void method(int n){
        class methodclass{
            public void show1(){
                System.out.println("局部变量为"+n);//访问局部变量
            }
        }
        methodclass methodclass = new methodclass();//需要创建对象
        methodclass.show1();
    }
}

6.1. 匿名内部类

匿名内部类是一个继承了该类或者实现了该接口的子类匿名对象！

new anonyClass(){
            public void show3(){
                System.out.println("匿名内部类！");
            }
        }.show3();//创建匿名内部类实现anonyClass接口，这是一个对象,能调用其实现的方法
        
anonyClass an = new anonyClass(){
            public void show3(){
                System.out.println("匿名内部类！");
            }
        };//该匿名内部类实现了anonyClass这个接口

上述的匿名内部类实现的是一个函数式接口，可以用lambda表达式来代替

1	anonyClass ano = ()-> System.out.println("匿名内部类！");

由于匿名内部类没有类名，所以不能有构造器

6.2. 静态内部类

只有内部类可以声明为static
特点：不能使用外部类的非static成员变量和成员方法。

非静态内部类编译后会默认的保存一个指向外部类的引用，而静态类却没有。即使没有外部类对象，也可以创建静态内部类对象

public class Outer {
    public static class inner{
        public void show(){
            System.out.println("静态内部类");
        }
    }
}

public class demo {
    public static void main(String[] args) {
        Outer.inner in = new Outer.inner();//无须外部类对象
}

注意：

静态内部类可以有静态字段和方法
接口中声明的内部类自动是static和public

展开全文 >>

字符串中数据排序

2020-04-09

字符串中的数据怎么进行排序呢？

首先将其转换为String数组
转化为int类型数组
利用Arrays类来进行排序
利用StringBuilder可以将整型转换为字符串。

以下为代码：

import java.util.Arrays;

/*
对字符串中的数字进行排序并输出
 */
public class StringSort {
    public static void main(String[] args) {
        String str = "91 37 41 38 50";
        System.out.println(str);

        String[] s = str.split(" ");//该方法将字符串转换为字符串数组，参数为分隔符
        //{"91"."37"."41","38","50"}

        int[] arr = new int[s.length];
        for(int i = 0;i<s.length;i++){
            arr[i] = Integer.parseInt(s[i]);//将字符串数组转换为int数组
        }

        Arrays.sort(arr);//排序

        StringBuilder sb = new StringBuilder();
        for(int i = 0;i<arr.length;i++){//将int数组转换为String
            if(i==arr.length-1){
                sb.append(arr[i]);
            }else{
                sb.append(arr[i]+" ");
            }
        }
        String s1 = sb.toString();
        System.out.println(s1);//37 38 41 50 91
    }
}

展开全文 >>

String类型和int类型之间相互转换

2020-04-09

关于这两种类型之间的相互转换，有几种下面几种方法：

public class StringToInt {
    public static void main(String[] args) {
        //Int to String
        // 方法一
        String s = ""+100;//用空字符串进行拼接
        // 方法二
        s = String.valueOf(100);//此方法也可以将浮点转换为String

        //String to Int
        //方法一
        Integer i = Integer.valueOf("100");//对字符串进行包装
        int num = i.intValue();//拆箱
        //方法二
        num = Integer.parseInt("100");//调用静态方法直接转换为int类型
    }
}

从上面可以看出，使用静态方法来转换更加简单。

展开全文 >>

java继承、多态和反射

2020-04-01

1. 覆盖方法
- 1.1. 关于变量的访问顺序
1. 子类构造器
1. 多态
- 3.1. 多态的前提和体现
- 3.2. 多态的好处与弊端
1. 理解方法调用
- 4.1. 阻止继承：final类和方法
1. 强制类型转换
1. 抽象类
1. 访问修饰符小结
1. Object：所有类的超类
- 8.1. equals方法
- 8.2. hashCode方法
- 8.3. toString方法
1. 泛型数组列表ArrayList
- 9.1. 访问数组列表的元素
- 9.2. 对象包装器和自动装箱
1. 参数数量可变的方法
1. 枚举类
1. 反射
- 12.1. 获取Class类的对象
- 12.2. 反射获取构造方法并使用
- 12.3. 反射获取成员变量并使用
- 12.4. 反射获取成员方法并使用
- 12.5. 通过反射越过泛型检查
- 12.6. 反射总结
1. 继承的设计技巧

继承

如果两个对象存在“is-a”关系，即某某是某某，可以使用继承。
使用关键字extends表示继承（c++中是 : ）,关键字extends表示正在构造的新类派生于一个已存在的类。这个已存在的类称之为基类，超类，父类；新类称为子类、派生类

1. 覆盖方法

超类中的一些方法对子类不一定适用，需要提供一个新的方法覆盖超类中的方法。

现假设有一个Employee(雇员类)和Manager(经理类),其中Employee中有一个薪资getSalary()方法及加薪raiseSalary()方法,Manager有一个奖金setBonus()方法.
Manager继承Employee

Employee类

public class Employee {
    private String name;//姓名
    private double salary;//工资
    private LocalDate hireDay;//雇佣时间

    public Employee(String name, double salary, int year, int month,int day) {
        this.name = name;
        this.salary = salary;
        hireDay = LocalDate.of(year,month,day);
    }

    public String getName() {
        return name;
    }

    public double getSalary() {
        return salary;
    }

    public LocalDate getHireDay() {
        return hireDay;
    }
    public void raiseSalary(double byPercent){//涨工资
        double raise = salary * byPercent / 100;
        salary += raise;
    }
}

Manager类

public class Manager extends  Employee{
    private double bonus;//奖金

    public Manager(String name, double salary, int year, int month, int day) {
        super(name, salary, year, month, day);
        bonus = 0;
    }

    public void setBonus (double b){
        bonus = b;
    }
}

Manager类中的getSalary()方法应该返回薪资和奖金的总和.所以需要在Manager中提供一个新的方法来覆盖超类Employee中的方法

public class Manager extends  Employee{
    .
    .
    public double getSalary() {
       .
       .
    }
}

刚开始一般都会这么想

1
2
3

public double getSalary() {
       return salary + bonus; //报错
   }

salary是Employee类的私有成员，只有他自己能够访问

那么可不可以调用Employee的访问器来访问salary呢?

public double getSalary() {
        double baseSalary = getSalary(); //报错
        return baseSalary +bonus;
    }

这是个死循环，覆盖的方法名和被覆盖的方法的名字是保持一致的！，它会首先在本类中寻找，因此这个方法会无限调用自己，应该使用关键字super来访问Employee中的getSalary方法

public double getSalary() {
        double baseSalary = super.getSalary();
        return baseSalary +bonus;
    }

super和this相对应，一个表示父类，一个表示本身

警告：在覆盖方法时，子类方法不能低于超类方法的可见性！

1.1. 关于变量的访问顺序

如果在子类方法中访问一个变量

现在子类局部变量找
子类成员范围找
父类成员范围找（非私有）
没找到就报错

方法中的局部变量会覆盖成员变量，虽然也可以使用super和this来访问成员变量，但是在子类方法中定义的局部变量要尽量不与成员变量同名！

2. 子类构造器

子类构造器一定要调用超类的构造器，如果子类构造器没有显式地调用超类的构造器，将自动调用超类的无参构造器
但是如果超类没有提供无参构造器，子类又有没有显式地调用超类其他构造器，java编译器会报错！

3. 多态

在java中，对象变量是多态的。
例如

1
2
3

Employee e;
e = new Employee();
e = new Manager();//Manager继承自Employee，这也是正确的

即一个对象变量即可以引用其本身类型的变量，也可以引用任何一个子类的对象.

但是： 编译器只将e看做是Employee的对象，e只能访问Employee类的方法，不能访问子类特有的方法。

//Manager类有个自己的方法setBonus
Manager boss = new Manager(...);
Employee[] staff = new Employee[3];
staff[0] = boss;//父类对象变量引用子类对象
boss.setBonues(5000);//正确
staff[0].setBonues(5000);//错误
//因为staff[0]声明的类型为Employee，而setBonus不是Employee类的方法

注意： 子类不能引用父类

1	Manager m = staff[1];//error;

3.1. 多态的前提和体现

有继承/实现关系
有方法重写
有父类引用指向子类对象

3.2. 多态的好处与弊端

提高了程序的拓展性：定义方法的时候，使用父类型作为参数，将来使用的时候可以使用子类作为参数
不能使用子类特有的功能

4. 理解方法调用

编译器查看对象的声明类型和方法名
确定方法调用中提供的参数类型
静态绑定：如果是static、private、final方法或者构造器，编译器将准确地知道应该调用哪个方法
动态绑定：程序运行并且采用动态绑定（多态）调用方法时，虚拟机必须调用与x所引用对象的实际类型所对应的方法。假设x的实际类型为d，它是c的子类，如果d定义了这个方法就会调用这个方法；否则将在d类的超类中寻找。

4.1. 阻止继承：final类和方法法
将某个特定的方法声明为final，子类就不可以重写（覆盖）这个方法。
将某个类声明为final，其中所有的方法都会被声明为final，但不包括字段

5. 强制类型转换

当一个父类对象变量引用子类对象时，如果要访问子类独有的方法，则需要进行强制类型转换

1
2
3

Employee[] staff = new Employee[3];
staff[0] = new Manager();
Manager boss = (Manager)staff[0];//正确,staff[0]为Manager的一个实例

前提是父类对象变量的实际类型要与转换类型一致，如果不一致将会发生错误

1	Manager boss = (Manager)staff[1];//error,staff[1]的实际类型时Employee

因此在进行强制转换前，最好检查一下是否能成功地转换

if(staff[1] instanceof Manager)
{
   boss = (Manager)staff[1];
}//检查是否为Manager的一个实例,是返回true，在这里返回false

综上所述：

只能在继承层次内进行强制类型转换
在将超类强制转换为子类之前，应该使用instanceof进行检查

6. 抽象类

可以用关键字abstract来声明一个类，说明这个类为抽象类。

1
2
3

public abstract class animal {
       ......
}

说明这个类不能被实例化，也就是不能创建抽象类的对象

1	animal an = new animal();//error

不过可以定义一个抽象类的对象变量，只能引用非抽象子类的对象

public class cat extends animal {//非抽象子类
      ......
}
animal an = new cat();//引用子类对象

可以将方法声明为抽象方法，那么就不需要实现这个方法了

1
2
3

public abstract class animal {
    abstract public void eat();//不需要在此类中实现
}

抽象方法的功能由其子类实现，抽象类的子类要么重写抽象类中的抽象类，要么也定义为抽象类！

注意事项:

抽象方法必须在抽象类中，有抽象方法的类一定为抽象类，但抽象类可以没有抽象方法。
抽象类可以有构造器，主要用于子类访问父类数据的初始化。
抽象方法类似于c++中的纯虚函数。
将通用字段和方法放在超类中

7. 访问修饰符小结

修饰符	权限
private	仅对本类可见
public	对外部完全可见
protected	对本包和所有子类可见
默认，不需要修饰符	对本包可见

8. Object：所有类的超类

java中每个类都扩展了Object，如果没有明确指出超类，Object就被认为是这个类的超类。

可以使用Object类型的变量引用任何类型的对象

1	Object obj = new Employee();

但如果相对其中的内容进行具体的操作，需要进行强制转换

1	Employee e = (Employee)obj;

8.1. equals方法

Object类中的equals方法用于检测一个对象是否等于另一个对象，但只是确定两个对象引用是否相等。

我们来看一下equals方法的源码

1
2
3

public boolean equals(Object obj) {
    return this == obj;
}

他依然是比较两个对象的地址值，只有当两个变量引用同一个对象时才会相等，这和“==”是等效的！

animal a = new cat();
animal b = new cat();
System.out.println(a.equals(b));//false

a = b;//引用同一个对象
System.out.printlln(a.equals(b));//true

如果要比较两个对象的内容是否相等，需要对equals方法进行重写。
在子类定义equals方法时，首先调用父类的equals进行比较（因为通用字段在父类中）。如果超类字段都相等，再比较子类字段。

为了防备两边都为null的情况，有一种Objects.equals(a,b)方法。如果两边都为null，返回true；只有一个为null，返回false；都不为null，则调用a.equals(b).

java中对于equals方法的规则如下：

自反性：对于任何非空引用x，x.equals(x)应该返回true。
对称性：对于任何x和y，当且仅当y.equals(x)返回true时,x.equals(y)返回true.
传递性：对于任何引用x,y,z,如果x.equals(y)为true，y.equals(z)为true，那么x.equals(z)为true。
一致性：如果x和y的引用没有发生变化，反复调用x.equals(y)应该返回同样的值。
对于任何非空引用x,x.equals(null)应该返回false。

idea中可以用快捷键重写，重写equals时也会自动重写hashcode。

8.2. hashCode方法

x.hashCode()返回散列码，Object默认会从对象的存储地址得出散列码。

equals与hashCode的定义必须相容:如果x.equals(y)返回true，那么x.hashCode()与y.hashCode()返回相同的值.

8.3. toString方法

源码为

1
2
3

public String toString() {
    return this.getClass().getName() + "@" + Integer.toHexString(this.hashCode());
}//打印对象的类名和散列码

idea中也可以用快捷键重写

如果x是一个任意对象，并调用System.out.println(x),println方法会简单地调用x.toString方法，并打印输出得到的字符串。

数组继承了Object类的toString方法，并没有覆盖

1 2	int[]arr = new int[]{1,2,3}; System.out.println(arr);//结果为[I@4411d970

因此要打印数组，要调用静态方法Arrays.toString

1 2	System.out.println(Arrays.toString(arr)); //结果为[1, 2, 3]

9. 泛型数组列表ArrayList

ArrayList相当于c语言中的顺序表（Linklist相当于链表），它是一个泛型类。

声明和构造一个数组列表

1	ArrayList<String> objects = new ArrayList<>();//右边的<>内容可以省略

尖括号内的类型参数不允许是基本类型！ 要使用包装器。

使用add方法将元素添加到数组列表当中

1
2
3

objects.add("hello");
objects.add("world");
System.out.println(objects);//[hello, world]

如果调用add而内部数组已满，数组列表就会自动地创建一个更大的数组，并将所有的对象从较小的数组中拷贝到较大的数组中。

如果已经知道或能够估计出数组可能存储的元素数量，就可以在填充数组之前调用ensureCapacity方法

1	objects.ensureCapacity(100);//分配一个包含100个对象的内部数组

这样一来，前100次add调用不会带来开销很大的重新分配空间，或者还可以这样

1	ArrayList<String> objects = new ArrayList<>(100);//直接传给构造器

数组列表的容量和数组的大小是有区别的，容量只是可能保存的元素的个数；而数组的大小就说明有这么多个空位置可以使用。

9.1. 访问数组列表的元素

不能像数组一样用[ ]来访问元素，而是用get来访问数组列表的元素。

ArrayList<String> objects = new ArrayList<>(3);
objects.add("hello ");
objects.add("world ");
objects.add("java!");
System.out.println(objects.get(0)+objects.get(1)+objects.get(2));
//打印结果
//hello world java!

如果要修改某个元素的值，则要使用set方法

1
2
3

objects.set(2,"yeah!");
System.out.println(objects.get(0)+objects.get(1)+objects.get(2));
//hello world yeah!

数组列表的容量和实际大小是不同的

ArrayList<String> objects = new ArrayList<>(5);
objects.add("hello ");
objects.add("world ");
objects.add("java!");
System.out.println(objects.size());//容量为5，大小为3
objects.set(3,"a");//error,只有当实际大小大于3时才能设置

还可以删除数组列表中的某个元素

1
2
3

String str = objects.remove(2);//返回被删除的元素
System.out.println(objects.size());//2
System.out.println(objects);//[hello , world ]

for each循环也同样适用于数组列表

        for(String s:objects){
            System.out.println(s);
        }
//hello 
//world 
//java!

9.2. 对象包装器和自动装箱

同时包装器类还是final，不能派生他们的子类。

对于那些泛型类包容的是对象类型，即泛型类的类型参数要是对象。而基本类型不是对象，可以用包装器代替基本类型。

1 2	ArrayList<int> list = new ArrayList<>();//error ArrayList<Integer> list = new ArrayList<>();//ok

有一个很方便的特性能将基本数据类型传进数组列表

list.add(3);//ok，等价于以下形式
list.add(Integer.valueOf(3));//会将3自动包装

int n = list.get(i);//ok，将一个Integer对象赋给int值时会自动拆箱

自动装箱与拆箱也适用于算术表达式

1 2	Integer n = 3;//ok,装箱 n++;//自动拆箱，进行自加运算，再自动装箱

包装器和基本类型有一点很大的不同，基本类型可以用”==”进行比较，而包装器是引用类型，要用equals方法进行比较。

最后强调一下，装箱和拆箱是编译器要做的工作，而不是虚拟机。

如果想要构造一个Integer对象,则需要使用工厂方法

1	Integer integer = Integer.valueOf(String s);//s为数字字符串

10. 参数数量可变的方法

可以提供参数数量可变的方法，用…即可

public static void meth(int...num){
   for(int n:num){
     System.out.print(n);
}

括号中的参数都为int类型，参数的个数是可变的，调用以上方法

1 2	meth(1,2,3,4,5,6); //结果为123456

可见，参数int…num实际为数组，可以看成int[ ]num，它将所有的参数保存在数组之中，具体事例可以参考printf方法的实现。

11. 枚举类

对于定义一个枚举类型

1	public enum size{small,mid,large}

这个声明定义的类型是一个类，它刚好有四个事例，不可能构造新的对象。
比较两个枚举类型的值可以直接使用==

我们也可以为其添加构造器，方法和字段

public enum size{
    small("s"),mid("m"),large("l");
    private String abbrevuation;
    private size(String s){
        this.abbrevuation = s;
    }
    public String getAbbrevuation(){return abbrevuation;}
}

枚举类的构造器总是私有的。

所有枚举类型都是Enum类的子类，其中继承过来的toString方法将返回枚举常量名。

1
2
3

size s = size.small;
System.out.println(s.toString());
//输出small

每个枚举类型都有一个静态的values方法，它将返回一个包含全部枚举值的数组。

size[] si = size.values();
for(size size:si){
    System.out.println(size);
}
//输出small mid large

compareTo可以用来比较两个枚举常量的大小，实现略

12. 反射

java反射机制，是指在运行时去获取一个类的变量和方法信息，然后通过获取到的信息来创建对象，调用方法的一种机制。

12.1. 获取Class类的对象

要想通过反射去使用一个类，首先我们要获取该类的字节码文件对象，也就Class类型的对象。

这里有个测试类

package reflection;
public class test {//测试类
    private int age;//年龄
    private String name;//姓名
    private String address;//地址

    public test() {
        age = 0;
        name = "none";
        address = "earth";
    }//无参构造函数
    public test(int a,String n,String add){
        age = a;
        name = n;
        address = add;
    }
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "test{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

有三种方法来获取该测试类的Class对象

Class<test> testClass = test.class;

Class<?> testClass = Class.forName("reflection.test");//类的位置

test a = new test();
Class<? extends test> aClass = a.getClass();

Class类是一个泛型类，它表示每个类运行时的类型信息，每个类都有个Class类的对象。

虚拟机为每个类型管理一个唯一的Class对象，因此可以用==来实现两个类对象的比较

1 2	test t = new test(); System.out.println(test.class==t.getClass());//true

12.2. 反射获取构造方法并使用

如果有一个Class类型的对象，可以用它构造类的实例。调用getConstructor方法将得到一个Constructor类型的对象，然后使用newInstance方法来构造一个实例。

//获取class对象
Class<?> c = Class.forName("reflection.test");
//等同于test o = new test(3,"jack","北京");通过反射来构造对象
Constructor con = c.getConstructor(int.class,String.class,String.class);
Object o = con.newInstance(3, "jack", "北京");//传进参数

其中getConstructor方法中的参数为Class类型的对象，指定要调用的构造器，并且只能是非私有的构造器，如果需要获取所有类型的构造器，需要用getDeclaredConstructor方法

newInstance方法返回一个Object类的引用

12.3. 反射获取成员变量并使用

可以通过getField方法来获取成员变量，由于许多成员变量都是私有的，因此要使用getDeclaredField方法来获取私有变量，返回一个Filed对象

1	Field age = c.getDeclaredField("age");//访问变量名为age的私有变量

获取了变量之后，便可以对其进行操作，但是默认是不能对私有成员进行操作的！ 因此需要调用setAccessible方法来取消检查

1	age.setAccessible(true);

现在可以用set方法来修改成员变量,第一个参数为所要修改的对象

1	age.set(o,5);//修改对象o中的age为5

get方法来返回这个Field对象所描述的对象的值

1	System.out.println(age.get(o));//5

下面来看一个例子，要求通过反射来修改类中的字段

public class demo {
    public static void main(String[]args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
        //利用反射来修改类中的字段
        //获取class对象
        Class<?> c = Class.forName("reflection.test");
        //等同于test o = new test(3,"jack","北京");通过反射来构造对象
        Constructor con = c.getConstructor(int.class,String.class,String.class);
        Object o = con.newInstance(3, "jack", "北京");

        System.out.println(o);//test{age=3, name='jack', address='北京'}

        //o.age = 5
        //Field age = c.getField("age");只能访问公有字段
        Field age = c.getDeclaredField("age");
        age.setAccessible(true);//对私有的成员变量/方法都要暴力使用
        age.set(o,5);//set方法来修改成员变量,第一个参数为所要修改的成员变量所在的对象

        //o.name = "peter"
        Field name = c.getDeclaredField("name");
        name.setAccessible(true);
        name.set(o,"peter");

        //o.address = "长沙"
        Field address = c.getDeclaredField("address");
        address.setAccessible(true);
        address.set(o,"长沙");
        System.out.println(o);//test{age=5, name='peter', address='长沙'}
    }
}

//打印结果为
//test{age=3, name='jack', address='北京'}
//test{age=5, name='peter', address='长沙'}

12.4. 反射获取成员方法并使用

与获取成员变量一样，方法可以通过getMethod来获取，返回一个Method对象（这些也都是非私有的）

Method getAge = c.getMethod("getAge");//第一个参数为方法名
//调用getAge()
Method setage = cl.getMethod("setAge", int.class);//第二个参数为要调用的方法参数的class对象
//调用setAge(int)

通过invoke方法来使用调用的方法,如果返回类型是基本类型，invoke方法会返回其包装器类型，invoke方法的第一个参数为所调用方法的对象，第二个为传进方法的值

1 2	Method getAge = c.getMethod("getAge"); int a = (int) getAge.invoke(o);//int a = getAge();调用o中的getAge方法

下面来看例子，通过反射来调用方法并使用

public class demo2 {
    public static void main(String[]args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException {
        //获得Class对象
        Class<?> cl = Class.forName("reflection.test");
        //使用反射调用方法

        //test t = new test();
        Constructor<?> constructor = cl.getConstructor();//默认构造函数
        Object o = constructor.newInstance();

        //t.getAge();
        Method getAge = cl.getMethod("getAge");//先得到方法
        int a = (int) getAge.invoke(o);//如果返回类型是基本类型，invoke方法会返回其包装器类型
        System.out.println(a);//默认值为0

        //t.setAge(12);
        Method setage = cl.getMethod("setAge", int.class);
        setage.invoke(o,12);//第一个参数是所要调用方法的对象，可以看做调用o的setage方法
        a = (int) getAge.invoke(o);//通过invoke来使用方法
        System.out.println(a);//值为12

        //对于静态方法，invoke中的第一个参数可以忽略
    }
}

12.5. 通过反射越过泛型检查

对于泛型类ArrayList，一旦尖括号中的类型定了，就不能传其他的值进去。

ArrayList<Integer> arr = new ArrayList();
arr.add(10);
arr.add(20);
arr.add("hello");//会报错

这时可以利用反射来越过泛型检查

Class<? extends ArrayList> cl = arr.getClass();
Method add = cl.getMethod("add", Object.class);
add.invoke(arr, "hello");
System.out.println(arr);//[10, 20, hello]

12.6. 反射总结

利用反射来操作类的步骤大致为以下几点

构造类的Class对象(三种方法)。
通过Class对象来获取构造器来创建实例。
通过所构造的Class对象的getMethod和getField方法来获取类的方法和成员变量。
使用返回的Field类所提供的各种方法来操作成员变量。
使用返回的Method类的invoke方法来使用所调用的方法。
如果要访问私有方法、构造器、变量，要使用setAccessible(true)。

注意事项：

得到构造器、方法和字段的方法都有一个获取所有类型的方法getDeclaredXXX,可以用它来访问私有类型，不过要加上setAccessible
invoke的返回值为Object，因此要进行强制类型转换.
13. 继承的设计技巧
将公共操作和字段放在超类中
不要使用被保护的字段
使用继承实现“is-a”关系
除非所有继承的方法都有意义，否则不要使用继承
在覆盖方法时，不要改变预期的行为
使用多态，而不用使用类型信息
不要滥用反射

展开全文 >>

C语言：通讯录

2020-03-29

突然在电脑文件夹中找到了这个，这是我在学习c语言时写的第一个练手小项目，看着当初的代码，忍不住吐槽了几句：这些命名是什么鬼？！这些goto是什么鬼？！还好原来写了点注释，要不然就看不懂了……

以下是代码，大概五百多行

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef struct head {
	int num;//序号 
	char name[20];//姓名 
	char number[20];//电话号码 
	struct head* next;
}node,*p;//联系人结构体 

p head1; //声明通讯录单链表 

void manage();//管理函数 

void boardadd();//键盘添加子函数 

void del();//删除主菜单
 
void delname();//姓名删除函数 

void delnum();//按编号删除

void delnumber();//按电话号码删除 

void search();//查询函数 

void filemanage();//存储管理函数

void fileadd();//从文件导入信息

void filestore();//存储函数 

void board();// 键盘添加函数 

int check(p);//检查是否重复 

void browse();//浏览所有联系人

void sort();//按编号冒泡排序 

int main()
{
	int i;
	start:
	printf("*****************************************\n");
	printf("             我的通讯录\n");
	printf("*****************************************\n");
	printf("                菜单：\n");
	printf("          1.管理联系人信息\n");
	printf("          2.查询\n");
	printf("          3.存储管理\n");
	printf("          4.退出通讯录\n");
	printf("*****************************************");
	printf("\n-----------------------------------------\n");
	printf("          请输入你的操作(1~3): ");
	scanf("%d",&i);
	switch (i)
	{
	case 1:
		system("cls");
		manage();
		goto start;
		break;
	case 2:
		system("cls");
		search();
		putchar('\n');
		goto start;
		break;
	case 3:
		system("cls");
		filemanage();
		goto start;
		break;
	case 4:
		system("cls");
		printf("感谢您的使用 再见！");
		break;
	default:
		system("cls");
		printf("请输入正确的操作！\n");
		goto start;
		break;
	}
	printf("\n");
	system("pause");
	return 0;
}

void manage()//联系人管理主函数
{
	int i;
	printf("请选择操作方式：\n");
	printf("1.从键盘添加联系人\n");
	printf("2.删除联系人\n");
	printf("3.返回上一级菜单\n");
	error://输入错误goto返回点 
	printf("请输入您的选择: \n");
	scanf("%d", &i);
	switch (i)
	{
	case 1:
		boardadd(); 
	    system("pause");
		system("cls");
		break;
	case 2:
		system("cls");
		del();
		break;
	case 3:
		system("cls");
		break;
	default:
		printf("输入错误! 请重新输入\n");
		goto error;
		break;
	}
	sort();
}

void boardadd(){//从键盘添加联系人信息 
		int c;
		do{
		board();
		printf("继续添加？1是/0否\n");
		scanf("%d",&c);
		getchar();
	    }while(c);
}

void board()//从键盘添加联系人子函数
{
	if(!head1){
	head1 = (p)malloc(sizeof(node));
	head1->next = NULL;
    }
    p s=head1;
    int n = 0;
    while(s->next!=NULL){
    	s=s->next;
	}
	printf("请输入联系人的编号 姓名 电话号码:\n ");
	p f = (p)malloc(sizeof(node));
	scanf("%d %s %s",&f->num,&f->name,&f->number);
	switch(check(f)){
		case 1:
			printf("此编号已存在,请重新输入!\n");
			return;
		case 2:
			printf("此人已存在,请重新输入!\n");
			return; 
		case 3:
			printf("此号码已存在,请重新输入!\n");
			return; 
		default:
		    break; 
	} 
	f->next = s->next; 
	s->next = f;
}

void delname()//删除联系人 
{
	char a[20];
	printf("请输入要删除联系人的姓名: ");
	fflush(stdin);
	scanf("%s",a);
	p l = head1;
	p q = l->next;
	while(q){
	if(strcmp(a,q->name)==0){
		l->next=q->next;
		free(q);
		printf("删除成功!\n");
		break;
	}
	else{
		l=l->next;
		q=q->next;
	}
   }
   if(q == NULL){
   	printf("未找到此人！\n");
   }
}

void search()//
{
	if(!head1){
		printf("通讯录为空!\n");
		system("pause");
		system("cls");
		return;
	}
	int i,j;
	char buff[20];
	p l=head1->next;
	if(l==NULL) { 
	 printf("通讯录为空！\n");
	 return;
	} 
	printf("1.按编号查询\n");
	printf("2.按姓名查询\n");
	printf("3.按电话号码查询\n");
	printf("4.查看所有联系人\n"); 
	printf("5.返回上一菜单\n");
	search_end://goto跳转点 
	printf("请输入您的选择(1,2,3,4,5):  "); 
	scanf("%d",&i);
	switch(i)
	{
		case 1:
			printf("请输入编号：");
			getchar();
			scanf("%d",&j);
			while(1){
				if(l == NULL){
					printf("未找到此人!\n");
					break;
				}
				else if(j==l->num){
					printf("%d %s %s\n",l->num,l->name,l->number);
					printf("继续查询？1（是）/0（否）\n") ;
					int c;
					fflush(stdin);
					if(( c = getchar())=='1')
					goto search_end;
					else break;
				}
				else { 
				    l=l->next;
				}
			}
			break;
		case 2:
			printf("请输入姓名：");
			getchar();
			scanf("%s",buff);
			while(1){
				if(l == NULL){
					printf("不存在此人！\n");
					break;
				}
				else if(!strcmp(buff,l->name)){
					printf("%d %s %s\n",l->num,l->name,l->number);
					printf("继续查询？1（是）/0（否）\n") ;
					int c;
					fflush(stdin);
					if(( c = getchar())=='1')
					goto search_end;
					else break;
				}
				else{
				    l=l->next;
				}
			}
			break;
		case 3:
			printf("请输入电话号码：");
			getchar();
			scanf("%s",buff);
			while(1){
				if(l == NULL){
					printf("未找到此人!\n");
					break;
				}
				else if(!strcmp(buff,l->number)){
					printf("%d %s %s\n",l->num,l->name,l->number);
					printf("继续查询？1（是）/0（否）\n") ;
					int c;
					fflush(stdin);
					if(( c = getchar())=='1')
					goto search_end;
				    else break;
				}
				else{
				    l=l->next;
			    }
	        }
	        break;
	    case 4:
	    	printf("\n编号 姓名   电话号码\n");
		    browse(); 
		    break; 
		case 5:
			break;
		default:
			printf("输入错误!\n");
			break;
	} 
	system("pause");
	system("cls");  
}

void browse(){
	for(p beg = head1->next;beg!=NULL;beg = beg->next){//遍历链表 
		printf("%d    %s     %s\n",beg->num,beg->name,beg->number);
	}
}

void filemanage(){
	int i;
	printf("1.导入联系人信息\n");
	printf("2.保存联系人信息\n");
	printf("3.返回\n");
	printf("请输入您的选择: \n");
	scanf("%d",&i);
	switch(i){
		case 1:
			fileadd();
			sort();
			break;
		case 2:
			filestore();
			break;
		case 3:
			system("cls");
			break;
		default:
			system("cls");
			printf("输入错误!\n");
			break;
	}
} 

void fileadd(){
	if(!head1){
		head1=(p)malloc(sizeof(node));
		head1->next=NULL;
	}
	char file_address[20];
	printf("请输入文件路径: ");
	fflush(stdin); 
	gets(file_address); 
	FILE *fp=fopen(file_address,"r");
	if(fp==NULL){
		fprintf(stderr,"打开文件失败!\n");
		exit(-1);
	}
	else{
		p s=head1;
		p f;
		while(s->next!=NULL) s=s->next;//转移到链表末尾 
		f=(p)malloc(sizeof(node));
		while(fscanf(fp,"%d%s%s",&f->num,&f->name,&f->number)!=EOF){
			if(check(f)!=0){
				continue;
			}
			f->next=s->next;
			s->next=f;//这里前面忘记设置了，搞得程序一直有问题。。。。 
			s=f;
			f=(p)malloc(sizeof(node));
		}
		system("cls");
		printf("导入成功！\n");
		fclose(fp);
	}
}

void filestore(){
	if(!head1){
		system("cls");
		printf("通讯录为空！\n");
		return;
	}	
	char file_address[20];
	printf("请输入文件路径: ");
	fflush(stdin); 
	gets(file_address); 
	FILE *fp=fopen(file_address,"w");
	if(fp==NULL){
		fprintf(stderr,"打开文件失败!\n");
		exit(-1);
	}
	else{
		p s=head1->next;
		while(s){
			fprintf(fp,"%d %s %s\n",s->num,s->name,s->number);
			s=s->next;
		}
		system("cls");
		printf("保存成功！\n");
		fclose(fp);
	}
}

int check(p che){
	for(p s1=head1->next;s1!=NULL;s1=s1->next){
		if(s1->num==che->num){
			return 1;
		}
		if(strcmp(s1->name,che->name)==0){
			return 2; 
		}
		if(strcmp(s1->number,che->number)==0){
			return 3;
		}
	}
	return 0;
}

void sort(){//采用冒泡排序 
	if(head1==NULL||head1->next==NULL) return;
	p begin = head1->next;
	p last = NULL;
	char bufname[20];
	char bufnumber[20];
	while(begin!=last){
		while(begin->next!=last){
			if((begin->num)>(begin->next->num)){
				int temp = begin->num;
				begin->num = begin->next->num;
				begin->next->num = temp;
				
				strcpy(bufname,begin->name);
				strcpy(begin->name,begin->next->name);
				strcpy(begin->next->name,bufname);
				
				strcpy(bufnumber,begin->number);
				strcpy(begin->number,begin->next->number);
				strcpy(begin->next->name,bufnumber);
			}
			begin = begin->next;
		}
		last = begin;
		begin = head1->next;
	}
}

void del(){
	if(!head1) {
	    printf("通讯录为空!\n");
	    system("pause");
		system("cls");
	    return;
	}
	int i;
	printf("\n编号 姓名   电话号码\n");
	browse();
	printf("\n");
	printf("请选择操作方式：\n");
	printf("1.按姓名删除联系人\n");
	printf("2.按编号删除联系人\n");
	printf("3.按电话号码删除联系人\n");
	printf("4.返回上一级菜单\n");
	printf("请输入您的选择: \n");
	scanf("%d", &i);
	switch(i){
		case 1:
			delname();
			break;
		case 2:
			delnum();
			break;
		case 3:
			delnumber();
			break;
		default:
			break;
	} 
	system("pause");
    system("cls");
} 

void delnumber(){
	char a[20];
	printf("请输入要删除联系人的电话号码: ");
	fflush(stdin);
	scanf("%s",a);
	p l = head1;
	p q = l->next;
	while(q){
	if(strcmp(a,q->number)==0){
		l->next=q->next;
		free(q);
		printf("删除成功!\n");
		break;
	}
	else{
		l=l->next;
		q=q->next;
	}
   }
   if(q == NULL){
   	printf("未找到此人！\n");
   }
}

void delnum(){
	int a;
	printf("请输入要删除联系人的编号: ");
	fflush(stdin);
	scanf("%d",&a);
	p l = head1;
	p q = l->next;
	while(q){
	if(a == q->num){
		l->next=q->next;
		free(q);
		printf("删除成功!\n");
		break;
	}
	else{
		l=l->next;
		q=q->next;
	}
   }
   if(q == NULL){
   	printf("未找到此人！\n");
   }
}

我在原来的基础上添加了个排序的算法，每次添加完联系人或者删除联系人后会按编号进行排序，要不然设置这些个编号没什么用

void sort(){//采用冒泡排序 
	if(head1==NULL||head1->next==NULL) return;
	p begin = head1->next;
	p last = NULL;
	char bufname[20];
	char bufnumber[20];
	while(begin!=last){
		while(begin->next!=last){
			if((begin->num)>(begin->next->num)){
				int temp = begin->num;
				begin->num = begin->next->num;
				begin->next->num = temp;
				
				strcpy(bufname,begin->name);
				strcpy(begin->name,begin->next->name);
				strcpy(begin->next->name,bufname);
				
				strcpy(bufnumber,begin->number);
				strcpy(begin->number,begin->next->number);
				strcpy(begin->next->name,bufnumber);
			}
			begin = begin->next;
		}
		last = begin;
		begin = head1->next;
	}
}

菜单界面并不好看，只是完成了一些基本的功能：查询，删除，添加，保存

曾经我在这里面踩了个很大的坑！在里面我写了几个野指针，只是定义了几个指针，并没有给他们赋初值（包括NULL），导致我在后面用这些指针和NULL进行比较的时候程序总是崩溃！废了九牛二虎之力才将这些错误找出来。

这个通讯录还有几个不足之处，在从文件导出信息的时候，如果联系人编号重复但姓名不重复，这个联系人也不会导出，可能会丢失一些信息。

写项目的时候还是很快乐的，但找bug的时候是痛苦的，以后还是要更加注意一点，命名也不要这么随便，也不要求方便乱用goto。。。

以上代码皆为我一人所写，如有雷同，纯属巧合（毕竟写的烂）

展开全文 >>

一个关于复杂声明的问题

2020-03-25

在看《c陷阱与缺陷》时，有这么一个复杂声明

1	((void()())0)();

起初看上去的确挺头疼的，思考了许久突然就有了思路，我的突破点在那个0。

(void(*)())0，0前面的括号与我们平常见的强制类型转换符极其相似

1	int x = (int)y;

所以这是将0强制转换成某种类型。
再看括号中的void(*)(),

void (*p)();//这是一个函数指针，指向返回值为void，没有参数的函数
int x;//这是个整型变量
(int)//这是个强制转换类型符，转换为整型
(void (*)())//所以这也是个强制转换类型符，转换为函数指针

而将其去掉变量名p，则为强制转换类型符，强制转换为函数指针类型。
所以(void (*))0 是将常数0强制转换为函数指针类型。

整个表达式的意思是调用0这个函数指针所指向的函数。

int MAX(int,int);
...
int (*p)(int,int) = MAX;//使函数指针指向MAX函数

(*p)(2,3)；//调用函数指针所指向的函数

展开全文 >>

快速排序java实现

算法的改进

含大量重复元素的数组

1. collection接口

1.1. 迭代器

1.2. 实现foreach循环

1.3. 泛型实用方法

2. 集合框架中的接口

2.1. List接口

2.2. 散列集

2.3. 树集

2.4. 队列与双端队列

2.5. 优先队列

3. 映射

3.1. 基本映射操作

3.2. 更新映射条目

3.3. 映射视图

3.4. 弱散列映射

3.5. 连接散列集和映射

3.6. 标识散列映射

4. 视图与包装器

4.1. 小集合

4.2. 子范围

4.3. 不可修改的视图

4.4. 检查型视图

5. 算法

5.1. 排序与混排

5.2. 二分查找

5.3. 批操作

5.4. 集合与数组的转换

泛型程序设计

1. 定义简单的泛型类

2. 泛型方法

2.1. 类型变量的限定

3. 泛型代码和虚拟机

3.1. 类型擦除

3.2. 转换泛型表达式

3.3. 转换泛型方法

4. 限制与局限性

5. 泛型类的继承规则

6. 通配符类型

6.1. 统配符的限定

6.2. 通配符限定的行为差异

6.3. 无限定通配符

6.4. 通配符捕获

7. 反射和泛型

1. 异常

1.1. 异常分类

1.2. 声明检查型异常

1.3. 抛出异常的情况

1.4. 如何抛出异常

1.5. 创建异常类

1.6. 捕获异常

1.7. 再次抛出异常与异常链

1.8. finally子句

1.9. try-with-Resources语句

1.10. 使用异常的技巧

2. 断言

3. 日志

3.1. 基本日志

3.2. 日志级别

3.3. 日志技巧

接口、lambda表达式与内部类

1. 接口

1.1. 接口的属性

1.2. 接口与抽象类

2. 接口中的其他方法

2.1. 静态方法

2.2. 私有方法

2.3. 默认方法

2.4. 解决默认方法冲突

3. 对象克隆

4. lambda表达式

4.1. 函数式接口

5. 方法引用

5.1. 变量作用域

6. 内部类

6.1. 匿名内部类

6.2. 静态内部类

字符串中的数据怎么进行排序呢？