1614011121 申逸凡

[ZBDXShenYifan]

package homework1;

public class BaseSort 
{
     public void sort(double [] list)
     {
    	 System.out.println("排序算法");
     }

}

public class BubbleSort extends BaseSort
{
	public void sort(double[] list)
	{
	   super.sort(list);
	   System.out.println("冒泡算法的结果");
		boolean needNextPass = true;
		//设置一个布尔变量，如果在某次遍历中没有发生交换，说明所有的元素都排好了顺序，不需要再进行交换
		for(int k = 1; k < list.length && needNextPass; k++)
		{
			//需要进行length - 1次遍历
			needNextPass = true;
			for(int i = 0; i < list.length - k; i++)
			{//第k次遍历不需要考虑最后共k-1个元素
				if(list[i] > list[i + 1])
				{
					double temp = list[i];
					list[i] = list[i+1];
					list[i+1] = temp;
					needNextPass = true;
					//进行了交换，说明还没有都排好序，需要进行下一次遍历
				}
			}
		}
	}

}

public class InsertionSort extends BaseSort
{
	public void sort(double[] list)
	{
		super.sort(list);
		System.out.println("插入算法的结果");
		for(int i = 1; i < list.length; i++)
		{
			//把list[i] 插入到 0 ~ i-1;   
			double currentElement = list[i];
			int k;
			for(k = i - 1; k >=0 && list[k] > currentElement; k--)
			{
				list[k+1] = list[k];
			}
			
			list[k + 1] = currentElement;
		}
			
	}

}

public class QuickSort extends BaseSort
{
	//对数组进行排序
	public void sort(double[] list)
	{
		super.sort(list);
		System.out.println("快速算法的结果");
		quickSort(list, 0, list.length-1);
			
	}
	
	//对特定的子数组进行排序
	private void quickSort(double[] list, int first, int last)
	{
		if(last > first)
		{
			int pivotIndex = partition(list, first, last);
			quickSort(list, first, pivotIndex - 1);
			quickSort(list, pivotIndex + 1, last);
			
		}
	}
	
	//找到主元，并合理放置主元，返回放置好的主元的索引
	private int partition(double[] list, int first, int last)
	{
		double pivot = list[first];
		int low = first + 1;  //从前找值低的索引
		int high = last; //从后找值高的索引
		
		while(high > low)
		{
			while(low <= high && list[low] <= pivot)
				low++;
			
			while(low <= high && list[high] > pivot)
				high--;
			
			if(high > low)
			{
				double temp = list[high];
				list[high] = list[low];
				list[low] = temp;
				
			}
		}
		
		while(high > first && list[high] >= pivot)
			high--;
		
		if(pivot > list[high])
		{
			list[first] = list[high];
			list[high] = pivot;
			return high;
		}
		else
		{
			return first;
		}
	}
	

}

public class SelectionSort extends BaseSort
{
	public void sort(double[] list)
	{
		super.sort(list);
		System.out.println("选择算法的结果");
	   for(int i = 0; i < list.length - 1; i++)
	   {
		   //找到数列从i到  length - 1 的最小值
		   double currentMin = list[i];
		   int currentMinIndex = i;
		   
		   for(int j = i + 1; j < list.length; j++)
			   if(currentMin > list[j])
			   {
				   currentMin = list[j];
				   currentMinIndex = j;
			   }
	       //找到最小值及其索引
	   
		//将最小值与第i个位置的值互换，实现排序   
	   if(currentMinIndex != i)
	   {
		   list[currentMinIndex] = list[i];
		   list[i] = currentMin;
	   }
	}
	}
}

public class Factory 
{
	private BaseSort sort;
	public void setSort(BaseSort sort)
	{
		this.sort = sort;
	}
	
	public void doSort(double[] a)
	{
		sort.sort(a);
	}

}

import java.util.*;
public class Test {

	public static void main(String[] args) 
	{
		// TODO Auto-generated method stub
		Scanner keyboard = new Scanner(System.in);
		double[] list = new double[10];
		System.out.println("请输入10个数字");
		for(int i = 0; i < list.length; i++)
		{
			list[i] = keyboard.nextDouble();
		}

		Factory factory = new Factory();
		BaseSort select_sort = new SelectionSort();
		factory.setSort(select_sort);
		factory.doSort(list);
		for(double element : list)
		{
			System.out.print(element + " ");
		}
		System.out.println();
		

		BaseSort bubbleSort = new BubbleSort();
		factory.setSort(bubbleSort);
		factory.doSort(list);
		for(double element : list)
		{
			System.out.print(element + " ");
		}
		System.out.println();
		

		BaseSort insertionSort = new InsertionSort();
		factory.setSort(insertionSort);
		factory.doSort(list);
		for(double element : list)
		{
			System.out.print(element + " ");
		}
		System.out.println();

		BaseSort quickSort = new QuickSort();
		factory.setSort(quickSort );
		factory.doSort(list);
		for(double element : list)
		{
			System.out.print(element + " ");
		}
		System.out.println();
		
	}

}

```java

[ZBDXShenYifan]

第二次作业

熟悉一种设计模式（建造者模式）

     工厂类提供的是建造单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来建造复合对象，建造者模式将很多功能集成到一个类里，这个类可以创造出比较复杂的东西。
     在本例中，Builder具有插入排序，冒泡排序，快速排序和选择排序的功能。

     与工厂模式的区分：
    工厂模式关注的是建造单个产品，建造者模式则是关注与创建多功能的复合对象。

import java.util.*;

public class Builder 
{
	private BaseSort sort;
	
	public void readInput(double[] a)
	{
		System.out.println("请输入" + a.length + "个数字");
		Scanner input = new Scanner(System.in);
		for(int i = 0; i < a.length; i++)
		{
			a[i] = input.nextDouble();
		}
		
	}
	
	public void writeOutput(double[] a)
	{
		for(int i = 0; i < a.length; i++)
		{
			System.out.print(a[i] + " ");
		}
		
		System.out.println();
	}
	public void produceBubbleSort(double[] a)
	{
		this.sort = new BubbleSort();
		this.doSort(a);
		
	}
	
	public void produceInsertionSort(double[] a)
	{
		this.sort = new InsertionSort();
		this.doSort(a);
	}
	
	public void produceQuickSort(double[] a)
	{
		this.sort = new QuickSort();
		this.doSort(a);
	}
	
	public void produceSelectionSort(double[] a)
	{
		this.sort = new SelectionSort();
		this.doSort(a);
		
	}
	
	public void doSort(double[] a)
	{
		this.readInput(a);
		sort.sort(a);
		this.writeOutput(a);
		
	}
	

}

import java.util.Scanner;

public class TestBuilder 
{
	

	public static void main(String[] args) 
	{
		// TODO Auto-generated method stub
		Builder build = new Builder();
		double[] a1 = new double[10];
		double[] a2 = new double[10];
		double[] a3 = new double[10];
		double[] a4 = new double[10];
		
		build.produceBubbleSort(a1);
		build.produceInsertionSort(a2);
		build.produceQuickSort(a3);
		build.produceSelectionSort(a4);

	}

}

运行结果：

请输入10个数字
1 2 3 6 5 4 9 8 7 0
排序算法
冒泡算法的结果
0.0 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
请输入10个数字
9 8 7 6 5 4 3 2 1 0
排序算法
插入算法的结果
0.0 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
请输入10个数字

9 8 7 3 2 1 4 5 6 0
排序算法
快速算法的结果
0.0 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0
请输入10个数字
7 5 3 4 6 8 3 1 0 2
排序算法
选择算法的结果
0.0 1.0 2.0 3.0 3.0 4.0 5.0 6.0 7.0 8.0

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

接口的default methods只能是public ，抽象类的abstract method可以是protected.

Java 8的接口上的default method最初的设计目的是让已经存在的接口可以演化——添加新方法
而不需要实现该接口的类做任何改变（甚至不需要重新编译），Java 8的接口暂时还无法完全替代抽象类，它不能拥有状态，只能提供公有方法的默认实现。

[ZBDXShenYifan]

第三次作业（）

一、 对Map的四种遍历

1.第一种遍历：利用Map.KeySet + foreach遍历value
2.第二种遍历：通过Map.entrySet使用iterator遍历Key和value
3.第三种遍历： 通过Map.entrySet + foreach循环
4.第四种遍历：通过Map.value() + foreach来遍历所有的value

package homework3;
import java.util.*;


public class TestMapIterator 
{

	public static void main(String[] args) 
	{
		// TODO Auto-generated method stub
		Map<String, String> studentInformation = new HashMap<>();
		studentInformation.put("1614011101", "小张");
		studentInformation.put("1614011102", "小赵");
		studentInformation.put("1614011103", "小可");
		studentInformation.put("1614011104", "小红");
		studentInformation.put("1614011105", "小军");
		studentInformation.put("1614011106", "小李");
		studentInformation.put("1614011107", "小刘");
		studentInformation.put("1614011108", "小王");
		
		
		System.out.println("第一种遍历：利用Map.KeySet遍历value");
		//KeySet返回所有Key的值
		for(String learningNumber: studentInformation.keySet())
		    System.out.println("value = " + studentInformation.get(learningNumber));
		
		
		System.out.println();
		System.out.println("第二种遍历：通过Map.entrySet使用iterator遍历Key和value");
		Iterator<Map.Entry<String, String>> iterator = studentInformation.entrySet().iterator();
		//.entrySet()返回的是键值对的一个集合
		//建议一个迭代器对象，它迭代的元素Map中的键值对
		while(iterator.hasNext())
		{
			Map.Entry<String, String> entry = iterator.next();
			System.out.println("key = " + entry.getKey() + " value = " + entry.getValue());
		}
		System.out.println();
		
		System.out.println("第三种遍历： 通过Map.entrySet + foreach循环");
		for(Map.Entry<String, String> entry : studentInformation.entrySet())
			System.out.println("key = " + entry.getKey() + " value = " + entry.getValue());
		
		System.out.println();
		
		System.out.println("通过Map.value()来遍历所有的value，但不能遍历key");
		   for(String aValue : studentInformation.values())
			   System.out.println("value = " + aValue);
			
		

	}

}

运行结果

第一种遍历：利用Map.KeySet遍历value
value = 小红
value = 小可
value = 小李
value = 小军
value = 小赵
value = 小张
value = 小王
value = 小刘

第二种遍历：通过Map.entrySet使用iterator遍历Key和value
key = 1614011104 value = 小红
key = 1614011103 value = 小可
key = 1614011106 value = 小李
key = 1614011105 value = 小军
key = 1614011102 value = 小赵
key = 1614011101 value = 小张
key = 1614011108 value = 小王
key = 1614011107 value = 小刘

第三种遍历： 通过Map.entrySet + foreach循环
key = 1614011104 value = 小红
key = 1614011103 value = 小可
key = 1614011106 value = 小李
key = 1614011105 value = 小军
key = 1614011102 value = 小赵
key = 1614011101 value = 小张
key = 1614011108 value = 小王
key = 1614011107 value = 小刘

通过Map.value()来遍历所有的value，但不能遍历key
value = 小红
value = 小可
value = 小李
value = 小军
value = 小赵
value = 小张
value = 小王
value = 小刘

二、对Stream的入门级学习

• 包含入门级创建，遍历，删除重复元素，过滤，排序，对元素进行统一操作，合并集合
• Stream不会存储数据
• Stream不会修改源数据
• Stream是单向的，不会重复使用

import java.util.*;
import java.util.stream.Stream;
public class TestStream 
{
	/**
	 * 原始版本的Iterator,用户只能一个一个的遍历元素并对他执行某些操作，而Stream，用户只需要
	 * 给出对其包含的元素执行什么操作
	 */
	
	public static void main(String[] args)
	{
		System.out.println("利用stream的建造集合与遍历");
		Stream<Integer> integerStream = Stream.of(1,3,3,4,5,6,6,8,9);
		//forEach()
		integerStream.forEach(number -> System.out.print(number + " "));
		System.out.println();
		//filter()
		System.out.println("stream中过滤出大于等于5的元素");
		Stream<Integer> integerStream2 = Stream.of(1,3,3,4,5,6,6,8,9);
		integerStream2.filter(number -> number >= 5)
		   .forEach(number -> System.out.print(number + " "));
		System.out.println();
		
		//distinct()
		System.out.println("删除重复的元素");
		Stream<Integer> integerStream3 = Stream.of(1,3,3,4,5,6,6,8,9);
		integerStream3.distinct()
		  .forEach(number -> System.out.print(number + " "));
				System.out.println();
		
		//sorted()
				System.out.println("进行降序排序");
		Stream<Integer> integerStream4 = Stream.of(1,3,3,4,5,6,6,8,9);
		integerStream4.sorted((num1, num2) -> num2 - num1)
		.forEach(number -> System.out.print(number + " "));
		System.out.println();
		
		//map()
		System.out.println("对所有元素进行+1的操作");
		Stream<Integer> integerStream5 = Stream.of(1,3,3,4,5,6,6,8,9);
		integerStream5.map(number-> number + 1)
		.forEach(number -> System.out.print(number + " "));
		System.out.println();
		
	//	flatMap()
		System.out.println("将两个集合合并");
		ArrayList<Integer> list1 = new ArrayList<>();
		list1.add(1);
		list1.add(2);
		list1.add(3);
		ArrayList<Integer> list2 = new ArrayList<>();
		list2.add(4);
		list2.add(5);
		list2.add(6);
		Stream<ArrayList<Integer>> stream = Stream.of(list1,list2);
		stream.flatMap(list -> list.stream())
		.forEach(number -> System.out.print(number + " "));
		System.out.println();
	}

}

运行结果

利用stream的建造集合与遍历
1 3 3 4 5 6 6 8 9
stream中过滤出大于等于5的元素
5 6 6 8 9
删除重复的元素
1 3 4 5 6 8 9
进行降序排序
9 8 6 6 5 4 3 3 1
对所有元素进行+1的操作
2 4 4 5 6 7 7 9 10
将两个集合合并
1 2 3 4 5 6