ਮੇਰੇ ਕੋਲ flow.map {ਮੁੱਲ-> \\n ਪਰਿਵਰਤਨ () \\n}. onEach {\\n\\n} ਹੈ। ", 'ਮੇਰੇ ਕੋਲ flow.map {ਮੁੱਲ-> ਪਰਿਵਰਤਨ ()}. onEach {} ਹੈ। onEach ਕੀ ਕਰਦਾ ਹੈ?', " ['ਮੇਰੇ ਕੋਲ flow.map {ਮੁੱਲ-> \\n ਪਰਿਵਰਤਨ () \\n}. onEach {\\n\\n} ਹੈ।', ਪ੍ਰਤੀਕ੍ਰਿਆਸ਼ੀਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਢਾਂਚੇ ਵਿੱਚ, 'onEach ()' ਕੀ ਕਰਦਾ ਹੈ?ਸੰਚਾਲਕ ਆਰਐਕਸਜੇਵਾ ਵਿੱਚ 'ਪ੍ਰਕਾਸ਼ਕ' ਇੰਟਰਫੇਸ ਦਾ ਇੱਕ ਹਿੱਸਾ ਹੈ। ਇਸ ਦੀ ਵਰਤੋਂ ਇੱਕ ਪ੍ਰਕਾਸ਼ਕ ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਉੱਤੇ ਇੱਕ ਕਾਰਵਾਈ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ 'ਫਲੋ',ਇੱਕ ਕ੍ਰਮਵਾਰ ਢੰਗ ਨਾਲ। \\n\\n ਤੁਹਾਡੇ ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਕੋਡ ਸਨਿੱਪਟ ਵਿੱਚ, 'flow.map' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ 'ਫਲੋ' ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਨੂੰ ਇੱਕ ਨਵੇਂ ਆਈਟਮ ਵਿੱਚ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।ਆਈਟਮ. ਨਤੀਜੇ ਵਜੋਂ ਪਰਿਵਰਤਿਤ ਆਈਟਮਾਂ ਨੂੰ ਫਿਰ 'onEach ()' ਓਪਰੇਟਰ ਨੂੰ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. \\n\\n 'onEach ()' ਓਪਰੇਟਰ ਇੱਕ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਇੱਕ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਲੈਂਦਾ ਹੈ,ਜਿਸ ਨੂੰ 'ਫਲੋ' ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਲਈ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਤੁਹਾਡੇ ਮਾਮਲੇ ਵਿੱਚ, ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਪ੍ਰਦਾਨ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ, ਇਸ ਲਈ 'onEach ()' ਦੇ ਅੰਦਰ ਕੁਝ ਨਹੀਂ ਹੁੰਦਾ ਹੈ।'onEach ()' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਇੱਕ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਪ੍ਰਦਾਨ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਜੋ ਹਰੇਕ ਆਈਟਮ ਉੱਤੇ ਕੁੱਝ ਕਾਰਵਾਈ ਕਰਦਾ ਹੈ।'ਫਲੋ'। ਉਦਾਹਰਨ ਲਈ, ਤੁਸੀਂ ਇਸ ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਵਸਤੂ ਨੂੰ ਸਾਈਡ-ਇਫੈਕਟ ਪ੍ਰਕਿਰਿਆ ਲਈ ਕਰ ਸਕਦੇ ਹੋ, ਜਾਂ ਮੂਲ ਦੇ ਪਰਿਵਰਤਨ ਦੇ ਅਧਾਰ ਉੱਤੇ ਇੱਕ ਨਵੀਂ ਵਸਤੂ ਨੂੰ ਛੱਡਣ ਲਈ ਕਰ ਸਕਦੇ ਹੋ।ਆਈਟਮ। \\n\\n ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਜੋ 'ਫਲੋ' ਦੁਆਰਾ ਕੱਢੀ ਗਈ ਮੂਲ ਆਈਟਮ ਦੇ ਅਧਾਰ ਉੱਤੇ ਇੱਕ ਨਵੀਂ ਆਈਟਮ ਨੂੰ ਛੱਡਣ ਲਈ 'onEach ()' ਦੀ ਵਰਤੋਂ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈਃ \\n '' scsss\\nvalਫਲੋ = ਫਲੋਓਫ (1,2,3) \\n\\nਫਲੋ\\n. ਮੈਪ {it * 2} \\n. onEach {ਮੁੱਲ-> \\n ਨਿਕਾਸ (ਮੁੱਲ)// ਪਰਿਵਰਤਿਤ ਮੁੱਲ ਨੂੰ ਨਿਕਾਸ ਕਰਦਾ ਹੈ \\n} \\n '\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ,'ਮੈਪ ()' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ 'ਫਲੋ' ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਨੂੰ 2 ਨਾਲ ਗੁਣਾ ਕਰਕੇ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।'onEach ()' ਓਪਰੇਟਰ, ਜਿੱਥੇ ਇੱਕ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਹਰੇਕ ਪਰਿਵਰਤਿਤ ਆਈਟਮ ਨੂੰ ਬਾਹਰ ਕੱਢਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ 'onEach ()' ਓਪਰੇਟਰ ਇਸ ਦੇ ਸਮਾਨ ਨਹੀਂ ਹੈ।'ਮੈਪ ()' ਓਪਰੇਟਰ, ਹਾਲਾਂਕਿ ਉਹ ਦੋਵੇਂ ਇੱਕ 'ਫਲੋ' ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਆਈਟਮਾਂ ਨੂੰ ਬਦਲਣ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ. 'ਮੈਪ ()' ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਆਈਟਮ ਨੂੰ ਇੱਕ ਨਵੀਂ ਆਈਟਮ ਵਿੱਚ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ,ਜਦੋਂ ਕਿ 'onEach ()' ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਆਈਟਮ ਉੱਤੇ ਇੱਕ ਸਾਈਡ-ਇਫੈਕਟ ਲਾਗੂ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਪਰ ਨਤੀਜੇ ਵਜੋਂ ਬਦਲੀਆਂ ਗਈਆਂ ਆਈਟਮਾਂ 'ਫਲੋ' ਦੁਆਰਾ ਨਹੀਂ ਨਿਕਲਦੀਆਂ।ਇੱਕ ਗਰਮ ਪ੍ਰਵਾਹ ਜਾਂ ਠੰਡਾ ਪ੍ਰਵਾਹ? ' ", 'ਮੇਰੇ ਕੋਲ flow.map {ਮੁੱਲ-> ਪਰਿਵਰਤਨ ()}. onEach {} ਹੈ। onEach ਕੀ ਕਰਦਾ ਹੈ?', ' [\'ਮੇਰੇ ਕੋਲ flow.map {ਮੁੱਲ-> \\n ਪਰਿਵਰਤਨ () \\n}. onEach {\\n\\n} ਹੈ।\', ਪ੍ਰਤੀਕ੍ਰਿਆਸ਼ੀਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਢਾਂਚੇ ਵਿੱਚ, \'onEach ()\' ਕੀ ਕਰਦਾ ਹੈ?ਸੰਚਾਲਕ ਆਰਐਕਸਜੇਵਾ ਵਿੱਚ \'ਪ੍ਰਕਾਸ਼ਕ\' ਇੰਟਰਫੇਸ ਦਾ ਇੱਕ ਹਿੱਸਾ ਹੈ। ਇਸ ਦੀ ਵਰਤੋਂ ਇੱਕ ਪ੍ਰਕਾਸ਼ਕ ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਉੱਤੇ ਇੱਕ ਕਾਰਵਾਈ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ \'ਫਲੋ\',ਇੱਕ ਕ੍ਰਮਵਾਰ ਢੰਗ ਨਾਲ। \\n\\n ਤੁਹਾਡੇ ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਕੋਡ ਸਨਿੱਪਟ ਵਿੱਚ, \'flow.map\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਨੂੰ ਇੱਕ ਨਵੇਂ ਆਈਟਮ ਵਿੱਚ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।ਆਈਟਮ. ਨਤੀਜੇ ਵਜੋਂ ਪਰਿਵਰਤਿਤ ਆਈਟਮਾਂ ਨੂੰ ਫਿਰ \'onEach ()\' ਓਪਰੇਟਰ ਨੂੰ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. \\n\\n \'onEach ()\' ਓਪਰੇਟਰ ਇੱਕ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਇੱਕ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਲੈਂਦਾ ਹੈ,ਜਿਸ ਨੂੰ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਲਈ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਤੁਹਾਡੇ ਮਾਮਲੇ ਵਿੱਚ, ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਪ੍ਰਦਾਨ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ, ਇਸ ਲਈ \'onEach ()\' ਦੇ ਅੰਦਰ ਕੁਝ ਨਹੀਂ ਹੁੰਦਾ ਹੈ।\'onEach ()\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਇੱਕ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਪ੍ਰਦਾਨ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਜੋ ਹਰੇਕ ਆਈਟਮ ਉੱਤੇ ਕੁੱਝ ਕਾਰਵਾਈ ਕਰਦਾ ਹੈ।\'ਫਲੋ\'। ਉਦਾਹਰਨ ਲਈ, ਤੁਸੀਂ ਇਸ ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਵਸਤੂ ਨੂੰ ਸਾਈਡ-ਇਫੈਕਟ ਪ੍ਰਕਿਰਿਆ ਲਈ ਕਰ ਸਕਦੇ ਹੋ, ਜਾਂ ਮੂਲ ਦੇ ਪਰਿਵਰਤਨ ਦੇ ਅਧਾਰ ਉੱਤੇ ਇੱਕ ਨਵੀਂ ਵਸਤੂ ਨੂੰ ਛੱਡਣ ਲਈ ਕਰ ਸਕਦੇ ਹੋ।ਆਈਟਮ। \\n\\n ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਜੋ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੀ ਗਈ ਮੂਲ ਆਈਟਮ ਦੇ ਅਧਾਰ ਉੱਤੇ ਇੱਕ ਨਵੀਂ ਆਈਟਮ ਨੂੰ ਛੱਡਣ ਲਈ \'onEach ()\' ਦੀ ਵਰਤੋਂ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈਃ \\n \'\' scsss\\nvalਫਲੋ = ਫਲੋਓਫ (1,2,3) \\n\\nਫਲੋ\\n. ਮੈਪ {it * 2} \\n. onEach {ਮੁੱਲ-> \\n ਨਿਕਾਸ (ਮੁੱਲ)// ਪਰਿਵਰਤਿਤ ਮੁੱਲ ਨੂੰ ਨਿਕਾਸ ਕਰਦਾ ਹੈ \\n} \\n \'\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ,\'ਮੈਪ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਨੂੰ 2 ਨਾਲ ਗੁਣਾ ਕਰਕੇ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।\'onEach ()\' ਓਪਰੇਟਰ, ਜਿੱਥੇ ਇੱਕ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਹਰੇਕ ਪਰਿਵਰਤਿਤ ਆਈਟਮ ਨੂੰ ਬਾਹਰ ਕੱਢਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ \'onEach ()\' ਓਪਰੇਟਰ ਇਸ ਦੇ ਸਮਾਨ ਨਹੀਂ ਹੈ।\'ਮੈਪ ()\' ਓਪਰੇਟਰ, ਹਾਲਾਂਕਿ ਉਹ ਦੋਵੇਂ ਇੱਕ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਆਈਟਮਾਂ ਨੂੰ ਬਦਲਣ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ. \'ਮੈਪ ()\' ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਆਈਟਮ ਨੂੰ ਇੱਕ ਨਵੀਂ ਆਈਟਮ ਵਿੱਚ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ,ਜਦੋਂ ਕਿ \'onEach ()\' ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਆਈਟਮ ਉੱਤੇ ਇੱਕ ਸਾਈਡ-ਇਫੈਕਟ ਲਾਗੂ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਪਰ ਨਤੀਜੇ ਵਜੋਂ ਬਦਲੀਆਂ ਗਈਆਂ ਆਈਟਮਾਂ \'ਫਲੋ\' ਦੁਆਰਾ ਨਹੀਂ ਨਿਕਲਦੀਆਂ।\',\' ਕੋਟਲਿਨ ਵਿੱਚ, \'ਸਟੇਟਫਲੋ\' ਇੱਕ ਕਿਸਮ ਦਾ \'ਫਲੋ\' ਹੈ ਜੋ ਉਹਨਾਂ ਮੁੱਲਾਂ ਦੇ ਇੱਕ ਕ੍ਰਮ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ ਜੋ ਬਦਲ ਸਕਦੇ ਹਨਸਮੇਂ ਦੇ ਨਾਲ ਇਹ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਲਾਇਬ੍ਰੇਰੀ ਦਾ ਹਿੱਸਾ ਹੈ ਜਿਸ ਨੂੰ ਜੇਟਪੈਕ ਕੰਪੋਜ਼ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। \\n\\n \'ਸਟੇਟਫਲੋ\' ਇੱਕ ਠੰਡਾ ਪ੍ਰਵਾਹ ਹੈ, ਜਿਸਦਾ ਅਰਥ ਹੈ ਕਿ ਇਹ ਟਰਿੱਗਰ ਨਹੀਂ ਕਰਦਾ ਹੈ।ਅੱਪਡੇਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਇਸਦੇ ਗਾਹਕ ਉਹਨਾਂ ਨੂੰ ਬੇਨਤੀ ਨਹੀਂ ਕਰਦੇ. ਠੰਡੇ ਪ੍ਰਵਾਹ ਆਮ ਤੌਰ \'ਤੇ ਗਰਮ ਪ੍ਰਵਾਹਾਂ ਨਾਲੋਂ ਵਧੇਰੇ ਕੁਸ਼ਲ ਹੁੰਦੇ ਹਨ, ਕਿਉਂਕਿ ਉਹ ਬੇਲੋਡ਼ੇ ਤੌਰ\' ਤੇ ਦੁਬਾਰਾ ਕੰਪਿਊਟ ਨਹੀਂ ਕਰਦੇ ਜਾਂਮੁੱਲ ਛੱਡੋ। \\n\\n \'ਸਟੇਟਫਲੋ\' ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਇਸ ਨੂੰ ਜੈੱਟਪੈਕ ਕੰਪੋਜ਼ ਵਿੱਚ ਇੱਕ ਹਿੱਸੇ ਲਈ ਮੁੱਲ ਧਾਰਕ ਵਜੋਂ ਵਰਤਣ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਇਹ ਆਪਣੇ ਆਪਆਪਣੇ ਗਾਹਕਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦਾ ਹੈ। ਜਦੋਂ ਕੋਈ ਗਾਹਕ ਇੱਕ ਅੱਪਡੇਟ ਦੀ ਬੇਨਤੀ ਕਰਦਾ ਹੈ, ਤਾਂ \'ਸਟੇਟਫਲੋ\' ਨਵੀਨਤਮ ਮੁੱਲ ਦਾ ਨਿਕਾਸ ਕਰਦਾ ਹੈ, ਅਤੇ ਮੁੱਲ ਵਿੱਚ ਕੋਈ ਵੀ ਬਾਅਦ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਹਨਆਪਣੇ ਆਪ ਸਾਰੇ ਗਾਹਕਾਂ ਨੂੰ ਸੰਚਾਰਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \\n\\nਇੱਥੇ ਜੇਟਪੈਕ ਵਿੱਚ \'ਸਟੇਟਫਲੋ\' ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n \'\' scsss\\ n@Composable \\nfunਮਾਈ ਕੰਪੋਨੈਂਟ (ਸਥਿਤੀਃ ਸਟੇਟਫਲੋ <ਇੰਟ>) {\\n ਵੈਲ ਸਟੇਟਵੈਲੂ ਬਾਈ state.collectAsState () \\n\\n ਟੈਕਸਟ (ਟੈਕਸਟ = "ਮੁੱਲ ${stateValue} ਹੈ") \\n} \\n "\'\\n ਇਸ ਵਿੱਚਉਦਾਹਰਨ ਲਈ, \'ਸਟੇਟਫਲੋ\' ਨੂੰ \'ਮਾਈ ਕੰਪੋਨੈਂਟ\' ਫੰਕਸ਼ਨ ਲਈ ਇੱਕ ਪੈਰਾਮੀਟਰ ਦੇ ਰੂਪ ਵਿੱਚ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਇਸ ਦੀ ਵਰਤੋਂ ਇੱਕ \'ਟੈਕਸਟ\' ਕੰਪੋਨੈਂਟ ਦੀ ਸਥਿਤੀ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।\'ਸੰਗ੍ਰਹਿ ਅਸਟੇਟ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ \'ਸਟੇਟ ਫਲੋ\' ਦੇ ਨਵੀਨਤਮ ਮੁੱਲ ਨੂੰ \'ਸਟੇਟ ਵੈਲਯੂ\' ਨਾਮਕ ਇੱਕ ਪਰਿਵਰਤਨਸ਼ੀਲ ਅਵਸਥਾ ਵੇਰੀਏਬਲ ਵਿੱਚ ਇਕੱਤਰ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜੋ ਕਿ ਹੋ ਸਕਦਾ ਹੈUI ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਜਦੋਂ UI ਪੇਸ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, \'ਸਟੇਟਫਲੋ\' ਉਦੋਂ ਤੱਕ ਅੱਪਡੇਟ ਨੂੰ ਟਰਿੱਗਰ ਨਹੀਂ ਕਰੇਗਾ ਜਦੋਂ ਤੱਕ \'ਟੈਕਸਟ\' ਕੰਪੋਨੈਂਟ ਇੱਕ ਅੱਪਡੇਟ ਦੀ ਬੇਨਤੀ ਨਹੀਂ ਕਰਦਾ। ਇਸਦਾ ਅਰਥ ਹੈਕਿ \'ਸਟੇਟਫਲੋ\' ਇੱਕ ਠੰਡਾ ਪ੍ਰਵਾਹ ਹੈ, ਅਤੇ ਇਹ ਬੇਲੋਡ਼ੀ ਤੌਰ \'ਤੇ ਮੁੱਲਾਂ ਦੀ ਮੁਡ਼ ਗਣਨਾ ਜਾਂ ਨਿਕਾਸ ਨਹੀਂ ਕਰੇਗਾ ਜਦੋਂ ਤੱਕ ਉਹਨਾਂ ਨੂੰ ਗਾਹਕਾਂ ਦੁਆਰਾ ਬੇਨਤੀ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ।ਇੱਕ ਹੋਰ ਪ੍ਰਵਾਹ ਤੋਂ ਇੱਕ ਪ੍ਰਵਾਹ ਬਣਾਓ? ', 'ਮੇਰੇ ਕੋਲ flow.map {ਮੁੱਲ-> ਪਰਿਵਰਤਨ ()}. onEach {} ਹੈ। onEach ਕੀ ਕਰਦਾ ਹੈ?', ' [\'ਮੇਰੇ ਕੋਲ flow.map {ਮੁੱਲ-> \\n ਪਰਿਵਰਤਨ () \\n}. onEach {\\n\\n} ਹੈ।\', ਪ੍ਰਤੀਕ੍ਰਿਆਸ਼ੀਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਢਾਂਚੇ ਵਿੱਚ, \'onEach ()\' ਕੀ ਕਰਦਾ ਹੈ?ਸੰਚਾਲਕ ਆਰਐਕਸਜੇਵਾ ਵਿੱਚ \'ਪ੍ਰਕਾਸ਼ਕ\' ਇੰਟਰਫੇਸ ਦਾ ਇੱਕ ਹਿੱਸਾ ਹੈ। ਇਸ ਦੀ ਵਰਤੋਂ ਇੱਕ ਪ੍ਰਕਾਸ਼ਕ ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਉੱਤੇ ਇੱਕ ਕਾਰਵਾਈ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ \'ਫਲੋ\',ਇੱਕ ਕ੍ਰਮਵਾਰ ਢੰਗ ਨਾਲ। \\n\\n ਤੁਹਾਡੇ ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਕੋਡ ਸਨਿੱਪਟ ਵਿੱਚ, \'flow.map\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਨੂੰ ਇੱਕ ਨਵੇਂ ਆਈਟਮ ਵਿੱਚ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।ਆਈਟਮ. ਨਤੀਜੇ ਵਜੋਂ ਪਰਿਵਰਤਿਤ ਆਈਟਮਾਂ ਨੂੰ ਫਿਰ \'onEach ()\' ਓਪਰੇਟਰ ਨੂੰ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. \\n\\n \'onEach ()\' ਓਪਰੇਟਰ ਇੱਕ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਇੱਕ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਲੈਂਦਾ ਹੈ,ਜਿਸ ਨੂੰ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਲਈ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਤੁਹਾਡੇ ਮਾਮਲੇ ਵਿੱਚ, ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਪ੍ਰਦਾਨ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ, ਇਸ ਲਈ \'onEach ()\' ਦੇ ਅੰਦਰ ਕੁਝ ਨਹੀਂ ਹੁੰਦਾ ਹੈ।\'onEach ()\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਇੱਕ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਪ੍ਰਦਾਨ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਜੋ ਹਰੇਕ ਆਈਟਮ ਉੱਤੇ ਕੁੱਝ ਕਾਰਵਾਈ ਕਰਦਾ ਹੈ।\'ਫਲੋ\'। ਉਦਾਹਰਨ ਲਈ, ਤੁਸੀਂ ਇਸ ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਵਸਤੂ ਨੂੰ ਸਾਈਡ-ਇਫੈਕਟ ਪ੍ਰਕਿਰਿਆ ਲਈ ਕਰ ਸਕਦੇ ਹੋ, ਜਾਂ ਮੂਲ ਦੇ ਪਰਿਵਰਤਨ ਦੇ ਅਧਾਰ ਉੱਤੇ ਇੱਕ ਨਵੀਂ ਵਸਤੂ ਨੂੰ ਛੱਡਣ ਲਈ ਕਰ ਸਕਦੇ ਹੋ।ਆਈਟਮ। \\n\\n ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਜੋ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੀ ਗਈ ਮੂਲ ਆਈਟਮ ਦੇ ਅਧਾਰ ਉੱਤੇ ਇੱਕ ਨਵੀਂ ਆਈਟਮ ਨੂੰ ਛੱਡਣ ਲਈ \'onEach ()\' ਦੀ ਵਰਤੋਂ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈਃ \\n \'\' scsss\\nvalਫਲੋ = ਫਲੋਓਫ (1,2,3) \\n\\nਫਲੋ\\n. ਮੈਪ {it * 2} \\n. onEach {ਮੁੱਲ-> \\n ਨਿਕਾਸ (ਮੁੱਲ)// ਪਰਿਵਰਤਿਤ ਮੁੱਲ ਨੂੰ ਨਿਕਾਸ ਕਰਦਾ ਹੈ \\n} \\n \'\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ,\'ਮੈਪ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਨੂੰ 2 ਨਾਲ ਗੁਣਾ ਕਰਕੇ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।\'onEach ()\' ਓਪਰੇਟਰ, ਜਿੱਥੇ ਇੱਕ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਹਰੇਕ ਪਰਿਵਰਤਿਤ ਆਈਟਮ ਨੂੰ ਬਾਹਰ ਕੱਢਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ \'onEach ()\' ਓਪਰੇਟਰ ਇਸ ਦੇ ਸਮਾਨ ਨਹੀਂ ਹੈ।\'ਮੈਪ ()\' ਓਪਰੇਟਰ, ਹਾਲਾਂਕਿ ਉਹ ਦੋਵੇਂ ਇੱਕ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਆਈਟਮਾਂ ਨੂੰ ਬਦਲਣ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ. \'ਮੈਪ ()\' ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਆਈਟਮ ਨੂੰ ਇੱਕ ਨਵੀਂ ਆਈਟਮ ਵਿੱਚ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ,ਜਦੋਂ ਕਿ \'onEach ()\' ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਆਈਟਮ ਉੱਤੇ ਇੱਕ ਸਾਈਡ-ਇਫੈਕਟ ਲਾਗੂ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਪਰ ਨਤੀਜੇ ਵਜੋਂ ਬਦਲੀਆਂ ਗਈਆਂ ਆਈਟਮਾਂ \'ਫਲੋ\' ਦੁਆਰਾ ਨਹੀਂ ਨਿਕਲਦੀਆਂ।\',\' ਕੋਟਲਿਨ ਵਿੱਚ, \'ਸਟੇਟਫਲੋ\' ਇੱਕ ਕਿਸਮ ਦਾ \'ਫਲੋ\' ਹੈ ਜੋ ਉਹਨਾਂ ਮੁੱਲਾਂ ਦੇ ਇੱਕ ਕ੍ਰਮ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ ਜੋ ਬਦਲ ਸਕਦੇ ਹਨਸਮੇਂ ਦੇ ਨਾਲ ਇਹ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਲਾਇਬ੍ਰੇਰੀ ਦਾ ਹਿੱਸਾ ਹੈ ਜਿਸ ਨੂੰ ਜੇਟਪੈਕ ਕੰਪੋਜ਼ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। \\n\\n \'ਸਟੇਟਫਲੋ\' ਇੱਕ ਠੰਡਾ ਪ੍ਰਵਾਹ ਹੈ, ਜਿਸਦਾ ਅਰਥ ਹੈ ਕਿ ਇਹ ਟਰਿੱਗਰ ਨਹੀਂ ਕਰਦਾ ਹੈ।ਅੱਪਡੇਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਇਸਦੇ ਗਾਹਕ ਉਹਨਾਂ ਨੂੰ ਬੇਨਤੀ ਨਹੀਂ ਕਰਦੇ. ਠੰਡੇ ਪ੍ਰਵਾਹ ਆਮ ਤੌਰ \'ਤੇ ਗਰਮ ਪ੍ਰਵਾਹਾਂ ਨਾਲੋਂ ਵਧੇਰੇ ਕੁਸ਼ਲ ਹੁੰਦੇ ਹਨ, ਕਿਉਂਕਿ ਉਹ ਬੇਲੋਡ਼ੇ ਤੌਰ\' ਤੇ ਦੁਬਾਰਾ ਕੰਪਿਊਟ ਨਹੀਂ ਕਰਦੇ ਜਾਂਮੁੱਲ ਛੱਡੋ। \\n\\n \'ਸਟੇਟਫਲੋ\' ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਇਸ ਨੂੰ ਜੈੱਟਪੈਕ ਕੰਪੋਜ਼ ਵਿੱਚ ਇੱਕ ਹਿੱਸੇ ਲਈ ਮੁੱਲ ਧਾਰਕ ਵਜੋਂ ਵਰਤਣ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਇਹ ਆਪਣੇ ਆਪਆਪਣੇ ਗਾਹਕਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦਾ ਹੈ। ਜਦੋਂ ਕੋਈ ਗਾਹਕ ਇੱਕ ਅੱਪਡੇਟ ਦੀ ਬੇਨਤੀ ਕਰਦਾ ਹੈ, ਤਾਂ \'ਸਟੇਟਫਲੋ\' ਨਵੀਨਤਮ ਮੁੱਲ ਦਾ ਨਿਕਾਸ ਕਰਦਾ ਹੈ, ਅਤੇ ਮੁੱਲ ਵਿੱਚ ਕੋਈ ਵੀ ਬਾਅਦ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਹਨਆਪਣੇ ਆਪ ਸਾਰੇ ਗਾਹਕਾਂ ਨੂੰ ਸੰਚਾਰਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \\n\\n \'ਇਹ ਜੇਟਪੈਕ ਵਿੱਚ\' ਸਟੇਟਫਲੋ \'ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n\' \'scsss\\ n@Composable \\nfunਮਾਈ ਕੰਪੋਨੈਂਟ (ਸਥਿਤੀਃ ਸਟੇਟਫਲੋ <ਇੰਟ>) {\\n ਵੈਲ ਸਟੇਟਵੈਲੂ ਬਾਈ state.collectAsState () \\n\\n ਟੈਕਸਟ (ਟੈਕਸਟ = "ਮੁੱਲ ${stateValue} ਹੈ") \\n} \\n "\'\\n ਇਸ ਵਿੱਚਉਦਾਹਰਨ ਲਈ, \'ਸਟੇਟਫਲੋ\' ਨੂੰ \'ਮਾਈ ਕੰਪੋਨੈਂਟ\' ਫੰਕਸ਼ਨ ਲਈ ਇੱਕ ਪੈਰਾਮੀਟਰ ਦੇ ਰੂਪ ਵਿੱਚ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਇਸ ਦੀ ਵਰਤੋਂ ਇੱਕ \'ਟੈਕਸਟ\' ਕੰਪੋਨੈਂਟ ਦੀ ਸਥਿਤੀ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।\'ਸੰਗ੍ਰਹਿ ਅਸਟੇਟ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ \'ਸਟੇਟ ਫਲੋ\' ਦੇ ਨਵੀਨਤਮ ਮੁੱਲ ਨੂੰ \'ਸਟੇਟ ਵੈਲਯੂ\' ਨਾਮਕ ਇੱਕ ਪਰਿਵਰਤਨਸ਼ੀਲ ਅਵਸਥਾ ਵੇਰੀਏਬਲ ਵਿੱਚ ਇਕੱਤਰ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜੋ ਕਿ ਹੋ ਸਕਦਾ ਹੈUI ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਜਦੋਂ UI ਪੇਸ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, \'ਸਟੇਟਫਲੋ\' ਉਦੋਂ ਤੱਕ ਅੱਪਡੇਟ ਨੂੰ ਟਰਿੱਗਰ ਨਹੀਂ ਕਰੇਗਾ ਜਦੋਂ ਤੱਕ \'ਟੈਕਸਟ\' ਕੰਪੋਨੈਂਟ ਇੱਕ ਅੱਪਡੇਟ ਦੀ ਬੇਨਤੀ ਨਹੀਂ ਕਰਦਾ। ਇਸਦਾ ਅਰਥ ਹੈਕਿ \'ਸਟੇਟਫਲੋ\' ਇੱਕ ਠੰਡਾ ਪ੍ਰਵਾਹ ਹੈ, ਅਤੇ ਇਹ ਬੇਲੋਡ਼ੀ ਤੌਰ \'ਤੇ ਮੁੱਲਾਂ ਦੀ ਮੁਡ਼ ਗਣਨਾ ਜਾਂ ਨਿਕਾਸ ਨਹੀਂ ਕਰੇਗਾ ਜਦੋਂ ਤੱਕ ਉਹਨਾਂ ਨੂੰ ਗਾਹਕਾਂ ਦੁਆਰਾ ਬੇਨਤੀ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ।ਕਿਸੇ ਹੋਰ ਪ੍ਰਵਾਹ ਤੋਂ ਇੱਕ ਪ੍ਰਵਾਹ ਬਣਾਓ? \',\' RxJava ਵਿੱਚ, ਤੁਸੀਂ \'ਮਰਜ ()\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਿਸੇ ਹੋਰ \'ਫਲੋ\' ਤੋਂ ਇੱਕ ਨਵਾਂ \'ਫਲੋ\' ਬਣਾ ਸਕਦੇ ਹੋ। \'ਮਰਜ ()\'ਓਪਰੇਟਰ ਦੋ \'ਫਲੋ\' ਨੂੰ ਇੱਕ ਸਿੰਗਲ \'ਫਲੋ\' ਵਿੱਚ ਜੋਡ਼ਦਾ ਹੈ, ਅਤੇ ਇਹ ਦੋਵਾਂ \'ਫਲੋ\' ਵਿੱਚੋਂ ਕਿਸੇ ਇੱਕ ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਦਾ ਹੈ। \\n\\nਇੱਥੇ ਇੱਕ ਬਣਾਉਣ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਦੋ ਹੋਰ \'ਫਲੋ\' ਤੋਂ ਨਵਾਂ \'ਫਲੋ\': \\n \'\' scsss\\nval ਫਲੋ 1 = ਫਲੋਓਫ (1,2,3) \\nval ਫਲੋ 2 = ਫਲੋਓਫ (4,5,6) \\n\\nval ਨਿਊਫਲੋ = flow1.merge (ਫਲੋ 2) \\n \'\' \\ninਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਦੋ \'ਫਲੋ\', \'ਫਲੋ 1\' ਅਤੇ \'ਫਲੋ 2\' ਬਣਾਏ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਨੂੰ \'ਮਰਜ ()\' ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ \'ਨਿਊ ਫਲੋ\' ਨਾਮਕ ਇੱਕ ਨਵੇਂ \'ਫਲੋ\' ਵਿੱਚ ਮਿਲਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।ਓਪਰੇਟਰ। \\n\\n ਨਤੀਜੇ ਵਜੋਂ \'ਨਵਾਂ ਫਲੋ\' ਜਾਂ ਤਾਂ \'ਫਲੋ 1\' ਜਾਂ \'ਫਲੋ 2\' ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢੇਗਾ, ਇਹ ਇਸ ਗੱਲ \'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹਡ਼ਾ\' ਫਲੋ \'ਪਹਿਲਾਂ ਆਈਟਮਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਦਾ ਹੈ।ਆਈਟਮਾਂ ਇੱਕੋ ਸਮੇਂ ਕੱਢੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ ਉਹ ਕੱਢੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਉਸ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਹੁੰਦੀ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ \'ਮਰਜ ()\' ਓਪਰੇਟਰ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਹੀਂ ਹੈ,ਜਿਸ ਦਾ ਅਰਥ ਹੈ ਕਿ ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ \'ਫਲੋ\' ਨੂੰ ਮਿਲਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਉਹ ਨਤੀਜੇ ਵਜੋਂ \'ਫਲੋ\' ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰ ਸਕਦਾ ਹੈ। ਨਾਲ ਹੀ, \'ਮਰਜ ()\' ਓਪਰੇਟਰ ਆਰਡਰ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਦਿੰਦਾ ਹੈ।ਜਿਸ ਵਿੱਚ ਆਈਟਮਾਂ ਦਾ ਨਿਕਾਸ ਹੁੰਦਾ ਹੈ, ਇਸ ਲਈ ਇਹ ਸਾਰੇ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਲਈ ਢੁਕਵਾਂ ਨਹੀਂ ਹੋ ਸਕਦਾ ਹੈ। ", \'ਐਂਡਰਾਇਡ ਕੋਟਲਿਨ ਵਿੱਚ ਇੱਕ ਪ੍ਰਵਾਹ ਕਿਵੇਂ ਬਣਾਇਆ ਜਾਵੇ ਜੋ ਕਿਸੇ ਹੋਰ ਪ੍ਰਵਾਹ ਉੱਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ।? \') ', 'ਮੇਰੇ ਕੋਲ flow.map {ਮੁੱਲ-> ਪਰਿਵਰਤਨ ()}. onEach {} ਹੈ। onEach ਕੀ ਕਰਦਾ ਹੈ?', ' [\'ਮੇਰੇ ਕੋਲ flow.map {ਮੁੱਲ-> \\n ਪਰਿਵਰਤਨ () \\n}. onEach {\\n\\n} ਹੈ।\', ਪ੍ਰਤੀਕ੍ਰਿਆਸ਼ੀਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਢਾਂਚੇ ਵਿੱਚ, \'onEach ()\' ਕੀ ਕਰਦਾ ਹੈ?ਸੰਚਾਲਕ ਆਰਐਕਸਜੇਵਾ ਵਿੱਚ \'ਪ੍ਰਕਾਸ਼ਕ\' ਇੰਟਰਫੇਸ ਦਾ ਇੱਕ ਹਿੱਸਾ ਹੈ। ਇਸ ਦੀ ਵਰਤੋਂ ਇੱਕ ਪ੍ਰਕਾਸ਼ਕ ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਉੱਤੇ ਇੱਕ ਕਾਰਵਾਈ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ \'ਫਲੋ\',ਇੱਕ ਕ੍ਰਮਵਾਰ ਢੰਗ ਨਾਲ। \\n\\n ਤੁਹਾਡੇ ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਕੋਡ ਸਨਿੱਪਟ ਵਿੱਚ, \'flow.map\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਨੂੰ ਇੱਕ ਨਵੇਂ ਆਈਟਮ ਵਿੱਚ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।ਆਈਟਮ. ਨਤੀਜੇ ਵਜੋਂ ਪਰਿਵਰਤਿਤ ਆਈਟਮਾਂ ਨੂੰ ਫਿਰ \'onEach ()\' ਓਪਰੇਟਰ ਨੂੰ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. \\n\\n \'onEach ()\' ਓਪਰੇਟਰ ਇੱਕ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਇੱਕ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਲੈਂਦਾ ਹੈ,ਜਿਸ ਨੂੰ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਲਈ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਤੁਹਾਡੇ ਮਾਮਲੇ ਵਿੱਚ, ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਪ੍ਰਦਾਨ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ, ਇਸ ਲਈ \'onEach ()\' ਦੇ ਅੰਦਰ ਕੁਝ ਨਹੀਂ ਹੁੰਦਾ ਹੈ।\'onEach ()\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਇੱਕ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਪ੍ਰਦਾਨ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਜੋ ਹਰੇਕ ਆਈਟਮ ਉੱਤੇ ਕੁੱਝ ਕਾਰਵਾਈ ਕਰਦਾ ਹੈ।\'ਫਲੋ\'। ਉਦਾਹਰਨ ਲਈ, ਤੁਸੀਂ ਇਸ ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਵਸਤੂ ਨੂੰ ਸਾਈਡ-ਇਫੈਕਟ ਪ੍ਰਕਿਰਿਆ ਲਈ ਕਰ ਸਕਦੇ ਹੋ, ਜਾਂ ਮੂਲ ਦੇ ਪਰਿਵਰਤਨ ਦੇ ਅਧਾਰ ਉੱਤੇ ਇੱਕ ਨਵੀਂ ਵਸਤੂ ਨੂੰ ਛੱਡਣ ਲਈ ਕਰ ਸਕਦੇ ਹੋ।ਆਈਟਮ। \\n\\n ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਜੋ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੀ ਗਈ ਮੂਲ ਆਈਟਮ ਦੇ ਅਧਾਰ ਉੱਤੇ ਇੱਕ ਨਵੀਂ ਆਈਟਮ ਨੂੰ ਛੱਡਣ ਲਈ \'onEach ()\' ਦੀ ਵਰਤੋਂ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈਃ \\n \'\' scsss\\nvalਫਲੋ = ਫਲੋਓਫ (1,2,3) \\n\\nਫਲੋ\\n. ਮੈਪ {it * 2} \\n. onEach {ਮੁੱਲ-> \\n ਨਿਕਾਸ (ਮੁੱਲ)// ਪਰਿਵਰਤਿਤ ਮੁੱਲ ਨੂੰ ਨਿਕਾਸ ਕਰਦਾ ਹੈ \\n} \\n \'\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ,\'ਮੈਪ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਨੂੰ 2 ਨਾਲ ਗੁਣਾ ਕਰਕੇ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।\'onEach ()\' ਓਪਰੇਟਰ, ਜਿੱਥੇ ਇੱਕ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਹਰੇਕ ਪਰਿਵਰਤਿਤ ਆਈਟਮ ਨੂੰ ਬਾਹਰ ਕੱਢਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ \'onEach ()\' ਓਪਰੇਟਰ ਇਸ ਦੇ ਸਮਾਨ ਨਹੀਂ ਹੈ।\'ਮੈਪ ()\' ਓਪਰੇਟਰ, ਹਾਲਾਂਕਿ ਉਹ ਦੋਵੇਂ ਇੱਕ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਆਈਟਮਾਂ ਨੂੰ ਬਦਲਣ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ. \'ਮੈਪ ()\' ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਆਈਟਮ ਨੂੰ ਇੱਕ ਨਵੀਂ ਆਈਟਮ ਵਿੱਚ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ,ਜਦੋਂ ਕਿ \'onEach ()\' ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਆਈਟਮ ਉੱਤੇ ਇੱਕ ਸਾਈਡ-ਇਫੈਕਟ ਲਾਗੂ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਪਰ ਨਤੀਜੇ ਵਜੋਂ ਬਦਲੀਆਂ ਗਈਆਂ ਆਈਟਮਾਂ \'ਫਲੋ\' ਦੁਆਰਾ ਨਹੀਂ ਨਿਕਲਦੀਆਂ।\',\' ਕੋਟਲਿਨ ਵਿੱਚ, \'ਸਟੇਟਫਲੋ\' ਇੱਕ ਕਿਸਮ ਦਾ \'ਫਲੋ\' ਹੈ ਜੋ ਉਹਨਾਂ ਮੁੱਲਾਂ ਦੇ ਇੱਕ ਕ੍ਰਮ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ ਜੋ ਬਦਲ ਸਕਦੇ ਹਨਸਮੇਂ ਦੇ ਨਾਲ ਇਹ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਲਾਇਬ੍ਰੇਰੀ ਦਾ ਹਿੱਸਾ ਹੈ ਜਿਸ ਨੂੰ ਜੇਟਪੈਕ ਕੰਪੋਜ਼ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। \\n\\n \'ਸਟੇਟਫਲੋ\' ਇੱਕ ਠੰਡਾ ਪ੍ਰਵਾਹ ਹੈ, ਜਿਸਦਾ ਅਰਥ ਹੈ ਕਿ ਇਹ ਟਰਿੱਗਰ ਨਹੀਂ ਕਰਦਾ ਹੈ।ਅੱਪਡੇਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਇਸਦੇ ਗਾਹਕ ਉਹਨਾਂ ਨੂੰ ਬੇਨਤੀ ਨਹੀਂ ਕਰਦੇ. ਠੰਡੇ ਪ੍ਰਵਾਹ ਆਮ ਤੌਰ \'ਤੇ ਗਰਮ ਪ੍ਰਵਾਹਾਂ ਨਾਲੋਂ ਵਧੇਰੇ ਕੁਸ਼ਲ ਹੁੰਦੇ ਹਨ, ਕਿਉਂਕਿ ਉਹ ਬੇਲੋਡ਼ੇ ਤੌਰ\' ਤੇ ਦੁਬਾਰਾ ਕੰਪਿਊਟ ਨਹੀਂ ਕਰਦੇ ਜਾਂਮੁੱਲ ਛੱਡੋ। \\n\\n \'ਸਟੇਟਫਲੋ\' ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਇਸ ਨੂੰ ਜੈੱਟਪੈਕ ਕੰਪੋਜ਼ ਵਿੱਚ ਇੱਕ ਹਿੱਸੇ ਲਈ ਮੁੱਲ ਧਾਰਕ ਵਜੋਂ ਵਰਤਣ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਇਹ ਆਪਣੇ ਆਪਆਪਣੇ ਗਾਹਕਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦਾ ਹੈ। ਜਦੋਂ ਕੋਈ ਗਾਹਕ ਇੱਕ ਅੱਪਡੇਟ ਦੀ ਬੇਨਤੀ ਕਰਦਾ ਹੈ, ਤਾਂ \'ਸਟੇਟਫਲੋ\' ਨਵੀਨਤਮ ਮੁੱਲ ਦਾ ਨਿਕਾਸ ਕਰਦਾ ਹੈ, ਅਤੇ ਮੁੱਲ ਵਿੱਚ ਕੋਈ ਵੀ ਬਾਅਦ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਹਨਆਪਣੇ ਆਪ ਸਾਰੇ ਗਾਹਕਾਂ ਨੂੰ ਸੰਚਾਰਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \\n\\n \'ਇਹ ਜੇਟਪੈਕ ਵਿੱਚ\' ਸਟੇਟਫਲੋ \'ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n\' \'scsss\\ n@Composable \\nfunਮਾਈ ਕੰਪੋਨੈਂਟ (ਸਥਿਤੀਃ ਸਟੇਟਫਲੋ <ਇੰਟ>) {\\n ਵੈਲ ਸਟੇਟਵੈਲੂ ਬਾਈ state.collectAsState () \\n\\n ਟੈਕਸਟ (ਟੈਕਸਟ = "ਮੁੱਲ ${stateValue} ਹੈ") \\n} \\n "\'\\n ਇਸ ਵਿੱਚਉਦਾਹਰਨ ਲਈ, \'ਸਟੇਟਫਲੋ\' ਨੂੰ \'ਮਾਈ ਕੰਪੋਨੈਂਟ\' ਫੰਕਸ਼ਨ ਲਈ ਇੱਕ ਪੈਰਾਮੀਟਰ ਦੇ ਰੂਪ ਵਿੱਚ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਇਸ ਦੀ ਵਰਤੋਂ ਇੱਕ \'ਟੈਕਸਟ\' ਕੰਪੋਨੈਂਟ ਦੀ ਸਥਿਤੀ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।\'ਸੰਗ੍ਰਹਿ ਅਸਟੇਟ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ \'ਸਟੇਟ ਫਲੋ\' ਦੇ ਨਵੀਨਤਮ ਮੁੱਲ ਨੂੰ \'ਸਟੇਟ ਵੈਲਯੂ\' ਨਾਮਕ ਇੱਕ ਪਰਿਵਰਤਨਸ਼ੀਲ ਅਵਸਥਾ ਵੇਰੀਏਬਲ ਵਿੱਚ ਇਕੱਤਰ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜੋ ਕਿ ਹੋ ਸਕਦਾ ਹੈUI ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਜਦੋਂ UI ਪੇਸ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, \'ਸਟੇਟਫਲੋ\' ਉਦੋਂ ਤੱਕ ਅੱਪਡੇਟ ਨੂੰ ਟਰਿੱਗਰ ਨਹੀਂ ਕਰੇਗਾ ਜਦੋਂ ਤੱਕ \'ਟੈਕਸਟ\' ਕੰਪੋਨੈਂਟ ਇੱਕ ਅੱਪਡੇਟ ਦੀ ਬੇਨਤੀ ਨਹੀਂ ਕਰਦਾ। ਇਸਦਾ ਅਰਥ ਹੈਕਿ \'ਸਟੇਟਫਲੋ\' ਇੱਕ ਠੰਡਾ ਪ੍ਰਵਾਹ ਹੈ, ਅਤੇ ਇਹ ਬੇਲੋਡ਼ੀ ਤੌਰ \'ਤੇ ਮੁੱਲਾਂ ਦੀ ਮੁਡ਼ ਗਣਨਾ ਜਾਂ ਨਿਕਾਸ ਨਹੀਂ ਕਰੇਗਾ ਜਦੋਂ ਤੱਕ ਉਹਨਾਂ ਨੂੰ ਗਾਹਕਾਂ ਦੁਆਰਾ ਬੇਨਤੀ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ।ਕਿਸੇ ਹੋਰ ਪ੍ਰਵਾਹ ਤੋਂ ਇੱਕ ਪ੍ਰਵਾਹ ਬਣਾਓ? \',\' RxJava ਵਿੱਚ, ਤੁਸੀਂ \'ਮਰਜ ()\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਿਸੇ ਹੋਰ \'ਫਲੋ\' ਤੋਂ ਇੱਕ ਨਵਾਂ \'ਫਲੋ\' ਬਣਾ ਸਕਦੇ ਹੋ। \'ਮਰਜ ()\'ਓਪਰੇਟਰ ਦੋ \'ਫਲੋ\' ਨੂੰ ਇੱਕ ਸਿੰਗਲ \'ਫਲੋ\' ਵਿੱਚ ਜੋਡ਼ਦਾ ਹੈ, ਅਤੇ ਇਹ ਦੋਵਾਂ \'ਫਲੋ\' ਵਿੱਚੋਂ ਕਿਸੇ ਇੱਕ ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਦਾ ਹੈ। \\n\\nਇੱਥੇ ਇੱਕ ਬਣਾਉਣ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਦੋ ਹੋਰ \'ਫਲੋ\' ਤੋਂ ਨਵਾਂ \'ਫਲੋ\': \\n \'\' scsss\\nval ਫਲੋ 1 = ਫਲੋਓਫ (1,2,3) \\nval ਫਲੋ 2 = ਫਲੋਓਫ (4,5,6) \\n\\nval ਨਿਊਫਲੋ = flow1.merge (ਫਲੋ 2) \\n \'\' \\ninਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਦੋ \'ਫਲੋ\', \'ਫਲੋ 1\' ਅਤੇ \'ਫਲੋ 2\' ਬਣਾਏ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਨੂੰ \'ਮਰਜ ()\' ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ \'ਨਿਊ ਫਲੋ\' ਨਾਮਕ ਇੱਕ ਨਵੇਂ \'ਫਲੋ\' ਵਿੱਚ ਮਿਲਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।ਓਪਰੇਟਰ। \\n\\n ਨਤੀਜੇ ਵਜੋਂ \'ਨਵਾਂ ਫਲੋ\' ਜਾਂ ਤਾਂ \'ਫਲੋ 1\' ਜਾਂ \'ਫਲੋ 2\' ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢੇਗਾ, ਇਹ ਇਸ ਗੱਲ \'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹਡ਼ਾ\' ਫਲੋ \'ਪਹਿਲਾਂ ਆਈਟਮਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਦਾ ਹੈ।ਆਈਟਮਾਂ ਇੱਕੋ ਸਮੇਂ ਕੱਢੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ ਉਹ ਕੱਢੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਉਸ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਹੁੰਦੀ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ \'ਮਰਜ ()\' ਓਪਰੇਟਰ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਹੀਂ ਹੈ,ਜਿਸ ਦਾ ਅਰਥ ਹੈ ਕਿ ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ \'ਫਲੋ\' ਨੂੰ ਮਿਲਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਉਹ ਨਤੀਜੇ ਵਜੋਂ \'ਫਲੋ\' ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰ ਸਕਦਾ ਹੈ। ਨਾਲ ਹੀ, \'ਮਰਜ ()\' ਓਪਰੇਟਰ ਆਰਡਰ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਦਿੰਦਾ ਹੈ।ਜਿਸ ਵਿੱਚ ਆਈਟਮਾਂ ਦਾ ਨਿਕਾਸ ਹੁੰਦਾ ਹੈ, ਇਸ ਲਈ ਇਹ ਸਾਰੇ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਲਈ ਢੁਕਵਾਂ ਨਹੀਂ ਹੋ ਸਕਦਾ ਹੈ। ", \'ਐਂਡਰਾਇਡ ਕੋਟਲਿਨ ਵਿੱਚ ਇੱਕ ਪ੍ਰਵਾਹ ਕਿਵੇਂ ਬਣਾਇਆ ਜਾਵੇ ਜੋ ਕਿਸੇ ਹੋਰ ਪ੍ਰਵਾਹ ਉੱਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ।\',\' ਐਂਡਰਾਇਡ ਕੋਟਲਿਨ ਵਿੱਚ, ਤੁਸੀਂ ਇੱਕ ਨਵਾਂ \'ਫਲੋ\' ਬਣਾ ਸਕਦੇ ਹੋ ਜੋ \'ਮਰਜ\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਿਸੇ ਹੋਰ \'ਫਲੋ\' ਉੱਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। \'ਮਰਜ\' ਓਪਰੇਟਰ ਦੋ ਨੂੰ ਜੋਡ਼ਦਾ ਹੈਇੱਕ ਸਿੰਗਲ ਪ੍ਰਵਾਹ ਵਿੱਚ ਵਹਿੰਦਾ ਹੈ, ਅਤੇ ਇਹ ਦੋਵਾਂ ਪ੍ਰਵਾਹਾਂ ਵਿੱਚੋਂ ਕਿਸੇ ਇੱਕ ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਦਾ ਹੈ। \\n\\nਇੱਥੇ ਇੱਕ ਨਵਾਂ \'ਪ੍ਰਵਾਹ\' ਬਣਾਉਣ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਜੋ ਇਸ ਉੱਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈਇੱਕ ਹੋਰ ਪ੍ਰਵਾਹਃ \\n "\'scsss\\nval ਫਲੋ 1 = ਫਲੋਓਫ (1,2,3) \\nval ਫਲੋ 2 = ਫਲੋਓਫ (4,5,6) \\n\\nval ਕੰਬਾਈਨਡਫਲੋ = flow1.merge (ਫਲੋ 2) \\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਦੋਪ੍ਰਵਾਹ \'ਫਲੋ 1\' ਅਤੇ \'ਫਲੋ 2\' ਬਣਾਏ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਨੂੰ \'ਮਰਜ\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ \'ਕੰਬਾਈਨਡ ਫਲੋ\' ਨਾਮਕ ਇੱਕ ਨਵੇਂ ਪ੍ਰਵਾਹ ਵਿੱਚ ਮਿਲਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।\'ਕੰਬਾਈਨਡ ਫਲੋ\' \'ਫਲੋ 1\' ਜਾਂ \'ਫਲੋ 2\' ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢੇਗਾ, ਇਹ ਇਸ ਗੱਲ \'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹਡ਼ਾ ਪ੍ਰਵਾਹ ਪਹਿਲਾਂ ਆਈਟਮਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਦਾ ਹੈ।ਉਸੇ ਸਮੇਂ, ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ ਉਹ ਕੱਢੇ ਜਾਂਦੇ ਹਨ, ਉਸ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਹੁੰਦੀ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ \'ਮਰਜ\' ਓਪਰੇਟਰ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਹੀਂ ਹੈ, ਜਿਸਦਾ ਅਰਥ ਹੈ ਕਿ ਕ੍ਰਮਜਿਸ ਵਿੱਚ ਪ੍ਰਵਾਹਾਂ ਨੂੰ ਮਿਲਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਨਤੀਜੇ ਵਜੋਂ ਪ੍ਰਵਾਹ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰ ਸਕਦਾ ਹੈ। ਨਾਲ ਹੀ, \'ਮਰਜ\' ਓਪਰੇਟਰ ਉਸ ਕ੍ਰਮ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਦਿੰਦਾ ਜਿਸ ਵਿੱਚ ਆਈਟਮਾਂ ਕੱਢੀਆਂ ਜਾਂਦੀਆਂ ਹਨ,ਇਸ ਲਈ ਇਹ ਸਾਰੇ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਲਈ ਢੁਕਵਾਂ ਨਹੀਂ ਹੋ ਸਕਦਾ. \',\' ਨਹੀਂ, ਇੱਥੇ ਸਿਰਫ ਇੱਕ ਪ੍ਰਵਾਹ ਹੈ ਅਤੇ ਮੈਂ ਪਹਿਲੇ ਤੋਂ ਆਪਣਾ ਦੂਜਾ ਪ੍ਰਵਾਹ ਬਣਾਉਣਾ ਚਾਹੁੰਦਾ ਹਾਂ? \' ', 'ਮੇਰੇ ਕੋਲ flow.map {ਮੁੱਲ-> ਪਰਿਵਰਤਨ ()}. onEach {} ਹੈ। onEach ਕੀ ਕਰਦਾ ਹੈ?', ' [\'ਮੇਰੇ ਕੋਲ flow.map {ਮੁੱਲ-> \\n ਪਰਿਵਰਤਨ () \\n}. onEach {\\n\\n} ਹੈ।\', ਪ੍ਰਤੀਕ੍ਰਿਆਸ਼ੀਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਢਾਂਚੇ ਵਿੱਚ, \'onEach ()\' ਕੀ ਕਰਦਾ ਹੈ?ਸੰਚਾਲਕ ਆਰਐਕਸਜੇਵਾ ਵਿੱਚ \'ਪ੍ਰਕਾਸ਼ਕ\' ਇੰਟਰਫੇਸ ਦਾ ਇੱਕ ਹਿੱਸਾ ਹੈ। ਇਸ ਦੀ ਵਰਤੋਂ ਇੱਕ ਪ੍ਰਕਾਸ਼ਕ ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਉੱਤੇ ਇੱਕ ਕਾਰਵਾਈ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ \'ਫਲੋ\',ਇੱਕ ਕ੍ਰਮਵਾਰ ਢੰਗ ਨਾਲ। \\n\\n ਤੁਹਾਡੇ ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਕੋਡ ਸਨਿੱਪਟ ਵਿੱਚ, \'flow.map\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਨੂੰ ਇੱਕ ਨਵੇਂ ਆਈਟਮ ਵਿੱਚ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।ਆਈਟਮ. ਨਤੀਜੇ ਵਜੋਂ ਪਰਿਵਰਤਿਤ ਆਈਟਮਾਂ ਨੂੰ ਫਿਰ \'onEach ()\' ਓਪਰੇਟਰ ਨੂੰ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. \\n\\n \'onEach ()\' ਓਪਰੇਟਰ ਇੱਕ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਇੱਕ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਲੈਂਦਾ ਹੈ,ਜਿਸ ਨੂੰ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਲਈ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਤੁਹਾਡੇ ਮਾਮਲੇ ਵਿੱਚ, ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਪ੍ਰਦਾਨ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ, ਇਸ ਲਈ \'onEach ()\' ਦੇ ਅੰਦਰ ਕੁਝ ਨਹੀਂ ਹੁੰਦਾ ਹੈ।\'onEach ()\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਇੱਕ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਪ੍ਰਦਾਨ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਜੋ ਹਰੇਕ ਆਈਟਮ ਉੱਤੇ ਕੁੱਝ ਕਾਰਵਾਈ ਕਰਦਾ ਹੈ।\'ਫਲੋ\'। ਉਦਾਹਰਨ ਲਈ, ਤੁਸੀਂ ਇਸ ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਵਸਤੂ ਨੂੰ ਸਾਈਡ-ਇਫੈਕਟ ਪ੍ਰਕਿਰਿਆ ਲਈ ਕਰ ਸਕਦੇ ਹੋ, ਜਾਂ ਮੂਲ ਦੇ ਪਰਿਵਰਤਨ ਦੇ ਅਧਾਰ ਉੱਤੇ ਇੱਕ ਨਵੀਂ ਵਸਤੂ ਨੂੰ ਛੱਡਣ ਲਈ ਕਰ ਸਕਦੇ ਹੋ।ਆਈਟਮ। \\n\\n ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਜੋ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੀ ਗਈ ਮੂਲ ਆਈਟਮ ਦੇ ਅਧਾਰ ਉੱਤੇ ਇੱਕ ਨਵੀਂ ਆਈਟਮ ਨੂੰ ਛੱਡਣ ਲਈ \'onEach ()\' ਦੀ ਵਰਤੋਂ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈਃ \\n \'\' scsss\\nvalਫਲੋ = ਫਲੋਓਫ (1,2,3) \\n\\nਫਲੋ\\n. ਮੈਪ {it * 2} \\n. onEach {ਮੁੱਲ-> \\n ਨਿਕਾਸ (ਮੁੱਲ)// ਪਰਿਵਰਤਿਤ ਮੁੱਲ ਨੂੰ ਨਿਕਾਸ ਕਰਦਾ ਹੈ \\n} \\n \'\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ,\'ਮੈਪ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਨੂੰ 2 ਨਾਲ ਗੁਣਾ ਕਰਕੇ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।\'onEach ()\' ਓਪਰੇਟਰ, ਜਿੱਥੇ ਇੱਕ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਹਰੇਕ ਪਰਿਵਰਤਿਤ ਆਈਟਮ ਨੂੰ ਬਾਹਰ ਕੱਢਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ \'onEach ()\' ਓਪਰੇਟਰ ਇਸ ਦੇ ਸਮਾਨ ਨਹੀਂ ਹੈ।\'ਮੈਪ ()\' ਓਪਰੇਟਰ, ਹਾਲਾਂਕਿ ਉਹ ਦੋਵੇਂ ਇੱਕ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਆਈਟਮਾਂ ਨੂੰ ਬਦਲਣ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ. \'ਮੈਪ ()\' ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਆਈਟਮ ਨੂੰ ਇੱਕ ਨਵੀਂ ਆਈਟਮ ਵਿੱਚ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ,ਜਦੋਂ ਕਿ \'onEach ()\' ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਆਈਟਮ ਉੱਤੇ ਇੱਕ ਸਾਈਡ-ਇਫੈਕਟ ਲਾਗੂ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਪਰ ਨਤੀਜੇ ਵਜੋਂ ਬਦਲੀਆਂ ਗਈਆਂ ਆਈਟਮਾਂ \'ਫਲੋ\' ਦੁਆਰਾ ਨਹੀਂ ਨਿਕਲਦੀਆਂ।\',\' ਕੋਟਲਿਨ ਵਿੱਚ, \'ਸਟੇਟਫਲੋ\' ਇੱਕ ਕਿਸਮ ਦਾ \'ਫਲੋ\' ਹੈ ਜੋ ਉਹਨਾਂ ਮੁੱਲਾਂ ਦੇ ਇੱਕ ਕ੍ਰਮ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ ਜੋ ਬਦਲ ਸਕਦੇ ਹਨਸਮੇਂ ਦੇ ਨਾਲ ਇਹ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਲਾਇਬ੍ਰੇਰੀ ਦਾ ਹਿੱਸਾ ਹੈ ਜਿਸ ਨੂੰ ਜੇਟਪੈਕ ਕੰਪੋਜ਼ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। \\n\\n \'ਸਟੇਟਫਲੋ\' ਇੱਕ ਠੰਡਾ ਪ੍ਰਵਾਹ ਹੈ, ਜਿਸਦਾ ਅਰਥ ਹੈ ਕਿ ਇਹ ਟਰਿੱਗਰ ਨਹੀਂ ਕਰਦਾ ਹੈ।ਅੱਪਡੇਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਇਸਦੇ ਗਾਹਕ ਉਹਨਾਂ ਨੂੰ ਬੇਨਤੀ ਨਹੀਂ ਕਰਦੇ. ਠੰਡੇ ਪ੍ਰਵਾਹ ਆਮ ਤੌਰ \'ਤੇ ਗਰਮ ਪ੍ਰਵਾਹਾਂ ਨਾਲੋਂ ਵਧੇਰੇ ਕੁਸ਼ਲ ਹੁੰਦੇ ਹਨ, ਕਿਉਂਕਿ ਉਹ ਬੇਲੋਡ਼ੇ ਤੌਰ\' ਤੇ ਦੁਬਾਰਾ ਕੰਪਿਊਟ ਨਹੀਂ ਕਰਦੇ ਜਾਂਮੁੱਲ ਛੱਡੋ। \\n\\n \'ਸਟੇਟਫਲੋ\' ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਇਸ ਨੂੰ ਜੈੱਟਪੈਕ ਕੰਪੋਜ਼ ਵਿੱਚ ਇੱਕ ਹਿੱਸੇ ਲਈ ਮੁੱਲ ਧਾਰਕ ਵਜੋਂ ਵਰਤਣ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਇਹ ਆਪਣੇ ਆਪਆਪਣੇ ਗਾਹਕਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦਾ ਹੈ। ਜਦੋਂ ਕੋਈ ਗਾਹਕ ਇੱਕ ਅੱਪਡੇਟ ਦੀ ਬੇਨਤੀ ਕਰਦਾ ਹੈ, ਤਾਂ \'ਸਟੇਟਫਲੋ\' ਨਵੀਨਤਮ ਮੁੱਲ ਦਾ ਨਿਕਾਸ ਕਰਦਾ ਹੈ, ਅਤੇ ਮੁੱਲ ਵਿੱਚ ਕੋਈ ਵੀ ਬਾਅਦ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਹਨਆਪਣੇ ਆਪ ਸਾਰੇ ਗਾਹਕਾਂ ਨੂੰ ਸੰਚਾਰਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \\n\\n \'ਇਹ ਜੇਟਪੈਕ ਵਿੱਚ\' ਸਟੇਟਫਲੋ \'ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n\' \'scsss\\ n@Composable \\nfunਮਾਈ ਕੰਪੋਨੈਂਟ (ਸਥਿਤੀਃ ਸਟੇਟਫਲੋ <ਇੰਟ>) {\\n ਵੈਲ ਸਟੇਟਵੈਲੂ ਬਾਈ state.collectAsState () \\n\\n ਟੈਕਸਟ (ਟੈਕਸਟ = "ਮੁੱਲ ${stateValue} ਹੈ") \\n} \\n "\'\\n ਇਸ ਵਿੱਚਉਦਾਹਰਨ ਲਈ, \'ਸਟੇਟਫਲੋ\' ਨੂੰ \'ਮਾਈ ਕੰਪੋਨੈਂਟ\' ਫੰਕਸ਼ਨ ਲਈ ਇੱਕ ਪੈਰਾਮੀਟਰ ਦੇ ਰੂਪ ਵਿੱਚ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਇਸ ਦੀ ਵਰਤੋਂ ਇੱਕ \'ਟੈਕਸਟ\' ਕੰਪੋਨੈਂਟ ਦੀ ਸਥਿਤੀ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।\'ਸੰਗ੍ਰਹਿ ਅਸਟੇਟ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ \'ਸਟੇਟ ਫਲੋ\' ਦੇ ਨਵੀਨਤਮ ਮੁੱਲ ਨੂੰ \'ਸਟੇਟ ਵੈਲਯੂ\' ਨਾਮਕ ਇੱਕ ਪਰਿਵਰਤਨਸ਼ੀਲ ਅਵਸਥਾ ਵੇਰੀਏਬਲ ਵਿੱਚ ਇਕੱਤਰ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜੋ ਕਿ ਹੋ ਸਕਦਾ ਹੈUI ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਜਦੋਂ UI ਪੇਸ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, \'ਸਟੇਟਫਲੋ\' ਉਦੋਂ ਤੱਕ ਅੱਪਡੇਟ ਨੂੰ ਟਰਿੱਗਰ ਨਹੀਂ ਕਰੇਗਾ ਜਦੋਂ ਤੱਕ \'ਟੈਕਸਟ\' ਕੰਪੋਨੈਂਟ ਇੱਕ ਅੱਪਡੇਟ ਦੀ ਬੇਨਤੀ ਨਹੀਂ ਕਰਦਾ। ਇਸਦਾ ਅਰਥ ਹੈਕਿ \'ਸਟੇਟਫਲੋ\' ਇੱਕ ਠੰਡਾ ਪ੍ਰਵਾਹ ਹੈ, ਅਤੇ ਇਹ ਬੇਲੋਡ਼ੀ ਤੌਰ \'ਤੇ ਮੁੱਲਾਂ ਦੀ ਮੁਡ਼ ਗਣਨਾ ਜਾਂ ਨਿਕਾਸ ਨਹੀਂ ਕਰੇਗਾ ਜਦੋਂ ਤੱਕ ਉਹਨਾਂ ਨੂੰ ਗਾਹਕਾਂ ਦੁਆਰਾ ਬੇਨਤੀ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ।ਕਿਸੇ ਹੋਰ ਪ੍ਰਵਾਹ ਤੋਂ ਇੱਕ ਪ੍ਰਵਾਹ ਬਣਾਓ? \',\' RxJava ਵਿੱਚ, ਤੁਸੀਂ \'ਮਰਜ ()\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਿਸੇ ਹੋਰ \'ਫਲੋ\' ਤੋਂ ਇੱਕ ਨਵਾਂ \'ਫਲੋ\' ਬਣਾ ਸਕਦੇ ਹੋ। \'ਮਰਜ ()\'ਓਪਰੇਟਰ ਦੋ \'ਫਲੋ\' ਨੂੰ ਇੱਕ ਸਿੰਗਲ \'ਫਲੋ\' ਵਿੱਚ ਜੋਡ਼ਦਾ ਹੈ, ਅਤੇ ਇਹ ਦੋਵਾਂ \'ਫਲੋ\' ਵਿੱਚੋਂ ਕਿਸੇ ਇੱਕ ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਦਾ ਹੈ। \\n\\nਇੱਥੇ ਇੱਕ ਬਣਾਉਣ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਦੋ ਹੋਰ \'ਫਲੋ\' ਤੋਂ ਨਵਾਂ \'ਫਲੋ\': \\n \'\' scsss\\nval ਫਲੋ 1 = ਫਲੋਓਫ (1,2,3) \\nval ਫਲੋ 2 = ਫਲੋਓਫ (4,5,6) \\n\\nval ਨਿਊਫਲੋ = flow1.merge (ਫਲੋ 2) \\n \'\' \\ninਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਦੋ \'ਫਲੋ\', \'ਫਲੋ 1\' ਅਤੇ \'ਫਲੋ 2\' ਬਣਾਏ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਨੂੰ \'ਮਰਜ ()\' ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ \'ਨਿਊ ਫਲੋ\' ਨਾਮਕ ਇੱਕ ਨਵੇਂ \'ਫਲੋ\' ਵਿੱਚ ਮਿਲਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।ਓਪਰੇਟਰ। \\n\\n ਨਤੀਜੇ ਵਜੋਂ \'ਨਵਾਂ ਫਲੋ\' ਜਾਂ ਤਾਂ \'ਫਲੋ 1\' ਜਾਂ \'ਫਲੋ 2\' ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢੇਗਾ, ਇਹ ਇਸ ਗੱਲ \'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹਡ਼ਾ\' ਫਲੋ \'ਪਹਿਲਾਂ ਆਈਟਮਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਦਾ ਹੈ।ਆਈਟਮਾਂ ਇੱਕੋ ਸਮੇਂ ਕੱਢੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ ਉਹ ਕੱਢੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਉਸ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਹੁੰਦੀ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ \'ਮਰਜ ()\' ਓਪਰੇਟਰ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਹੀਂ ਹੈ,ਜਿਸ ਦਾ ਅਰਥ ਹੈ ਕਿ ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ \'ਫਲੋ\' ਨੂੰ ਮਿਲਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਉਹ ਨਤੀਜੇ ਵਜੋਂ \'ਫਲੋ\' ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰ ਸਕਦਾ ਹੈ। ਨਾਲ ਹੀ, \'ਮਰਜ ()\' ਓਪਰੇਟਰ ਆਰਡਰ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਦਿੰਦਾ ਹੈ।ਜਿਸ ਵਿੱਚ ਆਈਟਮਾਂ ਦਾ ਨਿਕਾਸ ਹੁੰਦਾ ਹੈ, ਇਸ ਲਈ ਇਹ ਸਾਰੇ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਲਈ ਢੁਕਵਾਂ ਨਹੀਂ ਹੋ ਸਕਦਾ ਹੈ। ", \'ਐਂਡਰਾਇਡ ਕੋਟਲਿਨ ਵਿੱਚ ਇੱਕ ਪ੍ਰਵਾਹ ਕਿਵੇਂ ਬਣਾਇਆ ਜਾਵੇ ਜੋ ਕਿਸੇ ਹੋਰ ਪ੍ਰਵਾਹ ਉੱਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ।\',\' ਐਂਡਰਾਇਡ ਕੋਟਲਿਨ ਵਿੱਚ, ਤੁਸੀਂ ਇੱਕ ਨਵਾਂ \'ਫਲੋ\' ਬਣਾ ਸਕਦੇ ਹੋ ਜੋ \'ਮਰਜ\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਿਸੇ ਹੋਰ \'ਫਲੋ\' ਉੱਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। \'ਮਰਜ\' ਓਪਰੇਟਰ ਦੋ ਨੂੰ ਜੋਡ਼ਦਾ ਹੈਇੱਕ ਸਿੰਗਲ ਪ੍ਰਵਾਹ ਵਿੱਚ ਵਹਿੰਦਾ ਹੈ, ਅਤੇ ਇਹ ਦੋਵਾਂ ਪ੍ਰਵਾਹਾਂ ਵਿੱਚੋਂ ਕਿਸੇ ਇੱਕ ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਦਾ ਹੈ। \\n\\nਇੱਥੇ ਇੱਕ ਨਵਾਂ \'ਪ੍ਰਵਾਹ\' ਬਣਾਉਣ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਜੋ ਇਸ ਉੱਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈਇੱਕ ਹੋਰ ਪ੍ਰਵਾਹਃ \\n "\'scsss\\nval ਫਲੋ 1 = ਫਲੋਓਫ (1,2,3) \\nval ਫਲੋ 2 = ਫਲੋਓਫ (4,5,6) \\n\\nval ਕੰਬਾਈਨਡਫਲੋ = flow1.merge (ਫਲੋ 2) \\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਦੋਪ੍ਰਵਾਹ \'ਫਲੋ 1\' ਅਤੇ \'ਫਲੋ 2\' ਬਣਾਏ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਨੂੰ \'ਮਰਜ\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ \'ਕੰਬਾਈਨਡ ਫਲੋ\' ਨਾਮਕ ਇੱਕ ਨਵੇਂ ਪ੍ਰਵਾਹ ਵਿੱਚ ਮਿਲਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।\'ਕੰਬਾਈਨਡ ਫਲੋ\' ਜਾਂ ਤਾਂ \'ਫਲੋ 1\' ਜਾਂ \'ਫਲੋ 2\' ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢੇਗਾ, ਇਹ ਇਸ ਗੱਲ \'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹਡ਼ਾ ਪ੍ਰਵਾਹ ਪਹਿਲਾਂ ਆਈਟਮਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਦਾ ਹੈ।ਉਸੇ ਸਮੇਂ, ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ ਉਹ ਕੱਢੇ ਜਾਂਦੇ ਹਨ, ਉਸ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਹੁੰਦੀ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ \'ਮਰਜ\' ਓਪਰੇਟਰ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਹੀਂ ਹੈ, ਜਿਸਦਾ ਅਰਥ ਹੈ ਕਿ ਕ੍ਰਮਜਿਸ ਵਿੱਚ ਪ੍ਰਵਾਹਾਂ ਨੂੰ ਮਿਲਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਨਤੀਜੇ ਵਜੋਂ ਪ੍ਰਵਾਹ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰ ਸਕਦਾ ਹੈ। ਨਾਲ ਹੀ, \'ਮਰਜ\' ਓਪਰੇਟਰ ਉਸ ਕ੍ਰਮ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਦਿੰਦਾ ਜਿਸ ਵਿੱਚ ਆਈਟਮਾਂ ਕੱਢੀਆਂ ਜਾਂਦੀਆਂ ਹਨ,ਇਸ ਲਈ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਇਹ ਸਾਰੇ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਲਈ ਢੁਕਵਾਂ ਨਾ ਹੋਵੇ। ", \'ਨਹੀਂ, ਇੱਥੇ ਸਿਰਫ ਇੱਕ ਪ੍ਰਵਾਹ ਹੈ ਅਤੇ ਮੈਂ ਪਹਿਲੇ ਤੋਂ ਆਪਣਾ ਦੂਜਾ ਪ੍ਰਵਾਹ ਬਣਾਉਣਾ ਚਾਹੁੰਦਾ ਹਾਂ?\'", ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਹੈਸਿੰਗਲ \'ਫਲੋ\' ਅਤੇ ਤੁਸੀਂ ਇਸ ਤੋਂ ਇੱਕ ਨਵਾਂ \'ਫਲੋ\' ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤੁਸੀਂ ਆਰਐਕਸਜੇਵਾ ਵਿੱਚ \'ਫਲੈਟਮੈਪ\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਤਾਂ ਜੋ ਮੂਲ ਦੁਆਰਾ ਕੱਢੀ ਗਈ ਹਰੇਕ ਚੀਜ਼ ਨੂੰ ਬਦਲਿਆ ਜਾ ਸਕੇ।ਇੱਕ ਮੌਜੂਦਾ \'ਫਲੋ\' ਤੋਂ ਇੱਕ ਨਵਾਂ \'ਫਲੋ\' ਬਣਾਉਣ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n \'\' scsss\\nval ਫਲੋ1 = ਫਲੋਓਫ (1,2,3) \\n\\nval ਫਲੋ2 =flow1.flatMap {ਮੁੱਲ-> \\n ਫਲੋਓਫ (ਮੁੱਲ * 2, ਮੁੱਲ * 3, ਮੁੱਲ * 4) \\n} \\n \'\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ,\' ਫਲੈਟਮੈਪ \'ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਆਈਟਮ ਨੂੰ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।\'ਫਲੋ 1\' ਦੁਆਰਾ \'ਫਲੋ 2\' ਨਾਮਕ ਇੱਕ ਨਵੇਂ \'ਫਲੋ\' ਵਿੱਚ ਛੱਡਿਆ ਜਾਂਦਾ ਹੈ। \'ਫਲੈਟ ਮੈਪ\' ਨੂੰ ਪਾਸ ਕੀਤਾ ਗਿਆ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ \'ਫਲੋ 1\' ਦੁਆਰਾ ਛੱਡੀ ਗਈ ਹਰੇਕ ਚੀਜ਼ ਨੂੰ ਲੈਂਦਾ ਹੈ ਅਤੇ ਇੱਕ ਨਵਾਂ ਨਿਕਾਸ ਕਰਦਾ ਹੈ।\'ਫਲੋਓਫ\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਆਈਟਮਾਂ ਦਾ ਸੈੱਟ। \\n\\n ਨਤੀਜੇ ਵਜੋਂ \'ਫਲੋ2\' \'ਫਲੋ1\' ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਆਈਟਮਾਂ ਨੂੰ 2,3 ਅਤੇ 4 ਨਾਲ ਗੁਣਾ ਕਰਕੇ ਬਾਹਰ ਕੱਢੇਗਾ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ\'ਫਲੈਟਮੈਪ\' ਓਪਰੇਟਰ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਹੀਂ ਹੈ, ਜਿਸਦਾ ਅਰਥ ਹੈ ਕਿ ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ ਪ੍ਰਵਾਹਾਂ ਨੂੰ ਚਪਟਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਉਹ ਨਤੀਜੇ ਵਜੋਂ ਪ੍ਰਵਾਹ ਨੂੰ ਪ੍ਰਭਾਵਤ ਕਰ ਸਕਦਾ ਹੈ।\'ਫਲੈਟਮੈਪ\' ਓਪਰੇਟਰ ਉਸ ਕ੍ਰਮ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਦਿੰਦਾ ਜਿਸ ਵਿੱਚ ਆਈਟਮਾਂ ਕੱਢੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਇਸ ਲਈ ਇਹ ਸਾਰੇ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਲਈ ਢੁਕਵਾਂ ਨਹੀਂ ਹੋ ਸਕਦਾ।? \') ', 'ਮੇਰੇ ਕੋਲ flow.map {ਮੁੱਲ-> ਪਰਿਵਰਤਨ ()}. onEach {} ਹੈ। onEach ਕੀ ਕਰਦਾ ਹੈ?', ' [\'ਮੇਰੇ ਕੋਲ flow.map {ਮੁੱਲ-> \\n ਪਰਿਵਰਤਨ () \\n}. onEach {\\n\\n} ਹੈ।\', ਪ੍ਰਤੀਕ੍ਰਿਆਸ਼ੀਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਢਾਂਚੇ ਵਿੱਚ, \'onEach ()\' ਕੀ ਕਰਦਾ ਹੈ?ਸੰਚਾਲਕ ਆਰਐਕਸਜੇਵਾ ਵਿੱਚ \'ਪ੍ਰਕਾਸ਼ਕ\' ਇੰਟਰਫੇਸ ਦਾ ਇੱਕ ਹਿੱਸਾ ਹੈ। ਇਸ ਦੀ ਵਰਤੋਂ ਇੱਕ ਪ੍ਰਕਾਸ਼ਕ ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਉੱਤੇ ਇੱਕ ਕਾਰਵਾਈ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ \'ਫਲੋ\',ਇੱਕ ਕ੍ਰਮਵਾਰ ਢੰਗ ਨਾਲ। \\n\\n ਤੁਹਾਡੇ ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਕੋਡ ਸਨਿੱਪਟ ਵਿੱਚ, \'flow.map\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਨੂੰ ਇੱਕ ਨਵੇਂ ਆਈਟਮ ਵਿੱਚ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।ਆਈਟਮ. ਨਤੀਜੇ ਵਜੋਂ ਪਰਿਵਰਤਿਤ ਆਈਟਮਾਂ ਨੂੰ ਫਿਰ \'onEach ()\' ਓਪਰੇਟਰ ਨੂੰ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. \\n\\n \'onEach ()\' ਓਪਰੇਟਰ ਇੱਕ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਇੱਕ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਲੈਂਦਾ ਹੈ,ਜਿਸ ਨੂੰ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਲਈ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਤੁਹਾਡੇ ਮਾਮਲੇ ਵਿੱਚ, ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਪ੍ਰਦਾਨ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ, ਇਸ ਲਈ \'onEach ()\' ਦੇ ਅੰਦਰ ਕੁਝ ਨਹੀਂ ਹੁੰਦਾ ਹੈ।\'onEach ()\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਇੱਕ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਪ੍ਰਦਾਨ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਜੋ ਹਰੇਕ ਆਈਟਮ ਉੱਤੇ ਕੁੱਝ ਕਾਰਵਾਈ ਕਰਦਾ ਹੈ।\'ਫਲੋ\'। ਉਦਾਹਰਨ ਲਈ, ਤੁਸੀਂ ਇਸ ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਵਸਤੂ ਨੂੰ ਸਾਈਡ-ਇਫੈਕਟ ਪ੍ਰਕਿਰਿਆ ਲਈ ਕਰ ਸਕਦੇ ਹੋ, ਜਾਂ ਮੂਲ ਦੇ ਪਰਿਵਰਤਨ ਦੇ ਅਧਾਰ ਉੱਤੇ ਇੱਕ ਨਵੀਂ ਵਸਤੂ ਨੂੰ ਛੱਡਣ ਲਈ ਕਰ ਸਕਦੇ ਹੋ।ਆਈਟਮ। \\n\\n ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਜੋ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੀ ਗਈ ਮੂਲ ਆਈਟਮ ਦੇ ਅਧਾਰ ਉੱਤੇ ਇੱਕ ਨਵੀਂ ਆਈਟਮ ਨੂੰ ਛੱਡਣ ਲਈ \'onEach ()\' ਦੀ ਵਰਤੋਂ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈਃ \\n \'\' scsss\\nvalਫਲੋ = ਫਲੋਓਫ (1,2,3) \\n\\nਫਲੋ\\n. ਮੈਪ {it * 2} \\n. onEach {ਮੁੱਲ-> \\n ਨਿਕਾਸ (ਮੁੱਲ)// ਪਰਿਵਰਤਿਤ ਮੁੱਲ ਨੂੰ ਨਿਕਾਸ ਕਰਦਾ ਹੈ \\n} \\n \'\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ,\'ਮੈਪ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਨੂੰ 2 ਨਾਲ ਗੁਣਾ ਕਰਕੇ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।\'onEach ()\' ਓਪਰੇਟਰ, ਜਿੱਥੇ ਇੱਕ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਹਰੇਕ ਪਰਿਵਰਤਿਤ ਆਈਟਮ ਨੂੰ ਬਾਹਰ ਕੱਢਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ \'onEach ()\' ਓਪਰੇਟਰ ਇਸ ਦੇ ਸਮਾਨ ਨਹੀਂ ਹੈ।\'ਮੈਪ ()\' ਓਪਰੇਟਰ, ਹਾਲਾਂਕਿ ਉਹ ਦੋਵੇਂ ਇੱਕ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਆਈਟਮਾਂ ਨੂੰ ਬਦਲਣ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ. \'ਮੈਪ ()\' ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਆਈਟਮ ਨੂੰ ਇੱਕ ਨਵੀਂ ਆਈਟਮ ਵਿੱਚ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ,ਜਦੋਂ ਕਿ \'onEach ()\' ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਆਈਟਮ ਉੱਤੇ ਇੱਕ ਸਾਈਡ-ਇਫੈਕਟ ਲਾਗੂ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਪਰ ਨਤੀਜੇ ਵਜੋਂ ਬਦਲੀਆਂ ਗਈਆਂ ਆਈਟਮਾਂ \'ਫਲੋ\' ਦੁਆਰਾ ਨਹੀਂ ਨਿਕਲਦੀਆਂ।\',\' ਕੋਟਲਿਨ ਵਿੱਚ, \'ਸਟੇਟਫਲੋ\' ਇੱਕ ਕਿਸਮ ਦਾ \'ਫਲੋ\' ਹੈ ਜੋ ਉਹਨਾਂ ਮੁੱਲਾਂ ਦੇ ਇੱਕ ਕ੍ਰਮ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ ਜੋ ਬਦਲ ਸਕਦੇ ਹਨਸਮੇਂ ਦੇ ਨਾਲ ਇਹ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਲਾਇਬ੍ਰੇਰੀ ਦਾ ਹਿੱਸਾ ਹੈ ਜਿਸ ਨੂੰ ਜੇਟਪੈਕ ਕੰਪੋਜ਼ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। \\n\\n \'ਸਟੇਟਫਲੋ\' ਇੱਕ ਠੰਡਾ ਪ੍ਰਵਾਹ ਹੈ, ਜਿਸਦਾ ਅਰਥ ਹੈ ਕਿ ਇਹ ਟਰਿੱਗਰ ਨਹੀਂ ਕਰਦਾ ਹੈ।ਅੱਪਡੇਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਇਸਦੇ ਗਾਹਕ ਉਹਨਾਂ ਨੂੰ ਬੇਨਤੀ ਨਹੀਂ ਕਰਦੇ. ਠੰਡੇ ਪ੍ਰਵਾਹ ਆਮ ਤੌਰ \'ਤੇ ਗਰਮ ਪ੍ਰਵਾਹਾਂ ਨਾਲੋਂ ਵਧੇਰੇ ਕੁਸ਼ਲ ਹੁੰਦੇ ਹਨ, ਕਿਉਂਕਿ ਉਹ ਬੇਲੋਡ਼ੇ ਤੌਰ\' ਤੇ ਦੁਬਾਰਾ ਕੰਪਿਊਟ ਨਹੀਂ ਕਰਦੇ ਜਾਂਮੁੱਲ ਛੱਡੋ। \\n\\n \'ਸਟੇਟਫਲੋ\' ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਇਸ ਨੂੰ ਜੈੱਟਪੈਕ ਕੰਪੋਜ਼ ਵਿੱਚ ਇੱਕ ਹਿੱਸੇ ਲਈ ਮੁੱਲ ਧਾਰਕ ਵਜੋਂ ਵਰਤਣ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਇਹ ਆਪਣੇ ਆਪਆਪਣੇ ਗਾਹਕਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦਾ ਹੈ। ਜਦੋਂ ਕੋਈ ਗਾਹਕ ਇੱਕ ਅੱਪਡੇਟ ਦੀ ਬੇਨਤੀ ਕਰਦਾ ਹੈ, ਤਾਂ \'ਸਟੇਟਫਲੋ\' ਨਵੀਨਤਮ ਮੁੱਲ ਦਾ ਨਿਕਾਸ ਕਰਦਾ ਹੈ, ਅਤੇ ਮੁੱਲ ਵਿੱਚ ਕੋਈ ਵੀ ਬਾਅਦ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਹਨਆਪਣੇ ਆਪ ਸਾਰੇ ਗਾਹਕਾਂ ਨੂੰ ਸੰਚਾਰਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \\n\\n \'ਇਹ ਜੇਟਪੈਕ ਵਿੱਚ\' ਸਟੇਟਫਲੋ \'ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n\' \'scsss\\ n@Composable \\nfunਮਾਈ ਕੰਪੋਨੈਂਟ (ਸਥਿਤੀਃ ਸਟੇਟਫਲੋ <ਇੰਟ>) {\\n ਵੈਲ ਸਟੇਟਵੈਲੂ ਬਾਈ state.collectAsState () \\n\\n ਟੈਕਸਟ (ਟੈਕਸਟ = "ਮੁੱਲ ${stateValue} ਹੈ") \\n} \\n "\'\\n ਇਸ ਵਿੱਚਉਦਾਹਰਨ ਲਈ, \'ਸਟੇਟਫਲੋ\' ਨੂੰ \'ਮਾਈ ਕੰਪੋਨੈਂਟ\' ਫੰਕਸ਼ਨ ਲਈ ਇੱਕ ਪੈਰਾਮੀਟਰ ਦੇ ਰੂਪ ਵਿੱਚ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਇਸ ਦੀ ਵਰਤੋਂ ਇੱਕ \'ਟੈਕਸਟ\' ਕੰਪੋਨੈਂਟ ਦੀ ਸਥਿਤੀ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।\'ਸੰਗ੍ਰਹਿ ਅਸਟੇਟ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ \'ਸਟੇਟ ਫਲੋ\' ਦੇ ਨਵੀਨਤਮ ਮੁੱਲ ਨੂੰ \'ਸਟੇਟ ਵੈਲਯੂ\' ਨਾਮਕ ਇੱਕ ਪਰਿਵਰਤਨਸ਼ੀਲ ਅਵਸਥਾ ਵੇਰੀਏਬਲ ਵਿੱਚ ਇਕੱਤਰ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜੋ ਕਿ ਹੋ ਸਕਦਾ ਹੈUI ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਜਦੋਂ UI ਪੇਸ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, \'ਸਟੇਟਫਲੋ\' ਉਦੋਂ ਤੱਕ ਅੱਪਡੇਟ ਨੂੰ ਟਰਿੱਗਰ ਨਹੀਂ ਕਰੇਗਾ ਜਦੋਂ ਤੱਕ \'ਟੈਕਸਟ\' ਕੰਪੋਨੈਂਟ ਇੱਕ ਅੱਪਡੇਟ ਦੀ ਬੇਨਤੀ ਨਹੀਂ ਕਰਦਾ। ਇਸਦਾ ਅਰਥ ਹੈਕਿ \'ਸਟੇਟਫਲੋ\' ਇੱਕ ਠੰਡਾ ਪ੍ਰਵਾਹ ਹੈ, ਅਤੇ ਇਹ ਬੇਲੋਡ਼ੀ ਤੌਰ \'ਤੇ ਮੁੱਲਾਂ ਦੀ ਮੁਡ਼ ਗਣਨਾ ਜਾਂ ਨਿਕਾਸ ਨਹੀਂ ਕਰੇਗਾ ਜਦੋਂ ਤੱਕ ਉਹਨਾਂ ਨੂੰ ਗਾਹਕਾਂ ਦੁਆਰਾ ਬੇਨਤੀ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ।ਕਿਸੇ ਹੋਰ ਪ੍ਰਵਾਹ ਤੋਂ ਇੱਕ ਪ੍ਰਵਾਹ ਬਣਾਓ? \',\' RxJava ਵਿੱਚ, ਤੁਸੀਂ \'ਮਰਜ ()\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਿਸੇ ਹੋਰ \'ਫਲੋ\' ਤੋਂ ਇੱਕ ਨਵਾਂ \'ਫਲੋ\' ਬਣਾ ਸਕਦੇ ਹੋ। \'ਮਰਜ ()\'ਓਪਰੇਟਰ ਦੋ \'ਫਲੋ\' ਨੂੰ ਇੱਕ ਸਿੰਗਲ \'ਫਲੋ\' ਵਿੱਚ ਜੋਡ਼ਦਾ ਹੈ, ਅਤੇ ਇਹ ਦੋਵਾਂ \'ਫਲੋ\' ਵਿੱਚੋਂ ਕਿਸੇ ਇੱਕ ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਦਾ ਹੈ। \\n\\nਇੱਥੇ ਇੱਕ ਬਣਾਉਣ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਦੋ ਹੋਰ \'ਫਲੋ\' ਤੋਂ ਨਵਾਂ \'ਫਲੋ\': \\n \'\' scsss\\nval ਫਲੋ 1 = ਫਲੋਓਫ (1,2,3) \\nval ਫਲੋ 2 = ਫਲੋਓਫ (4,5,6) \\n\\nval ਨਿਊਫਲੋ = flow1.merge (ਫਲੋ 2) \\n \'\' \\ninਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਦੋ \'ਫਲੋ\', \'ਫਲੋ 1\' ਅਤੇ \'ਫਲੋ 2\' ਬਣਾਏ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਨੂੰ \'ਮਰਜ ()\' ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ \'ਨਿਊ ਫਲੋ\' ਨਾਮਕ ਇੱਕ ਨਵੇਂ \'ਫਲੋ\' ਵਿੱਚ ਮਿਲਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।ਓਪਰੇਟਰ। \\n\\n ਨਤੀਜੇ ਵਜੋਂ \'ਨਵਾਂ ਫਲੋ\' ਜਾਂ ਤਾਂ \'ਫਲੋ 1\' ਜਾਂ \'ਫਲੋ 2\' ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢੇਗਾ, ਇਹ ਇਸ ਗੱਲ \'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹਡ਼ਾ\' ਫਲੋ \'ਪਹਿਲਾਂ ਆਈਟਮਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਦਾ ਹੈ।ਆਈਟਮਾਂ ਇੱਕੋ ਸਮੇਂ ਕੱਢੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ ਉਹ ਕੱਢੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਉਸ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਹੁੰਦੀ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ \'ਮਰਜ ()\' ਓਪਰੇਟਰ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਹੀਂ ਹੈ,ਜਿਸ ਦਾ ਅਰਥ ਹੈ ਕਿ ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ \'ਫਲੋ\' ਨੂੰ ਮਿਲਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਉਹ ਨਤੀਜੇ ਵਜੋਂ \'ਫਲੋ\' ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰ ਸਕਦਾ ਹੈ। ਨਾਲ ਹੀ, \'ਮਰਜ ()\' ਓਪਰੇਟਰ ਆਰਡਰ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਦਿੰਦਾ ਹੈ।ਜਿਸ ਵਿੱਚ ਆਈਟਮਾਂ ਦਾ ਨਿਕਾਸ ਹੁੰਦਾ ਹੈ, ਇਸ ਲਈ ਇਹ ਸਾਰੇ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਲਈ ਢੁਕਵਾਂ ਨਹੀਂ ਹੋ ਸਕਦਾ ਹੈ। ", \'ਐਂਡਰਾਇਡ ਕੋਟਲਿਨ ਵਿੱਚ ਇੱਕ ਪ੍ਰਵਾਹ ਕਿਵੇਂ ਬਣਾਇਆ ਜਾਵੇ ਜੋ ਕਿਸੇ ਹੋਰ ਪ੍ਰਵਾਹ ਉੱਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ।\',\' ਐਂਡਰਾਇਡ ਕੋਟਲਿਨ ਵਿੱਚ, ਤੁਸੀਂ ਇੱਕ ਨਵਾਂ \'ਫਲੋ\' ਬਣਾ ਸਕਦੇ ਹੋ ਜੋ \'ਮਰਜ\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਿਸੇ ਹੋਰ \'ਫਲੋ\' ਉੱਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। \'ਮਰਜ\' ਓਪਰੇਟਰ ਦੋ ਨੂੰ ਜੋਡ਼ਦਾ ਹੈਇੱਕ ਸਿੰਗਲ ਪ੍ਰਵਾਹ ਵਿੱਚ ਵਹਿੰਦਾ ਹੈ, ਅਤੇ ਇਹ ਦੋਵਾਂ ਪ੍ਰਵਾਹਾਂ ਵਿੱਚੋਂ ਕਿਸੇ ਇੱਕ ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਦਾ ਹੈ। \\n\\nਇੱਥੇ ਇੱਕ ਨਵਾਂ \'ਪ੍ਰਵਾਹ\' ਬਣਾਉਣ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਜੋ ਇਸ ਉੱਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈਇੱਕ ਹੋਰ ਪ੍ਰਵਾਹਃ \\n "\'scsss\\nval ਫਲੋ 1 = ਫਲੋਓਫ (1,2,3) \\nval ਫਲੋ 2 = ਫਲੋਓਫ (4,5,6) \\n\\nval ਕੰਬਾਈਨਡਫਲੋ = flow1.merge (ਫਲੋ 2) \\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਦੋਪ੍ਰਵਾਹ \'ਫਲੋ 1\' ਅਤੇ \'ਫਲੋ 2\' ਬਣਾਏ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਨੂੰ \'ਮਰਜ\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ \'ਕੰਬਾਈਨਡ ਫਲੋ\' ਨਾਮਕ ਇੱਕ ਨਵੇਂ ਪ੍ਰਵਾਹ ਵਿੱਚ ਮਿਲਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।\'ਕੰਬਾਈਨਡ ਫਲੋ\' ਜਾਂ ਤਾਂ \'ਫਲੋ 1\' ਜਾਂ \'ਫਲੋ 2\' ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢੇਗਾ, ਇਹ ਇਸ ਗੱਲ \'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹਡ਼ਾ ਪ੍ਰਵਾਹ ਪਹਿਲਾਂ ਆਈਟਮਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਦਾ ਹੈ।ਉਸੇ ਸਮੇਂ, ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ ਉਹ ਕੱਢੇ ਜਾਂਦੇ ਹਨ, ਉਸ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਹੁੰਦੀ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ \'ਮਰਜ\' ਓਪਰੇਟਰ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਹੀਂ ਹੈ, ਜਿਸਦਾ ਅਰਥ ਹੈ ਕਿ ਕ੍ਰਮਜਿਸ ਵਿੱਚ ਪ੍ਰਵਾਹਾਂ ਨੂੰ ਮਿਲਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਨਤੀਜੇ ਵਜੋਂ ਪ੍ਰਵਾਹ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰ ਸਕਦਾ ਹੈ। ਨਾਲ ਹੀ, \'ਮਰਜ\' ਓਪਰੇਟਰ ਉਸ ਕ੍ਰਮ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਦਿੰਦਾ ਜਿਸ ਵਿੱਚ ਆਈਟਮਾਂ ਕੱਢੀਆਂ ਜਾਂਦੀਆਂ ਹਨ,ਇਸ ਲਈ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਇਹ ਸਾਰੇ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਲਈ ਢੁਕਵਾਂ ਨਾ ਹੋਵੇ। ", \'ਨਹੀਂ, ਇੱਥੇ ਸਿਰਫ ਇੱਕ ਪ੍ਰਵਾਹ ਹੈ ਅਤੇ ਮੈਂ ਪਹਿਲੇ ਤੋਂ ਆਪਣਾ ਦੂਜਾ ਪ੍ਰਵਾਹ ਬਣਾਉਣਾ ਚਾਹੁੰਦਾ ਹਾਂ?\'", ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਹੈਸਿੰਗਲ \'ਫਲੋ\' ਅਤੇ ਤੁਸੀਂ ਇਸ ਤੋਂ ਇੱਕ ਨਵਾਂ \'ਫਲੋ\' ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤੁਸੀਂ ਆਰਐਕਸਜੇਵਾ ਵਿੱਚ \'ਫਲੈਟਮੈਪ\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਤਾਂ ਜੋ ਮੂਲ ਦੁਆਰਾ ਕੱਢੀ ਗਈ ਹਰੇਕ ਚੀਜ਼ ਨੂੰ ਬਦਲਿਆ ਜਾ ਸਕੇ।ਇੱਕ ਮੌਜੂਦਾ \'ਫਲੋ\' ਤੋਂ ਇੱਕ ਨਵਾਂ \'ਫਲੋ\' ਬਣਾਉਣ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n \'\' scsss\\nval ਫਲੋ1 = ਫਲੋਓਫ (1,2,3) \\n\\nval ਫਲੋ2 =flow1.flatMap {ਮੁੱਲ-> \\n ਫਲੋਓਫ (ਮੁੱਲ * 2, ਮੁੱਲ * 3, ਮੁੱਲ * 4) \\n} \\n \'\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ,\' ਫਲੈਟਮੈਪ \'ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਆਈਟਮ ਨੂੰ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।\'ਫਲੋ 1\' ਦੁਆਰਾ \'ਫਲੋ 2\' ਨਾਮਕ ਇੱਕ ਨਵੇਂ \'ਫਲੋ\' ਵਿੱਚ ਛੱਡਿਆ ਜਾਂਦਾ ਹੈ। \'ਫਲੈਟ ਮੈਪ\' ਨੂੰ ਪਾਸ ਕੀਤਾ ਗਿਆ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ \'ਫਲੋ 1\' ਦੁਆਰਾ ਛੱਡੀ ਗਈ ਹਰੇਕ ਚੀਜ਼ ਨੂੰ ਲੈਂਦਾ ਹੈ ਅਤੇ ਇੱਕ ਨਵਾਂ ਨਿਕਾਸ ਕਰਦਾ ਹੈ।\'ਫਲੋਓਫ\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਆਈਟਮਾਂ ਦਾ ਸੈੱਟ। \\n\\n ਨਤੀਜੇ ਵਜੋਂ \'ਫਲੋ2\' \'ਫਲੋ1\' ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਆਈਟਮਾਂ ਨੂੰ 2,3 ਅਤੇ 4 ਨਾਲ ਗੁਣਾ ਕਰਕੇ ਬਾਹਰ ਕੱਢੇਗਾ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ\'ਫਲੈਟਮੈਪ\' ਓਪਰੇਟਰ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਹੀਂ ਹੈ, ਜਿਸਦਾ ਅਰਥ ਹੈ ਕਿ ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ ਪ੍ਰਵਾਹਾਂ ਨੂੰ ਚਪਟਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਉਹ ਨਤੀਜੇ ਵਜੋਂ ਪ੍ਰਵਾਹ ਨੂੰ ਪ੍ਰਭਾਵਤ ਕਰ ਸਕਦਾ ਹੈ।\'ਫਲੈਟਮੈਪ\' ਓਪਰੇਟਰ ਉਸ ਕ੍ਰਮ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਦਿੰਦਾ ਜਿਸ ਵਿੱਚ ਆਈਟਮਾਂ ਕੱਢੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਇਸ ਲਈ ਇਹ ਸਾਰੇ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਲਈ ਢੁਕਵਾਂ ਨਹੀਂ ਹੋ ਸਕਦਾ।\',\' ਕੋਟਲਿਨ ਐਂਡਰਾਇਡ ਵਿੱਚ, ਤੁਸੀਂ ਇੱਕ ਨਵਾਂ \'ਫਲੋ\' ਬਣਾ ਸਕਦੇ ਹੋ ਜੋ \'ਮਰਜ\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਿਸੇ ਹੋਰ \'ਫਲੋ\' ਉੱਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। \'ਮਰਜ\' ਓਪਰੇਟਰ ਦੋ ਨੂੰ ਜੋਡ਼ਦਾ ਹੈਇੱਕ ਸਿੰਗਲ ਪ੍ਰਵਾਹ ਵਿੱਚ ਵਹਿੰਦਾ ਹੈ, ਅਤੇ ਇਹ ਦੋਵਾਂ ਪ੍ਰਵਾਹਾਂ ਵਿੱਚੋਂ ਕਿਸੇ ਇੱਕ ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਦਾ ਹੈ। \\n\\nਇੱਥੇ ਇੱਕ ਨਵਾਂ \'ਪ੍ਰਵਾਹ\' ਬਣਾਉਣ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਜੋ ਇਸ ਉੱਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈਐਂਡਰਾਇਡ ਕੋਟਲਿਨ ਵਿੱਚ ਇੱਕ ਹੋਰ ਪ੍ਰਵਾਹਃ \\n "\'scsss\\nval ਫਲੋ1 = ਫਲੋਓਫ (1,2,3) \\nval ਫਲੋ2 = ਫਲੋਓਫ (4,5,6) \\n\\nval ਕੰਬਾਈਨਡਫਲੋ = flow1.merge (ਫਲੋ2) \\n"\' \\nਇਨਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਦੋ ਪ੍ਰਵਾਹ \'ਫਲੋ 1\' ਅਤੇ \'ਫਲੋ 2\' ਬਣਾਏ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਨੂੰ \'ਮਰਜ\' ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ \'ਕੰਬਾਈਨਡ ਫਲੋ\' ਨਾਮਕ ਇੱਕ ਨਵੇਂ ਪ੍ਰਵਾਹ ਵਿੱਚ ਮਿਲਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।ਓਪਰੇਟਰ। \\n\\n ਨਤੀਜੇ ਵਜੋਂ \'ਕੰਬਾਈਨਡ ਫਲੋ\' \'ਫਲੋ 1\' ਜਾਂ \'ਫਲੋ 2\' ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢੇਗਾ, ਇਹ ਇਸ ਗੱਲ \'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹਡ਼ਾ ਪ੍ਰਵਾਹ ਪਹਿਲਾਂ ਆਈਟਮਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਦਾ ਹੈ। ਜੇਕਰਆਈਟਮਾਂ ਇੱਕੋ ਸਮੇਂ ਕੱਢੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ ਉਹ ਕੱਢੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਉਸ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਹੁੰਦੀ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ \'ਮਰਜ\' ਓਪਰੇਟਰ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਹੀਂ ਹੈ,ਜਿਸ ਦਾ ਅਰਥ ਹੈ ਕਿ ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ ਪ੍ਰਵਾਹਾਂ ਨੂੰ ਮਿਲਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਉਹ ਨਤੀਜੇ ਵਜੋਂ ਪ੍ਰਵਾਹ ਨੂੰ ਪ੍ਰਭਾਵਤ ਕਰ ਸਕਦਾ ਹੈ। ਨਾਲ ਹੀ, \'ਅਭੇਦ\' ਸੰਚਾਲਕ ਕ੍ਰਮ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਦਿੰਦਾ ਹੈ।ਜਿਸ ਤੋਂ ਚੀਜ਼ਾਂ ਨਿਕਲਦੀਆਂ ਹਨ, ਇਸ ਲਈ ਇਹ ਸਾਰੇ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਲਈ ਢੁਕਵਾਂ ਨਹੀਂ ਹੋ ਸਕਦਾ ਹੈ। ", \'ਨਹੀਂ, ਇੱਥੇ ਸਿਰਫ ਇੱਕ ਪ੍ਰਵਾਹ ਹੈ ਅਤੇ ਮੈਂ ਇਸ ਤੋਂ ਆਪਣਾ ਦੂਜਾ ਪ੍ਰਵਾਹ ਬਣਾਉਣਾ ਚਾਹੁੰਦਾ ਹਾਂ।ਪਹਿਲਾਂ ਇੱਕ। ਕ੍ਰਿਪਾ ਕਰਕੇ ਮੈਨੂੰ ਕੋਟਲਿਨ ਐਂਡਰਾਇਡ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਦਿਖਾਓ? \' ', 'ਮੇਰੇ ਕੋਲ flow.map {ਮੁੱਲ-> ਪਰਿਵਰਤਨ ()}. onEach {} ਹੈ। onEach ਕੀ ਕਰਦਾ ਹੈ?', ' [\'ਮੇਰੇ ਕੋਲ flow.map {ਮੁੱਲ-> \\n ਪਰਿਵਰਤਨ () \\n}. onEach {\\n\\n} ਹੈ।\', ਪ੍ਰਤੀਕ੍ਰਿਆਸ਼ੀਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਢਾਂਚੇ ਵਿੱਚ, \'onEach ()\' ਕੀ ਕਰਦਾ ਹੈ?ਸੰਚਾਲਕ ਆਰਐਕਸਜੇਵਾ ਵਿੱਚ \'ਪ੍ਰਕਾਸ਼ਕ\' ਇੰਟਰਫੇਸ ਦਾ ਇੱਕ ਹਿੱਸਾ ਹੈ। ਇਸ ਦੀ ਵਰਤੋਂ ਇੱਕ ਪ੍ਰਕਾਸ਼ਕ ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਉੱਤੇ ਇੱਕ ਕਾਰਵਾਈ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ \'ਫਲੋ\',ਇੱਕ ਕ੍ਰਮਵਾਰ ਢੰਗ ਨਾਲ। \\n\\n ਤੁਹਾਡੇ ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਕੋਡ ਸਨਿੱਪਟ ਵਿੱਚ, \'flow.map\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਨੂੰ ਇੱਕ ਨਵੇਂ ਆਈਟਮ ਵਿੱਚ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।ਆਈਟਮ. ਨਤੀਜੇ ਵਜੋਂ ਪਰਿਵਰਤਿਤ ਆਈਟਮਾਂ ਨੂੰ ਫਿਰ \'onEach ()\' ਓਪਰੇਟਰ ਨੂੰ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ. \\n\\n \'onEach ()\' ਓਪਰੇਟਰ ਇੱਕ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਇੱਕ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਲੈਂਦਾ ਹੈ,ਜਿਸ ਨੂੰ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਲਈ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਤੁਹਾਡੇ ਮਾਮਲੇ ਵਿੱਚ, ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਪ੍ਰਦਾਨ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ, ਇਸ ਲਈ \'onEach ()\' ਦੇ ਅੰਦਰ ਕੁਝ ਨਹੀਂ ਹੁੰਦਾ ਹੈ।\'onEach ()\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਇੱਕ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਪ੍ਰਦਾਨ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਜੋ ਹਰੇਕ ਆਈਟਮ ਉੱਤੇ ਕੁੱਝ ਕਾਰਵਾਈ ਕਰਦਾ ਹੈ।\'ਫਲੋ\'। ਉਦਾਹਰਨ ਲਈ, ਤੁਸੀਂ ਇਸ ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਵਸਤੂ ਨੂੰ ਸਾਈਡ-ਇਫੈਕਟ ਪ੍ਰਕਿਰਿਆ ਲਈ ਕਰ ਸਕਦੇ ਹੋ, ਜਾਂ ਮੂਲ ਦੇ ਪਰਿਵਰਤਨ ਦੇ ਅਧਾਰ ਉੱਤੇ ਇੱਕ ਨਵੀਂ ਵਸਤੂ ਨੂੰ ਛੱਡਣ ਲਈ ਕਰ ਸਕਦੇ ਹੋ।ਆਈਟਮ। \\n\\n ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਜੋ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੀ ਗਈ ਮੂਲ ਆਈਟਮ ਦੇ ਅਧਾਰ ਉੱਤੇ ਇੱਕ ਨਵੀਂ ਆਈਟਮ ਨੂੰ ਛੱਡਣ ਲਈ \'onEach ()\' ਦੀ ਵਰਤੋਂ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈਃ \\n \'\' scsss\\nvalਫਲੋ = ਫਲੋਓਫ (1,2,3) \\n\\nਫਲੋ\\n. ਮੈਪ {it * 2} \\n. onEach {ਮੁੱਲ-> \\n ਨਿਕਾਸ (ਮੁੱਲ)// ਪਰਿਵਰਤਿਤ ਮੁੱਲ ਨੂੰ ਨਿਕਾਸ ਕਰਦਾ ਹੈ \\n} \\n \'\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ,\'ਮੈਪ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੇ ਗਏ ਹਰੇਕ ਆਈਟਮ ਨੂੰ 2 ਨਾਲ ਗੁਣਾ ਕਰਕੇ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।\'onEach ()\' ਓਪਰੇਟਰ, ਜਿੱਥੇ ਇੱਕ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ ਹਰੇਕ ਪਰਿਵਰਤਿਤ ਆਈਟਮ ਨੂੰ ਬਾਹਰ ਕੱਢਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ \'onEach ()\' ਓਪਰੇਟਰ ਇਸ ਦੇ ਸਮਾਨ ਨਹੀਂ ਹੈ।\'ਮੈਪ ()\' ਓਪਰੇਟਰ, ਹਾਲਾਂਕਿ ਉਹ ਦੋਵੇਂ ਇੱਕ \'ਫਲੋ\' ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਆਈਟਮਾਂ ਨੂੰ ਬਦਲਣ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ. \'ਮੈਪ ()\' ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਆਈਟਮ ਨੂੰ ਇੱਕ ਨਵੀਂ ਆਈਟਮ ਵਿੱਚ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ,ਜਦੋਂ ਕਿ \'onEach ()\' ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਆਈਟਮ ਉੱਤੇ ਇੱਕ ਸਾਈਡ-ਇਫੈਕਟ ਲਾਗੂ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਪਰ ਨਤੀਜੇ ਵਜੋਂ ਬਦਲੀਆਂ ਗਈਆਂ ਆਈਟਮਾਂ \'ਫਲੋ\' ਦੁਆਰਾ ਨਹੀਂ ਨਿਕਲਦੀਆਂ।\',\' ਕੋਟਲਿਨ ਵਿੱਚ, \'ਸਟੇਟਫਲੋ\' ਇੱਕ ਕਿਸਮ ਦਾ \'ਫਲੋ\' ਹੈ ਜੋ ਉਹਨਾਂ ਮੁੱਲਾਂ ਦੇ ਇੱਕ ਕ੍ਰਮ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ ਜੋ ਬਦਲ ਸਕਦੇ ਹਨਸਮੇਂ ਦੇ ਨਾਲ ਇਹ ਪ੍ਰਤੀਕਿਰਿਆਸ਼ੀਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਲਾਇਬ੍ਰੇਰੀ ਦਾ ਹਿੱਸਾ ਹੈ ਜਿਸ ਨੂੰ ਜੇਟਪੈਕ ਕੰਪੋਜ਼ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। \\n\\n \'ਸਟੇਟਫਲੋ\' ਇੱਕ ਠੰਡਾ ਪ੍ਰਵਾਹ ਹੈ, ਜਿਸਦਾ ਅਰਥ ਹੈ ਕਿ ਇਹ ਟਰਿੱਗਰ ਨਹੀਂ ਕਰਦਾ ਹੈ।ਅੱਪਡੇਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਇਸਦੇ ਗਾਹਕ ਉਹਨਾਂ ਨੂੰ ਬੇਨਤੀ ਨਹੀਂ ਕਰਦੇ. ਠੰਡੇ ਪ੍ਰਵਾਹ ਆਮ ਤੌਰ \'ਤੇ ਗਰਮ ਪ੍ਰਵਾਹਾਂ ਨਾਲੋਂ ਵਧੇਰੇ ਕੁਸ਼ਲ ਹੁੰਦੇ ਹਨ, ਕਿਉਂਕਿ ਉਹ ਬੇਲੋਡ਼ੇ ਤੌਰ\' ਤੇ ਦੁਬਾਰਾ ਕੰਪਿਊਟ ਨਹੀਂ ਕਰਦੇ ਜਾਂਮੁੱਲ ਛੱਡੋ। \\n\\n \'ਸਟੇਟਫਲੋ\' ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਇਸ ਨੂੰ ਜੈੱਟਪੈਕ ਕੰਪੋਜ਼ ਵਿੱਚ ਇੱਕ ਹਿੱਸੇ ਲਈ ਮੁੱਲ ਧਾਰਕ ਵਜੋਂ ਵਰਤਣ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਇਹ ਆਪਣੇ ਆਪਆਪਣੇ ਗਾਹਕਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦਾ ਹੈ। ਜਦੋਂ ਕੋਈ ਗਾਹਕ ਇੱਕ ਅੱਪਡੇਟ ਦੀ ਬੇਨਤੀ ਕਰਦਾ ਹੈ, ਤਾਂ \'ਸਟੇਟਫਲੋ\' ਨਵੀਨਤਮ ਮੁੱਲ ਦਾ ਨਿਕਾਸ ਕਰਦਾ ਹੈ, ਅਤੇ ਮੁੱਲ ਵਿੱਚ ਕੋਈ ਵੀ ਬਾਅਦ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਹਨਆਪਣੇ ਆਪ ਸਾਰੇ ਗਾਹਕਾਂ ਨੂੰ ਸੰਚਾਰਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। \\n\\n \'ਇਹ ਜੇਟਪੈਕ ਵਿੱਚ\' ਸਟੇਟਫਲੋ \'ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n\' \'scsss\\ n@Composable \\nfunਮਾਈ ਕੰਪੋਨੈਂਟ (ਸਥਿਤੀਃ ਸਟੇਟਫਲੋ <ਇੰਟ>) {\\n ਵੈਲ ਸਟੇਟਵੈਲੂ ਬਾਈ state.collectAsState () \\n\\n ਟੈਕਸਟ (ਟੈਕਸਟ = "ਮੁੱਲ ${stateValue} ਹੈ") \\n} \\n "\'\\n ਇਸ ਵਿੱਚਉਦਾਹਰਨ ਲਈ, \'ਸਟੇਟਫਲੋ\' ਨੂੰ \'ਮਾਈ ਕੰਪੋਨੈਂਟ\' ਫੰਕਸ਼ਨ ਲਈ ਇੱਕ ਪੈਰਾਮੀਟਰ ਦੇ ਰੂਪ ਵਿੱਚ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਇਸ ਦੀ ਵਰਤੋਂ ਇੱਕ \'ਟੈਕਸਟ\' ਕੰਪੋਨੈਂਟ ਦੀ ਸਥਿਤੀ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।\'ਸੰਗ੍ਰਹਿ ਅਸਟੇਟ ()\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ \'ਸਟੇਟ ਫਲੋ\' ਦੇ ਨਵੀਨਤਮ ਮੁੱਲ ਨੂੰ \'ਸਟੇਟ ਵੈਲਯੂ\' ਨਾਮਕ ਇੱਕ ਪਰਿਵਰਤਨਸ਼ੀਲ ਅਵਸਥਾ ਵੇਰੀਏਬਲ ਵਿੱਚ ਇਕੱਤਰ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜੋ ਕਿ ਹੋ ਸਕਦਾ ਹੈUI ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਜਦੋਂ UI ਪੇਸ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, \'ਸਟੇਟਫਲੋ\' ਉਦੋਂ ਤੱਕ ਅੱਪਡੇਟ ਨੂੰ ਟਰਿੱਗਰ ਨਹੀਂ ਕਰੇਗਾ ਜਦੋਂ ਤੱਕ \'ਟੈਕਸਟ\' ਕੰਪੋਨੈਂਟ ਇੱਕ ਅੱਪਡੇਟ ਦੀ ਬੇਨਤੀ ਨਹੀਂ ਕਰਦਾ। ਇਸਦਾ ਅਰਥ ਹੈਕਿ \'ਸਟੇਟਫਲੋ\' ਇੱਕ ਠੰਡਾ ਪ੍ਰਵਾਹ ਹੈ, ਅਤੇ ਇਹ ਬੇਲੋਡ਼ੀ ਤੌਰ \'ਤੇ ਮੁੱਲਾਂ ਦੀ ਮੁਡ਼ ਗਣਨਾ ਜਾਂ ਨਿਕਾਸ ਨਹੀਂ ਕਰੇਗਾ ਜਦੋਂ ਤੱਕ ਉਹਨਾਂ ਨੂੰ ਗਾਹਕਾਂ ਦੁਆਰਾ ਬੇਨਤੀ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ।ਕਿਸੇ ਹੋਰ ਪ੍ਰਵਾਹ ਤੋਂ ਇੱਕ ਪ੍ਰਵਾਹ ਬਣਾਓ? \',\' RxJava ਵਿੱਚ, ਤੁਸੀਂ \'ਮਰਜ ()\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਿਸੇ ਹੋਰ \'ਫਲੋ\' ਤੋਂ ਇੱਕ ਨਵਾਂ \'ਫਲੋ\' ਬਣਾ ਸਕਦੇ ਹੋ। \'ਮਰਜ ()\'ਓਪਰੇਟਰ ਦੋ \'ਫਲੋ\' ਨੂੰ ਇੱਕ ਸਿੰਗਲ \'ਫਲੋ\' ਵਿੱਚ ਜੋਡ਼ਦਾ ਹੈ, ਅਤੇ ਇਹ ਦੋਵਾਂ \'ਫਲੋ\' ਵਿੱਚੋਂ ਕਿਸੇ ਇੱਕ ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਦਾ ਹੈ। \\n\\nਇੱਥੇ ਇੱਕ ਬਣਾਉਣ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਦੋ ਹੋਰ \'ਫਲੋ\' ਤੋਂ ਨਵਾਂ \'ਫਲੋ\': \\n \'\' scsss\\nval ਫਲੋ 1 = ਫਲੋਓਫ (1,2,3) \\nval ਫਲੋ 2 = ਫਲੋਓਫ (4,5,6) \\n\\nval ਨਿਊਫਲੋ = flow1.merge (ਫਲੋ 2) \\n \'\' \\ninਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਦੋ \'ਫਲੋ\', \'ਫਲੋ 1\' ਅਤੇ \'ਫਲੋ 2\' ਬਣਾਏ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਨੂੰ \'ਮਰਜ ()\' ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ \'ਨਿਊ ਫਲੋ\' ਨਾਮਕ ਇੱਕ ਨਵੇਂ \'ਫਲੋ\' ਵਿੱਚ ਮਿਲਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।ਓਪਰੇਟਰ। \\n\\n ਨਤੀਜੇ ਵਜੋਂ \'ਨਵਾਂ ਫਲੋ\' ਜਾਂ ਤਾਂ \'ਫਲੋ 1\' ਜਾਂ \'ਫਲੋ 2\' ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢੇਗਾ, ਇਹ ਇਸ ਗੱਲ \'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹਡ਼ਾ\' ਫਲੋ \'ਪਹਿਲਾਂ ਆਈਟਮਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਦਾ ਹੈ।ਆਈਟਮਾਂ ਇੱਕੋ ਸਮੇਂ ਕੱਢੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ ਉਹ ਕੱਢੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਉਸ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਹੁੰਦੀ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ \'ਮਰਜ ()\' ਓਪਰੇਟਰ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਹੀਂ ਹੈ,ਜਿਸ ਦਾ ਅਰਥ ਹੈ ਕਿ ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ \'ਫਲੋ\' ਨੂੰ ਮਿਲਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਉਹ ਨਤੀਜੇ ਵਜੋਂ \'ਫਲੋ\' ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰ ਸਕਦਾ ਹੈ। ਨਾਲ ਹੀ, \'ਮਰਜ ()\' ਓਪਰੇਟਰ ਆਰਡਰ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਦਿੰਦਾ ਹੈ।ਜਿਸ ਵਿੱਚ ਆਈਟਮਾਂ ਦਾ ਨਿਕਾਸ ਹੁੰਦਾ ਹੈ, ਇਸ ਲਈ ਇਹ ਸਾਰੇ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਲਈ ਢੁਕਵਾਂ ਨਹੀਂ ਹੋ ਸਕਦਾ ਹੈ। ", \'ਐਂਡਰਾਇਡ ਕੋਟਲਿਨ ਵਿੱਚ ਇੱਕ ਪ੍ਰਵਾਹ ਕਿਵੇਂ ਬਣਾਇਆ ਜਾਵੇ ਜੋ ਕਿਸੇ ਹੋਰ ਪ੍ਰਵਾਹ ਉੱਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ।\',\' ਐਂਡਰਾਇਡ ਕੋਟਲਿਨ ਵਿੱਚ, ਤੁਸੀਂ ਇੱਕ ਨਵਾਂ \'ਫਲੋ\' ਬਣਾ ਸਕਦੇ ਹੋ ਜੋ \'ਮਰਜ\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਿਸੇ ਹੋਰ \'ਫਲੋ\' ਉੱਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। \'ਮਰਜ\' ਓਪਰੇਟਰ ਦੋ ਨੂੰ ਜੋਡ਼ਦਾ ਹੈਇੱਕ ਸਿੰਗਲ ਪ੍ਰਵਾਹ ਵਿੱਚ ਵਹਿੰਦਾ ਹੈ, ਅਤੇ ਇਹ ਦੋਵਾਂ ਪ੍ਰਵਾਹਾਂ ਵਿੱਚੋਂ ਕਿਸੇ ਇੱਕ ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਦਾ ਹੈ। \\n\\nਇੱਥੇ ਇੱਕ ਨਵਾਂ \'ਪ੍ਰਵਾਹ\' ਬਣਾਉਣ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਜੋ ਇਸ ਉੱਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈਇੱਕ ਹੋਰ ਪ੍ਰਵਾਹਃ \\n "\'scsss\\nval ਫਲੋ 1 = ਫਲੋਓਫ (1,2,3) \\nval ਫਲੋ 2 = ਫਲੋਓਫ (4,5,6) \\n\\nval ਕੰਬਾਈਨਡਫਲੋ = flow1.merge (ਫਲੋ 2) \\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਦੋਪ੍ਰਵਾਹ \'ਫਲੋ 1\' ਅਤੇ \'ਫਲੋ 2\' ਬਣਾਏ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਨੂੰ \'ਮਰਜ\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ \'ਕੰਬਾਈਨਡ ਫਲੋ\' ਨਾਮਕ ਇੱਕ ਨਵੇਂ ਪ੍ਰਵਾਹ ਵਿੱਚ ਮਿਲਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।\'ਕੰਬਾਈਨਡ ਫਲੋ\' ਜਾਂ ਤਾਂ \'ਫਲੋ 1\' ਜਾਂ \'ਫਲੋ 2\' ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢੇਗਾ, ਇਹ ਇਸ ਗੱਲ \'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹਡ਼ਾ ਪ੍ਰਵਾਹ ਪਹਿਲਾਂ ਆਈਟਮਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਦਾ ਹੈ।ਉਸੇ ਸਮੇਂ, ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ ਉਹ ਕੱਢੇ ਜਾਂਦੇ ਹਨ, ਉਸ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਹੁੰਦੀ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ \'ਮਰਜ\' ਓਪਰੇਟਰ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਹੀਂ ਹੈ, ਜਿਸਦਾ ਅਰਥ ਹੈ ਕਿ ਕ੍ਰਮਜਿਸ ਵਿੱਚ ਪ੍ਰਵਾਹਾਂ ਨੂੰ ਮਿਲਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਨਤੀਜੇ ਵਜੋਂ ਪ੍ਰਵਾਹ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰ ਸਕਦਾ ਹੈ। ਨਾਲ ਹੀ, \'ਮਰਜ\' ਓਪਰੇਟਰ ਉਸ ਕ੍ਰਮ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਦਿੰਦਾ ਜਿਸ ਵਿੱਚ ਆਈਟਮਾਂ ਕੱਢੀਆਂ ਜਾਂਦੀਆਂ ਹਨ,ਇਸ ਲਈ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਇਹ ਸਾਰੇ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਲਈ ਢੁਕਵਾਂ ਨਾ ਹੋਵੇ। ", \'ਨਹੀਂ, ਇੱਥੇ ਸਿਰਫ ਇੱਕ ਪ੍ਰਵਾਹ ਹੈ ਅਤੇ ਮੈਂ ਪਹਿਲੇ ਤੋਂ ਆਪਣਾ ਦੂਜਾ ਪ੍ਰਵਾਹ ਬਣਾਉਣਾ ਚਾਹੁੰਦਾ ਹਾਂ?\'", ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਹੈਸਿੰਗਲ \'ਫਲੋ\' ਅਤੇ ਤੁਸੀਂ ਇਸ ਤੋਂ ਇੱਕ ਨਵਾਂ \'ਫਲੋ\' ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤੁਸੀਂ ਆਰਐਕਸਜੇਵਾ ਵਿੱਚ \'ਫਲੈਟਮੈਪ\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਤਾਂ ਜੋ ਮੂਲ ਦੁਆਰਾ ਕੱਢੀ ਗਈ ਹਰੇਕ ਚੀਜ਼ ਨੂੰ ਬਦਲਿਆ ਜਾ ਸਕੇ।ਇੱਕ ਮੌਜੂਦਾ \'ਫਲੋ\' ਤੋਂ ਇੱਕ ਨਵਾਂ \'ਫਲੋ\' ਬਣਾਉਣ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n \'\' scsss\\nval ਫਲੋ1 = ਫਲੋਓਫ (1,2,3) \\n\\nval ਫਲੋ2 =flow1.flatMap {ਮੁੱਲ-> \\n ਫਲੋਓਫ (ਮੁੱਲ * 2, ਮੁੱਲ * 3, ਮੁੱਲ * 4) \\n} \\n \'\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ,\' ਫਲੈਟਮੈਪ \'ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਹਰੇਕ ਆਈਟਮ ਨੂੰ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।\'ਫਲੋ 1\' ਦੁਆਰਾ \'ਫਲੋ 2\' ਨਾਮਕ ਇੱਕ ਨਵੇਂ \'ਫਲੋ\' ਵਿੱਚ ਛੱਡਿਆ ਜਾਂਦਾ ਹੈ। \'ਫਲੈਟ ਮੈਪ\' ਨੂੰ ਪਾਸ ਕੀਤਾ ਗਿਆ ਲੈਂਬਡਾ ਫੰਕਸ਼ਨ \'ਫਲੋ 1\' ਦੁਆਰਾ ਛੱਡੀ ਗਈ ਹਰੇਕ ਚੀਜ਼ ਨੂੰ ਲੈਂਦਾ ਹੈ ਅਤੇ ਇੱਕ ਨਵਾਂ ਨਿਕਾਸ ਕਰਦਾ ਹੈ।\'ਫਲੋਓਫ\' ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਆਈਟਮਾਂ ਦਾ ਸੈੱਟ। \\n\\n ਨਤੀਜੇ ਵਜੋਂ \'ਫਲੋ2\' \'ਫਲੋ1\' ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਆਈਟਮਾਂ ਨੂੰ 2,3 ਅਤੇ 4 ਨਾਲ ਗੁਣਾ ਕਰਕੇ ਬਾਹਰ ਕੱਢੇਗਾ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ\'ਫਲੈਟਮੈਪ\' ਓਪਰੇਟਰ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਹੀਂ ਹੈ, ਜਿਸਦਾ ਅਰਥ ਹੈ ਕਿ ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ ਪ੍ਰਵਾਹਾਂ ਨੂੰ ਚਪਟਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਉਹ ਨਤੀਜੇ ਵਜੋਂ ਪ੍ਰਵਾਹ ਨੂੰ ਪ੍ਰਭਾਵਤ ਕਰ ਸਕਦਾ ਹੈ।\'ਫਲੈਟਮੈਪ\' ਓਪਰੇਟਰ ਉਸ ਕ੍ਰਮ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਦਿੰਦਾ ਜਿਸ ਵਿੱਚ ਆਈਟਮਾਂ ਕੱਢੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਇਸ ਲਈ ਇਹ ਸਾਰੇ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਲਈ ਢੁਕਵਾਂ ਨਹੀਂ ਹੋ ਸਕਦਾ।\',\' ਕੋਟਲਿਨ ਐਂਡਰਾਇਡ ਵਿੱਚ, ਤੁਸੀਂ ਇੱਕ ਨਵਾਂ \'ਫਲੋ\' ਬਣਾ ਸਕਦੇ ਹੋ ਜੋ \'ਮਰਜ\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਿਸੇ ਹੋਰ \'ਫਲੋ\' ਉੱਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। \'ਮਰਜ\' ਓਪਰੇਟਰ ਦੋ ਨੂੰ ਜੋਡ਼ਦਾ ਹੈਇੱਕ ਸਿੰਗਲ ਪ੍ਰਵਾਹ ਵਿੱਚ ਵਹਿੰਦਾ ਹੈ, ਅਤੇ ਇਹ ਦੋਵਾਂ ਪ੍ਰਵਾਹਾਂ ਵਿੱਚੋਂ ਕਿਸੇ ਇੱਕ ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਦਾ ਹੈ। \\n\\nਇੱਥੇ ਇੱਕ ਨਵਾਂ \'ਪ੍ਰਵਾਹ\' ਬਣਾਉਣ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਜੋ ਇਸ ਉੱਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈਐਂਡਰਾਇਡ ਕੋਟਲਿਨ ਵਿੱਚ ਇੱਕ ਹੋਰ ਪ੍ਰਵਾਹਃ \\n "\'scsss\\nval ਫਲੋ1 = ਫਲੋਓਫ (1,2,3) \\nval ਫਲੋ2 = ਫਲੋਓਫ (4,5,6) \\n\\nval ਕੰਬਾਈਨਡਫਲੋ = flow1.merge (ਫਲੋ2) \\n"\' \\nਇਨਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਦੋ ਪ੍ਰਵਾਹ \'ਫਲੋ 1\' ਅਤੇ \'ਫਲੋ 2\' ਬਣਾਏ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਨੂੰ \'ਮਰਜ\' ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ \'ਕੰਬਾਈਨਡ ਫਲੋ\' ਨਾਮਕ ਇੱਕ ਨਵੇਂ ਪ੍ਰਵਾਹ ਵਿੱਚ ਮਿਲਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।ਓਪਰੇਟਰ। \\n\\n ਨਤੀਜੇ ਵਜੋਂ \'ਕੰਬਾਈਨਡ ਫਲੋ\' \'ਫਲੋ 1\' ਜਾਂ \'ਫਲੋ 2\' ਦੁਆਰਾ ਕੱਢੀਆਂ ਗਈਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢੇਗਾ, ਇਹ ਇਸ ਗੱਲ \'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹਡ਼ਾ ਪ੍ਰਵਾਹ ਪਹਿਲਾਂ ਆਈਟਮਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਦਾ ਹੈ। ਜੇਕਰਆਈਟਮਾਂ ਇੱਕੋ ਸਮੇਂ ਕੱਢੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ ਉਹ ਕੱਢੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਉਸ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਹੁੰਦੀ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ \'ਮਰਜ\' ਓਪਰੇਟਰ ਪਰਿਵਰਤਨਸ਼ੀਲ ਨਹੀਂ ਹੈ,ਜਿਸ ਦਾ ਅਰਥ ਹੈ ਕਿ ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ ਪ੍ਰਵਾਹਾਂ ਨੂੰ ਮਿਲਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਉਹ ਨਤੀਜੇ ਦੇ ਪ੍ਰਵਾਹ ਨੂੰ ਪ੍ਰਭਾਵਤ ਕਰ ਸਕਦਾ ਹੈ। ਨਾਲ ਹੀ, \'ਅਭੇਦ\' ਸੰਚਾਲਕ ਕ੍ਰਮ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਦਿੰਦਾ ਹੈ।ਜਿਸ ਤੋਂ ਚੀਜ਼ਾਂ ਨਿਕਲਦੀਆਂ ਹਨ, ਇਸ ਲਈ ਇਹ ਸਾਰੇ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਲਈ ਢੁਕਵਾਂ ਨਹੀਂ ਹੋ ਸਕਦਾ ਹੈ। ", \'ਨਹੀਂ, ਇੱਥੇ ਸਿਰਫ ਇੱਕ ਪ੍ਰਵਾਹ ਹੈ ਅਤੇ ਮੈਂ ਇਸ ਤੋਂ ਆਪਣਾ ਦੂਜਾ ਪ੍ਰਵਾਹ ਬਣਾਉਣਾ ਚਾਹੁੰਦਾ ਹਾਂ।ਪਹਿਲਾਂ ਇੱਕ। ਕ੍ਰਿਪਾ ਕਰਕੇ ਮੈਨੂੰ ਕੋਟਲਿਨ ਐਂਡਰਾਇਡ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਦਿਖਾਓ? \', "ਮੈਂ ਮੁਆਫੀ ਮੰਗਦਾ ਹਾਂ, ਪਰ ਮੈਨੂੰ ਯਕੀਨ ਨਹੀਂ ਹੈ ਕਿ ਤੁਸੀਂ ਕੀ ਮੰਗ ਰਹੇ ਹੋ। ਕੀ ਤੁਸੀਂ ਕਿਰਪਾ ਕਰਕੇ ਕੁਝ ਹੋਰ ਪ੍ਰਸੰਗ ਪ੍ਰਦਾਨ ਕਰ ਸਕਦੇ ਹੋ ਜਾਂਤੁਸੀਂ ਕੀ ਪੂਰਾ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਹੇ ਹੋ ਇਸ ਬਾਰੇ ਜਾਣਕਾਰੀ?, \'ਇੱਥੇ ਸਿਰਫ ਇੱਕ ਪ੍ਰਵਾਹ ਹੈ ਅਤੇ ਮੈਂ ਪਹਿਲੇ ਤੋਂ ਆਪਣਾ ਦੂਜਾ ਪ੍ਰਵਾਹ ਬਣਾਉਣਾ ਚਾਹੁੰਦਾ ਹਾਂ। ਕਿਰਪਾ ਕਰਕੇ ਮੈਨੂੰ ਦਿਖਾਓਕੋਟਲਿਨ ਐਂਡਰਾਇਡ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ? \' ', 'ਮੇਰੇ ਕੋਲ flow.map {ਮੁੱਲ-> ਪਰਿਵਰਤਨ ()}. onEach {} ਹੈ। onEach ਕੀ ਕਰਦਾ ਹੈ? \n ']