1 可变参数
//可变参数
public static void method1(int ... num){
//[I@4554617c
System.out.println(num);
for (int i : num) {
System.out.println(i);
}
}
//可变参数和其他类型参数的传参
public static void method2(String str,int ... num){
//[I@4554617c
System.out.println(num);
for (int i : num) {
System.out.println(i);
}
System.out.println(str);
}
2.增强for循环
//增强for循环
public static void method3(int ...num){
//在增强for循环中数据的类型必须是集合或者数组中元素的数据类型。
for (int i : num) {
System.out.println(i);
}
}
3.lambda 表达式
lambda 表达式的形式
<函数式接口> <变量名称>=(参数列表)->{
方法体:
}
lambda 表达式的特点
- 函数式接口是接口中只有一个抽象方法的接口。
- = 右边的类型会根据左边的函数式接口类型自动判断
- 如果参数列表为空,只保留()
- 如果参数只有一个,可以省略数据类型,保留变量名称即可。
- 如果是想语句只有一句,且没有返回值则可以省略{},如果有返回值,执行语句只有一句想省略{} 则雅瑶省略return.
- lambda 不会生成一个单独的内部类文件。
public interface LambdaDemo1 {
void eat(String str);
}
//lambda 表达式
LambdaDemo1 lambdaDemo1 = (String str)->{
System.out.println("eat foods!!!!" + str);
};
LambdaDemo1 lambdaDemo3 = (String str)->
System.out.println("eat foods!!!!" + str);
//lambda 简化以后
LambdaDemo1 lambdaDemo4 = str ->
System.out.println("eat foods!!!!" + str);
lambdaDemo1.eat("World");
lambdaDemo3.eat("World");
lambdaDemo4.eat("World");
public interface Demo1 {
//默认的方法 是允许有方法体的,并且被所有实现类的对象直接使用。
public default void hello(){
System.out.println("HelloWolrd");
};
public void eat();
}
public class Demo1Impl implements Demo1 {
@Override
public void eat() {
System.out.println("Demo01Impl eat foods!!!");
}
}
public static void method5(){
Demo1Impl demo1 = new Demo1Impl();
demo1.hello();
demo1.eat();
}
// 带返回值的方法
public interface LambdaDemo2 {
int sum(int a,int b);
}
//lambda 表达式
public static void test3(){
LambdaDemo2 lambdaDemo2 = (int a,int b)->{return a+b;};
System.out.println(lambdaDemo2.sum(10,20));
//省略{} 和 return
LambdaDemo2 lambdaDemo3 = (int a,int b)-> a+b;;
System.out.println(lambdaDemo3.sum(100,200));
// 省略数据类型
LambdaDemo2 lambdaDemo4 = (a,b)-> a+b;;
System.out.println(lambdaDemo4.sum(1000,2000));
}
4集合Stream
public static void method4(){
ArrayList<String> list = new ArrayList<>();
list.add("String");
list.add("Hello");
list.add("Javav");
list.add("World");
list.add("c++");
list.add("lambda");
list.add("switch");
list.add("small");
list.add("shell");
//Stream 流
//Stream<String> stringStream = list.parallelStream();
//计算流中元素的个数
//System.out.println(stringStream.count());
//lambda 表达式结合集合流
// 从容器中获取最大值
// System.out.println(stringStream.max((a,b)->{return a.compareTo(b) ;}).get());
//System.out.println(stringStream.min((a,b)->{return a.compareTo(b) ;}).get());
System.out.println(list.parallelStream().count());
System.out.println(list.parallelStream().max((a,b)->a.compareTo(b)).get());
System.out.println("------");
//过滤集合中以s开头的元素
Object[] s = list.stream()
//过滤值不为空
.filter(num -> num != null)
//过滤值以s开头
.filter(str -> str.startsWith("s"))
//转换为数组
.toArray();
for (Object o : s) {
System.out.println(o);
}
}
public static void method7(){
ArrayList<Integer> list = new ArrayList<>();
list.add(23);
list.add(44);
list.add(55);
list.add(2);
list.add(88);
list.add(54);
list.add(12);
Stream<Integer> stream = list.stream();
//过滤
long count = stream.filter(num->num!=null).filter(num->num<50).count();
System.out.println(count);
}
5 字符串格式化
System.out.printf("Line %s",123);
//输出结果是
Line 123
6 类加载机制
先编译后运行,编译后的文件是一个.class 二进制字节码文件。
JVM加载我们的类去运行。
6.1类的加载
- 将class 文件加载到内存中,生成一个Class对象。
- Class 类的实例表示正在运行的 Java 应用程序中的类和接口。
- 连接
- 验证 验证是否有正确的内部结构。(成员和构造器)
- 准备 如果有静态的成员分配内存,默认初始化值。
- 解析 将类的二进制数据中的符号替换为直接引用。
- 初始化(new )
6.2 类加载器
将.class 文件加载到内存中,生成对应的Class对象。(运行时类的对象)
我们不需要关系类加载器的加载机制。
- 类加载器的组成
- 根类加载器
- 扩展类加载器(第三方的jar文件)
- 系统类加载器(环境变量指定的jar路径)
7 反射
反射机制是在运行状态中,对于任意一个类都能够知道类的属性和方法。
对于任意一个对象都能调用他的任意方法和属性
这种获取信息以及调用的对象方法的功能称为反射机制
要解刨一个类,首先要获取类的二进制字节码文件。解剖使用的就是Class类中的方法。
7.0 反射获取Class对象(三种放式)
- Student stu = new Student();
Class aClass = stu.getClass(); - Class c = Student.class:
- Class classz = Class.forName(“com.hdrj.reflect.Student”);
7.1 反射技术获取字段
public static void method()throws Exception{
//反射技术
//获取类的Class对象
Class classz = Class.forName("com.hdrj.reflect.Student");
//com.hdrj.reflect.Student
System.out.println(classz.getName());
//获取所有的字段 公共字段。
Field[] fields = classz.getFields();
for (Field field : fields) {
System.out.println("field--"+field);
}
//获取所有的字段
Field[] fields1 = classz.getDeclaredFields();
for (Field field : fields1) {
System.out.println(field);
}
//获取单个公共的字段
Field name = classz.getField("address");
System.out.println(name);
//实例化对象
Object o = classz.newInstance();
//设置值
name.set(o,"admin");
//获取 o 对象name 字段的值
System.out.println(name.get(o));
}
7.2 反射获取构造器
Constructor<T> getConstructor(Class<?>... parameterTypes)
返回一个 Constructor 对象,它反映此 Class 对象所表示的类的指定公共构造方法。
Constructor<?>[] getConstructors()
返回一个包含某些 Constructor 对象的数组,这些对象反映此 Class 对象所表示的类的所有公共构造方法。
public static void method3()throws Exception{
Class classz = Class.forName("com.hdrj.reflect.Student");
Constructor[] constructors =
classz.getConstructors();
for (Constructor constructor : constructors) {
//public com.hdrj.reflect.Student()
//public com.hdrj.reflect.Student(int,java.lang.String)
System.out.println(constructor);
}
//获取带参数的构造器
Constructor constructor = classz.getConstructor(int.class, String.class);
//使用带参数的构造器实例化对象
Object java = constructor.newInstance(12, "JAVA");
System.out.println("constructor==="+constructor);
System.out.println("java==="+java);
}
7.3 反射获取方法
Method getDeclaredMethod(String name, Class<?>... parameterTypes)
返回一个 Method 对象,该对象反映此 Class 对象所表示的类或接口的指定已声明方法。
Method[] getMethods()
Method getMethod(String name, Class<?>... parameterTypes)
返回一个 Method 对象,它反映此 Class 对象所表示的类或接口的指定公共成员方法。
Object invoke(Object obj, Object... args)
对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。
public static void method2()throws Exception{
Class classz = Class.forName("com.hdrj.reflect.Student");
//拿到的是自己和父类的方法
Method[] methods = classz.getMethods();
for (Method method : methods) {
System.out.println(method);
}
System.out.println("-----------------------------------------");
//获取方法
Method hello = classz.getMethod("hello", null);
//方法的执行
Object o = classz.newInstance();
hello.invoke(o,null);
Method say = classz.getMethod("say", String.class);
say.invoke(o,"reflect");
//获取私有方法执行
Method sum = classz.getDeclaredMethod("sum", null);
//暴力访问方法
sum.setAccessible(true);
sum.invoke(o,null);
}