java.lang 接口 Iterable<T>
java.util 接口 Collection<E> 父接口是 Iterable<T>
集合中的元素是否可以重复? ------ 有些可以,有些不可以
集合中的元素是否有顺序? ------有些是有序的,有些是无序的
Collection<E> 的子接口 :
java.util 接口 List<E>
java.util 接口 Set<E>
java.util 接口 Queue<E>
java.util 接口 List<E> : 有序的 collection
E get(int index) 返回列表中指定位置的元素
E remove(int index) 移除列表中指定位置的元素(可选操作)。
void add(int index, E element) 在列表的指定位置插入指定元素(可选操作)。
List接口的实现类: ArrayList 、LinkedList、Stack、Vector
java.util 类 ArrayList<E> : List 接口的大小可变数组的实现 (1.ArrayList的底层实现是静态数组 2.数组的大小可变)
int[] ages = new int[10];
Dog[] dogs = new Dog[10];
提问:静态数组的大小是如何实现变化的?
dogs[10] = new Dog("晶晶"); ---------会出现数组下标越界的异常
dogs = new Dog[20]; ------ 重新分配内存,把原有数据拷贝的新内存中
ArrayList()
构造一个初始容量为 10 的空列表
ArrayList(int initialCapacity)
构造一个具有指定初始容量的空列表
ArrayList初始容量的分配原则:既不要出现频繁的内存重新分配,也不要有太多的内存浪费,这样最好!
Collection<Student> stus = new ArrayList<Student>(60);
ArrayList的底层实现是Object[]
private transient Object[] elementData;
参考:构造函数之间的相互调用
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
}
public ArrayList() {
this(10);
}
public boolean add(E e) {
ensureCapacity(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
ArrayList内存重新分配的原则: int newCapacity = (oldCapacity * 3)/2 + 1;
用三种方法,遍历List集合:
for(int i=0;i<stus.size();i++){
System.out.println(stus.get(i).getName());
}
Iterator<Student> it = stus.iterator();
while(it.hasNext()){
Student stu = it.next();
System.out.println(stu.getName());
}
for(Student stu : stus){
System.out.println(stu.getName());
}
提问: 从ArrayList中移出某个元素后,会发生什么?
E remove(int index) 移除列表中指定位置的元素(可选操作)。
移除此列表中指定位置上的元素。向左移动所有后续元素(将其索引减 1)。
remove方法会产生内存的重新分配: System.arraycopy(elementData, index+1, elementData, index,numMoved);
结论:
ArrayList的数据结构的特点是查询检索元素的速度非常快!
当ArrayList中的数据出现插队或移出时,性能会受到很大的影响!
数据结构的特点,决定了它的使用场景:如从数据库中提取数据,然后进行展示、但不修改,这种情况性能最好!
Object 的 hashCode()
在 Java 应用程序执行期间,在对同一对象多次调用 hashCode 方法时,必须一致地返回相同的整数
两个对象不相等,那么对这两个对象中的任一对象上调用 hashCode 方法不 要求一定生成不同的整数结果
java.util 接口 Collection<E> 父接口是 Iterable<T>
集合中的元素是否可以重复? ------ 有些可以,有些不可以
集合中的元素是否有顺序? ------有些是有序的,有些是无序的
Collection<E> 的子接口 :
java.util 接口 List<E>
java.util 接口 Set<E>
java.util 接口 Queue<E>
java.util 接口 List<E> : 有序的 collection
E get(int index) 返回列表中指定位置的元素
E remove(int index) 移除列表中指定位置的元素(可选操作)。
void add(int index, E element) 在列表的指定位置插入指定元素(可选操作)。
List接口的实现类: ArrayList 、LinkedList、Stack、Vector
java.util 类 ArrayList<E> : List 接口的大小可变数组的实现 (1.ArrayList的底层实现是静态数组 2.数组的大小可变)
int[] ages = new int[10];
Dog[] dogs = new Dog[10];
提问:静态数组的大小是如何实现变化的?
dogs[10] = new Dog("晶晶"); ---------会出现数组下标越界的异常
dogs = new Dog[20]; ------ 重新分配内存,把原有数据拷贝的新内存中
ArrayList()
构造一个初始容量为 10 的空列表
ArrayList(int initialCapacity)
构造一个具有指定初始容量的空列表
ArrayList初始容量的分配原则:既不要出现频繁的内存重新分配,也不要有太多的内存浪费,这样最好!
Collection<Student> stus = new ArrayList<Student>(60);
ArrayList的底层实现是Object[]
private transient Object[] elementData;
参考:构造函数之间的相互调用
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
}
public ArrayList() {
this(10);
}
public boolean add(E e) {
ensureCapacity(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
ArrayList内存重新分配的原则: int newCapacity = (oldCapacity * 3)/2 + 1;
用三种方法,遍历List集合:
for(int i=0;i<stus.size();i++){
System.out.println(stus.get(i).getName());
}
Iterator<Student> it = stus.iterator();
while(it.hasNext()){
Student stu = it.next();
System.out.println(stu.getName());
}
for(Student stu : stus){
System.out.println(stu.getName());
}
提问: 从ArrayList中移出某个元素后,会发生什么?
E remove(int index) 移除列表中指定位置的元素(可选操作)。
移除此列表中指定位置上的元素。向左移动所有后续元素(将其索引减 1)。
remove方法会产生内存的重新分配: System.arraycopy(elementData, index+1, elementData, index,numMoved);
结论:
ArrayList的数据结构的特点是查询检索元素的速度非常快!
当ArrayList中的数据出现插队或移出时,性能会受到很大的影响!
数据结构的特点,决定了它的使用场景:如从数据库中提取数据,然后进行展示、但不修改,这种情况性能最好!
Object 的 hashCode()
在 Java 应用程序执行期间,在对同一对象多次调用 hashCode 方法时,必须一致地返回相同的整数
两个对象不相等,那么对这两个对象中的任一对象上调用 hashCode 方法不 要求一定生成不同的整数结果