Put all.

@param data       the data
@param startIndex the start index
358379
public synchronized void putAll(Collection<U> data, int startIndex) {
    putAll(new SerialArrayList<U>(factory, data), startIndex);
  }
196684
public void setWrappedData(Object data) {
        if (data == null) {
            inner = null;
            arrayFromInner = null;
            setRowIndex(-1);
        } else {
            inner = (Collection<E>) data;            
            arrayFromInner = (E[]) new Object[inner.size()];
            inner.toArray(arrayFromInner);
            setRowIndex(0);
        }
    }
1214328
private void add(Iterable<?> data) {

    for (Object el : data) {
      try {
        add(SoyData.createFromExistingData(el));

      } catch (SoyDataException sde) {
        sde.prependIndexToDataPath(list.size());
        throw sde;
      }
    }
  }
457404
public void setData(final List data) {
		// Bean properties to render
		String[] properties = new String[]{"colour", "shape", "animal"};

		simpleTable.setDataModel(new SimpleBeanListTableDataModel(properties, data));
	}
234037
public void set(long index, T value)
    {
        array[segment(index)][offset(index)] = value;
    }
104543
private static <T> void insertionSort(List<T> data, Comparator<? super T> comparator, int start, int end) {
    for(int i = start + 1; i < end; i++) {
      for(int j = i; j > start && comparator.compare(data.get(j - 1), data.get(j)) > 0; j--) {
        swap(data, j, j - 1);
      }
    }
  }
980953
public void setThisData(byte[] data)
    {
        try
        {
            pen.setData(data);
        }
        catch ( Exception e )
        {
            ThreadUtils.checkInterrupted(e);
            Throwables.propagate(e);
        }
    }
552723
@Override
    public void putAll(Map<? extends K, ? extends V> in) {
        if (fast) {
            synchronized (this) {
                Map<K, V> temp = cloneMap(map);
                temp.putAll(in);
                map = temp;
            }
        } else {
            synchronized (map) {
                map.putAll(in);
            }
        }
    }
70234
private void addRun(R run, int index) {
        int startIndex = currentPosition;
        int endIndex = currentPosition + RunUtil.getText(run).length() - 1;
        runs.add(new IndexedRun(startIndex, endIndex, index, run));
        currentPosition = endIndex + 1;
    }
810055
@Override
    public void put(Symbol key, Scriptable start, Object value)
    {
        if (putImpl(key, 0, start, value))
            return;

        if (start == this) throw Kit.codeBug();
        ensureSymbolScriptable(start).put(key, start, value);
    }
1235388
public void setStart(int index, Date value)
   {
      set(selectField(ResourceFieldLists.CUSTOM_START, index), value);
   }
764525
public void insert( int index , int value ) {
		if( size == data.length ) {
			int temp[] = new int[ size * 2];
			System.arraycopy(data,0,temp,0,index);
			temp[index] = value;
			System.arraycopy(data,index,temp,index+1,size-index);
			this.data = temp;
			size++;
		} else {
			size++;
			for( int i = size-1; i > index; i-- ) {
				data[i] = data[i-1];
			}
			data[index] = value;
		}
	}
666750
public synchronized int addAll(Collection<U> data) {
    int startIndex = length();
    putAll(data, startIndex);
    return startIndex;
  }
240044
public synchronized void insert(long data) {
        resetIfNeeded();
        long index = 0;
        if(data >= this.upperBound) {
            index = nBuckets - 1;
        } else if(data < 0) {
            logger.error(data + " can't be bucketed because it is negative!");
            return;
        } else {
            index = data / step;
        }
        if(index < 0 || index >= nBuckets) {
            // This should be dead code. Defending against code changes in
            // future.
            logger.error(data + " can't be bucketed because index is not in range [0,nBuckets).");
            return;
        }
        buckets[(int) index]++;
        sum += data;
        size++;
    }
50652
public void put(byte[] bytes, int start, int end) {
        byte[] buffer = chunk();
        
        for (int i = start; i < end; i++) {
            if (position == buffer.length) {
                buffer = alloc();
            }
            
            buffer[position++] = bytes[i];
            size++;
        }
    }
1363754
private void put(final Item i) {
        if (index > threshold) {
            int ll = items.length;
            int nl = ll * 2 + 1;
            Item[] newItems = new Item[nl];
            for (int l = ll - 1; l >= 0; --l) {
                Item j = items[l];
                while (j != null) {
                    int index = j.hashCode % newItems.length;
                    Item k = j.next;
                    j.next = newItems[index];
                    newItems[index] = j;
                    j = k;
                }
            }
            items = newItems;
            threshold = (int) (nl * 0.75);
        }
        int index = i.hashCode % items.length;
        i.next = items[index];
        items[index] = i;
    }
461556
public void set (int index, E e) {
		if (index >= data.length) {
			grow(index * 2);
		}
		size = index + 1;
		data[index] = e;
	}