精华内容
下载资源
问答
  • 我是一个java新手,写了一段代码,有关:摄氏度和华氏度之间的互相转化package method;import method.HuaShe;public class TestCToFandFToC {public static void main(String[] args){System.out.println("摄氏 华氏...

    我是一个java新手,写了一段代码,有关:摄氏度和华氏度之间的互相转化

    package method;

    import method.HuaShe;

    public class TestCToFandFToC {

    public static void main(String[] args){

    System.out.println("摄氏 华氏 华氏 摄氏");

    for(int i = 1;i <= 10;i++){

    double she1 = 40.0;

    double hua1 = cToF(she1);

    double hua2 = 120.0;

    double she2 = fToC(hua2);

    System.out.println(she1 + " " + hua1 + " " + hua2 + " " + she2);

    she1 -= 1;

    hua2 -= 10;

    }

    }

    }

    //问题:为何出现错误?我import了啊!!

    其中cToF和fToC是我另外写的函数,但是没有和上面代码段放在一起,而是新建了一个:package method;

    public class HuaShe {

    static double cToF(double c){

    double ft = (9.0 / 5) * c + 32;

    double f = (int)(ft * 100) / 100.0;

    return f;

    }

    //--------------------------------------

    static double fToC(double f){

    double ct = (f - 32) / (9.0 / 5);

    double c = (int)(ct * 100) / 100.0;

    return c;

    }

    }

    然后运行主函数时

    cToF(she1);和fToC(hua2);报错:

    The method cToF(double) is undefined for the type TestCToFandFToC

    为什么会这样???

    谢谢!

    展开全文
  • 前言方法引用是用来直接访问类或者实例的已经存在的方法或者构造方法。方法引用提供了一种引用而不执行方法的方式,它需要由兼容的函数式接口构成的目标类型上下文。计算时,方法引用会创建函数式接口的一个实例。当...

    前言

    方法引用是用来直接访问类或者实例的已经存在的方法或者构造方法。方法引用提供了一种引用而不执行方法的方式,它需要由兼容的函数式接口构成的目标类型上下文。计算时,方法引用会创建函数式接口的一个实例。

    当Lambda表达式中只是执行一个方法调用时,不用Lambda表达式,直接通过方法引用的形式可读性更高一些。方法引用是一种更简洁易懂的Lambda表达式。

    注意:方法引用是一个Lambda表达式,其中方法引用的操作符是双冒号"::"。

    在Java8中,使用方法引用非常简单,如String::isEmpty,但无法使用它否定的方法引用。本文内容即如何解决此问题使得我们能够更加全面地使用方法引用。

    首先看一个使用方法引用的例子:

    Stream.of("A", "", "B").filter(String::isEmpty).count()

    上面代码的输出为1,即空字符串的数目。如果我们想要获取非空字符串的数目,就不能直接使用方法引用了。

    Stream.of("A", "", "B").filter(s -> !s.isEmpty()).count()

    Java8中的Predicate,有predicate.negate()可以转换为断言的否定形式,但String::isEmpty却无法这么做(String::isEmpty.negate()或者!String::isEmpty )。因为方法引用并不是一个lambda或者函数接口,它能够被解析为一个或者多个函数接口。如,String::isEmpty至少可以被解析如下:

    Predicate

    Function

    为了解决上述的问题,我们可以通过某种机制显式地将方法引用转换为一个函数接口:

    public static Predicate as(Predicate predicate) {

    return predicate;

    }

    通过使用一个静态方法,接受方法引用参数,返回一个函数接口,即可实现方法引用到函数接口的转换。接着,我们就可以使用方法引用来实现上面例子中的获取非空字符串的数目。

    Stream.of("A", "", "B").filter(as(String::isEmpty).negate()).count();

    进一步还能使用各种组合的Predicate。

    .filter(as(String::isEmpty).negate().and("A"::equals))

    由于一个方法引用可能会被解析为多种函数接口,因此如果我们实现很多参数不同的as方法,那么很容易造成混淆。更好的方式则是在方法名中加入函数参数的类型来区分。

    import java.util.function.*;

    public class FunctionCastUtil {

    public static BiConsumer asBiConsumer(BiConsumer biConsumer) {

    return biConsumer;

    }

    public static BiFunction asBiFunction(BiFunction biFunction) {

    return biFunction;

    }

    public static BinaryOperator asBinaryOperator(BinaryOperator binaryOperator) {

    return binaryOperator;

    }

    public static BiPredicate asBiPredicate(BiPredicate biPredicate) {

    return biPredicate;

    }

    public static BooleanSupplier asBooleanSupplier(BooleanSupplier booleanSupplier) {

    return booleanSupplier;

    }

    public static Consumer asConsumer(Consumer consumer) {

    return consumer;

    }

    public static DoubleBinaryOperator asDoubleBinaryOperator(DoubleBinaryOperator doubleBinaryOperator) {

    return doubleBinaryOperator;

    }

    public static DoubleConsumer asDoubleConsumer(DoubleConsumer doubleConsumer) {

    return doubleConsumer;

    }

    public static DoubleFunction asDoubleFunction(DoubleFunction doubleFunction) {

    return doubleFunction;

    }

    public static DoublePredicate asDoublePredicate(DoublePredicate doublePredicate) {

    return doublePredicate;

    }

    public static DoubleToIntFunction asDoubleToIntFunction(DoubleToIntFunction doubleToIntFunctiontem) {

    return doubleToIntFunctiontem;

    }

    public static DoubleToLongFunction asDoubleToLongFunction(DoubleToLongFunction doubleToLongFunction) {

    return doubleToLongFunction;

    }

    public static DoubleUnaryOperator asDoubleUnaryOperator(DoubleUnaryOperator doubleUnaryOperator) {

    return doubleUnaryOperator;

    }

    public static Function asFunction(Function function) {

    return function;

    }

    public static IntBinaryOperator asIntBinaryOperator(IntBinaryOperator intBinaryOperator) {

    return intBinaryOperator;

    }

    public static IntConsumer asIntConsumer(IntConsumer intConsumer) {

    return intConsumer;

    }

    public static IntFunction asIntFunction(IntFunction intFunction) {

    return intFunction;

    }

    public static IntPredicate asIntPredicate(IntPredicate intPredicate) {

    return intPredicate;

    }

    public static IntSupplier asIntSupplier(IntSupplier intSupplier) {

    return intSupplier;

    }

    public static IntToDoubleFunction asIntToDoubleFunction(IntToDoubleFunction intToDoubleFunction) {

    return intToDoubleFunction;

    }

    public static IntToLongFunction asIntToLongFunction(IntToLongFunction intToLongFunction) {

    return intToLongFunction;

    }

    public static IntUnaryOperator asIntUnaryOperator(IntUnaryOperator intUnaryOperator) {

    return intUnaryOperator;

    }

    public static LongBinaryOperator asLongBinaryOperator(LongBinaryOperator longBinaryOperator) {

    return longBinaryOperator;

    }

    public static LongConsumer asLongConsumer(LongConsumer longConsumer) {

    return longConsumer;

    }

    public static LongFunction asLongFunction(LongFunction longFunction) {

    return longFunction;

    }

    public static LongPredicate asLongPredicate(LongPredicate longPredicate) {

    return longPredicate;

    }

    public static LongSupplier asLongSupplier(LongSupplier longSupplier) {

    return longSupplier;

    }

    public static LongToDoubleFunction asLongToDoubleFunction(LongToDoubleFunction longToDoubleFunction) {

    return longToDoubleFunction;

    }

    public static LongToIntFunction asLongToIntFunction(LongToIntFunction longToIntFunction) {

    return longToIntFunction;

    }

    public static LongUnaryOperator asLongUnaryOperator(LongUnaryOperator longUnaryOperator) {

    return longUnaryOperator;

    }

    public static ObjDoubleConsumer asObjDoubleConsumer(ObjDoubleConsumer objDoubleConsumer) {

    return objDoubleConsumer;

    }

    public static ObjIntConsumer asObjIntConsumer(ObjIntConsumer objIntConsumer) {

    return objIntConsumer;

    }

    public static ObjLongConsumer asObjLongConsumer(ObjLongConsumer objLongConsumer) {

    return objLongConsumer;

    }

    public static Predicate asPredicate(Predicate predicate) {

    return predicate;

    }

    public static Supplier asSupplier(Supplier supplier) {

    return supplier;

    }

    public static ToDoubleBiFunction asToDoubleBiFunction(ToDoubleBiFunction toDoubleBiFunction) {

    return toDoubleBiFunction;

    }

    public static ToDoubleFunction asToDoubleFunction(ToDoubleFunction toDoubleFunction) {

    return toDoubleFunction;

    }

    public static ToIntBiFunction asToIntBiFunction(ToIntBiFunction toIntBiFunction) {

    return toIntBiFunction;

    }

    public static ToIntFunction asToIntFunction(ToIntFunction ioIntFunction) {

    return ioIntFunction;

    }

    public static ToLongBiFunction asToLongBiFunction(ToLongBiFunction toLongBiFunction) {

    return toLongBiFunction;

    }

    public static ToLongFunction asToLongFunction(ToLongFunction toLongFunction) {

    return toLongFunction;

    }

    public static UnaryOperator asUnaryOperator(UnaryOperator unaryOperator) {

    return unaryOperator;

    }

    private FunctionCastUtil() {

    }

    }

    Stream.of("A", "", "B").filter(asPredicate(String::isEmpty).negate()).count();

    总结

    以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作能带来一定的帮助,如果有疑问大家可以留言交流,谢谢大家对脚本之家的支持。

    展开全文
  • Java8 中引入方法引用新特性,用于简化应用对象方法的调用, 方法引用是用来直接访问类或者实例的已经存在的方法或者构造方法。 方法引用提供了一种引用而不执行方法的方式,它需要由兼容的函数式接口构成的目标类型...

    Java8 中引入方法引用新特性,用于简化应用对象方法的调用, 方法引用是用来直接访问类或者实例的已经存在的方法或者构造方法。 方法引用提供了一种引用而不执行方法的方式,它需要由兼容的函数式接口构成的目标类型上下文。

    计算时,方法引用会创建函数式接口的一个实例。 当 Lambda 表达式中只是执行一个方法调用时,不用 Lambda 表达式,直接通过方法引用的形式可读性更高一些。方法引用是一种更简洁易懂的 Lambda 表达式。

    一、语法

    目标引用:方法名称

    目标引用:类名、实例对象

    方法名称:实例方法名、静态方法名

    等效 Lambda 的方法引用示例如下:84cc8e730bc3ef12c4f7c21e7afde1a8.png

    二、方法引用分类

    Java8 中对于方法引用主要分为四大类:构造器引用

    Class::new

    静态方法引用

    Class::static_method

    实例对象方法引用

    Instance::method

    特定类型任意对象的实例方法引用

    Class:: method

    三、构造器引用

    语法是Class::new,或者更一般的Class< T >::new实例如下:

    /**

    * Lambda 表达式 实例化User 对象

    */

    Supplier s01 =()->new User();

    Function  f01 = (id)->{

    return new User(id);

    };

    f01.apply(2019);

    BiFunction bf01 = (id,uname)->{

    return new User(id,uname);

    };

    bf01.apply(2019,"admin");

    //方法引用 等价写法

    Supplier s02 = User::new;

    Function f02 = User::new;

    f02.apply(2019);

    BiFunction bf02 = User::new;

    bf02.apply(2019,"admin");

    四、静态方法引用

    语法是Class::static_method,实例如下:

    // 判断字符串是否为空串

    Function f03 = (str)-> StringUtils.isBlank(str);

    System.out.println(f03.apply(""));

    // Base64 对输入字符串执行编码操作

    Supplier s01 = ()->Base64.getEncoder();

    s01.get().encodeToString("java8 is so easy!!!".getBytes());

    Function f04 = StringUtils::isBlank;

    System.out.println(f04.apply(""));

    Supplier s02 = Base64::getEncoder;

    s02.get().encodeToString("java8 is so easy!!!".getBytes());

    五、实例对象方法引用

    语法是Instance::method ,此时引用方法时必须存在实例,示例如下:

    //方法引用构造User 对象

    BiFunction bf02 = User::new;

    User u02 = bf02.apply(2019,"admin");

    // 调用实例对象方法

    Supplier s01 = ()->u02.getUserName();

    System.out.println(s01.get());

    // 方法引用 等价Lambda 写法

    Supplier s02 = u02::getUserName;

    System.out.println(s02.get());

    六、特定类型任意对象的实例方法引用

    语法是Class:: method,第四种类型比较特殊,这里特定类型指多个对象类型说的,对象类型属于同一类类型通常是一个集合,元素类型一致,此时可以对类方法实现引用。

    /**

    准备测试数据

    **/

    List list= Arrays.asList(10,2,30,5,8,10,60,99,101);

    List emails = Arrays.asList("126@126.com"," ","","java8@163.com");

    Goods g01=new Goods(1,"小米9",1789,200, BigDecimal.valueOf(2500));

    Goods g02=new Goods(2,"华为Mate20",5000,3000, BigDecimal.valueOf(7000));

    Goods g03=new Goods(3,"OPPO R17",2000,2827, BigDecimal.valueOf(1500));

    Goods g04=new Goods(4,"魅族 Note9",2000,1600, BigDecimal.valueOf(1600));

    Goods g05=new Goods(5,"一加6T",8000,5000, BigDecimal.valueOf(3500));

    List goods= Arrays.asList(g01,g02,g03,g04,g05);

    // Lambda 对集合list元素排序 list 存放整数元素

    list.sort((a1,a2)->a1-a2);

    // Lambda 对集合goods 按销量排序

    goods.sort((g1,g2)->g1.getSale()-g2.getSale());

    // 过滤邮箱集合空串

    emails.stream().filter((e) -> StringUtils.isNoneBlank(e))

    .collect(Collectors.toList());

    // 任意对象的实例方法引用 对集合list元素排序

    list.sort(Comparator.comparing(Integer::intValue));

    // 任意对象的实例方法引用 对集合goods 按销量排序

    goods.sort(Comparator.comparing(Goods::getSale));

    // 过滤邮箱集合空串

    emails.stream().filter(StringUtils::isNoneBlank).collect(Collectors.toList());

    七、方法引用应用

    方法引用简化了 Lambda 表达式书写方式,对于函数式接口实现可以使用方法引用来替换 Lambda,当对 Lambda 掌握后使用方法引用时代码会变得更加简洁、自然 。

    展开全文
  • 大家都知道一个java应用项目可以打包成一个jar,当然你必须指定一个拥有main函数的main class作为你这个jar包的程序入口。具体的方法是修改jar包内目录META-INF下的MANIFEST.MF文件。比如有个叫做test.jar的jar包,...

    大家都知道一个java应用项目可以打包成一个jar,当然你必须指定一个拥有main函数的main class作为你这个jar包的程序入口。

    具体的方法是修改jar包内目录META-INF下的MANIFEST.MF文件。

    比如有个叫做test.jar的jar包,里面有一个拥有main函数的main class:test.someClassName

    我们就只要在MANIFEST.MF里面添加如下一句话:

    Main-Class: test.someClassName

    然后我们可以在控制台里输入java -jar test.jar即可以运行这个jar。

    但是我们这个项目需要引用其他第三方的jar包,在eclipse里面以项目jar包的形式引用了这个叫做some.jar的包,当时放在项目的lib子目录下,最后项目打包时把这个some.jar也打进来了,但是用java -jar执行这个test.jar的时候报找不到Class异常,原因就是jar引用不到放在自己内部的jar包。

    那怎么办?

    运行时将其加入classpath的方式行不行?就是在运行jar的同时加入classpath参数:

    java -classpath some.jar -jar test.jar

    这种方式应该能解决问题吧,试一下,还是不行。

    查了下资料,原来使用java -jar 命令运行jar包时classpath参数将会失效,所以,这种方式也不行。

    那该怎么引用其他的jar包呢,答案还是在这个目录META-INF下的MANIFEST.MF文件中。jar包引用其他jar包的信息必须在这个文件中声明。

    我们在MANIFEST.MF中添加如下代码:

    Class-Path: lib/some.jar

    lib是和test.jar同目录的一个子目录,test.jar要引用的some.jar包就在这里面。

    然后测试运行,一切正常!

    如果有多个jar包需要引用的情况:

    Class-Path: lib/some.jar lib/some2.jar

    每个单独的jar用空格隔开就可以了。

    总结:不管怎么样,只要想办法在执行test.jar之前把需要引用的jar导入classpath就可以。你甚至可以把需要引用的包都放到jre/lib/ext目录下,这样jvm一启动,这些包就加载了。

    展开全文
  • 我是一个java新手,写了一段代码,有关:摄氏度和华氏度之间的互相转化package method;import method.HuaShe;public class TestCToFandFToC {public static void main(String[] args){System.out.println("摄氏 华氏...
  • 引用(PhantomReference)强引用是我们在编程过程中使用的最简单的引用,如代码String s=”abc...弱引用使用java.lang.ref.WeakReference class 类来表示,你可以使用如下代码创建弱引用:代码如下:Counter counter ...
  • 如这个类:import java.util.*;...public class Info {Date date = null;java.sql.Date sqlDate = new java.sql.Date(date.getTime());public List getTimes(Integer in,String s){date = new Date(...
  • ```class Dog{public String name;public Dog() {}public Dog(String name) {this.name = name;}}```然后,我们试着创建一个Dog对象:```Dog dog=null; //1System.out.println(dog.name);dog=new Dog();//2```然后...
  • 我是一个java新手,写了一段代码,有关:摄氏度和华氏度之间的互相转化 -------------------------------------------------------------------------- package method; import method.HuaShe; public class ...
  • 事实证明它是所引用的类接口。怎么会是这样的呢?那是一个循环推理?如果不是的话,为什么这样定义它?在以前的 JDK 中,Class.newInstance()方法的定义返回Object,您很可能要将该返回类型强制转换为另一种类型:...
  • JAVA 泛型 - Class<T>

    2016-11-17 11:06:41
    JAVA 泛型 - Class 2012-02-29 10:50:36 分类: Java Class 类 Class 已经泛型化了,但是很多人一开始都感觉其泛型化的方式很混乱。Class 中类型参数 T 的含义是什么?事实证明它是所...
  • 有很多博客介绍Object obj=new Object();就是一个强引用; 垃圾回收器不会回收它?那么这个Object具体指的时什么啊? ...软引用跟弱引用在这两个类中怎么体现啊? 有知道的大神指点一下,谢谢
  • 我是Java的新手,我正在使用BlueJ.我在尝试编译时不断得到“Int not be dereferenced”错误,我不确定问题是什么.错误特别发生在我底部的if语句中,其中“equals”是一个错误,“int不能被解除引用”.希望得到一些帮助,...
  • 在idea删除了引用class怎么找回

    千次阅读 2016-04-23 10:37:25
    不知道怎么引用java.util包删除课 点击alt+enter不能添加包 gg了 后来发现点击alt+enter之后 然后java.util.date就不会自动提示了 然后点击删除就好了
  • 一、java基本数据类型 int a=1; int b=a; int b=3; a的值不会改变,因为a、b指的不是一个对象了。 二、String、Integer等类型 String a="abc"; String b=a; String b="test" a的值不会改变,因为...
  • Class文件中的常量池在Class文件结构中,最头的4个字节用于存储魔数Magic Number,用于确定一个文件是否能被JVM接受,再接着4个字节用于存储版本号,前2个字节存储次版本号,后2个存储主版本号,再接着是用于存放...
  • public class A{ ...程序中只有这2各类的class文件的2进制数据(2个byte[]),怎么使用classloader加载这2个类呢. 因为涉及到了A类需要B类 B类需要A类,如果使用简单的defineClass会出ClassNotFoundException异常.
  • Java怎么自定义类

    千次阅读 2019-03-24 16:53:27
    引言: java的类我们可以把他们分为两种:一种是Java中已经定义好的类如:Scanner,Random类还又一种是需要我们自己去定义的类,我们可以在类中定义多个方法和...然后在class引用 Scanner input=new Scanner(...
  • 在以后的工作中,如果没有很好的掌握这两种传递方式,那么就会带了一些意想不到的问题.如果要很好的掌握他们的,必须要对其...废话不说了:第一种:值传递方式: 举个简单的程序[java] view plaincopypublic class Init...
  • 背景新语言Kotlin已经抛弃了Java里的基本数据类型,而是采用引用类型去声明一个变量,那么怎么区分基本数据类型和引用类型呢?文字概念基本数据类型:byte、short、int、long、float、double、char、boolean引用类型...
  • java 四种引用方式

    2018-05-17 15:11:57
    JVM 肯定不会回收此对象,即使跑出OOM也不会回收,那怎么才能回收呢?置null 软引用:softRefenrence 在内存不足时才会被回收,可预防OOM问题,可用来做缓存,如网页缓存,图片缓存 例: public class...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 442
精华内容 176
关键字:

java怎么引用class

java 订阅