【内部类匿名内部类反射LambdaStream流的使用】

news/2024/11/25 21:57:05/

一、内部类和匿名内部类

匿名内内部类和lambda表达式主要的区别在于
1、匿名内部类他必须实现继承类的所有方法
2、匿名内部类在重写时有override标识，而lambda没有
3、lambda表达式继承的接口只能有一个抽象方法

在使用匿名内部类的过程中，我们需要注意如下几点：

  • 1、使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。
  • 2、匿名内部类中是不能定义构造函数的。
  • 3、匿名内部类中不能存在任何的静态成员变量和静态方法。
  • 4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。
  • 5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

匿名内部类：在类的内部定义了一个新的类

内部类的分类：
静态内部类
实例内部类
局部内部类
实际上使用内部类编写代码，可读性太差

public interface Skill {void use(); // 释放技能的抽象方法
}
public class SkillImpl implements Skill {@Overridepublic 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() {@Overridepublic void use() {System.out.println("Pia~pia~pia~");}};hero.setSkill(skill);
}

同时使用匿名内部类和匿名对象

        // 进一步简化，同时使用匿名内部类和匿名对象hero.setSkill(new Skill() {@Overridepublic 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<T> 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{@Overridepublic 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{@Overridepublic void method() {}
}

1、方法的参数是一个接口,所以我们可以传递接口的匿名内部类【匿名内部的作用就是减少实现类的编写】

public class Demo {//定义一个方法,参数使用函数式接口MyFunctionalInterfacepublic static void show(MyFunctionalInterface myInter){myInter.method();}public static void main(String[] args) {//调用show方法,方法的参数是一个接口,所以可以传递接口的实现类对象show(new MyFunctionalInterfaceImpl());//调用show方法,方法的参数是一个接口,所以我们可以传递接口的匿名内部类show(new MyFunctionalInterface() {@Overridepublic 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<? super T> 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流中的数据进行过滤
Stream<T> filter(Predicate<? super T> 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<? super T, ? extends R> 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个。方法签名：
Stream<T> limit(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方法获取一个截取之后的新流：
Stream<T> skip(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<? extends T> a, Stream<? extends T> 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=‘张二狗’}


http://www.ppmy.cn/news/75074.html

相关文章

2023年最新VMware 17+虚拟机详细配置安装【程序员使用指南】！！

2023年最新VMware 17+虚拟机详细配置安装【程序员使用指南】！！

文章目录 Vmware版本选择17Pro安装自定义安装填写对应的许可证正式安装虚拟机进行对应的配置配置镜像文件选择对应的语言&#xff1a;到这个界面&#xff0c;选择中文 安装结束连接对应的xshell Vmware版本选择17Pro安装 ● 最开始从这里出发 自定义安装 ● 记得自定义在自…
阅读更多...
解决APP抓包问题「网络安全」

解决APP抓包问题「网络安全」

1.前言 在日常渗透过程中我们经常会遇到瓶颈无处下手&#xff0c;这个时候如果攻击者从APP进行突破&#xff0c;往往会有很多惊喜。但是目前市场上的APP都会为防止别人恶意盗取和恶意篡改进行一些保护措施&#xff0c;比如模拟器检测、root检测、APK加固、代码混淆、代码反调试…
阅读更多...
使用JWT实现登录认证

使用JWT实现登录认证

一、介绍 1.1、Session、Cookie、Token区别 session&#xff1a;存储再服务端&#xff0c;无法引用与分布式场景&#xff0c;并且需要占用服务端的资源 cookie&#xff1a;存储再客户端&#xff0c;适用于分布式场景&#xff0c;但是存在安全问题&#xff0c;不支持垮域访问 t…
阅读更多...
【多线程】什么是线程死锁？形成条件是什么？如何避免？

【多线程】什么是线程死锁？形成条件是什么？如何避免？

文章目录 一、什么是线程死锁二、线程死锁三、形成死锁的四个必要条件是什么四、如何避免线程死锁 一、什么是线程死锁 死锁是指两个或两个以上的进程&#xff08;线程&#xff09;在执行过程中&#xff0c;由于竞争资源或者由于彼此通信而造成的一种阻塞的现象&#xff0c;若…
阅读更多...
STL --- 2、容器 set 和multiset

STL --- 2、容器 set 和multiset

std::set 和 std::multiset 都是 STL 中的关联容器&#xff0c;用于存储一组有序的元素。 1、std::set 和 std::multiset 特点 &#xff08;1&#xff09;std::set 中每个元素的键值都唯一&#xff0c;而 std::multiset 中可以有多个相同的键值。 &#xff08;2&#xff09;s…
阅读更多...
Linux搭建MQTT服务器（mosquitto）并使用

Linux搭建MQTT服务器（mosquitto）并使用

零、码仙励志 在路上&#xff0c;寻找一个继续的理由&#xff0c;寻找一个曾经的梦想。 一、Linux搭建MQTT服务器&#xff08;mosquitto&#xff09;并使用 1、安装依赖 yum install gcc-c cmake openssl-devel libuuid-devel c-ares-devel uuid-devel libwebsockets-devel…
阅读更多...
HP打印機维护怎么找官方资料

HP打印機维护怎么找官方资料

关键词&#xff1a; “Removal and replacement” "part number" 范例 Removal and replacement A7W93 67033 Removal and replacement A7W93-67081 HP PageWide Enterprise, HP PageWide Managed - Removal and replacement: Service fluid container kit | H…
阅读更多...
Linux之NetLink学习笔记

Linux之NetLink学习笔记

1.NetLink机制 NetLink是一种基于应用层跟内核态的通信机制&#xff0c;其特点是一种异步全双工的通信方式&#xff0c;支持内核态主动发起通信的机制。该机制提供了一组特殊的API接口,用户态则通过socket API调用。内核发送的数据再应用层接收后会保存在接收进程socket的缓存…
阅读更多...
最新文章

Copyright @ 2022~2023