【内部类&匿名内部类&反射&Lambda&Stream流的使用】
一、内部类和匿名内部类
匿名内内部类和lambda表达式主要的区别在于
1、匿名内部类他必须实现继承类的所有方法
2、匿名内部类在重写时有override标识，而lambda没有
3、lambda表达式继承的接口只能有一个抽象方法
在使用匿名内部类的过程中，我们需要注意如下几点：
- 1、使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。
- 2、匿名内部类中是不能定义构造函数的。
- 3、匿名内部类中不能存在任何的静态成员变量和静态方法。
- 4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。
- 5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。
匿名内部类：在类的内部定义了一个新的类
内部类的分类：
静态内部类
实例内部类
局部内部类
实际上使用内部类编写代码，可读性太差
public interface Skill {
void use(); // 释放技能的抽象方法
}
public class SkillImpl implements Skill {
@Override
public void use() {
System.out.println("Biu~biu~biu~");
}
}
public class Hero {
private String name; // 英雄的名称
private Skill skill; // 英雄的技能
public Hero() {
}
public Hero(String name, Skill skill) {
this.name = name;
this.skill = skill;
}
public void attack() {
System.out.println("我叫" + name + "，开始施放技能：");
skill.use(); // 调用接口中的抽象方法
System.out.println("施放技能完成。");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Skill getSkill() {
return skill;
}
public void setSkill(Skill skill) {
this.skill = skill;
}
}
使用匿名对象或者匿名内部类来实现调用
public class DemoGame {
public static void main(String[] args) {
Hero hero = new Hero();
hero.setName("艾希"); // 设置英雄的名称
// 设置英雄技能
hero.setSkill(new SkillImpl()); // 使用单独定义的实现类
//还可以改成使用匿名内部类
Skill skill = new Skill() {
@Override
public void use() {
System.out.println("Pia~pia~pia~");
}
};
hero.setSkill(skill);
}
同时使用匿名内部类和匿名对象
// 进一步简化，同时使用匿名内部类和匿名对象
hero.setSkill(new Skill() {
@Override
public void use() {
System.out.println("Biu~Pia~Biu~Pia~");
}
});
hero.attack();
}
二、反射
反射的主要原理是通过字符方式去调用相应的常量和方法：eg，把方法名和变量名卸载.properties文件中
获取Class对象的方式：
1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
2. 类名.class：通过类名的属性class获取
3. 对象.getClass()：getClass()方法在Object类中定义着。
Class对象功能：
* 获取功能：
1. 获取成员变量们
* Field[] getFields() 获取所有public修饰的成员变量
* Field getField(String name) 获取指定public修饰的成员变量
* Field[] getDeclaredFields() 获取所有的成员变量，不考虑修饰符
* Field getDeclaredField(String name)
2. 获取构造方法们
* Constructor<?>[] getConstructors()
* Constructor<T> getConstructor(类<?>... parameterTypes)
* Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
* Constructor<?>[] getDeclaredConstructors()
3. 获取成员方法们：
* Method[] getMethods 获取所有public修饰的方法
* Method getMethod(String name, 类<?>... parameterTypes)
* Method[] getDeclaredMethods()
* Method getDeclaredMethod(String name, 类<?>... parameterTypes)
4. 获取类名
* String getName()
1、 获取成员变量们
Person.classs省略。。自己写
getFields()
public static void main(String[] args) throws Exception {
//0.获取Person的Class对象
Class personClass = Person.class;
//1.Field[] getFields()获取所有public修饰的成员变量
Field[] fields = personClass.getFields();
for (Field field : fields) {
System.out.println(field);
}
getField()
//2.Field getField(String name)
Field a = personClass.getField("a");
//获取成员变量a 的值
Person p = new Person();
Object value = a.get(p);
System.out.println(value);
//设置a的值
a.set(p,"张三");
System.out.println(p);
getDeclaredFields() && getDeclaredField()
//Field[] getDeclaredFields()：获取所有的成员变量，不考虑修饰符
Field[] declaredFields = personClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(declaredField);
}
//Field getDeclaredField(String name)
Field getd = personClass.getDeclaredField("d");
//忽略访问权限修饰符的安全检查
getd.setAccessible(true);//暴力反射
Object value2 = getd.get(p);//从p对象获取getd的值
System.out.println(value2);
2、 获取构造方法们
有参的构造器getConstructor(类… parameterTypes)
public static void main(String[] args) throws Exception {
//0.获取Person的Class对象
Class personClass = Person.class;
//有参的构造器
//Constructor getConstructor(类... parameterTypes)
Constructor constructor = personClass.getConstructor(String.class, int.class);
//创建对象
Object person = constructor.newInstance("张三", 23);
System.out.println(person);
无参的构造器getConstructor()
//方式一
//无参的构造器
Constructor constructor1 = personClass.getConstructor();
System.out.println(constructor1);
//创建对象
Object person1 = constructor1.newInstance();
System.out.println(person1);
//方式二
//直接创建无参的构造器
Object o = personClass.newInstance();
System.out.println(o);
3、获取成员方法们
获取无参的方法
public static void main(String[] args) throws Exception {
//0.获取Person的Class对象
Class personClass = Person.class;
//获取指定名称的方法
Method eat_method = personClass.getMethod("eat");
Person p = new Person();
//执行方法eat()方法
eat_method.invoke(p);
获取有参的方法getMethod()
//执行带一个String的犯法
Method eat_method2 = personClass.getMethod("eat", String.class);
//执行方法
eat_method2.invoke(p,"饭");
获取所有public修饰的方法：getMethods()
//获取所有public修饰的方法
Method[] methods = personClass.getMethods();
for (Method method : methods) {
System.out.println(method);
String name = method.getName();
System.out.println(name);
//method.setAccessible(true);
}
4、 获取类名
//获取类名
String className = personClass.getName();
System.out.println(className);//cn.itcast.domain.Person
5、测试反射，通Properties()对象来获取方法
pro.properties文件自己去创建
public class ReflectTest {
public static void main(String[] args) throws Exception {
//1.加载配置文件
//1.1创建Properties对象
Properties pro = new Properties();
//1.2加载配置文件，转换为一个集合
//1.2.1获取class目录下的配置文件
ClassLoader classLoader = ReflectTest.class.getClassLoader();
InputStream is = classLoader.getResourceAsStream("pro.properties");
pro.load(is);
//2.获取配置文件中定义的数据
String className = pro.getProperty("className");
String methodName = pro.getProperty("methodName");
//3.加载该类进内存
Class cls = Class.forName(className);
//4.创建对象
Object obj = cls.newInstance();
//5.获取方法对象
Method method = cls.getMethod(methodName);
//6.执行方法
method.invoke(obj);
}
}
编译成功
否:编译失败(接口中没有抽象方法抽象方法的个数多余1个)
```java
@FunctionalInterface
public interface MyFunctionalInterface {
//定义一个抽象方法
public abstract void method();
}
public class MyFunctionalInterfaceImpl implements MyFunctionalInterface{
@Override
public void method() {
}
}
三、函数式接口，一般配合Lambda表达式一起使用
（1）使用Lambda必须有接口，且接口只有一个抽象方法（即函数式接口）。
（2）Lambda必须可以“上下文推断”（就是依据语境推断出参数类型，这也是Lambda的一个优点，使得参数类型得以省略，更加简洁）
缺点：
（1）不容易debug模式调试；
（2）在lambda语句中强制类型转换不方便；
（3）不能再foreach中修改forEach外面的值
（4）如果不并行计算，很多时候计算速度不如传统for循环.
函数式接口:有且只有一个抽象方法的接口,称之为函数式接口
当然接口中可以包含其他的方法(默认,静态,私有)
@FunctionalInterface注解
作用:可以检测接口是否是一个函数式接口
是:编译成功
否:编译失败(接口中没有抽象方法抽象方法的个数多余1个)
@FunctionalInterface
public interface MyFunctionalInterface {
//定义一个抽象方法
public abstract void method();
}
public class MyFunctionalInterfaceImpl implements MyFunctionalInterface{
@Override
public void method() {
}
}
1、方法的参数是一个接口,所以我们可以传递接口的匿名内部类【匿名内部的作用就是减少实现类的编写】
public class Demo {
//定义一个方法,参数使用函数式接口MyFunctionalInterface
public static void show(MyFunctionalInterface myInter){
myInter.method();
}
public static void main(String[] args) {
//调用show方法,方法的参数是一个接口,所以可以传递接口的实现类对象
show(new MyFunctionalInterfaceImpl());
//调用show方法,方法的参数是一个接口,所以我们可以传递接口的匿名内部类
show(new MyFunctionalInterface() {
@Override
public void method() {
System.out.println("使用匿名内部类重写接口中的抽象方法");
}
});
}
}
2、使用Lambda表达式去重写method()方法【()代表的就是method()方法】
//调用show方法,方法的参数是一个函数式接口,所以我们可以Lambda表达式
show(()->{
System.out.println("使用Lambda表达式重写接口中的抽象方法");
});
//简化Lambda表达式
show(()-> System.out.println("使用Lambda表达式重写接口中的抽象方法"));
四、Stream的详细介绍
Stream的详细介绍所有的Collection集合都可以通过stream默认方法获取流；
https://blog.csdn.net/qq_41821963/article/details/125364126
public class Demo02Stream {
public static void main(String[] args) {
//创建一个List集合,存储姓名
List<String> list = new ArrayList<>();
list.add("张无忌");
list.add("周芷若");
list.add("赵敏");
list.add("张强");
list.add("张三丰");
//对list集合中的元素进行过滤,只要以张开头的元素,存储到一个新的集合中
//对listA集合进行过滤,只要姓名长度为3的人,存储到一个新集合中
//遍历listB集合
list.stream()
.filter(name->name.startsWith("张"))
.filter(name->name.length()==3)
.forEach(System.out::println);
}
}
把集合转换为Stream流
1、ArrayList集合中
public class Demo01GetStream {
public static void main(String[] args) {
//把集合转换为Stream流
List<String> list = new ArrayList<>();
Stream<String> stream1 = list.stream();
}
}
2、Set集合中
Set<String> set = new HashSet<>();
Stream<String> stream2 = set.stream();
3、键值对HashMap集合中key 和value的获取
Map<String,String> map = new HashMap<>();
//获取键,存储到一个Set集合中
Set<String> keySet = map.keySet();
Stream<String> stream3 = keySet.stream();
//获取值,存储到一个Collection集合中
Collection<String> values = map.values();
Stream<String> stream4 = values.stream();
4、获取键值对(键与值的映射关系 entrySet)
//获取键值对(键与值的映射关系 entrySet)
Set<Map.Entry<String, String>> entries = map.entrySet();
Stream<Map.Entry<String, String>> stream5 = entries.stream();
5、 把数组转换为Stream流
//把数组转换为Stream流
Stream<Integer> stream6 = Stream.of(1, 2, 3, 4, 5);
//可变参数可以传递数组
Integer[] arr = {1,2,3,4,5};
Stream<Integer> stream7 = Stream.of(arr);
String[] arr2 = {"a","bb","ccc"};
Stream<String> stream8 = Stream.of(arr2);
6、forEach
Stream流中的常用方法_forEach void forEach(Consumer action); 该方法接收一个Consumer接口函数，会将每一个流元素交给该函数进行处理。 Consumer接口是一个消费型的函数式接口,可以传递Lambda表达式,消费数
据
public static void main(String[] args) {
//获取一个Stream流
Stream<String> stream1 = Stream.of("张三", "李四", "王五", "赵六", "田七");
//使用Stream流中的方法forEach对Stream流中的数据进行遍历
/*stream.forEach((String name)->{
System.out.println(name);
});*/
stream1.forEach(name->System.out.println(name));
}
7、filter
Stream流中的常用方法_filter:用于对Stream流中的数据进行过滤 Streamfilter(Predicate predicate); filter方法的参数Predicate是一个函数式接口,所以可以传递Lambda表达式,对数据进行过滤 Predicate中的抽象方法: boolean test(T t);
Stream<String> stream = Stream.of("张三丰", "张翠山", "赵敏", "周芷若", "张无忌");
//对Stream流中的元素进行过滤,只要姓张的人
Stream<String> stream2 = stream.filter((String name)->{return name.startsWith("张");});
//遍历stream2流
stream2.forEach(name-> System.out.println(name));
7、map
Stream流中的常用方法_map:用于类型转换
如果需要将流中的元素映射到另一个流中，可以使用map方法.
Stream map(Function mapper);
该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流。
Function中的抽象方法:
R apply(T t);
//获取一个String类型的Stream流
Stream<String> stream = Stream.of("1", "2", "3", "4");
//使用map方法,把字符串类型的整数,转换(映射)为Integer类型的整数
stream.map((String s)->{
return Integer.parseInt(s);
}).forEach((i-> System.out.println(i)));
//简写
stream.map(Integer::parseInt).forEach((System.out::println));
8、count
Stream流中的常用方法_count:用于统计Stream流中元素的个数 long count(); count方法是一个终结方法,返回值是一个long类型的整数 所以不能再继续调用Stream流中的其他方法了
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
list.add(7);
Stream<Integer> stream = list.stream();
long count = stream.count();
System.out.println(count);//7
9、limit
Stream流中的常用方法_limit:用于截取流中的元素 limit方法可以对流进行截取，只取用前n个。方法签名： Streamlimit(long maxSize); 参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作 limit方法是一个延迟方法,只是对流中的元素进行截取,返回的是一个新的流,所以可以继续调用Stream流中的其他方法
String[] arr = {"美羊羊","喜洋洋","懒洋洋","灰太狼","红太狼"};
Stream<String> stream = Stream.of(arr);
//使用limit对Stream流中的元素进行截取,只要前3个元素
Stream<String> stream2 = stream.limit(3);
//遍历stream2流
stream2.forEach(name-> System.out.println(name));
10、skip
Stream流中的常用方法_skip:用于跳过元素 如果希望跳过前几个元素，可以使用skip方法获取一个截取之后的新流： Streamskip(long n); 如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。
String[] arr = {"美羊羊","喜洋洋","懒洋洋","灰太狼","红太狼"};
Stream<String> stream = Stream.of(arr);
//使用skip方法跳过前3个元素
Stream<String> stream2 = stream.skip(3);
//遍历stream2流
stream2.forEach(name-> System.out.println(name));
11、concat
Stream流中的常用方法_concat:用于把流组合到一起
如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat static Stream
concat(Stream a, Stream b)
//创建一个Stream流
Stream<String> stream1 = Stream.of("张三丰", "张翠山", "赵敏", "周芷若", "张无忌");
//获取一个Stream流
String[] arr = {"美羊羊","喜洋洋","懒洋洋","灰太狼","红太狼"};
Stream<String> stream2 = Stream.of(arr);
//把以上两个流组合为一个流
Stream<String> concat = Stream.concat(stream1, stream2);
//遍历concat流
concat.forEach(name-> System.out.println(name));
练习：集合元素处理（Stream方式）
将上一题当中的传统for循环写法更换为Stream流式处理方式。
两个集合的初始内容不变，Person类的定义也不变。
public class Demo02StreamTest {
public static void main(String[] args) {
//第一支队伍
ArrayList<String> one = new ArrayList<>();
one.add("迪丽热巴");
one.add("宋远桥");
one.add("苏星河");
one.add("石破天");
one.add("石中玉");
one.add("老子");
one.add("庄子");
one.add("洪七公");
//1. 第一个队伍只要名字为3个字的成员姓名；存储到一个新集合中。
//2. 第一个队伍筛选之后只要前3个人；存储到一个新集合中。
Stream<String> oneStream = one.stream().filter(name -> name.length() == 3).limit(3);
//第二支队伍
ArrayList<String> two = new ArrayList<>();
two.add("古力娜扎");
two.add("张无忌");
two.add("赵丽颖");
two.add("张三丰");
two.add("尼古拉斯赵四");
two.add("张天爱");
two.add("张二狗");
//3. 第二个队伍只要姓张的成员姓名；存储到一个新集合中。
//4. 第二个队伍筛选之后不要前2个人；存储到一个新集合中。
Stream<String> twoStream = two.stream().filter(name -> name.startsWith("张")).skip(2);
//5. 将两个队伍合并为一个队伍；存储到一个新集合中。
//6. 根据姓名创建Person对象；存储到一个新集合中。
//7. 打印整个队伍的Person对象信息。
Stream.concat(oneStream,twoStream).map(name->new Person(name)).forEach(p-> System.out.println(p));
Stream.concat(oneStream,twoStream).map(Person::new).forEach(System.out::println);
}
}
输出：
Person{name=‘宋远桥’}
Person{name=‘苏星河’}
Person{name=‘石破天’}
Person{name=‘张天爱’}
Person{name=‘张二狗’}