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 jenis kebolehan yang diperlukan?

Apakah ciri-ciri perpustakaan kelas pemprosesan data berstruktur yang ideal di bawah Java? Kita boleh meringkaskannya daripada SQL:

1 Tetapkan keupayaan pengkomputeran

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.

2 sintaks Lambda

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.

3 Medan rujukan terus dalam sintaks Lambda

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".

4 struktur data dinamik

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.

5 Bahasa yang Ditafsirkan

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.

Memperkenalkan SPL

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.

Fungsi operasi set kaya

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))

Sintaks Lambda ringkas

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)

Struktur data dinamik

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))

Pengiraan yang lebih kompleks biasanya dipecahkan kepada berbilang langkah dan struktur data setiap hasil perantaraan adalah hampir berbeza. SPL menyokong struktur data dinamik tanpa perlu menentukan struktur hasil perantaraan ini terlebih dahulu. Contohnya, berdasarkan jadual rekod pembayaran pelanggan untuk tahun tertentu, kira 10 pelanggan teratas dengan jumlah bayaran bulanan:

Sales2021.group(month(sellDate)).(~.groups(Client;sum(Amount):sumValue)).(~.sort(-sumValue))?.(~.select(#<=10)).(~.(Client)).isect()

Laksanakan SQL secara langsung

SPL juga melaksanakan penterjemah SQL, yang boleh melaksanakan SQL secara langsung Ia menyokong segala-galanya daripada asas WHERE, GROUP untuk JOIN, dan juga DENGAN:

$select * from d:/Orders.csv where (OrderDate<date(&#39;2020-01-01&#39;) 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

Lebih banyak kelebihan berbilang bahasa.

Sebagai bahasa pemprosesan data berstruktur profesional, SPL bukan sahaja merangkumi semua keupayaan pengkomputeran SQL, tetapi juga mempunyai kelebihan yang lebih berkuasa dari segi bahasa:

Kebijaksanaan Dan lebih teliti pengagregatan di bawah sokongannya

Pengumpulan ialah ciri asas SQL, yang menyokong data untuk mengambil bahagian dalam operasi dalam bentuk set. Walau bagaimanapun, sifat diskret SQL adalah sangat lemah Semua ahli set mesti mengambil bahagian dalam operasi secara keseluruhan dan tidak boleh dipisahkan daripada set. Bahasa peringkat tinggi seperti Java menyokong diskret yang baik, dan ahli tatasusunan boleh dikendalikan secara bebas.

但是，更徹底的集合化需要離散性來支持，集合成員可以游離在集合之外，并與其它數(shù)據(jù)隨意構(gòu)成新的集合參與運算 。

SPL兼具了SQL的集合化和Java的離散性，從而可以實現(xiàn)更徹底的集合化。

比如，SPL中很容易表達(dá)“集合的集合”，適合分組后計算。比如，找到各科成績均在前10名的學(xué)生：

	A
1	=T(“score.csv”).group(subject)
2	=A2.(.rank(score).pselect@a(<=10))
3	=A1.(~(A3(#)).(name)).isect()
SPL序表的字段可以存儲記錄或記錄集合，這樣可以用對象引用的方式，直觀地表達(dá)關(guān)聯(lián)關(guān)系，即使關(guān)系再多，也能直觀地表達(dá)。比如，根據(jù)員工表找到女經(jīng)理下屬的男員工：

Employees.select(性別:"男",部門.經(jīng)理.性別:"女")

有序計算是離散性和集合化的典型結(jié)合產(chǎn)物，成員的次序在集合中才有意義，這要求集合化，有序計算時又要將每個成員與相鄰成員區(qū)分開，會強調(diào)離散性。SPL兼具集合化和離散性，天然支持有序計算。

具體來說，SPL可以按絕對位置引用成員，比如，取第3條訂單可以寫成Orders(3)，取第1、3、5條記錄可以寫成Orders([1,3,5])。

SPL也可以按相對位置引用成員，比如，計算每條記錄相對于上一條記錄的金額增長率：Orders.derive(amount/amount[-1]-1)

SPL還可以用#代表當(dāng)前記錄的序號，比如把員工按序號分成兩組，奇數(shù)序號一組，偶數(shù)序號一組：Employees.group(#%2==1)

更方便的函數(shù)語法

大量功能強大的結(jié)構(gòu)化數(shù)據(jù)計算函數(shù)，這本來是一件好事，但這會讓相似功能的函數(shù)不容易區(qū)分。無形中提高了學(xué)習(xí)難度。

SPL提供了特有的函數(shù)選項語法，功能相似的函數(shù)可以共用一個函數(shù)名，只用函數(shù)選項區(qū)分差別。比如select函數(shù)的基本功能是過濾，如果只過濾出符合條件的第1條記錄，只須使用選項@1：

Orders.select@1(Amount>1000)

數(shù)據(jù)量較大時，用并行計算提高性能，只須改為選項@m：

Orders.select@m(Amount>1000)

對排序過的數(shù)據(jù)，用二分法進(jìn)行快速過濾，可用@b：

Orders.select@b(Amount>1000)

函數(shù)選項還可以組合搭配，比如：

Orders.select@1b(Amount>1000)

結(jié)構(gòu)化運算函數(shù)的參數(shù)常常很復(fù)雜，比如SQL就需要用各種關(guān)鍵字把一條語句的參數(shù)分隔成多個組，但這會動用很多關(guān)鍵字，也使語句結(jié)構(gòu)不統(tǒng)一。

SPL支持層次參數(shù)，通過分號、逗號、冒號自高而低將參數(shù)分為三層，用通用的方式簡化復(fù)雜參數(shù)的表達(dá)：

join(Orders:o,SellerId?;?Employees:e,EId)

擴展的Lambda語法

普通的Lambda語法不僅要指明表達(dá)式（即函數(shù)形式的參數(shù)），還必須完整地定義表達(dá)式本身的參數(shù)，否則在數(shù)學(xué)形式上不夠嚴(yán)密，這就讓Lambda語法很繁瑣。比如用循環(huán)函數(shù)select過濾集合A，只保留值為偶數(shù)的成員，一般形式是：

A.select(f(x):{x%2==0}?)

這里的表達(dá)式是x%2==0，表達(dá)式的參數(shù)是f(x)里的x，x代表集合A里的成員，即循環(huán)變量。

SPL用固定符號~代表循環(huán)變量，當(dāng)參數(shù)是循環(huán)變量時就無須再定義參數(shù)了。在SPL中，上面的Lambda語法可以簡寫作：A.select(~ %2==0)

普通Lambda語法必須定義表達(dá)式用到的每一個參數(shù)，除了循環(huán)變量外，常用的參數(shù)還有循環(huán)計數(shù)，如果把循環(huán)計數(shù)也定義到Lambda中，代碼就更繁瑣了。

SPL用固定符號#代表循環(huán)計數(shù)變量。比如，用函數(shù)select過濾集合A，只保留序號是偶數(shù)的成員，SPL可以寫作：A.select(# %2==0)

相對位置經(jīng)常出現(xiàn)在難度較大的計算中，而且相對位置本身就很難計算，當(dāng)要使用相對位置時，參數(shù)的寫法將非常繁瑣。

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驅(qū)動，可以無縫集成進(jìn)Java應(yīng)用程中。

簡單語句可以像SQL一樣直接執(zhí)行：

…
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();
...

復(fù)雜計算可以存成腳本文件，以存儲過程方式調(diào)用

…
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程序，一方面可以降低代碼耦合性，另一方面利用解釋執(zhí)行的特點還可以支持熱切換，業(yè)務(wù)邏輯變動時只要修改腳本即可立即生效，不像使用Java時常常要重啟整個應(yīng)用。這種機制特別適合編寫微服務(wù)架構(gòu)中的業(yè)務(wù)處理邏輯。

推薦學(xué)習(xí)：《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!