#千锋逆战班，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 blocke.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();//获得方法的对象MethodMethod 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 blocke.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);

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

#千锋逆战班，ssf# 在千锋“逆战”学习第 19天，每个人生阶段都需要努力去扮好自己的角色，越努力越轻松，越坚强越幸运！加油
package com.qf.day19.t1.callback; public class TestStudentSort { public static void main(String[] ar ...
#千锋逆战班，ssf# 在千锋“逆战”学习第 30天，每个人生阶段都需要努力去扮好自己的角色，越努力越轻松，越坚强越幸运！加油！本周心得及总结
Thread和Runnable两种实现方式. 这两种方法都是最基础的实现线程的方法,声明线程对象后,通过调用对象的start()方法,来执行线程内部的run()方法. 其中Runnable是由Thre ...
#千锋逆战班，ssf# 在千锋“逆战”学习第 31天，每个人生阶段都需要努力去扮好自己的角色，越努力越轻松，越坚强越幸运！加油！
第三题对于 FileInputStream 来说,从方向上来分,它是输入流,从数据单位上分,它是字节流,从功能上分,它是对象流. 第四题 I.无参的read方法返回值为int类型,表示从输入流中读 ...
#千锋逆战班，ssf# 在千锋“逆战”学习第 33天，每个人生阶段都需要努力去扮好自己的角色，越努力越轻松，越坚强越幸运！加油
网络编程第一题 TCP和UDP都是传输层协议,TCP是(有连接)的协议,UDP是(无连接)的协议.这两种协议中(TCP)协议更安全,而(UDP)协议传输效率更高第二题:AE 第三题:AC 第四题 ...
#千锋逆战班，ssf# 在千锋“逆战”学习第 27天，每个人生阶段都需要努力去扮好自己的角色，越努力越轻松，越坚强越幸运！加油
package com.qf.day27.quesyion112; public class TestException1 { public static void main(String[] arg ...
#千锋逆战班，ssf# 在千锋“逆战”学习第 26天，每个人生阶段都需要努力去扮好自己的角色，越努力越轻松，越坚强越幸运！加油
Question11 第一题 Java中所有的错误都继承自(Throwable)类:在该类的子类中, (Error)类表示严重的底层错误,对于这类错误一般处理的方式是 (不处理): (Exceptio ...
#千锋逆战班，ssf# 在千锋“逆战”学习第 23天，每个人生阶段都需要努力去扮好自己的角色，越努力越轻松，越坚强越幸运！加油
package com.qf.day23.t2.question10; import java.util.ArrayList; import java.util.Iterator; public cl ...
#千锋逆战班，ssf# 在千锋“逆战”学习第 18天，每个人生阶段都需要努力去扮好自己的角色，越努力越轻松，越坚强越幸运！加油
第三题: (1) void md().void ma().void mb().void mc() (2) (IA) ic.ma(); (IB) ic.mb(); ic.mc(); (ID) id.md ...
#千锋逆战班，ssf# 在千锋“逆战”学习第 29天，每个人生阶段都需要努力去扮好自己的角色，越努力越轻松，越坚强越幸运！加油
Question12. 第八题:C 第九题 Thread(this).sleep((int)(Math.random()*1000)); Thread t3 = new Thread(); t3.st ...

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

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

最新文章

热门文章

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

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

最新文章

热门文章

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

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