diff --git a/bundles/org.eclipse.osgi.tests/src/org/eclipse/osgi/tests/container/AllTests.java b/bundles/org.eclipse.osgi.tests/src/org/eclipse/osgi/tests/container/AllTests.java
index 47c527c..ab08f8e 100644
--- a/bundles/org.eclipse.osgi.tests/src/org/eclipse/osgi/tests/container/AllTests.java
+++ b/bundles/org.eclipse.osgi.tests/src/org/eclipse/osgi/tests/container/AllTests.java
@@ -23,6 +23,7 @@
 		suite.addTest(new JUnit4TestAdapter(TestModuleContainer.class));
 		suite.addTest(new JUnit4TestAdapter(ResolutionReportTest.class));
 		suite.addTest(new JUnit4TestAdapter(ModuleContainerUsageTest.class));
+		suite.addTest(new JUnit4TestAdapter(NamespaceListTest.class));
 		return suite;
 	}
 }
diff --git a/bundles/org.eclipse.osgi.tests/src/org/eclipse/osgi/tests/container/NamespaceListTest.java b/bundles/org.eclipse.osgi.tests/src/org/eclipse/osgi/tests/container/NamespaceListTest.java
new file mode 100644
index 0000000..dea96f9
--- /dev/null
+++ b/bundles/org.eclipse.osgi.tests/src/org/eclipse/osgi/tests/container/NamespaceListTest.java
@@ -0,0 +1,249 @@
+/*******************************************************************************
+ * Copyright (c) 2021 IBM Corporation and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.osgi.tests.container;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.function.Function;
+import org.junit.Test;
+import org.osgi.framework.Bundle;
+
+/**
+ * Using reflection because to avoid exporting internals.
+ */
+public class NamespaceListTest extends AbstractTest {
+	static final Method getList;
+	static final Method isEmpty;
+	static final Method getNamespaceIndex;
+	static final Method copyList;
+	static final Constructor<?> newNamespaceList;
+	static {
+		try {
+			Class<?> namespaceList = Bundle.class.getClassLoader()
+					.loadClass("org.eclipse.osgi.internal.container.NamespaceList");
+			getList = namespaceList.getMethod("getList", String.class);
+			isEmpty = namespaceList.getMethod("isEmpty");
+			getNamespaceIndex = namespaceList.getMethod("getNamespaceIndex", String.class);
+			copyList = namespaceList.getMethod("copyList");
+			newNamespaceList = namespaceList.getConstructor(List.class, Function.class);
+		} catch (Throwable t) {
+			throw new RuntimeException(t);
+		}
+	}
+	static class NamespaceElement {
+		final int id;
+		final String namespace;
+
+		public NamespaceElement(int id, String namespace) {
+			super();
+			this.id = id;
+			this.namespace = namespace;
+		}
+
+		public int getId() {
+			return id;
+		}
+
+		public String getNamespace() {
+			return namespace;
+		}
+
+		@Override
+		public boolean equals(Object o) {
+			if (o instanceof NamespaceElement) {
+				NamespaceElement other = (NamespaceElement) o;
+				return this.id == other.id && this.namespace.equals(other.namespace);
+			}
+			return false;
+		}
+
+		@Override
+		public int hashCode() {
+			return namespace.hashCode() ^ id;
+		}
+
+		@Override
+		public String toString() {
+			return namespace + ':' + id;
+		}
+	}
+
+	static final Function<NamespaceElement, String> getNamespaceFunc = (Function<NamespaceElement, String>) NamespaceElement::getNamespace;
+	Object newNamespace(List<NamespaceElement> elements) throws Exception {
+		return newNamespaceList.newInstance(elements, getNamespaceFunc);
+	}
+	@Test
+	public void testIsEmpty() throws Exception {
+		Object namespaceList = newNamespace(Collections.emptyList());
+		assertTrue("List is not empty.", isEmpty(namespaceList));
+
+		List<NamespaceElement> elements = new ArrayList<>();
+		elements.add(new NamespaceElement(0, "ns1"));
+		namespaceList = newNamespace(elements);
+		assertFalse("List is empty.", isEmpty(namespaceList));
+
+		elements.add(new NamespaceElement(1, "ns2"));
+		namespaceList = newNamespace(elements);
+		assertFalse("List is empty.", isEmpty(namespaceList));
+	}
+
+	private boolean isEmpty(Object namespaceList) throws Exception {
+		return (boolean) isEmpty.invoke(namespaceList);
+	}
+
+	private List<NamespaceElement> getList(Object namespaceList, String namespace) throws Exception {
+		return (List<NamespaceElement>) getList.invoke(namespaceList, namespace);
+	}
+
+	@Test
+	public void testGetList() throws Exception {
+		Object namespaceList = newNamespace(Collections.emptyList());
+
+		List<NamespaceElement> list = getList(namespaceList, null);
+		assertTrue("List is not empty.", list.isEmpty());
+		failAdd(list);
+
+		list = getList(namespaceList, "ns-1");
+		assertTrue("List is not empty.", list.isEmpty());
+		failAdd(list);
+
+		List<NamespaceElement> elements = populate(5, 10);
+
+		namespaceList = newNamespace(elements);
+
+		for (int i = 0; i < 10; i++) {
+			list = getList(namespaceList, "ns-" + i);
+			failAdd(list);
+			assertEquals("Wrong list.", populate(5, "ns-" + i), list);
+		}
+
+		list = getList(namespaceList, null);
+		failAdd(list);
+		assertEquals("Wrong list.", populate(5, 10), list);
+	}
+
+	@Test
+	public void testGetNamespaceIndex() throws Exception {
+		Object namespaceList = newNamespace(Collections.emptyList());
+		assertNull("Unexpected index.", getNamespaceIndex(namespaceList, "ns-0"));
+
+		List<NamespaceElement> elements = populate(21, 13);
+
+		namespaceList = newNamespace(elements);
+		Entry<Integer, Integer> nsIndex = getNamespaceIndex(namespaceList, "ns-0");
+		assertNotNull("Expected an index", nsIndex);
+		checkIndex(nsIndex, 0, 21);
+
+		nsIndex = getNamespaceIndex(namespaceList, "ns-12");
+		assertNotNull("Expected an index", nsIndex);
+		checkIndex(nsIndex, 21 * 12, 21 * 13);
+
+		nsIndex = getNamespaceIndex(namespaceList, "ns-4");
+		assertNotNull("Expected an index", nsIndex);
+		checkIndex(nsIndex, 21 * 4, 21 * 5);
+	}
+
+	@Test
+	public void testOutOfOrderNamespace() throws Exception {
+		List<NamespaceElement> elements = populate(4, 4);
+		// random sort by hashcode
+		elements.sort((n1, n2) -> n1.hashCode() - n2.hashCode());
+		Object namespaceList = newNamespace(elements);
+		for (int i = 0; i < 4; i++) {
+			List<NamespaceElement> list = getList(namespaceList, "ns-" + i);
+			failAdd(list);
+			// list is random order now, but should all have the same namespace
+			assertEquals("Wrong number of elements", 4, list.size());
+			for (NamespaceElement e : list) {
+				assertEquals("Wrong namespace", "ns-" + i, e.getNamespace());
+			}
+		}
+	}
+
+	@Test
+	public void testCopyList() throws Exception {
+		Object namespaceList = newNamespace(Collections.emptyList());
+		List<NamespaceElement> copy = copyList(namespaceList);
+		assertEquals("Wrong list.", Collections.emptyList(), copy);
+		successAdd(copy);
+		copy = copyList(namespaceList);
+		assertEquals("Wrong list.", Collections.emptyList(), copy);
+
+		List<NamespaceElement> elements = populate(100, 13);
+		namespaceList = newNamespace(elements);
+		copy = copyList(namespaceList);
+		assertEquals("Wrong list.", elements, copy);
+		successAdd(copy);
+		copy = copyList(namespaceList);
+		assertEquals("Wrong list.", elements, copy);
+	}
+
+	private List<NamespaceElement> copyList(Object namespaceList) throws Exception {
+		return (List<NamespaceElement>) copyList.invoke(namespaceList);
+	}
+
+	private void checkIndex(Entry<Integer, Integer> nsIndex, int start, int end) {
+		assertEquals("Unexpected Start", start, (int) nsIndex.getKey());
+	}
+
+	private Entry<Integer, Integer> getNamespaceIndex(Object namespaceList, String namespace) throws Exception {
+		return (Entry<Integer, Integer>) getNamespaceIndex.invoke(namespaceList, namespace);
+	}
+
+	private void failAdd(List<NamespaceElement> list) {
+		try {
+			list.add(new NamespaceElement(0, "ns"));
+			fail("Should fail to modify list");
+		} catch (UnsupportedOperationException e) {
+			// expected
+		}
+	}
+
+	private void successAdd(List<NamespaceElement> list) {
+		try {
+			list.add(new NamespaceElement(0, "ns"));
+		} catch (UnsupportedOperationException e) {
+			fail("Should not fail to modify list");
+		}
+	}
+
+	private List<NamespaceElement> populate(int numElementsPerNS, int numNS) {
+		ArrayList<NamespaceElement> elements = new ArrayList<>(numElementsPerNS * numNS);
+		for (int namespace = 0; namespace < numNS; namespace++) {
+			for (int element = 0; element < numElementsPerNS; element++) {
+				elements.add(new NamespaceElement(element, "ns-" + namespace));
+			}
+		}
+		return elements;
+	}
+
+	private List<NamespaceElement> populate(int numElements, String namespace) {
+		ArrayList<NamespaceElement> elements = new ArrayList<>(numElements);
+		for (int element = 0; element < numElements; element++) {
+			elements.add(new NamespaceElement(element, namespace));
+		}
+		return elements;
+	}
+}
diff --git a/bundles/org.eclipse.osgi.tests/src/org/eclipse/osgi/tests/container/TestModuleContainer.java b/bundles/org.eclipse.osgi.tests/src/org/eclipse/osgi/tests/container/TestModuleContainer.java
index 53888f6..eaaac92 100644
--- a/bundles/org.eclipse.osgi.tests/src/org/eclipse/osgi/tests/container/TestModuleContainer.java
+++ b/bundles/org.eclipse.osgi.tests/src/org/eclipse/osgi/tests/container/TestModuleContainer.java
@@ -3806,6 +3806,127 @@
 		assertEquals("Wrong state for moduleBF", State.INSTALLED, moduleBF.getState());
 	}
 
+	@Test
+	public void testModuleWiringLookup() throws BundleException {
+		DummyContainerAdaptor adaptor = createDummyAdaptor();
+		ModuleContainer container = adaptor.getContainer();
+
+		Map<String, String> manifestCore = new HashMap<>();
+		manifestCore.put(Constants.BUNDLE_MANIFESTVERSION, "2");
+		manifestCore.put(Constants.BUNDLE_SYMBOLICNAME, "core");
+		manifestCore.put(Constants.BUNDLE_VERSION, "1");
+		manifestCore.put(Constants.PROVIDE_CAPABILITY, "core");
+		manifestCore.put(Constants.EXPORT_PACKAGE, "core.a, core.b, core.dynamic.a, core.dynamic.b");
+		installDummyModule(manifestCore, "core", container);
+
+		Map<String, String> manifestA = new HashMap<>();
+		manifestA.put(Constants.BUNDLE_MANIFESTVERSION, "2");
+		manifestA.put(Constants.BUNDLE_SYMBOLICNAME, "a");
+		manifestA.put(Constants.BUNDLE_VERSION, "1");
+		manifestA.put(Constants.PROVIDE_CAPABILITY, "ca; ca=1, ca; ca=2, cb; cb=1, cb; cb=2, ca; ca=3");
+		manifestA.put(Constants.REQUIRE_CAPABILITY, "core");
+		manifestA.put(Constants.IMPORT_PACKAGE, "core.a, core.b");
+		manifestA.put(Constants.DYNAMICIMPORT_PACKAGE, "core.dynamic.*");
+		Module moduleA = installDummyModule(manifestA, "a", container);
+
+		Map<String, String> manifestB = new HashMap<>();
+		manifestB.put(Constants.BUNDLE_MANIFESTVERSION, "2");
+		manifestB.put(Constants.BUNDLE_SYMBOLICNAME, "b");
+		manifestB.put(Constants.BUNDLE_VERSION, "1");
+		manifestB.put(Constants.REQUIRE_CAPABILITY,
+				"ca; filter:=\"(ca=1)\", ca; filter:=\"(ca=2)\", cb; filter:=\"(cb=1)\", cb; filter:=\"(cb=2)\", ca; filter:=\"(ca=3)\"");
+		Module moduleB = installDummyModule(manifestB, "b", container);
+
+		container.resolve(Arrays.asList(moduleA, moduleB), false);
+
+		ModuleWiring wiringA = moduleA.getCurrentRevision().getWiring();
+		List<ModuleCapability> caCaps = wiringA.getModuleCapabilities("ca");
+		assertEquals("Wrong number of capabilities", 3, caCaps.size());
+		List<ModuleWire> caProvidedWires = wiringA.getProvidedModuleWires("ca");
+		assertEquals("Wrong number of wires.", 3, caProvidedWires.size());
+
+		ModuleWiring wiringB = moduleB.getCurrentRevision().getWiring();
+		List<ModuleRequirement> caReqs = wiringB.getModuleRequirements("ca");
+		assertEquals("Wrong number of requirements", 3, caReqs.size());
+		List<ModuleWire> caRequiredWires = wiringB.getRequiredModuleWires("ca");
+		assertEquals("Wrong number of wires.", 3, caRequiredWires.size());
+
+		Map<String, String> manifestAFrag = new HashMap<>();
+		manifestAFrag.put(Constants.BUNDLE_MANIFESTVERSION, "2");
+		manifestAFrag.put(Constants.BUNDLE_SYMBOLICNAME, "a.frag");
+		manifestAFrag.put(Constants.BUNDLE_VERSION, "1");
+		manifestAFrag.put(Constants.FRAGMENT_HOST, "a");
+		manifestAFrag.put(Constants.PROVIDE_CAPABILITY, "ca; ca=4, ca; ca=5, cb; cb=3, cb; cb=4, ca; ca=6");
+		installDummyModule(manifestAFrag, "a.frag", container);
+
+		Map<String, String> manifestBFrag = new HashMap<>();
+		manifestBFrag.put(Constants.BUNDLE_MANIFESTVERSION, "2");
+		manifestBFrag.put(Constants.BUNDLE_SYMBOLICNAME, "b.frag");
+		manifestBFrag.put(Constants.BUNDLE_VERSION, "1");
+		manifestBFrag.put(Constants.FRAGMENT_HOST, "b");
+		manifestBFrag.put(Constants.REQUIRE_CAPABILITY,
+				"ca; filter:=\"(ca=4)\", ca; filter:=\"(ca=5)\", cb; filter:=\"(cb=3)\", cb; filter:=\"(cb=4)\", ca; filter:=\"(ca=6)\"");
+		installDummyModule(manifestBFrag, "b.frag", container);
+
+		container.refresh(Arrays.asList(moduleA, moduleB));
+
+		wiringA = moduleA.getCurrentRevision().getWiring();
+		caCaps = wiringA.getModuleCapabilities("ca");
+		assertEquals("Wrong number of capabilities", 6, caCaps.size());
+		caProvidedWires = wiringA.getProvidedModuleWires("ca");
+		assertEquals("Wrong number of wires.", 6, caProvidedWires.size());
+
+		wiringB = moduleB.getCurrentRevision().getWiring();
+		caReqs = wiringB.getModuleRequirements("ca");
+		assertEquals("Wrong number of requirements", 6, caReqs.size());
+		caRequiredWires = wiringB.getRequiredModuleWires("ca");
+		assertEquals("Wrong number of wires.", 6, caRequiredWires.size());
+
+		// dynamically resolve a fragment to already resolved host, providing more
+		// capabilities and requirements
+		Map<String, String> manifestA2Frag = new HashMap<>();
+		manifestA2Frag.put(Constants.BUNDLE_MANIFESTVERSION, "2");
+		manifestA2Frag.put(Constants.BUNDLE_SYMBOLICNAME, "a.frag2");
+		manifestA2Frag.put(Constants.BUNDLE_VERSION, "1");
+		manifestA2Frag.put(Constants.FRAGMENT_HOST, "a");
+		manifestA2Frag.put(Constants.PROVIDE_CAPABILITY, "ca; ca=7, ca; ca=8, cb; cb=5, cb; cb=6, ca; ca=9");
+		manifestA2Frag.put(Constants.REQUIRE_CAPABILITY, "ca; filter:=\"(ca=6)\"");
+		Module moduleAFrag2 = installDummyModule(manifestA2Frag, "a.frag1", container);
+
+		container.resolve(Arrays.asList(moduleAFrag2), true);
+		assertEquals("Wrong state for frag2", State.RESOLVED, moduleAFrag2.getState());
+		caCaps = wiringA.getModuleCapabilities("ca");
+		assertEquals("Wrong number of capabilities", 9, caCaps.size());
+		caProvidedWires = wiringA.getProvidedModuleWires("ca");
+		assertEquals("Wrong number of wires.", 7, caProvidedWires.size());
+		caReqs = wiringA.getModuleRequirements("ca");
+		assertEquals("Wrong number of requirements.", 1, caReqs.size());
+		caRequiredWires = wiringA.getRequiredModuleWires("ca");
+		assertEquals("Wrong number of wires.", 1, caRequiredWires.size());
+
+		List<ModuleRequirement> pkgReqs = wiringA.getModuleRequirements(PackageNamespace.PACKAGE_NAMESPACE);
+		assertEquals("Wrong number of requirements.", 3, pkgReqs.size());
+		List<ModuleWire> pkgWires = wiringA.getRequiredModuleWires(PackageNamespace.PACKAGE_NAMESPACE);
+		assertEquals("Wring number of wires.", 2, pkgWires.size());
+
+		ModuleWire dynamicImport1 = container.resolveDynamic("core.dynamic.a", moduleA.getCurrentRevision());
+		assertNotNull("Dynamic resolve failed", dynamicImport1);
+
+		pkgReqs = wiringA.getModuleRequirements(PackageNamespace.PACKAGE_NAMESPACE);
+		assertEquals("Wrong number of requirements.", 3, pkgReqs.size());
+		assertEquals("Wrong last package requirement.", PackageNamespace.RESOLUTION_DYNAMIC,
+				pkgReqs.get(pkgReqs.size() - 1).getDirectives().get(Namespace.REQUIREMENT_RESOLUTION_DIRECTIVE));
+		pkgWires = wiringA.getRequiredModuleWires(PackageNamespace.PACKAGE_NAMESPACE);
+		assertEquals("Wring number of wires.", 3, pkgWires.size());
+		assertEquals("Wrong last package wire.", dynamicImport1, pkgWires.get(pkgWires.size() - 1));
+
+		ModuleWire dynamicImport2 = container.resolveDynamic("core.dynamic.b", moduleA.getCurrentRevision());
+		assertNotNull("Dynamic resolve failed", dynamicImport2);
+		pkgWires = wiringA.getRequiredModuleWires(PackageNamespace.PACKAGE_NAMESPACE);
+		assertEquals("Wring number of wires.", 4, pkgWires.size());
+		assertEquals("Wrong last package wire.", dynamicImport2, pkgWires.get(pkgWires.size() - 1));
+	}
+
 	private static void assertWires(List<ModuleWire> required, List<ModuleWire>... provided) {
 		for (ModuleWire requiredWire : required) {
 			for (List<ModuleWire> providedList : provided) {
diff --git a/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/container/ModuleContainer.java b/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/container/ModuleContainer.java
index 619dec1..52367f3 100644
--- a/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/container/ModuleContainer.java
+++ b/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/container/ModuleContainer.java
@@ -13,6 +13,8 @@
  *******************************************************************************/
 package org.eclipse.osgi.container;
 
+import static org.eclipse.osgi.internal.container.NamespaceList.WIRE;
+
 import java.io.Closeable;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
@@ -51,6 +53,7 @@
 import org.eclipse.osgi.framework.util.ThreadInfoReport;
 import org.eclipse.osgi.internal.container.InternalUtils;
 import org.eclipse.osgi.internal.container.LockSet;
+import org.eclipse.osgi.internal.container.NamespaceList;
 import org.eclipse.osgi.internal.debug.Debug;
 import org.eclipse.osgi.internal.framework.EquinoxConfiguration;
 import org.eclipse.osgi.internal.messages.Msg;
@@ -805,9 +808,10 @@
 					ModuleWiring current = wiringCopy.get(deltaEntry.getKey());
 					if (current != null) {
 						// need to update the provided capabilities, provided and required wires for currently resolved
-						current.setCapabilities(deltaEntry.getValue().getModuleCapabilities(null));
-						current.setProvidedWires(deltaEntry.getValue().getProvidedModuleWires(null));
-						current.setRequiredWires(deltaEntry.getValue().getRequiredModuleWires(null));
+						current.setCapabilities(deltaEntry.getValue().getCapabilities());
+						current.setProvidedWires(deltaEntry.getValue().getProvidedWires());
+						current.setRequirements(deltaEntry.getValue().getRequirements());
+						current.setRequiredWires(deltaEntry.getValue().getRequiredWires());
 						deltaEntry.setValue(current); // set the real wiring into the delta
 					} else {
 						ModuleRevision revision = deltaEntry.getValue().getRevision();
@@ -1045,9 +1049,9 @@
 					return null; // need to try again
 				// remove any wires from unresolved wirings that got removed
 				for (Map.Entry<ModuleWiring, Collection<ModuleWire>> entry : toRemoveWireLists.entrySet()) {
-					List<ModuleWire> provided = entry.getKey().getProvidedModuleWires(null);
+					List<ModuleWire> provided = entry.getKey().getProvidedWires().copyList();
 					provided.removeAll(entry.getValue());
-					entry.getKey().setProvidedWires(provided);
+					entry.getKey().setProvidedWires(new NamespaceList<>(provided, WIRE));
 					for (ModuleWire removedWire : entry.getValue()) {
 						// invalidate the wire
 						removedWire.invalidate();
diff --git a/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/container/ModuleDatabase.java b/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/container/ModuleDatabase.java
index 9ce1075..4e8689a 100644
--- a/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/container/ModuleDatabase.java
+++ b/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/container/ModuleDatabase.java
@@ -13,6 +13,8 @@
  *******************************************************************************/
 package org.eclipse.osgi.container;
 
+import static org.eclipse.osgi.internal.container.NamespaceList.WIRE;
+
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
@@ -41,6 +43,7 @@
 import org.eclipse.osgi.framework.util.ObjectPool;
 import org.eclipse.osgi.internal.container.Capabilities;
 import org.eclipse.osgi.internal.container.ComputeNodeOrder;
+import org.eclipse.osgi.internal.container.NamespaceList;
 import org.eclipse.osgi.internal.framework.EquinoxConfiguration;
 import org.osgi.framework.BundleException;
 import org.osgi.framework.Constants;
@@ -409,10 +412,9 @@
 				}
 				// remove any wires from unresolved wirings that got removed
 				for (Map.Entry<ModuleWiring, Collection<ModuleWire>> entry : toRemoveWireLists.entrySet()) {
-					List<ModuleWire> provided = entry.getKey().getProvidedModuleWires(null);
-					// No null checks; we are holding the write lock here.
+					List<ModuleWire> provided = entry.getKey().getProvidedWires().copyList();
 					provided.removeAll(entry.getValue());
-					entry.getKey().setProvidedWires(provided);
+					entry.getKey().setProvidedWires(new NamespaceList<>(provided, WIRE));
 					for (ModuleWire removedWire : entry.getValue()) {
 						// invalidate the wire
 						removedWire.invalidate();
@@ -503,7 +505,9 @@
 		try {
 			Map<ModuleRevision, ModuleWiring> clonedWirings = new HashMap<>();
 			for (Map.Entry<ModuleRevision, ModuleWiring> entry : wirings.entrySet()) {
-				ModuleWiring wiring = new ModuleWiring(entry.getKey(), entry.getValue().getModuleCapabilities(null), entry.getValue().getModuleRequirements(null), entry.getValue().getProvidedModuleWires(null), entry.getValue().getRequiredModuleWires(null), entry.getValue().getSubstitutedNames());
+				ModuleWiring wiring = new ModuleWiring(entry.getKey(), entry.getValue().getCapabilities(),
+						entry.getValue().getRequirements(), entry.getValue().getProvidedWires(),
+						entry.getValue().getRequiredWires(), entry.getValue().getSubstitutedNames());
 				clonedWirings.put(entry.getKey(), wiring);
 			}
 			return clonedWirings;
diff --git a/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/container/ModuleResolver.java b/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/container/ModuleResolver.java
index c072677..3a40b5b 100644
--- a/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/container/ModuleResolver.java
+++ b/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/container/ModuleResolver.java
@@ -13,6 +13,10 @@
  *******************************************************************************/
 package org.eclipse.osgi.container;
 
+import static org.eclipse.osgi.internal.container.NamespaceList.CAPABILITY;
+import static org.eclipse.osgi.internal.container.NamespaceList.REQUIREMENT;
+import static org.eclipse.osgi.internal.container.NamespaceList.WIRE;
+
 import java.security.Permission;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -36,12 +40,14 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Function;
 import org.apache.felix.resolver.Logger;
 import org.apache.felix.resolver.ResolutionError;
 import org.apache.felix.resolver.ResolverImpl;
 import org.eclipse.osgi.container.ModuleRequirement.DynamicModuleRequirement;
 import org.eclipse.osgi.container.namespaces.EquinoxFragmentNamespace;
 import org.eclipse.osgi.internal.container.InternalUtils;
+import org.eclipse.osgi.internal.container.NamespaceList;
 import org.eclipse.osgi.internal.debug.Debug;
 import org.eclipse.osgi.internal.framework.EquinoxConfiguration;
 import org.eclipse.osgi.internal.framework.EquinoxContainer;
@@ -183,9 +189,11 @@
 		for (Map.Entry<Resource, List<Wire>> resultEntry : result.entrySet()) {
 			ModuleRevision revision = (ModuleRevision) resultEntry.getKey();
 			List<ModuleWire> requiredWires = new ArrayList<>(resultEntry.getValue().size());
+			List<String> seen = new ArrayList<>(5);
 			for (Wire wire : resultEntry.getValue()) {
 				ModuleWire moduleWire = new ModuleWire((ModuleCapability) wire.getCapability(), (ModuleRevision) wire.getProvider(), (ModuleRequirement) wire.getRequirement(), (ModuleRevision) wire.getRequirer());
-				requiredWires.add(moduleWire);
+				requiredWires.add(getInsertIndex(moduleWire.getCapability().getNamespace(), requiredWires, seen,
+						NamespaceList.WIRE), moduleWire);
 				Map<ModuleCapability, List<ModuleWire>> providedWiresMap = provided.get(moduleWire.getProvider());
 				if (providedWiresMap == null) {
 					providedWiresMap = new HashMap<>();
@@ -232,9 +240,9 @@
 		if (requiredWires == null)
 			requiredWires = Collections.emptyList();
 
-		List<ModuleCapability> capabilities = new ArrayList<>(revision.getModuleCapabilities(null));
+		List<ModuleCapability> capabilities = sortByNamespaceCopy(revision.getModuleCapabilities(null), CAPABILITY);
 		ListIterator<ModuleCapability> iCapabilities = capabilities.listIterator(capabilities.size());
-		List<ModuleRequirement> requirements = new ArrayList<>(revision.getModuleRequirements(null));
+		List<ModuleRequirement> requirements = sortByNamespaceCopy(revision.getModuleRequirements(null), REQUIREMENT);
 		ListIterator<ModuleRequirement> iRequirements = requirements.listIterator(requirements.size());
 
 		// if revision is a fragment remove payload requirements and capabilities
@@ -257,7 +265,33 @@
 		addProvidedWires(providedWireMap, providedWires, capabilities);
 
 		InternalUtils.filterCapabilityPermissions(capabilities);
-		return new ModuleWiring(revision, capabilities, requirements, providedWires, requiredWires, substituted);
+		return new ModuleWiring(revision, new NamespaceList<>(capabilities, CAPABILITY),
+				new NamespaceList<>(requirements, REQUIREMENT), new NamespaceList<>(providedWires, WIRE),
+				new NamespaceList<>(requiredWires, WIRE), substituted);
+	}
+
+	private <E> List<E> sortByNamespaceCopy(List<E> elements, Function<E, String> getNamespace) {
+		List<E> result = new ArrayList<>(elements.size());
+		List<String> seen = new ArrayList<>();
+		for (E e : elements) {
+			String namespace = getNamespace.apply(e);
+			result.add(getInsertIndex(namespace, result, seen, getNamespace), e);
+		}
+		return result;
+	}
+
+	private <E> int getInsertIndex(String namespace, List<E> elements, List<String> seen,
+			Function<E, String> getNamespace) {
+		if (seen.contains(namespace)) {
+			for (int i = elements.size() - 1; i > -1; i--) {
+				if (namespace.equals(getNamespace.apply(elements.get(i)))) {
+					return i + 1;
+				}
+			}
+			throw new IllegalStateException();
+		}
+		seen.add(namespace);
+		return elements.size();
 	}
 
 	private static void removePayloadContent(ListIterator<ModuleCapability> iCapabilities, ListIterator<ModuleRequirement> iRequirements) {
@@ -379,6 +413,9 @@
 						}
 					}
 				}
+				if (!iCapabilities.hasPrevious()) {
+					fastForward(iCapabilities);
+				}
 				iCapabilities.add(fragmentCapability);
 			}
 			// add fragment requirements
@@ -406,6 +443,9 @@
 						}
 					}
 				}
+				if (!iRequirements.hasPrevious()) {
+					fastForward(iRequirements);
+				}
 				iRequirements.add(fragmentRequirement);
 			}
 		}
@@ -466,10 +506,10 @@
 
 	private static ModuleWiring createWiringDelta(ModuleRevision revision, ModuleWiring existingWiring, Map<ModuleCapability, List<ModuleWire>> providedWireMap, List<ModuleWire> requiredWires) {
 		// No null checks are done here on the wires since this is a copy.
-		List<ModuleWire> existingProvidedWires = existingWiring.getProvidedModuleWires(null);
-		List<ModuleCapability> existingCapabilities = existingWiring.getModuleCapabilities(null);
-		List<ModuleWire> existingRequiredWires = existingWiring.getRequiredModuleWires(null);
-		List<ModuleRequirement> existingRequirements = existingWiring.getModuleRequirements(null);
+		List<ModuleWire> existingProvidedWires = existingWiring.getProvidedWires().copyList();
+		List<ModuleCapability> existingCapabilities = existingWiring.getCapabilities().copyList();
+		List<ModuleWire> existingRequiredWires = existingWiring.getRequiredWires().copyList();
+		List<ModuleRequirement> existingRequirements = existingWiring.getRequirements().copyList();
 
 		// First, add newly resolved fragment capabilities and requirements
 		if (providedWireMap != null) {
diff --git a/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/container/ModuleWiring.java b/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/container/ModuleWiring.java
index 7f21644..e63df7f 100644
--- a/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/container/ModuleWiring.java
+++ b/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/container/ModuleWiring.java
@@ -13,19 +13,39 @@
  *******************************************************************************/
 package org.eclipse.osgi.container;
 
+import static org.eclipse.osgi.internal.container.NamespaceList.CAPABILITY;
+import static org.eclipse.osgi.internal.container.NamespaceList.REQUIREMENT;
+import static org.eclipse.osgi.internal.container.NamespaceList.WIRE;
+
 import java.net.URL;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
 import java.util.concurrent.Callable;
 import java.util.concurrent.atomic.AtomicReference;
 import org.eclipse.osgi.container.ModuleRevisionBuilder.GenericInfo;
 import org.eclipse.osgi.internal.container.AtomicLazyInitializer;
 import org.eclipse.osgi.internal.container.InternalUtils;
+import org.eclipse.osgi.internal.container.NamespaceList;
 import org.osgi.framework.AdminPermission;
 import org.osgi.framework.Bundle;
 import org.osgi.framework.namespace.HostNamespace;
 import org.osgi.framework.namespace.PackageNamespace;
-import org.osgi.framework.wiring.*;
-import org.osgi.resource.*;
+import org.osgi.framework.wiring.BundleCapability;
+import org.osgi.framework.wiring.BundleRequirement;
+import org.osgi.framework.wiring.BundleRevision;
+import org.osgi.framework.wiring.BundleWire;
+import org.osgi.framework.wiring.BundleWiring;
+import org.osgi.resource.Capability;
+import org.osgi.resource.Requirement;
+import org.osgi.resource.Wire;
 
 /**
  * An implementation of {@link BundleWiring}.
@@ -45,24 +65,38 @@
 	private static final RuntimePermission GET_CLASSLOADER_PERM = new RuntimePermission("getClassLoader"); //$NON-NLS-1$
 	private static final String DYNAMICALLY_ADDED_IMPORT_DIRECTIVE = "x.dynamically.added"; //$NON-NLS-1$
 	private final ModuleRevision revision;
-	private volatile List<ModuleCapability> capabilities;
-	private volatile List<ModuleRequirement> requirements;
+	private volatile NamespaceList<ModuleCapability> capabilities;
+	private volatile NamespaceList<ModuleRequirement> requirements;
 	private final Collection<String> substitutedPkgNames;
 	private final AtomicLazyInitializer<ModuleLoader> loader = new AtomicLazyInitializer<>();
 	private final LoaderInitializer loaderInitializer = new LoaderInitializer();
-	private volatile List<ModuleWire> providedWires;
-	private volatile List<ModuleWire> requiredWires;
+	private volatile NamespaceList<ModuleWire> providedWires;
+	private volatile NamespaceList<ModuleWire> requiredWires;
 	volatile boolean isValid = true;
 	private final AtomicReference<Set<String>> dynamicMissRef = new AtomicReference<>();
 
-	ModuleWiring(ModuleRevision revision, List<ModuleCapability> capabilities, List<ModuleRequirement> requirements, List<ModuleWire> providedWires, List<ModuleWire> requiredWires, Collection<String> substitutedPkgNames) {
+	ModuleWiring(ModuleRevision revision, List<ModuleCapability> capabilities, List<ModuleRequirement> requirements,
+			List<ModuleWire> providedWires, List<ModuleWire> requiredWires, Collection<String> substitutedPkgNames) {
+		super();
+		this.revision = revision;
+		this.capabilities = new NamespaceList<>(capabilities, CAPABILITY);
+		this.requirements = new NamespaceList<>(requirements, REQUIREMENT);
+		this.providedWires = new NamespaceList<>(providedWires, WIRE);
+		this.requiredWires = new NamespaceList<>(requiredWires, WIRE);
+		this.substitutedPkgNames = substitutedPkgNames.isEmpty() ? Collections.<String> emptyList() : substitutedPkgNames;
+	}
+
+	ModuleWiring(ModuleRevision revision, NamespaceList<ModuleCapability> capabilities,
+			NamespaceList<ModuleRequirement> requirements, NamespaceList<ModuleWire> providedWires,
+			NamespaceList<ModuleWire> requiredWires, Collection<String> substitutedPkgNames) {
 		super();
 		this.revision = revision;
 		this.capabilities = capabilities;
 		this.requirements = requirements;
 		this.providedWires = providedWires;
 		this.requiredWires = requiredWires;
-		this.substitutedPkgNames = substitutedPkgNames.isEmpty() ? Collections.<String> emptyList() : substitutedPkgNames;
+		this.substitutedPkgNames = substitutedPkgNames.isEmpty() ? Collections.<String>emptyList()
+				: substitutedPkgNames;
 	}
 
 	@Override
@@ -98,21 +132,10 @@
 	 * @see #getCapabilities(String)
 	 */
 	public List<ModuleCapability> getModuleCapabilities(String namespace) {
-		return getModuleCapabilities(namespace, capabilities);
-	}
-
-	private List<ModuleCapability> getModuleCapabilities(String namespace, List<ModuleCapability> allCapabilities) {
-		if (!isValid)
+		if (!isValid) {
 			return null;
-		if (namespace == null)
-			return new ArrayList<>(allCapabilities);
-		List<ModuleCapability> result = new ArrayList<>();
-		for (ModuleCapability capability : allCapabilities) {
-			if (namespace.equals(capability.getNamespace())) {
-				result.add(capability);
-			}
 		}
-		return result;
+		return capabilities.getList(namespace);
 	}
 
 	/**
@@ -123,14 +146,17 @@
 	 * @see #getRequirements(String)
 	 */
 	public List<ModuleRequirement> getModuleRequirements(String namespace) {
-		return getModuleRequirements(namespace, requirements);
+		if (!isValid) {
+			return null;
+		}
+		return requirements.getList(namespace);
 	}
 
 	List<ModuleRequirement> getPersistentRequirements() {
-		List<ModuleRequirement> persistentRequriements = getModuleRequirements(null);
-		if (persistentRequriements == null) {
+		if (!isValid) {
 			return null;
 		}
+		List<ModuleRequirement> persistentRequriements = requirements.copyList();
 		for (Iterator<ModuleRequirement> iRequirements = persistentRequriements.iterator(); iRequirements.hasNext();) {
 			ModuleRequirement requirement = iRequirements.next();
 			if (PackageNamespace.PACKAGE_NAMESPACE.equals(requirement.getNamespace())) {
@@ -142,20 +168,6 @@
 		return persistentRequriements;
 	}
 
-	private List<ModuleRequirement> getModuleRequirements(String namespace, List<ModuleRequirement> allRequirements) {
-		if (!isValid)
-			return null;
-		if (namespace == null)
-			return new ArrayList<>(allRequirements);
-		List<ModuleRequirement> result = new ArrayList<>();
-		for (ModuleRequirement requirement : allRequirements) {
-			if (namespace.equals(requirement.getNamespace())) {
-				result.add(requirement);
-			}
-		}
-		return result;
-	}
-
 	@Override
 	public List<BundleCapability> getCapabilities(String namespace) {
 		return InternalUtils.asListBundleCapability(getModuleCapabilities(namespace));
@@ -197,11 +209,11 @@
 		return getPersistentWires(requiredWires);
 	}
 
-	private List<ModuleWire> getPersistentWires(List<ModuleWire> allWires) {
-		List<ModuleWire> persistentWires = getWires(null, allWires);
-		if (persistentWires == null) {
+	private List<ModuleWire> getPersistentWires(NamespaceList<ModuleWire> allWires) {
+		if (!isValid) {
 			return null;
 		}
+		List<ModuleWire> persistentWires = allWires.copyList();
 		for (Iterator<ModuleWire> iWires = persistentWires.iterator(); iWires.hasNext();) {
 			ModuleWire wire = iWires.next();
 			if (PackageNamespace.PACKAGE_NAMESPACE.equals(wire.getRequirement().getNamespace())) {
@@ -223,18 +235,11 @@
 		return InternalUtils.asListBundleWire(getWires(namespace, requiredWires));
 	}
 
-	private List<ModuleWire> getWires(String namespace, List<ModuleWire> allWires) {
-		if (!isValid)
+	private List<ModuleWire> getWires(String namespace, NamespaceList<ModuleWire> wires) {
+		if (!isValid) {
 			return null;
-		if (namespace == null)
-			return new ArrayList<>(allWires);
-		List<ModuleWire> result = new ArrayList<>();
-		for (ModuleWire moduleWire : allWires) {
-			if (namespace.equals(moduleWire.getCapability().getNamespace())) {
-				result.add(moduleWire);
-			}
 		}
-		return result;
+		return wires.getList(namespace);
 	}
 
 	@Override
@@ -332,18 +337,22 @@
 		return revision;
 	}
 
-	void setProvidedWires(List<ModuleWire> providedWires) {
+	void setProvidedWires(NamespaceList<ModuleWire> providedWires) {
 		this.providedWires = providedWires;
 	}
 
-	void setRequiredWires(List<ModuleWire> requiredWires) {
+	void setRequiredWires(NamespaceList<ModuleWire> requiredWires) {
 		this.requiredWires = requiredWires;
 	}
 
-	void setCapabilities(List<ModuleCapability> capabilities) {
+	void setCapabilities(NamespaceList<ModuleCapability> capabilities) {
 		this.capabilities = capabilities;
 	}
 
+	void setRequirements(NamespaceList<ModuleRequirement> requirements) {
+		this.requirements = requirements;
+	}
+
 	void unload() {
 		// When unloading a wiring we need to release the loader.
 		// This is so that the loaders are not pinned when stopping the framework.
@@ -427,9 +436,15 @@
 		ModuleDatabase moduleDatabase = revision.getRevisions().getContainer().moduleDatabase;
 		moduleDatabase.writeLock();
 		try {
-			List<ModuleRequirement> updatedRequirements = new ArrayList<>(requirements);
-			updatedRequirements.addAll(newRequirements);
-			requirements = updatedRequirements;
+			List<ModuleRequirement> updatedRequirements = requirements.copyList();
+			Entry<Integer, Integer> packageStartEnd = requirements
+					.getNamespaceIndex(PackageNamespace.PACKAGE_NAMESPACE);
+			if (packageStartEnd == null) {
+				updatedRequirements.addAll(newRequirements);
+			} else {
+				updatedRequirements.addAll(packageStartEnd.getValue(), newRequirements);
+			}
+			requirements = new NamespaceList<>(updatedRequirements, REQUIREMENT);
 		} finally {
 			moduleDatabase.writeUnlock();
 		}
@@ -468,15 +483,29 @@
 		}
 		// Could cache this, but seems unnecessary since it will only be used by the resolver
 		List<Wire> substitutionWires = new ArrayList<>(substitutedPkgNames.size());
-		List<ModuleWire> current = requiredWires;
+		List<ModuleWire> current = requiredWires.getList(PackageNamespace.PACKAGE_NAMESPACE);
 		for (ModuleWire wire : current) {
 			Capability cap = wire.getCapability();
-			if (PackageNamespace.PACKAGE_NAMESPACE.equals(cap.getNamespace())) {
-				if (substitutedPkgNames.contains(cap.getAttributes().get(PackageNamespace.PACKAGE_NAMESPACE))) {
-					substitutionWires.add(wire);
-				}
+			if (substitutedPkgNames.contains(cap.getAttributes().get(PackageNamespace.PACKAGE_NAMESPACE))) {
+				substitutionWires.add(wire);
 			}
 		}
 		return substitutionWires;
 	}
+
+	NamespaceList<ModuleCapability> getCapabilities() {
+		return capabilities;
+	}
+
+	NamespaceList<ModuleWire> getProvidedWires() {
+		return providedWires;
+	}
+
+	NamespaceList<ModuleRequirement> getRequirements() {
+		return requirements;
+	}
+
+	NamespaceList<ModuleWire> getRequiredWires() {
+		return requiredWires;
+	}
 }
diff --git a/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/internal/container/NamespaceList.java b/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/internal/container/NamespaceList.java
new file mode 100644
index 0000000..74375c1
--- /dev/null
+++ b/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/internal/container/NamespaceList.java
@@ -0,0 +1,163 @@
+/*******************************************************************************
+ * Copyright (c) 2021 IBM Corporation and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.osgi.internal.container;
+
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.function.Function;
+import org.eclipse.osgi.container.ModuleCapability;
+import org.eclipse.osgi.container.ModuleRequirement;
+import org.eclipse.osgi.container.ModuleWire;
+
+/**
+ * An immutable list of elements for which each element has a name space. All
+ * elements are kept in a single list to avoid creating a list for each name
+ * space. The elements provided at construction are assumed to be ordered such
+ * that all elements with the same name space are ordered together in one
+ * continuous sequence An indexes list is used to keep track of the beginning
+ * indexes for each namespace contained in the list. Assuming the number of
+ * namespaces used by a bundle is relatively small compared to the overall
+ * number of elements this makes it faster to find the first index for a
+ * specific namespace without having to iterate over the complete list of
+ * elements.
+ * 
+ * @param <E> The element type which will have a name space associated with it
+ */
+public class NamespaceList<E> {
+
+	public final static Function<ModuleWire, String> WIRE = wire -> {
+		return wire.getCapability().getNamespace();
+	};
+	public final static Function<ModuleCapability, String> CAPABILITY = ModuleCapability::getNamespace;
+	public final static Function<ModuleRequirement, String> REQUIREMENT = ModuleRequirement::getNamespace;
+
+	private final List<E> elements;
+	private final Map<String, List<E>> namespaces;
+
+	/**
+	 * Create a new name space list with the specified elements. The elements must
+	 * be sorted properly by name space.
+	 * 
+	 * @param elements     the ordered list of elements
+	 * @param getNamespace a function that retrieves the namespace for each element
+	 */
+	public NamespaceList(List<E> elements, Function<E, String> getNamespace) {
+		List<E> unmodifiableElements = Collections.unmodifiableList(elements);
+
+		Map<String, List<E>> tmpNamespaces = new LinkedHashMap<>(5);
+		int size = unmodifiableElements.size();
+		int currentStart = 0;
+		String current = null;
+
+		boolean consolidated = false;
+		for (int i = 0; i < size; i++) {
+			String namespace = getNamespace.apply(unmodifiableElements.get(i));
+			if (current == null) {
+				current = namespace;
+			}
+			if (!current.equals(namespace)) {
+				int currentEnd = i;
+				consolidated |= addNamespaceList(tmpNamespaces, unmodifiableElements, current, currentStart,
+						currentEnd);
+				current = namespace;
+				currentStart = i;
+			}
+		}
+		if (size > 0) {
+			// add the last namespace
+			consolidated |= addNamespaceList(tmpNamespaces, unmodifiableElements, current, currentStart, size);
+		}
+		if (consolidated) {
+			List<E> tmpElements = new ArrayList<>(size);
+			for (Entry<String, List<E>> e : tmpNamespaces.entrySet()) {
+				tmpElements.addAll(e.getValue());
+			}
+			this.elements = Collections.unmodifiableList(tmpElements);
+		} else {
+			this.elements = unmodifiableElements;
+		}
+		this.namespaces = Collections.unmodifiableMap(tmpNamespaces);
+	}
+
+	private boolean addNamespaceList(Map<String, List<E>> tmpNamespaces, List<E> unmodifiableElements, String namespace,
+			int start, int end) {
+		List<E> namespaceList = unmodifiableElements.subList(start, end);
+		List<E> existing = tmpNamespaces.get(namespace);
+		boolean consolidated = false;
+		if (existing != null) {
+			// This should be an error, consolidate the lists
+			List<E> consolidateList = new ArrayList<>(existing);
+			consolidateList.addAll(namespaceList);
+			namespaceList = Collections.unmodifiableList(consolidateList);
+			consolidated = true;
+		}
+		tmpNamespaces.put(namespace, namespaceList);
+		return consolidated;
+	}
+
+	public boolean isEmpty() {
+		return elements.isEmpty();
+	}
+
+	/**
+	 * returns an unmodifiable list of elements with the specified name space. An
+	 * empty list is returned if there are no elements with the specified namespace.
+	 * A {@code null} namespace can be used to get all elements.
+	 * 
+	 * @param namespace the name space of the elements to return. May be
+	 *                  {@code null}
+	 * @return The list of elements found
+	 */
+	public List<E> getList(String namespace) {
+		if (namespace == null) {
+			return elements;
+		}
+
+		return namespaces.getOrDefault(namespace, Collections.emptyList());
+	}
+
+	/**
+	 * Returns the beginning index (inclusively) and ending index (exclusively) or
+	 * {@code null} if no element has the specified namespace
+	 * 
+	 * @param namespace the name space to find the indexes for
+	 * @return indexes found for the namespace or {@code null} if no elements exist
+	 *         with the name space.
+	 */
+	public Entry<Integer, Integer> getNamespaceIndex(String namespace) {
+		int startIndex = 0;
+		for (Entry<String, ? extends List<E>> entry : namespaces.entrySet()) {
+			if (entry.getKey().equals(namespace)) {
+				int end = startIndex + entry.getValue().size();
+				return new AbstractMap.SimpleEntry<>(startIndex, end);
+			}
+			startIndex += entry.getValue().size();
+		}
+		return null;
+	}
+
+	/**
+	 * Returns a copy of all the elements in this list
+	 * 
+	 * @return a copy of all the elements in this list
+	 */
+	public List<E> copyList() {
+		return new ArrayList<>(elements);
+	}
+}
diff --git a/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/internal/loader/BundleLoader.java b/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/internal/loader/BundleLoader.java
index af785f6..a1f451e 100644
--- a/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/internal/loader/BundleLoader.java
+++ b/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/internal/loader/BundleLoader.java
@@ -174,7 +174,7 @@
 		// init the provided packages set
 		exportSources = new BundleLoaderSources(this);
 		List<ModuleCapability> exports = wiring.getModuleCapabilities(PackageNamespace.PACKAGE_NAMESPACE);
-		exports = exports == null ? new ArrayList<>(0) : exports;
+		exports = exports == null ? Collections.emptyList() : exports;
 		exportedPackages = Collections.synchronizedCollection(exports.size() > 10 ? new HashSet<String>(exports.size()) : new ArrayList<String>(exports.size()));
 		initializeExports(exports, exportSources, exportedPackages);
 
diff --git a/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/storage/NativeCodeFinder.java b/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/storage/NativeCodeFinder.java
index b7d5821..bc3b4f9 100644
--- a/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/storage/NativeCodeFinder.java
+++ b/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/storage/NativeCodeFinder.java
@@ -15,8 +15,14 @@
 package org.eclipse.osgi.storage;
 
 import java.io.File;
-import java.util.*;
-import org.eclipse.osgi.container.*;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import org.eclipse.osgi.container.ModuleRevision;
+import org.eclipse.osgi.container.ModuleWire;
+import org.eclipse.osgi.container.ModuleWiring;
 import org.eclipse.osgi.internal.debug.Debug;
 import org.eclipse.osgi.internal.framework.FilterImpl;
 import org.eclipse.osgi.internal.hookregistry.ClassLoaderHook;
@@ -174,7 +180,7 @@
 		}
 
 		List<ModuleWire> nativeCode = wiring.getRequiredModuleWires(NativeNamespace.NATIVE_NAMESPACE);
-		if (nativeCode.isEmpty()) {
+		if (nativeCode == null || nativeCode.isEmpty()) {
 			return Collections.emptyList();
 		}