1、集合和数组
数组:
数组长度固定。数组可以存储基本数据类型,也可以存储引用类型。数组存储的数据类型是一致的。
集合:
总结:集合比数组强大,类似于包装类和基本类型的关系集合长度可变。集合只能存储引用类型。集合可以存储不同类型的对象
2、集合体系结构
|——List (接口)
|——ArrayList (类)
|——Vector (类)
|——LinkedList (类)
|——Set (接口)
|——HashSet (类)
|——TreeSet (类)
3、Collection接口中成员方法
boolean add(Object obj)
向集合中添加一个元素(常用)
boolean addAll(Collection c)
向集合中添加一个集合的元素
删除
void clear()
删除集合中的所有元素
boolean remove(Object obj)
从集合中删除指定的元素(常用)
boolean removeAll(Collection c)
从集合中删除一个指定的集合元素
判断
boolean isEmpty()
判断集合是否为空
boolean contains(Object obj)
判断集合中是否存在指定的元素(常用)
boolean containsAll(Collection c)
判断集合中是否存在指定的一个集合中的元素
遍历
Iterator iterator()
就是用来获取集合中每一个元素(常用)
长度
int size()
获取集合中的元素个数(常用)
交集
boolean retainAll(Collection c)
判断两个集合中是否有相同的元素
把集合转换成数组
Object[] toArray()
把集合转换成数组(常用)
4、List接口
void add(int index, Object obj)
在指定位置添加元素(常用)
删除
Object remove(int index)
根据指定索引删除元素,并把删除的元素返回(常用)
修改
Object set(int index, Object obj)
把指定索引位置的元素修改为指定的值,返回修改前的值(常用)
获取
int indexOf(Object o)
返回指定元素在集合中第一次出现的索引(常用)
Object get(int index)
返回指定索引位置对应的元素(常用)
ListIterator listIterator()
列表迭代器
截取
List subList(int fromIndex, int toIndex)
截取集合
5、迭代器
list.add(1);
list.add(3);
Iterator iterator = list.iterator();
while( iterator.hasNext()){
Integer next = (Integer) iterator.next();
System.out.println(next);
}
Iterator
boolean hasNext()
若被迭代的集合元素还没有被遍历,返回 true
Object next()
返回集合的下一个元素
void remove()
删除集合上一次 next()方法返回的元素。 (若集合中有多个相同的元素, 都可以删掉)
ListIterator 继承自Iterator
void add(Object obj)
将指定元素插入next()方法返回的元素后面
void set(Object obj)
用指定元素替换next()或previouse()方法返回的元素
boolean hasPrevious()
若被迭代的集合元素还没有被遍历,返回 true
Object previous()
返回集合的上一个元素
6、集合的遍历
1、迭代2、将集合转换为数组3、获取集合的长度,通过get(索引)+for遍历
7、集合体系
|——List (接口) 元素有序,可以重复
|——ArrayList (类)
|——Vector (类)
|——LinkedList (类)
|——Set (接口) 元素无序,唯一
|——HashSet (类)
|——TreeSet (类)
8、数据结构
9、List接口的三个子类的特点
底层数据结构是数组,查询快,增删慢
线程不安全,效率高。
2、Vector
底层数据结构是数组,查询快,增删慢
线程安全,效率低。
3、LinkedList
底层数据结构是链表,查询慢,增删快
线程不安全,效率高 。
10、Vector类
线程安全,效率低。
Vector
成员方法
| |
public void addElement(Object obj)
|
添加
|
public Object elementAt(int index)
|
获取
|
public Enumeration elements()
|
获取
|
public int size()
|
长度
|
11、LinkedList类
底层数据结构是链表,查询慢,增删快线程不安全,效率高 。
LinkedList 成员方法
| |
void addFirst(Object o)
|
添加
|
void addLast(Object o)
| |
Objcet getFirst()
|
获取
|
Object getLast()
| |
Object removeFirst()
|
删除
|
Object removeLast()
|
12、ArrayList类
线程不安全,效率高 。
13、泛型
}
}
14、增强for循环
15、遍历方式
1、迭代器(Set中只有iterator()方法)2、增强for3、将转换成数组
16、HashSet类
17、TreeSet类
A、对象所属的类去实现Comparable接口 重写compareTo方法 如果该方法返回0 ,则两个元素相同 | public class Person implements Comparable{ @Override public int compareTo(Object o) { return 0; } } TreeSet set = new TreeSet(); set.add(new Person()); |
B、调用TreeSet的带参构造方法,传入Comparator的子类对象
该子类对象重写compare(T o1, T o2)方法
如果返回0则两个元素相同
| public class MyComparator implements Comparator { @Override public int compare(Object o1, Object o2) { return 0; } } TreeSet set = new TreeSet(new MyComparator()); set.add(new Student); |
18、Collections类
19、Collection集合总结
Collection( 接口 )单列集合 List( 接口 )有序,不唯一 Set( 接口 )可能无序,肯定唯一 Vector( 类 ) ArrayList( 类 ) LinkecList( 类 ) HashSet(类) TreeSet(类)1、底层数据结构是数组,查询快,增删慢
2、线程安全,效率低 (只有Vector是线程安全的)1、底层数据结构是数组,查询快,增删慢
2、线程不安全,效率高1、底层数据结构是链表,增删快,查询慢
2、线程不安全,效率高1、底层数据结构是哈希表
2、通过重写 hashCode() 和 equals() 保证唯一性
3、线程不安全,效率高
(如果元素相同不操作,所以不会覆盖) 1、 底层数据结构是二叉树
2、通过判断 compareTo 或 compare 方法的返回值是否为 0 来判断是否重复
3、排序有两种方案:实现 Comparable 接口重写 compareTo 方法实现 Comparator 接口重写 compare 方法
4、线程不安全,效率高
(如果元素相同不操作,所以不会覆盖)
20、Map集合成员方法
V put(K key, V value) | 当key在集合中不存在时,添加元素;当key在集合存在时候,替换元素 |
删除功能 | |
void clear | 清除所有键值对数据 |
V remove(Object key) | 根据指定的键删除键值对 |
判断功能 | |
boolean containsKey(Object key) | 判断指定的键是否在集合中存在 |
boolean containsValue(Object value) | 判断指定的值是否在集合中存在 |
boolean isEmpty | 判断集合是否为空 |
获取功能 | |
Set<Map.Entry<K,V>> entrySet() | 键值对对象的集合 |
Object get(Object key) | 根据键获取值 |
Set<K> keySet(): | 所有键的集合 |
Collection<V> values() | 所有值的集合 |
长度 | |
int size() | 获取长度 |
|
|
21、Map集合的两种遍历方式
创建 Map集合 | // 创建集合对象 Map<String, String> map = new HashMap<String, String>();
// 创建并添加元素 map.put("杨过", "小龙女"); map.put("郭靖", "黄蓉"); map.put("梁山伯", "祝英台"); map.put("牛郎", "织女"); |
第一种 遍历方式(通过keySet()) | Set<String> keySet = map.keySet(); for(String key : keySet){ System.out.println("key:"+key+" value"+map.get(key)); } |
第二种 遍历方式(通过entrySet()) | Set<Entry<String,String>> entrySet = map.entrySet(); for(Map.Entry<String, String> entry : entrySet){ System.out.println("key"+entry.getKey()+" value"+entry.getValue()); } |
22、集合体系-总结
Collection(单列集合) | Map(双列集合) |
|--Collection(单列) |--List(有序,可重复) |--ArrayList 底层数据结构是数组,查询快,增删慢。 线程不安全,效率高。 |--Vector 底层数据结构是数组,查询快,增删慢。 线程安全,效率低。 |--LinkedList 底层数据结构是链表,查询慢,增删快。 线程不安全,效率高。 |--Set(可能无序,肯定唯一) |--HashSet 底层数据结构是哈希表。 线程不安全,效率高。 怎么保证唯一性的呢? 它依赖两个方法:hashCode()和equals() 顺序: 首先判断hashCode()值是否相同。 同:继续走equals(),看返回值 如果true:就不添加到集合。 如果false:就添加到集合。 不同:就添加到集合。 |--TreeSet 底层数据结构是二叉树。 线程不安全,效率高。 怎么保证唯一性的呢?是根据返回是否是0。 怎么保证排序的呢?两种方式 自然排序(元素具备比较性) 实现Comparable接口 比较器排序(集合具备比较性) 实现Comparator接口 | |--Map(双列 底层结构是针对键有效,跟值无关) |--HashMap 底层数据结构是哈希表。 线程不安全,效率高。允许null键和值 怎么保证唯一性的呢? 它依赖两个方法:hashCode()和equals() 顺序: 首先判断hashCode()值是否相同。 同:继续走equals(),看返回值 如果true:就不添加到集合。 如果false:就添加到集合。 不同:就添加到集合。 |--Hashtable 底层数据结构是哈希表。 线程安全,效率低。不允许null键和值 怎么保证唯一性的呢? 它依赖两个方法:hashCode()和equals() 顺序: 首先判断hashCode()值是否相同。 同:继续走equals(),看返回值 如果true:就不添加到集合。 如果false:就添加到集合。 不同:就添加到集合。 |--TreeMap 底层数据结构是二叉树。 线程不安全,效率高。 怎么保证唯一性的呢?是根据返回是否是0。 怎么保证排序的呢?两种方式 自然排序(元素具备比较性) 实现Comparable接口 比较器排序(集合具备比较性) 实现Comparator接口 |