Java はデータベース テーブルに 7 種類の接続を実装します [Mysql]

情報 2023-09-21 02:18:12 訪問数: null

Java はデータベース テーブルに 7 種類の接続を実装します [Mysql]

序文

2023-8-4 16:51:42

以下のコンテンツは「[Mysql]」から出典されており
、学習とコミュニケーションのみを目的としています。

著作権

他のプラットフォームで公開する場合は、次の単語を削除してください。この
記事は最初に CSDN プラットフォームで公開されました。
著者は CSDN@日星月云です。
ブログのホームページは https://blog.csdn.net/qq_51625007 です。
他のプラットフォームで公開する場合は上記の文言を使用してください。

推薦する

なし

Java はデータベース テーブルに 7 種類の接続を実装します

左外部結合

  /**
     * 左外连接
     * 计算
     *     SELECT cla1.`id`,cla1.`type`,cla2.`name`
     *     FROM cla1
     *     LEFT JOIN cla2
     *     ON cla1.`id`=cla2.`id`
     *     (Where cla2.id IS NULL);
     *
     * @param list1
     * @param list2
     * @param isNull 有没有括号中的IS NULL这条语句
     * @param out 输出吗？
     * @return
     */
    public static  List<Cla3> leftJoin(List<Cla3> list1, List<Cla3> list2,boolean isNull,boolean out) {
    
    
       List<Cla3> leftJoin=new ArrayList<>();

       //左表遍历
       list1.forEach(c1->{
    
    
           //在右表中有没有找到
           AtomicBoolean flag= new AtomicBoolean(false);
           list2.forEach(c2->{
    
    
               //找到了
               if(c1.id.equals(c2.id)){
    
    
                   //如果cla2.id is null,就不需要添加
                   if (!isNull) {
    
    
                       leftJoin.add(new Cla3(c1.id, c1.type, c2.name));
                   }
                   flag.set(true);
               }
           });
           //没有找到添加 右表属性 NULL
           if(!flag.get()){
    
    
               leftJoin.add(new Cla3(c1.id,c1.type,"null"));
           }
       });
       
        return leftJoin;
    }

右外部結合

    /**
     * 右外连接
     * 计算
     *     SELECT cla2.`id`,cla1.`type`,cla2.`name`
     *     FROM cla1
     *     RIGHT JOIN cla2
     *     ON cla1.`id`=cla2.`id`
     *     (WHERE cla1.`id` IS NULL);
     *
     * @param list1
     * @param list2
     * @param isNull 有没有括号中的IS NULL这条语句
     * @return
     */
    public static  List<Cla3> rightJoin(List<Cla3> list1, List<Cla3> list2,boolean isNull,boolean out) {
    
    
        List<Cla3> rightJoin=new ArrayList<>();
        //右表遍历
        list2.forEach(c2->{
    
    
            //在左表中有没有找到
            AtomicBoolean flag= new AtomicBoolean(false);
            list1.forEach(c1->{
    
    
                //找到了
                if(c1.id.equals(c2.id)){
    
    
                    //如果cla1.id is null,就不需要添加
                    if (!isNull){
    
    
                        rightJoin.add(new Cla3(c2.id, c1.type,c2.name));
                    }
                    flag.set(true);
                }
            });
            //没有找到添加 左表属性 NULL
            if(!flag.get()){
    
    
                rightJoin.add(new Cla3(c2.id,"null",c2.name));
            }
        });

        return rightJoin;
    }

その他の接続

外连接
 * 左外+右外
 * 右外+左外

内连接
 * 左外-左外ISNULL
 * 右外-右外ISNULL

外连接-内连接

付録

7つの接続

MySQL ノート: 第 06 章_複数テーブルのクエリ

ここに画像の説明を挿入します

SQLテスト

CREATE DATABASE cla;


USE cla;

CREATE TABLE cla1(
	`id` 	VARCHAR(10),
	`type` 	VARCHAR(10)
);

CREATE TABLE cla2(
	`id` 	VARCHAR(10),
	`name` 	VARCHAR(10)
);



INSERT INTO cla1 VALUES('22','cde');
INSERT INTO cla1 VALUES('11','abc');
INSERT INTO cla1 VALUES('44','cdef');
INSERT INTO cla1 VALUES('55','cdefg');

INSERT INTO cla2 
VALUES
('11','name1'),
('22','name2'),
('33','name3'),
('44','name4'),
('aa','nameaa');

#leftJoin 
SELECT cla1.`id`,cla1.`type`,cla2.`name`
FROM cla1
LEFT JOIN cla2
ON cla1.`id`=cla2.`id`
/*
id	type	name
22	cde	name2
11	abc	name1
44	cdef	name4
55	cdefg	\N
*/

#leftJoin isnull
SELECT cla1.`id`,cla1.`type`,cla2.`name`
FROM cla1
LEFT JOIN cla2
ON cla1.`id`=cla2.`id`
WHERE cla2.`id` IS NULL;
/*
id	type	name
55	cdefg	\N
*/


#rightJoin 
SELECT cla2.`id`,cla1.`type`,cla2.`name`
FROM cla1
RIGHT JOIN cla2
ON cla1.`id`=cla2.`id`
/*
id	type	name
11	abc	name1
22	cde	name2
33	\N	name3
44	cdef	name4
aa	\N	nameaa
*/

#rightJoin ISNULL
SELECT cla2.`id`,cla1.`type`,cla2.`name`
FROM cla1
RIGHT JOIN cla2
ON cla1.`id`=cla2.`id`
WHERE cla1.`id` IS NULL;
/*
id	type	name
33	\N	name3
aa	\N	nameaa
*/


#innerJoin leftBefore
SELECT cla1.`id`,cla1.`type`,cla2.`name`
FROM cla1
INNER JOIN cla2
ON cla1.`id`=cla2.`id`
/*
id	type	name
11	abc	name1
22	cde	name2
44	cdef	name4
*/

#innerJoin rightBefore
SELECT cla2.`id`,cla1.`type`,cla2.`name`
FROM cla2
INNER JOIN cla1
ON cla2.`id`=cla1.`id`
/*
id	type	name
11	abc	name1
22	cde	name2
44	cdef	name4
*/

#outJoin leftBefore
#左1+右2
SELECT cla1.`id`,cla1.`type`,cla2.`name`
FROM cla1
LEFT JOIN cla2
ON cla1.`id`=cla2.`id`
UNION ALL
SELECT cla2.`id`,cla1.`type`,cla2.`name`
FROM cla1
RIGHT JOIN cla2
ON cla1.`id`=cla2.`id`
WHERE cla1.`id` IS NULL;
/*
id	type	name
22	cde	name2
11	abc	name1
44	cdef	name4
55	cdefg	\N
33	\N	name3
aa	\N	nameaa
*/

#outJoin rightBefore
#右1+左2
SELECT cla2.`id`,cla1.`type`,cla2.`name`
FROM cla1
RIGHT JOIN cla2
ON cla1.`id`=cla2.`id`
UNION ALL
SELECT cla1.`id`,cla1.`type`,cla2.`name`
FROM cla1
LEFT JOIN cla2
ON cla1.`id`=cla2.`id`
WHERE cla2.`id` IS NULL;
/*
id	type	name
11	abc	name1
22	cde	name2
33	\N	name3
44	cdef	name4
aa	\N	nameaa
55	cdefg	\N
*/

Javaのテスト

変換方法


package test.algo;


import test.algo.main2.Cla1;
import test.algo.main2.Cla2;
import test.algo.main2.Cla3;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;



public class testJoin {
    
    

    static List<Cla1> claList1 = new ArrayList<>();
    static List<Cla2> claList2 = new ArrayList<>();

    static List<Cla3> list1 = new ArrayList<>();
    static List<Cla3> list2 = new ArrayList<>();


    public static void main(String[] args) {
    
    

        test();

        init(claList1,claList2);

        leftJoin(list1, list2,false,true);
        /*
        {id: 22, type: cde, name: name2}
        {id: 11, type: abc, name: name1}
        {id: 44, type: cdef, name: name4}
        {id: 55, type: cdefg, name: null}
         */

        leftJoin(list1, list2,true,true);;
        /*
        {id: 55, type: cdefg, name: null}
         */

        rightJoin(list1, list2,false,true);
        /*
        {id: 11, type: abc, name: name1}
        {id: 22, type: cde, name: name2}
        {id: 33, type: null, name: name3}
        {id: 44, type: cdef, name: name4}
        {id: aa, type: null, name: nameaa}
         */

        rightJoin(list1, list2,true,true);
        /*
        {id: 33, type: null, name: name3}
        {id: aa, type: null, name: nameaa}
         */


        outJoin(list1, list2,true,true);
        /*
        {id: 22, type: cde, name: name2}
        {id: 11, type: abc, name: name1}
        {id: 44, type: cdef, name: name4}
        {id: 55, type: cdefg, name: null}
        {id: 33, type: null, name: name3}
        {id: aa, type: null, name: nameaa}
         */

        outJoin(list1, list2,false,true);
        /*
        {id: 11, type: abc, name: name1}
        {id: 22, type: cde, name: name2}
        {id: 33, type: null, name: name3}
        {id: 44, type: cdef, name: name4}
        {id: aa, type: null, name: nameaa}
        {id: 55, type: cdefg, name: null}
         */


        innerJoin(list1,list2,true,true);
        /*
        {id: 22, type: cde, name: name2}
        {id: 11, type: abc, name: name1}
        {id: 44, type: cdef, name: name4}
         */

        innerJoin(list1,list2,false,true);
        /*
        {id: 11, type: abc, name: name1}
        {id: 22, type: cde, name: name2}
        {id: 44, type: cdef, name: name4}
         */

        outJoin_InnerJoin(list1,list2,true,true);
        /*
        {id: 55, type: cdefg, name: null}
        {id: 33, type: null, name: name3}
        {id: aa, type: null, name: nameaa}
         */
        outJoin_InnerJoin(list1,list2,false,true);
        /*
        {id: 33, type: null, name: name3}
        {id: aa, type: null, name: nameaa}
        {id: 55, type: cdefg, name: null}
         */

    }

    /**
     * 初始两个表中的数据
     */
    public static void test(){
    
    
        claList1.add(new Cla1("22", "cde"));
        claList1.add(new Cla1("11", "abc"));
        claList1.add(new Cla1("44", "cdef"));
        claList1.add(new Cla1("55", "cdefg"));

        claList2.add(new Cla2("11", "name1"));
        claList2.add(new Cla2("22", "name2"));
        claList2.add(new Cla2("33", "name3"));
        claList2.add(new Cla2("44", "name4"));
        claList2.add(new Cla2("aa", "nameaa"));
    }


    /**
     * 初始结果表中的数据
     */
    public static void init(List<Cla1> claList1, List<Cla2> claList2){
    
    
        claList1.forEach(cla1 -> list1.add(new Cla3(cla1.getId(), cla1.getType(), "null")));
        claList2.forEach(cla2 -> list2.add(new Cla3(cla2.getId(), "null", cla2.getName())));
    }


    /**
     *外连接-内连接
     * @param list1
     * @param list2
     * @param leftBefore 左边在前
     * @param out 是否输出
     * @return
     */
    public static List<Cla3> outJoin_InnerJoin(List<Cla3> list1, List<Cla3> list2,boolean leftBefore,boolean out){
    
    
        List<Cla3> outJoin_InnerJoin=new ArrayList<>();

        outJoin_InnerJoin.addAll(outJoin(list1, list2, leftBefore, false));
        outJoin_InnerJoin.removeAll(innerJoin(list1, list2, leftBefore, false));


        if(out){
    
    
            System.out.println("--------------------outJoin_InnerJoin"+((leftBefore)?"leftBefore":"rightBefore")+"-------------------------------");
            outJoin_InnerJoin.forEach(System.out::println);
            System.out.println("--------------------outJoin_InnerJoin"+((leftBefore)?"leftBefore":"rightBefore")+"-------------------------------");
        }
        return outJoin_InnerJoin;

    }

    /**
     * 内连接
     * 左外-左外ISNULL
     * 右外-右外ISNULL
     * @param list1
     * @param list2
     * @param leftBefore 左边在前
     * @param out 是否输出
     * @return
     */
    public static List<Cla3> innerJoin(List<Cla3> list1, List<Cla3> list2,boolean leftBefore,boolean out){
    
    
        List<Cla3> innerJoin=new ArrayList<>();

        if(leftBefore){
    
    
            innerJoin.addAll(leftJoin(list1, list2, false, false));
            innerJoin.removeAll(leftJoin(list1, list2, true, false));
        }else {
    
    
            innerJoin.addAll(rightJoin(list1, list2, false, false));
            innerJoin.removeAll(rightJoin(list1, list2, true, false));
        }

        if(out){
    
    
            System.out.println("--------------------innerJoin"+((leftBefore)?"leftBefore":"rightBefore")+"-------------------------------");
            innerJoin.forEach(System.out::println);
            System.out.println("--------------------innerJoin"+((leftBefore)?"leftBefore":"rightBefore")+"-------------------------------");
        }
        return innerJoin;
    }


    /**
     * 左外连接
     * 计算
     *     SELECT cla1.`id`,cla1.`type`,cla2.`name`
     *     FROM cla1
     *     LEFT JOIN cla2
     *     ON cla1.`id`=cla2.`id`
     *     (Where cla2.id IS NULL);
     *
     * @param list1
     * @param list2
     * @param isNull 有没有括号中的IS NULL这条语句
     * @param out 输出吗？
     * @return
     */
    public static  List<Cla3> leftJoin(List<Cla3> list1, List<Cla3> list2,boolean isNull,boolean out) {
    
    
       List<Cla3> leftJoin=new ArrayList<>();

       list1.forEach(c1->{
    
    
           AtomicBoolean flag= new AtomicBoolean(false);
           list2.forEach(c2->{
    
    
               if(c1.id.equals(c2.id)){
    
    
                   if (!isNull) {
    
    
                       leftJoin.add(new Cla3(c1.id, c1.type, c2.name));
                   }
                   flag.set(true);
               }
           });
           if(!flag.get()){
    
    
               leftJoin.add(new Cla3(c1.id,c1.type,"null"));
           }
       });

       if(out){
    
    
            System.out.println("--------------------leftJoin---"+((isNull)?"isNull":"----")+"-------------------------------");
            leftJoin.forEach(System.out::println);
            System.out.println("--------------------leftJoin---"+((isNull)?"isNull":"----")+"-------------------------------");
            System.out.println();
       }

        return leftJoin;
    }

    /**
     * 右外连接
     * 计算
     *     SELECT cla2.`id`,cla1.`type`,cla2.`name`
     *     FROM cla1
     *     RIGHT JOIN cla2
     *     ON cla1.`id`=cla2.`id`
     *     (WHERE cla1.`id` IS NULL);
     *
     * @param list1
     * @param list2
     * @param isNull 有没有括号中的IS NULL这条语句
     * @return
     */
    public static  List<Cla3> rightJoin(List<Cla3> list1, List<Cla3> list2,boolean isNull,boolean out) {
    
    
        List<Cla3> rightJoin=new ArrayList<>();
        list2.forEach(c2->{
    
    
            AtomicBoolean flag= new AtomicBoolean(false);
            list1.forEach(c1->{
    
    
                if(c1.id.equals(c2.id)){
    
    
                    if (!isNull){
    
    
                        rightJoin.add(new Cla3(c2.id, c1.type,c2.name));
                    }
                    flag.set(true);
                }
            });
            if(!flag.get()){
    
    
                rightJoin.add(new Cla3(c2.id,"null",c2.name));
            }
        });
        if (out){
    
    
            System.out.println("--------------------rightJoin---"+((isNull)?"isNull":"----")+"-------------------------------");
            rightJoin.forEach(System.out::println);
            System.out.println("--------------------rightJoin---"+((isNull)?"isNull":"----")+"-------------------------------");
            System.out.println();
        }
        return rightJoin;
    }

    /**
     * 外连接
     * 左外+右外
     * 右外+左外
     *     SELECT *
     *     FROM tableA A
     *     FULL OUTER JOIN TableB B
     *     ON A.key=B.key
     *
     * @param leftBefore 结果集左表在前还是右边在前
     * @param out 输出吗
     * @return
     */
    public static List<Cla3> outJoin(List<Cla3> list1, List<Cla3> list2,boolean leftBefore,boolean out) {
    
    


        List<Cla3> outJoin=new ArrayList<>();
        List<Cla3> leftJoin = leftJoin(list1, list2,!leftBefore,false);
        List<Cla3> rightJoin = rightJoin(list1, list2,leftBefore,false);

        if (leftBefore){
    
    
            outJoin.addAll(leftJoin);
            outJoin.addAll(rightJoin);
        }else {
    
    
            outJoin.addAll(rightJoin);
            outJoin.addAll(leftJoin);
        }

        if(out){
    
    
            System.out.println("--------------------outJoin"+((leftBefore)?"leftBefore":"rightBefore")+"-------------------------------");
            outJoin.forEach(System.out::println);
            System.out.println("--------------------outJoin"+((leftBefore)?"leftBefore":"rightBefore")+"-------------------------------");
        }

        return outJoin;

    }

}

クラスCla1

package test.algo.main2;

public class Cla1 {
    
    
    public String id;
    public String type;

    public Cla1(String id, String type) {
    
    
        this.id = id;
        this.type = type;
    }

    public String getId() {
    
    
        return id;
    }

    public void setId(String id) {
    
    
        this.id = id;
    }

    public String getType() {
    
    
        return type;
    }

    public void setType(String type) {
    
    
        this.type = type;
    }

    @Override
    public String toString() {
    
    
        return "{id: " + id + ", type: " + type + "}";
    }
}

クラスCla2

package test.algo.main2;

public class Cla2 {
    
    
    public String id;
    public String name;

    public Cla2(String id, String name) {
    
    
        this.id = id;
        this.name = name;
    }

    public String getId() {
    
    
        return id;
    }

    public void setId(String id) {
    
    
        this.id = id;
    }

    public String getName() {
    
    
        return name;
    }

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

    @Override
    public String toString() {
    
    
        return "{id: " + id + ", name: " + name + "}";
    }
}

クラスCla3

書き換える必要があるequals()
id==id

package test.algo.main2;

import java.util.Objects;

public class Cla3 {
    
    
    public String id;
    public String name;
    public String type;

    public Cla3(String id, String type, String name) {
    
    
        this.id = id;
        this.type = type;
        this.name = name;
    }

    public String getId() {
    
    
        return id;
    }

    public void setId(String id) {
    
    
        this.id = id;
    }

    public String getName() {
    
    
        return name;
    }

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

    public String getType() {
    
    
        return type;
    }

    public void setType(String type) {
    
    
        this.type = type;
    }

    @Override
    public boolean equals(Object o) {
    
    
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Cla3 cla3 = (Cla3) o;
        return Objects.equals(id, cla3.id);
    }

    @Override
    public int hashCode() {
    
    
        return Objects.hash(id);
    }

    @Override
    public String toString() {
    
    
        return "{id: " + id + ", type: " + type + ", name: " + name + "}";
    }
}

やっと

2023-8-4 17:04:28

私たち全員に明るい未来があります

大学院受験の成功を祈り、
仕事での
成功を祈り、欲しいものを手に入れて
ください、いいね、集めて、フォローしてください。

おすすめ

転載: blog.csdn.net/qq_51625007/article/details/132108115
おすすめ
大規模な言語モデルに基づくオープンソースのナレッジベースの質問と回答システムである MaxKB GitHub Star の数が 5,000 を超えました。
ランキング
短线选股的一种方法
Javaクライアントでのユーバーのリズムワークフローで睡眠時間をキャンセルし、再スケジュール
CALIPSOデータバッチダウンロード方式
LeetCode アルゴリズム再帰クラス - ソードはオファー 26 を参照します。 ツリーの部分構造
HTMLのインポート外部CSS、JavaScriptの論文
PostgreSQL 13.1、12.5、11.10、10.15、9.6.20、および9.5.24がリリースされました
アップルは、エラーメッセージがポテトに接続されていた実行する方法ポテトポテトショーをダウンロードすることができません
あなたは空腹で突然電話を切っていますか？これはテクノロジーの裏側ですか、それともテスト用の銃ですか？
VIMエディタのヒント
動的計画法の最長共通部分列（LCS）
アーカイブ
もっと
2024-05-13(8)
2024-05-12(27)
2024-05-11(31)
2024-05-10(33)
2024-05-09(30)
2024-05-08(18)
2024-05-07(34)
2024-05-06(6)
2024-05-05(0)
2024-05-04(18)

コードワールド

© 2018 codetd.com