#千锋逆战班，ssf# 在千锋“逆战”学习第 35天， 每个人生阶段都需要努力去扮好自己的角色，越努力越轻松，越坚强越幸运！ 加油！

本周主要学习了I/O框架、网络编程、反射以及JDK1.8部分内容（Lambda表达式）。

I/O框架主要讲的是“流“：
什么是流呢？就是内存与存储设备之间传输数据的通道。
按方向分为：
输入流（将存储设备中的内容读入到内存中）
输出流（将内存中的内容写入到存储设备中）

按单位：
字节流：以字节为单位，可以读写所有的数据
字符流：以字符为单位，只能读写文本数据

按功能：
节点流：具有实际传输数据的读写功能
过滤流：在节点流的基础上增强功能

反射
类对象：类加载的产物、封装了一个类的所有信息(类名、父类、接口、属性、方法、构造方法)、一类.class文件就代表着一个类对象

package com.qf.day35.t1.reflects;

import java.lang.reflect.Method;

public class TestInvokeMethod {

public static void main(String[] args) throws Exception {
	//反射  类的对象
	Object o = createObject("com.qf.day35.t1.reflects.Student");
	//类对象
	Class c = o.getClass();
	//name-->方法名，parameterTypes-->参数列表类型
	Method m = c.getMethod("study", null);
	//通过invoke方法，执行某个实例方法，参数：Object --> 所需对象，arg --》调用的方法所需的实参
	m.invoke(o, 23);
	//-----------------
	Method m2 =c.getMethod("study", int.class);
	m2.invoke(o, 123);

// System.out.println(retult);
System.out.println(c.getMethod(“study”, int.class).invoke(o, 23));
//------------------------
Method m3 = c.getMethod(“exam”, int.class,double.class,String.class);
m3.invoke(o, 2,98,“张三”);
//----------------------------------
// Method m4 = c.getMethod(“calc”, null);//error 无法获得私有方法
Method m4 = c.getDeclaredMethod(“calc”, null);//获得自身方法，包含私有

	//注意：反射是一种Java底层技术，可以取消语言检查。  突破封装
	m4.setAccessible(true);
	
	m4.invoke(o,null);

}
public static Object createObject(String className) {
	try {
		Class c = Class.forName(className);
		return c.newInstance();
	} catch (Exception e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	return null;
}

}
class Student{
String name;
Integer age;
Double score;
public Student() {
}
public Student(String name, Integer age, Double score) {
super();
this.name = name;
this.age = age;
this.score = score;
}
public void study() {
System.out.println(“正在学习。。。。”);

}
public int study(int a) {
	System.out.println("学习"+a+"个小时");
	return 0;
}
public void exam(int a , double b , String s ) {
	System.out.println(s+"考试"+a+"个小时，考了"+b+"分");
	
}
private void calc() {
	System.out.println("计算。。。。");
}

}

通用编程案例
package com.qf.day35.t1.reflects;

import java.lang.reflect.Method;

public class TestInvokeAnything {

public static void main(String[] args) {
	//invokeAny() --> 执行方法
	
	Object o = createObject("com.qf.day35.t1.reflects.Student");
	

}
//通用编程（调用任何一个方法）
//（Object）对象、（String）方法名称，形参（Class），实参（Object）
public static void invokeAny(Object obj,String methodName,Class[] type,Object... args) throws Exception {
	//使用反射技术执行任何方法
	//类对象
	Class c = obj.getClass();
	//获得方法的对象Method
	Method m = c.getDeclaredMethod(methodName, type);
	
	//执行方法
	m.invoke(obj, args);
	
	
}
public static Object createObject(String className) {
	try {
		Class c = Class.forName(className);
		return c.newInstance();
	} catch (Exception e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	return null;
}

}
单例模式
package com.qf.day35.t2.singletons;

public class TestSingleton {

public static void main(String[] args) {
	Singleton s1 = Singleton.getInstance();
	Singleton s2 = Singleton.getInstance();
	Singleton s3 = Singleton.getInstance();
	System.out.println(s1	);
	System.out.println(s2	);
	System.out.println(s3	);

}

}
//懒汉式：使用时创建、天生线程安全
class Singleton{

private Singleton() {}

private static class Holder{
	
	static final Singleton instance = new Singleton();
}
public static Singleton getInstance() {
	return Holder.instance;
}

}

//懒汉式：使用时创建、天生线程不安全（加同步锁）；效率低
//class Singleton{

// private static Singleton instance = null;

// private Singleton() {}

// public synchronized static Singleton getInstance() {
// if (instance ==null) {
// instance = new Singleton();
// }
// return instance;
// }
//
//}

//饿汉式：天生线程安全（无锁）、类加载时创建（不用的时候，也被迫创建了，占用资源）
//class Singleton{
// private static final Singleton instance = new Singleton();
// private Singleton() {}
// public static Singleton getInstance() {
// return instance;
// }
//
//}

网络编程：由点和线构成的，标识诸多对象间的相互联系









lambda表达式
新的操作符 -> (箭头操作符)
（参数1，参数2）-> 表示参数列表
->{ }方法体
package com.qf.day35.t3.lambdas;

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

public class TestEmployee {
public static void main(String[] args) {
List list = new ArrayList();
list.add(new Employee(“高强”,18,1500));
list.add(new Employee(“高蓝轩”,20,3500));
list.add(new Employee(“高Java”,22,30000));
list.add(new Employee(“高BigData”,25,45000));
list.add(new Employee(“高Physon”,39,150000));

	//获得年龄大于等于25 的员工

// List ageList = getAgeEmployee(list);
// for(Employee e:ageList) {
// System.out.println(e);
// }
// System.out.println("--------------------");
// //获得工资大于10000的员工
// List saList = getSalaryEmployee(list);
// for(Employee e:saList) {
// System.out.println(e);
// }
System.out.println("-------lambda 工资大于等于10000的，并且年龄大于等于25的--------------------");
//获得工资大于等于10000的，并且年龄大于等于25的
// List preList = getAgeAndSalary(list,(e) ->{return e.getAge()>=25 && e.getSalary()>=10000;});

	List<Employee> preList = getAgeAndSalary(list,(e) ->e.getAge()>=25 && e.getSalary()>=10000);
	for (Employee employee : preList) {
		System.out.println(employee);
	}
	System.out.println("-----lambda 年龄大于等于25-----------------");
	
	List<Employee> preList2 = getAgeAndSalary(list, e->e.getAge()>=25);
	for (Employee employee : preList2) {
		System.out.println(employee);
	}
		System.out.println("-----lambda 工资大于等于10000-----------------");
	
	List<Employee> preList3 = getAgeAndSalary(list, e->e.getSalary()>=10000);
	for (Employee employee : preList3) {
		System.out.println(employee);
	}
	
	System.out.println("-------------stream相关的----------------------");
	
	list.stream().filter((e)->e.getSalary()>=10000).forEach(System.out::println);
}

public static List<Employee> getAgeAndSalary(List<Employee> list,MyPredicate<Employee> predicate){
	List<Employee> newlist = new ArrayList<>();
	for(Employee e: list) {
		if(predicate.test(e)) {//调用规则！只关心结果，不关心过程
			newlist.add(e);
		}
	}
	return newlist;
}



public static List<Employee> getAgeEmployee(List<Employee> list){
	List<Employee> newlist = new ArrayList<>();
	
	for(Employee e:list) {
		if(e.getAge() >=25) {
			newlist.add(e);
		}
	}
	return newlist;
}
public static List<Employee> getSalaryEmployee(List<Employee> list){
	List<Employee> newlist = new ArrayList<>();
	
	for(Employee e:list) {
		if(e.getSalary() >=10000) {
			newlist.add(e);
		}
	}
	return newlist;
}

}

方法引用
//Lambda表达式简化了匿名内部类.方法引用简化了Lambda表达式
//1.对象::方法名
Consumer con = (s)->System.out.println(s);//lambda
con.accept(“hello”);
Consumer con2 =System.out::println;//方法引用
con2.accept(“嘿嘿嘿”);

	Employee e = new Employee("高强",18,2000);

// Supplier sup = ()->e.getName();
Supplier sup = e::getName;//与上同理
System.out.println(sup.get());

	//2.类名::静态方法 (不常用)

// Comparator com = (x,y)->Integer.compare(x,y); lambda
Comparator com = Integer::compare;//方法引用
// int result = com.compare(1, 2);
// System.out.println(result);
TreeSet ts = new TreeSet<>(com);

	//3.类名：：实例方法名
	//Function<T,R>     R apply(T t);

// Function<Employee,String> fun = emp->emp.getName();//lambda
Function<Employee,String> fun = Employee::getName;//方法引用
String name = fun.apply(e);
System.out.println(name);

	//4. 类名::new    类名::构造方法

// Supplier supp = ()->new Employee();//lambda
Supplier supp =Employee::new;//方法引用
Employee emps = supp.get();
System.out.println(emps);