Artikel ini membawakan anda pengetahuan yang berkaitan tentang java, yang terutamanya memperkenalkan isu yang berkaitan dengan perpustakaan sumber terbuka SPL untuk pemprosesan data berstruktur Mari kita lihat struktur yang ideal di bawah perpustakaan kelas pemprosesan data. Saya harap ia akan membantu semua orang.
Kajian yang disyorkan: "tutorial video java"
Seni bina aplikasi Java moden semakin menekankan pengasingan penyimpanan dan pemprosesan data, jadi untuk Mendapatkan kebolehselenggaraan, skalabilitas dan mudah alih yang lebih baik, seperti perkhidmatan mikro yang popular. Seni bina ini biasanya memerlukan logik perniagaan untuk dilaksanakan dalam program Java dan bukannya diletakkan dalam pangkalan data seperti dalam seni bina aplikasi tradisional.
Kebanyakan logik perniagaan dalam aplikasi melibatkan pemprosesan data berstruktur. Pangkalan data (SQL) mempunyai sokongan yang kaya untuk tugasan sedemikian, dan logik perniagaan boleh dilaksanakan dengan mudah. Walau bagaimanapun, Java sentiasa kekurangan sokongan asas sedemikian, menjadikannya sangat rumit dan tidak cekap untuk melaksanakan logik perniagaan di Jawa. Akibatnya, walaupun terdapat pelbagai kelebihan seni bina, kecekapan pembangunan telah menurun dengan ketara.
Jika kami juga menyediakan satu set lengkap pemprosesan data berstruktur dan perpustakaan kelas pengiraan di Jawa, maka masalah ini boleh diselesaikan: menikmati kelebihan seni bina tanpa mengurangkan kecekapan pembangunan.
Apakah ciri-ciri perpustakaan kelas pemprosesan data berstruktur yang ideal di bawah Java? Kita boleh meringkaskannya daripada SQL:
Data berstruktur sering muncul dalam kelompok (dalam bentuk set untuk mengira jenis ini dengan mudah). daripada data, adalah perlu untuk menyediakan keupayaan pengkomputeran set yang mencukupi.
Jika tiada pustaka operasi yang ditetapkan, hanya terdapat jenis data asas tatasusunan (bersamaan dengan set Jika kita ingin melakukan jumlah ahli set yang mudah, kita juga perlu menulis empat atau lima). baris pernyataan gelung untuk dilengkapkan, ditapis dan kumpulan Operasi seperti pengagregatan memerlukan ratusan baris kod.
SQL menyediakan set operasi yang kaya, seperti SUM/COUNT dan operasi pengagregatan lain, WHERE digunakan untuk penapisan, GROUP digunakan untuk pengumpulan dan ia juga menyokong operasi asas seperti persilangan, kesatuan dan perbezaan untuk set. Kod yang ditulis dengan cara ini akan menjadi lebih pendek.
Adakah cukup untuk menetapkan keupayaan operasi? Jika kita membangunkan kumpulan pustaka operasi set untuk Java, bolehkah kita mencapai kesan SQL?
Ia tidak semudah itu!
Ambil operasi penapisan sebagai contoh. Penapisan biasanya memerlukan syarat untuk mengekalkan ahli set yang memenuhi syarat. Dalam SQL, syarat ini muncul dalam bentuk ungkapan Contohnya, menulis WHERE x>0 bermakna mengekalkan ahli yang membuat hasil pengiraan x>0 benar. Ungkapan x>0 tidak dinilai sebelum melaksanakan pernyataan ini, tetapi dinilai untuk setiap ahli set semasa lelaran. Pada asasnya, ungkapan ini pada asasnya adalah fungsi, fungsi yang mengambil ahli koleksi semasa sebagai parameter. Untuk operasi WHERE, ia bersamaan dengan menggunakan fungsi yang ditakrifkan dengan ungkapan sebagai parameter WHERE.
Cara penulisan ini mempunyai istilah yang dipanggil sintaks Lambda, atau bahasa berfungsi.
Tanpa sintaks Lambda, kita selalunya perlu mentakrifkan fungsi buat sementara waktu, yang akan menjadikan kod itu sangat rumit dan terdedah kepada konflik nama.
Sintaks Lambda digunakan secara meluas dalam SQL Ia tidak diperlukan untuk operasi penapisan dan pengelompokan Ia juga boleh digunakan dalam senario yang tidak perlu seperti lajur yang dikira, yang sangat memudahkan kod.
Data berstruktur bukan nilai tunggal yang mudah, tetapi rekod dengan medan.
Kami mendapati bahawa apabila merujuk medan rekod dalam parameter ungkapan SQL, dalam kebanyakan kes, nama medan boleh digunakan secara langsung tanpa menyatakan rekod kepunyaan medan Hanya apabila terdapat berbilang medan dengan nama yang sama nama jadual perlu digunakan ( atau alias) untuk membezakan.
Walaupun versi baharu Java juga telah mula menyokong sintaks Lambda, ia hanya boleh menghantar rekod semasa sebagai parameter ke dalam fungsi yang ditakrifkan dengan sintaks Lambda, dan kemudian sentiasa membawa rekod ini semasa menulis formula pengiraan. Sebagai contoh, apabila mengira jumlah menggunakan harga dan kuantiti seunit, jika parameter yang digunakan untuk mewakili ahli semasa dinamakan x, ia perlu ditulis dalam bentuk panjang berjela "x. harga unit * x. kuantiti". Dalam SQL, ia boleh ditulis dengan lebih intuitif sebagai "harga unit * kuantiti".
SQL juga menyokong struktur data dinamik dengan baik.
Dalam pengiraan data berstruktur, nilai pulangan selalunya adalah data berstruktur dan struktur data hasil berkaitan dengan operasi dan tidak boleh disediakan sebelum menulis kod. Oleh itu, adalah perlu untuk menyokong keupayaan struktur data dinamik.
Sebarang pernyataan SELECT dalam SQL akan menjana struktur data baharu dan medan boleh ditambah serta dipadamkan dalam kod tanpa perlu menentukan struktur (kelas) terlebih dahulu. Ini tidak boleh dilakukan dengan bahasa seperti Java Semua struktur (kelas) yang digunakan mesti ditakrifkan semasa fasa penyusunan kod Pada dasarnya, struktur baharu tidak boleh dijana secara dinamik semasa pelaksanaan.
Daripada analisis item sebelumnya, kita sudah boleh membuat kesimpulan bahawa Java sendiri tidak sesuai sebagai bahasa untuk pemprosesan data berstruktur. Mekanisme Lambdanya tidak menyokong ciri 3, dan sebagai bahasa yang disusun, ia tidak dapat melaksanakan ciri 4.
Malah, sintaks Lambda yang dinyatakan sebelum ini tidak sesuai untuk pelaksanaan dalam bahasa yang disusun. Pengkompil tidak dapat menentukan sama ada ungkapan yang ditulis pada kedudukan parameter harus mengira nilai ungkapan di tempat kejadian dan kemudian menyampaikannya, atau menyusun keseluruhan ungkapan ke dalam fungsi dan menghantarnya, dan lebih banyak simbol sintaks perlu direka bentuk untuk membezakan ia. Bahasa yang ditafsirkan tidak mempunyai masalah ini Sama ada ungkapan sebagai parameter dikira terlebih dahulu atau dikira selepas melintasi ahli koleksi boleh diputuskan oleh fungsi itu sendiri.
SQL sememangnya bahasa yang ditafsirkan.
Stream ialah perpustakaan pemprosesan data berstruktur yang dilancarkan secara rasmi di Java 8, tetapi ia tidak memenuhi keperluan di atas. Ia tidak mempunyai jenis data berstruktur profesional, tidak mempunyai banyak fungsi pengiraan data berstruktur yang penting, bukan bahasa yang ditafsirkan, tidak menyokong jenis data dinamik dan antara muka sintaks Lambda adalah kompleks.
Kotlin ialah sebahagian daripada ekosistem Java Ia telah membuat sedikit peningkatan berdasarkan Stream dan juga menyediakan jenis pengiraan data berstruktur Walau bagaimanapun, disebabkan oleh fungsi pengiraan data berstruktur yang tidak mencukupi bahasa tafsiran tidak menyokong jenis data dinamik, dan antara muka sintaks Lambda adalah kompleks. Ia masih bukan perpustakaan kelas pengkomputeran data berstruktur yang ideal.
Scala menyediakan set yang kaya dengan fungsi pengiraan data berstruktur, tetapi ciri bahasa yang disusun juga menghalangnya daripada menjadi perpustakaan kelas pengiraan data berstruktur yang ideal.
Jadi, apakah lagi yang boleh digunakan dalam ekosistem Java?
esProc SPL.
SPL ialah bahasa pengaturcaraan yang ditafsir dan dilaksanakan oleh Java Ia mempunyai perpustakaan kelas pengiraan data berstruktur yang kaya, sintaks Lambda yang ringkas dan struktur data dinamik yang mudah dan mudah digunakan Ia adalah perpustakaan kelas pemprosesan berstruktur yang ideal di bawah Jawa.
SPL menyediakan jenis data berstruktur profesional, iaitu jujukan. Seperti jadual data SQL, jadual jujukan ialah koleksi rekod kelompok dan mempunyai fungsi umum jenis data berstruktur Berikut ialah contoh.
Menghuraikan data sumber dan menjana jadual jujukan:
Orders=T("d:/Orders.csv")Janakan jadual jujukan baharu daripada jadual jujukan asal mengikut nama lajur:
Orders.new(OrderID, Amount, OrderDate)
Lajur yang dikira :
Orders.new(OrderID, Amount, year(OrderDate))
Nama semula medan:
Orders.new(OrderID:ID, SellerId, year(OrderDate):y)
Gunakan medan mengikut nombor siri:
Orders.groups(year(_5),_2; sum(_4))
Nama semula jujukan (perkaitan kiri)
join@1(Orders:o,SellerId ; Employees:e,EId).groups(e.Dept; sum(o.Amount))
Jujukan Jadual menyokong semua fungsi pengiraan berstruktur dan hasil pengiraan juga adalah jadual jujukan, bukan jenis data seperti Peta. Sebagai contoh, teruskan memproses data berstruktur untuk hasil ringkasan berkumpulan:
Orders.groups(year(OrderDate):y; sum(Amount):m).new(y:OrderYear, m*0.2:discount)
Berdasarkan jadual jujukan, SPL menyediakan set kaya dengan fungsi pengiraan data berstruktur, seperti penapisan, pengisihan, pengumpulan dan penyahduplikasian. , menamakan semula, lajur yang dikira, perkaitan, subkueri, pengiraan set, pengiraan tersusun, dsb. Fungsi ini mempunyai keupayaan pengkomputeran yang berkuasa dan boleh melengkapkan pengiraan secara bebas tanpa bantuan berkod keras:
Pertanyaan gabungan:
Orders.select(Amount>1000 && Amount<=3000 && like(Client,"*bro*"))
Isih:
Orders.sort(-Client,Amount)
Ringkasan kumpulan :
Orders.groups(year(OrderDate),Client; sum(Amount))
Perkaitan dalaman:
join(Orders:o,SellerId ; Employees:e,EId).groups(e.Dept; sum(o.Amount))
SPL menyokong sintaks Lambda yang ringkas, tidak perlu mentakrifkan nama fungsi dan badan fungsi , anda boleh terus menggunakan ungkapan sebagai parameter fungsi, seperti penapisan:
Orders.select(Amount>1000)
Apabila mengubah suai logik perniagaan, anda tidak perlu membina semula fungsi, anda hanya perlu mengubah suai ungkapan:
Orders.select(Amount>1000 && Amount<2000)
SPL ialah bahasa yang ditafsirkan Apabila menggunakan ungkapan parameter, tidak perlu mentakrifkan jenis parameter secara eksplisit, menjadikan antara muka Lambda lebih mudah. Sebagai contoh, jika anda ingin mengira jumlah kuasa dua, anda boleh menulisnya secara intuitif:
Orders.sum(Amount*Amount)
Serupa dengan SQL, sintaks SPL juga menyokong penggunaan langsung nama medan dalam pengiraan jadual tunggal:
Orders.sort(-Client, Amount)
SPL ialah bahasa tafsiran yang secara semula jadi menyokong struktur data dinamik dan boleh menjana jujukan baharu secara dinamik berdasarkan struktur hasil pengiraan. Ia amat sesuai untuk pengiraan seperti lajur yang dikira, ringkasan kumpulan dan korelasi Contohnya, mengira semula secara langsung hasil ringkasan kumpulan:
Orders.groups(Client;sum(Amount):amt).select(amt>1000 && like(Client,"*S*"))
atau terus mengira semula hasil pengiraan korelasi:
<.>join(Orders:o,SellerId ; Employees:e,Eid).groups(e.Dept; sum(o.Amount))
Sales2021.group(month(sellDate)).(~.groups(Client;sum(Amount):sumValue)).(~.sort(-sumValue)) .(~.select(#<=10)).(~.(Client)).isect()
$select * from d:/Orders.csv where (OrderDate<date('2020-01-01') and Amount<=100)or (OrderDate>=date('2020-12-31') and Amount>100)$select year(OrderDate),Client ,sum(Amount),count(1) from d:/Orders.csv group by year(OrderDate),Client having sum(Amount)<=100
$select o.OrderId,o.Client,e.Name e.Dept from d:/Orders.csv o join d:/Employees.csv e on o.SellerId=e.Eid
$with t as (select Client ,sum(amount) s from d:/Orders.csv group by Client) select t.Client, t.s, ct.Name, ct.address from t left join ClientTable ct on t.Client=ct.Client
但是，更彻底的集合化需要离散性来支持，集合成员可以游离在集合之外，并与其它数据随意构成新的集合参与运算 。
SPL兼具了SQL的集合化和Java的离散性，从而可以实现更彻底的集合化。
比如，SPL中很容易表达“集合的集合”，适合分组后计算。比如，找到各科成绩均在前10名的学生：
| A | |
|---|---|
| 1 | =T(“score.csv”).group(subject) |
| 2 | =A2.(.rank(score).pselect@a(<=10)) |
| 3 | =A1.(~(A3(#)).(name)).isect() |
| SPL序表的字段可以存储记录或记录集合，这样可以用对象引用的方式，直观地表达关联关系，即使关系再多，也能直观地表达。比如，根据员工表找到女经理下属的男员工： |
Employees.select(性别:"男",部门.经理.性别:"女")
有序计算是离散性和集合化的典型结合产物，成员的次序在集合中才有意义，这要求集合化，有序计算时又要将每个成员与相邻成员区分开，会强调离散性。SPL兼具集合化和离散性，天然支持有序计算。
具体来说，SPL可以按绝对位置引用成员，比如，取第3条订单可以写成Orders(3)，取第1、3、5条记录可以写成Orders([1,3,5])。
SPL也可以按相对位置引用成员，比如，计算每条记录相对于上一条记录的金额增长率：Orders.derive(amount/amount[-1]-1)
SPL还可以用#代表当前记录的序号，比如把员工按序号分成两组，奇数序号一组，偶数序号一组：Employees.group(#%2==1)
大量功能强大的结构化数据计算函数，这本来是一件好事，但这会让相似功能的函数不容易区分。无形中提高了学习难度。
SPL提供了特有的函数选项语法，功能相似的函数可以共用一个函数名，只用函数选项区分差别。比如select函数的基本功能是过滤，如果只过滤出符合条件的第1条记录，只须使用选项@1：
Orders.select@1(Amount>1000)
数据量较大时，用并行计算提高性能，只须改为选项@m：
Orders.select@m(Amount>1000)
对排序过的数据，用二分法进行快速过滤，可用@b：
Orders.select@b(Amount>1000)
函数选项还可以组合搭配，比如：
Orders.select@1b(Amount>1000)
结构化运算函数的参数常常很复杂，比如SQL就需要用各种关键字把一条语句的参数分隔成多个组，但这会动用很多关键字，也使语句结构不统一。
SPL支持层次参数，通过分号、逗号、冒号自高而低将参数分为三层，用通用的方式简化复杂参数的表达：
join(Orders:o,SellerId ; Employees:e,EId)
普通的Lambda语法不仅要指明表达式（即函数形式的参数），还必须完整地定义表达式本身的参数，否则在数学形式上不够严密，这就让Lambda语法很繁琐。比如用循环函数select过滤集合A，只保留值为偶数的成员，一般形式是：
A.select(f(x):{x%2==0} )这里的表达式是x%2==0，表达式的参数是f(x)里的x，x代表集合A里的成员，即循环变量。
SPL用固定符号~代表循环变量，当参数是循环变量时就无须再定义参数了。在SPL中，上面的Lambda语法可以简写作：A.select(~ %2==0)
普通Lambda语法必须定义表达式用到的每一个参数，除了循环变量外，常用的参数还有循环计数，如果把循环计数也定义到Lambda中，代码就更繁琐了。
SPL用固定符号#代表循环计数变量。比如，用函数select过滤集合A，只保留序号是偶数的成员，SPL可以写作：A.select(# %2==0)
相对位置经常出现在难度较大的计算中，而且相对位置本身就很难计算，当要使用相对位置时，参数的写法将非常繁琐。
SPL用固定形式[序号]代表相对位置：
| A | B | |
|---|---|---|
| 1 | =T(“Orders.txt”) | /订单序表 |
| 2 | =A1.groups(year(Date):y,month(Date):m; sum(Amount):amt) | /按年月分组汇总 |
| 3 | =A2.derive(amt/amt[-1]:lrr, amt[-1:1].avg():ma) | /计算比上期和移动平均 |
作为用Java解释的脚本语言，SPL提供了JDBC驱动，可以无缝集成进Java应用程中。
简单语句可以像SQL一样直接执行：
…
Class.forName("com.esproc.jdbc.InternalDriver");
Connection conn =DriverManager.getConnection("jdbc:esproc:local://");
PrepareStatement st = conn.prepareStatement("=T(\"D:/Orders.txt\").select(Amount>1000 && Amount<=3000 && like(Client,\"*S*\"))");
ResultSet result=st.execute();
...复杂计算可以存成脚本文件，以存储过程方式调用
…
Class.forName("com.esproc.jdbc.InternalDriver");
Connection conn =DriverManager.getConnection("jdbc:esproc:local://");
Statement st = connection.();
CallableStatement st = conn.prepareCall("{call splscript1(?, ?)}");
st.setObject(1, 3000);
st.setObject(2, 5000);
ResultSet result=st.execute();
...将脚本外置于Java程序，一方面可以降低代码耦合性，另一方面利用解释执行的特点还可以支持热切换，业务逻辑变动时只要修改脚本即可立即生效，不像使用Java时常常要重启整个应用。这种机制特别适合编写微服务架构中的业务处理逻辑。
推荐学习：《java视频教程》
Atas ialah kandungan terperinci Membolehkan anda memahami SPL pustaka sumber terbuka pemprosesan data berstruktur Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
