精华内容
下载资源
问答
  • 复合数据类型

    千次阅读 2018-07-12 00:22:12
    复合数据类型 主要内容 重点介绍以下四种常用复合数据类型: 数组 slice map 结构体 数组和结构体的长度是固定的;slice和map都是动态数据结构,它们的长度在元素添加到结构体中时可以动态增长 使用这些...

    复合数据类型

    主要内容

    1. 重点介绍以下四种常用复合数据类型:

      • 数组
      • slice
      • map
      • 结构体

      数组和结构体的长度是固定的;slice和map都是动态数据结构,它们的长度在元素添加到结构体中时可以动态增长

    2. 使用这些数据类型构成的结构化数据编码为json数据,从json数据转换为结构化数据

    数组

    数组是一个由固定长度且多个相同数据类型元素的序列。因此,无法添加或者删除元素。

    声明方式:

    // 第一种声明,初始化方式
    var q [3]int = [3]int{1, 2, 3}
    
    // 第二种:...表示数组的长度由初始化元素的个数决定
    q := [...]int{1, 2, 3}

    数组的长度也是数组类型的一部分

    // [3]int和[4]int是两种不同的数组类型
    q := [3]int{1, 2, 3}
    // 编译报错,理由如上
    q = [4]int{1, 2, 3, 4} 

    数组初始化:

    // 初始化索引的顺序是无关紧要的
    type Currency int
    const (
        USD Currency = iota // 美元
        EUR // 欧元
        GBP // 英镑
        RMB // 人民币
    ) 
    symbol := [...]string{USD: "$", EUR: "€", GBP: "£", RMB: "¥"}
    fmt.Println(RMB, symbol[RMB])
    
    // 定义了一个含有100个元素的数组r,最后一个元素被初始化为-1,其它元素都是用0初始化。
    r := [...]int{99: -1}

    数组间的比较:数组类型和元素类型确定能不能比较;元素相等决定数组相等

    a := [2]int{1, 2}
    b := [...]int{1, 2}
    c := [2]int{1, 3}
    // a与b数组类型相同,元素类型相同,可比较
    // a与b的各个元素相等,则a与b相等
    // a与c,b与c,数组类型相同,元素类型相同,元素不相等
    fmt.Println(a == b, a == c, b == c) // "true false false"
    d := [3]int{1, 2}
    // 编译错误,数组类型不同,不能比较
    fmt.Println(a == d) 

    函数调用参数传递:Go把数组和其他的类型都看成值传递,而在其他语言中,数组是隐式的使用引用传递

    显式地传入一个数组指针,那样的话函数通过指针对数组的任何修改都可以直接反馈到调用者。

    func zero(ptr *[32]byte) {
        //  ptr是指针变量,使用range只返回一个索引?
        for i := range ptr {
            // 将ptr数组清零
            ptr[i] = 0
        }
    }
    
    // 另一种清零写法
    func zero(ptr *[32]byte) {
        // [32]byte{}生成一个有你32字节元素的数组
        // 数组中每个元素的值是字节类型的零值,即0.
        // 
        *ptr = [32]byte{}
    }

    使用指针:1.高效。 2.允许被调函数修改调用方数组中的元素。

    slice

    Slice(切片)代表变长的序列,序列中每个元素都有相同的类型。

    slice的底层是数组,一个底层数组可以对应多个slice。
    months是底层数组,Q2和summer是slice。
    image

    slice 属性:

    - 指针:指向第一个slice元素对应的底层数组元素的地址,要注意的是slice的第一个元素并不一定就是数组的第一个元素
    - 长度:slice中元素的个数
    - 容量:一般是从slice的**开始位置**到**底层数据的结尾位置**
    

    slice操作符:左闭右开

    // s即序列或底层数组。引用了s的i到j-1索引位置的元素
    // 切片长度为:j-i
    s[i:j]
    // 引用了s的位置i到最后一个索引的元素
    s[i:]
    // 引用了s从0到j-1索引的元素。
    s[:j]
    // 引用整个数组
    s[:]

    引用异常:panic异常和slice扩容

    // 根据上图的显示,months有13个元素。
    // 初始化时,使用了 索引号:值的方式初始化。
    months := [...]string{1: "January", /* ... */, 12: "December"}
    // summer引用了months数组的6-8的元素。
    // 其中指针指向6,长度为3,容量为7(指针开始位置为6,底层数组的结束位置为12.)
    summer := months[6:9]
    // panic 异常,引用超过了被引用对象summer的容量。导致宕机
    fmt.Println(summer[:20]) 
    // endlessSummer的引用超出了被引用对象summer的长度3。
    // 因此endlessSummer**长度**会扩展到5.应用也会变为
    // 从6-11
    endlessSummer := summer[:5] 

    数组与slice初始化一点区别:

    // 数组有固定长度
    a := [...]int {0,1,2,3,4,5}
    // slice无固定长度
    s := []int{0,1,2,3,4,5}

    slice无法直接使用==做比较:slice的元素是非直接的,它可以包含自身;底层数组元素改变,同一个slice在不同的时间会有不同的元素。

    slice允许的比较操作:和nil比较。

    检查slice为空:使用len(s) == 0,而非 s==nil

    make创建slie:

    // 长度和容量相等
    make([]T, len)
    // 指定长度和容量
    make([]T, len, cap)
    展开全文
  • 2复合类型也称自定义数据类型%type复合数据类型 %type隐试将变量的数据类型指定为对应列的数据类型 语法 variable_name table_name.column_name%type 【【not null 】{:= | default} value】解释 将variable_...

    复合变量
    1可以将不同的数据类型的多个值存储在一个单元中
    2复合类型也称自定义数据类型

    %type复合数据类型
    %type隐试将变量的数据类型指定为对应列的数据类型
    语法
    variable_name table_name.column_name%type
    【【not null 】{:= | default} value】

    解释
    将variable_name 的数据类型设置为表中某个列的数据类型(table_name.column_name),当表的数据类型有变动后,相应的variable_name 的数据类型也发生改变

    这里写图片描述
    sno student.sno%type ;
    解释:定义变量sno 类型与表student.sno相同
    into:将查询的结果保存在变量中

    %rowtype复合数据类型
    1存储表的一行数据
    语法
    variable_name table_name%rowtype;

    * *

    这里写图片描述

    这里写图片描述
    结合上面2个图,可以将%rowtype定义的变量s看做是java中的一个对象,保存类student的数据,第二图错误的原因就是2个对象数据存入一个对象中,所以爆值过多。

    展开全文
  • PL/SQL复合数据类型包括:PL/SQL记录、PL/SQL表(索引表)、嵌套表、可变长数组。 复合数据类型的说明在本博客的《PL/SQL数据类型》中详述,这里对复合数据类型所使用到的方法做专题分析。
    Oracle PL/SQL集合数据类型专题:


    一、什么是PL/SQL集合数据类型
    PL/SQL复合数据类型包括:PL/SQL记录、PL/SQL集合(分为PL/SQL表(别名索引表)、嵌套表、VARRAY)。
    其中PL/SQL集合数据类型是指符合数据类型中的PL/SQL集合。


    复合数据类型的说明在本博客的《PLSQL数据类型》中有详述,这里只对PL/SQL集合数据类型的一系列特有操作与应用做讲述。




    二、PL/SQL集合的多级集合调用应用
    说明:多级集合是指嵌套了集合类型的集合类型,从而实现多维数组功能,9i后支持。


    1)多级PL/SQL表(索引表)
    说明:如果多维数组元素个数没有限制,可以使用多级PL/SQL表和嵌套表。
    Declare
    Type al_table_type is table of int index by binary_integer; --定义一维table
    Type nal_table_type is table of al_table_type index by binary_integer;--定义二维table集合
    Nv1 nal_table_type;
    Begin
    Nv1(1)(1):=10; 
    Nv1(1)(2):=5;                                                                                                
    Nv1(2)(1):=100; 
    Nv1(2)(2):=50;
    Dbms_output.put_line(‘显示二维数组所有元素’);
    For I in 1..nv1.count loop
      For j in 1..nu1(i).count loop
        Dbms_output.put_line(i||’,’||j||’shi’||nv1(i)(j));
      End loop;
    End loop;
    End;


    2)多级嵌套表
    Declare
    Type al_table_type is table of int;--定义一维嵌套表
    Type nal_table_type is table of al_table_type;--定义二维嵌套表集合
    Nv1 nal_table_typer :=nal_table_typer (al_table_type(2,4),al_table_type(5,73));
    Begin
    Dbms_output.put_line(‘显示二维数组所有元素’);
    For I in 1..nv1.count loop
      For j in 1..nv1(i).count loop
        Dbms_output.put_line(i||’,’||j||’shi’||nv1(i)(j));
      End loop;
    End loop;
    End;


    3)多级VARRAY
    Declare
    Type al_varray_type is varray(10) of int;--定义一维varray
    Type nal_varray_type is varray(10) of al_varray_type;--定义二维varray集合
    nvl nal_varray_type:= nal_varray_type(
    al_varray_type(58,100,102);
    al_varray_type(55,6,73);
    al_varray_type(2,4);
    begin
    dbms_output.put_line(‘显示二维数组所有元素’);
    for i in 1..nv1.count loop
      for j in 1..nv1.count loop
        Dbms_output.put_line(i||’,’||j||’shi’||nv1(i)(j));
      End loop;
    End loop;
    End;




    三、集合数据类型的方法
    说明:复合数据类型中PL/SQL集合类型所特有的集合方法,集合方法是Oracle所提供用于操纵集合变量的内置函数或过程。
    方法包含EXISTS、COUNT、LIMIT、FIRST、NEXT、PRIOR和NEXT是函数,EXTEND、TRIM和DELETE是过程。


    1、exists方法
    说明:确定特定的PL/SQL表元素是否存在,如果集合元素存在,则返回true;如果不存在,则返回false
    例子:
    declare
    type ename_table_type is table of emp.ename%type;
    ename_table ename_table_type;
    begin
    if ename_table.exsts(1) then
    ename_table(1):='scott';
    else
    dbms_output.put_line('必须初始化集合元素');


    2、count方法
    说明:返回当前集合变量中的元素总个数。
    declare
    type aneme_table_type is table of emp.ename%type index by binary_integer;
    ename_table ename_table_type;
    begin
    ename_table(-5):='aa';
    ename_table(1):='b';
    ename_table(10):='bk';
    dbms_output.put_line(ename_table.count);
    end;


    3、limit方法
    说明:返回集合元素的最大元素个数。因为嵌套表和索引表的元素个数没有限制,所以调用方法会返回NULL;而对于VARRAY会返回最大元素个数。
    declare
    type aneme_table_type is varray(20) of emp.ename%type;
    ename_table ename_table_type:=ename_table_type('mary');
    begin
    dbms_output.put_line(ename_table_type.limit);
    end;


    4、first和last方法
    说明:返回集合第一个、最后一个元素的下标。
    declare
    type aneme_table_type is table of emp.ename%type index by binary_integer;
    ename_table ename_table_type;
    begin
    ename_table(-5):='aa';
    ename_table(1):='b';
    ename_table(10):='bk';
    dbms_output.put_line(ename_table.first);
    dbms_output.put_line(ename_table.last);
    end;


    5、prior和next方法
    说明:返回当前集合元素的前一个元素和下一个元素


    举例:
    declare
    type ename_table_type is table of emp.ename%type index by benary_integer; --PL/SQL表
    ett ename_table_type;
    begin
    et(-5):='scott';
    et(1):='smith';
    st(5):='mary';
    dbms_output.put_line('元素1的前一个元素值:' || et(et.prior(1))); --结果是scott
    dbms_output.put_line('元素1的后一个元素值:' || et(et.next(1))); --结果是mary
    end;


    6、extend方法
    说明:为集合变量增加元素,只适用于嵌套表和VARRAY。
    格式:extend 添加一个null元素
    extend(n) 添加n个null元素
    extend(n,i) 添加n个值与第i个元素相同的元素


    举例:
    declare
    type id_table_type is table of number(6); --嵌套表
    idt id_table_type:=id_table_type(1,2,5); --声明并初始化3个元素
    begin
    if idt.exists(4) then --判读第四个元素是否存在
    dbms_output.put_line('元素值:' || idt(no));
    else
    dbms_output.put_line('元素未初始化'); --结果
    end if;
    idt.extend(999); --添加999个空元素
    dbms_output.put_line('第一个元素是:' || idt(idt.first)); --结果为1
    dbms_output.put_line('最后一个元素是:' || nvl(to_char(idt(idt.first)),'null')); --结果为null
    dbms_output.put_line('元素总数为:' || idt.count); --结果为1002
    end;


    7、trim方法
    说明:从集合尾部删除元素,只适用于嵌套表和VARRAY。
    格式:trim 删除一个元素
    trim(n) 删除n个


    举例:
    declare
    type id_array_type is varray(30) of number(6); --可变长数组
    iat id_array_type:=id_array_type('A','B','C','D','E','F','G','H','I','J','K','L');
    begin
    dbms_output.put_line('元素总数为:' || iat.count); --结果为12
    dbms_output.put_line('最大元素个数:' || iat.limit); --结果是30
    iat.trim(5);
    dbms_output.put_line('最后一个元素:' || iat(iat.last)); --结果是G
    end;


    8、delete方法
    说明:删除集合元素,只适用于嵌套表和索引表。
    格式:delete 删除全部元素
    delete(n) 删除第N个元素
    delete(m,n) 删除除集合变量中m~n之间的所有元素


    举例:
    declare
    type id_table_type is table of number(6) index by binary_integer; --PL/SQL表
    itt id_table_type;
    begin
    for i in 1..10000 loop
    itt(i):=i;
    end loop;
    for j in 1..itt.count loop
    if mod(j,2)=0 then
    id.delete(j); --余数为0则删除该元素
    end if;
    end loop;
    end;




    四、集合数据类型的赋值。
    当使用嵌套表和VARRAY时,通过执行insert、update、fetch、select,赋值语句,用可以将一个集合的数据赋值给另外一个集合。
    从Oracle10g开始,给嵌套表赋值时,还可以用set、multiset union、multiset intersect、multiset except等集合操作符。
    其中set用于取消嵌套表中的重复值,multiset union用于取得2个嵌套表的并集(带有distinct可以取消重复结果)
    multiset intersect取得2个嵌套表的交集,multiset except取得2个嵌套表的差集。


    1、将一个集合的数据赋值给另外一个集合
    说明:当使用赋值语句(:=)或sql语句将源集合中的数据赋值给目标集合时,会自动清除模板集合原有数据再赋值。
    注意:当进行集合赋值时,源集合和目标集合的数据类型必须一致。
    declare
    type name_varray_type is varray(4) of varchar2(10);
    name_array1 name_varray_type;
    name_array2 name_varray_type;
    begin
    name_array1:=name_varray_type('scott','smith');
    name_array2:=name_varray_type('a','a','a','a','a');
    dbms_output.put('2的原数据:');
    for i in 1..name_array2.count loop
    dbms_output.put(name_array2(i));
    end loop;
    dbms_output.new_line;
    name_array2:=name_array1;
    dbms_output.put('2的新数据:');
    for i in 1..name_array2.count loop
    dbms_output.put(name_array2(i));
    end loop;
    dbms_output.new_line;
    end;


    2、给集合符NULL值
    说明:在清空集合变量的所有数据时,既可以使用集合delete和trim,也可以讲一个null集合变量赋给目标集合变量。
    declare
    type name_varray_type is varray(4) of varchar2(10);
    name_array1 name_varray_type;
    name_array2 name_varray_type;
    begin
    name_array1:=name_varray_type('scott','smith');
    dbms_output.put('2的原数据个数'||name_array1.count);
    name_array1:=name_array2;
    --dbms_output.put('2的新数据个数'||name_array1.count);
    end;


    3、使用集合操作符给嵌套表赋值
    说明:10g开始,允许将多个嵌套表的结果组合到某个嵌套表中,通过使用ANSI集合操作符(set,multiset union,
    multiset intersect,multiset except)实现。


    1)、set操作符
    说明:用于去掉嵌套表中的重复值。
    declare
    type nt_table_type is table of number;
    nt_table nt_table_type:=nt_table_type(2,4,3,1,2);
    result nt_table_type;
    begin
    result:=set(nt_table);
    dbms_output.put('result:');
    for i in 1..result.count loop
    dbms_output.put(' '||result(1));
    end loop;
    dbms_output.new_line;
    end;


    2)、multiset union和multiset union distinct操作符
    说明:multiset union取得2个嵌套表的并集,保留重复项;multiset union distinct去掉重复。
    declare 
    type nt_table_type is table of numberr;
    nt1 nt_table_type:=nt_table_type(1,2,3);
    nt2 nt_table_type:=nt_table_type(3,4,5);
    result nt_table_type;
    begin
    result:=nt1 multiset union nt2;
    dbms_output.put('resilt:');
    for i in 1..result.count loop
    dbms_output.put(' '||result(i));
    end loop;
    dbms_output.new_line;
    end;


    3)、multiset intersect操作符
    说明:取得2个嵌套表的交集。
    declare 
    type nt_table_type is table of numberr;
    nt1 nt_table_type:=nt_table_type(1,2,3);
    nt2 nt_table_type:=nt_table_type(3,4,5);
    result nt_table_type;
    begin
    result:=nt1 multiset intersect nt2;
    dbms_output.put('resilt:');
    for i in 1..result.count loop
    dbms_output.put(' '||result(i));
    end loop;
    dbms_output.new_line;
    end;


    4)、multiset except操作符
    说明:取两个嵌套表变量的差集。
    declare 
    type nt_table_type is table of numberr;
    nt1 nt_table_type:=nt_table_type(1,2,3);
    nt2 nt_table_type:=nt_table_type(3,4,5);
    result nt_table_type;
    begin
    result:=nt1 multiset except nt2;
    dbms_output.put('resilt:');
    for i in 1..result.count loop
    dbms_output.put(' '||result(i));
    end loop;
    dbms_output.new_line;
    end;




    五、集合数据类型的比较
    说明:用于比较两个集合变量是否相同。
    10g后新增集合比较操作符包括:
    CARDINALITY(返回嵌套表变量的元素个数),
    SUBMULTISET OF(确定一个嵌套表是否为领一个嵌套表的子集),
    MEMBER OF(检测特定数据是否为嵌套表元素),
    IS A SET(检测嵌套表是否包含重复的元素),
    IS EMPTY(检测嵌套表是否为null)等。


    1、检测集合是否为null
    说明:is null使用于嵌套表或VARRAY变量;is empty只使用于嵌套表。
    declare
    type name_array_type is varray(3) of varchar2(10);
    name_array nane_array_type;
    begin
    --if name_array is empty then
    if name_array is null then
    dbms_output.put_line('未初始化');
    end if;
    end;


    2、比较嵌套表是否相同
    说明:使用=和!=比较嵌套表是否相同,只能用于嵌套表。
    declare
    type name_table_type is table of varchar2(10);
    name_table1 name_table_type;
    name_table2 name_table_type;
    begin
    name_table1:=name_table_type('scott');
    name_table2:=name_table_tyoe('smith');
    if name_table1=name_table2 then
    dbms_output.put_line('相同');
    else
    dbms_output.put_line('不同');
    end if;
    end;


    3、在嵌套表上使用ANSI集合操作符
    说明:这些操作符只适用于嵌套表。


    1)、CARDINALITY
    说明:也可以称为函数,返回嵌套表变量的元素个数。
    declare
    type nt_table_type is table of number;
    nt1 nt_table_tyoe:=nt_table_type(1,2,3,1);
    begin
    dbms_output.put_line('元素个数'||CARDINALITY(nt1));
    end;


    2)、SUBMULTISET OF
    说明:用于确定一个嵌套表是否为另一个嵌套表的子集。
    declare
    type nt_table_type is table of number;
    nt1 nt_table_type:=nt_table_type(1,2,3);
    nt2 nt_table_type:=nt_table_type(1,2,3);
    begin
    if nt1 submiltiset of nt2 then
    dbms_output.put_line('nt1是nt2的子集');
    end if;
    end;


    3)、MEMBER OF
    说明:检测特定数据是否为嵌套表的元素。
    declare
    type nt_table_type is table of number;
    nt1 nt_table_tyoe:=nt_table_tyoe(1,2,3,5);
    v1 number:=2;
    begin
    if v1 member of nt1 then
    dbms_output.put_line('v1是nt1的元素');
    end if;
    end;


    4)、IS A SET
    说明:用于检测嵌套表是否包含重复的元素值。
    declare
    type nt_table_type is table of number;\
    ot1 nt_table_type:=nt_table_type(1,2,3,5);
    begin
    if nt1 is a set then
    dbms_output.put_line('嵌套表nt1无重复值');
    end if;
    end;




    六、集合数据类型的批量绑定
    说明:9i新增,是指执行单次SQL操作能传递所有集合的数据,当在select、insert、update、delete
    语句上处理批量数据时,通过批量绑定,可以极大加快数据处理速度。
    批量绑定用bult collect子句和forall语句完成,其中bult collect子句用于取得批量数据,
    该子句只能用于select语句、fetch语句、dml返回子句中;而forall语句值适用于执行批量DML操作。


    1、使用与不使用批量绑定的区别


    1)、不适用批量绑定
    说明:9i之前,为了将多个集合元素插入到数据库表,必须要使用循环完成。
    例子:以索引表为例
    declare
    type id_table_type id table of number(6) index by binary_integer;
    type name_table_type is table of varchar2(10) index by binary_integer;
    id_table id_table_type;
    name_table name_table_type;
    start_time number(10);
    end_time number(10);
    begin
    for i in 1..5000 loop
    id_table(i):=i;
    name_table(i):='Name'||to_char(i);
    end loop;
    start_time:=dbms_utility.get_time;
    for i in 1..id_table.count loop
    insert into demo values(id_table(i),name_table(i));
    end loop;
    end_time:=dbms_utility.get_time;
    dbms_output.put_line('总时间'||to_char((end_time-start_time)/100));
    end;


    2)、使用批量绑定
    declare
    type id_table_type id table of number(6) index by binary_integer;
    type name_table_type is table of varchar2(10) index by binary_integer;
    id_table id_table_type;
    name_table name_table_type;
    start_time number(10);
    end_time number(10);
    begin
    for i in 1..5000 loop
    id_table(i):=i;
    name_table(i):='Name'||to_char(i);
    end loop;
    start_time:=dbms_utility.get_time;
    --批量绑定的使用开始
    forall i in 1..id_table.count
    insert into demo values(id_table(i),name_table(i));
    --批量绑定的使用结束
    end_time:=dbms_utility.get_time;
    dbms_output.put_line('总时间'||to_char((end_time-start_time)/100));
    end;


    2、FORALL语句
    说明:当要在PL/SQL中执行批量insert、update、delete操作,可以使用forall语句。
    9i前forall语句必须是连续的元素;10g后通过增加indices of子句和values of子句,可以使用不连续的集合元素。
    注意:for语句时循环语句,forall不是循环语句。如下面语法,9i只有语法一,10g后新增了语法二、三。


    语法一:forall i in lower_bound..upper_bound sql_statement;
    其中,i是隐含定义的整数变量(将作为集合元素下标被引用),lower_bound和upper_bound是集合元素上下界。


    语法二:forall i in indices of collection [between lower_bound and upper_bound] sql_statement;
    其中,indices of指定只取对应于collection集合元素下标的i值。


    语法三:forall i in values of index_collection sql_statement;
    其中,values of指定i值从集合变量index_collection中取得。


    1)、DML语句上使用批量绑定
    说明:使用批量绑定为数据库表插入数据时,首先需要给集合元素赋值,然后使用forall语句执行批量绑定插入操作。
    declare
    type id_table_type id table of number(6) index by binary_integer;
    type name_table_type is table of varchar2(10) index by binary_integer;
    id_table id_table_type;
    name_table name_table_type;
    begin
    for i in 1..50 loop
    id_table(i):=i;
    name_table(i):='Name'||to_char(i);
    end loop;
    forall i in 1..id_table.count
    insert into demo values(id_table(i),name_table(i));
    update demo set name=name_table(i) where id=id_table(i);
    delete from demo where id=id_table(i);
    commit;
    end;


    2)、FORALL语句中使用部分集合连续的元素
    说明:上面说到的都是集合的所有元素,forall可以使用部分元素。
    declare
    type id_table_type id table of number(6) index by binary_integer;
    id_table id_table_type;
    begin
    for i in 1..50 loop
    id_table(i):=i;
    end loop;
    forall i in 8..10
    insert into demo values(id_table(i),name_table(i));
    commit;
    end;


    3)、forall语句上使用indices of子句
    说明:indices of子句是10g新增,用于跳过集合中的null元素。
    declare
    type id_table_tyoe is table of number(6);
    id_table id_table_type;
    begin
    id_table:=id_table_type(1,null,3,null,5);
    forall i in indicrs of id_table
    delete from demo where id=id_table(i);
    end;


    4)、forall语句上使用values of子句
    说明:values of子句是10g新增,用于从其他集合中取得集合下标的值。
    declare
    type id_table_type is table of demo.id%type;
    type name_table_type is table of demo.name%type;
    id_table id_table_type;
    name_table name_table_type;
    type index_pointer_type is table of pls_integer;
    index_pointer index_pointer_type;
    begin
    select * bulk collect into id_table,name_table from demo;
    index_pointer:=index_pointer_type(6,8,10);
    forall i in values of index_pointer
    insert into new_demo_table2 values(id_table(i),name_table(i));
    end;
    --结果是向表中插入了6 8 10的数据


    5)、forall语句上使用SQL%BULK_ROWCOUNT属性
    说明:专门为forall语句提供的属性,用于取得执行批量绑定是第i个元素所作用的行数。
    declare
    type dno_table_type is table of number(3);
    dno_table dno_table_type:=dno_table_type(10,20);
    begin
    forall i in 1..dno_table.count
    update emp set sal=sal*1.1 where deptno=dno_table(i);
    dbms_output.put_line('第2个元素更新的行数:'||SQL%BULK_ROWCOUNT(2));
    end;


    3、BULK COLLECT子句
    说明:用于取得批量数据,将批量数据存放到PL/SQL集合变量中,只用于select into、fetch into和dml返回子句中。
    语法:。。。BULK COLLECT into collection_name[,collection_name]。。。
    其中,collection_name指定存放的集合变量名


    1)、在select into语句中使用bulk collect
    说明:9i前,select into必须且只能返回1行数据,否者抛异常,9i开始通过在elect into使用bulk collect子句可以
    一次将select语句的多行结果检索到集合变量。
    declare
    type emp_table_type is table of emp%rowtype index by binary_integer;
    emp_table emp_table_type;
    begin
    select * bulk collect into emp_table from emp where deptno=&no;
    for i in 1..emp_table.count loop
    dnms_output.put_line('emp_table(i).ename');
    end;


    2)、在DML的返回子句中使用bulk collect子句
    说明:为了取得DML操作所改变的数据,可以使用returning子句;为了取得DML所作用的多行数据,需要使用bulk collect子句。
    declare
    type ename_table_type is table of emp.ename%type;
    ename_table ename_table_type;
    begin
    delete from emp where deptnp=&no returning ename bulk collect into ename_table;
    dbms_output.put('雇员名:');
    for i in 1..ename_table.count loop
    dbms_output.put(ename_table(i));
    end loop;
    end;




    展开全文
  • Java复合数据类型

    千次阅读 2020-02-01 12:28:06
    在 Java 中字符串被作为 String 类型的对象处理。String 类位于 java.lang 包中,默认情况下该包自动导入。 String对象创建后不会被修改,当我们修改某个字符串对象实际上是将原引用指向了新创建的内存空间。并且...

    1、Java字符串

    在 Java 中字符串被作为 String 类型的对象处理。 String 类位于 java.lang 包中,默认情况下该包自动导入。

    String对象创建后不会被修改,当我们修改某个字符串对象实际上是将原引用指向了新创建的内存空间。并且相同的字符串常量Java不会分配两个内存空间,而是将两个引用指向相同的空间。

    public class MyString {
        public static void main(String[] args) {
            String s1="字符串";
            String s2="字符串";
            String s3=s1;
            System.out.println(s1==s2);     // s1、s2字符串内容相同,指向相同的内存空间,输出:true
            System.out.println(s1==s3);     // 修改之前s1与s3相同,输出:true
            s1="修改字符串";
            System.out.println(s1==s3);     // 修改之后s1指向新的内存空间,与s3不同,输出:false
        }
    }
    

    String中常用的方法:

    str.length()    //返回当前字符串的长度
    str.indexOf(int ch)    //查找ch字符在该字符串中第一次出现的位置,若无返回-1
    str.indexOf(subStr)    //查找str子字符串在该字符串中第一次出现的位罝
    str.lastIndexOf(ch)    //查找ch字符在该字符串中最后一次出现的位置
    str.lastlndexOf(subStr)查找St子字符串在该字符串中最后一次出现的位置
    str.substring(beginlndex)    //获取从beginlndex位置幵始到结朿的子字符串
    str.substring(beginlndex, endlndex)    //获取从beginlndex位置幵始到endlndex位M的子字符串
    str.trim()        //返回去除了前后空格的字符串
    str.equals(obj)        //将该字符串与指定对象比较,返回true或false
    str.toLowerCase()        //将字符串转换为小写
    str.toUpperCase()        //将字符串转换为大写
    str.charAt(int index)    //获取字符串中指定位置的字符
    str.setCharAt(i,c)    //设置某个位置的字符串
    str.split(String regex, int limit)        //将字符串分割为子字符串,返回字符串数组
    str.concat(str2)        //将str2拼接到末尾
    str.getBytes()        /将该字符串转换为byte数组
    str.toCharArray()        //转化为字符数组

    如果需要使用经常修改的字符串,可以用StringBuilder类来保存,可以通过append、replace等方法对字符串进行修改,修改之后仍然指向同一块内存地址

    public class MyString {
        public static void main(String[] args) {
            StringBuilder s4=new StringBuilder("初始字符串");
            StringBuilder s5=s4;
            s4.replace(0,10,"修改后的字符串");
            System.out.println(s4);
            System.out.println(s4==s5);     // 修改后仍然指向同一块内存,因此输出:true
        }
    }
    

     通过String.valueOf()可以将其他类型数据转化为字符串。

    char[] arr={'a', 'd', 'e'};
    String s=String.valueOf(arr);

    2、Java中的包装类

    Java中的基本数据类型如int、double等都不具有对象的特性,为了像其他对象一样拥有自己的方法,Java为每个基本数据类型提供了包装类,像对象那样来操作基本数据类型。包装类的基本方法用于实现类型之间的相互转换。

    Java包装类可以自动装箱/拆箱,即通过=运算符自动完成基本类型和包装类之间的类型转换。

                    // 定义int类型变量,值为86
    		int score1 = 86;       
    		// 使用int创建Integer包装类对象,手动装箱
    		Integer score2=new Integer(score1);  
                    Integer score2=score1;    //自动装箱      
    		// 将Integer包装类转换为double类型
    		double score3=score2.doubleValue();        
    		// 将Integer包装类转换为float类型
    		float score4=score2.floatValue();        
    		// 将Integer包装类转换为int类型,手动拆箱
    		int score5 =score2.intValue();	
                    int score5 = score2        // 自动拆箱	
    		// 将字符串转为int
    		int score6 = Integer.parseInt("666");

    基本类型与字符串之间的互相转换:

       

    通过Integer.MAX_VALUE可以获得最大整数值

    使用 java.util 包中的 Date 类可以创建时间对象,使用java.text 包中的 SimpleDateFormat 类可以将时间转化为所需格式的字符串,其中 “yyyy-MM-dd HH:mm:ss” 为预定义字符串, yyyy 表示四位年, MM 表示两位月份, dd 表示两位日期, HH 表示小时(使用24小时制), mm 表示分钟, ss 表示秒,这样就指定了转换的目标格式,最后调用 format() 方法将时间对象Date转换为指定的格式的字符串,反之parse()方法可以将普通字符串转化为Date对象。

    java.util.Calendar 类可以更加方便地进行时间的处理,通过调用 getInstance() 静态方法获取一个 Calendar 对象,默认代表当前时间,可以通过c.getTime()将其转化为Date对象。Calendar对象的更多方法如下

    Math 类位于 java.lang 包中,包含用于执行基本数学运算的方法, Math 类的所有方法都是静态方法,所以使用该类中的方法时,可以直接使用类名.方法名,如: Math.round();

    int minNum=Math.min(2, 3);    //获取最小值
    int maxNum=Math.max(2, 3);    //获取最大值
    
    long round=Math.round(3.1415);      //四舍五入
    double floor=Math.floor(3.1415);    //向下取整
    double ceil=Math.ceil(3.1415);      //向上取整
    double random=Math.random();        //取[0,1)之间的随机数

    3、Java容器

    在各种基本数据类型的基础上,Java使用集合类当作容器来储存具有相同属性的对象。通过集合类组织数据可以实现对特定数据的快速插入、删除与查询操作。而且与数组相比,集合的长度灵活可变,而且查找方式也不只有下标一种。Java中常见的集合类分为两个接口Collection和Map,其中Collection有三个子接口链表List、队列Queue、集Set,List常见的实现类为数组序列ArrayList,Queue实现类为LinkedList称为链表,Set实现类为哈希集。Collection中按照一个一个对象来存储数据,Map中按照键值对<key,value>来存储数据。

    Collection接口规定了ArrayList、Set等具体实现类的接口方法,例如它们都使用add()方法来添加元素,因此一些方法名在各个类实现中是通用的。

    ArrayList

    ArrayList是类似于数组的容器,将对象储存进ArrayList之中便于组织和管理。通过add()方法可以将单个对象插入列表,addAll()可以将多个对象组成的子列表插入父列表中,插入时可以指定插入的位置,可以通过Arrays.asList()将数组转化为列表,通过toArray()方法可以将列表转为Object[]数组,可以向其中传入泛型参数从而返回特定类型的数组。

    需要注意的是通过Arrays.asList()转化成的List长度是固定的,不能进行add()操作,会报错;我们可以将其作为子列表添加到一个新的List列表,然后再进行插入操作。

    例如向列表courseList中插入Course对象:

    public void addCourse(){
        Course c1=new Course(1,"数据结构");
        Course c2=new Course(2,"操作系统");
        Course[] cArr={new Course(3,"组成原理"),new Course(4,"计算机网络")};
    
        courseList.add(c1);                         // 向数组列表中添加对象
        courseList.add(0,c2);                 // 向指定位置添加对象
        courseList.addAll(Arrays.asList(cArr));     // 向列表中添加子列表,前加数字表示插入位置
        Course tmp=(Course)courseList.get(0);       // 从列表中取出对象
        Course[] courseArr=courseList.toArray(new Course[courseList.size()]);    // 转换为特定类型的数组
    }

    特别地,int[]与List<Integer>之间无法直接使用asList()/toArray()方法进行互相转换,可以经过如下流操作,或者遍历int[]逐个添加到List

    int[] nums=new int[]{3,1,5,8};
    //arr转list
    List<Integer> numList = Arrays.stream(nums).boxed().collect(Collectors.toList());
    //list转arr
    int[] arr = numList.stream().mapToInt(Integer::valueOf).toArray();

    通过size()方法可以获取列表长度,通过get()方法可以获取指定位置的对象,进而通过for循环遍历每个对象,也可以使用for each的方式遍历每个元素。还可以通过迭代器实现对每个对象的访问。值得注意的是,每个对象在列表中都是以Object对象的方式储存的,因此在取出之后需要通过强制类型转换为原来的对象类型,例如(Course)转为Course类的对象

        public void showCourse(){
            int listLength=courseList.size();           // 获取列表长度
            for (int i=0;i<listLength;i++) {
                Course c=(Course)courseList.get(i);     // 获取列表第i个元素
                System.out.println(c.name);
            }
        }
    
        public void iteratorCourse(){
            Iterator it=courseList.iterator();          // 获取迭代器
            while (it.hasNext()){                       // 如果仍有下一个元素
                Course c=(Course)it.next();             // 取出下一个元素
                System.out.println(c.name);
            }
        }

    通过set()方法对列表指定位置的元素进行修改。通过remove()方法移除指定位置或者指定对象。通过removeAll()删除父列表中包含的所有子列表中的元素,通过clear()可以清空列表。

        public void modifyCourse(){
            courseList.set(2,new Course(5,"离散数学"));     // 修改2位置上的对象
        }
    
        public void removeCourse(){
            courseList.remove(3);               // 删除3位置上的对象
            Course c1= (Course) courseList.get(1);
            Course c2=(Course) courseList.get(2);
            courseList.remove(c1);                      // 删除指定对象
            Course[] cArr={c1,c2};
            courseList.removeAll(Arrays.asList(cArr));  // 删除courseList中所包含的cArr的元素
        }

    通过contains()containsAll()方法判断List是否包含某个或者某几个对象,其实现原理是遍历List中的每个对象调用其equals()方法和目标对象进行比较,如果存在返回true,否则返回false。因此我们可以重写Course类的equals()方法,进而调用contains()方法判断List中是否包含指定Course对象。类似地indexOf()方法可以通过调用equals()找到元素在List中第一次出现的位置。

        // 重写Course类的equals()方法
        public boolean equals(Object o) {
            if (this == o) return true;     // 如果两个对象的地址相同,肯定相同
            if (!(o instanceof Course)) return false;
            Course course = (Course) o;
            return id == course.id &&       // 判断两个Course对象的id和name相同
                    name.equals(course.name);
        }
    
        // 在CourseList中调用contains()判读是否包含某个对象
        public void containCourse(){
            Course nc=new Course(5,"数据结构");
            if(courseList.contains(nc)) {                     // 判断List中是否包含Course对象nc
                int index = courseList.indexOf(nc);           // 获取元素在List中的位置
                System.out.println("列表中包含该课程,位置:" + index);
            }
        }

    之前提到集合中存放的都是对象的引用(Object),每次存入时集合会忽略对象的具体类型,有时存入其他类型对象则会在运行时出错,而且每次取出时则需要进行类型的强制转换还原回来。可以使用泛型规定某个集合只能存放特定类型或者其子类型的对象,这样就会在编译期间进行类型检查,而且在取出时可以直接返回特定类型的对象。注意泛型不能用于基本数据类型,例如List <int>会报错,而应该使用其包装类List <Integer>。

        // 创建元素类型为Course的列表
        public List<Course> courseList=new ArrayList<Course>();
    
        public void addCourse(){
            Course c=new Course(6,"数据结构");
            courseList.add(c);
    //        courseList.add("字符串");    // 尝试向列表中添加非Course类型的对象,报错
            Course c2=courseList.get(0);        // 可以直接取出为Course类型对象
            System.out.println(c2.name);
        }

    通过集合的工具类Collections.sort()方法可以实现对List对象的排序,其实现的原理是调用每个元素的compareTo()方法实现对象之间的比较进而排序。因此每个对象必须是可比较的类型,即必须实现了Comparable 接口的对象,如下所示首先定义可比较类Student,再定义学生列表studentLis添加学生对象后,调用Collections.sort()方法对列表进行排序,或者直接使用studentList.sort()。

    public class Student implements Comparable<Student> {   // 定义Student类实现Comparable接口
        public String name;
        public int id;
    
        public Student(int id, String name) {
            this.name = name;
            this.id = id;
        }
    
        @Override
        public int compareTo(Student o) {        // 实现接口的方法,根据id大小对学生进行比较
            if (this.id>o.id){          // 如果大于o返回1
                return 1;
            }else if (this.id<o.id){    // 小于返回-1
                return -1;
            }else {                     // 等于返回0
                return 0;
            }
        }
    }
    
    public class ListSort {
        public List<Student> studentList=new ArrayList<Student>();    // 学生列表
    
        public void sortStudent(){
            Student s1=new Student(1011,"小明");
            Student s2=new Student(1005,"小赵");
            Student s3=new Student(1021,"小钱");
            Student[] sArr={s1,s2,s3};
            studentList.addAll(Arrays.asList(sArr));
            Collections.sort(studentList);                // 调用方法对学生列表进行排序
            for (Student s:studentList) {
                System.out.println(s.id+":"+s.name);
            }
        }
    }

    也可以在调用sort()方法时传入一个自定义的比较器对象Comparator,通过重写compare()方法来实现两个对象的比较。这里很明显可以看到上面的Comparable接口是被比较对象自身实现的,用于自身和其他对象比较;而Comparator是第三方对象实现的接口,用于比较两个对象。

    // 自定义比较器类来实现两个Student对象的比较
    public class StudentComparator implements Comparator<Student> {
        @Override
        public int compare(Student o1, Student o2) {
            if (o1.id>o2.id){          // 如果大于o返回1
                return 1;
            }else if (o1.id<o2.id){    // 小于返回-1
                return -1;
            }else {                     // 等于返回0
                return 0;
            }
        }
    }
    
    // 调用sort()方法时传入比较器
    Collections.sort(studentList,new StudentComparator());
    

    HashSet

    哈希集是Set的一个实现类,与list不同,set中的元素是无序且不可以重复的。

    和List一样,在Set中通过add()remove()等方法实现元素的增加删除等操作。由于Set是无序的,因此没有set()、get()方法实现在指定位置插入/获取元素,在遍历元素时通过for each、iterator来实现,而且每次遍历的结果顺序是不确定的。

    注意HashSet中的contains()方法会首先调用对象的hashCode()方法比较哈希码,再调用equals()方法,两个都为true才会认为两个对象相同。

    例如通过HashSet来存储学生所选课程

    public class Student {
        public String name;
        public int id;
        public Set<Course> courses;     // 用set保存学生所选课程
    
        public Student(int id, String name) {
            this.name = name;
            this.id = id;
            this.courses=new HashSet<Course>();     //创建Hash集
        }
    
        public static void main(String[] args){
            Course c=new Course(1,"数据结构");
            Student s=new Student(101,"小明");     
            s.courses.add(c);               // 向集中添加对象
            for (Course course:s.courses) {         // 遍历集
                System.out.println(course.name);
            }
        }
    }

    HashMap

    Map以一一对应的键值对<key,value>的形式储存数据,通过映射关系可以实现key快速查找value,key值不能重复。Map也支持泛型Map<K,V>,注意K,V不能是Java类,而是包装类。

    通过put(key,value)向Map中添加键值对,get(key)通过键获取值,remove(key)移除键。修改Map键值对也使用put()方法,新的键值对会覆盖原有的值。通过containsKey(key)方法可以返回Map中是否包含某个key值,containsValue(value)返回Map中是否包含某个值,它通过调用对象的equals()方法比较来返回是否存在。

    还可以通过keySet()、values()、entrySet()方法分别获取Map的键、值、键值对,返回的键值对Entry仍然可以定义泛型类型。

        // 创建存储学生类的哈希Map
        public Map<Integer,String> studentMap=new HashMap<Integer, String>();
    
        public void addStudent(){
            Scanner input=new Scanner(System.in);
            System.out.print("请输入学生ID:");
            int studentID=input.nextInt();
            String s=studentMap.get(studentID);        // 根据key值获取对应的value
            if (s!=null){                              // 如果s不为空说明该key已经存在
                System.out.println("该学生ID已存在!");
            }else {
                System.out.print("请输入姓名:");
                String name=input.next();
                studentMap.put(studentID,name);     // 将<ID,name>键值对添加到Map中
            }
        }
    
        public void showStudent(){            //通过foreach遍历HashMap
            // 获取Map的键值对Entry并对其泛型进行定义
            Set<Map.Entry<Integer,String>> entrySet=studentMap.entrySet();
            for(Map.Entry<Integer,String> entry:entrySet){
                int key= entry.getKey();                    // 从Entry中获取key
                String name=entry.getValue();               // 从Entry中获取value
                System.out.println(key+":"+name);
            }
        }
    
        public void showStudent2(){            //通过迭代器遍历HashMap
          Iterator iter = studentMap.entrySet().iterator();
          while (iter.hasNext()) {
              Map.Entry entry = (Map.Entry) iter.next();
              Int key= entry.getKey();
              String name = entry.getValue();
                System.out.println(key+":"+name);
            }
      }

    4、工具类

    Stack

    栈的创建和简单使用如下所示

            Stack<Integer> st = new Stack<>();      //新建栈
            st.push(3);
            int peek=st.peek();     //获取栈顶元素
            System.out.println(peek);
            int pop=st.pop();       //弹出栈顶元素
            System.out.println(pop);
            System.out.println(st.empty());     //判断栈是否为空

    Queue

    LinkedList类实现了Queue接口,因此我们可以把LinkedList当成Queue来用。队列的使用如下

            Queue<Integer> queue = new LinkedList<>();    //创建并初始化队列
            queue.offer(1);     //元素入队
            queue.offer(3);
            queue.offer(5);
            
            for(int num:queue)      //遍历队列
                System.out.println(num);
            int pNum=queue.peek()    //获取第一个元素
            int qNum=queue.poll();  //元素出队
            System.out.println(qNum);

     

    展开全文
  • JAVA的简单数据类型和复合数据类型

    千次阅读 2013-05-01 20:31:14
    Java的简单数据类型 数据类型 数据类型就是对内存位置的抽象表达。程序员可以利用多种数据类型:某些由编程语言定义,某些由外部库定义,还有些则由程序员来定义。很多编程语言都依赖于特定的计算机类型和对...
  • Oracle复合数据类型

    2008-11-15 11:29:00
     PL/SQL 记录 记录是PL/SQL的一种复合数据结构,scalar数据类型和其他数据类型只是简单的在包一级进行预定义,但复合数据类型在使用前必须被定义,记录之所以被称为复合数据类型是因为他由域这种由数据元素的逻辑...
  • 数据类型分为:标量数据类型,复合数据类型,特殊数据类型1.标量数据类型:是数据结构中最基本单元,只能储存一个数据,包括boolean,string,integer,float1.1string类型:定义字符串与三种方式:单引号(‘)、双...
  • js中的基本数据类型和复合数据类型

    千次阅读 2018-07-15 22:41:37
      基本数据类型:   1、数值类型:整数和浮点数 ...2、布尔类型:true和false ...3、字符串类型:用引号括起来,可以双引号,也可以单引号 ...4、undefined类型:...复合数据类型:     1、对象:Object  ...
  • 数仓工具—Hive复合数据类型(9)

    万次阅读 2020-12-25 22:50:21
    除了使用`string`之外的基础数据类型,Hive中的列支持使用struct, map, array,union_type 等复合数据类型。 复合类型是指array、map、struct和uniontype,一般在企业中使用 array和map会比较多一些。
  • 其中,基础数据类型包括:TINYINT,SMALLINT,INT,BIGINT,BOOLEAN,FLOAT,DOUBLE,STRING,BINARY,TIMESTAMP,DECIMAL,CHAR,VARCHAR,DATE。下面的表格列出这些基础类型所占的字节以及从什么版本开始支持这
  • C语言之复合数据类型

    2018-11-27 17:26:25
    复合数据类型思维导图结构体基础结构体内存对齐模式为什么要进行内存对齐?内存对齐原则系统默认对齐系数结构体位域共用体定义、初始化和使用:大小端模式:枚举 思维导图 结构体基础 结构体类型的定义与声明 ...
  • 2.1 复合数据类型 复合数据类型是以组合的方式通过组合其它数据类型数据来获得。 2.2.1 Strings 字符串类型是由字符组成的序列(不能和symbols混淆,symbols仅是由一组字符来命名的简单类型)。你可以通过将...
  • Hive中的复合数据类型

    千次阅读 2019-12-03 23:19:27
    在正式开始之前,先让我们来看下Hive中所有的数据类型吧! 数字类 类型 长度 备注 TINYINT 1字节 符号整型 SMALLINT 2字节 符号整型 INT 4字节 符号整型 BIGINT 8字节 符号整型 FLOAT 4字节...
  • 复合数据类型叫对象,这个对象不是女朋友,也不是男朋友哈。
  • JavaScript的数据类型有哪些

    千次阅读 2019-02-16 20:30:15
    JavaScript的数据类型有哪些? 基本数据类型:字符串 String、数字 Number、布尔Boolean 复合数据类型:数组 Array、对象 Object 特殊数据类型:Null 空对象、Undefined 未定义 ...
  • hive复合数据类型之array

    万次阅读 2016-09-02 18:40:23
    ARRAY:ARRAY类型是由一系列相同数据类型的元素组成,这些元素可以通过下标来访问。比如一个ARRAY类型的变量fruits,它是由['apple','orange','mango']组成,那么我们可以通过fruits[1]来访问元素orange,因为...
  • PHP数据类型有哪些

    2016-06-16 02:47:57
    三大类: 1、基本数据类型: 整数型(integer),可以是正、负...2、复合数据类型: 数组(array) 对象(object) 3、特殊数据类型: null() 资源类型(resource) 注:1>在下列情况下一个变量被认为是 NULL:
  • C语言学习之复合数据类型

    千次阅读 2012-05-06 21:15:43
    结构体它的成员可以是基本数据类型,也可以是复合数据类型。 1. 结构体类型的定义 struct point {  int x;  int y; }; 注意结构体类型的定义要以';'结尾。定义了一个结构体类型就相当于新定义了一个数据类型,...
  • Js_复合数据类型

    千次阅读 2012-02-21 14:56:33
    复合数据类型 //对象和数组 //对象是js中封装了一套操作方法和属性的类实例 //常用的内置对象 //在面向对象的设计模式中,将数据和处理数据的方法捆绑在一起形成一个整体,成为对象 //可以使用new...
  • 在C++中常用的复合数据类型,一种是结构体,另一种就是枚举类型。struct对于struct来说,如果出现在顶层函数,并作为顶层函数参数的时候,struct里的scalar变量就会被映射scalar类型的端口,数组就会被映射为相应的...
  • Hive复合数据类型array,map,struct的使用

    千次阅读 2016-12-27 12:20:40
    1.array的用法 2.map的用法 ...Hive中复合数据类型Array,Map,Struct的操作 The following functions construct instances of complex types. Constructor Function Operands Descript...
  • C语言支持的数据类型有字符型、整型(符号和无符号)、浮点型、boolean类型等的,需要注意的是char 16_t和char 30_t这两个数据类型在Vivado HLS中是不支持的; Vivado HLS继承了传统的C/C++包含的数据类型包括...
  • sparkSql(hive) 复合数据类型的使用

    千次阅读 2017-01-09 22:48:09
    在Hive中可以使用复合数据类型三种常用的类型:Array 数组,Map 字典,Struct结构。在sparkSql中RDD可以转换成非常灵活的DataFrame, 但是如果需要将数据结构完整的存储为Hive表,那么在RDD到DataFrame转换中...
  • 在ElasticSearch中,使用JSON结构...复合数据类型是指数组类型,对象类型和嵌套类型,各个类型的特点分别是: 数组字段是指一个字段多个值,每个值都是该数组字段的一个元素;元素的类型可以是基础类型,也可以是文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 158,544
精华内容 63,417
关键字:

复合数据类型包括哪些