기존 배열에서 하위 배열 얻기
10 개의 요소로 구성된 배열 X가 있습니다. 인덱스 3에서 시작하여 인덱스 7로 끝나는 X의 모든 요소가 포함 된 새 배열을 만들고 싶습니다. 물론 나를 위해 할 루프를 쉽게 작성할 수 있지만 가능한 한 코드를 깨끗하게 유지하고 싶습니다. . C #에 나를 위해 할 수있는 방법이 있습니까?
(의사 코드)와 같은 것 :
Array NewArray = oldArray.createNewArrayFromRange(int BeginIndex , int EndIndex)
Array.Copy내 요구에 맞지 않습니다 . 새 배열의 항목이 복제본이 필요합니다. Array.copyC 스타일 memcpy과 동일하며 내가 찾고있는 것이 아닙니다.
확장 방법으로 추가 할 수 있습니다.
public static T[] SubArray<T>(this T[] data, int index, int length)
{
T[] result = new T[length];
Array.Copy(data, index, result, 0, length);
return result;
}
static void Main()
{
int[] data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int[] sub = data.SubArray(3, 4); // contains {3,4,5,6}
}
다시 복제 업데이트 (원래 질문에서 명확하지 않음). 당신이 정말로 깊은 클론을 원한다면; 같은 :
public static T[] SubArrayDeepClone<T>(this T[] data, int index, int length)
{
T[] arrCopy = new T[length];
Array.Copy(data, index, arrCopy, 0, length);
using (MemoryStream ms = new MemoryStream())
{
var bf = new BinaryFormatter();
bf.Serialize(ms, arrCopy);
ms.Position = 0;
return (T[])bf.Deserialize(ms);
}
}
그러나 객체를 직렬화 가능 ( [Serializable]또는 ISerializable) 해야합니다 . - 당신은 쉽게 적절한 다른 직렬에 대한 대체 할 수 XmlSerializer, DataContractSerializer등, protobuf - 그물,
딥 클론은 직렬화없이 까다로울 수 있습니다. 특히 ICloneable대부분의 경우 신뢰하기가 어렵습니다.
당신은 사용할 수 있습니다 Array.Copy(...)당신이 그것을 만든 후 새 배열에 복사,하지만 난 새로운 배열을 생성하는 방법이 생각하지 않습니다 및 사본 요소의 범위.
.NET 3.5를 사용하는 경우 LINQ를 사용할 수 있습니다.
var newArray = array.Skip(3).Take(5).ToArray();
그러나 그것은 다소 덜 효율적입니다.
보다 구체적인 상황에 대한 옵션에 대해서는 유사한 질문에 대한 이 답변 을 참조하십시오 .
ArraySegment? 사용을 고려 했습니까 ?
http://msdn.microsoft.com/en-us/library/1hsbd92d.aspx
참조를 복사하는 것이 아니라 복제를 원한다고 봅니다. 이 경우 .Select배열 구성원을 복제본에 투영 하는 데 사용할 수 있습니다 . 예를 들어, 요소가 구현 된 경우 IClonable다음과 같은 작업을 수행 할 수 있습니다.
var newArray = array.Skip(3).Take(5).Select(eachElement => eachElement.Clone()).ToArray();
참고 :이 솔루션에는 .NET Framework 3.5가 필요합니다.
다음 코드는 한 줄로 수행합니다.
// Source array
string[] Source = new string[] { "A", "B", "C", "D" };
// Extracting a slice into another array
string[] Slice = new List<string>(Source).GetRange(2, 2).ToArray();
string[] arr = { "Parrot" , "Snake" ,"Rabbit" , "Dog" , "cat" };
arr = arr.ToList().GetRange(0, arr.Length -1).ToArray();
Marc의 답변을 기반으로하지만 원하는 복제 동작 추가
public static T[] CloneSubArray<T>(this T[] data, int index, int length)
where T : ICloneable
{
T[] result = new T[length];
for (int i = 0; i < length; i++)
{
var original = data[index + i];
if (original != null)
result[i] = (T)original.Clone();
return result;
}
그리고 ICloneable을 구현하는 것이 어려운 일과 비슷 하다면 Håvard Stranden의 Copyable 라이브러리 를 사용하여 많은 노력을 기울여야 합니다.
using OX.Copyable;
public static T[] DeepCopySubArray<T>(
this T[] data, int index, int length)
{
T[] result = new T[length];
for (int i = 0; i < length; i++)
{
var original = data[index + i];
if (original != null)
result[i] = (T)original.Copy();
return result;
}
OX.Copyable 구현은 다음과 함께 작동합니다.
그러나 자동 사본이 작동하려면 다음 명령문 중 하나를 보유해야합니다.
- 형식에는 매개 변수가없는 생성자가 있어야합니다. 또는
- Copyable이거나
- 해당 유형에 대해 IInstanceProvider가 등록되어 있어야합니다.
따라서 이것은 당신이 가진 거의 모든 상황을 다루어야합니다. 하위 그래프에 db 연결 또는 파일 / 스트림 핸들과 같은 항목이 포함 된 개체를 복제하는 경우 분명히 문제가 있지만 일반 딥 카피에는 해당됩니다.
다른 딥 카피 방법을 사용하려면이 기사에 다른 몇 가지 방법이 있으므로 직접 작성하지 않는 것이 좋습니다.
이 작업을 매우 쉽게 수행 할 수 있습니다.
object[] foo = new object[10];
object[] bar = new object[7];
Array.Copy(foo, 3, bar, 0, 7);
C # 8 그들은 새로운 도입했습니다 Range및 Index유형을
int[] a = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
Index i1 = 3; // number 3 from beginning
Index i2 = ^4; // number 4 from end
var slice = a[i1..i2]; // { 3, 4, 5 }
찾고있는 코드는 다음과 같습니다.
Array.Copy(oldArray, 0, newArray, BeginIndex, EndIndex - BeginIndex)
데이터 복사에 대한 대안으로 래퍼를 만들어 배열의 일부의 복사 본인 것처럼 원래 배열의 일부에 액세스 할 수 있습니다. 메모리에 데이터의 다른 사본을 얻지 못하고 데이터에 액세스 할 때 약간의 오버 헤드가 발생한다는 장점이 있습니다.
public class SubArray<T> : IEnumerable<T> {
private T[] _original;
private int _start;
public SubArray(T[] original, int start, int len) {
_original = original;
_start = start;
Length = len;
}
public T this[int index] {
get {
if (index < 0 || index >= Length) throw new IndexOutOfRangeException();
return _original[_start + index];
}
}
public int Length { get; private set; }
public IEnumerator<T> GetEnumerator() {
for (int i = 0; i < Length; i++) {
yield return _original[_start + i];
}
}
IEnumerator IEnumerable.GetEnumerator() {
return GetEnumerator();
}
}
용법:
int[] original = { 1, 2, 3, 4, 5 };
SubArray<int> copy = new SubArray<int>(original, 2, 2);
Console.WriteLine(copy.Length); // shows: 2
Console.WriteLine(copy[0]); // shows: 3
foreach (int i in copy) Console.WriteLine(i); // shows 3 and 4
Array.ConstrainedCopy가 작동합니다.
public static void ConstrainedCopy (
Array sourceArray,
int sourceIndex,
Array destinationArray,
int destinationIndex,
int length
)
원하는 것을 수행하는 단일 방법은 없습니다. 배열의 클래스에 대해 클론 메소드를 사용 가능하게해야합니다. 그런 다음 LINQ가 옵션 인 경우 :
Foo[] newArray = oldArray.Skip(3).Take(5).Select(item => item.Clone()).ToArray();
class Foo
{
public Foo Clone()
{
return (Foo)MemberwiseClone();
}
}
Array.ConstrainedCopy 사용은 어떻습니까 ?
int[] ArrayOne = new int[8] {1,2,3,4,5,6,7,8};
int[] ArrayTwo = new int[5];
Array.ConstrainedCopy(ArrayOne, 3, ArrayTwo, 0, 7-3);
아래는 내 원래 게시물입니다. 이거 작동 안 할거야
Array.CopyTo를 사용할 수 있습니다 .
int[] ArrayOne = new int[8] {1,2,3,4,5,6,7,8};
int[] ArrayTwo = new int[5];
ArrayOne.CopyTo(ArrayTwo,3); //starts copy at index=3 until it reaches end of
//either array
이건 어때:
public T[] CloneCopy(T[] array, int startIndex, int endIndex) where T : ICloneable
{
T[] retArray = new T[endIndex - startIndex];
for (int i = startIndex; i < endIndex; i++)
{
array[i - startIndex] = array[i].Clone();
}
return retArray;
}
그런 다음 이것을 사용해야하는 모든 클래스에서 ICloneable 인터페이스를 구현해야하지만 그렇게해야합니다.
나는 그것이 얼마나 깊이 있는지 확실하지 않지만,
MyArray.ToList<TSource>().GetRange(beginningIndex, endIndex).ToArray()
약간의 오버 헤드이지만 불필요한 방법을 잘라낼 수 있습니다.
복제가 진행되는 한 직렬화가 생성자를 호출한다고 생각하지 않습니다. ctor에서 흥미로운 일을하고 있다면 클래스 불변성을 깨뜨릴 수 있습니다.
복사 생성자를 호출하는 가상 클론 메소드가 더 안전한 것 같습니다.
protected MyDerivedClass(MyDerivedClass myClass)
{
...
}
public override MyBaseClass Clone()
{
return new MyDerivedClass(this);
}
배열에서 요소를 복제하는 것은 보편적 인 방법으로 수행 할 수있는 것이 아닙니다. 깊은 복제 또는 모든 회원의 간단한 사본을 원하십니까?
ICloneable 인터페이스 또는 이진 직렬화를 사용하여 객체를 복제하는 "최선의 노력"접근 방법을 살펴 보겠습니다.
public static class ArrayExtensions
{
public static T[] SubArray<T>(this T[] array, int index, int length)
{
T[] result = new T[length];
for (int i=index;i<length+index && i<array.Length;i++)
{
if (array[i] is ICloneable)
result[i-index] = (T) ((ICloneable)array[i]).Clone();
else
result[i-index] = (T) CloneObject(array[i]);
}
return result;
}
private static object CloneObject(object obj)
{
BinaryFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, obj);
stream.Seek(0,SeekOrigin.Begin);
return formatter.Deserialize(stream);
}
}
}
이것은 모든 유형의 객체에 작동하는 것이 없기 때문에 완벽한 솔루션은 아닙니다.
Microsoft에서 만든 수업을들을 수 있습니다.
internal class Set<TElement>
{
private int[] _buckets;
private Slot[] _slots;
private int _count;
private int _freeList;
private readonly IEqualityComparer<TElement> _comparer;
public Set()
: this(null)
{
}
public Set(IEqualityComparer<TElement> comparer)
{
if (comparer == null)
comparer = EqualityComparer<TElement>.Default;
_comparer = comparer;
_buckets = new int[7];
_slots = new Slot[7];
_freeList = -1;
}
public bool Add(TElement value)
{
return !Find(value, true);
}
public bool Contains(TElement value)
{
return Find(value, false);
}
public bool Remove(TElement value)
{
var hashCode = InternalGetHashCode(value);
var index1 = hashCode % _buckets.Length;
var index2 = -1;
for (var index3 = _buckets[index1] - 1; index3 >= 0; index3 = _slots[index3].Next)
{
if (_slots[index3].HashCode == hashCode && _comparer.Equals(_slots[index3].Value, value))
{
if (index2 < 0)
_buckets[index1] = _slots[index3].Next + 1;
else
_slots[index2].Next = _slots[index3].Next;
_slots[index3].HashCode = -1;
_slots[index3].Value = default(TElement);
_slots[index3].Next = _freeList;
_freeList = index3;
return true;
}
index2 = index3;
}
return false;
}
private bool Find(TElement value, bool add)
{
var hashCode = InternalGetHashCode(value);
for (var index = _buckets[hashCode % _buckets.Length] - 1; index >= 0; index = _slots[index].Next)
{
if (_slots[index].HashCode == hashCode && _comparer.Equals(_slots[index].Value, value))
return true;
}
if (add)
{
int index1;
if (_freeList >= 0)
{
index1 = _freeList;
_freeList = _slots[index1].Next;
}
else
{
if (_count == _slots.Length)
Resize();
index1 = _count;
++_count;
}
int index2 = hashCode % _buckets.Length;
_slots[index1].HashCode = hashCode;
_slots[index1].Value = value;
_slots[index1].Next = _buckets[index2] - 1;
_buckets[index2] = index1 + 1;
}
return false;
}
private void Resize()
{
var length = checked(_count * 2 + 1);
var numArray = new int[length];
var slotArray = new Slot[length];
Array.Copy(_slots, 0, slotArray, 0, _count);
for (var index1 = 0; index1 < _count; ++index1)
{
int index2 = slotArray[index1].HashCode % length;
slotArray[index1].Next = numArray[index2] - 1;
numArray[index2] = index1 + 1;
}
_buckets = numArray;
_slots = slotArray;
}
internal int InternalGetHashCode(TElement value)
{
if (value != null)
return _comparer.GetHashCode(value) & int.MaxValue;
return 0;
}
internal struct Slot
{
internal int HashCode;
internal TElement Value;
internal int Next;
}
}
그리고
public static T[] GetSub<T>(this T[] first, T[] second)
{
var items = IntersectIteratorWithIndex(first, second);
if (!items.Any()) return new T[] { };
var index = items.First().Item2;
var length = first.Count() - index;
var subArray = new T[length];
Array.Copy(first, index, subArray, 0, length);
return subArray;
}
private static IEnumerable<Tuple<T, Int32>> IntersectIteratorWithIndex<T>(IEnumerable<T> first, IEnumerable<T> second)
{
var firstList = first.ToList();
var set = new Set<T>();
foreach (var i in second)
set.Add(i);
foreach (var i in firstList)
{
if (set.Remove(i))
yield return new Tuple<T, Int32>(i, firstList.IndexOf(i));
}
}
이것이 내가 찾은 최적의 방법입니다.
private void GetSubArrayThroughArraySegment() {
int[] array = { 10, 20, 30 };
ArraySegment<int> segment = new ArraySegment<int>(array, 1, 2);
Console.WriteLine("-- Array --");
int[] original = segment.Array;
foreach (int value in original)
{
Console.WriteLine(value);
}
Console.WriteLine("-- Offset --");
Console.WriteLine(segment.Offset);
Console.WriteLine("-- Count --");
Console.WriteLine(segment.Count);
Console.WriteLine("-- Range --");
for (int i = segment.Offset; i <= segment.Count; i++)
{
Console.WriteLine(segment.Array[i]);
}
}
그것이 도움이되기를 바랍니다!
확장 법 사용 :
public static T[] Slice<T>(this T[] source, int start, int end)
{
// Handles negative ends.
if (end < 0)
{
end = source.Length + end;
}
int len = end - start;
// Return new array.
T[] res = new T[len];
for (int i = 0; i < len; i++)
{
res[i] = source[i + start];
}
return res;
}
그리고 당신은 그것을 사용할 수 있습니다
var NewArray = OldArray.Slice(3,7);
public static T[] SubArray<T>(T[] data, int index, int length)
{
List<T> retVal = new List<T>();
if (data == null || data.Length == 0)
return retVal.ToArray();
bool startRead = false;
int count = 0;
for (int i = 0; i < data.Length; i++)
{
if (i == index && !startRead)
startRead = true;
if (startRead)
{
retVal.Add(data[i]);
count++;
if (count == length)
break;
}
}
return retVal.ToArray();
}
참고 URL : https://stackoverflow.com/questions/943635/getting-a-sub-array-from-an-existing-array
'Programing' 카테고리의 다른 글
| 안드로이드에서 비트 맵의 크기를 조정하는 방법? (0) | 2020.03.12 |
|---|---|
| Android에서 뷰 배경색의 애니메이션 변경 (0) | 2020.03.12 |
| 내 레지스트리없이 개인 NPM 모듈을 설치하는 방법은 무엇입니까? (0) | 2020.03.11 |
| 노드에서 사용자의 IP 주소를 확인하는 방법 (0) | 2020.03.11 |
| git rebase :“오류 : 'file'통계를 할 수 없습니다 : 권한이 거부되었습니다.” (0) | 2020.03.11 |