Spark DataFrame和Dataset使用例子

已于 2023-12-12 20:45:15 修改
阅读量1.1k 收藏 16
点赞数 21
分类专栏： java 大数据 文章标签： spark 大数据
于 2023-12-07 13:00:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/penngo/article/details/134852807
版权

文章目录

1、基本操作

1.1、创建SparkSession

import org.apache.spark.sql.SparkSession;

SparkSession spark = SparkSession
.builder()
.appName("Java Spark SQL basic example")
.config("spark.some.config.option", "some-value")
.getOrCreate();

1.2、创建DataFrames

import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;

Dataset<Row> df = spark.read().json("examples/src/main/resources/people.json");

// Displays the content of the DataFrame to stdout
df.show();
// +----+-------+
// | age|   name|
// +----+-------+
// |null|Michael|
// |  30|   Andy|
// |  19| Justin|
// +----+-------+

1.3、创建Dataset操作

// col("...") is preferable to df.col("...")
import static org.apache.spark.sql.functions.col;

// Print the schema in a tree format
df.printSchema();
// root
// |-- age: long (nullable = true)
// |-- name: string (nullable = true)

// Select only the "name" column
df.select("name").show();
// +-------+
// |   name|
// +-------+
// |Michael|
// |   Andy|
// | Justin|
// +-------+

// Select everybody, but increment the age by 1
df.select(col("name"), col("age").plus(1)).show();
// +-------+---------+
// |   name|(age + 1)|
// +-------+---------+
// |Michael|     null|
// |   Andy|       31|
// | Justin|       20|
// +-------+---------+

// Select people older than 21
df.filter(col("age").gt(21)).show();
// +---+----+
// |age|name|
// +---+----+
// | 30|Andy|
// +---+----+

// Count people by age
df.groupBy("age").count().show();
// +----+-----+
// | age|count|
// +----+-----+
// |  19|    1|
// |null|    1|
// |  30|    1|
// +----+-----+

1.4、运行sql查询

import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;

// Register the DataFrame as a SQL temporary view
df.createOrReplaceTempView("people");

Dataset<Row> sqlDF = spark.sql("SELECT * FROM people");
sqlDF.show();
// +----+-------+
// | age|   name|
// +----+-------+
// |null|Michael|
// |  30|   Andy|
// |  19| Justin|
// +----+-------+

1.5、创建全局临时视图

// Register the DataFrame as a global temporary view
df.createGlobalTempView("people");

// Global temporary view is tied to a system preserved database `global_temp`
spark.sql("SELECT * FROM global_temp.people").show();
// +----+-------+
// | age|   name|
// +----+-------+
// |null|Michael|
// |  30|   Andy|
// |  19| Justin|
// +----+-------+

// Global temporary view is cross-session
spark.newSession().sql("SELECT * FROM global_temp.people").show();
// +----+-------+
// | age|   name|
// +----+-------+
// |null|Michael|
// |  30|   Andy|
// |  19| Justin|
// +----+-------+

1.6、创建Datasets

import java.util.Arrays;
import java.util.Collections;
import java.io.Serializable;

import org.apache.spark.api.java.function.MapFunction;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.Encoder;
import org.apache.spark.sql.Encoders;

public static class Person implements Serializable {
  private String name;
  private long age;

  public String getName() {
    return name;
  }

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

  public long getAge() {
    return age;
  }

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

// Create an instance of a Bean class
Person person = new Person();
person.setName("Andy");
person.setAge(32);

// Encoders are created for Java beans
Encoder<Person> personEncoder = Encoders.bean(Person.class);
Dataset<Person> javaBeanDS = spark.createDataset(
  Collections.singletonList(person),
  personEncoder
);
javaBeanDS.show();
// +---+----+
// |age|name|
// +---+----+
// | 32|Andy|
// +---+----+

// Encoders for most common types are provided in class Encoders
Encoder<Long> longEncoder = Encoders.LONG();
Dataset<Long> primitiveDS = spark.createDataset(Arrays.asList(1L, 2L, 3L), longEncoder);
Dataset<Long> transformedDS = primitiveDS.map(
    (MapFunction<Long, Long>) value -> value + 1L,
    longEncoder);
transformedDS.collect(); // Returns [2, 3, 4]

// DataFrames can be converted to a Dataset by providing a class. Mapping based on name
String path = "examples/src/main/resources/people.json";
Dataset<Person> peopleDS = spark.read().json(path).as(personEncoder);
peopleDS.show();
// +----+-------+
// | age|   name|
// +----+-------+
// |null|Michael|
// |  30|   Andy|
// |  19| Justin|
// +----+-------+

1.7、与rdd进行互操作

1.7.1、使用反射推断模式

Spark SQL支持将JavaBeans的RDD自动转换为DataFrame。使用反射获得的BeanInfo定义了表的模式。目前，Spark SQL不支持包含Map字段的JavaBeans。但是支持嵌套JavaBeans和List或Array字段。您可以通过创建一个实现Serializable的类来创建JavaBean，并且该类的所有字段都有getter和setter。

import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.api.java.function.MapFunction;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.Encoder;
import org.apache.spark.sql.Encoders;

// Create an RDD of Person objects from a text file
JavaRDD<Person> peopleRDD = spark.read()
  .textFile("examples/src/main/resources/people.txt")
  .javaRDD()
  .map(line -> {
    String[] parts = line.split(",");
    Person person = new Person();
    person.setName(parts[0]);
    person.setAge(Integer.parseInt(parts[1].trim()));
    return person;
  });

// Apply a schema to an RDD of JavaBeans to get a DataFrame
Dataset<Row> peopleDF = spark.createDataFrame(peopleRDD, Person.class);
// Register the DataFrame as a temporary view
peopleDF.createOrReplaceTempView("people");

// SQL statements can be run by using the sql methods provided by spark
Dataset<Row> teenagersDF = spark.sql("SELECT name FROM people WHERE age BETWEEN 13 AND 19");

// The columns of a row in the result can be accessed by field index
Encoder<String> stringEncoder = Encoders.STRING();
Dataset<String> teenagerNamesByIndexDF = teenagersDF.map(
    (MapFunction<Row, String>) row -> "Name: " + row.getString(0),
    stringEncoder);
teenagerNamesByIndexDF.show();
// +------------+
// |       value|
// +------------+
// |Name: Justin|
// +------------+

// or by field name
Dataset<String> teenagerNamesByFieldDF = teenagersDF.map(
    (MapFunction<Row, String>) row -> "Name: " + row.<String>getAs("name"),
    stringEncoder);
teenagerNamesByFieldDF.show();
// +------------+
// |       value|
// +------------+
// |Name: Justin|
// +------------+
1.7.2、以编程方式指定模式

当JavaBean类不能提前定义时(例如，记录的结构被编码为字符串，或者文本数据集将被解析，字段将以不同的方式投影给不同的用户)，可以通过三个步骤以编程方式创建dataset 。

  • 从原始RDD的行创建一个RDD;
  • 创建由StructType表示的模式，该模式与步骤1中创建的RDD中的Rows结构相匹配。
  • 通过SparkSession提供的createDataFrame方法将模式应用到RDD的行。
import java.util.ArrayList;
import java.util.List;

import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.function.Function;

import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;

import org.apache.spark.sql.types.DataTypes;
import org.apache.spark.sql.types.StructField;
import org.apache.spark.sql.types.StructType;

// Create an RDD
JavaRDD<String> peopleRDD = spark.sparkContext()
  .textFile("examples/src/main/resources/people.txt", 1)
  .toJavaRDD();

// The schema is encoded in a string
String schemaString = "name age";

// Generate the schema based on the string of schema
List<StructField> fields = new ArrayList<>();
for (String fieldName : schemaString.split(" ")) {
  StructField field = DataTypes.createStructField(fieldName, DataTypes.StringType, true);
  fields.add(field);
}
StructType schema = DataTypes.createStructType(fields);

// Convert records of the RDD (people) to Rows
JavaRDD<Row> rowRDD = peopleRDD.map((Function<String, Row>) record -> {
  String[] attributes = record.split(",");
  return RowFactory.create(attributes[0], attributes[1].trim());
});

// Apply the schema to the RDD
Dataset<Row> peopleDataFrame = spark.createDataFrame(rowRDD, schema);

// Creates a temporary view using the DataFrame
peopleDataFrame.createOrReplaceTempView("people");

// SQL can be run over a temporary view created using DataFrames
Dataset<Row> results = spark.sql("SELECT name FROM people");

// The results of SQL queries are DataFrames and support all the normal RDD operations
// The columns of a row in the result can be accessed by field index or by field name
Dataset<String> namesDS = results.map(
    (MapFunction<Row, String>) row -> "Name: " + row.getString(0),
    Encoders.STRING());
namesDS.show();
// +-------------+
// |        value|
// +-------------+
// |Name: Michael|
// |   Name: Andy|
// | Name: Justin|
// +-------------+

2、完整的测试例子

本例子代码是在window下测试，需要下载https://github.com/steveloughran/winutils，解压放在hadoop对应目录

package com.penngo.spark;

import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.api.java.function.MapFunction;
import org.apache.spark.sql.*;
import org.apache.spark.sql.types.DataTypes;
import org.apache.spark.sql.types.StructField;
import org.apache.spark.sql.types.StructType;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import static org.apache.spark.sql.functions.col;

public class SparkDataset {
    private static final String jsonPath = "D:\\hadoop\\spark\\resources\\people.json";
    private static final String txtPath = "D:\\hadoop\\spark\\resources\\people.txt";
    public static class Person implements Serializable {
        private String name;
        private long age;

        public String getName() {
            return name;
        }

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

        public long getAge() {
            return age;
        }

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

    public static void createDataFrame(SparkSession spark) throws Exception{
        // 创建DataFrame
        Dataset<Row> df = spark.read().json(jsonPath);
        df.show();

        // 操作
        operations(df);

        // sql查询
        sqlQuery(spark, df);
    }

    public static void operations(Dataset<Row> df){
        df.printSchema();
        // root
        // |-- age: long (nullable = true)
        // |-- name: string (nullable = true)

        // Select only the "name" column
        df.select("name").show();
        // +-------+
        // |   name|
        // +-------+
        // |Michael|
        // |   Andy|
        // | Justin|
        // +-------+

        // Select everybody, but increment the age by 1
        df.select(col("name"), col("age").plus(1)).show();
        // +-------+---------+
        // |   name|(age + 1)|
        // +-------+---------+
        // |Michael|     null|
        // |   Andy|       31|
        // | Justin|       20|
        // +-------+---------+

        // Select people older than 21
        df.filter(col("age").gt(21)).show();
        // +---+----+
        // |age|name|
        // +---+----+
        // | 30|Andy|
        // +---+----+

        // Count people by age
        df.groupBy("age").count().show();
        // +----+-----+
        // | age|count|
        // +----+-----+
        // |  19|    1|
        // |null|    1|
        // |  30|    1|
        // +----+-----+
    }

    /**
     * SQL查询
     */
    public static void sqlQuery(SparkSession spark, Dataset<Row> df) throws Exception{
        // 临时视图，会话消失，视图也会消失
        df.createOrReplaceTempView("people");

        Dataset<Row> sqlDF = spark.sql("SELECT * FROM people");
        sqlDF.show();

        // 全局视图，全局临时视图绑定到系统保留的数据库' global_temp '
        df.createGlobalTempView("people");
        spark.sql("SELECT * FROM global_temp.people").show();
        // +----+-------+
        // | age|   name|
        // +----+-------+
        // |null|Michael|
        // |  30|   Andy|
        // |  19| Justin|
        // +----+-------+

        // 全局临时视图是跨会话的
        spark.newSession().sql("SELECT * FROM global_temp.people").show();
        // +----+-------+
        // | age|   name|
        // +----+-------+
        // |null|Michael|
        // |  30|   Andy|
        // |  19| Justin|
        // +----+-------+
    }

    public static void createDataset(SparkSession spark){
        // 列表转成dataset
        Person person = new Person();
        person.setName("Andy");
        person.setAge(32);
        Encoder<Person> personEncoder = Encoders.bean(Person.class);
        Dataset<Person> javaBeanDS = spark.createDataset(
                Collections.singletonList(person),
                personEncoder
        );
        System.out.println("createDataset show");
        javaBeanDS.show();
        // +---+----+
        // |age|name|
        // +---+----+
        // | 32|Andy|
        // +---+----+

        Encoder<Long> longEncoder = Encoders.LONG();
        Dataset<Long> primitiveDS = spark.createDataset(Arrays.asList(1L, 2L, 3L), longEncoder);
        Dataset<Long> transformedDS = primitiveDS.map(
                (MapFunction<Long, Long>) value -> value + 1L,
                longEncoder);
        transformedDS.collect(); // Returns [2, 3, 4]

        // 读取文件转成dataset
        Dataset<Person> peopleDS = spark.read().json(jsonPath).as(personEncoder);
        peopleDS.show();
        // +----+-------+
        // | age|   name|
        // +----+-------+
        // |null|Michael|
        // |  30|   Andy|
        // |  19| Justin|
        // +----+-------+
    }

    /**
     * 非Bean的方式转换：rdd->DataFrame->Dataset
     * @param spark
     * @throws Exception
     */
    public static void rddToDataset(SparkSession spark) throws Exception{
        // 读取文件生成一个Person类型的RDD
        JavaRDD<Person> peopleRDD = spark.read()
                .textFile(txtPath)
                .javaRDD()
                .map(line -> {
                    String[] parts = line.split(",");
                    Person person = new Person();
                    person.setName(parts[0]);
                    person.setAge(Integer.parseInt(parts[1].trim()));
                    return person;
                });

        // RDD转成DataFrame
        Dataset<Row> peopleDF = spark.createDataFrame(peopleRDD, Person.class);
        // 把DataFrame注册为临时视图
        peopleDF.createOrReplaceTempView("people");

        // SQL语句可以通过spark提供的SQL方法来运行
        Dataset<Row> teenagersDF = spark.sql("SELECT name FROM people WHERE age BETWEEN 13 AND 19");

        // 结果中一行的列可以通过字段索引访问
        Encoder<String> stringEncoder = Encoders.STRING();
        Dataset<String> teenagerNamesByIndexDF = teenagersDF.map(
                (MapFunction<Row, String>) row -> "Name: " + row.getString(0),
                stringEncoder);
        teenagerNamesByIndexDF.show();
        // +------------+
        // |       value|
        // +------------+
        // |Name: Justin|
        // +------------+

        // 也可以通过字段名访问
        Dataset<String> teenagerNamesByFieldDF = teenagersDF.map(
                (MapFunction<Row, String>) row -> "Name: " + row.<String>getAs("name"),
                stringEncoder);
        teenagerNamesByFieldDF.show();
        // +------------+
        // |       value|
        // +------------+
        // |Name: Justin|
        // +------------+
    }

    /**
     * 非Bean的方式转换：rdd->DataFrame->Dataset
     * @param spark
     * @throws Exception
     */
    public static void rddToDataset2(SparkSession spark) throws Exception{
        // 创建RDD
        JavaRDD<String> peopleRDD = spark.sparkContext()
                .textFile(txtPath, 1)
                .toJavaRDD();
        // 字段字义
        String schemaString = "name age";
        // 根据schema的字符串生成schema
        List<StructField> fields = new ArrayList<>();
        for (String fieldName : schemaString.split(" ")) {
            StructField field = DataTypes.createStructField(fieldName, DataTypes.StringType, true);
            fields.add(field);
        }
        StructType schema = DataTypes.createStructType(fields);

        // 将RDD(people)的记录转换为视图的Row
        JavaRDD<Row> rowRDD = peopleRDD.map((Function<String, Row>) record -> {
            String[] attributes = record.split(",");
            return RowFactory.create(attributes[0], attributes[1].trim());
        });

        // 将schema应用于RDD，转为DataFrame
        Dataset<Row> peopleDataFrame = spark.createDataFrame(rowRDD, schema);

        // 使用DataFrame创建临时视图
        peopleDataFrame.createOrReplaceTempView("people");

        // SQL可以在使用dataframe创建的临时视图上运行
        Dataset<Row> results = spark.sql("SELECT name FROM people");

        // SQL查询的结果是dataframe，支持所有正常的RDD操作
        // 结果行的列可以通过字段索引或字段名称访问
        Dataset<String> namesDS = results.map(
                (MapFunction<Row, String>) row -> "Name: " + row.getString(0),
                Encoders.STRING());
        namesDS.show();
        // +-------------+
        // |        value|
        // +-------------+
        // |Name: Michael|
        // |   Name: Andy|
        // | Name: Justin|
        // +-------------+
    }

    public static void main(String[] args) throws Exception{
        Logger.getLogger("org.apache.spark").setLevel(Level.WARN);
        Logger.getLogger("org.apache.eclipse.jetty.server").setLevel(Level.OFF);

        //windows下调试spark需要使用https://github.com/steveloughran/winutils
        System.setProperty("hadoop.home.dir", "D:\\hadoop\\hadoop-3.3.1");
        System.setProperty("HADOOP_USER_NAME", "root");

        SparkSession spark = SparkSession
                .builder()
                .appName("SparkDataset")
                .master("local[*]")
                .getOrCreate();

        createDataFrame(spark);

        createDataset(spark);

        rddToDataset(spark);

        rddToDataset2(spark);

        spark.stop();
    }
}

参考自官方文档：https://spark.apache.org/docs/3.1.2/sql-getting-started.html
spark支持数据源：https://spark.apache.org/docs/3.1.2/sql-data-sources.html
spark sql语法相关：https://spark.apache.org/docs/3.1.2/sql-ref.html

penngo
关注
专栏目录
Spark编程案例——DataFrame
weixin_44804248的博客
05-29 874
Spark SQL 1、相应于Hive: SQL —> MapReduce 2、底层依赖RDD： SQL —> RDD 一、Spark SQL基础 1、什么是Spark SQL？ 参考官网 2、核心概念：DataFrame（表）= Schema（表结构） + Data（表数据） （*）就是表，是Spark SQL对结构化数据的抽象 ...
Apache Spark：Spark高级特性：DataFrame与Dataset
最新发布
kkchenjj的博客
07-18 781
用户定义函数（UDF）允许在DataFrame和Dataset中使用自定义的Java、Scala或Python函数。这为处理复杂的数据转换提供了灵活性，尤其是在标准函数无法满足需求时。在Apache Spark中，DataFrame和Dataset API提供了强大的工具来处理大规模数据集，进行数据清洗和复杂查询。通过使用这些API，我们可以更高效、更安全地处理数据，为数据分析和机器学习项目提供高质量的数据输入。DataFrame是Apache Spark中用于处理结构化数据的核心API。
Spark dataset常用操作优化思路
sdfasfasdfdfdfd的博客
05-25 1590
select字段格式转换优化，大dataset拆分优化，开窗函数
Spark DataFrame 演示Demo
05-20
简单一个示例，演示Spark中DataFrame的创建与操作
SparkSQL之DataFrame案例
vincent_duan的专栏
03-29 314
待处理文件 准备待处理文件student.data，内容如下： 1|vincent|13827460000|gvark@eyou.com 2|jenny|13827460002|ovwgofpa@56.com 3|sofia|13827460003|jfbmgpm@netease.com 4|natasha|13827460004|vjtw@35.com 5|catalina|1382746000...
Spark DataSet 、DataFrame 一些使用示例
weixin_30485379的博客
11-18 114
以前使用过DS和DF，最近使用Spark ML跑实验，再次用到简单复习一下。 //案例数据 1,2,3 4,5,6 7,8,9 10,11,12 13,14,15 1,2,3 4,5,6 7,8,9 10,11,12 13,14,15 1,2,3 4,5,6 7,8,9 10,11,12 13,14,15 1：DS与DF关系？ ty...
六.SparkSQL之DataFrame操作实例实战API
飞翔的宇宙
10-11 1561
前面已经说过DataFrame的基本API操作,接下来就讲下实际开发过程中的应用,首先需要准备一个数据源文件,以下面这种格式的数据(这种数据是可以清洗日志得到的) 第一步: 实例实战演示 import org.apache.spark.sql.SparkSession object DataFrameCase { def main(args: Array[String]){ val spark ...
RDD、DataFrame和Dataset 怎么选择才好？
稚枭天卓
10-29 551
最令开发者们高兴的事莫过于有一组API，可以大大提高开发者们的工作效率，容易使用、非常直观并且富有表现力。Apache Spark广受开发者们欢迎的一个重要原因也在于它那些非常容易使用的API，可以方便地通过多种语言，如Scala、Java、Python和R等来操作大数据集。 在本文中，我将深入讲讲Apache Spark 2.2以及以上版本提供的三种API——RDD、DataFrame和Dat...
【Spark】Dataset与DataFrame的使用
HR的博客
01-06 1483
@[toc](Dataset (DataFrame) 的基础操作)
Spark DataFrame Dataset 的java使用入门
踩坑小王子
12-28 9830
问题描述 环境介绍 依赖库: spark-core_2.11 version: ‘2.4.0’ hadoop-client version: ‘3.1.1’ spark-sql_2.11 version: ‘2.4.0’ jackson-module-scala_2.11 version: ‘2.8.8’ DataFrame 和 Dataset是 spark中的一种重要数据格式,它支持使用SQ...
Spark SQL, Dataset,Dataframe之间的关系
Jackel_yan的博客
10-17 827
Spark SQL, Dataset, DataframeOverviewDataFrame功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程...
spark使用DataSet
serenysdfg的博客
03-05 589
本文中，我们介绍了Spark的基本概念，并通过spark shell演示了spark中的核心Api DataSet的使用。 在后面的文章中将会介绍spark中两个重要的扩展库Spark SQL和StructruedStreaming等,它们为数据的处理提供了更加方便和强大的操作。 Spark依然处于快速发展阶段中，其提供的功能可能随着版本的演进也会在不停的演进，就如RDD被DataSet替换，...
Spark中的DataFrame是什么？以及如何构建DataFrame？（附案例）
奇迹虎虎的博客
02-23 9929
在 Spark 中，DataFrame 是一种以 RDD 为基础的分布式数据集，是一种特殊的RDD，是一个分布式的表，类似于传统数据库中的二维表格。DataFrame 与 RDD 的主要区别在于，前者带有 schema 元信息，即 DataFrame 所表示的二维表数据集的每一列都带有名称和类型。
Spark Dataset
an13654067079的博客
08-12 1414
Spark Dataset
Spark_Day07：Spark SQL(DataFrame是什么和数据分析（案例讲解）)
Maynor的博客
07-25 762
Spark Day07：Spark SQL 主要讲解2个方面内容：Spark 调度内核和SparkSQL 快速体验。 1、Spark 内核调度 讲解Spark框架如何对1个Job作业进行调度执行，将1个Job如何拆分为Task任务，放到Executor上执行。 【以大数据经典案例：词频统计WordCount】 - 每个Job是RDD Action函数触发，比如fo.
Spark SQL之Dataset
派大星的博客
09-01 1087
Dataset
Spark DataFrame之创建DataFrame
Toby的博客
04-06 2789
创建DataFrame的各种例子代码，主要是用来构造测试用例，方便快速测试方法、UDF之类。 参考spark官方文档 总共15个例子，每个例子分别使用了scala和python语言code，两种语言的例子是一一对应的，序号相同的就是同一个例子。 包括Array、Seq数据格式存储的数据，包括稀疏向量、稠密向量的特征列，包括含有缺失值的列等，看完就再也不怕用各种奇形怪状的数据类型来创建DataFrame了。 一、In Scala 1、常规情况 val dataset = spark.create
Spark DataSet介绍
象在舞的技术专栏
04-25 7905
声明：代码主要以Scala为主，希望广大读者注意。本博客以代码为主，代码中会有详细的注释。相关文章将会发布在我的个人博客专栏《Spark 2.0机器学习》，欢迎大家关注。 Spark的发展史可以简单概括为三个阶段，分别为：RDD、DataFrame和DataSet。在Spark 2.0之前，使用Spark必须先创建SparkConf和SparkContext，不过...
spark java dataset例子
06-08
接下来，我们可以使用Encoder将DataFrame转换为类型安全的Java对象： ``` Encoder<MyObject> myObjectEncoder = Encoders.bean(MyObject.class); Dataset<MyObject> myObjects = df.as(myObjectEncoder); ``` 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

penngo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值