精华内容
下载资源
问答
  • 今天读博客时看到这样一段代码: //遍历集合 Set<String> keys = prop.stringPropertyNames(); for (String key : keys) { ...这里的冒号是什么意思了?就百度了一下,原来是遍历集合的意思,Rando

    今天读博客时看到这样一段代码:

    //遍历集合
    Set<String> keys = prop.stringPropertyNames();
    for (String key : keys) {
        //通过键 找值
        //prop.get(key)
        String value = prop.getProperty(key);
        System.out.println(key+"==" +value);
    }
    

    这里的冒号是什么意思了?就百度了一下,原来是遍历集合的意思,RandomWrite的博文里写的清晰明了,这里记录学习一下。
    点击:原文链接
    1:遍历集合

    String[] abc=new String[3]{"a","b","c"};
    for(String str:abc){
         System.out.println(str);
         }//这个地方的意思就是遍历abc集合,取出每个元素赋值给str
    

    2:三元运算符boolean?a:b

    int a=1;
    int b=3;
    int i=a>b?3:1;//如果a>b那么i=3,否则i=1
    

    3:跳转标记

    outer:for(int i=0;i<5;i++){
              for(int i=0;i<5;i++){
                   if(i==3){
                         continue outer;
                   }
               }
           }//这个地方就是跳转标识,里层循环continue直接跳到外层循环,继续执行外层循环。
    

    4:switch中用到

    switch(i){
    case 1:operate;break;
    case 2:operate;break;
    case 3:operate;break;
    ...//当i等于下面的值时执行后面的操作,然后break跳出,若果没有就一直往下索引。
    
    展开全文
  • java8 lambda 内部接口需要@FunctionalInterface这个注解,这个注解是一个说明性质的注解,被@FunctionalInterface注解的接口只能由一个抽象方法,@FunctionalInterface只能用于注解接口而不能用在c

    1.说明

    之前没用过::这个东西,今天看flink的时候发现官网有个例子用到了这个符号, 本着求知欲去百度查了一番,没找到能说到我心里去的解释,本着求知欲的态度,我去了官网看了看. java ::

    2.先来说下@FunctionalInterface

    java8 lambda 内部接口需要@FunctionalInterface这个注解,这个注解是一个说明性质的注解,被@FunctionalInterface注解的接口只能由一个抽象方法,@FunctionalInterface只能用于注解接口而不能用在class以及枚举上.
    被@FunctionalInterface注解的符合规则的接口,可以用lambda表达式. 下面举一个例子:

    public class Main {
        public static void pr(String s){
            System.out.println(s);
        }
        public static void main(String[] args) throws Exception {
    
            List<String> list = Arrays.asList("aaaa", "bbbb", "cccc");
            list.forEach(s -> System.out.println(s));
    
        }
    }
    所以说,@FunctionalInterface用于lambda样式说明.
    

    3. 下面来讲讲这个 "::"是干嘛的

    "::"官网对这个符号的解释是方法引用,也就是引用一个方法的意思,英文名称Method References
    lambda expressions 可以用来创建一匿名的方法, 这个匿名的方式你需要自己实现.

       1. list.forEach(new Consumer<String>() {
                @Override
                public void accept(String s) {
                    System.out.println(s);
                }
            });
       2. list.forEach(s -> System.out.println(s));
    
    上面两种写法是一样的,下面就是lambda表达式.
    

    上面说了lambda表达式你需要自己实现,但是有些时候这不是必要的,比如你的项目里某个地方存在了一个符合当前逻辑的lambda表达式的方法, 那么我是否可以直接拿来用?, 答案是可以, 程序追求的就是不重复极简的思想, 既有则拿来用即可,为什么还要自己实现呢. Method References 就是用来做这件事的.
    在看下面的例子之前读者需要知道java 比较器,否则看不懂代码.

    4. 建立一个Person类

    public class Person implements Comparable<Person>{
        public String name;
        public int age;
    
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public static int compareByAge(Person a, Person b) {
            return a.compareTo(b);
        }
    
        @Override
        public int compareTo(Person o) {
            if (this.age > o.age){
                return -1;
            }else{
                return 1;
            }
        }
    }
    

    4:构建多个person对象,放入数组中,然后对数组中的person重新排序

    public class Test {
    
        //编写Comparator,Person的age
        private static final Comparator<Person> COMPARATOR = new Comparator<Person>() {
            public int compare(Person a, Person b) {
                return a.compareTo(b);//运用User类的compareTo方法比较两个对象
            }
        };
    
        public static void main(String[] args) {
            Person one = new Person("张三",50);
            Person two = new Person("李四",100);
            ArrayList<Person> array = new ArrayList<>();
            array.add(one);
            array.add(two);
            Collections.sort(array,COMPARATOR);
            System.out.println(array);
        }
    }
    //输出结果:
    //[Person{name='李四', age=100}
    //Person{name='张三', age=50}]
    

    仔细看上面的代码,重点在Collections.sort(array,COMPARATOR);这一行,sort接收两个参数,第一个是要被排序的数组,第二个是一个比较器对象Comparator,其源码如下,我只粘贴了必要的部分.

    **@FunctionalInterface**
    public interface Comparator<T> {
        int compare(T o1, T o2);
    }
    

    @FunctionalInterface我们知道,被这个注解修饰的接口可以用lambda表达式的.

    所以我们将class Test改成下面的样子:

    public class Test {
        public static void main(String[] args) {
            Person one = new Person("张三",50);
            Person two = new Person("李四",100);
            ArrayList<Person> array = new ArrayList<>();
            array.add(one);
            array.add(two);
            Collections.sort(array, (a, b) -> a.compareTo(b)); 
            System.out.println(array);
        }
    
    }
    

    注意:下面是lambda写法,和正常传统写法

    Collections.sort(array, (a, b) -> a.compareTo(b));
    和下面的等效
    Collections.sort(array, new Comparator() {
    @Override
    public int compare(Person a, Person b) {
    return a.compareTo(b);
    }
    });

    5:揭秘 "::"符号

    到这里其实我们上面的功能已经完成了,我们来分析一下代码.
    1:构造了两个对象
    2:把对象放入了数组
    3:Collection.sort(array,Comparator<T>) 对数组进行排序

    关键点在于:Comparator<T> 比较器,它是一个被@FunctionalInterface修饰的接口,我们一般成为函数式接口.
    因此,Collection.sort(array,Comparator<T>) ,对于第二个参数Comparator<T>,我们可以传入一个匿名实现类,然后实现里面的 int compare(T o1, T o2) 方法,也可以写成lambda表达式的样子,到这里如果你都懂了,那么接下来就好说了,如果没明白,回头接着看,相信自己骚年. 下面我们重点看lambda方式的写法,这和"::"息息相关

    Collections.sort(array, (a, b) -> a.compareTo(b));

    1. **(a, b) -> a.compareTo(b)**这个其实就是匿名函数, 该函数的参数分别是Person a, Person b
    2. a.compareTo(b) 是该匿名函数的逻辑,
      也即是说我们写出来的这个匿名函数有两个参数,以及一个调用compareTo的函数体,到这里其实结束了,一开始我们就说了,符号"::"的意义就是用一个已经存在的函数代替我们lambda表达式中的函数体,只要这个存在的函数和lambda函数体的函数格式一致就行了. 格式其实就是参数个数,和参数类型下面是新的class Test揭示了答案
    public class Test {
    
    
    
        public static void main(String[] args) {
            Person one = new Person("张三",50);
            Person two = new Person("李四",100);
            ArrayList<Person> array = new ArrayList<>();
            array.add(one);
            array.add(two);
            Collections.sort(array, Person::compareByAge);//写法一
         // Collections.sort(array, one::entyMethod);//写法二
    
           System.out.println(array);
        }
    }
    附官网的一句话:
    Because this lambda expression 
    invokes an existing method, 
    you can use a method reference 
    **instead of** a lambda expression
    
     Collections.sort(array, Person::compareByAge);
     Collections.sort(array, one::entyMethod);
     这两种写法都是可行的.
    

    6.0 方法引用的支持如下

    在这里插入图片描述
    我们上面讲了静态方法,和类方法的代替方式,至于其他的这里不讲了,主要是我要去吃饭了.

    展开全文
  • java运算符

    千次阅读 2019-04-18 11:54:48
    java运算符运算符分类**运算符指明对操作数的运算方式。组成表达式的Java操作符有很多种。**1.单目2.双目3.三目1.算数运算符1.算数运算符 运算符分类 运算符指明对操作数的运算方式。组成表达式的Java操作符有很多...

    运算符分类

    运算符指明对操作数的运算方式。组成表达式的Java操作符有很多种。

    • 运算符按照其要求的操作数数目来分,可以有单目运算符、双目运算符和三目运算符,它们分别对应于1个、2个、3个操作数。
    • 运算符按其功能来分,有算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符和其他运算符。

    1.单目

    • 单目:~(按位取反)、! (取非)、-(负号运算符)、 ++(自增)、 - -(自减)

    2.双目

    • 双目 + - * / %(取余)

    3.三目

    • 三目:a>b?true:false 说明:当a大于b的时候,为true(也就是冒号之前的值),否则为false;这整个运算符包括一个关系运算符(可以是“>”"<""!="等等),一个“?”,一个“:”,冒号前后需要有两个表达式或者是值或者是对象。

    1.算数运算符

    • 加 +
    • 减 -
    • 乘 *
    • 除 /

    整数做除运算时只能求商

    • 取模 %
    • 与 &
    按位将参与运算的数字转换为二级制数,相同位数进行与运算,全1为1,否则为0
    System.out.println( 5 & 8);//结果为0
    /*
     *0101   5
     *1000   8
     *0000   0
     */
    
    • 或 |
    将参与运算的数字转换为二级制数,相同位数进行或运算,有1则1,否则为0
    System.out.println(19 | 10);//结果为27
    		/*
    		 * 10011	19
    		 * 01010	10
    		 * 11011	27
    		 */
    
    • 异或 ^
    将参与运算的数字转换为二级制数,相同位数进行异或运算,不同为1,否则为0
    System.out.println(19 ^ 10);//结果为25
    		/*
    		 * 10011	19
    		 * 01010	10
    		 * 11001	25
    		 */
    

    2.关系运算符

    运算的结果为boolean类型 (true或fales)
    
    • 等于符号:==
    • 不等于符号:!=
    • 大于符号:>
    • 小于符号:<
    • 大于等于符号:>=
    • 小于等于符号:<=
    • ! 取反

    3.逻辑运算符

    运算结果为boolean类型(true或fales)

    • 与 &
    • 或 |
    • 异或 ^
    • 短路运算符
      • 短路与 &&
        若&&左边的表达式为false则不再执行右边的表达式
      • 短路或||
        若||左边的表达式为true则不再执行右边的表达式

    4.赋值运算符

    = 等号右边赋值给等号左边

    • +=
    a += b 等同于 a = a+b 
    
    • -=
    • *=
    • /=
    • %=
    • &=
    • |=
    • ^=

    5.自增与自减

    • ++ i 先自增,再运算
    • i ++先运算,再自增
    • –i 先自减,再运算
    • i - - 先运算,再自增

    6.位运算

    只能进行整数运算,将符号左边的数转换为二级制数,移动符号右边的位数
    
    • 带符号右移

    int a = 10;
    		System.out.println(a >> 2 );
    		/*
    		 * 1010 10
    		 * 0010 2
    		 */
    
    • <<带符号左移
    • (>>>无符号右移)

    5.运算符优先级

    在这里插入图片描述

    展开全文
  • 深入理解Java冒号(::)运算符的使用

    万次阅读 多人点赞 2019-02-20 15:12:53
    英文:double colon,双冒号(::)运算符Java 8中被用作 方法引用(method reference) ,方法引用是与lambda表达式相关的一个重要特性。它提供了一种不执行方法的方法。为此,方法引用需要由兼容的函数接口组成的...

    Jdk8中有好多新的特性,比如引入Lambda,简化代码的书写等等

    我们先看一个关于Lambda的使用

    /**
    * 输出list
     */
    @Test
    public void test() {
    	String[] array = {"aaaa", "bbbb", "cccc"};
    	List<String> list = Arrays.asList(array);
    	
    	//Java 7 
    	for(String s:list){
    		System.out.println(s);
    	}
    	
    	//Java 8
    	list.forEach(System.out::println);
    }
    

    其中list.forEach(System.out::println);就是Java 8中的Lambda写法之一, 有没有特别注意到输出语句跟我们平时写的syso语句不一样,常规输出语句是这样的:

    System.out.println("流浪地球拍的不错哦!");
    

    这里面使用到了::, 有点意思,来认识一下这个新东西!

    双冒号(::)

    英文:double colon,双冒号(::)运算符在Java 8中被用作方法引用(method reference),方法引用是与lambda表达式相关的一个重要特性。它提供了一种不执行方法的方法。为此,方法引用需要由兼容的函数接口组成的目标类型上下文。

    Method References
    You use lambda expressions to create anonymous methods. Sometimes, however, a lambda expression does nothing but call an existing method. In those cases, it’s often clearer to refer to the existing method by name. Method references enable you to do this; they are compact, easy-to-read lambda expressions for methods that already have a name.
    关于方法引用的描述,摘自oracle官网

    大致意思是,使用lambda表达式会创建匿名方法, 但有时候需要使用一个lambda表达式只调用一个已经存在的方法(不做其它), 所以这才有了方法引用!

    以下是Java 8中方法引用的一些语法:

    1. 静态方法引用(static method)语法:classname::methodname 例如:Person::getAge
    2. 对象的实例方法引用语法:instancename::methodname 例如:System.out::println
    3. 对象的超类方法引用语法: super::methodname
    4. 类构造器引用语法: classname::new 例如:ArrayList::new
    5. 数组构造器引用语法: typename[]::new 例如: String[]:new

    如果上的语法太枯燥,那就通过一些例子来加强对它的理解:

    静态方法语法使用例子:

    import java.util.Arrays;
    import java.util.List;
    
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    /**
     * 
     * @author zhoufy
     * @date 2019年2月20日 下午2:19:13
     */
    @RunWith(SpringJUnit4ClassRunner.class)
    @ComponentScan("com.zhoufy")
    public class Demo {
    	@Test
    	public void test() {
    		List<String> list = Arrays.asList("aaaa", "bbbb", "cccc");
    		
    		//静态方法语法	ClassName::methodName
    		list.forEach(Demo::print);
    	}
    	
    	public static void print(String content){
    		System.out.println(content);
    	}
    }
    

    类实例方法语法使用例子:

    import java.util.Arrays;
    import java.util.List;
    
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    /**
     * 
     * @author zhoufy
     * @date 2019年2月20日 下午2:19:13
     */
    @RunWith(SpringJUnit4ClassRunner.class)
    @ComponentScan("com.zhoufy")
    public class Demo {
    	@Test
    	public void test() {
    		List<String> list = Arrays.asList("aaaa", "bbbb", "cccc");
    		
    		//对象实例语法	instanceRef::methodName
    		list.forEach(new Demo()::print);
    	}
    	
    	public void print(String content){
    		System.out.println(content);
    	}
    }
    

    超类方法语法使用例子:

    import java.util.Arrays;
    import java.util.List;
    
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    
    
    /**
     * @author zhoufy
     * @date 2019年2月20日 下午2:41:38
     */
    @RunWith(SpringJUnit4ClassRunner.class)
    @ComponentScan("com.zhoufy")
    public class Example extends BaseExample{
    
    	@Test
    	public void test() {
    		List<String> list = Arrays.asList("aaaa", "bbbb", "cccc");
    		
    		//对象的超类方法语法: super::methodName 
    		list.forEach(super::print);
    	}
    }
    
    class BaseExample {
    	public void print(String content){
    		System.out.println(content);
    	}
    }
    

    类构造器语法使用例子:

    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    /**
     * 
     * @author zhoufy
     * @date 2019年2月20日 下午2:19:13
     */
    @RunWith(SpringJUnit4ClassRunner.class)
    @ComponentScan("com.zhoufy")
    public class Example {
    
    	@Test
    	public void test() {
    		InterfaceExample com =  Example::new;
    		Example bean = com.create();	
    		System.out.println(bean);
    	}
    }
    
    interface InterfaceExample{
    	Example create();
    }
    

    如果是带参数的构造器,示例如下:

    /**
     * @author zhoufy
     * @date 2019年2月20日 下午2:19:13
     */
    public class Example {
    	
    	private String name;
    	
    	Example(String name){
    		this.name = name;
    	}
    	
    	public static void main(String[] args) {
    		InterfaceExample com =  Example::new;
    		Example bean = com.create("hello world");
    		System.out.println(bean.name);
    	}
    }
    interface InterfaceExample{
    	Example create(String name);
    }
    

    这里需要特别注意的是:Example 类并没有implements InterfaceExample接口哦!!!

    数组构造器语法使用例子:

    import java.util.function.Function;
    
    /**
     * @author zhoufy
     * @date 2019年2月20日 下午2:19:13
     */
    public class Example {
    	public static void main(String[] args) {
    		Function <Integer, Example[]> function = Example[]::new;
    		Example[] array = function.apply(4);	//这里的4是数组的大小
    		
    		for(Example e:array){
    			System.out.println(e);	//如果输出的话,你会发现会输出4个空对象(null)
    		}
    	}
    }
    

    这里是借用jdk自带的java.util.function.Function类实现的,如果想要自定义接口

    
    /**
     * 
     * @author zhoufy
     * @date 2019年2月20日 下午2:19:13
     */
    public class Example {
    	
    	public static void main(String[] args) {
    		Interface <Integer, Example[]> function = Example[]::new;
    		Example[] array = function.apply(4);	//这里的4是数组的大小
    		
    		for(Example e:array){
    			System.out.println(e);
    		}
    	}
    }
    
    @FunctionalInterface
    interface Interface<A, T>{
    	T apply(A a); 
    }
    
    展开全文
  • java运算符_Java运算符

    2020-07-29 07:16:31
    java运算符 Java运算符 (Java Operators) Operator is a symbol which tells to the compiler to perform some operation. Java provides a rich set of operators do deal with various types of operations. ...
  • java8 双冒号运算符::

    万次阅读 2017-05-14 10:53:42
    前面的章节我们提及到过双冒号运算符,双冒号运算就是Java中的[方法引用],[方法引用]的格式是 类名::方法名 注意是方法名哦,后面没有括号“()”哒。为啥不要括号,因为这样的是式子并不代表一定会调用这个方法。...
  • 一直搞不明白双冒号运算要怎么使用,今天在《Java8实战》中看到相关内容,讲解的比较详细,参考这篇文章,总结一下,希望能帮助大家,如果有兴趣,也可以直接看《Java8实战》这本书 双冒号运算就是Java中的方法引用...
  • } 二、双冒号(::)运算符冒号运算符java8中被用作方法引用, 方法引用是与lambda表达式相关的一个重要特性。它提供了一种不执行方法的方法 1. 使用场景 静态方法引用语法:classname::methodname,例如:...
  • Java 8中,双冒号(::)运算符称为方法引用。 请参考以下示例: 匿名类打印列表。 List<String> list = Arrays.asList("node", "java", "python", "ruby"); list.forEach(new Consumer<String>() ...
  • java运算符总结

    2018-04-02 21:43:34
    运算符的优先级及注意事项: 1. []、.、() []用于数组 .方法调用 ()复合运算时可以改变既定的优先级 2. !、~、++、– !逻辑非,只能用于boolean型值取反的意思 ~按位非,输入0返回1,输入1返回0 ++自增...
  • java运算符及解释

    2020-10-13 20:03:51
    运算符分类 package com.zhiyou100; // 运算符 operator public class Demo01_Operator { public static void main(String[] args){ /* 运算符 程序中一种很特殊的符号 连接程序中需要参与运算的变量(前提条件是...
  • JAVA运算符

    2017-08-19 11:18:18
    组成表达式的Java操作符有很多种。运算符按照其要求的操作数数目来分,可以有单目运算符、双目运算符和三目运算符,它们分别对应于1个、2个、3个操作数。运算符按其功能来分,有算术运算符、赋值运算符、关系运算符...
  • java冒号(:)的用法

    万次阅读 多人点赞 2018-01-04 15:37:38
    ...你见到的冒号是在哪个地方的,java中不同的地方的冒号的作用是不同的,例如: 1、 String[] abc = new String[3]{"a","b","c"}; for (String str : abc){  System.out.println(str);
  • Java冒号的用法

    2021-01-02 10:48:24
    1. 三目运算符 “?:” “式子A?式子B:式子C”:当A成立时,得到式子B的结果;当式子A不成立时,得到式子C的结果。 2.switch-case的分支标记 ...... System.out.println("凉风有信,秋月无边。打二字"); ...
  • Java-java冒号(:)的用法

    千次阅读 2019-03-28 13:50:36
    转 你见到的冒号是在哪个地方的,java中不同的地方的冒号的作用是不同的,例如:
  • Java运算符重写问题

    千次阅读 2013-01-03 15:16:24
    系统已经有的运算符很多时候已经满足使用,但根据具体情况有时需要有特殊的比较,原有的操作已经不满足,需要重写。 比如系统 equals 操作符,通常可用于比较两个字符串是否相等, String a = "abc"; String b = ...
  • 一、Java运算符总结: 1.算术运算符: ①单目:+(取正),-(取负), ++(自增1), - -(自减1); ②双目:+ - * / %(取余)(+还可以连接字符串); ③三目:a>b?true:false 说明:当a大于b的时候,为true...
  • Java,是由Sun Microsystems公司于1995年5月推出的Java程序设计语言和Java平台的...介绍Java运算符,以及区分JAVA语言与C语言中运算符的差异。 基本信息 中文名称 JAVA语言运算符 推出 Sun Microsyste..
  • Java运算符

    2014-10-16 14:56:50
    Java运算符 Java提供了丰富的运算符环境。Java有4大类运算符:算术运算、位运算、关系运算和逻辑运算。Java还定义了一些附加的运算符用于处理特殊情况。本章将描述Java所有的运算符,而比较运算符instanceof将...
  • Java运算符可分为 4 类:算术运算符、关系运算符、逻辑运算符和位运算符Java 中的语句有多种形式,表达式就是其中的一种形式。表达式是由操作数与运算符所组成的。操作数可以是常量、变量,也可以是方法,而...
  • Java运算符详解

    2020-04-02 21:25:16
    目录一、算数运算符一元运算符二元运算符算术赋值运算符二、关系运算符三、逻辑运算符四、位运算符五、其他运算符六、运算符优先级 一、算数运算符 一元运算符 算术一元运算符一共有3个,分别是-、++和–。 示例...
  • Java 运算符

    2020-12-11 16:30:56
    目录Java 运算符Java 运算符分类1. 算数运算符2. 关系运算符3. 位运算符4. 逻辑运算符 Java 运算符 Java 运算符分类 1. 算数运算符 单目:~(按位取反)、! (取非)、-(负号运算符)、 ++(自增)、 - -(自减) ...
  • :: 双冒号运算符Java

    2019-07-04 18:55:21
    import java.util.Arrays; import java.util.HashMap; import java.util.List;...//双冒号运算就是Java中的[方法引用], // [方法引用]的格式是 // 类名::方法名 //例如 //表达式: //person -> person.getAge...
  • Java 中的 :: 使用方式 Repository: Author: GitHub Introduction: Author:杭州电子科技大学 唐涛 CreateTime:2020-6-22 03:30:04 UpdateTime:2020-6-22 04:27:18 Copyright: 唐涛 HOME | 首页 © 2020 Email: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,105
精华内容 4,042
关键字:

java运算符冒号

java 订阅