java基础-Java8新特性

最新推荐文章于 2024-01-12 23:55:36 发布
最新推荐文章于 2024-01-12 23:55:36 发布
阅读量110 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48865614/article/details/125976692
版权

文章目录

Java8新特性

Lambda表达式

  • 面向对象的思想：，做一件事，找一个能解决这件事的对象，调用对象的方法完成事情
  • 函数式编程思想：只要能获取到结果，谁去做的怎么做的都不重要，重视的是结果不是过程

使用Lambda表达式

package com.z.lambda.testlambda;

public class Test2 {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("hhh");
            }
        };
        new Thread(runnable).start();

        /*
            接口内的方法没有任何参数

            ()：看要重写的方法有没有参数
            ->：lambda表达式的一个标识
            {}：代表了当前方法体 重写方法要做的内容

            ()->{System.out.println("hhh");}
        */
        new Thread(()->{System.out.println("哈哈哈");}).start();


        int a = 10;
        int b = 20;
     /*   show(a, b, new Calc() {
            @Override
            public int add(int a, int b) {
                return a+b;
            }
        });*/
//        show(a,b,(int c,int d)->{return c+d;});//30

        //可以省略形参类型：  接口中已经定义了方法的形参
//        show(100,120,(c,d)->{return c+d;});//220

        //当方法体只有一句代码的时候 可以省略return
        show(10,120,(c,d)->c+d);//130


    }
    static void show(int a,int b,Calc c){
        int add = c.add(a,b);
        System.out.println(add);

    }
}
interface Calc{
    int add(int a, int b);
}

函数式接口分类

1. 自定义函数式接口
  • 自定义函数式接口与已知函数接口
package com.z.lambda.func;
/*
    @FunctionalInterface
    检验当前接口是不是函数式接口：只能有一个抽象方法
    
    知道的函数式接口：Runnable   Comparator
*/
@FunctionalInterface//自定义函数接口
public interface Show {
    int NUM = 20;
    public void show();
    public static void showMessage(){
        System.out.println("this is showMessage()");
    }
    public default void c(){
        System.out.println("this is c()");
    }
}
2. 消费型接口
  • 消费型接口的抽象方法特点：有形参，但是返回值类型是void
    在这里插入图片描述
package com.z.lambda.consumer;

import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

/*
    消费型接口：只进不出

*/
public class Test2 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("李白");
        list.add("杜甫");
        list.add("王安石");
        list.add("白居易");
/*//      ↓ 四种遍历方式
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        for (String s : list) {
            System.out.println(s);
        }
        //迭代器
        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        ListIterator<String> listIterator = list.listIterator();
        while(listIterator.hasNext()){
            System.out.println(listIterator.next());
        }*/

        /*//消费型接口
        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/

        //使用lambda表达式简化
//        list.forEach((l)-> {System.out.println(l);});
        //当只有一个参数的时候 可以省略（）
        list.forEach(l-> System.out.println(l));


        Map<Integer,String> map = new HashMap<>();
        map.put(10,"李白");
        map.put(11,"杜甫");
        map.put(12,"王安石");
        map.put(13,"李商隐");
        /*map.forEach(new BiConsumer<Integer, String>() {
            @Override
            public void accept(Integer key, String value) {
                System.out.println(key+"----->"+value);
            }
        });*/
        //使用lambda表达式简化
        map.forEach((k,v)->{System.out.println(k+"----->"+v);});
    }
}
3. 供给型接口
  • 供给型接口抽象方法特点：无参，但是有返回值
    在这里插入图片描述
package com.z.lambda.inter;

import java.util.function.Supplier;
import java.util.stream.Stream;

public class TestLambda {
    public static void main(String[] args) {
        Supplier<String> s = new Supplier<String>() {
            @Override
            public String get() {
                return "你好";
            }
        };
        System.out.println(s.get());

        //当没有形参的时候，不能省略()
        Supplier<String> s1 =()->"HelloWorld";
        System.out.println(s1.get());

//      无限流
/*
        Stream.generate(new Supplier<Double>() {
            @Override
            public Double get() {
                return Math.random();
            }
        }).forEach((a)->System.out.println(a));
*/

        Stream.generate(()->Math.random()).forEach((a)-> System.out.println(a));
    }
}
4. 判断型接口
  • 判断型接口的抽象方法特点：有参，但是返回值类型是boolean结果
    在这里插入图片描述
package com.z.lambda.judge;

import java.util.ArrayList;
import java.util.function.Predicate;

public class Test2 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("李白");
        list.add("杜甫");
        list.add("李商隐");
        list.add("白居易");

        /*list.removeIf(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                if (s.startsWith("李")){
                    return true;
                }
                return false;
            }
        });*/
        
        /*list.removeIf(s -> {
            if (s.startsWith("李")){
                return true;
            }
            return false;
        });*/
//          三目运算符简化
        list.removeIf(s -> s.startsWith("李") ? true : false);
        System.out.println(list);
    }
}
5. 功能型接口
  • 功能型接口的抽象方法特点：既有参数又有返回值
package com.z.lambda.function;

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiFunction;

public class Test2 {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>();
        map.put(10,"李白");
        map.put(12,"杜甫");
        map.put(13,"李商隐");
        map.put(14,"白居易");
/*        map.replaceAll(new BiFunction<Integer, String, String>() {
            @Override
            public String apply(Integer integer, String s) {
                if (s.startsWith("李")){
                    return "hahah";
                }
                return null;
            }
        });*/
        map.replaceAll((key,value)->{
            if (value.startsWith("李"))
            {
                return "lalal";
            }
            return null;
        });
        System.out.println(map);//{10=lalal, 12=null, 13=lalal, 14=null}
    }
}

方法引用与构造器引用

  • Lambda表达式是可以简化函数式接口的变星与形参赋值的语法。而方法引用和构造器引用是为了简化Iambda表达式的。当Lambda表达式满足一些特殊的情况时，还可以再简化:

    1. Lambda体只有一句语句，并且是通过调用一个对象的/类现有的方法来完成的
      例如: System.out对象，调用println()方法来完成Lambda体
      Math类，调用random()静态方法来完成Lambda体
    2. 并且Lambda表达式的形参正好是给该方法的实参
      例如: t->System.out.printIn(t)
      ()-> Math.random()都是无参
方法引用
  • 方法引用的作用：简化Lambda表达式
  • 方法引用的语法格式：
    1. 实例对象名::实例方法
    2. 类名::静态方法
    3. 类名::实例方法
  • 说明：
    1. ::称为方法引用操作符(两个:中间不能有空格，而且必须英文状态下半角输入)
    2. Lambda表达式的形参列表，全部在Lambda体中使用上了，要么是作为调用方法的对象，要么是作为方法的实参。
    3. 在整个Lambda体中没有额外的数据。
package com.z.lambda.method;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.function.Consumer;
import java.util.function.Supplier;
import java.util.stream.Stream;

public class TestMethod {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("李白");
        list.add("杜甫");
        list.add("白居易");
        list.add("李商隐");
/*        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/
        /*list.forEach(s-> System.out.println(s));*/

        list.forEach(System.out::println);

//      方法引用1
        Employee e = new Employee(1, "李白", "男", 19, 9889);
        /*Supplier<String> name = new Supplier<String>() {
            @Override
            public String get() {
                return e.getName();
            }
        };*/
//        Supplier<String> name = ()->e.getName();
        //实例对象名::实例方法(实例对象名调用实例方法)
        Supplier<String> name = e::getName;
        System.out.println(name.get());

//方法引用2
        /*Stream.generate(new Supplier<Double>() {
            @Override
            public Double get() {
                return Math.random();
            }
        }).forEach(System.out::println);*/
//        Stream.generate(() -> Math.random()).forEach(System.out::println);
        //类名::静态方法(类名调用静态方法)
        //Stream.generate(Math::random).forEach(System.out::println);

//方法引用3
        String[] arr = {"c","d","a","z","e"};
        /*Arrays.sort(arr, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });*/
//        Arrays.sort(arr,((o1, o2) -> o1.compareTo(o2)));
        //类名::实例方法(类调用实例方法)
        Arrays.sort(arr,String::compareTo);
        System.out.println(Arrays.toString(arr));
    }
}

class Employee {
    private int no;
    private String name;
    private String sex;
    private int age;
    private double salary;

    public Employee() {
    }

    public Employee(int no, String name, String sex, int age, double salary) {
        this.no = no;
        this.name = name;
        this.sex = sex;
        this.age = age;
        this.salary = salary;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }
}
构造器引用
  • 当Lambda表达式是创建一个对象，并且满足Lambda表达式形参，正好是给创建这个对象的构造器的实参列表。
  • 当Lambda表达式是创建一个数组对象，并且满足Lambda表达式形参，正好是给创建这个数组对象的长度构造器引用的语法格式:
    1. 类名::new
    2. 数组类型名::new
package com.z.lambda.constru;

import java.util.function.Function;
import java.util.function.Supplier;

public class Test2 {
    public static void main(String[] args) {
        //构造器引用
        /*Supplier<Employee> e = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };*/
        //类名::new
        Supplier<Employee> e =Employee::new;
                System.out.println(e.get());


        Function<Integer,int []> f = new Function<Integer, int[]>() {
            @Override
            public int[] apply(Integer integer) {
                return new int[integer];
            }
        };
        int[] apply = f.apply(20);
        System.out.println(apply.length);
        //数组类型名::new
        Function<Integer,int []> f1 = int[]::new;
        int[] apply1 = f1.apply(10);
        System.out.println(apply1.length);
    }
}
class Employee {
    private int no;
    private String name;
    private String sex;
    private int age;
    private double salary;

    public Employee() {
    }

    public Employee(int no, String name, String sex, int age, double salary) {
        this.no = no;
        this.name = name;
        this.sex = sex;
        this.age = age;
        this.salary = salary;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }
}

Stream API

  • 注意：
    1. Stream自己不会存储元素。
    2. Stream不会改变源对象。每次处理都会返回一个持有结果的新Stream。
    3. stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
  • Stream的操作三个步骤:
    • 创建Stream:通过一个数据源(如:集合、数组)，获取一个流
    • 中间操作:中间操作是个操作链，对数据源的数据进行n次处理，但是在终结操作前，并不会真正执行。
    • 终止操作:一旦执行终止操作，就执行中间操作链，最终产生结果并结束Stream,
      在这里插入图片描述

创建Stream

  1. 创建Stream方式一：通过集合
    Java8中的Collection接口被扩展，提供了两个获取流的方法:
  • public default Stream<E> stream()：返回一个顺序流
  • public default Stream<E> parallelStream()：返回一个并行流
package com.z.stream;

import java.util.ArrayList;
import java.util.stream.Stream;

public class CreateStream {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList();
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
/*通过集合*/
        Stream<Integer> stream = list.stream();
        //获取并行流
//        Stream<Integer> stream = list.parallelStream();
        // 方法引用
//        stream.forEach(System.out::println);
        stream.forEach((t)->{
            System.out.println(Thread.currentThread().getName()+"===>"+t);
        });
  	}
}
  1. 创建Stream方式二：通过数组

Java8中的Arrays 的静态方法 stream()可以获取数组流:

  • public static <T> Stream<T> stream(T[] array)：返回一个流
    重载形式，能够处理对应基本类型的数组：
  • public static IntStream stream(int[] array)：返回一个整型数据流
  • public static LongStream stream(long[] array)：返回一个长整型数据流
  • public static DoubleStream stream(double[] array)：返回一个浮点型数据流
package com.z.stream;

import java.util.Arrays;
import java.util.stream.Stream;

public class CreateStream {
    public static void main(String[] args) {
        
        int [] arr = {20 ,50,40,30,12};
        Arrays.stream(arr).forEach(System.out::println);
    }
}
  1. 创建Stream方式三：通过Stream的of()
    可以调用Stream类静态方法of()，通过显示值创建一个流。它可以接收任意数量的参数。
  • public static<T> Stream<T> of(T… values)：返回一个顺序流
// 创建流↓                         遍历↓
Stream.of(10,20,40,30).forEach(System.out::println);
  1. 创建Stream方式四：创建无限流
    可以使用静态方法Stream.iterate()和Stream.generate(),创建无限流。
  • public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)：返回一个无限流
  • public static<T> Stream<T> generate(Supplier<T> s)：返回一个无限流
 //无限流
        /*Stream.iterate(1, new UnaryOperator<Integer>() {
            @Override
            public Integer apply(Integer integer) {
                return 10;
            }
        }).forEach(System.out::println);*/
//        Stream.iterate(1, (t)->t+=1).forEach(System.out::println);
        Stream.generate(Math::random).forEach(System.out::println);

中间操作

package com.z.stream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.function.Predicate;
import java.util.stream.Stream;

/*
    1. 不会对原有数据造成影响
    2. 中间操作的流 和 终结操作的流 必须是同一个流
*/
public class MiddleTest {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList();
        list.add(10);
        list.add(21);
        list.add(30);
        list.add(43);
        list.add(50);
        //1. 创建流
        Stream<Integer> stream = list.stream();
        /*stream.filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return false;
            }
        });*/
        System.out.println("========去掉偶数只保留奇数==========");

        //去掉偶数只保留奇数
        Stream<Integer> integerStream = stream.filter((s) -> s % 2 != 0);
        integerStream.forEach(System.out::println);
        System.out.println("========去掉奇数只要偶数==========");
        //去掉奇数只要偶数
        list.stream().filter((s) -> s % 2 == 0).forEach(System.out::println);
        System.out.println("========从小到大排序==========");

        //从小到大排序
        list.stream().sorted().forEach(System.out::println);
        System.out.println("==========从大到小排序========");

        //从大到小排序
        /*list.stream().sorted(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return -o1.compareTo(o2);
            }
        }).forEach(System.out::println);*/
        list.stream().sorted((a,b)-> {return b.compareTo(a);}).forEach(System.out::println);
        System.out.println("==========拿前两数========");
//      limit(2)：限制：取前俩个
        list.stream().sorted((a,b)-> {return b.compareTo(a);}).limit(2).forEach(System.out::println);
        System.out.println("==========拿第2个数，不要第一个========");
        //skip(1 ):跳过一个
        list.stream().sorted((a,b)-> {return b.compareTo(a);}).limit(2).skip(1 ).forEach(System.out::println);

        System.out.println("=================");
        String[] arr = {"hello","world","hero"};
        //映射关系
        Arrays.stream(arr).map((s) -> s.toUpperCase()).forEach(System.out::println);

        System.out.println("=========distinct():去除重复元素========");
        Stream.of(1,2,3,3,2,1,10,20).distinct().forEach(System.out::println);
    }
}

终结操作

package com.z.stream;

import java.util.List;
import java.util.Optional;
import java.util.function.BinaryOperator;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/*  中间操作可以有多个，但是终结操作只能有一个*/
public class EndTest {
    public static void main(String[] args) {
        long count = Stream.of(10, 20, 30, 1, 1, 2, 3, 4, 5, 7).filter((s) -> s % 2 != 0).peek(System.out::println).count();
        System.out.println("------>" + count);
        /*  1
            1
            3
            5
            7
            ------>5
*/
        System.out.println("======allMatch  判断所有元素是否都是10=======");
        System.out.println("======anyMatch  任意一个元素是否是10=======");
        System.out.println("======noneMatch  没有一个元素是10=======");
        boolean b = Stream.of(10, 20, 30, 1, 1, 2, 3, 4, 5, 7).noneMatch((s) -> s == 10);
        System.out.println(b);//false

        Optional<Integer> first = Stream.of(10, 20, 30, 1, 1, 2, 3, 4, 5, 7).findFirst();
        System.out.println(first.get());//10

        /*collect:将满足要求的数据  进行收集*/
        List<Integer> collect = Stream.of(10, 20, 30, 1, 1, 2, 3, 4, 5, 7).filter((s) -> s % 2 == 0).collect(Collectors.toList());
        System.out.println(collect);//[10, 20, 30, 2, 4]

        //将值反复结合，最终变为一个值
/*        Optional<Integer> reduce = Stream.of(10, 20, 30).reduce(new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer integer, Integer integer2) {
                return integer + integer2;
            }
        });*/
        Optional<Integer> reduce = Stream.of(10, 20, 30).reduce((s, s1) -> s + s1);
        System.out.println(reduce.get());//60

    }
}

Optional

package com.z.op;

import java.util.Optional;

public class OpTest {
    public static void main(String[] args) {
        String s = null;
        Optional<String> s1 = Optional.ofNullable(s);
        System.out.println(s1);//Optional.empty 防止空指针
        System.out.println(s1.orElse("世界"));//世界

        String s2 = "你好";
        Optional<String> s21 = Optional.ofNullable(s2);
        System.out.println(s21.orElse("世界"));//你好


        Student student  = new Student();
        Optional<String> name = getName(student);
        System.out.println(name.orElse("张三"));//orElse("张三")避免空


    }
    public  static  Optional<String> getName (Student s){
        return Optional.ofNullable(s.name);//ofNullable避免空值
    }
}
class Student{
    String name ;

    public Student() {
    }

    public Student(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}
I会飞的鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 14万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
Java-Java8十大特性详解教程
11-08
Java8 十大特性详解教程 资源为视频教程资源 希望对你的 Java 学习有所帮助。
Java8 新特性
select_zxl的博客
07-14 305
Java8新特性
Java8新特性：StreamAPI、创建Stream对象、中间操作、终止操作
GQ的博客
06-16 541
**Stream APl ( java.util.stream)**把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。Stream是 Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API对集合数据进行操作，就类似于使用SQL执行的数据库查询。也可以使用Stream API来并行执行操作。简言之，S
Java8 - Java17新特性说明
h295928126的博客
07-06 3496
Java8 - Java17新特性说明
Java8新特性-Lambda表达式
ThinkWon的博客
02-08 1万+
文章目录简介使用Lambda表达式的优缺点基本概念函数式接口接口默认方法嵌套类(Nested Classes)使用Lambda表达式的前提基础语法Lambda表达式的重要特征目标类型与类型推断作用域方法引用静态方法引用指定对象实例方法引用特定类型任意对象方法引用超类方法引用构造器方法引用数组构造器方法引用Java8内置的函数式接口消费型接口供给型接口函数型接口断言型接口 简介 Lambda表达式（也称闭包），是Java8中最受期待和欢迎的新特性之一。Lambda表达式本质是一个匿名函数，但是它并不是匿名类的
java基础 -- java8,9,10,11新特性
weixin_42469070的博客
03-31 1296
java基础 -- TODOjava8 新特性接口中的新特性可重复注解、类型注解 连接视频 java8 新特性 接口中的新特性 JDK7及以前：只能定义全局常量和抽象方法 全局常量：public static final的，但是书写时，可以省略不写 抽象方法：public abstract的 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法 Java 8 中，你可以为接口添加 静态方法 和 默认方法。从技术角度来说，这是完全合法的，只是它看起来违反了接口作为一个抽象定义的理念。 静
JAVA8新特性(吐血整理)
yitian_66的博客
07-12 11万+
一、Java 8 Lambda 表达式... 31.1 语法... 31.2 Lambda 表达式实例... 3Java8Tester.java 文件... 31.3 变量作用域... 5Java8Tester.java 文件... 5Java8Tester.java 文件... 5二、Java 8 方法引用... 72.1方法引用... 72.2方法引用实例... 8Java8Tester.j...
java8常用新特性(超详细)
最新发布
蒾酒的博客
01-12 1994
Lambda表达式通常与函数式接口（只有一个抽象方法的接口）一起使用，可以大大简化代码。方法引用是一种更简洁地表示已经存在的方法的方式。默认方法是接口中的一种新特性，它允许在接口中定义具有默认实现的方法。这样可以向已有的接口添加新的方法，而不会破坏实现该接口的类的兼容性。它提供了一种更安全和优雅的方式来处理可能出现空指针异常的情况，避免了频繁的null检查。它可以对集合进行过滤、映射、排序等操作，还支持并行处理，从而提高了代码的可读性和性能。java基础之java8新特性-默认方法-CSDN博客。
Java基础知识面试题（2020最新版）
热门推荐
ThinkWon的博客
02-19 130万+
文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性？原理是什么Java语言有哪些特点什么是字节码？采用字节码的最大好处是什么什么是Java程序的主类？应用程序和小程序的主类有何不同？Java应用程序与小程序之间有那些差别？Java和C++的区别Oracle JDK 和 OpenJDK 的对比基础语法数据类型Java有哪些数据类型switc...
Java学习--JDK8新特性
qq_41971768的博客
07-09 1211
JDK8新特性前言参考目录 前言 说来惭愧，一直在使用JDK8却并不了解其中新的特性，甚至于自己都没有使用到过。惭愧啊！！！ 写这篇博文的目的在于自己学习所用，博文将参考多处文章进行理解后书写。因此，本文会将参考目录放在前面，有需要的可以直接前往学习。 参考目录 文章标题 作者 发表时间 文章地址 从Java5基础开始初识Lambda表达式——走进Java Lambda(一) lumence 2014-11-13 18:49:49 here Java 8 新特性总结 Snailc
Java-JDK8新特性总结-接口方法/Lambda/方法引用/Optional
07-12
总结JDK8新特性，内容言简意赅，突出重点 内容：包括接口中的方法/Lambda/方法引用/Optional/函数式接口 适合人群：有一定编程基础及Java基础的伙伴 使用场景：开发和面试题中都会用到，开发中合理运用Java 8新特性...
Java零基础 - Java语言特性简介.md
08-11
本文档介绍了Java语言的一些基本特性和常见用法，并附带了一个简单的Java示例代码。 内容概要 本文档涵盖以下内容： Java语言的面向对象编程特性 Java的跨平台性和内存管理机制 Java的异常处理机制 一个简单的Java...
大学课程讲义-Java基础-高级类特性.pptx
08-14
大学课程讲义_Java基础_高级类特性.pptx
Java基础－漫谈EJB在Java中的应用
02-04
它是为了实现嵌入式的消费类电子产品应用而产生的，它的作者是JamesGosling.EdFrank，PatrickNaughton，JonathanPayne，ChrisWarth在随后的几年时间中为Java语言加入了大量的特性，并把Java语言的目标做了一个重新的...
java8 新特性
02-28
介绍了Java 8 这个里程碑版本的新特性，包括Lambdas、流和函数式编程。有了函数式的编程 特性，可以让代码更简洁，同时也能自动化地利用多核硬件。全书分四个部分：基础知识、函数式数据处理、 高效Java 8 编程和...
Java语法基础-面试专题及答案
01-28
11.Java 面向对象编程三大特性: 封装 继承 多态 关于继承的3点 12.String StringBuffer 和 StringBuilder 的区别是什么 String 为什么是不可变的 可变性、线程安全性的研究 13.自动装箱与拆箱 14.在一个静态方法内...
Java零基础-多态.md
08-10
建议读者在阅读前具备Java的基础知识，包括类、对象、方法和继承等概念。 在阅读过程中，尝试编写简单的Java程序，体验多态的效果，并观察父类引用指向子类对象时的行为变化。 建议通过阅读相关的Java教材或搜索资料...
Java零基础-final关键字.md
08-10
建议读者在阅读前具备Java的基础知识，包括类、对象、方法和变量等概念。 在阅读过程中，尝试编写简单的Java程序，体验final关键字的作用，并观察final变量和final方法的特性。 建议通过阅读相关的Java教材或搜索...
深入java虚拟机--jvm高级特性与最佳实践 pdf
08-06
《深入java虚拟机--jvm高级特性与最佳实践》是一本关于Java虚拟机（JVM）的专业著作。该书以深入全面的方式介绍了JVM的高级特性和最佳实践。 在该书中，作者首先介绍了Java虚拟机的基础知识，包括JVM的结构、运行时数据区域以及垃圾回收机制等。然后，作者讲解了JVM的优化技术，包括即时编译器、逃逸分析以及编译器与解释器的混合模式等。这些内容有助于开发者理解JVM内部的工作原理，并能够优化代码的性能。 此外，该书还介绍了Java内存模型（JMM）和并发编程中的相关内容。作者详细解释了JMM的规范和特性，以及如何正确地进行线程同步和并发编程。这对于开发高效、稳定的多线程应用程序至关重要。 除了讲解JVM的基础知识和优化技术，该书还提供了一些最佳实践和常见问题的解决方法。例如，作者分享了如何优化Java应用程序的性能、如何排查和解决内存泄漏问题，以及如何进行JVM的调优等。 总之，《深入java虚拟机--jvm高级特性与最佳实践》是一本系统全面的关于JVM的专业著作，适合那些希望深入了解JVM内部工作原理和开发高效、稳定Java应用程序的开发者阅读。阅读该书可以帮助开发者更好地理解JVM的高级特性，并应用到实际开发中，从而提升程序的性能和稳定性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值