学习Java第二十五天

一、反射获取成员变量（重点）

方法名称	方法描述
public Field[] getFields()	获取所有公有的成员变量
public Field[] getDeclaredFields()	获取所有的成员变量（包括私有）
public Field[] getDeclaredFields()	获取单个公有的成员变量
public Field getDeclaredField(String name)	获取单个私有的成员变量

代码-获取所有公有的成员变量

/** * 获取所有公有的成员对象 * @throws ClassNotFoundException */ @Test public void showInfo01() throws ClassNotFoundException { //获取Class对象 Class cla = Class.forName("com.gkd.test01.Student"); //获取所有公有的成员对象 Field[] fields = cla.getFields(); //使用循环遍历数组 for(Field f:fields){ System.out.println(f); } }

代码-获取所有的成员变量（包括私有）

/** * 获取所有的成员对象(包括私有) * @throws ClassNotFoundException */ @Test public void showInfo02() throws ClassNotFoundException { //获取Class对象 Class cla = Class.forName("com.gkd.test01.Student"); //获取所有的成员对象（包括私有） Field[] fields = cla.getDeclaredFields(); //使用循环遍历数组 for(Field f:fields){ System.out.println(f); } }

代码-获取单个公有成员对象

/** * 获取单个公有的成员对象 * @throws ClassNotFoundException * @throws IllegalAccessException * @throws InvocationTargetException * @throws InstantiationException * @throws NoSuchMethodException * @throws NoSuchFieldException */ @Test public void showInfo03() throws ClassNotFoundException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException, NoSuchFieldException { //获取Class对象 Class cla = Class.forName("com.gkd.test01.Student"); //获取单个公有的成员对象 Field hobby = cla.getField("hobby"); //获取构造方法 Constructor con = cla.getConstructor(); //实例化对象 Object o = con.newInstance(); //设置成员变量 hobby.set(o,"按摩"); //获取值 System.out.println(hobby.get(o)); }

代码-获取单个私有成员对象

/** * 获取单个私有的成员对象 * @throws ClassNotFoundException * @throws IllegalAccessException * @throws InvocationTargetException * @throws InstantiationException * @throws NoSuchMethodException * @throws NoSuchFieldException */ @Test public void showInfo04() throws ClassNotFoundException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException, NoSuchFieldException { //获取Class对象 Class cla = Class.forName("com.gkd.test01.Student"); //获取单个私有的成员对象 Field name = cla.getDeclaredField("name"); //暴力反射去除私有 name.setAccessible(true); //获取构造方法 Constructor con = cla.getConstructor(); //实例化对象 Object o = con.newInstance(); //设置成员变量 name.set(o,"老王"); //获取值 System.out.println(name.get(o)); }

二、函数型接口（了解）

2.1简介

1、概念：接口中只有一个抽象方法 可以又其他方法 这就是函数型接口

2、函数型接口使用的注解：用于检查是否是函数型接口

3、函数型接口两种体现 A、函数行接口作为方法的参数 B、函数型接口作为方法的返回值

2.2函数型接口作为方法的参数

package com.gkd.test02; public class Test01 { public static void main(String[] args) { show(()-> System.out.println("嘻嘻嘻")); } public static void show(Inner inner){ inner.showInfo(); } }

2.3函数型接口作为方法的返回值

代码：

package com.gkd.test03; import java.util.Arrays; import java.util.Comparator; public class Test01 { public static void main(String[] args) { //定义一个字符串数组 String[] arrays={"a","abcd","ab","abcdef","abcdefghijk","abc"}; //使用工具类 // Arrays.sort(arrays, new Comparator<String>() { // @Override // public int compare(String o1, String o2) { // return o1.length()-o2.length(); // } // }); Arrays.sort(arrays,((o1, o2) -> o1.length()-o2.length())); System.out.println(Arrays.toString(arrays)); } }

代码-函数型接口

package com.gkd.test04; @FunctionalInterface public interface Inner { void showInfo(); }

代码-函数型接口测试类

package com.gkd.test04; public class Test01 { public static void main(String[] args) { getInner().showInfo(); } public static Inner getInner(){ // return new Inner() { // @Override // public void showInfo() { // System.out.println("老王去按摩……"); // } // }; return ()->{ System.out.println("凤舞去洗脚"); }; } }

三、jdk8提供 四个函数型接口（了解）

3.1Supplier供给型接口

1、Supplier 供给型接口

2、方法的名称

T get() 得到一个结果

代码-01获取字符串的前两位

package com.gkd.test05; import java.util.function.Supplier; public class Test01 { public static void main(String[] args) { // String s = getValue(new Supplier<String>() { // @Override // public String get() { // String str="abc"; // String substring = str.substring(0, 2); // return substring; // } // }); String s=getValue(()->"abc".substring(0,2)); System.out.println(s); } public static String getValue(Supplier<String> sup){ return sup.get(); } }

代码-01获取数组中的最大值

package com.gkd.test05; import java.util.Arrays; import java.util.function.Supplier; public class Test02 { public static void main(String[] args) { // int num= getMax(new Supplier<Integer>() { // @Override // public Integer get() { // //定义一个数组 // int [] arrays={10,20,30,80,5,-100,-98,0}; // //对数组进行排序 // Arrays.sort(arrays); // //获取数组的最后一位 // int ar = arrays[arrays.length - 1]; // return ar; // } // }); int num=getMax(()->{ //定义一个数组 int [] arrays={10,20,30,80,5,-100,-98,0}; //对数组进行排序 Arrays.sort(arrays); //获取数组的最后一位 int ar = arrays[arrays.length - 1]; return ar; }); System.out.println(num); } public static int getMax(Supplier<Integer> sup){ return sup.get(); } }

3.2Consumer消费型接口

方法名称	方法描述
void accept(T t)	表示消费
default Consumer andThen(Consumer after)	连接多个消费型接口

代码-01 使用消费型接口获取字符串的前两位

package com.gkd.test06; import java.util.function.Consumer; public class Test01 { public static void main(String[] args) { // showInfo("今天天气晴朗，适合出去玩",(String s)->{ // System.out.println(s.substring(9)); // } ); showInfo("今天天气晴朗，适合出去玩",s -> { System.out.println(s.substring(0,6)); }); } public static void showInfo(String s,Consumer<String> con){ con.accept(s); } }

代码-02 使用消费型接口对一个字符串进行两次消费 一次转换为大写 一次转换为小写

package com.gkd.test06; import java.util.Locale; import java.util.function.Consumer; public class Test02 { public static void main(String[] args) { // showInfo("abcDEF",(String s)->{ // System.out.println(s.toUpperCase()); // },(String n)->{ // System.out.println(n.toLowerCase()); // }); showInfo("abcDEF",s-> System.out.println(s.toUpperCase()),n->System.out.println(n.toLowerCase())); } public static void showInfo(String s, Consumer<String> con1,Consumer<String> con2){ con1.andThen(con2).accept(s); } }

代码-03 使用消费型接口 String[] arrays={"迪丽热巴:24","古力娜扎:28","马尔扎哈:30"}==>姓名:迪丽热巴,年龄:24

package com.gkd.test06; import java.util.function.Consumer; public class Test03 { public static void main(String[] args) { //定义数组 // String [] arrays={"迪丽热巴：24","古力娜扎：28","马儿扎哈：30"}; // showInfo(arrays,(String s)->{ // String[] nums = s.split("："); // System.out.print("姓名："+nums[0]+","); // // },(String n)->{ // String[] nums = n.split("："); // System.out.println("年龄："+nums[1]+"\t"); // }); String [] arrays={"迪丽热巴：24","古力娜扎：28","马儿扎哈：30"}; showInfo(arrays,s->{ String[] nums = s.split("："); System.out.print("姓名："+nums[0]+","+"\t"); }, n->{ String[] nums = n.split("："); System.out.println("年龄："+nums[1]); }); } public static void showInfo(String [] strings, Consumer<String> con1,Consumer<String> con2){ //使用循环遍历数组 for (String s:strings){ con1.andThen(con2).accept(s); } } }

3.3Predicate断言型接口

方法的名称	方法的描述
	用于来做判断
	并且&&
	或者||
	非！

代码-01使用断言型接口判断字符串长度是否大于5

代码-02使用断言型接口判断字符串长度是否大于5 并且字符包含a

代码-03使用断言型接口 String[]arrays={“ 迪丽热巴 ”，“古力娜扎 ”，“ ”，“ ”}

对数组进行中的元素 如果元素长度==4 并且包含迪 将满足条件的元素存入集合中

package com.gkd.test06; import java.util.ArrayList; import java.util.List; import java.util.function.Predicate; public class Test04 { public static void main(String[] args) { //创建一个数组 // List<String> list= showInfo(new String[]{"迪丽热巴","古力娜扎","杨迪","欧阳娜娜"},(String s)->{ // return s.length()==4; // },(String n)->{ // return n.contains("迪"); // }); List<String> list= showInfo(new String[]{"迪丽热巴","古力娜扎","杨迪","欧阳娜娜"},s-> s.length()==4,n->n.contains("迪")); System.out.println(list); } public static List<String> showInfo(String [] s , Predicate<String> pre1,Predicate<String> pre2){ //实例化一个集合 List<String> list=new ArrayList<>(); //使用循环遍历数组 for (String l:s){ //判断是否满足条件，满足就存入集合 if (pre1.and(pre2).test(l)){ list.add(l); } } return list; } }

3.4Function函数型接口

方法的名称	方法的描述
R apply(T t)	用于来做转换（将T类型转化成R类型）
R apply(T t)	用于来连接多个函数型接口

代码-01使用函数型接口 将String类型的数字转换int类型的数字

四、Stream（重点）

只能用一次，用完就关了

4.1简介

1、Stream 是一个接口 主要用于对数据进行过滤 类似工厂流水线

2、Stream 提供了两类方法 a、延迟方法 b、终结方法

3、延迟方法：使用Stream流的方法之后 返回的还是Stream流对象 可以继续使用其方法

4、终结方法：使用Stream流的方法之后 返回的还是Stream流对象 不可以继续使用其方法

没有Stream流之前

有Stream流之后

4.2获取Stream对象

方法的名称	方法的描述
static Stream of(T... values)	将多个元素封装到Stream对象中
default Stream stream()	将集合中的数据封装到Stream对象中（单列集合）

4.3Stream常用的方法

方法名称	方法的描述	是否是延迟方法
Stream filter(Predicate predicate)	用于对数据进行过滤	是
void forEach(Consumer action)	对Stream对象中元素进行遍历	否
long count()	返回的是Stream流中元素的个数	否
Stream limit(long maxSize)	截取Stream指定长度的元素（substring）	是
Stream map(Functionmapper)	用来进行转换	是
Stream skip(long n)	跳过指定的元素	是
static Stream concat(Stream a,Stream b)	用于拼接两个Stream对象	是

代码：

package com.gkd.test07; import java.util.ArrayList; import java.util.List; import java.util.stream.Stream; public class Test01 { public static void main(String[] args) { //定义一个集合 List<String> list=new ArrayList<>(); list.add("张三"); list.add("李四"); list.add("王五"); list.add("张无忌"); list.add("张三丰"); //将集合转换为Stream对象 Stream<String> st = list.stream(); // st.forEach((String s)->{ // System.out.println(s); // }); // st.filter((String s)->{ // return s.contains("张"); // }).forEach((String n)->{ // System.out.println(n); // }); // Stream<String> s1 = st.filter((String s) -> { // return s.contains("张"); // }); // s1.forEach((String s)->{ // System.out.println(s); // }); // long count = Stream.of(10, 20, "凤舞", "老王", 'a', 20.5).count(); // System.out.println(count); // Stream.of(10, 20, "凤舞", "老王", 'a', 20.5).limit(3).forEach((Object obj)->{ // System.out.println(obj); // }); // Stream.of(10, 20, "凤舞", "老王", 'a', 20.5).skip(3).forEach((Object obj)->{ // System.out.println(obj); // }); Stream.concat(Stream.of(1,2,3,4,5,6,7),Stream.of(8,9,0)).forEach((Object obj)->{ System.out.println(obj); }); } }

4.4案例

step01-需求

step02-Persong类

package com.gkd.test07; public class Person { private String name; public Person() { } public Person(String name) { this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public String toString() { return "Person{" + "name='" + name + '\'' + '}'; } }

step03-代码测试类

package com.gkd.test07; import com.sun.xml.internal.ws.addressing.WsaActionUtil; import java.util.ArrayList; import java.util.List; import java.util.stream.Stream; public class Test02 { public static void main(String[] args) { //定义两个集合 List<String> list01=new ArrayList<>(); List<String> list02=new ArrayList<>(); list01.add("宫本武藏"); list01.add("宋公明"); list01.add("苏有朋"); list01.add("石头人"); list01.add("时传祥"); list01.add("李耳"); list01.add("庄子"); list01.add("洪七公"); list02.add("帕瓦罗蒂"); list02.add("张三疯"); list02.add("赵微微"); list02.add("张自忠"); list02.add("儿只斤铁木真"); list02.add("张天爱"); list02.add("张翠花"); // //第一 // Stream<String> st1 = list01.stream(); // st1.filter((String s)->{ // return s.length()==3; // }).forEach((String n)->{ // System.out.println(n); // }); // System.out.println("====================="); // // //第二 // Stream<String> st2 = list01.stream(); // st2.filter((String s)->{ // return s.length()==3; // }).limit(3).forEach((String n)->{ // System.out.println(n); // }); // System.out.println("======================="); // // //第三 // Stream<String> st3 = list02.stream(); // st3.filter((String s)->{ // return s.contains("张"); // }).forEach((String n)->{ // System.out.println(n); // }); // // System.out.println("==============="); // // // //第四 // Stream<String> st4= list02.stream(); // st4.filter((String s)->{ // return s.contains("张"); // }).skip(2).forEach((String n)->{ // System.out.println(n); // }); // System.out.println("================"); // // //第五 // Stream.concat(list01.stream(),list02.stream()).forEach((Object s)->{ // System.out.println(s); // }); // // //第六 // Stream<String> s1 = list01.stream().filter((String s) -> { return s.length() == 3; }).limit(3); Stream<String> s2 = list02.stream().filter((String s) -> { return s.substring(0, 1).equals("张"); }).skip(2); //实例化集合 List<Person> personList=new ArrayList<>(); //合并 Stream<String> s3 = Stream.concat(s1, s2); // s3.map((String s)->{ return new Person(s); }).forEach((Person n)->{ personList.add(n); }); System.out.println(personList); } }

五、注解（重点）

5.1简介

1、注释：用于对代码进行解释说明 主要提供给程序员查看

2、注解：用于对代码进行解释说明 主要时用于给jvm来进行识别

3、定义：

a、注解又称为元数据 b、在jdk1.5之后引入 c、用来对这些元素进行说明 注释

4、作用：

A、编写文档

B、代码分析

C、编译检查

5.2jdk提供三个注解

A、@Override 用于来标注是否是重写的方法

B、@Deprecated用于来表示是否是过时的方法

例如：stop() 过时的方法是可以使用 不提倡使用过时的方法

C、@SuppressWarnings用于压制黄色的警告线

说明：a、定义在类上（表示压制所有黄色警告） b、定义在方法上 c、定义在属性

5.3自定义注解

1、格式：

A、元注解

B、

2、本质：注解其实就是一个接口

反编译的指令：javap class文件

3、接口（注解）成员

A、静态常量（不关注） B、抽象方法（关注）==>注解中的抽象方法也称为属性

4、抽象方法（属性）返回值类型

A、基本数据类型 四类八种

B、String类型

C、枚举类型

D、注解类型

E、以上类型的数组类型

5、注意点：

A、使用注解的时候必须给注解的所有属性进行赋值

B、如果属性设置默认值 使用注解的时候可以不用给该属性赋值

C、如果属性的返回值是数组类型 使用注解的时候 使用大括号赋多个值 如果只需要赋值一个值 使用小括号

D、如果注解中只有一个属性值 属性值的名称 名称是value 那么使用注解的时候 属性名可以省略

代码-枚举类

package com.gkd.test08; public enum Color { RED }

代码-注解

package com.gkd.test08; public @interface MyAnno { int age(); String name(); Color getColor(); MyAnno01 show(); String[] value(); }

代码-注解my

package com.gkd.test08; public @interface MyAnno01 { }

代码-测试类

package com.gkd.test08; //@MyAnno(age = 18,name = "老王",getColor = Color.RED,show = @MyAnno01,value={"1","abc","凤舞"}) public class Test01 { public static void main(String[] args) { } }