ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਇੱਕ ਹੱਲ ਦੇ ਸਕਦੇ ਹੋ ਜੋ NAME _ 1 ਕੋਡ ਵਿੱਚ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਤੋਂ ਇੱਕ ਗੁੰਝਲਦਾਰ XML ਸਮੱਗਰੀ ਨੂੰ ਮਿਲਾਉਂਦਾ ਹੈ ਅਤੇ ਕੱਢਦਾ ਹੈ?' ", 'ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਇੱਕ ਹੱਲ ਦੇ ਸਕਦੇ ਹੋ ਜੋ NAME _ 1 ਕੋਡ ਵਿੱਚ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਤੋਂ ਇੱਕ ਗੁੰਝਲਦਾਰ XML ਸਮੱਗਰੀ ਨੂੰ ਮਿਲਾਉਂਦਾ ਹੈ ਅਤੇ ਕੱਢਦਾ ਹੈ?', ' [\'ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਇੱਕ ਹੱਲ ਦੇ ਸਕਦੇ ਹੋ ਜੋ ਨਾਮ _ 1 ਕੋਡ ਵਿੱਚ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਤੋਂ ਇੱਕ ਗੁੰਝਲਦਾਰ ਐਕਸ. ਐੱਮ. ਐੱਲ. ਸਮੱਗਰੀ ਨੂੰ ਮਿਲਾਉਂਦਾ ਹੈ ਅਤੇ ਕੱਢਦਾ ਹੈ?\', \'ਜ਼ਰੂਰ, ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਨਾਮ _ 1?ਕੋਡ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਇੱਕ ਗੁੰਝਲਦਾਰ XML ਸਮੱਗਰੀ ਤੋਂ ਡੇਟਾ ਨੂੰ ਕਿਵੇਂ ਪਾਰਸ ਅਤੇ ਐਕਸਟਰੈਕਟ ਕਰਨਾ ਹੈ ਜੋ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਫਾਰਮੈਟ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਗਿਆ ਹੈਃ \\n \'\' NAME _ 1 \'NAME_1.util.List; \\nimਪੋਰ੍ਟ javax.xml.parsers.DocumentBuilder ਫੈਕਟਰੀ; \\nimਪੋਰ੍ਟ javax.xml.parsers.DocumentBuilder; \\nimਪੋਰਟjavax.xml.parsers.ParserConfigurationException; \\nimports org.w3c.dom.Document; \\nimports org.w3c.dom.Element; \\nimports org.w3c.dom.NodeList; \\nimportsNAME_1.util.ArrayList; \\nimport NAME_1.util.Collections; \\n\\nਪਬਲਿਕ ਕਲਾਸ XMLParser {\\n ਪਬਲਿਕ ਸਟੈਟਿਕ ਵੋਇਡ ਪਾਰਸਟੈਕਸਟ ਟੂਐਕਸਐੱਮਐੱਲ (NAME _ 2 ਟੈਕਸਟ, NAME _ 2)ਤੱਤ ਨਾਮ, ਨਾਮ _ 2 ਗੁਣ ਨਾਮ, ਨਾਮ _ 2 ਗੁਣ ਮੁੱਲ) ਪਾਰਸਰ ਕਨਫਿਗਰੇਸ਼ਨ ਐਕਸੈਪਸ਼ਨ {\\n ਡੌਕੂਮੈਂਟਬਿਲਡਰਫੈਕਟਰੀ ਫੈਕਟਰੀ = ਸੁੱਟਦਾ ਹੈDocumentBuilderFactory.newInstance (); \\n ਡੌਕੂਮੈਂਟ ਬਿਲਡਰ ਬਿਲਡਰ = factory.newDocumentBuilder (); \\n ਡੌਕੂਮੈਂਟ ਡੌਕ = builder.newDocument (); \\n ਐਲੀਮੈਂਟ ਰੂਟ= doc.createElement (ਤੱਤ-ਨਾਮ); \\n doc.appendChild (ਰੂਟ); \\n NAME _ 2 [] ਹਿੱਸੇ = text.split ("\\\\\\\\s +"); \\n ਲਈ (ਇੰਟ i = 0; i <parts.length; i + +) {\\nਤੱਤ ਤੱਤ = doc.createElement ("ਆਈਟਮ"); \\n element.setAttribute (ਗੁਣ-ਨਾਮ, ਗੁਣ-ਮੁੱਲ); \\n element.setAttribute ("ਮੁੱਲ", ਹਿੱਸੇ [i]); \\nroot.appendChild (ਤੱਤ); \\n} \\n System.out.println (doc.XMLOutput.toString ()); \\n} \\n\\n ਪਬਲਿਕ ਸਟੈਟਿਕ ਵੋਇਡ ਮੇਨ (NAME _ 2 [] ਆਰਗਸ) {\\n NAME _ 2 ਟੈਕਸਟ ="ਐਪਲ ਕੇਲੇ ਦਾ ਸੰਤਰੀ ਕੀਵੀ ਪੀਅਰ"; \\n ਨਾਮ _ 2 ਤੱਤ ਨਾਮ = "ਆਈਟਮ"; \\n ਨਾਮ _ 2 ਗੁਣ ਨਾਮ = "ਮੁੱਲ"; \\n ਨਾਮ _ 2 ਗੁਣ ਮੁੱਲ = "ਟੈਕਸਟ"; \\n ਕੋਸ਼ਿਸ਼ ਕਰੋ {\\nਪਾਰਸ ਟੈਕਸਟ ਟੂਐਕਸਐੱਮਐੱਲ (ਟੈਕਸਟ, ਤੱਤ-ਨਾਮ, ਗੁਣ-ਨਾਮ, ਗੁਣ-ਮੁੱਲ); \\n} ਕੈਚ (ਪਾਰਸਰ ਕਨਫਿਗਰੇਸ਼ਨ ਐਕਸੈਪਸ਼ਨ ਈ) {\\n e.printStackTrace (); \\n} \\n} \\n} \\n "\\n ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਸਾਡੇ ਕੋਲ ਇੱਕ ਢੰਗ ਹੈ \'ਪਾਰਸਟੈਕਸਟ ਟੂਐਕਸਐੱਮਐੱਲ ()\' ਜੋ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਨਾਮ _ 2, ਇੱਕ ਤੱਤ ਨਾਮ, ਇੱਕ ਗੁਣ ਨਾਮ, ਅਤੇ ਇੱਕ ਵਿੱਚ ਲੈਂਦਾ ਹੈ।ਗੁਣ ਮੁੱਲ ਮਾਪਦੰਡਾਂ ਦੇ ਰੂਪ ਵਿੱਚ। ਇਹ ਫਿਰ \'ਡੌਕੂਮੈਂਟ ਬਿਲਡਰਫੈਕਟਰੀ\' ਅਤੇ \'ਡੌਕੂਮੈਂਟ ਬਿਲਡਰ\' ਕਲਾਸਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਟੈਕਸਟ ਨੂੰ ਇੱਕ XML ਡੌਕੂਮੈਂਟ ਵਿੱਚ ਪਾਰਸ ਕਰਦਾ ਹੈ। \\n\\n\'ਤੱਤ ਨਾਮ\' ਪੈਰਾਮੀਟਰ ਉਸ ਤੱਤ ਦਾ ਨਾਮ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ \'ਪਲੇਨ\' ਹੁੰਦਾ ਹੈ, \'ਮੈਨੂੰ ਇੱਕ ਹੱਲ ਦਿਓ ਜੋ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਤੋਂ XML ਸਮੱਗਰੀ ਨੂੰ ਲੱਭਦਾ ਹੈਨਾਮ _ 1 ਕੋਡ ਵਿੱਚ ਰੀਜੈਕਸ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ? \'] ', 'ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਇੱਕ ਹੱਲ ਦੇ ਸਕਦੇ ਹੋ ਜੋ NAME _ 1 ਕੋਡ ਵਿੱਚ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਤੋਂ ਇੱਕ ਗੁੰਝਲਦਾਰ XML ਸਮੱਗਰੀ ਨੂੰ ਮਿਲਾਉਂਦਾ ਹੈ ਅਤੇ ਕੱਢਦਾ ਹੈ?', ' [\'ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਇੱਕ ਹੱਲ ਦੇ ਸਕਦੇ ਹੋ ਜੋ ਨਾਮ _ 1 ਕੋਡ ਵਿੱਚ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਤੋਂ ਇੱਕ ਗੁੰਝਲਦਾਰ ਐਕਸ. ਐੱਮ. ਐੱਲ. ਸਮੱਗਰੀ ਨੂੰ ਮਿਲਾਉਂਦਾ ਹੈ ਅਤੇ ਕੱਢਦਾ ਹੈ?\', \'ਜ਼ਰੂਰ, ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਨਾਮ _ 1?ਕੋਡ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਇੱਕ ਗੁੰਝਲਦਾਰ XML ਸਮੱਗਰੀ ਤੋਂ ਡੇਟਾ ਨੂੰ ਕਿਵੇਂ ਪਾਰਸ ਅਤੇ ਐਕਸਟਰੈਕਟ ਕਰਨਾ ਹੈ ਜੋ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਫਾਰਮੈਟ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਗਿਆ ਹੈਃ \\n \'\' NAME _ 1 \'NAME_1.util.List; \\nimਪੋਰ੍ਟ javax.xml.parsers.DocumentBuilder ਫੈਕਟਰੀ; \\nimਪੋਰ੍ਟ javax.xml.parsers.DocumentBuilder; \\nimਪੋਰਟjavax.xml.parsers.ParserConfigurationException; \\nimports org.w3c.dom.Document; \\nimports org.w3c.dom.Element; \\nimports org.w3c.dom.NodeList; \\nimportsNAME_1.util.ArrayList; \\nimport NAME_1.util.Collections; \\n\\nਪਬਲਿਕ ਕਲਾਸ XMLParser {\\n ਪਬਲਿਕ ਸਟੈਟਿਕ ਵੋਇਡ ਪਾਰਸਟੈਕਸਟ ਟੂਐਕਸਐੱਮਐੱਲ (NAME _ 2 ਟੈਕਸਟ, NAME _ 2)ਤੱਤ ਨਾਮ, ਨਾਮ _ 2 ਗੁਣ ਨਾਮ, ਨਾਮ _ 2 ਗੁਣ ਮੁੱਲ) ਪਾਰਸਰ ਕਨਫਿਗਰੇਸ਼ਨ ਐਕਸੈਪਸ਼ਨ {\\n ਡੌਕੂਮੈਂਟਬਿਲਡਰਫੈਕਟਰੀ ਫੈਕਟਰੀ = ਸੁੱਟਦਾ ਹੈDocumentBuilderFactory.newInstance (); \\n ਡੌਕੂਮੈਂਟ ਬਿਲਡਰ ਬਿਲਡਰ = factory.newDocumentBuilder (); \\n ਡੌਕੂਮੈਂਟ ਡੌਕ = builder.newDocument (); \\n ਐਲੀਮੈਂਟ ਰੂਟ= doc.createElement (ਤੱਤ-ਨਾਮ); \\n doc.appendChild (ਰੂਟ); \\n NAME _ 2 [] ਹਿੱਸੇ = text.split ("\\\\\\\\s +"); \\n ਲਈ (ਇੰਟ i = 0; i <parts.length; i + +) {\\nਤੱਤ ਤੱਤ = doc.createElement ("ਆਈਟਮ"); \\n element.setAttribute (ਗੁਣ-ਨਾਮ, ਗੁਣ-ਮੁੱਲ); \\n element.setAttribute ("ਮੁੱਲ", ਹਿੱਸੇ [i]); \\nroot.appendChild (ਤੱਤ); \\n} \\n System.out.println (doc.XMLOutput.toString ()); \\n} \\n\\n ਪਬਲਿਕ ਸਟੈਟਿਕ ਵੋਇਡ ਮੇਨ (NAME _ 2 [] ਆਰਗਸ) {\\n NAME _ 2 ਟੈਕਸਟ ="ਐਪਲ ਕੇਲੇ ਦਾ ਸੰਤਰੀ ਕੀਵੀ ਪੀਅਰ"; \\n ਨਾਮ _ 2 ਤੱਤ ਨਾਮ = "ਆਈਟਮ"; \\n ਨਾਮ _ 2 ਗੁਣ ਨਾਮ = "ਮੁੱਲ"; \\n ਨਾਮ _ 2 ਗੁਣ ਮੁੱਲ = "ਟੈਕਸਟ"; \\n ਕੋਸ਼ਿਸ਼ ਕਰੋ {\\nਪਾਰਸ ਟੈਕਸਟ ਟੂਐਕਸਐੱਮਐੱਲ (ਟੈਕਸਟ, ਤੱਤ-ਨਾਮ, ਗੁਣ-ਨਾਮ, ਗੁਣ-ਮੁੱਲ); \\n} ਕੈਚ (ਪਾਰਸਰ ਕਨਫਿਗਰੇਸ਼ਨ ਐਕਸੈਪਸ਼ਨ ਈ) {\\n e.printStackTrace (); \\n} \\n} \\n} \\n "\\n ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਸਾਡੇ ਕੋਲ ਇੱਕ ਢੰਗ ਹੈ \'ਪਾਰਸਟੈਕਸਟ ਟੂਐਕਸਐੱਮਐੱਲ ()\' ਜੋ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਨਾਮ _ 2, ਇੱਕ ਤੱਤ ਨਾਮ, ਇੱਕ ਗੁਣ ਨਾਮ, ਅਤੇ ਇੱਕ ਵਿੱਚ ਲੈਂਦਾ ਹੈ।ਗੁਣ ਮੁੱਲ ਮਾਪਦੰਡਾਂ ਦੇ ਰੂਪ ਵਿੱਚ। ਇਹ ਫਿਰ \'ਡੌਕੂਮੈਂਟ ਬਿਲਡਰਫੈਕਟਰੀ\' ਅਤੇ \'ਡੌਕੂਮੈਂਟ ਬਿਲਡਰ\' ਕਲਾਸਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਟੈਕਸਟ ਨੂੰ ਇੱਕ XML ਡੌਕੂਮੈਂਟ ਵਿੱਚ ਪਾਰਸ ਕਰਦਾ ਹੈ। \\n\\n\'ਤੱਤ ਨਾਮ\' ਪੈਰਾਮੀਟਰ ਉਸ ਤੱਤ ਦਾ ਨਾਮ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ \'ਪਲੇਨ\' ਹੁੰਦਾ ਹੈ, \'ਮੈਨੂੰ ਇੱਕ ਹੱਲ ਦਿਓ ਜੋ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਤੋਂ XML ਸਮੱਗਰੀ ਨੂੰ ਲੱਭਦਾ ਹੈ\',\' ਜ਼ਰੂਰ, ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ NAME _ 1 ਕੋਡ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਨਿਯਮਤ ਵਰਤੋਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਤੋਂ XML ਸਮੱਗਰੀ ਨੂੰ ਕਿਵੇਂ ਕੱਢਿਆ ਜਾਵੇ?ਸਮੀਕਰਨਃ \'\\n\' \'NAME _ 1 \\nimport NAME_1.util.regex.Matcher; \\nimport NAME_1.util.regex.Pattern; \\n\\nਪਬਲਿਕ ਕਲਾਸ XMLEXTractor {\\n ਪਬਲਿਕ ਸਟੈਟਿਕ ਵੋਇਡਮੁੱਖ (ਨਾਮ _ 2 [] ਆਰਗਸ) {\\n ਨਾਮ _ 2 ਪਲੇਨਟੈਕਸਟ = "ਇਹ ਕੁੱਝ ਸਧਾਰਨ ਟੈਕਸਟ ਸਮੱਗਰੀ ਹੈ। ਹੇਠਾਂ ਇੱਕ XML ਸਮੱਗਰੀ ਹੈਃ<ਆਈਟਮ> ਸੇਬ </ਆਈਟਮ> <ਆਈਟਮ> ਕੇਲਾ </ਆਈਟਮ> <ਆਈਟਮ> ਸੰਤਰੀ </ਆਈਟਮ> "; \\n NAME _ 2 xMLRagex =" (? s) "= Pattern.compile (xملਰੇਗੈਕਸ, Pattern.DOTALL); \\n ਮੈਚਰ ਮੈਚਰ = pattern.matcher (ਪਲੇਨਟੈਕਸਟ); \\n ਜੇਕਰ (matcher.find ()) {\\nSystem.out.println (matcher.group ()); \\n} \\n} \\n "\'\\n ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਸਾਡੇ ਕੋਲ ਇੱਕ ਵਿਧੀ\' ਮੈਨ () \'ਹੈ ਜੋ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਵਿੱਚ NAME _ 2 ਨੂੰ ਇੰਪੁੱਟ ਵਜੋਂ ਲੈਂਦੀ ਹੈ। ਅਸੀਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂਇੱਕ ਨਿਯਮਤ ਸਮੀਕਰਨ ਪੈਟਰਨ \'xmlRegex\' ਜੋ ਸਾਦੇ ਟੈਕਸਟ ਵਿੱਚ ਕਿਸੇ ਵੀ XML ਸਮੱਗਰੀ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਪੈਟਰਨ ਡਾਟ-ਆਲ ਮੋਡ ਨੂੰ ਸਮਰੱਥ ਕਰਨ ਲਈ \'(? s)\' ਫਲੈਗ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ\'.\' ਅੱਖਰ ਨੂੰ ਨਵੀਂ ਲਾਈਨ ਅੱਖਰਾਂ ਸਮੇਤ ਕਿਸੇ ਵੀ ਅੱਖਰ ਨਾਲ ਮੇਲ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਪੈਟਰਨ ਫਿਰ ਇੱਕ XML ਤੱਤ ਦੇ ਖੁੱਲ੍ਹਣ ਅਤੇ ਬੰਦ ਹੋਣ ਵਾਲੇ ਟੈਗ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ,ਅਤੇ ਟੈਗ ਦੇ ਵਿਚਕਾਰ ਟੈਕਸਟ ਸਮੱਗਰੀ। ਮੇਲ ਖਾਂਦੀ ਸਮੱਗਰੀ ਨੂੰ \'ਮੈਚਰ\' ਆਬਜੈਕਟ ਦੇ \'ਗਰੁੱਪ ()\' ਢੰਗ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੱਢਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਨਿਯਮਿਤ ਹੈਸਮੀਕਰਨ ਪੈਟਰਨ ਇਹ ਮੰਨਦਾ ਹੈ ਕਿ XML ਸਮੱਗਰੀ ਨੂੰ ਟੈਗ ਖੋਲ੍ਹਣ ਅਤੇ ਬੰਦ ਕਰਨ ਦੇ ਨਾਲ ਸਹੀ ਢੰਗ ਨਾਲ ਫਾਰਮੈਟ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਉਹਨਾਂ ਦੇ ਵਿਚਕਾਰ ਕੁਝ ਟੈਕਸਟ ਸਮੱਗਰੀ ਹੈ।ਐਕਸ. ਐੱਮ. ਐੱਲ. ਸਮੱਗਰੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਤਿਆਰ ਨਹੀਂ ਹੈ ਜਾਂ ਇਸ ਵਿੱਚ ਟਿੱਪਣੀਆਂ ਜਾਂ ਪ੍ਰੋਸੈਸਿੰਗ ਨਿਰਦੇਸ਼ ਸ਼ਾਮਲ ਹਨ, ਨਿਯਮਤ ਸਮੀਕਰਨ ਪੈਟਰਨ ਨੂੰ ਐਡਜਸਟ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋ ਸਕਦੀ ਹੈ।\',\' NAME _ 1 ਕੋਡ ਵਿੱਚ ਨਿਯਮਤ ਸਮੀਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ XML ਸਮੱਗਰੀ ਨੂੰ ਕਿਵੇਂ ਮਿਲਾਉਣਾ ਹੈ \'] ', 'ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਇੱਕ ਹੱਲ ਦੇ ਸਕਦੇ ਹੋ ਜੋ NAME _ 1 ਕੋਡ ਵਿੱਚ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਤੋਂ ਇੱਕ ਗੁੰਝਲਦਾਰ XML ਸਮੱਗਰੀ ਨੂੰ ਮਿਲਾਉਂਦਾ ਹੈ ਅਤੇ ਕੱਢਦਾ ਹੈ?', ' [\'ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਇੱਕ ਹੱਲ ਦੇ ਸਕਦੇ ਹੋ ਜੋ ਨਾਮ _ 1 ਕੋਡ ਵਿੱਚ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਤੋਂ ਇੱਕ ਗੁੰਝਲਦਾਰ ਐਕਸ. ਐੱਮ. ਐੱਲ. ਸਮੱਗਰੀ ਨੂੰ ਮਿਲਾਉਂਦਾ ਹੈ ਅਤੇ ਕੱਢਦਾ ਹੈ?\', \'ਜ਼ਰੂਰ, ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਨਾਮ _ 1?ਕੋਡ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਇੱਕ ਗੁੰਝਲਦਾਰ XML ਸਮੱਗਰੀ ਤੋਂ ਡੇਟਾ ਨੂੰ ਕਿਵੇਂ ਪਾਰਸ ਅਤੇ ਐਕਸਟਰੈਕਟ ਕਰਨਾ ਹੈ ਜੋ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਫਾਰਮੈਟ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਗਿਆ ਹੈਃ \\n \'\' NAME _ 1 \'NAME_1.util.List; \\nimਪੋਰ੍ਟ javax.xml.parsers.DocumentBuilder ਫੈਕਟਰੀ; \\nimਪੋਰ੍ਟ javax.xml.parsers.DocumentBuilder; \\nimਪੋਰਟjavax.xml.parsers.ParserConfigurationException; \\nimports org.w3c.dom.Document; \\nimports org.w3c.dom.Element; \\nimports org.w3c.dom.NodeList; \\nimportsNAME_1.util.ArrayList; \\nimport NAME_1.util.Collections; \\n\\nਪਬਲਿਕ ਕਲਾਸ XMLParser {\\n ਪਬਲਿਕ ਸਟੈਟਿਕ ਵੋਇਡ ਪਾਰਸਟੈਕਸਟ ਟੂਐਕਸਐੱਮਐੱਲ (NAME _ 2 ਟੈਕਸਟ, NAME _ 2)ਤੱਤ ਨਾਮ, ਨਾਮ _ 2 ਗੁਣ ਨਾਮ, ਨਾਮ _ 2 ਗੁਣ ਮੁੱਲ) ਪਾਰਸਰ ਕਨਫਿਗਰੇਸ਼ਨ ਐਕਸੈਪਸ਼ਨ {\\n ਡੌਕੂਮੈਂਟਬਿਲਡਰਫੈਕਟਰੀ ਫੈਕਟਰੀ = ਸੁੱਟਦਾ ਹੈDocumentBuilderFactory.newInstance (); \\n ਡੌਕੂਮੈਂਟ ਬਿਲਡਰ ਬਿਲਡਰ = factory.newDocumentBuilder (); \\n ਡੌਕੂਮੈਂਟ ਡੌਕ = builder.newDocument (); \\n ਐਲੀਮੈਂਟ ਰੂਟ= doc.createElement (ਤੱਤ-ਨਾਮ); \\n doc.appendChild (ਰੂਟ); \\n NAME _ 2 [] ਹਿੱਸੇ = text.split ("\\\\\\\\s +"); \\n ਲਈ (ਇੰਟ i = 0; i <parts.length; i + +) {\\nਤੱਤ ਤੱਤ = doc.createElement ("ਆਈਟਮ"); \\n element.setAttribute (ਗੁਣ-ਨਾਮ, ਗੁਣ-ਮੁੱਲ); \\n element.setAttribute ("ਮੁੱਲ", ਹਿੱਸੇ [i]); \\nroot.appendChild (ਤੱਤ); \\n} \\n System.out.println (doc.XMLOutput.toString ()); \\n} \\n\\n ਪਬਲਿਕ ਸਟੈਟਿਕ ਵੋਇਡ ਮੇਨ (NAME _ 2 [] ਆਰਗਸ) {\\n NAME _ 2 ਟੈਕਸਟ ="ਐਪਲ ਕੇਲੇ ਦਾ ਸੰਤਰੀ ਕੀਵੀ ਪੀਅਰ"; \\n ਨਾਮ _ 2 ਤੱਤ ਨਾਮ = "ਆਈਟਮ"; \\n ਨਾਮ _ 2 ਗੁਣ ਨਾਮ = "ਮੁੱਲ"; \\n ਨਾਮ _ 2 ਗੁਣ ਮੁੱਲ = "ਟੈਕਸਟ"; \\n ਕੋਸ਼ਿਸ਼ ਕਰੋ {\\nਪਾਰਸ ਟੈਕਸਟ ਟੂਐਕਸਐੱਮਐੱਲ (ਟੈਕਸਟ, ਤੱਤ-ਨਾਮ, ਗੁਣ-ਨਾਮ, ਗੁਣ-ਮੁੱਲ); \\n} ਕੈਚ (ਪਾਰਸਰ ਕਨਫਿਗਰੇਸ਼ਨ ਐਕਸੈਪਸ਼ਨ ਈ) {\\n e.printStackTrace (); \\n} \\n} \\n} \\n "\\n ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਸਾਡੇ ਕੋਲ ਇੱਕ ਢੰਗ ਹੈ \'ਪਾਰਸਟੈਕਸਟ ਟੂਐਕਸਐੱਮਐੱਲ ()\' ਜੋ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਨਾਮ _ 2, ਇੱਕ ਤੱਤ ਨਾਮ, ਇੱਕ ਗੁਣ ਨਾਮ, ਅਤੇ ਇੱਕ ਵਿੱਚ ਲੈਂਦਾ ਹੈ।ਗੁਣ ਮੁੱਲ ਮਾਪਦੰਡਾਂ ਦੇ ਰੂਪ ਵਿੱਚ। ਇਹ ਫਿਰ \'ਡੌਕੂਮੈਂਟ ਬਿਲਡਰਫੈਕਟਰੀ\' ਅਤੇ \'ਡੌਕੂਮੈਂਟ ਬਿਲਡਰ\' ਕਲਾਸਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਟੈਕਸਟ ਨੂੰ ਇੱਕ XML ਡੌਕੂਮੈਂਟ ਵਿੱਚ ਪਾਰਸ ਕਰਦਾ ਹੈ। \\n\\n\'ਤੱਤ ਨਾਮ\' ਪੈਰਾਮੀਟਰ ਉਸ ਤੱਤ ਦਾ ਨਾਮ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ \'ਪਲੇਨ\' ਹੁੰਦਾ ਹੈ, \'ਮੈਨੂੰ ਇੱਕ ਹੱਲ ਦਿਓ ਜੋ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਤੋਂ XML ਸਮੱਗਰੀ ਨੂੰ ਲੱਭਦਾ ਹੈ\',\' ਜ਼ਰੂਰ, ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ NAME _ 1 ਕੋਡ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਨਿਯਮਤ ਵਰਤੋਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਤੋਂ XML ਸਮੱਗਰੀ ਨੂੰ ਕਿਵੇਂ ਕੱਢਿਆ ਜਾਵੇ?ਸਮੀਕਰਨਃ \'\\n\' \'NAME _ 1 \\nimport NAME_1.util.regex.Matcher; \\nimport NAME_1.util.regex.Pattern; \\n\\nਪਬਲਿਕ ਕਲਾਸ XMLEXTractor {\\n ਪਬਲਿਕ ਸਟੈਟਿਕ ਵੋਇਡਮੁੱਖ (ਨਾਮ _ 2 [] ਆਰਗਸ) {\\n ਨਾਮ _ 2 ਪਲੇਨਟੈਕਸਟ = "ਇਹ ਕੁੱਝ ਸਧਾਰਨ ਟੈਕਸਟ ਸਮੱਗਰੀ ਹੈ। ਹੇਠਾਂ ਇੱਕ XML ਸਮੱਗਰੀ ਹੈਃ<ਆਈਟਮ> ਸੇਬ </ਆਈਟਮ> <ਆਈਟਮ> ਕੇਲਾ </ਆਈਟਮ> <ਆਈਟਮ> ਸੰਤਰੀ </ਆਈਟਮ> "; \\n NAME _ 2 xMLRagex =" (? s) "= Pattern.compile (xملਰੇਗੈਕਸ, Pattern.DOTALL); \\n ਮੈਚਰ ਮੈਚਰ = pattern.matcher (ਪਲੇਨਟੈਕਸਟ); \\n ਜੇਕਰ (matcher.find ()) {\\nSystem.out.println (matcher.group ()); \\n} \\n} \\n "\'\\n ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਸਾਡੇ ਕੋਲ ਇੱਕ ਵਿਧੀ\' ਮੈਨ () \'ਹੈ ਜੋ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਵਿੱਚ NAME _ 2 ਨੂੰ ਇੰਪੁੱਟ ਵਜੋਂ ਲੈਂਦੀ ਹੈ। ਅਸੀਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂਇੱਕ ਨਿਯਮਤ ਸਮੀਕਰਨ ਪੈਟਰਨ \'xmlRegex\' ਜੋ ਸਾਦੇ ਟੈਕਸਟ ਵਿੱਚ ਕਿਸੇ ਵੀ XML ਸਮੱਗਰੀ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਪੈਟਰਨ ਡਾਟ-ਆਲ ਮੋਡ ਨੂੰ ਸਮਰੱਥ ਕਰਨ ਲਈ \'(? s)\' ਫਲੈਗ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ\'.\' ਅੱਖਰ ਨੂੰ ਨਵੀਂ ਲਾਈਨ ਅੱਖਰਾਂ ਸਮੇਤ ਕਿਸੇ ਵੀ ਅੱਖਰ ਨਾਲ ਮੇਲ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਪੈਟਰਨ ਫਿਰ ਇੱਕ XML ਤੱਤ ਦੇ ਖੁੱਲ੍ਹਣ ਅਤੇ ਬੰਦ ਹੋਣ ਵਾਲੇ ਟੈਗ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ,ਅਤੇ ਟੈਗ ਦੇ ਵਿਚਕਾਰ ਟੈਕਸਟ ਸਮੱਗਰੀ। ਮੇਲ ਖਾਂਦੀ ਸਮੱਗਰੀ ਨੂੰ \'ਮੈਚਰ\' ਆਬਜੈਕਟ ਦੇ \'ਗਰੁੱਪ ()\' ਢੰਗ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੱਢਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਨਿਯਮਿਤ ਹੈਸਮੀਕਰਨ ਪੈਟਰਨ ਇਹ ਮੰਨਦਾ ਹੈ ਕਿ XML ਸਮੱਗਰੀ ਨੂੰ ਟੈਗ ਖੋਲ੍ਹਣ ਅਤੇ ਬੰਦ ਕਰਨ ਦੇ ਨਾਲ ਸਹੀ ਢੰਗ ਨਾਲ ਫਾਰਮੈਟ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਉਹਨਾਂ ਦੇ ਵਿਚਕਾਰ ਕੁਝ ਟੈਕਸਟ ਸਮੱਗਰੀ ਹੈ।ਐਕਸ. ਐੱਮ. ਐੱਲ. ਸਮੱਗਰੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਤਿਆਰ ਨਹੀਂ ਹੈ ਜਾਂ ਇਸ ਵਿੱਚ ਟਿੱਪਣੀਆਂ ਜਾਂ ਪ੍ਰੋਸੈਸਿੰਗ ਨਿਰਦੇਸ਼ ਸ਼ਾਮਲ ਹਨ, ਨਿਯਮਤ ਸਮੀਕਰਨ ਪੈਟਰਨ ਨੂੰ ਐਡਜਸਟ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋ ਸਕਦੀ ਹੈ।\',\' NAME _ 1 ਕੋਡ ਵਿੱਚ ਨਿਯਮਤ ਸਮੀਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ XML ਸਮੱਗਰੀ ਨੂੰ ਕਿਵੇਂ ਮਿਲਾਉਣਾ ਹੈ \',\' NAME _ 1 ਵਿੱਚ ਨਿਯਮਤ ਸਮੀਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ XML ਸਮੱਗਰੀ ਨੂੰ ਮਿਲਾਉਣ ਲਈ, ਤੁਸੀਂ\'ਪੈਟਰਨ\' ਅਤੇ \'ਮੈਚਰ\' ਕਲਾਸਾਂ ਦੀ ਵਰਤੋਂ ਇੱਕ ਪੈਟਰਨ ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਜੋ XML ਸਮੱਗਰੀ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ ਅਤੇ ਫਿਰ ਪੈਟਰਨ ਦੀ ਖੋਜ ਕਰਨ ਲਈ \'ਮੈਚਰ ()\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦਾ ਹੈ।ਇੱਕ NAME _ 2 ਵਿੱਚ. \\n\\n ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ NAME _ 1 ਕੋਡ ਹੈ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਨਿਯਮਤ ਸਮੀਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ XML ਸਮੱਗਰੀ ਨੂੰ ਕਿਵੇਂ ਮਿਲਾਉਣਾ ਹੈਃ \\n \'\' NAME _ 1\\ਨਿਮਪੋਰਟNAME_1.util.regex.Matcher; \\nimport NAME_1.util.regex.Pattern; \\n\\nਪਬਲਿਕ ਕਲਾਸ XMLRegex {\\n ਪਬਲਿਕ ਸਟੈਟਿਕ ਵਾਇਲਡ ਮੇਨ (NAME _ 2 [] ਆਰਗਸ) {\\n NAME _ 2 ਪਲੇਨਟੈਕਸਟ= "ਇਹ ਕੁੱਝ ਸਧਾਰਨ ਪਾਠ ਸਮੱਗਰੀ ਹੈ। ਹੇਠਾਂ ਇੱਕ XML ਸਮੱਗਰੀ ਹੈਃ <ਆਈਟਮ> ਐਪਲ </ਆਈਟਮ> <ਆਈਟਮ> ਕੇਲਾ </ਆਈਟਮ> <ਆਈਟਮ> ਸੰਤਰੀ </ਆਈਟਮ>"; \\n NAME _ 2 xmlRegex ="(? s) <\\\\\\\\w +\\\\\\\\s +\\\\w +\\\\s +\\\\w + [^>] *>\\\\s *. *? <\\\\ \\w +\\\\s +\\\\ \\w +\\\\\\\\s +\\\\\\\\w +\\\\\\\\"; \\n ਪੈਟਰਨ = Pattern.compile (xmlR\u0a46ਗ\u0a46ਕਸ, Pattern.DOTALL); \\nਮੈਚਰ ਮੈਚਰ = pattern.matcher (ਪਲੇਨਟੈਕਸਟ); \\n ਜੇਕਰ (matcher.find ()) {\\n System.out.println (matcher.group ()); \\n} \\n} \\n "\\n" ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਅਸੀਂਇੱਕ ਨਿਯਮਿਤ ਸਮੀਕਰਨ ਪੈਟਰਨ \'xmlRegex\' ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜੋ ਸਾਦੇ ਟੈਕਸਟ ਵਿੱਚ ਕਿਸੇ ਵੀ XML ਸਮੱਗਰੀ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਪੈਟਰਨ ਡਾਟ-ਆਲ ਨੂੰ ਸਮਰੱਥ ਕਰਨ ਲਈ \'(? s)\' ਫਲੈਗ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਮੋਡ, ਜੋ \'.\' ਅੱਖਰ ਨੂੰ ਨਵੀਂ ਲਾਈਨ ਅੱਖਰਾਂ ਸਮੇਤ ਕਿਸੇ ਵੀ ਅੱਖਰ ਨਾਲ ਮੇਲ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਪੈਟਰਨ ਫਿਰ ਇੱਕ ਅੱਖਰ ਦੇ ਖੁੱਲ੍ਹਣ ਅਤੇ ਬੰਦ ਹੋਣ ਵਾਲੇ ਟੈਗ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ।XML ਤੱਤ ਅਤੇ ਟੈਗ ਦੇ ਵਿਚਕਾਰ ਟੈਕਸਟ ਸਮੱਗਰੀ। \'ਪੈਟਰਨ\' ਕਲਾਸ ਦਾ \'ਮੈਚਰ ()\' ਢੰਗ ਫਿਰ ਸਾਦੇ ਵਿੱਚ ਪੈਟਰਨ ਦੀ ਖੋਜ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।ਪਾਠ ਨਾਮ _ 2, ਅਤੇ ਮੇਲ ਖਾਂਦੀ ਸਮੱਗਰੀ ਨੂੰ \'ਮੈਚਰ\' ਆਬਜੈਕਟ ਦੇ \'ਗਰੁੱਪ ()\' ਢੰਗ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੱਢਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਨਿਯਮਤ ਸਮੀਕਰਨ ਪੈਟਰਨ ਹੈ।ਇਹ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ ਕਿ XML ਸਮੱਗਰੀ ਨੂੰ ਟੈਗ ਖੋਲ੍ਹਣ ਅਤੇ ਬੰਦ ਕਰਨ ਦੇ ਨਾਲ ਸਹੀ ਢੰਗ ਨਾਲ ਫਾਰਮੈਟ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਉਹਨਾਂ ਦੇ ਵਿਚਕਾਰ ਕੁਝ ਟੈਕਸਟ ਸਮੱਗਰੀ ਹੈ। ਜੇਕਰ XML ਸਮੱਗਰੀ ਹੈਚੰਗੀ ਤਰ੍ਹਾਂ ਤਿਆਰ ਨਹੀਂ ਹੈ ਜਾਂ ਟਿੱਪਣੀਆਂ ਜਾਂ ਪ੍ਰੋਸੈਸਿੰਗ ਨਿਰਦੇਸ਼ ਸ਼ਾਮਲ ਨਹੀਂ ਹਨ, ਨਿਯਮਤ ਸਮੀਕਰਨ ਪੈਟਰਨ ਨੂੰ ਉਸ ਅਨੁਸਾਰ ਐਡਜਸਟ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋ ਸਕਦੀ ਹੈ।ਨਿਯਮਿਤ ਸਮੀਕਰਨ ਜਿਸ ਦੀ ਵਰਤੋਂ ਇੱਕ ਗੁੰਝਲਦਾਰ XML ਨਾਲ ਮੇਲ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ? ', 'ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਇੱਕ ਹੱਲ ਦੇ ਸਕਦੇ ਹੋ ਜੋ NAME _ 1 ਕੋਡ ਵਿੱਚ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਤੋਂ ਇੱਕ ਗੁੰਝਲਦਾਰ XML ਸਮੱਗਰੀ ਨੂੰ ਮਿਲਾਉਂਦਾ ਹੈ ਅਤੇ ਕੱਢਦਾ ਹੈ?', ' [\'ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਇੱਕ ਹੱਲ ਦੇ ਸਕਦੇ ਹੋ ਜੋ ਨਾਮ _ 1 ਕੋਡ ਵਿੱਚ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਤੋਂ ਇੱਕ ਗੁੰਝਲਦਾਰ ਐਕਸ. ਐੱਮ. ਐੱਲ. ਸਮੱਗਰੀ ਨੂੰ ਮਿਲਾਉਂਦਾ ਹੈ ਅਤੇ ਕੱਢਦਾ ਹੈ?\', \'ਜ਼ਰੂਰ, ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਨਾਮ _ 1?ਕੋਡ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਇੱਕ ਗੁੰਝਲਦਾਰ XML ਸਮੱਗਰੀ ਤੋਂ ਡੇਟਾ ਨੂੰ ਕਿਵੇਂ ਪਾਰਸ ਅਤੇ ਐਕਸਟਰੈਕਟ ਕਰਨਾ ਹੈ ਜੋ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਫਾਰਮੈਟ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਗਿਆ ਹੈਃ \\n \'\' NAME _ 1 \'NAME_1.util.List; \\nimਪੋਰ੍ਟ javax.xml.parsers.DocumentBuilder ਫੈਕਟਰੀ; \\nimਪੋਰ੍ਟ javax.xml.parsers.DocumentBuilder; \\nimਪੋਰਟjavax.xml.parsers.ParserConfigurationException; \\nimports org.w3c.dom.Document; \\nimports org.w3c.dom.Element; \\nimports org.w3c.dom.NodeList; \\nimportsNAME_1.util.ArrayList; \\nimport NAME_1.util.Collections; \\n\\nਪਬਲਿਕ ਕਲਾਸ XMLParser {\\n ਪਬਲਿਕ ਸਟੈਟਿਕ ਵੋਇਡ ਪਾਰਸਟੈਕਸਟ ਟੂਐਕਸਐੱਮਐੱਲ (NAME _ 2 ਟੈਕਸਟ, NAME _ 2)ਤੱਤ ਨਾਮ, ਨਾਮ _ 2 ਗੁਣ ਨਾਮ, ਨਾਮ _ 2 ਗੁਣ ਮੁੱਲ) ਪਾਰਸਰ ਕਨਫਿਗਰੇਸ਼ਨ ਐਕਸੈਪਸ਼ਨ {\\n ਡੌਕੂਮੈਂਟਬਿਲਡਰਫੈਕਟਰੀ ਫੈਕਟਰੀ = ਸੁੱਟਦਾ ਹੈDocumentBuilderFactory.newInstance (); \\n ਡੌਕੂਮੈਂਟ ਬਿਲਡਰ ਬਿਲਡਰ = factory.newDocumentBuilder (); \\n ਡੌਕੂਮੈਂਟ ਡੌਕ = builder.newDocument (); \\n ਐਲੀਮੈਂਟ ਰੂਟ= doc.createElement (ਤੱਤ-ਨਾਮ); \\n doc.appendChild (ਰੂਟ); \\n NAME _ 2 [] ਹਿੱਸੇ = text.split ("\\\\\\\\s +"); \\n ਲਈ (ਇੰਟ i = 0; i <parts.length; i + +) {\\nਤੱਤ ਤੱਤ = doc.createElement ("ਆਈਟਮ"); \\n element.setAttribute (ਗੁਣ-ਨਾਮ, ਗੁਣ-ਮੁੱਲ); \\n element.setAttribute ("ਮੁੱਲ", ਹਿੱਸੇ [i]); \\nroot.appendChild (ਤੱਤ); \\n} \\n System.out.println (doc.XMLOutput.toString ()); \\n} \\n\\n ਪਬਲਿਕ ਸਟੈਟਿਕ ਵੋਇਡ ਮੇਨ (NAME _ 2 [] ਆਰਗਸ) {\\n NAME _ 2 ਟੈਕਸਟ ="ਐਪਲ ਕੇਲੇ ਦਾ ਸੰਤਰੀ ਕੀਵੀ ਪੀਅਰ"; \\n ਨਾਮ _ 2 ਤੱਤ ਨਾਮ = "ਆਈਟਮ"; \\n ਨਾਮ _ 2 ਗੁਣ ਨਾਮ = "ਮੁੱਲ"; \\n ਨਾਮ _ 2 ਗੁਣ ਮੁੱਲ = "ਟੈਕਸਟ"; \\n ਕੋਸ਼ਿਸ਼ ਕਰੋ {\\nਪਾਰਸ ਟੈਕਸਟ ਟੂਐਕਸਐੱਮਐੱਲ (ਟੈਕਸਟ, ਤੱਤ-ਨਾਮ, ਗੁਣ-ਨਾਮ, ਗੁਣ-ਮੁੱਲ); \\n} ਕੈਚ (ਪਾਰਸਰ ਕਨਫਿਗਰੇਸ਼ਨ ਐਕਸੈਪਸ਼ਨ ਈ) {\\n e.printStackTrace (); \\n} \\n} \\n} \\n "\\n ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਸਾਡੇ ਕੋਲ ਇੱਕ ਢੰਗ ਹੈ \'ਪਾਰਸਟੈਕਸਟ ਟੂਐਕਸਐੱਮਐੱਲ ()\' ਜੋ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਨਾਮ _ 2, ਇੱਕ ਤੱਤ ਨਾਮ, ਇੱਕ ਗੁਣ ਨਾਮ, ਅਤੇ ਇੱਕ ਵਿੱਚ ਲੈਂਦਾ ਹੈ।ਗੁਣ ਮੁੱਲ ਮਾਪਦੰਡਾਂ ਦੇ ਰੂਪ ਵਿੱਚ। ਇਹ ਫਿਰ \'ਡੌਕੂਮੈਂਟ ਬਿਲਡਰਫੈਕਟਰੀ\' ਅਤੇ \'ਡੌਕੂਮੈਂਟ ਬਿਲਡਰ\' ਕਲਾਸਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਟੈਕਸਟ ਨੂੰ ਇੱਕ XML ਡੌਕੂਮੈਂਟ ਵਿੱਚ ਪਾਰਸ ਕਰਦਾ ਹੈ। \\n\\n\'ਤੱਤ ਨਾਮ\' ਪੈਰਾਮੀਟਰ ਉਸ ਤੱਤ ਦਾ ਨਾਮ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ \'ਪਲੇਨ\' ਹੁੰਦਾ ਹੈ, \'ਮੈਨੂੰ ਇੱਕ ਹੱਲ ਦਿਓ ਜੋ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਤੋਂ XML ਸਮੱਗਰੀ ਨੂੰ ਲੱਭਦਾ ਹੈ\',\' ਜ਼ਰੂਰ, ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈ NAME _ 1 ਕੋਡ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਨਿਯਮਤ ਵਰਤੋਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਤੋਂ XML ਸਮੱਗਰੀ ਨੂੰ ਕਿਵੇਂ ਕੱਢਿਆ ਜਾਵੇ?ਸਮੀਕਰਨਃ \'\\n\' \'NAME _ 1 \\nimport NAME_1.util.regex.Matcher; \\nimport NAME_1.util.regex.Pattern; \\n\\nਪਬਲਿਕ ਕਲਾਸ XMLEXTractor {\\n ਪਬਲਿਕ ਸਟੈਟਿਕ ਵੋਇਡਮੁੱਖ (ਨਾਮ _ 2 [] ਆਰਗਸ) {\\n ਨਾਮ _ 2 ਪਲੇਨਟੈਕਸਟ = "ਇਹ ਕੁੱਝ ਸਧਾਰਨ ਟੈਕਸਟ ਸਮੱਗਰੀ ਹੈ। ਹੇਠਾਂ ਇੱਕ XML ਸਮੱਗਰੀ ਹੈਃ<ਆਈਟਮ> ਸੇਬ </ਆਈਟਮ> <ਆਈਟਮ> ਕੇਲਾ </ਆਈਟਮ> <ਆਈਟਮ> ਸੰਤਰੀ </ਆਈਟਮ> "; \\n NAME _ 2 xMLRagex =" (? s) "= Pattern.compile (xملਰੇਗੈਕਸ, Pattern.DOTALL); \\n ਮੈਚਰ ਮੈਚਰ = pattern.matcher (ਪਲੇਨਟੈਕਸਟ); \\n ਜੇਕਰ (matcher.find ()) {\\nSystem.out.println (matcher.group ()); \\n} \\n} \\n "\'\\n ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਸਾਡੇ ਕੋਲ ਇੱਕ ਵਿਧੀ\' ਮੈਨ () \'ਹੈ ਜੋ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਵਿੱਚ NAME _ 2 ਨੂੰ ਇੰਪੁੱਟ ਵਜੋਂ ਲੈਂਦੀ ਹੈ। ਅਸੀਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂਇੱਕ ਨਿਯਮਤ ਸਮੀਕਰਨ ਪੈਟਰਨ \'xmlRegex\' ਜੋ ਸਾਦੇ ਟੈਕਸਟ ਵਿੱਚ ਕਿਸੇ ਵੀ XML ਸਮੱਗਰੀ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਪੈਟਰਨ ਡਾਟ-ਆਲ ਮੋਡ ਨੂੰ ਸਮਰੱਥ ਕਰਨ ਲਈ \'(? s)\' ਫਲੈਗ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ\'.\' ਅੱਖਰ ਨੂੰ ਨਵੀਂ ਲਾਈਨ ਅੱਖਰਾਂ ਸਮੇਤ ਕਿਸੇ ਵੀ ਅੱਖਰ ਨਾਲ ਮੇਲ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਪੈਟਰਨ ਫਿਰ ਇੱਕ XML ਤੱਤ ਦੇ ਖੁੱਲ੍ਹਣ ਅਤੇ ਬੰਦ ਹੋਣ ਵਾਲੇ ਟੈਗ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ,ਅਤੇ ਟੈਗ ਦੇ ਵਿਚਕਾਰ ਟੈਕਸਟ ਸਮੱਗਰੀ। ਮੇਲ ਖਾਂਦੀ ਸਮੱਗਰੀ ਨੂੰ \'ਮੈਚਰ\' ਆਬਜੈਕਟ ਦੇ \'ਗਰੁੱਪ ()\' ਢੰਗ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੱਢਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਨਿਯਮਿਤ ਹੈਸਮੀਕਰਨ ਪੈਟਰਨ ਇਹ ਮੰਨਦਾ ਹੈ ਕਿ XML ਸਮੱਗਰੀ ਨੂੰ ਟੈਗ ਖੋਲ੍ਹਣ ਅਤੇ ਬੰਦ ਕਰਨ ਦੇ ਨਾਲ ਸਹੀ ਢੰਗ ਨਾਲ ਫਾਰਮੈਟ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਉਹਨਾਂ ਦੇ ਵਿਚਕਾਰ ਕੁਝ ਟੈਕਸਟ ਸਮੱਗਰੀ ਹੈ।ਐਕਸ. ਐੱਮ. ਐੱਲ. ਸਮੱਗਰੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਤਿਆਰ ਨਹੀਂ ਹੈ ਜਾਂ ਇਸ ਵਿੱਚ ਟਿੱਪਣੀਆਂ ਜਾਂ ਪ੍ਰੋਸੈਸਿੰਗ ਨਿਰਦੇਸ਼ ਸ਼ਾਮਲ ਹਨ, ਨਿਯਮਤ ਸਮੀਕਰਨ ਪੈਟਰਨ ਨੂੰ ਐਡਜਸਟ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋ ਸਕਦੀ ਹੈ।\',\' NAME _ 1 ਕੋਡ ਵਿੱਚ ਨਿਯਮਤ ਸਮੀਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ XML ਸਮੱਗਰੀ ਨੂੰ ਕਿਵੇਂ ਮਿਲਾਉਣਾ ਹੈ \',\' NAME _ 1 ਵਿੱਚ ਨਿਯਮਤ ਸਮੀਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ XML ਸਮੱਗਰੀ ਨੂੰ ਮਿਲਾਉਣ ਲਈ, ਤੁਸੀਂ\'ਪੈਟਰਨ\' ਅਤੇ \'ਮੈਚਰ\' ਕਲਾਸਾਂ ਦੀ ਵਰਤੋਂ ਇੱਕ ਪੈਟਰਨ ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਜੋ XML ਸਮੱਗਰੀ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ ਅਤੇ ਫਿਰ ਪੈਟਰਨ ਦੀ ਖੋਜ ਕਰਨ ਲਈ \'ਮੈਚਰ ()\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦਾ ਹੈ।ਇੱਕ NAME _ 2 ਵਿੱਚ. \\n\\n ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ NAME _ 1 ਕੋਡ ਹੈ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਨਿਯਮਤ ਸਮੀਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ XML ਸਮੱਗਰੀ ਨੂੰ ਕਿਵੇਂ ਮਿਲਾਉਣਾ ਹੈਃ \\n \'\' NAME _ 1\\ਨਿਮਪੋਰਟNAME_1.util.regex.Matcher; \\nimport NAME_1.util.regex.Pattern; \\n\\nਪਬਲਿਕ ਕਲਾਸ XMLRegex {\\n ਪਬਲਿਕ ਸਟੈਟਿਕ ਵਾਇਲਡ ਮੇਨ (NAME _ 2 [] ਆਰਗਸ) {\\n NAME _ 2 ਪਲੇਨਟੈਕਸਟ= "ਇਹ ਕੁੱਝ ਸਧਾਰਨ ਪਾਠ ਸਮੱਗਰੀ ਹੈ। ਹੇਠਾਂ ਇੱਕ XML ਸਮੱਗਰੀ ਹੈਃ <ਆਈਟਮ> ਐਪਲ </ਆਈਟਮ> <ਆਈਟਮ> ਕੇਲਾ </ਆਈਟਮ> <ਆਈਟਮ> ਸੰਤਰੀ </ਆਈਟਮ>"; \\n NAME _ 2 xmlRegex ="(? s) <\\\\\\\\w +\\\\\\\\s +\\\\w +\\\\s +\\\\w + [^>] *>\\\\s *. *? <\\\\ \\w +\\\\s +\\\\ \\w +\\\\\\\\s +\\\\\\\\w +\\\\\\\\"; \\n ਪੈਟਰਨ = Pattern.compile (xmlR\u0a46ਗ\u0a46ਕਸ, Pattern.DOTALL); \\nਮੈਚਰ ਮੈਚਰ = pattern.matcher (ਪਲੇਨਟੈਕਸਟ); \\n ਜੇਕਰ (matcher.find ()) {\\n System.out.println (matcher.group ()); \\n} \\n} \\n "\\n" ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਅਸੀਂਇੱਕ ਨਿਯਮਿਤ ਸਮੀਕਰਨ ਪੈਟਰਨ \'xmlRegex\' ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜੋ ਸਾਦੇ ਟੈਕਸਟ ਵਿੱਚ ਕਿਸੇ ਵੀ XML ਸਮੱਗਰੀ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਪੈਟਰਨ ਡਾਟ-ਆਲ ਨੂੰ ਸਮਰੱਥ ਕਰਨ ਲਈ \'(? s)\' ਫਲੈਗ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।ਮੋਡ, ਜੋ \'.\' ਅੱਖਰ ਨੂੰ ਨਵੀਂ ਲਾਈਨ ਅੱਖਰਾਂ ਸਮੇਤ ਕਿਸੇ ਵੀ ਅੱਖਰ ਨਾਲ ਮੇਲ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਪੈਟਰਨ ਫਿਰ ਇੱਕ ਅੱਖਰ ਦੇ ਖੁੱਲ੍ਹਣ ਅਤੇ ਬੰਦ ਹੋਣ ਵਾਲੇ ਟੈਗ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ।XML ਤੱਤ ਅਤੇ ਟੈਗ ਦੇ ਵਿਚਕਾਰ ਟੈਕਸਟ ਸਮੱਗਰੀ। \'ਪੈਟਰਨ\' ਕਲਾਸ ਦਾ \'ਮੈਚਰ ()\' ਢੰਗ ਫਿਰ ਸਾਦੇ ਵਿੱਚ ਪੈਟਰਨ ਦੀ ਖੋਜ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।ਪਾਠ ਨਾਮ _ 2, ਅਤੇ ਮੇਲ ਖਾਂਦੀ ਸਮੱਗਰੀ ਨੂੰ \'ਮੈਚਰ\' ਆਬਜੈਕਟ ਦੇ \'ਗਰੁੱਪ ()\' ਢੰਗ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੱਢਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਨਿਯਮਤ ਸਮੀਕਰਨ ਪੈਟਰਨ ਹੈ।ਇਹ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ ਕਿ XML ਸਮੱਗਰੀ ਨੂੰ ਟੈਗ ਖੋਲ੍ਹਣ ਅਤੇ ਬੰਦ ਕਰਨ ਦੇ ਨਾਲ ਸਹੀ ਢੰਗ ਨਾਲ ਫਾਰਮੈਟ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਉਹਨਾਂ ਦੇ ਵਿਚਕਾਰ ਕੁਝ ਟੈਕਸਟ ਸਮੱਗਰੀ ਹੈ। ਜੇਕਰ XML ਸਮੱਗਰੀ ਹੈਚੰਗੀ ਤਰ੍ਹਾਂ ਤਿਆਰ ਨਹੀਂ ਹੈ ਜਾਂ ਟਿੱਪਣੀਆਂ ਜਾਂ ਪ੍ਰੋਸੈਸਿੰਗ ਨਿਰਦੇਸ਼ ਸ਼ਾਮਲ ਨਹੀਂ ਹਨ, ਨਿਯਮਤ ਸਮੀਕਰਨ ਪੈਟਰਨ ਨੂੰ ਉਸ ਅਨੁਸਾਰ ਐਡਜਸਟ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋ ਸਕਦੀ ਹੈ।ਨਿਯਮਤ ਸਮੀਕਰਨ ਜਿਸ ਦੀ ਵਰਤੋਂ ਇੱਕ ਗੁੰਝਲਦਾਰ ਐਕਸ. ਐੱਮ. ਐੱਲ. ਨਾਲ ਮੇਲ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ? \',\' ਨਿਯਮਤ ਸਮੀਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਗੁੰਝਲਦਾਰ ਐਕਸ. ਐੱਮ. ਐੱਲ. ਨਾਲ ਮੇਲ ਕਰਨਾ ਐਕਸ. ਐੱਮ. ਐੱਲ. ਬਣਤਰ ਦੇ ਰੂਪ ਵਿੱਚ ਚੁਣੌਤੀਪੂਰਨ ਹੋ ਸਕਦਾ ਹੈ।ਇਹ ਵਿਆਪਕ ਰੂਪ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਹੋ ਸਕਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਨਿਯਮਤ ਸਮੀਕਰਨ ਪੈਟਰਨ ਹੈ ਜੋ ਇੱਕ ਗੁੰਝਲਦਾਰ XML ਬਣਤਰ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈਃ \\n \'\' NAME _ 1\\ਨਿਮਪੋਰਟNAME_1.util.regex.Matcher; \\nimport NAME_1.util.regex.Pattern; \\n\\nਪਬਲਿਕ ਕਲਾਸ XMLRegex {\\n ਪਬਲਿਕ ਸਟੈਟਿਕ ਵੋਇਡ ਮੇਨ (NAME _ 2 [] ਆਰਗਸ) {\\n NAME _ 2 xmlString= "<root> <ਤੱਤ ਗੁਣ 1 =\\\'ਮੁੱਲ 1\\\' ਗੁਣ 2 =\\\'ਮੁੱਲ 2\\\'> ਪਾਠ ਸਮੱਗਰੀ </ਤੱਤ> </ਰੂਟ>"; \\n NAME _ 2 xmlRegex ="<(\\\\\\\\w +)\\\\ \\s + (\\\\\\\\w +)\\\\s + (\\\\ \\w +)\\\\s + (\\\\ \\w +)\\\\s *>\\\\ \\s * ([<] +) <\\\\\\/ (\\\\ \\w +)>"; \\n ਪੈਟਰਨ ਪੈਟਰਨ = Pattern.compile (xmlR\u0a46ਗ\u0a46ਕਸ,Pattern.DOTALL); \\n ਮੈਚਰ ਮੈਚਰ = pattern.matcher (xملਸਟ੍ਰਿੰਗ); \\n ਜੇਕਰ (matcher.find ()) {\\n System.out.println (matcher.group ()); \\n} \\n} \\n \'\\n\'ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਨਿਯਮਿਤ ਸਮੀਕਰਨ ਪੈਟਰਨ \'xmlRegex\' ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂ ਜੋ ਸਾਦੇ ਟੈਕਸਟ ਵਿੱਚ ਕਿਸੇ ਵੀ ਗੁੰਝਲਦਾਰ XML ਸਮੱਗਰੀ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਪੈਟਰਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ\'(\\\\ \\w +)\' ਗਰੁੱਪ ਤੱਤ ਦਾ ਨਾਮ, ਗੁਣ ਨਾਮ, ਗੁਣ ਮੁੱਲ ਅਤੇ ਟੈਕਸਟ ਸਮੱਗਰੀ ਨਾਲ ਮੇਲ ਕਰਨ ਲਈ। \'\\\\ \\s *\' ਪੈਟਰਨ ਕਿਸੇ ਵੀ ਵਾਈਟਸਪੇਸ ਨਾਲ ਮੇਲ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।ਟੈਗ ਦੇ ਵਿਚਕਾਰ ਅੱਖਰ। \'([^ <] +)\' ਗਰੁੱਪ ਟੈਗ ਦੇ ਵਿਚਕਾਰ ਟੈਕਸਟ ਸਮੱਗਰੀ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। \'</(\\\\ \\w +)>\' ਪੈਟਰਨ ਟੈਗ ਦੇ ਸਮਾਪਤੀ ਟੈਗ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ।ਤੱਤ. \\n\\n ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਨਿਯਮਤ ਸਮੀਕਰਨ ਪੈਟਰਨ ਇਹ ਮੰਨਦਾ ਹੈ ਕਿ XML ਸਮੱਗਰੀ ਨੂੰ ਟੈਗ ਖੋਲ੍ਹਣ ਅਤੇ ਬੰਦ ਕਰਨ ਦੇ ਨਾਲ ਸਹੀ ਢੰਗ ਨਾਲ ਫਾਰਮੈਟ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਗੁਣਮੁੱਲ ਹਵਾਲੇ ਵਿੱਚ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ। ਜੇਕਰ XML ਸਮੱਗਰੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਤਿਆਰ ਨਹੀਂ ਹੈ ਜਾਂ ਟਿੱਪਣੀਆਂ ਜਾਂ ਪ੍ਰੋਸੈਸਿੰਗ ਨਿਰਦੇਸ਼ ਸ਼ਾਮਲ ਹਨ, ਤਾਂ ਨਿਯਮਤ ਸਮੀਕਰਨ ਪੈਟਰਨਉਸ ਅਨੁਸਾਰ ਐਡਜਸਟ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਪੈ ਸਕਦੀ ਹੈ। \',\' ਮੈਨੂੰ ਇੱਕ ਨਿਯਮਿਤ ਸਮੀਕਰਨ ਦਿਓ ਜੋ ਇੱਕ ਗੁੰਝਲਦਾਰ xml ਨਾਲ ਮੇਲ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ \'] ', 'ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਇੱਕ ਹੱਲ ਦੇ ਸਕਦੇ ਹੋ ਜੋ NAME _ 1 ਕੋਡ ਵਿੱਚ ਇੱਕ ਸਾਦੇ ਟੈਕਸਟ ਤੋਂ ਇੱਕ ਗੁੰਝਲਦਾਰ XML ਸਮੱਗਰੀ ਨੂੰ ਮਿਲਾਉਂਦਾ ਹੈ ਅਤੇ ਕੱਢਦਾ ਹੈ? \n ']