常連

Java初心者です。
お手柔らかにお願いいたします。

### 実現したいこと
Mapを要素とするList型(List<Map<String,String>>)が2つあり、mapList1とmapList2とします。
中身のデータは、例)のような形になっており、mapList1とmapList2の値をそれぞれ比較して、異なる値だけを別のMapを要素とするList型(「diffValueMapList」とします。)に格納したいです。
比較する際には、mapList1のListの要素単位で、Keyの値が等しいvalueを比較したいです。
以下の例を元にすると、mapList1のList[0]とmapList2のList[0]の中身を比較するのであり、mapList1のList[0]とmapList2のList[1]の中身を比較することはないということです。
diffValueMapListに格納する際は、List[0]の中に、mapList1の値とmapList2の値を格納したいです。


例）
■mapList1
List[0]
 -Map(Key=キー①,value=1111)
 -Map(Key=キー②,value="**あああ**")

List[1]
 -Map(Key=キー①,value=2222)
 -Map(Key=キー②,value="いいい")

List[2]
 -Map(Key=キー①,value=2222)
 -Map(Key=キー②,value="**ううう**")

■mapList2
List[0]
 -Map(Key=キー①,value=1111)
 -Map(Key=キー②,value="**かかか**")

List[1]
 -Map(Key=キー①,value=2222)
 -Map(Key=キー②,value="いいい")

List[2]
 -Map(Key=キー①,value=2222)
 -Map(Key=キー②,value="**くくく**")

↓

以下のように格納したい
■diffValueMapList
List[0]
 -Map(Key=キー②,value="**あああ**")
 -Map(Key=キー②,value="**かかか**")
List[1]
 -Map(Key=キー②,value="**ううう**")
 -Map(Key=キー②,value="**くくく**")


### 前提

特にないです。

### 発生している問題・エラーメッセージ
diffValueMapList1に格納されるデータが想定より少ない。
以下のソースコードで、最終的にはdiffValueMapList1とdiffValueMapList2をまとめた形で戻り値としたかったのですが、diffValueMapList1が想定通りにならなかったため、コードは途中の状態となっております。
### 該当のソースコード
冗長なコードになっていると思いますが、効率よく比較できるように修正できそうであれば教えて頂きたいです。
```Java
    public List<Map<String, String>> checkMapList(List<Map<String, String>> mapList1, List<Map<String, String>> mapList2){
        Map<String,String> diffValueMap1 = new HashMap<>();
        Map<String,String> diffValueMap2 = new HashMap<>();

        List<Map<String, String>> diffValueMapList1 = new ArrayList<>();
        List<Map<String, String>> diffValueMapList2 = new ArrayList<>();

        for(Map<String,String> resultMap11:mapList1){
            for(Map.Entry<String, String> resultValue11:resultMap11.entrySet()) {
                boolean isEqual1 = false;
                for (Map<String, String> resultMap12 : mapList2) {
                    for (Map.Entry<String, String> resultValue12 : resultMap12.entrySet()) {
                        if(resultValue11.getValue().equals(resultValue12.getValue())) {
                            isEqual1 = true;
                            break;
                        }
                    }
                }
                if(isEqual1 == false){
                    diffValueMap1.put(resultValue11.getKey(),resultValue11.getValue());
                    diffValueMapList1.add(diffValueMap1);
                }
            }
        }

        for(Map<String,String> resultMap21:mapList2){
            for(Map.Entry<String,String> resultValue21:resultMap21.entrySet()){
                boolean isEqual2 = false;
                for(Map<String,String> resultMap22:mapList1){
                    for(Map.Entry<String,String> resultValue22:resultMap22.entrySet()){
                        if(resultValue22.getValue().equals(resultValue21.getValue())){
                            isEqual2 = true;
                            break;
                        }
                    }
                }
                if(isEqual2 == false){
                    diffValueMap2.put(resultValue21.getKey(),resultValue21.getValue());
                    diffValueMapList2.add(diffValueMap2);
                }
            }
        }
        return diffValueMapList1;
    }

```

### 試したこと

試行錯誤した結果、自分の求める形に一番近い結果となったのが上記コードでした。

### 補足情報（FW/ツールのバージョンなど）

特にないです。


2つのMapを要素とするList型を比較して、異なる値だけを抽出したい


疑問解決
初めての質問のため、至らない部分があるかと存じますが、ご了承ください。

1次元リストから要素を2つずつ取り出して2次元リストを作る場合を想定します。

### 前提

Java初心者です。

QiitaというサイトでArrayListのnewとclear()の違いに関する記事を拝見していたのですが
配列の格納のされ方がよくわからず、関係のないところで気になってしまい
自分で確認できないか試してみたんですが、足跡は追えてもなぜそういう動きをするのかがわからないため質問させていただきます。
以下記事に掲載されていたソースコードです。
---------------------------------------------------
```
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class TestArraylist {
    public static void main(String args[]) {
        // 出力用の2次元リスト 
        List<ArrayList<String>> sampleLists = new ArrayList<>();
        // sampleListsに要素を追加するための一時的なリスト
        ArrayList<String> listA = new ArrayList<>();
        // 適当なサンプル
        List<String> listB = Arrays.asList("AA", "BB", "CC", "DD", "EE", "FF");

        // 要素数が2のリストを作ってsampleListsに追加する
        for (int i = 0; i < listB.size(); i++) {
            if (i % 2 == 0) {
                listA.add(listB.get(i));
                continue;
            }
            sampleLists.add(listA);
            listA.add(listB.get(i));
            // new前の確認
            System.out.println(sampleLists);

            // 一時的なリストをnewする
            listA = new ArrayList<>();
            // new後の確認
            System.out.println(sampleLists);
        }
    }
}
```
-----------------------------------------------------
出展：https://qiita.com/RoG/items/850390f97702144471cf

listAにlistBの”AA”を格納した後に、ifブロックを抜けsampleListにlistAの"AA"を格納したのち
listAにlistBの"BB"を格納しているのですが、その結果、sampleListになにも格納していないにも関わらず、listAに格納したはずの"BB"がsampleListにも格納されていました。
なぜなのでしょう。

### 試したこと
足跡がわかるように通ったところにa,b,c,dと出力するようにしたのですが
仕組みがわかりませんでした。

-----------------------------------------------------
上記省略
```for (int i = 0; i < listB.size(); i++) {
			System.out.println("a");
			if (i % 2 == 0) {
				listA.add(listB.get(i));
				System.out.println("b");
				continue;
			}
			System.out.println("d");
			System.out.println(sampleLists);

			sampleLists.add(listA);

			System.out.println(sampleLists);
			System.out.println(listA);

			listA.add(listB.get(i));
			// new前の確認
			System.out.println(sampleLists);
			System.out.println(listA);
			System.out.println("c");

			// 一時的なリストをnewする
			listA = new ArrayList<>();
			// new後の確認
			System.out.println(sampleLists);
			System.out.println(listA);
		}
	}
}
```
-----------------------------------------------------
-----------------------------------------------------
出力結果
```a
b
a
d
[]
[[AA]]
[AA]
[[AA, BB]]
[AA, BB]
c
[[AA, BB]]
[]
a
b
a
d
[[AA, BB]]
[[AA, BB], [CC]]
[CC]
[[AA, BB], [CC, DD]]
[CC, DD]
c
[[AA, BB], [CC, DD]]
[]
a
b
a
d
[[AA, BB], [CC, DD]]
[[AA, BB], [CC, DD], [EE]]
[EE]
[[AA, BB], [CC, DD], [EE, FF]]
[EE, FF]
c
[[AA, BB], [CC, DD], [EE, FF]]
[]
```
-----------------------------------------------------


ArrayListの動き方がわかりません。

pythonでは変数が長い配列だと
print( value ) 
などとしても

   [ 0.  0.  0. ...,  0.  0.  0.]

のように..., で省略されてしまいますよね？


省略させずに全部の内容を出力したいのですが
どうしたら良いでしょうか？


また、
この時の変数 valueは次元数が幾つあるか分からないのですが、
そういう時などでも全部を出力する方法などは無いのでしょうか

pythonで配列の内容を全部表示する方法

index()を使うとlistの中の一致する要素の一番はじめのindexを取ってきますが、一致する値すべてのindexを取得するにはどうしたらいいでしょうか？

現状
```python
list = [1,2,1,3,1]
index = list.index(1) # index ->  0
```

理想
```python
list = [1,2,1,3,1]
# index -> [0,2,4]
```

[Python] listに同じ値が複数含まれている時にすべてのindexを取得したい

以前、コードを書いているときセッションスコープを使った際に、セッションに配列を格納しておりそれをgetで取り出しaddでその配列に新しい要素を格納した時にセッションに再び配列をsetしなくてもセッションにsetしている配列が新しい要素を格納している配列になっていたのですが、これはどうゆう論理なのでしょうか？
ここから考えると、setattributeの意味があまりなくなってしまうと思うのですが、、、
セッションの具体的な場所や動きなどを教えていただけるとありがたいです。


セッションスコープについて

こんにちは。現在Javaの学習をしているものです。

getメソッドで取得した情報をDTOにセットしArrayListを用いて取り出す方法が分からず苦戦しています。
どなたか気になる箇所などございましたらご教示いただけますと幸いです。
どうぞよろしくお願いいたします。

###実現したいこと

```ここに言語を入力
ArrayList<GenreDTO> maingenreList = bn.MainGenresAll();
```
のようにDTO型のArrayListでDTOをArrayListに格納した後、格納したDTOからmaingenreidとmaingenrenameを取り出す。
取り出したのちにその情報をDTOにセットし、allgenreListにDTO型として格納しsetAtributeメソッドを用いてセットしたいと考えています。


### 分からないこと

下記2つの処理をどうやって記述してあげたらよいのかがいまいちよくわかりません、、、

```ここに言語を入力
//取得したmaingenreidとmaingenrenameをDTOにセットする
```

```ここに言語を入力
        // genreListデータをapplicationスコープで保存
        context.setAttribute("allgenreList", allgenreList);
```


###私の現在のソースコード

```ここに言語を入力
import java.io.IOException;
import java.sql.SQLException;
import java.util.ArrayList;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import common.LoggerTester;
import dao.GenreDAO;
import dto.GenreDTO;

public class InitializationListener implements ServletContextListener {
    public void contextInitialized(ServletContextEvent event) {
        ServletContext context = event.getServletContext();

        // ログの出力
        LoggerTester lt = new LoggerTester();
        lt.outActionLog("InitializationListener.java", "処理開始");

        GenreDAO bn = new GenreDAO();
        ArrayList<GenreDTO> maingenreList = bn.MainGenresAll();

        if (maingenreList != null) {
            for (int i = 0; i < maingenreList.size(); ++i) {

                GerneDTO genreInfo = maingenreList.get(i);

                genreInfo.get(String_maingenreid);
                genreInfo.get(String_maingenrename);

　　　　　　　　　//取得したmaingenreidとmaingenrenameをDTOにセットする

                

            }
        }

　　　　
　　　　//DTOにセットしたmaingenreidとmaingenrenameをallgenreListにDTO型として格納する
　　　　　ArrayList<GenreDTO> allgenreList = 


        // genreListデータをapplicationスコープで保存
        context.setAttribute("allgenreList", allgenreList);

    }

    public void contextDestoryed(ServletContextEvent event) {
        ServletContext context = event.getServletContext();
        context.removeAttribute("allgenreList"); // 削除処理
    }
}

```

DTOから取得した情報をArrayListのDTO型で格納したい

### 実現したいこと

ぱっと見では、

あり得ないだろうかも　知れない、
もしかしたら　Python開発者しか、
対処不可能かも　知れない、
挙動不振を　何とかしたい。

_
### 前提

・pythonで　配列データを、
＿スライスして　再結合する、
＿コーディングを　しました。
_

環境、

ウィンドウズ１１　　22H2
Powershell　　　　　7.3.3
python　　　　　　　3.11×64bit　Microsoft配布版
Visual Studio Code　1.76.1

＿
### 発生している問題・エラーメッセージ

※注：エラーメッセージは　ありません。

・配列データが　確率的に、
＿一部　欠損します、
＿失われたり、失われなかったり、
＿します。

・コード初見時　100％、
＿誰もが　嘘を、
＿疑うでしょう。

＿
### 該当のソースコード

```Python　iround.py(参照受けルーチン。)
import numpy as LAC

def iround(lis: list, dimensyon: int = 0, istypeint: bool = True):
     temp = (LAC.asarray(LAC.asarray((LAC.fabs((I := LAC.array(lis))) * (dimtemp := 10 **
            (0 - dimensyon + 1)) + 5) / 10, dtype=int), dtype=float) * LAC.sign(I)) / dimtemp * 10
    return LAC.asarray(temp, dtype=int) if (dimensyon > -1) and istypeint else temp
```

```Python　リスト操作。
# coding: UTF-8
# python3.11

from logging import StreamHandler, FileHandler, getLogger, DEBUG, INFO, ERROR, Formatter, WARNING, CRITICAL
import pytest
import traceback as TB
import functools as FT
import itertools as IT
import math as MT
import random as RA
import numpy as LAC  # List Array Control.
import tqdm as PGR  # Progress rate.
from iround import iround
import sys


# Backtrace define section.
ERRORformatter = Formatter(
    "  Alert I I %(levelname)s   %(message)s %(asctime)s %(filename)s")
formatter = Formatter(
    "[%(levelname)s] %(asctime)s - %(message)s (%(filename)s)")
logger = getLogger(__name__)

nomalhandler = FileHandler("DEBUG.log")
nomalhandler.setLevel(DEBUG)
nomalhandler.setFormatter(formatter)

WARNINGhandler = FileHandler("WARNING.log")
WARNINGhandler.setLevel(WARNING)
WARNINGhandler.setFormatter(formatter)

terminalhandler = StreamHandler()
terminalhandler.setLevel(ERROR)
terminalhandler.setFormatter(ERRORformatter)

logger.setLevel(DEBUG)
logger.addHandler(nomalhandler)
logger.addHandler(WARNINGhandler)
logger.addHandler(terminalhandler)


# Data definition section.
recursionlimit = sys.getrecursionlimit()
DisDataanomal = 0
E_Recursivecount = 0
Recursivemount = 3
C_Recursivecount = 0
C_Dataanomaly = 0
P_Dataanomaly = 0

# Unique random number routine.
#   Center-biased random number.
def Cran(end: int, start: int = 1, Centralization: int = 3):
    return iround([LAC.average(LAC.random.randint(start, end + 1,  Centralization))])[0]
# Combining Shuffle routine.


def list_action(action_times: int = 3, Orderlist: list = list(range(1, 55 + 1))):
    try:
        assert isinstance(Orderlist, (LAC.ndarray, list)) and not (isinstance(
            Orderlist[0], (LAC.ndarray, list)))
    except AssertionError:
        logger.debug(TB.format_exc)
    Orderlistlen = len(Orderlist)
    Spare_Orderlist = Orderlist

# Random biased on one side.
    def Eran2(end: int, start: int = 1):
        temporary1 = RA.randint(start, min(end, 4 + start) + 1)
        try:
            assert temporary1 >= start
        except AssertionError:
            logger.debug(TB.format_exc)
            logger.debug(
                f"Eran ŗ    l ُ픭   temporary1 = {temporary1}")
            return Eran2(end)
        except RecursionError:
#            E_Recursivecount += 1
            logger.warning(TB.format_exc)
            logger.warning(
                f"Eran ōċA Ăяo   񐔂 {Recursivemount} 񕪑  ₵ ܂   ")
            sys.setrecursionlimit(
                sys.getrecursionlimit() + Recursivemount)
        except MemoryError:
            logger.error(TB.format_exc)
            raise MemoryError
        return temporary1

# Overlap and integrate - routine.
    def Merements(target: list, removalside: list):
        temp1 = len(removalside)
        if temp1 < 3:
            target = removalside + target
            removalside = []
        else:
            temp2 = -Eran2(temp1)
            target = removalside[len(
                removalside) + temp2: len(removalside)] + target
            removalside = removalside[: temp2]
        return target, removalside

    for J in range(action_times):
        temp1 = Cran(len(Orderlist), Centralization=15)
        temporary1 = Orderlist[:temp1]
        temporary2 = Orderlist[temp1:]
        temporary3 = []
        while (len(temporary1) > 0) and (len(temporary2) > 0):
            temporary3, temporary1 = Merements(temporary3, temporary1)
            temporary3, temporary2 = Merements(temporary3, temporary2)
        Orderlist = temporary1 + temporary2 + temporary3
    try:
        assert Orderlistlen == len(Orderlist)
    except AssertionError:
        logger.warning(TB.format_exc)
        logger.warning(
            f"list_action Ńf [ ^ ُ픭   Orderlistlen = {len(Orderlist)}")
        Orderlist = list_action(Orderlist=Spare_Orderlist)
    except RecursionError:
        logger.warning(TB.format_exc)
        logger.warning(
            f"list_action ōċA Ăяo   񐔂 {Recursivemount} 񕪑  ₵ ܂   ")
        sys.setrecursionlimit(
            sys.getrecursionlimit() + Recursivemount)
    except MemoryError:
        logger.error(TB.format_exc)
        raise MemoryError
    return Orderlist


# Durability test routine.
def Durabilitytest(plactics: int):
    l = 0
    for j in PGR.tqdm(range(plactics)):
        l += (len(list_action()) != 55) + 0
    print(f"{l} {l / plactics * 100}%")


# main
Durabilitytest(10 ** 7)
```
### 試したこと

データ欠損異常が、

以下の　範囲で、
集中して　発生している事を、
突き止めました。
```　Python
    def Merements(target: list, removalside: list):
        temp1 = len(removalside)
        if temp1 < 3:
            target = removalside + target
            removalside = []
        else:
            temp2 = -Eran2(temp1)
            target = removalside[len(
                removalside) + temp2: len(removalside)] + target
            removalside = removalside[: temp2]
        return target, removalside

    for J in range(action_times):
        temp1 = Cran(len(Orderlist), Centralization=15)
        temporary1 = Orderlist[:temp1]
        temporary2 = Orderlist[temp1:]
        temporary3 = []
        while (len(temporary1) > 0) and (len(temporary2) > 0):
            temporary3, temporary1 = Merements(temporary3, temporary1)
            temporary3, temporary2 = Merements(temporary3, temporary2)
        Orderlist = temporary1 + temporary2 + temporary3
```

しかし、

Merementsルーチン内で、
異常は　発生しませんでした。
＿

詰り、

以下の　範囲内で、
データ欠損異常が　発生しているものと、
思われます。
```　Python
    for J in range(action_times):
        temp1 = Cran(len(Orderlist), Centralization=15)
        temporary1 = Orderlist[:temp1]
        temporary2 = Orderlist[temp1:]
        temporary3 = []
        while (len(temporary1) > 0) and (len(temporary2) > 0):
          処理、
        Orderlist = temporary1 + temporary2 + temporary3
```
＿

流石に、

此は　初任者では、
どうこうできる　レベルを、
超えてそうな　気が、
しています、

ご教示を　お願いします。
＿

### 補足情報

実行すると、

大量の　Warningを、
ファイルに　吐き出し始めます、
お気をつけを。

### 追記
なんだか、

酷い　虚実な、
誹り、誹謗中傷、悪態を、
つけられてますので、

どっちが　聞く、
耳を　持たないのか、
どっちが　迷惑行為を、
仕掛けているのか、

検証Coding提示によって、
明らかにしたいと　思います。
_
是非、

お手元で　検証を、
頂き、
原因究明に　お役立て、
頂ければ　幸いです。

_
尚、

当然ですが　当該環境では、
ok以外の　結果は、
詰まり　データ欠損は、
存在しませんでした。

_
Merementsルーチンは、

無問題である旨、
示したにも　関わらず、
他者の　仕業を、
軽軽しく　踏みにじり、

_
おまけに、

冒涜の限りを、
尽くす　姿勢には、
誰であろうと　看過できない、
事でしょう。

_
Merements検証ルーチン。
```Python3.11．1
j = 0
k = 0
Eran2 = lambda X: j
def test(func):
    pass
    def wrap(*args, **kwargs):
        a = [1, 2, 3, 4, 5, 6, 7]
        master = []
        global k, j
        for i in a:
            master.append(a)
            applicable = master
            for j in range(-1, -7, -1):
                temp1, temp2 = func([], applicable)
                k += 0 if len(master) == len(temp1) + len(temp2) else 1
        return
    return wrap

@test
def Merements(target: list, removalside: list):
    temp1 = len(removalside)
    if temp1 < 3:
        target = removalside + target
        removalside = []
    else:
        temp2 = -1 * Eran2(temp1)
        target = removalside[len(removalside) +
                             temp2: len(removalside)] + target
        removalside = removalside[: temp2]
    return target, removalside

print(str(k) if Merements([], []) else "ok")
```

Python3.11.1:原因不明の　挙動不審を、何とかしたい。

プログラミング初心者です。jspにてプルダウンを表示させようとしています。その際にjspは、ServletでArrayListに格納した値を受け取り、プルダウンにて表示させようとしています。

下記にjspのソースコードを記述しました。
ここではjsp内でArrayListに値を格納し、ArrayListに格納した値を利用して、プルダウンを表示させています。JSP内では実現できるのですが、次のステップとして、前述したようにServletにてArrayListに値を格納し、jspにてその値を受け取り、プルダウンを表示させようとしています。しかし、実現方法がわからず困っています。

【質問】
ServletにてArrayListに値(2000と2001)を格納し、jspにてその値を受け取り、list.jspと同様のプルダウンを表示させる方法をご教授頂けないでしょうか？

何卒宜しくお願い致します。

list.jsp
```ここに言語を入力
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<%@ page import="java.util.ArrayList" %>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>list.jsp</title>
</head>
<script type="text/javascript">

</script>
<body>
	<%ArrayList dummyList = new ArrayList();%>
		<% dummyList.add("2000"); %>
		<% dummyList.add("2001"); %>
	<select>
	<%for (int i = 0; i < dummyList.size(); i++) {%>
		<option value="list<%=i%>"><%=dummyList.get(i)%></option>
	<%}%>
	</select>
</body>
</html>
```