1607094128-解奕鹏

[xieyipeng]

排序算法

public class baseSort {
    public void sort(int[] a){

    }
}

快速排序

public class QuickSort extends baseSort {

    @Override//重写
    public void sort(int[] a){
        sort(a,0,a.length-1);
    }

    public void sort(int[] a,int low,int high) {

        super.sort(a);
        if (low < high) {
            int middle = getMiddle(a, low, high);//将a数组进行一分为二
            sort(a, low, middle - 1);//对低字表进行递归排序
            sort(a, middle + 1, high);//对高字表进行递归排序
        }
    }

    public int getMiddle(int[] a, int low, int high) {
        int tmp = a[low];//数组的第一个作为中轴
        int i = low;
        int j = high;
        while (i != j) {
            while (a[j] >= tmp && i < j) {
                j--;
            }
            //a[low] = a[high];//比中轴小的记录移到低端
            while (a[i] <= tmp && i < j) {
                i++;
            }
            int temp = a[i];
            a[i] = a[j];//比中轴大的记录移到高端
            a[j] = temp;
        }
        int temp = a[low];
        a[low] = a[i];
        a[i] = temp;
        return i;
    }
}

插入排序

public class InsertSort extends baseSort{//插入排序

    @Override
    public void sort(int[] a) {
        for (int j = 1; j < a.length; j++) {//j从第二个元素开始
            int key = a[j];
            int i = j - 1;//i表示在j前面有多少个元素
            while (i >= 0 && a[i] > key) {//i控制循环次数，循环i次并且a[i]要大于key
                a[i + 1] = a[i];//
                i = i - 1;
                a[i + 1] = key;//符合条件换一次
            }
            //a[i + 1] = key;//不好理解。。。
        }
    }

选择排序

public class SelectSort extends baseSort {//选择排序

    @Override
    public void sort(int[] a) {
        int min = 0;//最小值的下标
        int temp;
        for (int i = 0; i < a.length; i++) {
            min = i;
            for (int j = i + 1; j < a.length; j++) {
                if (a[j] < a[min]) {//在后面的集合中寻找最小的下标
                    min = j;//小的下标赋给min
                }
            }
            if (min != i) {//最小值的下标和i不一样的时候，交换
                temp = a[i];
                a[i] = a[min];
                a[min] = temp;
            }
        }
    }
}

Factory

public class Factory {
    private baseSort Sort;//依赖注入
    public void setSort(baseSort Sort){//建立任意三种排序
        this.Sort=Sort;
    }
    public void doSort(int[] a){
        Sort.sort(a);
    }
}

Test

public class Test {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("输入10个数字");
        int[] a=new int[10];
        for (int i=0;i<10;i++){
            a[i]=scanner.nextInt();
        }

//        int[] a = new int[]{5, 8, 6, 7, 4, 3, 16, 2, 9, 12,};

        Factory factory = new Factory();
        baseSort quick_sort = new QuickSort();//向上转型
        factory.setSort(quick_sort);
        factory.doSort(a);

        for (int i = 0; i < 10; i++) {
            System.out.print(a[i] + " ");
        }
    }
}

[xieyipeng]

有了接口为什么还要有抽象类

• 抽象类：
  抽象类中可以有抽象方法，抽象方法，可以只定义方法，不用写方法的实现。普通类继承抽象类必须要实现抽象类的方法，抽象类继承抽象类可以实现抽象方法也可以不实现。
• 接口：
  只定义方法，不写方法的实现。一个接口可以继承另一个接口，一个类可以实现一个或多个接口。
• 有了接口为什么还要有抽象类？
  java中，只能实现单继承，但可以实现多个接口。假定现在有3个类，A1，A2，A3，都实现接口B，同时他们三个都想要实现接口的某个方法，而接口中不能定义方法实体，就必须在他们三个内部重复写三遍相同的代码。这种做法明显不符合代码重用的规则。因此可以重新写一个抽象类C，在抽象类内实现该方法，再令他们三个实现接口同时继承C。因此，并不能没有抽象类。

命令模式

• 司令员下令让士兵去干件事情，司令员的作用是，发出命令，命令经过传递，传到士兵，士兵去执行。三者相互解耦，任何一方不用依赖另一方，只要做好自己的事情就行。

• command

package day2;

public interface Command {
    public void exe();
}

• Invoker

package day2;

/**
 * 长官
 */
public class Invoker {
    private Command command;

    public Invoker(Command command) {
        this.command = command;
    }

    public void action(){
        command.exe();
    }
}

• Receiver

package day2;

/**
 * 士兵
 */
public class Receiver {

    public void action(){
        System.out.println("command received!");
    }

}

• MyCommand

package day2;

/**
 * 命令
 */
public class MyCommand implements Command{

    private Receiver receiver;

    public MyCommand(Receiver receiver) {
        this.receiver = receiver;
    }

    @Override
    public void exe() {
        receiver.action();
    }
}

• Test

package day2;

public class test {
    public static void main(String[] args) {
        Receiver receiver=new Receiver();
        Command command=new MyCommand(receiver);
        Invoker invoker=new Invoker(command);
        invoker.action();
    }
}

[xieyipeng]

Stream学习(可以把Stream当成高版本的Iterator)

剖析Stream通用语发

• start
  
  一条语句被分割成三部分，红色框是Stream生命开始的地方，创建Stream实例，绿色框赋予Stream灵魂，把一个Stream转换成另一个Stream。红框语句是包含所有变量的Stream，进入绿色框以后，过滤掉不符合条件的元素，并生成一个新的Stream。蓝色框把Stream的里面包含的内容按照某种算法来汇聚成一个值，例子中是获取Stream中包含的元素个数。
• 使用Stream的基本步骤：

1、创建Stream；

2、转换Stream，每次转换原有Stream对象不改变，返回一个新的Stream对象

3、对Stream进行聚合（Reduce）操作，获取想要的结果；

创建Stream

• of方法

Stream<IntegerStream> IntegerStream=Stream.of(1,2,3,4,5);
Stream<String> stringStream = Stream.of("taobao");

• generator方法

Stream.generate(new Supplier<Double>(){
  @Override
  public Double get(){
    return Math.random();
  }
});
Stream.generate(()->Math.random);
Stream.generate(Math::random);

三条语句效果一样，生成无限长的Stream，使用了lambda表达式和方法引用来简化代码。

• iterate方法

Stream.iterate(1,item->item+1).limit(10).forEach;
(System.out.println);

这段代码就是先获取一个无限长度的正整数集合的Stream，然后取出前10个打印

• Collection子类获取Stream

public interface Collection<E> extends Iterable<E> {
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }
}

转换Stream

转换Stream其实就是把一个Stream通过某些行为转换成一个新的Stream。

• distinct-对Stream中的元素进行去重操作。
• filter- 对于Stream中包含的元素使用给定的过滤函数进行过滤操作。
• map- 对于Stream中包含的元素使用给定的转换函数进行转换操作
• flatMap-和map类似，不同的是其每个元素转换得到的是Stream对象，会把子Stream中的元素压缩到父集合中
• peek-生成一个包含原Stream的所有元素的新Stream，同时会提供一个消费函数（Consumer实例），新Stream每个元素被消费的时候都会执行给定的消费函数
• limit-对一个Stream进行截断操作，获取其前N个元素，如果原Stream中包含的元素个数小于N，那就获取其所有的元素
• skip-返回一个丢弃原Stream的前N个元素后剩下元素组成的新Stream，如果原Stream中包含的元素个数小于N，那么返回空Stream
• 上面的方法结合到一起：

List<Integer>nums=Lists.newArrayList(1,1,null,2,3,4,null,5,6,7,8,9,10);
System.out.println(“sum is:”+nums.stream()
.filter(num -> num != null)
.distinct().mapToInt(num -> num * 2)
.peek(System.out::println)
.skip(2)
.limit(4)
.sum());

• 性能问题
  在对于一个Stream进行多次转换操作，每次都对Stream的每个元素进行转换，而且是执行多次，这样时间复杂度就是一个for循环里把所有操作都做掉的N（转换的次数）倍啊。其实不是这样，转换操作都是lazy的，多个转换操作只会在汇聚操作的时候融合起来，一次循环完成。Stream里有个操作函数的集合，每次转换操作就是把转换函数放入这个集合中，在汇聚操作的时候循环Stream对应的集合，然后对每个元素执行所有的函数。

汇聚（Reduce）Stream

先对java doc中的定义进行翻译:

汇聚操作（也称为折叠）接受一个元素序列为输入，反复使用某个合并操作，把序列中的元素合并成一个汇总的结果。比如查找一个数字列表的总和或者最大值，或者把这些数字累积成一个List对象。Stream接口有一些通用的汇聚操作，比如reduce()和collect()；也有一些特定用途的汇聚操作，比如sum(),max()和count()。注意：sum方法不是所有的Stream对象都有的，只有IntStream、LongStream和DoubleStream是实例才有。

1、可变汇聚

可变汇聚对应的方法只有一个：collect，它可以把Stream中的要有元素收集到一个结果容器collection中。

List<Integer>nums=Lists.newArrayList(1,1,null,2,3,4,null,5,6,7,8,9,10);
List<Integer> numsWithoutNull = nums.stream()
.filter(num -> num != null)
.collect(() -> new ArrayList<Integer>(),
(list, item) -> list.add(item),
(list1, list2) -> list1.addAll(list2));

• 第一个函数生成一个新的ArrayList实例；
• 第二个函数接受两个参数，第一个是前面生成的ArrayList对象，二个是stream中包含的元素，函数体就是把stream中的元素加入ArrayList对象中。第二个函数被反复调用直到原stream的元素被消费完毕；
• 第三个函数也是接受两个参数，这两个都是ArrayList类型的，函数体就是把第二个ArrayList全部加入到第一个中；

2、其他汇聚

List<Integer> ints = Lists.newArrayList(1,2,3,4,5,6,7,8,9,10);
System.out.println("ints sum is:" + ints.stream().reduce((sum, item) -&gt; sum + item).get());

遍历集合的操作，（list，map），eg:fori，foreach，stream，iterator；

• list

package day3;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * 遍历集合的操作，（list，map），eg:fori，foreach，stream，iterator；
 */
public class ListTest {
    public static void main(String[] args) {
        List<Student>stringList=new ArrayList<>();
        stringList.add(new Student(16,"a"));
        stringList.add(new Student(15,"b"));
        stringList.add(new Student(18,"c"));
        stringList.add(new Student(11,"d"));
        stringList.add(new Student(16,"e"));
        stringList.add(new Student(19,"f"));
        stringList.add(new Student(12,"j"));
        stringList.add(new Student(14,"h"));
        stringList.add(new Student(17,"i"));
        stringList.add(new Student(16,"j"));

        System.out.println("fori :");
        for (int i = 0; i < stringList.size(); i++) {
            System.out.print(stringList.get(i).getName()+" ");
            System.out.println(stringList.get(i).getAge());
        }

        System.out.println("foreach :");
        for (Student student:
             stringList) {
            System.out.print(student.getName()+" ");
            System.out.println(student.getAge());
        }

        System.out.println("stream :");
        stringList.stream()
                .forEach(student -> System.out.println(student.getName()+" "+student.getAge()));

        System.out.println("iterator :");
        Iterator iterator=stringList.iterator();
        while (iterator.hasNext()){
            Student student=(Student)iterator.next();
            System.out.println(student.getName()+" "+student.getAge());
        }
    }
}

//运行结果
fori :
a 16
b 15
c 18
d 11
e 16
f 19
j 12
h 14
i 17
j 16
foreach :
a 16
b 15
c 18
d 11
e 16
f 19
j 12
h 14
i 17
j 16
stream :
a 16
b 15
c 18
d 11
e 16
f 19
j 12
h 14
i 17
j 16
iterator :
a 16
b 15
c 18
d 11
e 16
f 19
j 12
h 14
i 17
j 16

• map

package day3;

import java.util.*;
public class MapTest {
    public static void main(String[] args) {
        Map<Integer,Student>map=new HashMap<>();
        map.put(1,new Student(12,"a"));
        map.put(2,new Student(18,"b"));
        map.put(3,new Student(14,"c"));
        map.put(4,new Student(16,"d"));
        map.put(5,new Student(13,"e"));
        map.put(6,new Student(11,"f"));
        map.put(7,new Student(12,"j"));
        map.put(8,new Student(15,"h"));
        map.put(9,new Student(14,"i"));
        map.put(10,new Student(18,"g"));

        System.out.println("fori :");
        for (Map.Entry<Integer,Student> entry:map.entrySet()) {
            System.out.print(entry.getKey() + " = ");
            System.out.println(entry.getValue().getAge() + " " + entry.getValue().getName());
        }
//        for (int i = 0; i < map.size(); i++) {
//            System.out.println(map.get(i).getAge());
//        }
        System.out.println("foreach :");
        for (Map.Entry<Integer,Student> entry:
             map.entrySet()) {
            System.out.print(entry.getKey() + " = ");
            System.out.println(entry.getValue().getAge() + " " + entry.getValue().getName());
        }

        System.out.println("iterator :");
        Iterator iterator=map.values().iterator();
        while (iterator.hasNext()){
            //System.out.println(iterator.next());
            Student student=(Student)iterator.next();
            System.out.println(student.getName()+" "+student.getAge());
        }
    }
}

//运行结果
fori :
1 = 12 a
2 = 18 b
3 = 14 c
4 = 16 d
5 = 13 e
6 = 11 f
7 = 12 j
8 = 15 h
9 = 14 i
10 = 18 g
foreach :
1 = 12 a
2 = 18 b
3 = 14 c
4 = 16 d
5 = 13 e
6 = 11 f
7 = 12 j
8 = 15 h
9 = 14 i
10 = 18 g
iterator :
a 12
b 18
c 14
d 16
e 13
f 11
j 12
h 15
i 14
g 18

• student

package day3;

/**
 * 姓名，学号
 * construct,set,get
 */
public class Student {
    private int age;
    private String name;

    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public Student(String name) {
        this.name = name;
    }

    public Student(int age) {
        this.age = age;
    }

    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;
    }
}