- 浏览: 154477 次
- 性别:
- 来自: 北京
文章分类
最新评论
-
szxiaoli:
都打不开呀,
240个jQuery实现AJAX插件 -
Corwen:
class要声明为final 不一定需要这个吧
不可变对象,深层次克隆等总结 -
chengqianl:
厉害 形象
大部分领导都是屁眼而已 -
xiangzi21:
m. show engies; --->应该是show ...
Mysql中show的用法 -
fromaust:
可以用inverse="true"来解决这 ...
[转]hibernate n+1问题
数组的使用可以被证明为是相当快的,这里指的是与ArrayList的比较,但是array不能伸缩,上来就要固定长度,这个是它的局限性,也是它速度快的原因。
ArrayList可以变换长度,会自动帮你扩展,现在想一下,它是怎么扩展的呢?很容易想到,它就是新建一个数组,把现有的东西复制到一个这个更大的数组中去,实现的,这样的效率极其低下。
有个问题,我事先要是不知道长度呢,我怎么定,可能会想,我估个值,尽可能大,就行了,这样的做法虽然浪费了许多空间,但是
当然数组不能存储对象类型,ArrayList在大多数时是很不错的,但是如果有机会有数组实现,还是用数组实现。
数组的复制也是经常遇到的问题,通常是这样做的:
如果知道有个函数是System.arraycopy(src, srcPos, dest, destPos, length),就会这样
原因:System.arraycopy是以本机函数实现的,执行速度更快。
是啊,像你学习了~
就这么点代码,是个人都能看出来arraylist就是封装了数组在里面,你说封装个数组,还比数组快,可能么。
这也就罢了,您换个方式研究咱没意见,最后的结论竟然是为了性能请用数组。
要是这么喜欢性能,您用java干嘛阿。
PS.而且凡是读过书,读过代码,哪怕写过1k行代码的最菜的人,也知道大多数时候,维护一个定长数组需要付出多大的功夫,连cpp里面都漫天vector了。还有人发现了一块新大陆,你让别人能不吐么?
长得丑无所谓,但是出来吓人还是有所谓的。对于不懂的事情,别做总结性发言。
我也没让你来看啊,你自己非要进来看,还回帖一直在这冷嘲热讽,不过还是给谢谢你的建议。
arraylist是随机存储介质,适合于需要访问某个特定位置的内容,而list(linkedlist)一般也就是增删容易,add没有额外的负担,但是遍历很快
需要快速定位,除非是需要key的,否则没人用hashmap,因为hasher本身也是很大的计算复杂度。
就这么点代码,是个人都能看出来arraylist就是封装了数组在里面,你说封装个数组,还比数组快,可能么。
这也就罢了,您换个方式研究咱没意见,最后的结论竟然是为了性能请用数组。
要是这么喜欢性能,您用java干嘛阿。
PS.而且凡是读过书,读过代码,哪怕写过1k行代码的最菜的人,也知道大多数时候,维护一个定长数组需要付出多大的功夫,连cpp里面都漫天vector了。还有人发现了一块新大陆,你让别人能不吐么?
长得丑无所谓,但是出来吓人还是有所谓的。对于不懂的事情,别做总结性发言。
说得好啊,其实你说出了最平凡的道理,但是能做到的人很少,咱们国家的程序员都是这样的,像古代的文人--自古相轻,你搞出了无论是不是好的东西,都会觉得你是个SB,一直是这样
吐呗,可劲吐,只是一种思考,以前从来没想过这些性能问题,而且又没说永远不许用集合对象,
只有通过细致的性能测评和对系统的详尽分析,才能做出正确的选择!!
如果你考虑性能问题就从这些地方入手,还是把编程当做业余爱好吧。
外国一个编程的高手,Peter hagger--大名鼎鼎的practicial java的作者,也考虑了这个问题,我就是看他的文章,思考的。总之,谢谢你的建议。
吐呗,可劲吐,只是一种思考,以前从来没想过这些性能问题,而且又没说永远不许用集合对象,
只有通过细致的性能测评和对系统的详尽分析,才能做出正确的选择!!
如果你考虑性能问题就从这些地方入手,还是把编程当做业余爱好吧。
吐啊吐啊就习惯了。这个版面真让人不敢来啊。
呵呵,你是不是楼上的小弟啊~
吐呗,可劲吐,只是一种思考,以前从来没想过这些性能问题,而且又没说永远不许用集合对象,
只有通过细致的性能测评和对系统的详尽分析,才能做出正确的选择!!
吐啊吐啊就习惯了。这个版面真让人不敢来啊。
ArrayList可以变换长度,会自动帮你扩展,现在想一下,它是怎么扩展的呢?很容易想到,它就是新建一个数组,把现有的东西复制到一个这个更大的数组中去,实现的,这样的效率极其低下。
引用
array在某些时候的表现,可能比ArrayList快上10倍---
Peter hagger
Peter hagger
有个问题,我事先要是不知道长度呢,我怎么定,可能会想,我估个值,尽可能大,就行了,这样的做法虽然浪费了许多空间,但是
引用
性能上的收益可能超过内存方面的代价,只有通过细致的性能测评和对系统的详尽分析,才能做出正确的选择---Peter hagger
当然数组不能存储对象类型,ArrayList在大多数时是很不错的,但是如果有机会有数组实现,还是用数组实现。
数组的复制也是经常遇到的问题,通常是这样做的:
public void copyArray(int[] src,int[] target){ for(int i:src){ target[i]=src[i]; } }
如果知道有个函数是System.arraycopy(src, srcPos, dest, destPos, length),就会这样
public void copyArray2(int[] src,int[] target){ int length = src.length; System.arraycopy(src, 0, target, 0, length); }
打印结果: 用普通复制方法的时间32 用System.arraycopy的时间15
原因:System.arraycopy是以本机函数实现的,执行速度更快。
评论
13 楼
DoubleEO
2009-01-10
抛出异常的爱 写道
如果想要多次增加数组大小
用list比array快.....因为:
如果想要快速遍历所有点.
list比array快
因为:
如果想要快速定位
用hashmap会不会更快一点呢.
用list比array快.....因为:
int newCapacity = (oldCapacity * 3)/2 + 1; //....... elementData = Arrays.copyOf(elementData, newCapacity);
如果想要快速遍历所有点.
list比array快
因为:
//当remove时 System.arraycopy(elementData, index+1, elementData, index, numMoved);
如果想要快速定位
用hashmap会不会更快一点呢.
是啊,像你学习了~
12 楼
DoubleEO
2009-01-10
hurricane1026 写道
/* * @(#)ArrayList.java 1.56 06/04/21 * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package java.util; /** * Resizable-array implementation of the <tt>List</tt> interface. Implements * all optional list operations, and permits all elements, including * <tt>null</tt>. In addition to implementing the <tt>List</tt> interface, * this class provides methods to manipulate the size of the array that is * used internally to store the list. (This class is roughly equivalent to * <tt>Vector</tt>, except that it is unsynchronized.)<p> * * The <tt>size</tt>, <tt>isEmpty</tt>, <tt>get</tt>, <tt>set</tt>, * <tt>iterator</tt>, and <tt>listIterator</tt> operations run in constant * time. The <tt>add</tt> operation runs in <i>amortized constant time</i>, * that is, adding n elements requires O(n) time. All of the other operations * run in linear time (roughly speaking). The constant factor is low compared * to that for the <tt>LinkedList</tt> implementation.<p> * * Each <tt>ArrayList</tt> instance has a <i>capacity</i>. The capacity is * the size of the array used to store the elements in the list. It is always * at least as large as the list size. As elements are added to an ArrayList, * its capacity grows automatically. The details of the growth policy are not * specified beyond the fact that adding an element has constant amortized * time cost.<p> * * An application can increase the capacity of an <tt>ArrayList</tt> instance * before adding a large number of elements using the <tt>ensureCapacity</tt> * operation. This may reduce the amount of incremental reallocation. * * <p><strong>Note that this implementation is not synchronized.</strong> * If multiple threads access an <tt>ArrayList</tt> instance concurrently, * and at least one of the threads modifies the list structurally, it * <i>must</i> be synchronized externally. (A structural modification is * any operation that adds or deletes one or more elements, or explicitly * resizes the backing array; merely setting the value of an element is not * a structural modification.) This is typically accomplished by * synchronizing on some object that naturally encapsulates the list. * * If no such object exists, the list should be "wrapped" using the * {@link Collections#synchronizedList Collections.synchronizedList} * method. This is best done at creation time, to prevent accidental * unsynchronized access to the list:<pre> * List list = Collections.synchronizedList(new ArrayList(...));</pre> * * <p>The iterators returned by this class's <tt>iterator</tt> and * <tt>listIterator</tt> methods are <i>fail-fast</i>: if the list is * structurally modified at any time after the iterator is created, in any way * except through the iterator's own <tt>remove</tt> or <tt>add</tt> methods, * the iterator will throw a {@link ConcurrentModificationException}. Thus, in * the face of concurrent modification, the iterator fails quickly and cleanly, * rather than risking arbitrary, non-deterministic behavior at an undetermined * time in the future.<p> * * Note that the fail-fast behavior of an iterator cannot be guaranteed * as it is, generally speaking, impossible to make any hard guarantees in the * presence of unsynchronized concurrent modification. Fail-fast iterators * throw <tt>ConcurrentModificationException</tt> on a best-effort basis. * Therefore, it would be wrong to write a program that depended on this * exception for its correctness: <i>the fail-fast behavior of iterators * should be used only to detect bugs.</i><p> * * This class is a member of the * <a href="{@docRoot}/../technotes/guides/collections/index.html"> * Java Collections Framework</a>. * * @author Josh Bloch * @author Neal Gafter * @version 1.56, 04/21/06 * @see Collection * @see List * @see LinkedList * @see Vector * @since 1.2 */ public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable { private static final long serialVersionUID = 8683452581122892189L; /** * The array buffer into which the elements of the ArrayList are stored. * The capacity of the ArrayList is the length of this array buffer. */ private transient Object[] elementData; /** * The size of the ArrayList (the number of elements it contains). * * @serial */ private int size; /** * Constructs an empty list with the specified initial capacity. * * @param initialCapacity the initial capacity of the list * @exception IllegalArgumentException if the specified initial capacity * is negative */ public ArrayList(int initialCapacity) { super(); if (initialCapacity < 0) throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); this.elementData = new Object[initialCapacity]; } /** * Constructs an empty list with an initial capacity of ten. */ public ArrayList() { this(10); } /** * Constructs a list containing the elements of the specified * collection, in the order they are returned by the collection's * iterator. * * @param c the collection whose elements are to be placed into this list * @throws NullPointerException if the specified collection is null */ public ArrayList(Collection<? extends E> c) { elementData = c.toArray(); size = elementData.length; // c.toArray might (incorrectly) not return Object[] (see 6260652) if (elementData.getClass() != Object[].class) elementData = Arrays.copyOf(elementData, size, Object[].class); } /** * Trims the capacity of this <tt>ArrayList</tt> instance to be the * list's current size. An application can use this operation to minimize * the storage of an <tt>ArrayList</tt> instance. */ public void trimToSize() { modCount++; int oldCapacity = elementData.length; if (size < oldCapacity) { elementData = Arrays.copyOf(elementData, size); } } /** * Increases the capacity of this <tt>ArrayList</tt> instance, if * necessary, to ensure that it can hold at least the number of elements * specified by the minimum capacity argument. * * @param minCapacity the desired minimum capacity */ public void ensureCapacity(int minCapacity) { modCount++; int oldCapacity = elementData.length; if (minCapacity > oldCapacity) { Object oldData[] = elementData; int newCapacity = (oldCapacity * 3)/2 + 1; if (newCapacity < minCapacity) newCapacity = minCapacity; // minCapacity is usually close to size, so this is a win: elementData = Arrays.copyOf(elementData, newCapacity); } } /** * Returns the number of elements in this list. * * @return the number of elements in this list */ public int size() { return size; } /** * Returns <tt>true</tt> if this list contains no elements. * * @return <tt>true</tt> if this list contains no elements */ public boolean isEmpty() { return size == 0; } /** * Returns <tt>true</tt> if this list contains the specified element. * More formally, returns <tt>true</tt> if and only if this list contains * at least one element <tt>e</tt> such that * <tt>(o==null ? e==null : o.equals(e))</tt>. * * @param o element whose presence in this list is to be tested * @return <tt>true</tt> if this list contains the specified element */ public boolean contains(Object o) { return indexOf(o) >= 0; } /** * Returns the index of the first occurrence of the specified element * in this list, or -1 if this list does not contain the element. * More formally, returns the lowest index <tt>i</tt> such that * <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>, * or -1 if there is no such index. */ public int indexOf(Object o) { if (o == null) { for (int i = 0; i < size; i++) if (elementData[i]==null) return i; } else { for (int i = 0; i < size; i++) if (o.equals(elementData[i])) return i; } return -1; } /** * Returns the index of the last occurrence of the specified element * in this list, or -1 if this list does not contain the element. * More formally, returns the highest index <tt>i</tt> such that * <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>, * or -1 if there is no such index. */ public int lastIndexOf(Object o) { if (o == null) { for (int i = size-1; i >= 0; i--) if (elementData[i]==null) return i; } else { for (int i = size-1; i >= 0; i--) if (o.equals(elementData[i])) return i; } return -1; } /** * Returns a shallow copy of this <tt>ArrayList</tt> instance. (The * elements themselves are not copied.) * * @return a clone of this <tt>ArrayList</tt> instance */ public Object clone() { try { ArrayList<E> v = (ArrayList<E>) super.clone(); v.elementData = Arrays.copyOf(elementData, size); v.modCount = 0; return v; } catch (CloneNotSupportedException e) { // this shouldn't happen, since we are Cloneable throw new InternalError(); } } /** * Returns an array containing all of the elements in this list * in proper sequence (from first to last element). * * <p>The returned array will be "safe" in that no references to it are * maintained by this list. (In other words, this method must allocate * a new array). The caller is thus free to modify the returned array. * * <p>This method acts as bridge between array-based and collection-based * APIs. * * @return an array containing all of the elements in this list in * proper sequence */ public Object[] toArray() { return Arrays.copyOf(elementData, size); } /** * Returns an array containing all of the elements in this list in proper * sequence (from first to last element); the runtime type of the returned * array is that of the specified array. If the list fits in the * specified array, it is returned therein. Otherwise, a new array is * allocated with the runtime type of the specified array and the size of * this list. * * <p>If the list fits in the specified array with room to spare * (i.e., the array has more elements than the list), the element in * the array immediately following the end of the collection is set to * <tt>null</tt>. (This is useful in determining the length of the * list <i>only</i> if the caller knows that the list does not contain * any null elements.) * * @param a the array into which the elements of the list are to * be stored, if it is big enough; otherwise, a new array of the * same runtime type is allocated for this purpose. * @return an array containing the elements of the list * @throws ArrayStoreException if the runtime type of the specified array * is not a supertype of the runtime type of every element in * this list * @throws NullPointerException if the specified array is null */ public <T> T[] toArray(T[] a) { if (a.length < size) // Make a new array of a's runtime type, but my contents: return (T[]) Arrays.copyOf(elementData, size, a.getClass()); System.arraycopy(elementData, 0, a, 0, size); if (a.length > size) a[size] = null; return a; } // Positional Access Operations /** * Returns the element at the specified position in this list. * * @param index index of the element to return * @return the element at the specified position in this list * @throws IndexOutOfBoundsException {@inheritDoc} */ public E get(int index) { RangeCheck(index); return (E) elementData[index]; } /** * Replaces the element at the specified position in this list with * the specified element. * * @param index index of the element to replace * @param element element to be stored at the specified position * @return the element previously at the specified position * @throws IndexOutOfBoundsException {@inheritDoc} */ public E set(int index, E element) { RangeCheck(index); E oldValue = (E) elementData[index]; elementData[index] = element; return oldValue; } /** * Appends the specified element to the end of this list. * * @param e element to be appended to this list * @return <tt>true</tt> (as specified by {@link Collection#add}) */ public boolean add(E e) { ensureCapacity(size + 1); // Increments modCount!! elementData[size++] = e; return true; } /** * Inserts the specified element at the specified position in this * list. Shifts the element currently at that position (if any) and * any subsequent elements to the right (adds one to their indices). * * @param index index at which the specified element is to be inserted * @param element element to be inserted * @throws IndexOutOfBoundsException {@inheritDoc} */ public void add(int index, E element) { if (index > size || index < 0) throw new IndexOutOfBoundsException( "Index: "+index+", Size: "+size); ensureCapacity(size+1); // Increments modCount!! System.arraycopy(elementData, index, elementData, index + 1, size - index); elementData[index] = element; size++; } /** * Removes the element at the specified position in this list. * Shifts any subsequent elements to the left (subtracts one from their * indices). * * @param index the index of the element to be removed * @return the element that was removed from the list * @throws IndexOutOfBoundsException {@inheritDoc} */ public E remove(int index) { RangeCheck(index); modCount++; E oldValue = (E) elementData[index]; int numMoved = size - index - 1; if (numMoved > 0) System.arraycopy(elementData, index+1, elementData, index, numMoved); elementData[--size] = null; // Let gc do its work return oldValue; } /** * Removes the first occurrence of the specified element from this list, * if it is present. If the list does not contain the element, it is * unchanged. More formally, removes the element with the lowest index * <tt>i</tt> such that * <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt> * (if such an element exists). Returns <tt>true</tt> if this list * contained the specified element (or equivalently, if this list * changed as a result of the call). * * @param o element to be removed from this list, if present * @return <tt>true</tt> if this list contained the specified element */ public boolean remove(Object o) { if (o == null) { for (int index = 0; index < size; index++) if (elementData[index] == null) { fastRemove(index); return true; } } else { for (int index = 0; index < size; index++) if (o.equals(elementData[index])) { fastRemove(index); return true; } } return false; } /* * Private remove method that skips bounds checking and does not * return the value removed. */ private void fastRemove(int index) { modCount++; int numMoved = size - index - 1; if (numMoved > 0) System.arraycopy(elementData, index+1, elementData, index, numMoved); elementData[--size] = null; // Let gc do its work } /** * Removes all of the elements from this list. The list will * be empty after this call returns. */ public void clear() { modCount++; // Let gc do its work for (int i = 0; i < size; i++) elementData[i] = null; size = 0; } /** * Appends all of the elements in the specified collection to the end of * this list, in the order that they are returned by the * specified collection's Iterator. The behavior of this operation is * undefined if the specified collection is modified while the operation * is in progress. (This implies that the behavior of this call is * undefined if the specified collection is this list, and this * list is nonempty.) * * @param c collection containing elements to be added to this list * @return <tt>true</tt> if this list changed as a result of the call * @throws NullPointerException if the specified collection is null */ public boolean addAll(Collection<? extends E> c) { Object[] a = c.toArray(); int numNew = a.length; ensureCapacity(size + numNew); // Increments modCount System.arraycopy(a, 0, elementData, size, numNew); size += numNew; return numNew != 0; } /** * Inserts all of the elements in the specified collection into this * list, starting at the specified position. Shifts the element * currently at that position (if any) and any subsequent elements to * the right (increases their indices). The new elements will appear * in the list in the order that they are returned by the * specified collection's iterator. * * @param index index at which to insert the first element from the * specified collection * @param c collection containing elements to be added to this list * @return <tt>true</tt> if this list changed as a result of the call * @throws IndexOutOfBoundsException {@inheritDoc} * @throws NullPointerException if the specified collection is null */ public boolean addAll(int index, Collection<? extends E> c) { if (index > size || index < 0) throw new IndexOutOfBoundsException( "Index: " + index + ", Size: " + size); Object[] a = c.toArray(); int numNew = a.length; ensureCapacity(size + numNew); // Increments modCount int numMoved = size - index; if (numMoved > 0) System.arraycopy(elementData, index, elementData, index + numNew, numMoved); System.arraycopy(a, 0, elementData, index, numNew); size += numNew; return numNew != 0; } /** * Removes from this list all of the elements whose index is between * <tt>fromIndex</tt>, inclusive, and <tt>toIndex</tt>, exclusive. * Shifts any succeeding elements to the left (reduces their index). * This call shortens the list by <tt>(toIndex - fromIndex)</tt> elements. * (If <tt>toIndex==fromIndex</tt>, this operation has no effect.) * * @param fromIndex index of first element to be removed * @param toIndex index after last element to be removed * @throws IndexOutOfBoundsException if fromIndex or toIndex out of * range (fromIndex < 0 || fromIndex >= size() || toIndex * > size() || toIndex < fromIndex) */ protected void removeRange(int fromIndex, int toIndex) { modCount++; int numMoved = size - toIndex; System.arraycopy(elementData, toIndex, elementData, fromIndex, numMoved); // Let gc do its work int newSize = size - (toIndex-fromIndex); while (size != newSize) elementData[--size] = null; } /** * Checks if the given index is in range. If not, throws an appropriate * runtime exception. This method does *not* check if the index is * negative: It is always used immediately prior to an array access, * which throws an ArrayIndexOutOfBoundsException if index is negative. */ private void RangeCheck(int index) { if (index >= size) throw new IndexOutOfBoundsException( "Index: "+index+", Size: "+size); } /** * Save the state of the <tt>ArrayList</tt> instance to a stream (that * is, serialize it). * * @serialData The length of the array backing the <tt>ArrayList</tt> * instance is emitted (int), followed by all of its elements * (each an <tt>Object</tt>) in the proper order. */ private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{ // Write out element count, and any hidden stuff int expectedModCount = modCount; s.defaultWriteObject(); // Write out array length s.writeInt(elementData.length); // Write out all elements in the proper order. for (int i=0; i<size; i++) s.writeObject(elementData[i]); if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } } /** * Reconstitute the <tt>ArrayList</tt> instance from a stream (that is, * deserialize it). */ private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException { // Read in size, and any hidden stuff s.defaultReadObject(); // Read in array length and allocate array int arrayLength = s.readInt(); Object[] a = elementData = new Object[arrayLength]; // Read in all elements in the proper order. for (int i=0; i<size; i++) a[i] = s.readObject(); } }
就这么点代码,是个人都能看出来arraylist就是封装了数组在里面,你说封装个数组,还比数组快,可能么。
这也就罢了,您换个方式研究咱没意见,最后的结论竟然是为了性能请用数组。
要是这么喜欢性能,您用java干嘛阿。
PS.而且凡是读过书,读过代码,哪怕写过1k行代码的最菜的人,也知道大多数时候,维护一个定长数组需要付出多大的功夫,连cpp里面都漫天vector了。还有人发现了一块新大陆,你让别人能不吐么?
长得丑无所谓,但是出来吓人还是有所谓的。对于不懂的事情,别做总结性发言。
我也没让你来看啊,你自己非要进来看,还回帖一直在这冷嘲热讽,不过还是给谢谢你的建议。
11 楼
hurricane1026
2009-01-10
抛出异常的爱 写道
如果想要多次增加数组大小
用list比array快.....因为:
如果想要快速遍历所有点.
list比array快
因为:
如果想要快速定位
用hashmap会不会更快一点呢.
用list比array快.....因为:
int newCapacity = (oldCapacity * 3)/2 + 1; //....... elementData = Arrays.copyOf(elementData, newCapacity);
如果想要快速遍历所有点.
list比array快
因为:
//当remove时 System.arraycopy(elementData, index+1, elementData, index, numMoved);
如果想要快速定位
用hashmap会不会更快一点呢.
arraylist是随机存储介质,适合于需要访问某个特定位置的内容,而list(linkedlist)一般也就是增删容易,add没有额外的负担,但是遍历很快
需要快速定位,除非是需要key的,否则没人用hashmap,因为hasher本身也是很大的计算复杂度。
10 楼
抛出异常的爱
2009-01-10
如果想要多次增加数组大小
用list比array快.....因为:
如果想要快速遍历所有点.
list比array快
因为:
如果想要快速定位
用hashmap会不会更快一点呢.
用list比array快.....因为:
int newCapacity = (oldCapacity * 3)/2 + 1; //....... elementData = Arrays.copyOf(elementData, newCapacity);
如果想要快速遍历所有点.
list比array快
因为:
//当remove时 System.arraycopy(elementData, index+1, elementData, index, numMoved);
如果想要快速定位
用hashmap会不会更快一点呢.
9 楼
hurricane1026
2009-01-10
/* * @(#)ArrayList.java 1.56 06/04/21 * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package java.util; /** * Resizable-array implementation of the <tt>List</tt> interface. Implements * all optional list operations, and permits all elements, including * <tt>null</tt>. In addition to implementing the <tt>List</tt> interface, * this class provides methods to manipulate the size of the array that is * used internally to store the list. (This class is roughly equivalent to * <tt>Vector</tt>, except that it is unsynchronized.)<p> * * The <tt>size</tt>, <tt>isEmpty</tt>, <tt>get</tt>, <tt>set</tt>, * <tt>iterator</tt>, and <tt>listIterator</tt> operations run in constant * time. The <tt>add</tt> operation runs in <i>amortized constant time</i>, * that is, adding n elements requires O(n) time. All of the other operations * run in linear time (roughly speaking). The constant factor is low compared * to that for the <tt>LinkedList</tt> implementation.<p> * * Each <tt>ArrayList</tt> instance has a <i>capacity</i>. The capacity is * the size of the array used to store the elements in the list. It is always * at least as large as the list size. As elements are added to an ArrayList, * its capacity grows automatically. The details of the growth policy are not * specified beyond the fact that adding an element has constant amortized * time cost.<p> * * An application can increase the capacity of an <tt>ArrayList</tt> instance * before adding a large number of elements using the <tt>ensureCapacity</tt> * operation. This may reduce the amount of incremental reallocation. * * <p><strong>Note that this implementation is not synchronized.</strong> * If multiple threads access an <tt>ArrayList</tt> instance concurrently, * and at least one of the threads modifies the list structurally, it * <i>must</i> be synchronized externally. (A structural modification is * any operation that adds or deletes one or more elements, or explicitly * resizes the backing array; merely setting the value of an element is not * a structural modification.) This is typically accomplished by * synchronizing on some object that naturally encapsulates the list. * * If no such object exists, the list should be "wrapped" using the * {@link Collections#synchronizedList Collections.synchronizedList} * method. This is best done at creation time, to prevent accidental * unsynchronized access to the list:<pre> * List list = Collections.synchronizedList(new ArrayList(...));</pre> * * <p>The iterators returned by this class's <tt>iterator</tt> and * <tt>listIterator</tt> methods are <i>fail-fast</i>: if the list is * structurally modified at any time after the iterator is created, in any way * except through the iterator's own <tt>remove</tt> or <tt>add</tt> methods, * the iterator will throw a {@link ConcurrentModificationException}. Thus, in * the face of concurrent modification, the iterator fails quickly and cleanly, * rather than risking arbitrary, non-deterministic behavior at an undetermined * time in the future.<p> * * Note that the fail-fast behavior of an iterator cannot be guaranteed * as it is, generally speaking, impossible to make any hard guarantees in the * presence of unsynchronized concurrent modification. Fail-fast iterators * throw <tt>ConcurrentModificationException</tt> on a best-effort basis. * Therefore, it would be wrong to write a program that depended on this * exception for its correctness: <i>the fail-fast behavior of iterators * should be used only to detect bugs.</i><p> * * This class is a member of the * <a href="{@docRoot}/../technotes/guides/collections/index.html"> * Java Collections Framework</a>. * * @author Josh Bloch * @author Neal Gafter * @version 1.56, 04/21/06 * @see Collection * @see List * @see LinkedList * @see Vector * @since 1.2 */ public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable { private static final long serialVersionUID = 8683452581122892189L; /** * The array buffer into which the elements of the ArrayList are stored. * The capacity of the ArrayList is the length of this array buffer. */ private transient Object[] elementData; /** * The size of the ArrayList (the number of elements it contains). * * @serial */ private int size; /** * Constructs an empty list with the specified initial capacity. * * @param initialCapacity the initial capacity of the list * @exception IllegalArgumentException if the specified initial capacity * is negative */ public ArrayList(int initialCapacity) { super(); if (initialCapacity < 0) throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); this.elementData = new Object[initialCapacity]; } /** * Constructs an empty list with an initial capacity of ten. */ public ArrayList() { this(10); } /** * Constructs a list containing the elements of the specified * collection, in the order they are returned by the collection's * iterator. * * @param c the collection whose elements are to be placed into this list * @throws NullPointerException if the specified collection is null */ public ArrayList(Collection<? extends E> c) { elementData = c.toArray(); size = elementData.length; // c.toArray might (incorrectly) not return Object[] (see 6260652) if (elementData.getClass() != Object[].class) elementData = Arrays.copyOf(elementData, size, Object[].class); } /** * Trims the capacity of this <tt>ArrayList</tt> instance to be the * list's current size. An application can use this operation to minimize * the storage of an <tt>ArrayList</tt> instance. */ public void trimToSize() { modCount++; int oldCapacity = elementData.length; if (size < oldCapacity) { elementData = Arrays.copyOf(elementData, size); } } /** * Increases the capacity of this <tt>ArrayList</tt> instance, if * necessary, to ensure that it can hold at least the number of elements * specified by the minimum capacity argument. * * @param minCapacity the desired minimum capacity */ public void ensureCapacity(int minCapacity) { modCount++; int oldCapacity = elementData.length; if (minCapacity > oldCapacity) { Object oldData[] = elementData; int newCapacity = (oldCapacity * 3)/2 + 1; if (newCapacity < minCapacity) newCapacity = minCapacity; // minCapacity is usually close to size, so this is a win: elementData = Arrays.copyOf(elementData, newCapacity); } } /** * Returns the number of elements in this list. * * @return the number of elements in this list */ public int size() { return size; } /** * Returns <tt>true</tt> if this list contains no elements. * * @return <tt>true</tt> if this list contains no elements */ public boolean isEmpty() { return size == 0; } /** * Returns <tt>true</tt> if this list contains the specified element. * More formally, returns <tt>true</tt> if and only if this list contains * at least one element <tt>e</tt> such that * <tt>(o==null ? e==null : o.equals(e))</tt>. * * @param o element whose presence in this list is to be tested * @return <tt>true</tt> if this list contains the specified element */ public boolean contains(Object o) { return indexOf(o) >= 0; } /** * Returns the index of the first occurrence of the specified element * in this list, or -1 if this list does not contain the element. * More formally, returns the lowest index <tt>i</tt> such that * <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>, * or -1 if there is no such index. */ public int indexOf(Object o) { if (o == null) { for (int i = 0; i < size; i++) if (elementData[i]==null) return i; } else { for (int i = 0; i < size; i++) if (o.equals(elementData[i])) return i; } return -1; } /** * Returns the index of the last occurrence of the specified element * in this list, or -1 if this list does not contain the element. * More formally, returns the highest index <tt>i</tt> such that * <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>, * or -1 if there is no such index. */ public int lastIndexOf(Object o) { if (o == null) { for (int i = size-1; i >= 0; i--) if (elementData[i]==null) return i; } else { for (int i = size-1; i >= 0; i--) if (o.equals(elementData[i])) return i; } return -1; } /** * Returns a shallow copy of this <tt>ArrayList</tt> instance. (The * elements themselves are not copied.) * * @return a clone of this <tt>ArrayList</tt> instance */ public Object clone() { try { ArrayList<E> v = (ArrayList<E>) super.clone(); v.elementData = Arrays.copyOf(elementData, size); v.modCount = 0; return v; } catch (CloneNotSupportedException e) { // this shouldn't happen, since we are Cloneable throw new InternalError(); } } /** * Returns an array containing all of the elements in this list * in proper sequence (from first to last element). * * <p>The returned array will be "safe" in that no references to it are * maintained by this list. (In other words, this method must allocate * a new array). The caller is thus free to modify the returned array. * * <p>This method acts as bridge between array-based and collection-based * APIs. * * @return an array containing all of the elements in this list in * proper sequence */ public Object[] toArray() { return Arrays.copyOf(elementData, size); } /** * Returns an array containing all of the elements in this list in proper * sequence (from first to last element); the runtime type of the returned * array is that of the specified array. If the list fits in the * specified array, it is returned therein. Otherwise, a new array is * allocated with the runtime type of the specified array and the size of * this list. * * <p>If the list fits in the specified array with room to spare * (i.e., the array has more elements than the list), the element in * the array immediately following the end of the collection is set to * <tt>null</tt>. (This is useful in determining the length of the * list <i>only</i> if the caller knows that the list does not contain * any null elements.) * * @param a the array into which the elements of the list are to * be stored, if it is big enough; otherwise, a new array of the * same runtime type is allocated for this purpose. * @return an array containing the elements of the list * @throws ArrayStoreException if the runtime type of the specified array * is not a supertype of the runtime type of every element in * this list * @throws NullPointerException if the specified array is null */ public <T> T[] toArray(T[] a) { if (a.length < size) // Make a new array of a's runtime type, but my contents: return (T[]) Arrays.copyOf(elementData, size, a.getClass()); System.arraycopy(elementData, 0, a, 0, size); if (a.length > size) a[size] = null; return a; } // Positional Access Operations /** * Returns the element at the specified position in this list. * * @param index index of the element to return * @return the element at the specified position in this list * @throws IndexOutOfBoundsException {@inheritDoc} */ public E get(int index) { RangeCheck(index); return (E) elementData[index]; } /** * Replaces the element at the specified position in this list with * the specified element. * * @param index index of the element to replace * @param element element to be stored at the specified position * @return the element previously at the specified position * @throws IndexOutOfBoundsException {@inheritDoc} */ public E set(int index, E element) { RangeCheck(index); E oldValue = (E) elementData[index]; elementData[index] = element; return oldValue; } /** * Appends the specified element to the end of this list. * * @param e element to be appended to this list * @return <tt>true</tt> (as specified by {@link Collection#add}) */ public boolean add(E e) { ensureCapacity(size + 1); // Increments modCount!! elementData[size++] = e; return true; } /** * Inserts the specified element at the specified position in this * list. Shifts the element currently at that position (if any) and * any subsequent elements to the right (adds one to their indices). * * @param index index at which the specified element is to be inserted * @param element element to be inserted * @throws IndexOutOfBoundsException {@inheritDoc} */ public void add(int index, E element) { if (index > size || index < 0) throw new IndexOutOfBoundsException( "Index: "+index+", Size: "+size); ensureCapacity(size+1); // Increments modCount!! System.arraycopy(elementData, index, elementData, index + 1, size - index); elementData[index] = element; size++; } /** * Removes the element at the specified position in this list. * Shifts any subsequent elements to the left (subtracts one from their * indices). * * @param index the index of the element to be removed * @return the element that was removed from the list * @throws IndexOutOfBoundsException {@inheritDoc} */ public E remove(int index) { RangeCheck(index); modCount++; E oldValue = (E) elementData[index]; int numMoved = size - index - 1; if (numMoved > 0) System.arraycopy(elementData, index+1, elementData, index, numMoved); elementData[--size] = null; // Let gc do its work return oldValue; } /** * Removes the first occurrence of the specified element from this list, * if it is present. If the list does not contain the element, it is * unchanged. More formally, removes the element with the lowest index * <tt>i</tt> such that * <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt> * (if such an element exists). Returns <tt>true</tt> if this list * contained the specified element (or equivalently, if this list * changed as a result of the call). * * @param o element to be removed from this list, if present * @return <tt>true</tt> if this list contained the specified element */ public boolean remove(Object o) { if (o == null) { for (int index = 0; index < size; index++) if (elementData[index] == null) { fastRemove(index); return true; } } else { for (int index = 0; index < size; index++) if (o.equals(elementData[index])) { fastRemove(index); return true; } } return false; } /* * Private remove method that skips bounds checking and does not * return the value removed. */ private void fastRemove(int index) { modCount++; int numMoved = size - index - 1; if (numMoved > 0) System.arraycopy(elementData, index+1, elementData, index, numMoved); elementData[--size] = null; // Let gc do its work } /** * Removes all of the elements from this list. The list will * be empty after this call returns. */ public void clear() { modCount++; // Let gc do its work for (int i = 0; i < size; i++) elementData[i] = null; size = 0; } /** * Appends all of the elements in the specified collection to the end of * this list, in the order that they are returned by the * specified collection's Iterator. The behavior of this operation is * undefined if the specified collection is modified while the operation * is in progress. (This implies that the behavior of this call is * undefined if the specified collection is this list, and this * list is nonempty.) * * @param c collection containing elements to be added to this list * @return <tt>true</tt> if this list changed as a result of the call * @throws NullPointerException if the specified collection is null */ public boolean addAll(Collection<? extends E> c) { Object[] a = c.toArray(); int numNew = a.length; ensureCapacity(size + numNew); // Increments modCount System.arraycopy(a, 0, elementData, size, numNew); size += numNew; return numNew != 0; } /** * Inserts all of the elements in the specified collection into this * list, starting at the specified position. Shifts the element * currently at that position (if any) and any subsequent elements to * the right (increases their indices). The new elements will appear * in the list in the order that they are returned by the * specified collection's iterator. * * @param index index at which to insert the first element from the * specified collection * @param c collection containing elements to be added to this list * @return <tt>true</tt> if this list changed as a result of the call * @throws IndexOutOfBoundsException {@inheritDoc} * @throws NullPointerException if the specified collection is null */ public boolean addAll(int index, Collection<? extends E> c) { if (index > size || index < 0) throw new IndexOutOfBoundsException( "Index: " + index + ", Size: " + size); Object[] a = c.toArray(); int numNew = a.length; ensureCapacity(size + numNew); // Increments modCount int numMoved = size - index; if (numMoved > 0) System.arraycopy(elementData, index, elementData, index + numNew, numMoved); System.arraycopy(a, 0, elementData, index, numNew); size += numNew; return numNew != 0; } /** * Removes from this list all of the elements whose index is between * <tt>fromIndex</tt>, inclusive, and <tt>toIndex</tt>, exclusive. * Shifts any succeeding elements to the left (reduces their index). * This call shortens the list by <tt>(toIndex - fromIndex)</tt> elements. * (If <tt>toIndex==fromIndex</tt>, this operation has no effect.) * * @param fromIndex index of first element to be removed * @param toIndex index after last element to be removed * @throws IndexOutOfBoundsException if fromIndex or toIndex out of * range (fromIndex < 0 || fromIndex >= size() || toIndex * > size() || toIndex < fromIndex) */ protected void removeRange(int fromIndex, int toIndex) { modCount++; int numMoved = size - toIndex; System.arraycopy(elementData, toIndex, elementData, fromIndex, numMoved); // Let gc do its work int newSize = size - (toIndex-fromIndex); while (size != newSize) elementData[--size] = null; } /** * Checks if the given index is in range. If not, throws an appropriate * runtime exception. This method does *not* check if the index is * negative: It is always used immediately prior to an array access, * which throws an ArrayIndexOutOfBoundsException if index is negative. */ private void RangeCheck(int index) { if (index >= size) throw new IndexOutOfBoundsException( "Index: "+index+", Size: "+size); } /** * Save the state of the <tt>ArrayList</tt> instance to a stream (that * is, serialize it). * * @serialData The length of the array backing the <tt>ArrayList</tt> * instance is emitted (int), followed by all of its elements * (each an <tt>Object</tt>) in the proper order. */ private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{ // Write out element count, and any hidden stuff int expectedModCount = modCount; s.defaultWriteObject(); // Write out array length s.writeInt(elementData.length); // Write out all elements in the proper order. for (int i=0; i<size; i++) s.writeObject(elementData[i]); if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } } /** * Reconstitute the <tt>ArrayList</tt> instance from a stream (that is, * deserialize it). */ private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException { // Read in size, and any hidden stuff s.defaultReadObject(); // Read in array length and allocate array int arrayLength = s.readInt(); Object[] a = elementData = new Object[arrayLength]; // Read in all elements in the proper order. for (int i=0; i<size; i++) a[i] = s.readObject(); } }
就这么点代码,是个人都能看出来arraylist就是封装了数组在里面,你说封装个数组,还比数组快,可能么。
这也就罢了,您换个方式研究咱没意见,最后的结论竟然是为了性能请用数组。
要是这么喜欢性能,您用java干嘛阿。
PS.而且凡是读过书,读过代码,哪怕写过1k行代码的最菜的人,也知道大多数时候,维护一个定长数组需要付出多大的功夫,连cpp里面都漫天vector了。还有人发现了一块新大陆,你让别人能不吐么?
长得丑无所谓,但是出来吓人还是有所谓的。对于不懂的事情,别做总结性发言。
8 楼
DoubleEO
2009-01-09
李逍遥 写道
楼主虽然是研究了一个已经约定俗成的做法
但毕竟是花了心思的
觉得无价值的可以什么都不说
觉得自己牛的可以别来这个版
但没必要冷嘲热讽吧
难道你们一生下来就什么都会啊
但毕竟是花了心思的
觉得无价值的可以什么都不说
觉得自己牛的可以别来这个版
但没必要冷嘲热讽吧
难道你们一生下来就什么都会啊
说得好啊,其实你说出了最平凡的道理,但是能做到的人很少,咱们国家的程序员都是这样的,像古代的文人--自古相轻,你搞出了无论是不是好的东西,都会觉得你是个SB,一直是这样
7 楼
李逍遥
2009-01-09
楼主虽然是研究了一个已经约定俗成的做法
但毕竟是花了心思的
觉得无价值的可以什么都不说
觉得自己牛的可以别来这个版
但没必要冷嘲热讽吧
难道你们一生下来就什么都会啊
但毕竟是花了心思的
觉得无价值的可以什么都不说
觉得自己牛的可以别来这个版
但没必要冷嘲热讽吧
难道你们一生下来就什么都会啊
6 楼
DoubleEO
2009-01-09
hurricane1026 写道
DoubleEO 写道
抛出异常的爱 写道
如果为了快程序里都是[]这东西.....
让我出去吐吐回来再看.
能排序?能快速打印?能快速增加?
让我出去吐吐回来再看.
能排序?能快速打印?能快速增加?
吐呗,可劲吐,只是一种思考,以前从来没想过这些性能问题,而且又没说永远不许用集合对象,
只有通过细致的性能测评和对系统的详尽分析,才能做出正确的选择!!
如果你考虑性能问题就从这些地方入手,还是把编程当做业余爱好吧。
外国一个编程的高手,Peter hagger--大名鼎鼎的practicial java的作者,也考虑了这个问题,我就是看他的文章,思考的。总之,谢谢你的建议。
5 楼
hurricane1026
2009-01-09
DoubleEO 写道
抛出异常的爱 写道
如果为了快程序里都是[]这东西.....
让我出去吐吐回来再看.
能排序?能快速打印?能快速增加?
让我出去吐吐回来再看.
能排序?能快速打印?能快速增加?
吐呗,可劲吐,只是一种思考,以前从来没想过这些性能问题,而且又没说永远不许用集合对象,
只有通过细致的性能测评和对系统的详尽分析,才能做出正确的选择!!
如果你考虑性能问题就从这些地方入手,还是把编程当做业余爱好吧。
4 楼
DoubleEO
2009-01-09
hurricane1026 写道
抛出异常的爱 写道
如果为了快程序里都是[]这东西.....
让我出去吐吐回来再看.
能排序?能快速打印?能快速增加?
让我出去吐吐回来再看.
能排序?能快速打印?能快速增加?
吐啊吐啊就习惯了。这个版面真让人不敢来啊。
呵呵,你是不是楼上的小弟啊~
3 楼
DoubleEO
2009-01-09
抛出异常的爱 写道
如果为了快程序里都是[]这东西.....
让我出去吐吐回来再看.
能排序?能快速打印?能快速增加?
让我出去吐吐回来再看.
能排序?能快速打印?能快速增加?
吐呗,可劲吐,只是一种思考,以前从来没想过这些性能问题,而且又没说永远不许用集合对象,
只有通过细致的性能测评和对系统的详尽分析,才能做出正确的选择!!
2 楼
hurricane1026
2009-01-09
抛出异常的爱 写道
如果为了快程序里都是[]这东西.....
让我出去吐吐回来再看.
能排序?能快速打印?能快速增加?
让我出去吐吐回来再看.
能排序?能快速打印?能快速增加?
吐啊吐啊就习惯了。这个版面真让人不敢来啊。
1 楼
抛出异常的爱
2009-01-09
如果为了快程序里都是[]这东西.....
让我出去吐吐回来再看.
能排序?能快速打印?能快速增加?
让我出去吐吐回来再看.
能排序?能快速打印?能快速增加?
发表评论
-
【转】Java:使用synchronized和Lock对象获取对象锁
2010-02-28 23:17 936在并发环境下,解决共享资源冲突问题时,可以考虑使用锁机制。 1 ... -
java基础配置
2009-09-23 13:49 738总有朋友问,每次都打一遍,太麻烦了 在我的电脑 右键 -- ... -
关于ThreadLocal
2009-05-31 22:19 1136一、概述 ThreadLocal是什么呢?其实ThreadLo ... -
构造函数中调用其他的方法会产生的问题
2009-01-14 21:47 801看代码 class Base{ priv ... -
不可变对象,深层次克隆等总结
2009-01-13 15:18 1808前面有篇自己总结的文章,是用final方法标注引用的,引 ... -
集合对象的迭代效率
2009-01-09 16:45 864集合的迭代,在多数情况下,咱们想都不想,就会用下面这种 ... -
局部变量效率更高
2009-01-09 14:09 970程序中的变量有3种,局部变量,实例变量,类变量,他们在 ... -
几种拼接字符串的效率问题
2009-01-09 09:26 1728每次拼接字符串的时候用习惯了String,从来没想过用其他的c ... -
参数到底怎样传递?只有传值!!
2009-01-05 11:47 751只有传值!! import java. ... -
对接口的概念一直不理解,请畅所欲言,谈谈自己的理解
2008-11-08 18:31 916接口,java中很重要的概念。 在大学的时候(当然了,我大学没 ... -
方法实参传递的疑惑!!
2008-06-15 13:59 977public class PassArray { ...
相关推荐
4存取数组元素6-5使用Length属性检查数组上下限6-6 数组与集合的比较6-7 声明时初始化数组6-7-1 使用简短的表示法6-7-2 初始化多维的数组6-8 执行时期指定数组的大小6-9 JaggedArray6-10 复制数组变量6-11 ...
4存取数组元素6-5使用Length属性检查数组上下限6-6 数组与集合的比较6-7 声明时初始化数组6-7-1 使用简短的表示法6-7-2 初始化多维的数组6-8 执行时期指定数组的大小6-9 JaggedArray6-10 复制数组变量6-11 ...
810.3 数组指针和指向数组的指针变量 141 10.3.1 指向数组元素的指针 142 10.3.2 通过指针引用数组元素 143 10.3.3 数组名作函数参数 146 10.3.4 指向多维数组的指针和指针变量 148 10.4 字符串的指针指向字符串的针...
810.3 数组指针和指向数组的指针变量 141 10.3.1 指向数组元素的指针 142 10.3.2 通过指针引用数组元素 143 10.3.3 数组名作函数参数 146 10.3.4 指向多维数组的指针和指针变量 148 10.4 字符串的指针指向字符串的针...
- 标准算术支持遵守符号优先和括号: +, -, /, *, and, or, , >> - 高速编译器, 大约 300 000 行/分钟在P200! - 过程支持本地和全局变量结构编程 - 支持所有标准 BASIC 关键词: If-Else-EndIf, Repeat-Until, 等等 -...
jQuery因为易于使用和功能强大著称,是所有Web开发者应该掌握的一种利器,初学者如何才能快速而有效地掌握jQuery呢?最好的方法莫过于一边学习理论,一边动手实践这些理论,本书就是按照这种思路为读者打造的,强烈...
5.2 数组的顺序表示和实现 5.3 矩阵的压缩存储 5.3.1 特殊矩阵 5.3.2 稀疏矩阵 5.4 广义表的定义 5.5 广义表的存储结构 5.6 m元多项式的表示 5.7 广义表的递归算法 5.7.1 求广义表的深度 5.7.2 复制广义表 5.7.3 ...
-- 演示数组复制 -- local bArray = new("[B", 16) for i = 0, 15 do set(bArray, "[" .. i .. "]", i 1) end local bArray2 = new("[B", get(bArray, "length")) ...
5、2、0 数组的顺序表示和实现 实验五 5、3、0 矩阵的压缩存储 5、3、1 特殊矩阵 5、3、2 稀疏矩阵 5、4、0 广义表的定义 5、5、0 广义表的存储结构 5、6、0 m元多项式的表示 5、7、0 广义表的递归算法 5、7、1 求...
10、新增“文本_逐字分割_快速”,【注意】 必须和 文本_逐字分割_快速_释放() 配套使用, 如果不释放可能会导致崩溃, 快速把一个文本按每个字符进行分割, 返回分割后的成员数;感谢【@福仔 】提供; 11、新增“文本...
5、2、0 数组的顺序表示和实现 实验五 5、3、0 矩阵的压缩存储 5、3、1 特殊矩阵 5、3、2 稀疏矩阵 5、4、0 广义表的定义 5、5、0 广义表的存储结构 5、6、0 m元多项式的表示 5、7、0 广义表的递归算法 5、7、1 求...
2、修正“目录_复制”在线程未初始化,导致对象不能创建的问题,感谢易友【@pp25729391】反馈。 3、修正“类_环境存取->读环境变量”不能读取当前进程环境变量的BUG,感谢易友【@詠不言敗】反馈。 4、修正“文本_...
17.4.4 使用-定值链和定值-使用链 277 17.4.5 工作表算法 278 17.4.6 增量式数据流分析 278 17.5 别名分析 281 17.5.1 基于类型的别名分析 282 17.5.2 基于流的别名分析 283 17.5.3 使用可能别名信息 284 17.5.4 ...
常见虚拟机监控与故障处理工具的原理和使用方法。第三部分分析了虚拟机的执行子系统,包括类文件结构、虚拟机类加载机制、虚拟机字节码执行引擎。第四部分讲解了程序的编译与代码的优化,阐述了泛型、自动装箱拆箱、...
子程序 _高级处理事件, , 公开, 优化处理事件的效率,先判断是否存在事件 .子程序 _高精度等待, , 公开 .参数 微秒, 整数型, , 单位/微秒 1000微秒=1毫秒;1000毫秒=1秒 .子程序 _高精度延时, , 公开 .参数 微秒, ...
10、新增“文本_逐字分割_快速”,【注意】 必须和 文本_逐字分割_快速_释放() 配套使用, 如果不释放可能会导致崩溃, 快速把一个文本按每个字符进行分割, 返回分割后的成员数;感谢【 @福仔 】提供; 11、新增...
八数码问题,多多指教 ...因此它只求解了问题的全部状态空间中的部分状态,提高了效率和减少了用于处理的空间。另外A*算法是AI的基本算法之一。我们也可以这么说:人工智能的精髓就是穷举,人工智能的关键就是控制策略