What are the methods of pattern matching and implicit conversion in Java Scala?

Pattern matching:

Pattern matching in Scala is equivalent to switch in Java

In Java We have a basic syntax consisting of switch and case default. In Scala, we have match and case. The role of default is replaced by case.

The basic syntax is as follows:

val a=10
    val b=20
    var c='+'
    c match {
      case '+'=> println(a+b)
      case '-'=> println(a-b)
      case _  =>println("错误的运算符")
    }

In Scala it is By default,

case _ is executed from this case to the next case, which means that none of the above situations are satisfied.

Pattern guard:

If you want to express data that matches a certain range , you need to add condition guards in pattern matching

(actually add if judgment in case)

 val x=3.153
    val value: Any = x match {
      case i: Double if i >= 0 => i
      case j: Double if j < 0 => -j
      case _ => "type illegal"
    }

Type matching:

When defining a function, the parameters are all objects The parent class Any

 def function(x:Any): Unit ={
      x match {
        case s:String =>println("字符串")
        case i:Int=>println("整数")
        case d:Double=>println("小数")
        case _ =>println("其他")
      }
    }

Object matching

The matching of objects is more complicated. The simple comparison is to compare the address values. The address values ​​​​of the two variables are definitely different

object Test_03MatchObject {
  def main(args: Array[String]): Unit = {
    val sss: person1 = person1("sss", 1)
  sss match {
    case person1("sss",1)=>println("victory")
    case _=>println("defite")
  }
  }
  class person1(val name: String,val age :Int){
  }
  object person1{
    def apply(name: String, age: Int): person1 = new person1(name, age)
    def unapply(arg: person1): Option[(String, Int)] =
      if (arg==null)
      {
        None
      }
      else{
        Some(arg.name,arg.age)
      }  }
}

Here we define the unapply method in object. The unapply method is equivalent to the reverse application of the apply method. The apply method creates an object in object, and the unapply method is an extraction method, which extracts the object of the operation (the incoming parameter is the object, Extract data according to the object and store it in Some, and compare it with your own incoming data) This method also does not need to write a method name like the apply method.

This method is mainly used to parse objects (matching objects)

Sample class:

The main attribute in the sample class defaults to val. If you need to use var, you need to do it yourself. Mark

The sample class will automatically generate methods such as unapply and apply, saving a lot of code

Comment the above class and object and create a new sample class: (used in large quantities)

  case class person1(val name: String,val age :Int)

Partial function:

Abbreviation of partial function:

We can directly call the collect function to call the partial function parameters and directly write the case. The operation you need

Abbreviation The method is equivalent to omitting the match, and the effect is equivalent to the filter map

Partial functions can also be used in the scenario of using map

The use of partial functions:

    val list = List(List(1, 2, 3, 4), List(1), List(8, 5))
    val list1: List[Int] = list.collect({ case List(x, y, _*) => y })
  println(list1)

Implicit Conversion:

Official definition:

When the compiler fails to compile for the first time, it will search for a method in the current environment that can make the code compile successfully, using

Used to convert types to achieve secondary compilation

Personal understanding:

Implicit conversion is an operation we perform when an error occurs when calling a function on an object that is not in the class in which it is located.

Implicit function:

Implicit conversion steps:

(1) You need to define a target class below and define the called method and logic in the class

eg: We call a non-existent method on Int type data:

class MyRichInt(val self :Int)
  {
def myMax(int: Int):Int =
    {
      if (int>self)
        int
        else
        self
    }
  }

(2) Define the converter in the main function

Introduce ---- implicit at the beginning The implicit conversion function is then defined

 implicit def changeInt(self:Int)  =
    {
new MyRichInt(self)
    }

When the implicit conversion method is the same and conflicts with its own method, its own method will be used (because the compilation will not fail---the official definition of implicit conversion)

Implicit parameters:

We already know the default parameter value when defining the function, but we need to add parentheses when calling it

Here we introduce a new concept Implicit Parameters

Parameter comparison example:

   implicit val name:String="lisi"
    def sayhi(implicit name: String="sd"): Unit =
    {
      println(s"hi $name")
    }
   sayhi
   sayhi()

The default value of the parameter is just to add a bracket after the calling function

Running result:

Implicit class:

Add the keyword implicit in front of the ordinary class and it will automatically be converted into an implicit class

If the target class of the implicit conversion is converted into an implicit class, then If you don’t need to create a new implicit class in the main function

, you can directly call the specified function

The above is the detailed content of What are the methods of pattern matching and implicit conversion in Java Scala?. For more information, please follow other related articles on the PHP Chinese website!