diff --git a/cpp/src/arrow/array/array_base.h b/cpp/src/arrow/array/array_base.h
index 716ae072206..45cefdb1a12 100644
--- a/cpp/src/arrow/array/array_base.h
+++ b/cpp/src/arrow/array/array_base.h
@@ -24,6 +24,7 @@
 #include <vector>
 
 #include "arrow/array/data.h"
+#include "arrow/array/statistics.h"
 #include "arrow/buffer.h"
 #include "arrow/compare.h"
 #include "arrow/result.h"
@@ -232,6 +233,11 @@ class ARROW_EXPORT Array {
   /// \return DeviceAllocationType
   DeviceAllocationType device_type() const { return data_->device_type(); }
 
+  /// \brief Return the statistics of this Array
+  ///
+  /// \return const std::shared_ptr<ArrayStatistics>&
+  const std::shared_ptr<ArrayStatistics>& statistics() const { return statistics_; }
+
  protected:
   Array() = default;
   ARROW_DEFAULT_MOVE_AND_ASSIGN(Array);
@@ -239,8 +245,20 @@ class ARROW_EXPORT Array {
   std::shared_ptr<ArrayData> data_;
   const uint8_t* null_bitmap_data_ = NULLPTR;
 
-  /// Protected method for constructors
-  void SetData(const std::shared_ptr<ArrayData>& data) {
+  /// Protected method for constructors. This must be called from each
+  /// array class to call its SetData(). You can't use call this in a
+  /// parent array class.
+  void Init(const std::shared_ptr<ArrayData>& data,
+            const std::shared_ptr<ArrayStatistics>& statistics) {
+    SetData(data);
+    if (statistics) {
+      SetStatistics(statistics);
+    }
+  }
+
+  /// Protected method for constructors. Don't call this method
+  /// directly. This should be called from Init().
+  virtual void SetData(const std::shared_ptr<ArrayData>& data) {
     if (data->buffers.size() > 0) {
       null_bitmap_data_ = data->GetValuesSafe<uint8_t>(0, /*offset=*/0);
     } else {
@@ -249,6 +267,15 @@ class ARROW_EXPORT Array {
     data_ = data;
   }
 
+  // The statistics for this Array.
+  std::shared_ptr<ArrayStatistics> statistics_;
+
+  /// Protected method for constructors. Don't call this method
+  /// directly. This should be called from Init().
+  void SetStatistics(const std::shared_ptr<ArrayStatistics>& statistics) {
+    statistics_ = statistics;
+  }
+
  private:
   ARROW_DISALLOW_COPY_AND_ASSIGN(Array);
 
@@ -261,32 +288,22 @@ static inline std::ostream& operator<<(std::ostream& os, const Array& x) {
 }
 
 /// Base class for non-nested arrays
-class ARROW_EXPORT FlatArray : public Array {
- protected:
-  using Array::Array;
-};
+class ARROW_EXPORT FlatArray : public Array {};
 
 /// Base class for arrays of fixed-size logical types
 class ARROW_EXPORT PrimitiveArray : public FlatArray {
  public:
-  PrimitiveArray(const std::shared_ptr<DataType>& type, int64_t length,
-                 const std::shared_ptr<Buffer>& data,
-                 const std::shared_ptr<Buffer>& null_bitmap = NULLPTR,
-                 int64_t null_count = kUnknownNullCount, int64_t offset = 0);
-
   /// Does not account for any slice offset
   const std::shared_ptr<Buffer>& values() const { return data_->buffers[1]; }
 
  protected:
   PrimitiveArray() : raw_values_(NULLPTR) {}
 
-  void SetData(const std::shared_ptr<ArrayData>& data) {
-    this->Array::SetData(data);
+  void SetData(const std::shared_ptr<ArrayData>& data) override {
+    Array::SetData(data);
     raw_values_ = data->GetValuesSafe<uint8_t>(1, /*offset=*/0);
   }
 
-  explicit PrimitiveArray(const std::shared_ptr<ArrayData>& data) { SetData(data); }
-
   const uint8_t* raw_values_;
 };
 
@@ -295,11 +312,14 @@ class ARROW_EXPORT NullArray : public FlatArray {
  public:
   using TypeClass = NullType;
 
-  explicit NullArray(const std::shared_ptr<ArrayData>& data) { SetData(data); }
+  explicit NullArray(const std::shared_ptr<ArrayData>& data,
+                     const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR) {
+    Init(data, statistics);
+  }
   explicit NullArray(int64_t length);
 
  private:
-  void SetData(const std::shared_ptr<ArrayData>& data) {
+  void SetData(const std::shared_ptr<ArrayData>& data) override {
     null_bitmap_data_ = NULLPTR;
     data->null_count = data->length;
     data_ = data;
diff --git a/cpp/src/arrow/array/array_binary.cc b/cpp/src/arrow/array/array_binary.cc
index d83ba0ca893..9a781e1798e 100644
--- a/cpp/src/arrow/array/array_binary.cc
+++ b/cpp/src/arrow/array/array_binary.cc
@@ -32,36 +32,19 @@ namespace arrow {
 
 using internal::checked_cast;
 
-BinaryArray::BinaryArray(const std::shared_ptr<ArrayData>& data) {
+void BinaryArray::SetData(const std::shared_ptr<ArrayData>& data) {
   ARROW_CHECK(is_binary_like(data->type->id()));
-  SetData(data);
+  BaseBinaryArray<BinaryType>::SetData(data);
 }
 
-BinaryArray::BinaryArray(int64_t length, const std::shared_ptr<Buffer>& value_offsets,
-                         const std::shared_ptr<Buffer>& data,
-                         const std::shared_ptr<Buffer>& null_bitmap, int64_t null_count,
-                         int64_t offset) {
-  SetData(ArrayData::Make(binary(), length, {null_bitmap, value_offsets, data},
-                          null_count, offset));
-}
-
-LargeBinaryArray::LargeBinaryArray(const std::shared_ptr<ArrayData>& data) {
+void LargeBinaryArray::SetData(const std::shared_ptr<ArrayData>& data) {
   ARROW_CHECK(is_large_binary_like(data->type->id()));
-  SetData(data);
+  BaseBinaryArray<LargeBinaryType>::SetData(data);
 }
 
-LargeBinaryArray::LargeBinaryArray(int64_t length,
-                                   const std::shared_ptr<Buffer>& value_offsets,
-                                   const std::shared_ptr<Buffer>& data,
-                                   const std::shared_ptr<Buffer>& null_bitmap,
-                                   int64_t null_count, int64_t offset) {
-  SetData(ArrayData::Make(large_binary(), length, {null_bitmap, value_offsets, data},
-                          null_count, offset));
-}
-
-StringArray::StringArray(const std::shared_ptr<ArrayData>& data) {
+void StringArray::SetData(const std::shared_ptr<ArrayData>& data) {
   ARROW_CHECK_EQ(data->type->id(), Type::STRING);
-  SetData(data);
+  BinaryArray::SetData(data);
 }
 
 StringArray::StringArray(int64_t length, const std::shared_ptr<Buffer>& value_offsets,
@@ -74,9 +57,9 @@ StringArray::StringArray(int64_t length, const std::shared_ptr<Buffer>& value_of
 
 Status StringArray::ValidateUTF8() const { return internal::ValidateUTF8(*data_); }
 
-LargeStringArray::LargeStringArray(const std::shared_ptr<ArrayData>& data) {
+void LargeStringArray::SetData(const std::shared_ptr<ArrayData>& data) {
   ARROW_CHECK_EQ(data->type->id(), Type::LARGE_STRING);
-  SetData(data);
+  LargeBinaryArray::SetData(data);
 }
 
 LargeStringArray::LargeStringArray(int64_t length,
@@ -90,19 +73,27 @@ LargeStringArray::LargeStringArray(int64_t length,
 
 Status LargeStringArray::ValidateUTF8() const { return internal::ValidateUTF8(*data_); }
 
-BinaryViewArray::BinaryViewArray(std::shared_ptr<ArrayData> data) {
-  ARROW_CHECK_EQ(data->type->id(), Type::BINARY_VIEW);
-  SetData(std::move(data));
+void BinaryViewArray::SetData(const std::shared_ptr<ArrayData>& data) {
+  ARROW_CHECK_EQ(data->type->id(), expected_type_id());
+  FlatArray::SetData(data);
+  raw_values_ = data_->GetValuesSafe<c_type>(1);
+}
+
+namespace {
+void InitViewArrayBuffers(BufferVector& buffers, std::shared_ptr<Buffer> views,
+                          std::shared_ptr<Buffer> null_bitmap) {
+  buffers.insert(buffers.begin(), std::move(views));
+  buffers.insert(buffers.begin(), std::move(null_bitmap));
 }
+};  // namespace
 
 BinaryViewArray::BinaryViewArray(std::shared_ptr<DataType> type, int64_t length,
                                  std::shared_ptr<Buffer> views, BufferVector buffers,
                                  std::shared_ptr<Buffer> null_bitmap, int64_t null_count,
                                  int64_t offset) {
-  buffers.insert(buffers.begin(), std::move(views));
-  buffers.insert(buffers.begin(), std::move(null_bitmap));
-  SetData(
-      ArrayData::Make(std::move(type), length, std::move(buffers), null_count, offset));
+  InitViewArrayBuffers(buffers, std::move(views), std::move(null_bitmap));
+  Init(ArrayData::Make(std::move(type), length, std::move(buffers), null_count, offset),
+       nullptr);
 }
 
 std::string_view BinaryViewArray::GetView(int64_t i) const {
@@ -110,25 +101,22 @@ std::string_view BinaryViewArray::GetView(int64_t i) const {
   return util::FromBinaryView(raw_values_[i], data_buffers);
 }
 
-StringViewArray::StringViewArray(std::shared_ptr<ArrayData> data) {
-  ARROW_CHECK_EQ(data->type->id(), Type::STRING_VIEW);
-  SetData(std::move(data));
+StringViewArray::StringViewArray(std::shared_ptr<DataType> type, int64_t length,
+                                 std::shared_ptr<Buffer> views, BufferVector buffers,
+                                 std::shared_ptr<Buffer> null_bitmap, int64_t null_count,
+                                 int64_t offset) {
+  InitViewArrayBuffers(buffers, std::move(views), std::move(null_bitmap));
+  Init(ArrayData::Make(std::move(type), length, std::move(buffers), null_count, offset),
+       nullptr);
 }
 
 Status StringViewArray::ValidateUTF8() const { return internal::ValidateUTF8(*data_); }
 
-FixedSizeBinaryArray::FixedSizeBinaryArray(const std::shared_ptr<ArrayData>& data) {
-  SetData(data);
+void FixedSizeBinaryArray::SetData(const std::shared_ptr<ArrayData>& data) {
+  PrimitiveArray::SetData(data);
+  byte_width_ = internal::checked_cast<const FixedSizeBinaryType&>(*type()).byte_width();
 }
 
-FixedSizeBinaryArray::FixedSizeBinaryArray(const std::shared_ptr<DataType>& type,
-                                           int64_t length,
-                                           const std::shared_ptr<Buffer>& data,
-                                           const std::shared_ptr<Buffer>& null_bitmap,
-                                           int64_t null_count, int64_t offset)
-    : PrimitiveArray(type, length, data, null_bitmap, null_count, offset),
-      byte_width_(checked_cast<const FixedSizeBinaryType&>(*type).byte_width()) {}
-
 const uint8_t* FixedSizeBinaryArray::GetValue(int64_t i) const {
   return raw_values_ + (i + data_->offset) * byte_width_;
 }
diff --git a/cpp/src/arrow/array/array_binary.h b/cpp/src/arrow/array/array_binary.h
index 19fdee61243..7c6e96882d2 100644
--- a/cpp/src/arrow/array/array_binary.h
+++ b/cpp/src/arrow/array/array_binary.h
@@ -142,8 +142,8 @@ class BaseBinaryArray : public FlatArray {
   BaseBinaryArray() = default;
 
   // Protected method for constructors
-  void SetData(const std::shared_ptr<ArrayData>& data) {
-    this->Array::SetData(data);
+  void SetData(const std::shared_ptr<ArrayData>& data) override {
+    Array::SetData(data);
     raw_value_offsets_ = data->GetValuesSafe<offset_type>(1, /*offset=*/0);
     raw_data_ = data->GetValuesSafe<uint8_t>(2, /*offset=*/0);
   }
@@ -155,16 +155,23 @@ class BaseBinaryArray : public FlatArray {
 /// Concrete Array class for variable-size binary data
 class ARROW_EXPORT BinaryArray : public BaseBinaryArray<BinaryType> {
  public:
-  explicit BinaryArray(const std::shared_ptr<ArrayData>& data);
+  explicit BinaryArray(const std::shared_ptr<ArrayData>& data,
+                       const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR) {
+    Init(data, statistics);
+  }
 
   BinaryArray(int64_t length, const std::shared_ptr<Buffer>& value_offsets,
               const std::shared_ptr<Buffer>& data,
               const std::shared_ptr<Buffer>& null_bitmap = NULLPTR,
-              int64_t null_count = kUnknownNullCount, int64_t offset = 0);
+              int64_t null_count = kUnknownNullCount, int64_t offset = 0)
+      : BinaryArray(ArrayData::Make(binary(), length, {null_bitmap, value_offsets, data},
+                                    null_count, offset)) {}
 
  protected:
   // For subclasses such as StringArray
   BinaryArray() : BaseBinaryArray() {}
+
+  void SetData(const std::shared_ptr<ArrayData>& data) override;
 };
 
 /// Concrete Array class for variable-size string (utf-8) data
@@ -172,7 +179,10 @@ class ARROW_EXPORT StringArray : public BinaryArray {
  public:
   using TypeClass = StringType;
 
-  explicit StringArray(const std::shared_ptr<ArrayData>& data);
+  explicit StringArray(const std::shared_ptr<ArrayData>& data,
+                       const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR) {
+    Init(data, statistics);
+  }
 
   StringArray(int64_t length, const std::shared_ptr<Buffer>& value_offsets,
               const std::shared_ptr<Buffer>& data,
@@ -183,21 +193,33 @@ class ARROW_EXPORT StringArray : public BinaryArray {
   ///
   /// This check is also implied by ValidateFull()
   Status ValidateUTF8() const;
+
+ protected:
+  void SetData(const std::shared_ptr<ArrayData>& data) override;
 };
 
 /// Concrete Array class for large variable-size binary data
 class ARROW_EXPORT LargeBinaryArray : public BaseBinaryArray<LargeBinaryType> {
  public:
-  explicit LargeBinaryArray(const std::shared_ptr<ArrayData>& data);
+  explicit LargeBinaryArray(
+      const std::shared_ptr<ArrayData>& data,
+      const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR) {
+    Init(data, statistics);
+  }
 
   LargeBinaryArray(int64_t length, const std::shared_ptr<Buffer>& value_offsets,
                    const std::shared_ptr<Buffer>& data,
                    const std::shared_ptr<Buffer>& null_bitmap = NULLPTR,
-                   int64_t null_count = kUnknownNullCount, int64_t offset = 0);
+                   int64_t null_count = kUnknownNullCount, int64_t offset = 0)
+      : LargeBinaryArray(ArrayData::Make(large_binary(), length,
+                                         {null_bitmap, value_offsets, data}, null_count,
+                                         offset)) {}
 
  protected:
   // For subclasses such as LargeStringArray
   LargeBinaryArray() : BaseBinaryArray() {}
+
+  void SetData(const std::shared_ptr<ArrayData>& data) override;
 };
 
 /// Concrete Array class for large variable-size string (utf-8) data
@@ -205,7 +227,11 @@ class ARROW_EXPORT LargeStringArray : public LargeBinaryArray {
  public:
   using TypeClass = LargeStringType;
 
-  explicit LargeStringArray(const std::shared_ptr<ArrayData>& data);
+  explicit LargeStringArray(
+      const std::shared_ptr<ArrayData>& data,
+      const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR) {
+    Init(data, statistics);
+  }
 
   LargeStringArray(int64_t length, const std::shared_ptr<Buffer>& value_offsets,
                    const std::shared_ptr<Buffer>& data,
@@ -216,6 +242,9 @@ class ARROW_EXPORT LargeStringArray : public LargeBinaryArray {
   ///
   /// This check is also implied by ValidateFull()
   Status ValidateUTF8() const;
+
+ protected:
+  void SetData(const std::shared_ptr<ArrayData>& data) override;
 };
 
 // ----------------------------------------------------------------------
@@ -229,7 +258,10 @@ class ARROW_EXPORT BinaryViewArray : public FlatArray {
   using IteratorType = stl::ArrayIterator<BinaryViewArray>;
   using c_type = BinaryViewType::c_type;
 
-  explicit BinaryViewArray(std::shared_ptr<ArrayData> data);
+  explicit BinaryViewArray(std::shared_ptr<ArrayData> data,
+                           const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR) {
+    Init(data, statistics);
+  }
 
   BinaryViewArray(std::shared_ptr<DataType> type, int64_t length,
                   std::shared_ptr<Buffer> views, BufferVector data_buffers,
@@ -251,12 +283,12 @@ class ARROW_EXPORT BinaryViewArray : public FlatArray {
   IteratorType end() const { return IteratorType(*this, length()); }
 
  protected:
-  using FlatArray::FlatArray;
+  // This constructor defers Init() to a derived array class
+  BinaryViewArray() = default;
 
-  void SetData(std::shared_ptr<ArrayData> data) {
-    FlatArray::SetData(std::move(data));
-    raw_values_ = data_->GetValuesSafe<c_type>(1);
-  }
+  void SetData(const std::shared_ptr<ArrayData>& data) override;
+
+  virtual Type::type expected_type_id() const { return TypeClass::type_id; }
 
   const c_type* raw_values_;
 };
@@ -267,14 +299,23 @@ class ARROW_EXPORT StringViewArray : public BinaryViewArray {
  public:
   using TypeClass = StringViewType;
 
-  explicit StringViewArray(std::shared_ptr<ArrayData> data);
+  explicit StringViewArray(std::shared_ptr<ArrayData> data,
+                           const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR) {
+    Init(data, statistics);
+  }
 
-  using BinaryViewArray::BinaryViewArray;
+  StringViewArray(std::shared_ptr<DataType> type, int64_t length,
+                  std::shared_ptr<Buffer> views, BufferVector data_buffers,
+                  std::shared_ptr<Buffer> null_bitmap = NULLPTR,
+                  int64_t null_count = kUnknownNullCount, int64_t offset = 0);
 
   /// \brief Validate that this array contains only valid UTF8 entries
   ///
   /// This check is also implied by ValidateFull()
   Status ValidateUTF8() const;
+
+ protected:
+  Type::type expected_type_id() const override { return TypeClass::type_id; }
 };
 
 // ----------------------------------------------------------------------
@@ -286,12 +327,18 @@ class ARROW_EXPORT FixedSizeBinaryArray : public PrimitiveArray {
   using TypeClass = FixedSizeBinaryType;
   using IteratorType = stl::ArrayIterator<FixedSizeBinaryArray>;
 
-  explicit FixedSizeBinaryArray(const std::shared_ptr<ArrayData>& data);
+  explicit FixedSizeBinaryArray(
+      const std::shared_ptr<ArrayData>& data,
+      const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR) {
+    Init(data, statistics);
+  }
 
   FixedSizeBinaryArray(const std::shared_ptr<DataType>& type, int64_t length,
                        const std::shared_ptr<Buffer>& data,
                        const std::shared_ptr<Buffer>& null_bitmap = NULLPTR,
-                       int64_t null_count = kUnknownNullCount, int64_t offset = 0);
+                       int64_t null_count = kUnknownNullCount, int64_t offset = 0)
+      : FixedSizeBinaryArray(
+            ArrayData::Make(type, length, {null_bitmap, data}, null_count, offset)) {}
 
   const uint8_t* GetValue(int64_t i) const;
   const uint8_t* Value(int64_t i) const { return GetValue(i); }
@@ -315,11 +362,10 @@ class ARROW_EXPORT FixedSizeBinaryArray : public PrimitiveArray {
   IteratorType end() const { return IteratorType(*this, length()); }
 
  protected:
-  void SetData(const std::shared_ptr<ArrayData>& data) {
-    this->PrimitiveArray::SetData(data);
-    byte_width_ =
-        internal::checked_cast<const FixedSizeBinaryType&>(*type()).byte_width();
-  }
+  // This constructor defers Init() to a derived array class
+  FixedSizeBinaryArray() = default;
+
+  void SetData(const std::shared_ptr<ArrayData>& data) override;
 
   int32_t byte_width_;
 };
diff --git a/cpp/src/arrow/array/array_decimal.cc b/cpp/src/arrow/array/array_decimal.cc
index d65f6ee5356..75085b4dcca 100644
--- a/cpp/src/arrow/array/array_decimal.cc
+++ b/cpp/src/arrow/array/array_decimal.cc
@@ -35,9 +35,10 @@ using internal::checked_cast;
 // ----------------------------------------------------------------------
 // Decimal128
 
-Decimal128Array::Decimal128Array(const std::shared_ptr<ArrayData>& data)
-    : FixedSizeBinaryArray(data) {
+Decimal128Array::Decimal128Array(const std::shared_ptr<ArrayData>& data,
+                                 const std::shared_ptr<ArrayStatistics>& statistics) {
   ARROW_CHECK_EQ(data->type->id(), Type::DECIMAL128);
+  Init(data, statistics);
 }
 
 std::string Decimal128Array::FormatValue(int64_t i) const {
@@ -49,9 +50,10 @@ std::string Decimal128Array::FormatValue(int64_t i) const {
 // ----------------------------------------------------------------------
 // Decimal256
 
-Decimal256Array::Decimal256Array(const std::shared_ptr<ArrayData>& data)
-    : FixedSizeBinaryArray(data) {
+Decimal256Array::Decimal256Array(const std::shared_ptr<ArrayData>& data,
+                                 const std::shared_ptr<ArrayStatistics>& statistics) {
   ARROW_CHECK_EQ(data->type->id(), Type::DECIMAL256);
+  Init(data, statistics);
 }
 
 std::string Decimal256Array::FormatValue(int64_t i) const {
diff --git a/cpp/src/arrow/array/array_decimal.h b/cpp/src/arrow/array/array_decimal.h
index f1481254908..5589c06db3c 100644
--- a/cpp/src/arrow/array/array_decimal.h
+++ b/cpp/src/arrow/array/array_decimal.h
@@ -43,7 +43,8 @@ class ARROW_EXPORT Decimal128Array : public FixedSizeBinaryArray {
   using FixedSizeBinaryArray::FixedSizeBinaryArray;
 
   /// \brief Construct Decimal128Array from ArrayData instance
-  explicit Decimal128Array(const std::shared_ptr<ArrayData>& data);
+  explicit Decimal128Array(const std::shared_ptr<ArrayData>& data,
+                           const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR);
 
   std::string FormatValue(int64_t i) const;
 };
@@ -62,7 +63,8 @@ class ARROW_EXPORT Decimal256Array : public FixedSizeBinaryArray {
   using FixedSizeBinaryArray::FixedSizeBinaryArray;
 
   /// \brief Construct Decimal256Array from ArrayData instance
-  explicit Decimal256Array(const std::shared_ptr<ArrayData>& data);
+  explicit Decimal256Array(const std::shared_ptr<ArrayData>& data,
+                           const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR);
 
   std::string FormatValue(int64_t i) const;
 };
diff --git a/cpp/src/arrow/array/array_dict.cc b/cpp/src/arrow/array/array_dict.cc
index 7fd76a1dae8..1e1c5e088ff 100644
--- a/cpp/src/arrow/array/array_dict.cc
+++ b/cpp/src/arrow/array/array_dict.cc
@@ -78,15 +78,16 @@ int64_t DictionaryArray::GetValueIndex(int64_t i) const {
   }
 }
 
-DictionaryArray::DictionaryArray(const std::shared_ptr<ArrayData>& data)
+DictionaryArray::DictionaryArray(const std::shared_ptr<ArrayData>& data,
+                                 const std::shared_ptr<ArrayStatistics>& statistics)
     : dict_type_(checked_cast<const DictionaryType*>(data->type.get())) {
   ARROW_CHECK_EQ(data->type->id(), Type::DICTIONARY);
   ARROW_CHECK_NE(data->dictionary, nullptr);
-  SetData(data);
+  Init(data, statistics);
 }
 
 void DictionaryArray::SetData(const std::shared_ptr<ArrayData>& data) {
-  this->Array::SetData(data);
+  Array::SetData(data);
   auto indices_data = data_->Copy();
   indices_data->type = dict_type_->index_type();
   indices_data->dictionary = nullptr;
@@ -104,7 +105,7 @@ DictionaryArray::DictionaryArray(const std::shared_ptr<DataType>& type,
   auto data = indices->data()->Copy();
   data->type = type;
   data->dictionary = dictionary->data();
-  SetData(data);
+  Init(data, nullptr);
 }
 
 const std::shared_ptr<Array>& DictionaryArray::dictionary() const {
diff --git a/cpp/src/arrow/array/array_dict.h b/cpp/src/arrow/array/array_dict.h
index bf376b51f8c..32cb78ebb2e 100644
--- a/cpp/src/arrow/array/array_dict.h
+++ b/cpp/src/arrow/array/array_dict.h
@@ -54,7 +54,8 @@ class ARROW_EXPORT DictionaryArray : public Array {
  public:
   using TypeClass = DictionaryType;
 
-  explicit DictionaryArray(const std::shared_ptr<ArrayData>& data);
+  explicit DictionaryArray(const std::shared_ptr<ArrayData>& data,
+                           const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR);
 
   DictionaryArray(const std::shared_ptr<DataType>& type,
                   const std::shared_ptr<Array>& indices,
@@ -114,7 +115,7 @@ class ARROW_EXPORT DictionaryArray : public Array {
   const DictionaryType* dict_type() const { return dict_type_; }
 
  private:
-  void SetData(const std::shared_ptr<ArrayData>& data);
+  void SetData(const std::shared_ptr<ArrayData>& data) override;
   const DictionaryType* dict_type_;
   std::shared_ptr<Array> indices_;
 
diff --git a/cpp/src/arrow/array/array_nested.cc b/cpp/src/arrow/array/array_nested.cc
index 47c0fd35829..cae033679f1 100644
--- a/cpp/src/arrow/array/array_nested.cc
+++ b/cpp/src/arrow/array/array_nested.cc
@@ -518,10 +518,6 @@ Result<std::shared_ptr<Array>> FlattenLogicalListRecursively(const Array& in_arr
 // ----------------------------------------------------------------------
 // ListArray
 
-ListArray::ListArray(std::shared_ptr<ArrayData> data) {
-  ListArray::SetData(std::move(data));
-}
-
 ListArray::ListArray(std::shared_ptr<DataType> type, int64_t length,
                      std::shared_ptr<Buffer> value_offsets, std::shared_ptr<Array> values,
                      std::shared_ptr<Buffer> null_bitmap, int64_t null_count,
@@ -531,7 +527,7 @@ ListArray::ListArray(std::shared_ptr<DataType> type, int64_t length,
       std::move(type), length,
       BufferVector{std::move(null_bitmap), std::move(value_offsets)}, null_count, offset);
   internal_data->child_data.emplace_back(values->data());
-  SetData(std::move(internal_data));
+  Init(std::move(internal_data), nullptr);
 }
 
 void ListArray::SetData(const std::shared_ptr<ArrayData>& data) {
@@ -575,10 +571,6 @@ std::shared_ptr<Array> ListArray::offsets() const { return BoxOffsets(int32(), *
 // ----------------------------------------------------------------------
 // LargeListArray
 
-LargeListArray::LargeListArray(const std::shared_ptr<ArrayData>& data) {
-  LargeListArray::SetData(data);
-}
-
 LargeListArray::LargeListArray(const std::shared_ptr<DataType>& type, int64_t length,
                                const std::shared_ptr<Buffer>& value_offsets,
                                const std::shared_ptr<Array>& values,
@@ -588,7 +580,7 @@ LargeListArray::LargeListArray(const std::shared_ptr<DataType>& type, int64_t le
   auto internal_data =
       ArrayData::Make(type, length, {null_bitmap, value_offsets}, null_count, offset);
   internal_data->child_data.emplace_back(values->data());
-  LargeListArray::SetData(internal_data);
+  Init(std::move(internal_data), nullptr);
 }
 
 void LargeListArray::SetData(const std::shared_ptr<ArrayData>& data) {
@@ -636,22 +628,6 @@ std::shared_ptr<Array> LargeListArray::offsets() const {
 // ----------------------------------------------------------------------
 // ListViewArray
 
-ListViewArray::ListViewArray(std::shared_ptr<ArrayData> data) {
-  ListViewArray::SetData(std::move(data));
-}
-
-ListViewArray::ListViewArray(std::shared_ptr<DataType> type, int64_t length,
-                             std::shared_ptr<Buffer> value_offsets,
-                             std::shared_ptr<Buffer> value_sizes,
-                             std::shared_ptr<Array> values,
-                             std::shared_ptr<Buffer> null_bitmap, int64_t null_count,
-                             int64_t offset) {
-  ListViewArray::SetData(ArrayData::Make(
-      std::move(type), length,
-      {std::move(null_bitmap), std::move(value_offsets), std::move(value_sizes)},
-      /*child_data=*/{values->data()}, null_count, offset));
-}
-
 void ListViewArray::SetData(const std::shared_ptr<ArrayData>& data) {
   internal::SetListData(this, data);
   raw_value_sizes_ = data->GetValuesSafe<ListViewType::offset_type>(2, /*offset=*/0);
@@ -711,22 +687,6 @@ std::shared_ptr<Array> ListViewArray::sizes() const { return BoxSizes(int32(), *
 // ----------------------------------------------------------------------
 // LargeListViewArray
 
-LargeListViewArray::LargeListViewArray(std::shared_ptr<ArrayData> data) {
-  LargeListViewArray::SetData(std::move(data));
-}
-
-LargeListViewArray::LargeListViewArray(std::shared_ptr<DataType> type, int64_t length,
-                                       std::shared_ptr<Buffer> value_offsets,
-                                       std::shared_ptr<Buffer> value_sizes,
-                                       std::shared_ptr<Array> values,
-                                       std::shared_ptr<Buffer> null_bitmap,
-                                       int64_t null_count, int64_t offset) {
-  LargeListViewArray::SetData(ArrayData::Make(
-      type, length,
-      {std::move(null_bitmap), std::move(value_offsets), std::move(value_sizes)},
-      /*child_data=*/{values->data()}, null_count, offset));
-}
-
 void LargeListViewArray::SetData(const std::shared_ptr<ArrayData>& data) {
   internal::SetListData(this, data);
   raw_value_sizes_ = data->GetValuesSafe<LargeListViewType::offset_type>(2, /*offset=*/0);
@@ -774,17 +734,6 @@ std::shared_ptr<Array> LargeListViewArray::sizes() const {
 // ----------------------------------------------------------------------
 // MapArray
 
-MapArray::MapArray(const std::shared_ptr<ArrayData>& data) { SetData(data); }
-
-MapArray::MapArray(const std::shared_ptr<DataType>& type, int64_t length,
-                   const std::shared_ptr<Buffer>& offsets,
-                   const std::shared_ptr<Array>& values,
-                   const std::shared_ptr<Buffer>& null_bitmap, int64_t null_count,
-                   int64_t offset) {
-  SetData(ArrayData::Make(type, length, {null_bitmap, offsets}, {values->data()},
-                          null_count, offset));
-}
-
 MapArray::MapArray(const std::shared_ptr<DataType>& type, int64_t length,
                    BufferVector buffers, const std::shared_ptr<Array>& keys,
                    const std::shared_ptr<Array>& items, int64_t null_count,
@@ -793,17 +742,9 @@ MapArray::MapArray(const std::shared_ptr<DataType>& type, int64_t length,
                                    {nullptr}, {keys->data(), items->data()}, 0);
   auto map_data =
       ArrayData::Make(type, length, std::move(buffers), {pair_data}, null_count, offset);
-  SetData(map_data);
+  Init(map_data, nullptr);
 }
 
-MapArray::MapArray(const std::shared_ptr<DataType>& type, int64_t length,
-                   const std::shared_ptr<Buffer>& offsets,
-                   const std::shared_ptr<Array>& keys,
-                   const std::shared_ptr<Array>& items,
-                   const std::shared_ptr<Buffer>& null_bitmap, int64_t null_count,
-                   int64_t offset)
-    : MapArray(type, length, {null_bitmap, offsets}, keys, items, null_count, offset) {}
-
 Result<std::shared_ptr<Array>> MapArray::FromArraysInternal(
     std::shared_ptr<DataType> type, const std::shared_ptr<Array>& offsets,
     const std::shared_ptr<Array>& keys, const std::shared_ptr<Array>& items,
@@ -921,10 +862,6 @@ void MapArray::SetData(const std::shared_ptr<ArrayData>& data) {
 // ----------------------------------------------------------------------
 // FixedSizeListArray
 
-FixedSizeListArray::FixedSizeListArray(const std::shared_ptr<ArrayData>& data) {
-  SetData(data);
-}
-
 FixedSizeListArray::FixedSizeListArray(const std::shared_ptr<DataType>& type,
                                        int64_t length,
                                        const std::shared_ptr<Array>& values,
@@ -932,12 +869,12 @@ FixedSizeListArray::FixedSizeListArray(const std::shared_ptr<DataType>& type,
                                        int64_t null_count, int64_t offset) {
   auto internal_data = ArrayData::Make(type, length, {null_bitmap}, null_count, offset);
   internal_data->child_data.emplace_back(values->data());
-  SetData(internal_data);
+  Init(internal_data, nullptr);
 }
 
 void FixedSizeListArray::SetData(const std::shared_ptr<ArrayData>& data) {
   ARROW_CHECK_EQ(data->type->id(), Type::FIXED_SIZE_LIST);
-  this->Array::SetData(data);
+  Array::SetData(data);
 
   ARROW_CHECK_EQ(list_type()->value_type()->id(), data->child_data[0]->type->id());
   DCHECK(list_type()->value_type()->Equals(data->child_data[0]->type));
@@ -1004,9 +941,9 @@ Result<std::shared_ptr<Array>> FixedSizeListArray::Flatten(
 // ----------------------------------------------------------------------
 // Struct
 
-StructArray::StructArray(const std::shared_ptr<ArrayData>& data) {
-  ARROW_CHECK_EQ(data->type->id(), Type::STRUCT);
-  SetData(data);
+StructArray::StructArray(const std::shared_ptr<ArrayData>& data,
+                         const std::shared_ptr<ArrayStatistics>& statistics) {
+  Init(data, statistics);
   boxed_fields_.resize(data->child_data.size());
 }
 
@@ -1015,7 +952,7 @@ StructArray::StructArray(const std::shared_ptr<DataType>& type, int64_t length,
                          std::shared_ptr<Buffer> null_bitmap, int64_t null_count,
                          int64_t offset) {
   ARROW_CHECK_EQ(type->id(), Type::STRUCT);
-  SetData(ArrayData::Make(type, length, {null_bitmap}, null_count, offset));
+  Init(ArrayData::Make(type, length, {null_bitmap}, null_count, offset), nullptr);
   for (const auto& child : children) {
     data_->child_data.push_back(child->data());
   }
@@ -1174,11 +1111,16 @@ Result<std::shared_ptr<Array>> StructArray::GetFlattenedField(int index,
   return MakeArray(flattened_data);
 }
 
+void StructArray::SetData(const std::shared_ptr<ArrayData>& data) {
+  ARROW_CHECK_EQ(data->type->id(), Type::STRUCT);
+  Array::SetData(data);
+}
+
 // ----------------------------------------------------------------------
 // UnionArray
 
-void UnionArray::SetData(std::shared_ptr<ArrayData> data) {
-  this->Array::SetData(std::move(data));
+void UnionArray::SetData(const std::shared_ptr<ArrayData>& data) {
+  Array::SetData(data);
 
   union_type_ = checked_cast<const UnionType*>(data_->type.get());
 
@@ -1187,8 +1129,8 @@ void UnionArray::SetData(std::shared_ptr<ArrayData> data) {
   boxed_fields_.resize(data_->child_data.size());
 }
 
-void SparseUnionArray::SetData(std::shared_ptr<ArrayData> data) {
-  this->UnionArray::SetData(std::move(data));
+void SparseUnionArray::SetData(const std::shared_ptr<ArrayData>& data) {
+  UnionArray::SetData(data);
   ARROW_CHECK_EQ(data_->type->id(), Type::SPARSE_UNION);
   ARROW_CHECK_EQ(data_->buffers.size(), 2);
 
@@ -1197,7 +1139,7 @@ void SparseUnionArray::SetData(std::shared_ptr<ArrayData> data) {
 }
 
 void DenseUnionArray::SetData(const std::shared_ptr<ArrayData>& data) {
-  this->UnionArray::SetData(data);
+  UnionArray::SetData(data);
 
   ARROW_CHECK_EQ(data_->type->id(), Type::DENSE_UNION);
   ARROW_CHECK_EQ(data_->buffers.size(), 3);
@@ -1208,10 +1150,6 @@ void DenseUnionArray::SetData(const std::shared_ptr<ArrayData>& data) {
   raw_value_offsets_ = data->GetValuesSafe<int32_t>(2, /*offset=*/0);
 }
 
-SparseUnionArray::SparseUnionArray(std::shared_ptr<ArrayData> data) {
-  SetData(std::move(data));
-}
-
 SparseUnionArray::SparseUnionArray(std::shared_ptr<DataType> type, int64_t length,
                                    ArrayVector children,
                                    std::shared_ptr<Buffer> type_codes, int64_t offset) {
@@ -1221,7 +1159,7 @@ SparseUnionArray::SparseUnionArray(std::shared_ptr<DataType> type, int64_t lengt
   for (const auto& child : children) {
     internal_data->child_data.push_back(child->data());
   }
-  SetData(std::move(internal_data));
+  Init(std::move(internal_data), nullptr);
 }
 
 Result<std::shared_ptr<Array>> SparseUnionArray::GetFlattenedField(
@@ -1261,10 +1199,6 @@ Result<std::shared_ptr<Array>> SparseUnionArray::GetFlattenedField(
   return MakeArray(child_data);
 }
 
-DenseUnionArray::DenseUnionArray(const std::shared_ptr<ArrayData>& data) {
-  SetData(data);
-}
-
 DenseUnionArray::DenseUnionArray(std::shared_ptr<DataType> type, int64_t length,
                                  ArrayVector children, std::shared_ptr<Buffer> type_ids,
                                  std::shared_ptr<Buffer> value_offsets, int64_t offset) {
@@ -1275,7 +1209,7 @@ DenseUnionArray::DenseUnionArray(std::shared_ptr<DataType> type, int64_t length,
   for (const auto& child : children) {
     internal_data->child_data.push_back(child->data());
   }
-  SetData(internal_data);
+  Init(std::move(internal_data), nullptr);
 }
 
 Result<std::shared_ptr<Array>> DenseUnionArray::Make(
diff --git a/cpp/src/arrow/array/array_nested.h b/cpp/src/arrow/array/array_nested.h
index a6d4977839e..6952d365f95 100644
--- a/cpp/src/arrow/array/array_nested.h
+++ b/cpp/src/arrow/array/array_nested.h
@@ -162,7 +162,10 @@ class BaseListArray : public VarLengthListLikeArray<TYPE> {
 /// Concrete Array class for list data
 class ARROW_EXPORT ListArray : public BaseListArray<ListType> {
  public:
-  explicit ListArray(std::shared_ptr<ArrayData> data);
+  explicit ListArray(const std::shared_ptr<ArrayData>& data,
+                     const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR) {
+    Init(data, statistics);
+  }
 
   ListArray(std::shared_ptr<DataType> type, int64_t length,
             std::shared_ptr<Buffer> value_offsets, std::shared_ptr<Array> values,
@@ -220,16 +223,19 @@ class ARROW_EXPORT ListArray : public BaseListArray<ListType> {
   std::shared_ptr<Array> offsets() const;
 
  protected:
-  // This constructor defers SetData to a derived array class
+  // This constructor defers Init() to a derived array class
   ListArray() = default;
 
-  void SetData(const std::shared_ptr<ArrayData>& data);
+  void SetData(const std::shared_ptr<ArrayData>& data) override;
 };
 
 /// Concrete Array class for large list data (with 64-bit offsets)
 class ARROW_EXPORT LargeListArray : public BaseListArray<LargeListType> {
  public:
-  explicit LargeListArray(const std::shared_ptr<ArrayData>& data);
+  explicit LargeListArray(const std::shared_ptr<ArrayData>& data,
+                          const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR) {
+    Init(data, statistics);
+  }
 
   LargeListArray(const std::shared_ptr<DataType>& type, int64_t length,
                  const std::shared_ptr<Buffer>& value_offsets,
@@ -284,7 +290,7 @@ class ARROW_EXPORT LargeListArray : public BaseListArray<LargeListType> {
   std::shared_ptr<Array> offsets() const;
 
  protected:
-  void SetData(const std::shared_ptr<ArrayData>& data);
+  void SetData(const std::shared_ptr<ArrayData>& data) override;
 };
 
 // ----------------------------------------------------------------------
@@ -324,13 +330,20 @@ class BaseListViewArray : public VarLengthListLikeArray<TYPE> {
 /// \brief Concrete Array class for list-view data
 class ARROW_EXPORT ListViewArray : public BaseListViewArray<ListViewType> {
  public:
-  explicit ListViewArray(std::shared_ptr<ArrayData> data);
+  explicit ListViewArray(const std::shared_ptr<ArrayData>& data,
+                         const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR) {
+    Init(data, statistics);
+  }
 
   ListViewArray(std::shared_ptr<DataType> type, int64_t length,
                 std::shared_ptr<Buffer> value_offsets,
                 std::shared_ptr<Buffer> value_sizes, std::shared_ptr<Array> values,
                 std::shared_ptr<Buffer> null_bitmap = NULLPTR,
-                int64_t null_count = kUnknownNullCount, int64_t offset = 0);
+                int64_t null_count = kUnknownNullCount, int64_t offset = 0)
+      : ListViewArray(ArrayData::Make(
+            std::move(type), length,
+            {std::move(null_bitmap), std::move(value_offsets), std::move(value_sizes)},
+            /*child_data=*/{values->data()}, null_count, offset)) {}
 
   /// \brief Construct ListViewArray from array of offsets, sizes, and child
   /// value array
@@ -402,23 +415,31 @@ class ARROW_EXPORT ListViewArray : public BaseListViewArray<ListViewType> {
   std::shared_ptr<Array> sizes() const;
 
  protected:
-  // This constructor defers SetData to a derived array class
+  // This constructor defers Init() to a derived array class
   ListViewArray() = default;
 
-  void SetData(const std::shared_ptr<ArrayData>& data);
+  void SetData(const std::shared_ptr<ArrayData>& data) override;
 };
 
 /// \brief Concrete Array class for large list-view data (with 64-bit offsets
 /// and sizes)
 class ARROW_EXPORT LargeListViewArray : public BaseListViewArray<LargeListViewType> {
  public:
-  explicit LargeListViewArray(std::shared_ptr<ArrayData> data);
+  explicit LargeListViewArray(
+      std::shared_ptr<ArrayData> data,
+      const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR) {
+    Init(data, statistics);
+  }
 
   LargeListViewArray(std::shared_ptr<DataType> type, int64_t length,
                      std::shared_ptr<Buffer> value_offsets,
                      std::shared_ptr<Buffer> value_sizes, std::shared_ptr<Array> values,
                      std::shared_ptr<Buffer> null_bitmap = NULLPTR,
-                     int64_t null_count = kUnknownNullCount, int64_t offset = 0);
+                     int64_t null_count = kUnknownNullCount, int64_t offset = 0)
+      : LargeListViewArray(ArrayData::Make(
+            type, length,
+            {std::move(null_bitmap), std::move(value_offsets), std::move(value_sizes)},
+            /*child_data=*/{values->data()}, null_count, offset)) {}
 
   /// \brief Construct LargeListViewArray from array of offsets, sizes, and child
   /// value array
@@ -486,10 +507,10 @@ class ARROW_EXPORT LargeListViewArray : public BaseListViewArray<LargeListViewTy
   std::shared_ptr<Array> sizes() const;
 
  protected:
-  // This constructor defers SetData to a derived array class
+  // This constructor defers Init() to a derived array class
   LargeListViewArray() = default;
 
-  void SetData(const std::shared_ptr<ArrayData>& data);
+  void SetData(const std::shared_ptr<ArrayData>& data) override;
 };
 
 // ----------------------------------------------------------------------
@@ -502,13 +523,18 @@ class ARROW_EXPORT MapArray : public ListArray {
  public:
   using TypeClass = MapType;
 
-  explicit MapArray(const std::shared_ptr<ArrayData>& data);
+  explicit MapArray(const std::shared_ptr<ArrayData>& data,
+                    const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR) {
+    Init(data, statistics);
+  }
 
   MapArray(const std::shared_ptr<DataType>& type, int64_t length,
            const std::shared_ptr<Buffer>& value_offsets,
            const std::shared_ptr<Array>& keys, const std::shared_ptr<Array>& items,
            const std::shared_ptr<Buffer>& null_bitmap = NULLPTR,
-           int64_t null_count = kUnknownNullCount, int64_t offset = 0);
+           int64_t null_count = kUnknownNullCount, int64_t offset = 0)
+      : MapArray(type, length, {null_bitmap, value_offsets}, keys, items, null_count,
+                 offset) {}
 
   MapArray(const std::shared_ptr<DataType>& type, int64_t length, BufferVector buffers,
            const std::shared_ptr<Array>& keys, const std::shared_ptr<Array>& items,
@@ -518,7 +544,9 @@ class ARROW_EXPORT MapArray : public ListArray {
            const std::shared_ptr<Buffer>& value_offsets,
            const std::shared_ptr<Array>& values,
            const std::shared_ptr<Buffer>& null_bitmap = NULLPTR,
-           int64_t null_count = kUnknownNullCount, int64_t offset = 0);
+           int64_t null_count = kUnknownNullCount, int64_t offset = 0)
+      : MapArray(ArrayData::Make(type, length, {null_bitmap, value_offsets},
+                                 {values->data()}, null_count, offset)) {}
 
   /// \brief Construct MapArray from array of offsets and child key, item arrays
   ///
@@ -558,7 +586,7 @@ class ARROW_EXPORT MapArray : public ListArray {
       const std::vector<std::shared_ptr<ArrayData>>& child_data);
 
  protected:
-  void SetData(const std::shared_ptr<ArrayData>& data);
+  void SetData(const std::shared_ptr<ArrayData>& data) override;
 
   static Result<std::shared_ptr<Array>> FromArraysInternal(
       std::shared_ptr<DataType> type, const std::shared_ptr<Array>& offsets,
@@ -579,7 +607,11 @@ class ARROW_EXPORT FixedSizeListArray : public Array {
   using TypeClass = FixedSizeListType;
   using offset_type = TypeClass::offset_type;
 
-  explicit FixedSizeListArray(const std::shared_ptr<ArrayData>& data);
+  explicit FixedSizeListArray(
+      const std::shared_ptr<ArrayData>& data,
+      const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR) {
+    Init(data, statistics);
+  }
 
   FixedSizeListArray(const std::shared_ptr<DataType>& type, int64_t length,
                      const std::shared_ptr<Array>& values,
@@ -655,7 +687,7 @@ class ARROW_EXPORT FixedSizeListArray : public Array {
       int64_t null_count = kUnknownNullCount);
 
  protected:
-  void SetData(const std::shared_ptr<ArrayData>& data);
+  void SetData(const std::shared_ptr<ArrayData>& data) override;
   int32_t list_size_;
 
  private:
@@ -670,7 +702,8 @@ class ARROW_EXPORT StructArray : public Array {
  public:
   using TypeClass = StructType;
 
-  explicit StructArray(const std::shared_ptr<ArrayData>& data);
+  explicit StructArray(const std::shared_ptr<ArrayData>& data,
+                       const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR);
 
   StructArray(const std::shared_ptr<DataType>& type, int64_t length,
               const std::vector<std::shared_ptr<Array>>& children,
@@ -727,6 +760,9 @@ class ARROW_EXPORT StructArray : public Array {
   Result<std::shared_ptr<Array>> GetFlattenedField(
       int index, MemoryPool* pool = default_memory_pool()) const;
 
+ protected:
+  void SetData(const std::shared_ptr<ArrayData>& data) override;
+
  private:
   // For caching boxed child data
   // XXX This is not handled in a thread-safe manner.
@@ -765,7 +801,7 @@ class ARROW_EXPORT UnionArray : public Array {
   std::shared_ptr<Array> field(int pos) const;
 
  protected:
-  void SetData(std::shared_ptr<ArrayData> data);
+  void SetData(const std::shared_ptr<ArrayData>& data) override;
 
   const type_code_t* raw_type_codes_;
   const UnionType* union_type_;
@@ -779,7 +815,11 @@ class ARROW_EXPORT SparseUnionArray : public UnionArray {
  public:
   using TypeClass = SparseUnionType;
 
-  explicit SparseUnionArray(std::shared_ptr<ArrayData> data);
+  explicit SparseUnionArray(
+      const std::shared_ptr<ArrayData>& data,
+      const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR) {
+    Init(data, statistics);
+  }
 
   SparseUnionArray(std::shared_ptr<DataType> type, int64_t length, ArrayVector children,
                    std::shared_ptr<Buffer> type_ids, int64_t offset = 0);
@@ -822,7 +862,7 @@ class ARROW_EXPORT SparseUnionArray : public UnionArray {
       int index, MemoryPool* pool = default_memory_pool()) const;
 
  protected:
-  void SetData(std::shared_ptr<ArrayData> data);
+  void SetData(const std::shared_ptr<ArrayData>& data) override;
 };
 
 /// \brief Concrete Array class for dense union data
@@ -832,7 +872,10 @@ class ARROW_EXPORT DenseUnionArray : public UnionArray {
  public:
   using TypeClass = DenseUnionType;
 
-  explicit DenseUnionArray(const std::shared_ptr<ArrayData>& data);
+  explicit DenseUnionArray(const std::shared_ptr<ArrayData>& data,
+                           const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR) {
+    Init(data, statistics);
+  }
 
   DenseUnionArray(std::shared_ptr<DataType> type, int64_t length, ArrayVector children,
                   std::shared_ptr<Buffer> type_ids,
@@ -890,7 +933,7 @@ class ARROW_EXPORT DenseUnionArray : public UnionArray {
  protected:
   const int32_t* raw_value_offsets_;
 
-  void SetData(const std::shared_ptr<ArrayData>& data);
+  void SetData(const std::shared_ptr<ArrayData>& data) override;
 };
 
 /// @}
diff --git a/cpp/src/arrow/array/array_primitive.cc b/cpp/src/arrow/array/array_primitive.cc
index da3810aa392..b7198245b52 100644
--- a/cpp/src/arrow/array/array_primitive.cc
+++ b/cpp/src/arrow/array/array_primitive.cc
@@ -28,29 +28,15 @@
 
 namespace arrow {
 
-// ----------------------------------------------------------------------
-// Primitive array base
-
-PrimitiveArray::PrimitiveArray(const std::shared_ptr<DataType>& type, int64_t length,
-                               const std::shared_ptr<Buffer>& data,
-                               const std::shared_ptr<Buffer>& null_bitmap,
-                               int64_t null_count, int64_t offset) {
-  SetData(ArrayData::Make(type, length, {null_bitmap, data}, null_count, offset));
-}
-
 // ----------------------------------------------------------------------
 // BooleanArray
 
-BooleanArray::BooleanArray(const std::shared_ptr<ArrayData>& data)
-    : PrimitiveArray(data) {
+BooleanArray::BooleanArray(const std::shared_ptr<ArrayData>& data,
+                           const std::shared_ptr<ArrayStatistics>& statistics) {
   ARROW_CHECK_EQ(data->type->id(), Type::BOOL);
+  Init(data, statistics);
 }
 
-BooleanArray::BooleanArray(int64_t length, const std::shared_ptr<Buffer>& data,
-                           const std::shared_ptr<Buffer>& null_bitmap, int64_t null_count,
-                           int64_t offset)
-    : PrimitiveArray(boolean(), length, data, null_bitmap, null_count, offset) {}
-
 int64_t BooleanArray::false_count() const {
   return this->length() - this->null_count() - this->true_count();
 }
@@ -70,24 +56,6 @@ int64_t BooleanArray::true_count() const {
 // ----------------------------------------------------------------------
 // Day time interval
 
-DayTimeIntervalArray::DayTimeIntervalArray(const std::shared_ptr<ArrayData>& data) {
-  SetData(data);
-}
-
-DayTimeIntervalArray::DayTimeIntervalArray(const std::shared_ptr<DataType>& type,
-                                           int64_t length,
-                                           const std::shared_ptr<Buffer>& data,
-                                           const std::shared_ptr<Buffer>& null_bitmap,
-                                           int64_t null_count, int64_t offset)
-    : PrimitiveArray(type, length, data, null_bitmap, null_count, offset) {}
-
-DayTimeIntervalArray::DayTimeIntervalArray(int64_t length,
-                                           const std::shared_ptr<Buffer>& data,
-                                           const std::shared_ptr<Buffer>& null_bitmap,
-                                           int64_t null_count, int64_t offset)
-    : PrimitiveArray(day_time_interval(), length, data, null_bitmap, null_count, offset) {
-}
-
 DayTimeIntervalType::DayMilliseconds DayTimeIntervalArray::GetValue(int64_t i) const {
   DCHECK(i < length());
   return *reinterpret_cast<const DayTimeIntervalType::DayMilliseconds*>(
@@ -97,23 +65,6 @@ DayTimeIntervalType::DayMilliseconds DayTimeIntervalArray::GetValue(int64_t i) c
 // ----------------------------------------------------------------------
 // Month, day and Nanos interval
 
-MonthDayNanoIntervalArray::MonthDayNanoIntervalArray(
-    const std::shared_ptr<ArrayData>& data) {
-  SetData(data);
-}
-
-MonthDayNanoIntervalArray::MonthDayNanoIntervalArray(
-    const std::shared_ptr<DataType>& type, int64_t length,
-    const std::shared_ptr<Buffer>& data, const std::shared_ptr<Buffer>& null_bitmap,
-    int64_t null_count, int64_t offset)
-    : PrimitiveArray(type, length, data, null_bitmap, null_count, offset) {}
-
-MonthDayNanoIntervalArray::MonthDayNanoIntervalArray(
-    int64_t length, const std::shared_ptr<Buffer>& data,
-    const std::shared_ptr<Buffer>& null_bitmap, int64_t null_count, int64_t offset)
-    : PrimitiveArray(month_day_nano_interval(), length, data, null_bitmap, null_count,
-                     offset) {}
-
 MonthDayNanoIntervalType::MonthDayNanos MonthDayNanoIntervalArray::GetValue(
     int64_t i) const {
   DCHECK(i < length());
diff --git a/cpp/src/arrow/array/array_primitive.h b/cpp/src/arrow/array/array_primitive.h
index e6df92e3b78..17ac3958c3a 100644
--- a/cpp/src/arrow/array/array_primitive.h
+++ b/cpp/src/arrow/array/array_primitive.h
@@ -41,11 +41,14 @@ class ARROW_EXPORT BooleanArray : public PrimitiveArray {
   using TypeClass = BooleanType;
   using IteratorType = stl::ArrayIterator<BooleanArray>;
 
-  explicit BooleanArray(const std::shared_ptr<ArrayData>& data);
+  explicit BooleanArray(const std::shared_ptr<ArrayData>& data,
+                        const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR);
 
   BooleanArray(int64_t length, const std::shared_ptr<Buffer>& data,
                const std::shared_ptr<Buffer>& null_bitmap = NULLPTR,
-               int64_t null_count = kUnknownNullCount, int64_t offset = 0);
+               int64_t null_count = kUnknownNullCount, int64_t offset = 0)
+      : BooleanArray(ArrayData::Make(boolean(), length, {null_bitmap, data}, null_count,
+                                     offset)) {}
 
   bool Value(int64_t i) const {
     return bit_util::GetBit(reinterpret_cast<const uint8_t*>(raw_values_),
@@ -67,9 +70,6 @@ class ARROW_EXPORT BooleanArray : public PrimitiveArray {
   IteratorType begin() const { return IteratorType(*this); }
 
   IteratorType end() const { return IteratorType(*this, length()); }
-
- protected:
-  using PrimitiveArray::PrimitiveArray;
 };
 
 /// \addtogroup numeric-arrays
@@ -90,7 +90,10 @@ class NumericArray : public PrimitiveArray {
   using value_type = typename TypeClass::c_type;
   using IteratorType = stl::ArrayIterator<NumericArray<TYPE>>;
 
-  explicit NumericArray(const std::shared_ptr<ArrayData>& data) : PrimitiveArray(data) {}
+  explicit NumericArray(const std::shared_ptr<ArrayData>& data,
+                        const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR) {
+    Init(data, statistics);
+  }
 
   // Only enable this constructor without a type argument for types without additional
   // metadata
@@ -99,8 +102,17 @@ class NumericArray : public PrimitiveArray {
                const std::shared_ptr<Buffer>& data,
                const std::shared_ptr<Buffer>& null_bitmap = NULLPTR,
                int64_t null_count = kUnknownNullCount, int64_t offset = 0)
-      : PrimitiveArray(TypeTraits<T1>::type_singleton(), length, data, null_bitmap,
-                       null_count, offset) {}
+      : NumericArray(ArrayData::Make(TypeTraits<T1>::type_singleton(), length,
+                                     {null_bitmap, data}, null_count, offset),
+                     NULLPTR) {}
+
+  NumericArray(const std::shared_ptr<DataType>& type, int64_t length,
+               const std::shared_ptr<Buffer>& data,
+               const std::shared_ptr<Buffer>& null_bitmap = NULLPTR,
+               int64_t null_count = kUnknownNullCount, int64_t offset = 0)
+      : NumericArray(
+            ArrayData::Make(type, length, {null_bitmap, data}, null_count, offset),
+            NULLPTR) {}
 
   const value_type* raw_values() const {
     return reinterpret_cast<const value_type*>(raw_values_) + data_->offset;
@@ -118,9 +130,6 @@ class NumericArray : public PrimitiveArray {
   IteratorType begin() const { return IteratorType(*this); }
 
   IteratorType end() const { return IteratorType(*this, length()); }
-
- protected:
-  using PrimitiveArray::PrimitiveArray;
 };
 
 /// DayTimeArray
@@ -131,16 +140,24 @@ class ARROW_EXPORT DayTimeIntervalArray : public PrimitiveArray {
   using TypeClass = DayTimeIntervalType;
   using IteratorType = stl::ArrayIterator<DayTimeIntervalArray>;
 
-  explicit DayTimeIntervalArray(const std::shared_ptr<ArrayData>& data);
+  explicit DayTimeIntervalArray(
+      const std::shared_ptr<ArrayData>& data,
+      const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR) {
+    Init(data, statistics);
+  }
 
   DayTimeIntervalArray(const std::shared_ptr<DataType>& type, int64_t length,
                        const std::shared_ptr<Buffer>& data,
                        const std::shared_ptr<Buffer>& null_bitmap = NULLPTR,
-                       int64_t null_count = kUnknownNullCount, int64_t offset = 0);
+                       int64_t null_count = kUnknownNullCount, int64_t offset = 0)
+      : DayTimeIntervalArray(
+            ArrayData::Make(type, length, {null_bitmap, data}, null_count, offset)) {}
 
   DayTimeIntervalArray(int64_t length, const std::shared_ptr<Buffer>& data,
                        const std::shared_ptr<Buffer>& null_bitmap = NULLPTR,
-                       int64_t null_count = kUnknownNullCount, int64_t offset = 0);
+                       int64_t null_count = kUnknownNullCount, int64_t offset = 0)
+      : DayTimeIntervalArray(ArrayData::Make(day_time_interval(), length,
+                                             {null_bitmap, data}, null_count, offset)) {}
 
   TypeClass::DayMilliseconds GetValue(int64_t i) const;
   TypeClass::DayMilliseconds Value(int64_t i) const { return GetValue(i); }
@@ -167,16 +184,25 @@ class ARROW_EXPORT MonthDayNanoIntervalArray : public PrimitiveArray {
   using TypeClass = MonthDayNanoIntervalType;
   using IteratorType = stl::ArrayIterator<MonthDayNanoIntervalArray>;
 
-  explicit MonthDayNanoIntervalArray(const std::shared_ptr<ArrayData>& data);
+  explicit MonthDayNanoIntervalArray(
+      const std::shared_ptr<ArrayData>& data,
+      const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR) {
+    Init(data, statistics);
+  }
 
   MonthDayNanoIntervalArray(const std::shared_ptr<DataType>& type, int64_t length,
                             const std::shared_ptr<Buffer>& data,
                             const std::shared_ptr<Buffer>& null_bitmap = NULLPTR,
-                            int64_t null_count = kUnknownNullCount, int64_t offset = 0);
+                            int64_t null_count = kUnknownNullCount, int64_t offset = 0)
+      : MonthDayNanoIntervalArray(
+            ArrayData::Make(type, length, {null_bitmap, data}, null_count, offset)) {}
 
   MonthDayNanoIntervalArray(int64_t length, const std::shared_ptr<Buffer>& data,
                             const std::shared_ptr<Buffer>& null_bitmap = NULLPTR,
-                            int64_t null_count = kUnknownNullCount, int64_t offset = 0);
+                            int64_t null_count = kUnknownNullCount, int64_t offset = 0)
+      : MonthDayNanoIntervalArray(ArrayData::Make(
+            month_day_nano_interval(), length, {null_bitmap, data}, null_count, offset)) {
+  }
 
   TypeClass::MonthDayNanos GetValue(int64_t i) const;
   TypeClass::MonthDayNanos Value(int64_t i) const { return GetValue(i); }
diff --git a/cpp/src/arrow/array/array_run_end.cc b/cpp/src/arrow/array/array_run_end.cc
index f423bdb33c5..1dd242d1dff 100644
--- a/cpp/src/arrow/array/array_run_end.cc
+++ b/cpp/src/arrow/array/array_run_end.cc
@@ -26,21 +26,6 @@ namespace arrow {
 // ----------------------------------------------------------------------
 // RunEndEncodedArray
 
-RunEndEncodedArray::RunEndEncodedArray(const std::shared_ptr<ArrayData>& data) {
-  this->SetData(data);
-}
-
-RunEndEncodedArray::RunEndEncodedArray(const std::shared_ptr<DataType>& type,
-                                       int64_t length,
-                                       const std::shared_ptr<Array>& run_ends,
-                                       const std::shared_ptr<Array>& values,
-                                       int64_t offset) {
-  this->SetData(ArrayData::Make(type, length,
-                                /*buffers=*/{NULLPTR},
-                                /*child_data=*/{run_ends->data(), values->data()},
-                                /*null_count=*/0, offset));
-}
-
 Result<std::shared_ptr<RunEndEncodedArray>> RunEndEncodedArray::Make(
     const std::shared_ptr<DataType>& type, int64_t logical_length,
     const std::shared_ptr<Array>& run_ends, const std::shared_ptr<Array>& values,
diff --git a/cpp/src/arrow/array/array_run_end.h b/cpp/src/arrow/array/array_run_end.h
index b46b0855ab3..00bde118a8b 100644
--- a/cpp/src/arrow/array/array_run_end.h
+++ b/cpp/src/arrow/array/array_run_end.h
@@ -53,7 +53,11 @@ class ARROW_EXPORT RunEndEncodedArray : public Array {
  public:
   using TypeClass = RunEndEncodedType;
 
-  explicit RunEndEncodedArray(const std::shared_ptr<ArrayData>& data);
+  explicit RunEndEncodedArray(
+      const std::shared_ptr<ArrayData>& data,
+      const std::shared_ptr<ArrayStatistics>& statistics = NULLPTR) {
+    Init(data, statistics);
+  }
 
   /// \brief Construct a RunEndEncodedArray from all parameters
   ///
@@ -63,7 +67,12 @@ class ARROW_EXPORT RunEndEncodedArray : public Array {
   /// the child run_ends and values arrays.
   RunEndEncodedArray(const std::shared_ptr<DataType>& type, int64_t length,
                      const std::shared_ptr<Array>& run_ends,
-                     const std::shared_ptr<Array>& values, int64_t offset = 0);
+                     const std::shared_ptr<Array>& values, int64_t offset = 0)
+      : RunEndEncodedArray(
+            ArrayData::Make(type, length,
+                            /*buffers=*/{NULLPTR},
+                            /*child_data=*/{run_ends->data(), values->data()},
+                            /*null_count=*/0, offset)) {}
 
   /// \brief Construct a RunEndEncodedArray from all parameters
   ///
@@ -85,7 +94,7 @@ class ARROW_EXPORT RunEndEncodedArray : public Array {
       const std::shared_ptr<Array>& values, int64_t logical_offset = 0);
 
  protected:
-  void SetData(const std::shared_ptr<ArrayData>& data);
+  void SetData(const std::shared_ptr<ArrayData>& data) override;
 
  public:
   /// \brief Returns an array holding the logical indexes of each run-end