diff --git a/src/corelib/kernel/qjniarray.h b/src/corelib/kernel/qjniarray.h
index f63433253da..7dbd3d475d2 100644
--- a/src/corelib/kernel/qjniarray.h
+++ b/src/corelib/kernel/qjniarray.h
@@ -181,6 +181,13 @@ class QJniArrayBase
                                                      >
                                       > : std::true_type {};
 
+    template <typename C, typename = void> struct HasEmplaceBackTest : std::false_type {};
+    template <typename C> struct HasEmplaceBackTest<C,
+        std::void_t<decltype(std::declval<C>().emplace_back(std::declval<typename C::value_type>()))>
+                                                        > : std::true_type
+    {};
+
+
 protected:
     // these are used in QJniArray
     template <typename C, typename = void>
@@ -205,6 +212,24 @@ protected:
     template <typename From, typename To>
     using unless_convertible = std::enable_if_t<!QtPrivate::AreArgumentsConvertibleWithoutNarrowingBase<From, To>::value, bool>;
 
+    // helpers for toContainer
+    template <typename E> struct ToContainerHelper { using type = QList<E>; };
+    template <> struct ToContainerHelper<jstring> { using type = QStringList; };
+    template <> struct ToContainerHelper<jbyte> { using type = QByteArray; };
+    template <> struct ToContainerHelper<char> { using type = QByteArray; };
+
+    template <typename E>
+    using ToContainerType = typename ToContainerHelper<E>::type;
+
+    template <typename E, typename CRef, typename C = q20::remove_cvref_t<CRef>>
+    static constexpr bool isCompatibleTargetContainer =
+        (QtPrivate::AreArgumentsConvertibleWithoutNarrowingBase<E, typename C::value_type>::value
+         || QtPrivate::AreArgumentsConvertibleWithoutNarrowingBase<typename ToContainerType<E>::value_type,
+                                                                   typename C::value_type>::value
+         || (std::is_base_of_v<QtJniTypes::JObjectBase, E> && std::is_same_v<typename C::value_type, QString>))
+        && (qxp::is_detected_v<HasEmplaceBackTest, C>
+            || (isContiguousContainer<C> && ElementTypeHelper<C>::isPrimitive));
+
 public:
     using size_type = jsize;
     using difference_type = size_type;
@@ -236,6 +261,8 @@ public:
 
     template <typename C>
     using if_compatible_source_container = std::enable_if_t<isCompatibleSourceContainer<C>, bool>;
+    template <typename T, typename C>
+    using if_compatible_target_container = std::enable_if_t<isCompatibleTargetContainer<T, C>, bool>;
 
     template <typename Container, if_compatible_source_container<Container> = true>
     static auto fromContainer(Container &&container)
@@ -332,13 +359,10 @@ class QJniArray : public QJniArrayBase
 {
     friend struct QJniArrayIterator<T>;
 
-    template <typename E> struct ToContainerHelper { using type = QList<E>; };
-    template <> struct ToContainerHelper<jstring> { using type = QStringList; };
-    template <> struct ToContainerHelper<jbyte> { using type = QByteArray; };
-    template <> struct ToContainerHelper<char> { using type = QByteArray; };
-
-    template <typename E>
-    using ToContainerType = typename ToContainerHelper<E>::type;
+    template <typename C>
+    using CanReserveTest = decltype(std::declval<C>().reserve(0));
+    template <typename C>
+    static constexpr bool canReserve = qxp::is_detected_v<CanReserveTest, C>;
 
 public:
     using Type = T;
@@ -480,7 +504,7 @@ public:
         }
     }
 
-    template <typename Container = ToContainerType<T>>
+    template <typename Container = ToContainerType<T>, if_compatible_target_container<T, Container> = true>
     Container toContainer(Container &&container = {}) const
     {
         const qsizetype sz = size();
@@ -490,7 +514,8 @@ public:
 
         using ContainerType = q20::remove_cvref_t<Container>;
 
-        container.reserve(sz);
+        if constexpr (canReserve<ContainerType>)
+            container.reserve(sz);
         if constexpr (std::is_same_v<typename ContainerType::value_type, QString>) {
             for (auto element : *this) {
                 if constexpr (std::is_same_v<decltype(element), QString>)
diff --git a/src/corelib/kernel/qjniarray.qdoc b/src/corelib/kernel/qjniarray.qdoc
index 727f60e6497..633586a1db1 100644
--- a/src/corelib/kernel/qjniarray.qdoc
+++ b/src/corelib/kernel/qjniarray.qdoc
@@ -410,7 +410,7 @@
 */
 
 /*!
-    \fn template <typename T> template <typename Container> Container QJniArray<T>::toContainer(Container &&container) const
+    \fn template <typename T> template <typename Container, QJniArrayBase::if_compatible_target_container<T, Container>> Container QJniArray<T>::toContainer(Container &&container) const
 
     \return a container populated with the data in the wrapped Java array.
 
diff --git a/tests/auto/corelib/kernel/qjniarray/tst_qjniarray.cpp b/tests/auto/corelib/kernel/qjniarray/tst_qjniarray.cpp
index 61637abf972..ead87713371 100644
--- a/tests/auto/corelib/kernel/qjniarray/tst_qjniarray.cpp
+++ b/tests/auto/corelib/kernel/qjniarray/tst_qjniarray.cpp
@@ -367,6 +367,29 @@ void tst_QJniArray::ordering()
     QCOMPARE_GT(arrayEnd, arrayBegin);
 }
 
+template <typename T, typename C>
+using ToContainerTest = decltype(std::declval<QJniArray<T>>().toContainer(std::declval<C>()));
+
+template <typename T, typename C>
+static constexpr bool hasToContainer = qxp::is_detected_v<ToContainerTest, T, C>;
+
+static_assert(hasToContainer<jint, QList<jint>>);
+static_assert(hasToContainer<jint, QList<int>>);
+
+static_assert(hasToContainer<jbyte, QByteArray>);
+static_assert(hasToContainer<jstring, QStringList>);
+static_assert(hasToContainer<String, QStringList>);
+static_assert(hasToContainer<jchar, std::list<jchar>>);
+static_assert(hasToContainer<jbyte, std::vector<jbyte>>);
+// different types but doesn't narrow
+static_assert(hasToContainer<jshort, QList<int>>);
+static_assert(hasToContainer<jfloat, QList<jdouble>>);
+// would narrow
+static_assert(!hasToContainer<jlong, QList<short>>);
+static_assert(!hasToContainer<jdouble, QList<jfloat>>);
+// incompatible types
+static_assert(!hasToContainer<jstring, QByteArray>);
+
 void tst_QJniArray::toContainer()
 {
     std::vector<jchar> charVector{u'a', u'b', u'c'};
@@ -377,6 +400,10 @@ void tst_QJniArray::toContainer()
 
     QCOMPARE(vector, charVector);
     QCOMPARE(charArray.toContainer<std::vector<jchar>>(), charVector);
+
+    // non-contiguous container of primitive elements
+    std::list charList = charArray.toContainer<std::list<jchar>>();
+    QCOMPARE(charList.size(), charVector.size());
 }
 
 void tst_QJniArray::pointerToValue()