AS3 вектор массивов

Question

Есть ли какой-то выигрыш в производительности при хранении массивов в векторе типа Array?

например, вариант 1

private var _arrays:Vector.<Array> =  new Vector.<Array>(2); 
_arrays[0] = new Array(10);
_arrays[1] = new Array(10);

Вариант 2

private var _arrays:Array =  new Array(2); 
_arrays[0] = new Array(10);
_arrays[1] = new Array(10);

Могу ли я иметь Вектор или Векторы?

 private var _vectors:Vector.<Vector> = new Vector.<Vector>(2);

_vectors[0] = new Vector.<String>(10);
_vectors[1] = new Vector.<String>(10);

Спасибо

Mark

Answer 1

EDIT

Мой первоначальный ответ был неправильным, за исключением самой последней части, и я должен извиниться за это. Я точно знал, что у Vector ровно четыре реализации «под капотом». (Вы можете найти декомпилированные источники из FP 10 playerglobal.swc в посте Роберта Пеннера здесь ) Три из них предназначены для типов чисел (int, uint и Number). Один для типов объектов. Этот последний служит универсальным и принимает все классы, полученные из Object. Вот почему я предположил, что Vector.<Object> все еще быстрее, чем Array, полагаясь на информацию о векторах и массивах, доступную в Adobe .

Однако, похоже, что эта информация неверна или, по крайней мере, она пропускает некоторые важные части:

1. Хотя Vector.<AnyClassDerivedFromObject> допускает строгую типизацию, эта информация о типе оценивается только во время компиляции (так вы получаете большую безопасность типов), но не во время выполнения - таким образом, по существу, преимущества векторов объектов строгой типизации не применяются к производительности. Подробнее см. в этом блоге .

2. Следовательно, единственные реализации Vector, которые быстрее, чем Array, - это реализации для числовых типов (!).

На самом деле, я провел несколько обширных испытаний по этому вопросу и пришел к выводу, что, хотя Vector.<int> на 60% быстрее, чем Массив целых, все производные Vector.<Object> не только равны по скорости. (т. е. Vector.<Object> работает так же, как Vector.<String>, они также примерно на 20% медленнее , чем Array. Я дважды и трижды проверил это, поэтому я считаю, что результаты достаточно точны.

Верно, что векторы числового типа быстрее, поэтому вы должны использовать их для повышения производительности по сравнению с массивом. Но:

END EDIT

Только если вы собираетесь использовать sort(), sortOn() или любую другую из удобных функций сортировки массива, вы все равно можете принять иное решение, потому что это собственные функции, и как таковые действительно быстро. Реализация собственных методов сортировки в векторе, вероятно, не будет соответствовать их скорости.

Answer 2

Лично я не вижу никакой выгоды в производительности. Если есть, то будет минимальным. Весь смысл наличия векторного класса в том, чтобы строго набирать элементы массива. Но сам объект массива предназначен для хранения нескольких типов объектов или даже нетипизированных ... так строго вводя вектор в практически нетипизированный контейнер, который может быть заполнен нетипизированным или множественным содержимым различного типа ... если продумать это так это просто логически звучит так, как будто это мало что даст.

Обновление

Вот некоторые результаты теста производительности, чтобы доказать мою точку зрения. Мы можем видеть, что при стрессе вектор массивов равен производительности в виде массива массивов, и в одном тестовом случае это даже хуже:

/ =============================================================================================
                                     Array  Tests                                               
 ============================================================================================= /
Testing Array of Arrays push performance:
Total time for 100000 push calls on Array of Arrays: 24

Testing Array of Arrays random assignment performance:
Total time for 100000 random assignment calls on Array of Arrays: 40

Testing Array of Arrays sequential read performance:
Total time for 100000 sequential read calls on Array of Arrays: 14

Testing Array of Arrays random read performance:
Total time for 100000 random read calls on Array of Arrays: 41
/ ============================================================================================= /

/ =============================================================================================
                                     Vector Tests                                               
 ============================================================================================= /
Testing Vector of Arrays push performance:
Total time for 100000 push calls on Vector of Arrays: 24

Testing Vector of Arrays random assignment performance:
Total time for 100000 random assignment calls on Vector of Arrays: 49

Testing Vector of Arrays sequential read performance:
Total time for 100000 sequential read calls on Vector of Arrays: 14

Testing Vector of Arrays random read performance:
Total time for 100000 random read calls on Vector of Arrays: 41
/ ============================================================================================= /

И тестовый код:

import flash.events.Event;
import flash.utils.getTimer;

//Performance timer related
var startTime:Number; //ms
//

//Our two container types we're testing IO on
var arrayOfArrays:Array = new Array();
var vectorOfArrays:Vector.<Array> = new Vector.<Array>();
//

//Used to store a bunch of arrays we're going to use to test
var testArrays:Array = new Array();
//

var randomIndex:uint = 0;
var i:uint = 0;
var arr:Array;

//Generate a bunch of arrays of mixed typed content
for(i = 0; i < 100000; ++i) {
    generateTestArray();
}

/*======================================================================================================
***********************************      Array  Tests      *********************************************
*=====================================================================================================*/
//Test push on array of arrays
trace("Testing Array of Arrays push performance:");
startTime = getTimer();
for(i = 0; i < 100000; ++i) {
    arrayOfArrays.push(testArrays[i]);
}
trace("Total time for 100000 push calls on Array of Arrays: " + (getTimer() - startTime));
trace(" ");
//

//Test random write on array of arrays
trace("Testing Array of Arrays random assignment performance:");
startTime = getTimer();
for(i = 0; i < 100000; ++i) {
    randomIndex = Math.round(Math.random() * 99999) as uint;
    arrayOfArrays[randomIndex] = testArrays[randomIndex];
}
trace("Total time for 100000 random assignment calls on Array of Arrays: " + (getTimer() - startTime));
trace(" ");
//

//Test sequential read on array of arrays
trace("Testing Array of Arrays sequential read performance:");
startTime = getTimer();
for(i = 0; i < 100000; ++i) {
    arr = arrayOfArrays[i];
}
trace("Total time for 100000 sequential read calls on Array of Arrays: " + (getTimer() - startTime));
trace(" ");
//

//Test random read on array of arrays
trace("Testing Array of Arrays sequential read performance:");
startTime = getTimer();
for(i = 0; i < 100000; ++i) {
    randomIndex = Math.round(Math.random() * 99999) as uint;
    arr = arrayOfArrays[randomIndex];
}
trace("Total time for 100000 random read calls on Array of Arrays: " + (getTimer() - startTime));
trace(" ");
//
/*====================================================================================================*/


/*======================================================================================================
***********************************      Vector Tests      *********************************************
*=====================================================================================================*/
//Test push on vector of arrays
trace("Testing Vector of Arrays push performance:");
startTime = getTimer();
for(i = 0; i < 100000; ++i) {
    vectorOfArrays.push(testArrays[i]);
}
trace("Total time for 100000 push calls on Vector of Arrays: " + (getTimer() - startTime));
trace(" ");
//

//Test random write on vector of arrays
trace("Testing Vector of Arrays random assignment performance:");
startTime = getTimer();
for(i = 0; i < 100000; ++i) {
    randomIndex = Math.round(Math.random() * 99999) as uint;
    vectorOfArrays[randomIndex] = testArrays[randomIndex];
}
trace("Total time for 100000 random assignment calls on Vector of Arrays: " + (getTimer() - startTime));
trace(" ");
//

//Test sequential read on vector of arrays
trace("Testing Vector of Arrays sequential read performance:");
startTime = getTimer();
for(i = 0; i < 100000; ++i) {
    arr = vectorOfArrays[i];
}
trace("Total time for 100000 sequential read calls on Vector of Arrays: " + (getTimer() - startTime));
trace(" ");
//

//Test random read on vector of arrays
trace("Testing Vector of Arrays sequential read performance:");
startTime = getTimer();
for(i = 0; i < 100000; ++i) {
    randomIndex = Math.round(Math.random() * 99999) as uint;
    arr = vectorOfArrays[randomIndex];
}
trace("Total time for 100000 random read calls on Vector of Arrays: " + (getTimer() - startTime));
trace(" ");
//
/*====================================================================================================*/

function generateTestArray():void
{
    var newArray:Array = new Array();

    var totalItems:uint = Math.round(Math.random() * 50 + 1);

    var i:uint = 0;

    var dice:uint = 0;

    for(i; i < totalItems; ++i) {

        dice = Math.round(Math.random() * 5);

        switch(dice) {
            case 0:
                newArray.push(new int(Math.random()));
            break;

            case 1:
                newArray.push(new String(Math.random()));
            break;

            case 2:
                newArray.push(new Array());
            break;

            case 3:
                newArray.push(new MovieClip());
            break;

            case 4:
                newArray.push(new Date());
            break;

            case 5:
                newArray.push(new Event(Event.COMPLETE, false, false));
            break;  

        }
    }

    testArrays.push(newArray);
}