chapter05

已于 2022-09-30 13:16:41 修改
阅读量153 收藏
点赞数
分类专栏： 大数据flink测试代码 文章标签： scala 开发语言 后端
于 2022-09-29 23:16:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61527407/article/details/127115593
版权

点击来源(ClickSource)

package com.liao.chapter05

import java.util.Calendar

import org.apache.flink.streaming.api.functions.source.SourceFunction
import org.apache.flink.streaming.api.watermark.Watermark

import scala.util.Random

class ClickSource extends SourceFunction[Event]{
  //标志位
  var running = true


  override def run(ctx: SourceFunction.SourceContext[Event]): Unit = {
    //随机数生成
    val random = new Random()

    //定义数据随机选择的范围
    var users = Array("Mary","Alice","Bob","Cary")
    var urls = Array("./home","./cart","./fav","./prod?id=1","./prod?id=2","./prod?id=3")

    //用标志位作为循环判断条件，不停地发出数据
    while(running){
      var event = Event(users(random.nextInt(users.length)),urls(random.nextInt(urls.length)), Calendar.getInstance.getTimeInMillis)
      //为要发送的数据分配时间戳
//      ctx.collectWithTimestamp(event,event.timestamp)
//
//      //向下游直接发送水位线
//      ctx.emitWatermark(new Watermark(event.timestamp-1L))

      //调用ctx地方法向下游发送数据
      ctx.collect(event)
      //每隔1s发送一条数据
      Thread.sleep(1000)

    }
  }

  override def cancel(): Unit = running = false
}

JdbcSinkTest

package com.liao.chapter05

import java.sql.{Connection, DriverManager, PreparedStatement}

import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.functions.sink.RichSinkFunction
import org.apache.flink.streaming.api.scala._

object JdbcSinkTest {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

//    val stream :DataStream[Event]= env.fromElements(
//      Event("Mary", "./home", 1000L),
//      Event("Bob", "./cart", 2000L),
//      Event("Bob", "./cart", 3000L),
//      Event("Alice", "./cart", 3000L),
//      Event("Mary", "./prod?id=1", 4000L),
//      Event("Mary", "./prod?id=3", 6000L),
//      Event("Mary", "./prod?id=2", 5000L)
//    )

    val stream = env.addSource(new ClickSource)

    stream.addSink( new MyJdbcSinkFunc() )

    env.execute("jdbc sink test")

  }

  class MyJdbcSinkFunc() extends RichSinkFunction[Event]{
    //定义连接、预编译语句
    var conn: Connection = _
    var insertStmt: PreparedStatement = _
    var updateStmt: PreparedStatement = _

    override def open(parameters: Configuration): Unit = {
      conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test?useSSL=false","root","1234")
      insertStmt = conn.prepareStatement("insert into event (user,url) values(?,?) ")
      updateStmt = conn.prepareStatement("update event set url = ? where user =? ")

    }

    override def invoke(value: Event): Unit = {
      //先执行更新操作，查到就更新
      updateStmt.setString(1,value.url)
      updateStmt.setString(2,value.user)
      updateStmt.execute()
      //如果更新没有查到数据，那么就插入
      if( updateStmt.getUpdateCount == 0 ){
        insertStmt.setString(1,value.user)
        insertStmt.setString(2,value.url)
        insertStmt.execute()
      }
    }

    override def close(): Unit = {
      insertStmt.close()
      updateStmt.close()
      conn.close()
    }
  }


}

分区广播测试

(PartitionBroadcastTest)

package com.liao.chapter05

import org.apache.flink.streaming.api.scala._

object PartitionBroadcastTest {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    //读取自定义的数据源
    val stream = env.addSource(new ClickSource)

    //轮询重分区后打印输出
    stream.broadcast.print("broadcast").setParallelism(4)


    stream.global.print("global").setParallelism(4)

    env.execute()
  }
}

分区客户测试

(PartitionCustomTest)

package com.liao.chapter05

import org.apache.flink.api.common.functions.Partitioner
import org.apache.flink.streaming.api.scala._

object PartitionCustomTest {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    //读取自定义的数据源
    val stream = env.fromElements(1,2,3,4,5,6,7,8)

    //自定义重分区策略
    stream.partitionCustom(new Partitioner[Int]{
      override def partition(k: Int ,i: Int): Int = {
        k % 2
      }
    } , data => data)
      .print("rebalance").setParallelism(4)

    env.execute()
  }
}

分区兼容性测试

(PartitionReblanceTest)

package com.liao.chapter05

import org.apache.flink.streaming.api.scala._

object PartitionReblanceTest {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    //读取自定义的数据源
    val stream = env.addSource(new ClickSource)

    //轮询重分区后打印输出
    stream.rebalance.print("rebalance").setParallelism(4)

    env.execute()
  }
}

分区重新缩放测试(PartitionRescaleTest)

package com.liao.chapter05

import org.apache.flink.streaming.api.functions.source.{RichParallelSourceFunction, SourceFunction}
import org.apache.flink.streaming.api.scala._

object PartitionRescaleTest {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    //读取自定义的数据源
    val stream = env.addSource(new RichParallelSourceFunction[Int] {
      override def run(ctx: SourceFunction.SourceContext[Int]): Unit = {
        for (i <- 0 to 7){
          //利用运行时上下文中的subTask的id信息，来控制数据由哪个并行子任务生成
          if (getRuntimeContext.getIndexOfThisSubtask == (i + 1) % 2)
          ctx.collect( i + 1)
        }
      }

      override def cancel(): Unit = ???
    }).setParallelism(2)

    //轮询重分区后打印输出
    stream.rescale.print("rescale").setParallelism(4)

    env.execute()
  }
}

分区随机测试(PartitionShuffleTest )

package com.liao.chapter05

import org.apache.flink.streaming.api.scala._

object PartitionShuffleTest {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    //读取自定义的数据源
    val stream = env.addSource(new ClickSource)

    //洗牌之后打印输出
    stream.shuffle.print("shuffle").setParallelism(4)

    env.execute()


  }
}

SinkToEsTest(水槽测试)

package com.liao.chapter05

import java.util

import org.apache.flink.api.common.functions.RuntimeContext
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.connectors.elasticsearch.{ElasticsearchSinkFunction, RequestIndexer}
import org.apache.flink.streaming.connectors.elasticsearch6.ElasticsearchSink
import org.apache.http.HttpHost
import org.elasticsearch.client.Requests

object SinkToEsTest {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    val stream :DataStream[Event]= env.fromElements(
      Event("Mary", "./home", 1000L),
      Event("Bob", "./cart", 2000L),
      Event("Bob", "./cart", 3000L),
      Event("Alice", "./cart", 3000L),
      Event("Mary", "./prod?id=1", 4000L),
      Event("Mary", "./prod?id=3", 6000L),
      Event("Mary", "./prod?id=2", 5000L)
    )

    //定义es集群地主机列表
    val httpHosts = new util.ArrayList[HttpHost]()
    httpHosts.add(new HttpHost("hadoop002", 9200))

    //定义一个ES sink function
    val esFun = new ElasticsearchSinkFunction[Event]() {
      override def process(t: Event, runtimeContext: RuntimeContext, requestIndexer: RequestIndexer): Unit = {
        val data = new util.HashMap[String, String]()
        data.put(t.user, t.url)

        //包装要发送地http请求
        val indexRequest = Requests.indexRequest()
          .index("clicks")
          .source(data)
          .`type`("event")

        //发送请求
        requestIndexer.add(indexRequest)
      }
    }

    stream.addSink( new ElasticsearchSink.Builder[Event](httpHosts,esFun).build() )

    env.execute()
  }
}

SinkToFileTest

(接收器到文件测试)

package com.liao.chapter05

import org.apache.flink.api.common.serialization.SimpleStringEncoder
import org.apache.flink.core.fs.Path
import org.apache.flink.streaming.api.functions.sink.filesystem.StreamingFileSink
import org.apache.flink.streaming.api.scala._

object SinkToFileTest {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(4)

    val stream :DataStream[Event]= env.fromElements(
      Event("Mary", "./home", 1000L),
      Event("Bob", "./cart", 2000L),
      Event("Bob", "./cart", 3000L),
      Event("Alice", "./cart", 3000L),
      Event("Mary", "./prod?id=1", 4000L),
      Event("Mary", "./prod?id=3", 6000L),
      Event("Mary", "./prod?id=2", 5000L)
    )

    var fileSink =  StreamingFileSink
      .forRowFormat(new Path("./output"), new SimpleStringEncoder[String]("UTF-8"))
        .build()

    //直接以文本形式分布式地写入到文件中
    stream.map(_.toString).addSink( fileSink )


    env.execute()
  }
}

SinkTokafkaTest

package com.liao.chapter05

import java.util.Properties

import org.apache.flink.api.common.serialization.SimpleStringSchema
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.connectors.kafka.{FlinkKafkaConsumer010, FlinkKafkaProducer011}

object SinkTokafkaTest {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    //读取文件数据
//    val stream = env.readTextFile("input/clicks.txt")


    var properties = new Properties()

    properties.setProperty("bootstrap.servers","hadoop002:9092")
    properties.setProperty("group.id","consumer-group")


    val stream:DataStream[String] = env.addSource(new FlinkKafkaConsumer010[String]("clicks", new SimpleStringSchema(), properties))
        .map(data=>{
          val fileds = data.split(",")
          Event(fileds(0).trim, fileds(1).trim , fileds(2).trim.toLong).toString
        })

    //将数据写入到kafka
    stream.addSink(new FlinkKafkaProducer011[String]("hadoop002:9092","events",new SimpleStringSchema()))

    env.execute()


}
}

SinkToRedisTest

package com.liao.chapter05

import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.connectors.redis.RedisSink
import org.apache.flink.streaming.connectors.redis.common.config.FlinkJedisPoolConfig
import org.apache.flink.streaming.connectors.redis.common.mapper.{RedisCommand, RedisCommandDescription, RedisMapper}

object SinkToRedisTest {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    val stream = env.addSource(new ClickSource)

    //创建一个Jedis连接地配置项
    var conf = new FlinkJedisPoolConfig.Builder()
      .setHost("hadoop002")
      .build()


    stream.addSink(new RedisSink[Event](conf,new MyRedisMapper))

    env.execute()

  }

  //实现RedisMapper接口
  class MyRedisMapper extends RedisMapper[Event] {
    override def getCommandDescription: RedisCommandDescription = new RedisCommandDescription(RedisCommand.HSET,"clicks")

    override def getKeyFromData(t: Event): String = t.user

    override def getValueFromData(t: Event): String = t.url
  }

}

源边界测试

(SourceBoundedTest)

package com.liao.chapter05

import org.apache.flink.streaming.api.scala._



case class Event(user:String ,url:String ,timestamp: Long)

object SourceBoundedTest {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    //1.从元素中读取数据
    val stream:DataStream[Int]= env.fromElements(1, 2, 3, 4, 5)

    val stream1:DataStream[Event] = env.fromElements(Event("Mary", "./home", 1000L),
      Event("Bob", "./cart", 2000L)
    )

    //2.从集合中读取数据
    val clicks = List(Event("Mary", "./home", 1000L),Event("Bob", "./cart", 2000L))
    val stream2:DataStream[Event] = env.fromCollection(clicks)

    //3.从文件中读取数据
    val stream3:DataStream[String] = env.readTextFile("input/clicks.txt")

    //打印输出
    stream.print("number")
    stream1.print("1")
    stream2.print("2")
    stream3.print("3")

    env.execute()
  }
}

源客户测试

(SourceCustomTest)

package com.liao.chapter05

import org.apache.flink.streaming.api.scala._

object SourceCustomTest {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    //读取自定义的数据源
    val stream:DataStream[Event] = env.addSource(new ClickSource)

    stream.print()

    env.execute()

  }
}

SourceKafkaTest

package com.liao.chapter05

import java.util.Properties

import org.apache.flink.api.common.serialization.SimpleStringSchema
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer010

object SourceKafkaTest {
  def main(args: Array[String]): Unit = {
    var env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    //用Properties保存Kafka连接的相关配置
    var properties = new Properties()

    properties.setProperty("bootstrap.servers","hadoop002:9092")
    properties.setProperty("group.id","consumer-group")


    val stream:DataStream[String] = env.addSource(new FlinkKafkaConsumer010[String]("clicks", new SimpleStringSchema(), properties))

    stream.print()

    env.execute()
  }
}

TransformAggTest

package com.liao.chapter05

import org.apache.flink.api.java.functions.KeySelector
import org.apache.flink.streaming.api.scala._

object TransformAggTest {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    val stream :DataStream[Event]= env.fromElements(Event("Mary", "./home", 1000L), Event("Bob", "./cart", 2000L),
      Event("Alice", "./cart", 3000L),
      Event("Mary", "./prod?id=1", 4000L),
      Event("Mary", "./prod?id=3", 6000L),
      Event("Mary", "./prod?id=2", 5000L)
    )
//    stream.keyBy(new MyKetSelector()).print()
    //    /*stream.keyBy( data =>data.user )*/
    //    stream.keyBy(_.user)
    //    stream.keyBy(_.url)
    stream.keyBy(new MyKetSelector())
        .maxBy("timestamp")
        .print()


    env.execute()

  }

  class MyKetSelector() extends KeySelector[Event,String]{
    override def getKey(in: Event): String = in.user
  }

}

TransformFilterTest

package com.liao.chapter05

import org.apache.flink.api.common.functions.FilterFunction
import org.apache.flink.streaming.api.scala._

object TransformFilterTest {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    val stream:DataStream[Event] = env.fromElements(Event("Mary", "./home", 1000L), Event("Bob", "./cart", 2000L))

    //过滤出用户为Mary的所有点击事件
    //1.使用匿名函数

    stream.filter( _.user == "Mary"  ).print("1")

    //实现FilterFunction接口
    stream.filter(new UserFilter).print("2")

    env.execute()

  }
  class UserFilter extends FilterFunction[Event]{
    override def filter(t: Event): Boolean = t.user == "Mary"
  }
}

TransformFlatmapTest

package com.liao.chapter05

import org.apache.flink.api.common.functions.FlatMapFunction
import org.apache.flink.streaming.api.scala._
import org.apache.flink.util.Collector

object TransformFlatmapTest {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    val stream :DataStream[Event]= env.fromElements(Event("Mary", "./home", 1000L), Event("Bob", "./cart", 2000L),
      Event("Alice", "./cart", 3000L))

    //测试灵活的输出形式
    stream.flatMap( new MyFlatMap ).print()

    env.execute()
  }

  //自定义实现FlatMapFunction
  class MyFlatMap extends FlatMapFunction[Event,String]{
    override def flatMap(t: Event, collector: Collector[String]): Unit ={
      //如果当前数据是Mary的点击事件，那么就直接输出user
      if(t.user == "Mary"){
        collector.collect(t.user)
      }
      //如果当前数据是Bob的点击事件,那么输出user和url
      else if(t.user == "Bob"){
        collector.collect(t.user)
        collector.collect(t.url)
      }
    }

  }
}

TransformMapTest

package com.liao.chapter05

import org.apache.flink.api.common.functions.MapFunction
import org.apache.flink.streaming.api.scala._

object TransformMapTest {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment

    env.setParallelism(1)


    val stream:DataStream[Event] =
    env.fromElements(Event("Mary","./home",1000L),
      Event("Bob", "./cart", 2000L)
    )

    //提取每次点击事件的用户名
    //1.使用匿名函数
    stream.map( _.user ).print("1")

    //2.实现MapFunction接口
    stream.map(new UserExtractor).print("2")


    env.execute()
  }

  class UserExtractor extends MapFunction[Event,String]{
    override def map(t: Event): String = t.user
  }

}

TransformReduceTest

package com.liao.chapter05

import org.apache.flink.api.common.functions.ReduceFunction
import org.apache.flink.streaming.api.scala._

object TransformReduceTest {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    val stream :DataStream[Event]= env.fromElements(
      Event("Mary", "./home", 1000L),
      Event("Bob", "./cart", 2000L),
      Event("Bob", "./cart", 3000L),
      Event("Alice", "./cart", 3000L),
      Event("Mary", "./prod?id=1", 4000L),
      Event("Mary", "./prod?id=3", 6000L),
      Event("Mary", "./prod?id=2", 5000L)
    )

    //reduce 归约聚合,提取当前最活跃的用户
    stream.map( data=>(data.user, 1L) )
      .keyBy( _._1 )
      .reduce(new MySum())    //统计每个用户的活跃度
      .keyBy(data => true)    //将所有数据按照同样的key分到同一个组中
      .reduce( (state,data) =>if(data._2 >= state._2) data else state )   //选取当前最活跃的用户
      .print()

    env.execute()

  }

  class MySum() extends ReduceFunction[(String,Long)]{
    override def reduce(t: (String, Long), t1: (String, Long)): (String, Long) = (t._1,t._2 + t1._2)

  }

}

TransformRichFunctionTest

package com.liao.chapter05

import org.apache.flink.api.common.functions.RichMapFunction
import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.scala._

object  TransformRichFunctionTest {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(2)

    val stream :DataStream[Event]= env.fromElements(
      Event("Mary", "./home", 1000L),
      Event("Bob", "./cart", 2000L),
      Event("Bob", "./cart", 3000L),
      Event("Alice", "./cart", 3000L),
      Event("Mary", "./prod?id=1", 4000L),
      Event("Mary", "./prod?id=3", 6000L),
      Event("Mary", "./prod?id=2", 5000L)
    )


    //自定义一个RichMapFunction，测试富函数类的功能
    stream.map( new MyRichMap )
      .print()

    env.execute()


  }

  class MyRichMap() extends RichMapFunction[Event, Long]{

    override def open(parameters: Configuration): Unit =
      println("索引号为"+getRuntimeContext.getIndexOfThisSubtask + "的任务开始")

    override def map(in: Event): Long = in.timestamp

    override def close(): Unit =
      println("索引号为"+getRuntimeContext.getIndexOfThisSubtask + "的任务结束")
  }

}

TransformUDFTest

package com.liao.chapter05

import org.apache.flink.api.common.functions.FilterFunction
import org.apache.flink.streaming.api.scala._

object TransformUDFTest {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    val stream :DataStream[Event]= env.fromElements(
      Event("Mary", "./home", 1000L),
      Event("Bob", "./cart", 2000L),
      Event("Bob", "./cart", 3000L),
      Event("Alice", "./cart", 3000L),
      Event("Mary", "./prod?id=1", 4000L),
      Event("Mary", "./prod?id=3", 6000L),
      Event("Mary", "./prod?id=2", 5000L)
    )


    //测试UDF的用法,筛选url中包含某个关键字home的Event事件
    //1.实现一个自定义的函数类
    stream.filter(new MyFilterFunction("prod"))
      .print("1")

    //2.使用匿名类
    stream.filter( new FilterFunction[Event] {
      override def filter(t: Event): Boolean = t.url.contains("prod")
    } )
      .print("2")


    //3.使用匿名函数
    stream.filter(_.url.contains("prod"))
        .print("3")

    env.execute()

  }

  //实现自定义的FilterFunction
  class MyFilterFunction(keyWord: String) extends FilterFunction[Event]{
    override def filter(t: Event): Boolean = t.url.contains(keyWord)
  }
}
计算机小白白
关注
专栏目录
chapter05.zip
10-27
标题“chapter05.zip”可能指的是一个包含第五章学习材料或教程内容的压缩文件。在IT领域，压缩文件经常被用来存储和传输大量的数据，尤其是当文件数量多或者体积大时，压缩可以节省存储空间和网络传输时间。最常见...
Flink-将DataStream 转换成表 | 创建临时视图 | 输出到文件 | 输出到Kafka | 更新模式
SmallScorpion
05-31 4087
将 DataStream 转换成表 Flink允许我们把Table和DataStream做转换：我们可以基于一个DataStream，先流式地读取数据源，然后map成样例类，再把它转成Table。Table的列字段（column fields），就是样例类里的字段，这样就不用再麻烦地定义schema了。 import com.atguigu.bean.SensorReading import org.apache.flink.streaming.api.scala._ import org.apache.f
Flink KafkaProducer
Claroja
12-24 2671
package com.claroja; import org.apache.flink.api.common.serialization.SimpleStringSchema; import org.apache.flink.streaming.api.datastream.DataStreamSource; import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; import org.apache.fl
chapter05.rar
06-21
在本压缩包"chapter05.rar"中，包含的是《PHP网站开发实例教程》第五单元的源代码。这个单元很可能会深入讲解PHP编程语言在实际网站开发中的应用，特别是通过实例来教学，使得学习者能够更好地理解和掌握PHP的核心...
chapter05.ipynb
02-12
chapter05.ipynb
Chapter05.rar
12-12
Chapter05.rar
scala和Java的可变参数怎么用
别人笑我太疯癫，我笑他人看不穿。
11-02 231
3、可变参数本身是个数组，你可以把一个数组做传参给可变行参，但是怎么用的话，就不能传其他的了。scala可变参数需要在类型后面加个*Java的可变参数是在类型后面加三个点。2、多个参数可变参数需要定义在最后。1、一个方法只能有一个可变参数。两者在使用的时候要注意。
scala set集合
2301_80936715的博客
11-04 368
不可变集合：它的元素是不可以进行更新操作的，只有可变集合才可以进行元素的更新，使用集合调用update方法可以直接更新元素。1.添加单个或多个元素：+= ，添加集合：++=2.移除元素：-=和--=
Scala 的访问权限
2301_81748087的博客
11-06 426
Scala中也有四种访问控制权限，分别为:默认访问权限、protected访问权限、private 访问权限和private[ thisl访问权限。在Java中，访问权限的级别范围由小到大为类、包、继承、all,在Scala中，访问权限的级别范围由小到大为对象、类、继承、 包、all。Scala的控制方法作用域有:默认访问权限、protected访问权限、private访问权限、private[package] 访问权限、private[this]访问权限。(4)private[package]访问权限。
Scala的访问权限
2401_87129058的博客
11-04 206
Scala 中的属性成员、方法和构造器这三种变量可以通过访问控制符控制访问权限。不同的访问控制符可以决定是否可以被外部类访问。
Scala的访问权限。
2401_87129116的博客
11-04 520
Scala中的访问权限和Java一致，采用public, private, protected三种访问权限。在不声明访问权限的情况下，Scala使用public作为默认权限private为私有属性，只有在类的内部和伴生对象中可用protected为受保护权限，同类、子类可以访问，但是同包不行Scala中的private限定符比Java更严格，在嵌套类情况下，外层类甚至不能访问被嵌套类的私有成员。
Scala 的例题：银行账户钱存取功能
2401_87129058的博客
11-04 236
（5）private[package]访问权限。（4）private[this]访问权限。（2）protected 访问权限。private[this]方法。（3）private 访问权限。private 方法。
spark==centos安装hadoop集群，安装spark standalone集群，编写pyspark/java/scala代码使用集群
hebian1994的博客
11-03 332
master地址 hadoop100:8080历史服务器 hadoop100:18080hdfs地址1centos安装hadoop集群，上传文件到hdfs2安装spark standalone集群，查看自带的pyspark使用的python版本，然后安装annaconda安装该版本的虚拟环境，安装该版本的pyspark依赖包3 python pyspark代码pycharm远程选择python解释器编写pyspark代码。
Scala入门基础（16）scala的包
2401_82393217的博客
11-06 284
包名称应全部为小写，只能包含数字，字母，下划线，小圆点。不能使用数字开头，也不要用关键字。(2) 嵌套 package 表示层级关系。这样的好处是一个文件可以定义多个包，内层。package（包：一个容器。可以把类，对象，包，装入。风格 1：将包名与包合 scale 文件的目承名相间。风格 2：铁套 packege 表示层级关系。格式：import 包名{原名字=>新名字}(1)一个源文件一个包，与路径名一一对应；//错误，因为class是关键字。可以访间外层的包的类和对象；// 错误，数字开头。
Scala的属性访问权限(一)默认访问权限
2401_85414079的博客
11-04 211
【代码】Scala的属性访问权限(一)默认访问权限。
scala set训练
最新发布
2301_80936715的博客
11-06 251
4.检查一本特定的书籍（eg：Python从入门到实践）是否在图书馆集合中,使用contains方法，并输出结果。1.创建一个可变Set，用于存储图书馆中的书籍信息（假设书籍信息用字符串表示），初始化为包含几本你喜欢的书籍。5.创建另一个可变Set，表示另一个图书馆的书籍集合。2.添加两本新的书籍到图书馆集合中，使用+=操作符。3.删除一本图书馆集合中的书籍，使用+=操作符。8.求出当前图书馆相对于另一个图书馆的差集。6.求出两个图书馆集合的并集。7.求出两个图书馆集合的交集。
Scala的包及其导入
2401_87129058的博客
11-06 270
Scala 的包 定义： 相比于Java中的包，Scala中的包可以定义在文件的开头，也可以在代码的任意位置。Scala的包用于解决类的命名冲突和类的文件管理。在引入类时加上包名可以区分不同的，解决类名冲突的问题。类的文件管理就是通过包名可以把具有相同功能的不同类组织在一起，放入同一个包中。如果一个包中包含多个类，除包中某一个类之外都需要导入，可以使用导入成员隐藏类的方法，其语法格式为：把包中的A不导入。在包里建A，B，C类，在类里打入： （A,B,C都打一样的这个）导入的关键字是 import。
Scala IF...ELSE 语句
lly202406的博客
11-06 203
Scala 是一种多范式的编程语言，它结合了面向对象和函数式编程的特点。在 Scala 中，if...else语句是一种基本且常用的控制结构，用于根据条件执行不同的代码块。与 Java 或 Python 等其他语言中的if...else语句类似，Scala 中的if...else语句也用于基于布尔表达式的值来选择执行路径。
scala的属性访问权限
2401_85414079的博客
11-04 253
【代码】scala的访问权限。
深入解析chapter05压缩包内的关键信息
资源摘要信息:"chapter05.zip" 由于提供的文件信息不足，我们无法直接提取出具体的章节内容或者详细的知识点。不过，根据文件的命名方式，我们可以推测这是一个以"chapter05"命名的压缩包文件，其中可能包含了与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值