集合
引入:
集合和数组的区别
1)长度区别
数组的长度是固定的
集合的长度是可变的
2)存储数据类型的区别
数组:可以存储基本数据类型,也可以存储引用数据类型
集合:只能存储引用数据类型
3)存储元素的区别
数组:只能存储同一种类型的元素
集合:可以存储任意类型的元素
1.Collection集合(单列集合)
Collection的特点:是所有单列集合的父接口
Collection集合的常用方法
boolean add(E e);//向集合中添加元素
boolean remove(E e);//删除集合中的某个元素
void clear();//清空集合中所有元素
boolean contains(E e);//判断集合中是否包含某个元素
Boolean isEmpty();//判断集合是否为空
int size();//获取集合的长度
Object[] toArray();//将集合转成一个数组
Iterator iterator();//迭代器
注意：其子类都可以使用以上方法
Collection集合的高级功能
Boolean addAll(Collection c)
//添加一个集合中的所有元素
Boolean removeAll(Collection c)
//问题:是删除一个算删除还是删除所有算删除?
//只要集合中有一个元素被包含，将这个元素从c1删除掉,则返回true!
Boolean containsAll(Collection c)
//问题:包含一个算包含还是包含所有算包含?
//包含所有元素才算包含,返回true
Boolean retainAll(Collection c)
//问题：boolean的真实含义是什么？
//取交集，有变化时true，没变化就返回flase
/* A.retainlAll(B):A集合的元素是否发生变化!
A集合对B集合取交集,将交集的元素保存到A集合,boolean表达的是A集合是否发生变化,如果A集合没有变化的,返回结果false;如果A集合有变化,则返回true!
*/
Collection的遍历方法
1）Collection集合的方法Object[] toArray ();
//创建Collection集合
Collection c = new ArrayList() ; //接口多态!
//添加元素....
//将集合转换成对象数组
Object[] objs = c.toArray() ;
//使用for循环遍历数组
for(int x = 0 ; x < objs.length ; x ++) {
//通过get方法学生姓名和年龄
Student s = (Student)objs[x] ;
System.out.println(s.getName()+"---"+s.getAge());
}
2）Collection集合的迭代器Iterator Iterator();
//创建Collection集合
Collection c = new ArrayList() ; //接口多态!
//添加元素....
//使用迭代器遍历集合
Iterator it = c.iterator() ;
//hasNext()方法判断是否存在下一个元素
while(it.hasNext()) {
//next()方法获取下一个元素
Student s = (Student)it.next() ;
System.out.println(s.getName()+"----"+s.getAge());
}
1.1.List集合
有序集合,可以存储重复元素
有序性:取出的元素和存储时的顺序一致
1.List集合的特有功能
add(int index , Object obj )://添加元素
remove (int index)://删除角标对应的元素
get()://获取指定位置的元素
set(int index ,Object obj ):// 把制定索引位置的元素修改为指定的值
int size()://获取指定位置处的元素
int indexOf(Object o)://返回指定元素自己和中第一次出现的索引
ListIterator listIterator() ://列表迭代器
List subList(int fromIndex ,int toIndex)://截取集合
2.List的五种遍历方法
1）Collection集合的方法Object[] toArray ();
//创建List集合
List<String> list = new ArrayList<String>() ;
//添加元素....
//将集合转换成对象数组
Object[] objs = list.toArray() ;
//使用for循环遍历数组
for(int x = 0 ; x < objs.length ; x ++) {
//通过get方法学生姓名和年龄
Student s = (Student)objs[x] ;
System.out.println(s.getName()+"---"+s.getAge());
}
2）Collection集合的迭代器Iterator Iterator();
//创建List集合
List<String> list = new ArrayList<String>() ;
//添加元素....
//使用迭代器遍历集合
Iterator it = list.iterator() ;
//hasNext()方法判断是否存在下一个元素
while(it.hasNext()) {
//next()方法获取下一个元素
Student s = (Student)it.next() ;
System.out.println(s.getName()+"----"+s.getAge());
}
3）size() _Object get (int index):普通for循环
//创建List集合
List<String> list = new ArrayList<String>() ;
//添加元素....
//使用size()+Object get(int index):普通for循环
for(int x = 0 ; x < list.size(); x ++) {
Student s = list.get(x) ;
System.out.println(s.getName()+"---"+s.getAge());
}
4）List集合中的迭代器 ListIterator listIterator
//创建List集合
List<String> list = new ArrayList<String>() ;
//添加元素....
//获取列表迭代器
ListIterator<Student> lit = list.listIterator() ;
while(lit.hasNext()) {
Student s = lit.next() ;
System.out.println(s.getName()+"---"+s.getAge());
}
5）增强for循环
//创建List集合
List<String> list = new ArrayList<String>() ;
//添加元素....
//增强for循环遍历
for(Student s : list) {
System.out.println(s.getName()+"---"+s.getAge());
}
注意:
使用迭代器遍历时,使用集合的方法添加元素会出错
原因:迭代器不能识别集合方法添加的元素
解决方法:
要么使用迭代器遍历元素,使用迭代器添加元素!要么集合遍历遍历元素,使用集合添加元素
3 元素去重
1.重新定义一个List集合将所有不重复的元素添加到其中
//创建List集合 List<String> list = new ArrayList<String>() ; //添加元素.... //遍历list集合,获取到每一个元素 List<String> list2 = new ArrayList<String>() ; Iterator<Student> it = list.iterator() ; while(it.hasNext()) { Student s = it.next() ; //使用集合判断是否存在这个元素s if(!list2.contains(s)) { //当前元素在第二个集合中不包含,不重复,添加到集合中 //将这个元素存储新集合中 list2.add(s) ; }2.利用选择排序的思想,将相同的元素保留一个出现的将其他的相同元素删除
//创建List集合 List<String> list = new ArrayList<String>() ; //添加元素.... for(int x = 0 ; x < list.size()-1 ; x ++) { for(int y = x +1 ; y < list.size() ; y ++) { //如果后面的和前面的元素相等,删除后面的元素 if(list.get(y).equals(list.get(x))) { list.remove(y) ; y -- ; } } }
3. List 集合的三个子实现类的特点
3.1 LinkedList
底层数据结构:链接列表实现(链表)
线程角度:线程不安全-----不同步---->执行效率高
特有功能:可以模拟栈结构的:先进后出!
特有功能
public void addFirst(Object e)://将该元素添加到列表的开头!
public void addLast(Object e)://将该元素添加到列表的末尾!
public Object removeFirst()://删除列表第一个
public Object removeLast()://删除列表最后一个
public Object getFirst()://获取第一个元素
public Object getLast() ://获取最后一个元素
3.2 ArrayList
底层数据结构是可变数组结构: 查询快,增删慢
ArrayList()---->通过初试容量大小判断是否构造一个新Object[] 数组对象
线程角度:线程不安全的类----不同步的----执行效率高!
单线程程序中,通常没有告诉使用什么集合的时候,优先采用的是ArrayList集合!
3.3 Vector
底层数据是数组结构(对象数组):查询快,增删慢
线程角度:线程安全的类 ---->同步的----->执行效率低
多线程程序中要考虑安全问题,使用Vector
特有功能
public void add(int index, E element)://插入元素
public Enumeration<Object> elements();//相当于迭代器,返回此向量的组件的枚举。
boolean hasMoreElements()://判断是否有下一个元素
Object nextElement()://获取一个元素
public Object elementAt(int index)://通过角标获取指定的元素
public E elementAt(int index);//获取指定索引值的元素
1.2.set集合
Set存储和取出顺序不一致
Set集合中的元素是唯一的
Set不能根据索引获取元素
1.2.1HashSet集合
HashSet底层数据结构采用哈希表实现，元素无序且唯一，线程不安全，效率高，可以存储null元素，元素的唯一性是靠所存储元素类型是否重写hashCode()和equals()方法来保证的，如果没有重写这两个方法，则无法保证元素的唯一性。
//创建一个HashSet集合
Set<String> set = new HashSet<String>() ;
//添加元素...
//增强for遍历
for(Student s :set) {
System.out.println(s.getName()+"---"+s.getAge());
}
1.2.3TreeSet集合
TreeSet底层数据结构采用二叉树来实现，元素唯一且已经排好序；唯一性同样需要重写hashCode和equals()方法，二叉树结构保证了元素的有序性。根据构造方法不同，分为自然排序（无参构造）和比较器排序（有参构造）。需要实现接口Comparable ，并重写compareTo方法
自然排序
//无参构造方法:自然排序
//默认的是自然排序
TreeSet<T> ts = new TreeSet<T>();
//如果是自定义对象那么该类必须实现Comparable接口,并重写comparaTo()方法
//添加元素...
//遍历
比较器排序
//方式1:直接给了创建了接口子实现类
//Comparator的子实现类
public class MyComparator implements Comparator<Student> {
@Override
public int compare(Object o1,Object o2) {
//比较条件
}
}
//方式2:形参参数如果接口:传入接口的匿名内部类(本质:接口的子实现类)
TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
//比较条件
}
}) ;
1.3.Collections类
特有方法
public static <T> int binarySearch(List<?> list,T key)://针对集合的二分查询方法:查询key在集合中出现的索引值
public static <T> T max(Collection<? extends T> list)://获取集合中最大值
public static <T> T min(Collection<? extends T> list)://获取集合中最小值
public static <T> void sort(List<T> list)://针对List集合进行排序:升序排序
public static <T> void sort(List<T> list,Comparator<T> com)://比较器排序
public static void shuffle(List<?> list)://针对List集合的元素进行随机置换
2.Map集合
Map集合的功能
V put(K key, V value) ://添加一个键值对元素
V remove(Object key)://刪除指定的键,返回的是跟键关联的值,如果没有映射关系,则返回null
void clear()://删除全部的键以及值
boolean containsKey(Object key)://是否包含指定的键
boolean containsValue(Object value)://是否包含指定的值
boolean isEmpty()://判断Map集合是否为空
V replace(K key, V value);//替换指定key对应的value值
boolean replace(K key, V oldValue, V newValue);//当指定key的对应的value为指定值时，替换该值为新值
Map的遍历方法
方式1
方式1:遍历(推荐的方式:Map常用的方式)
Set keySet():获取所有的键的集合
V get(Object key):通过键获取对应的值
//创建Map集合对象
Map<String,String> map = new HashMap<String,String>() ;
//添加键值对元素
//遍历Map集合
//方式1:Set<K> keySet():获取所有的键的集合
Set<String> set = map.keySet() ;
//通过键在值
for(String key : set) {
//通过键获取值
//V get(Object key):通过键获取对应的值
String value = map.get(key) ;
System.out.println(key+"="+value);
}
方式2
Set<Map.Entry<K,V>> entrySet():获取当前Map集合中所有的键值对对象
K getKey() :通过键值对对象获取键
V getValue():通过键值对对象获取值
//获取所有的键值对对象
Set<Map.Entry<String, String>> entrySet = map.entrySet() ;
//遍历
for(Map.Entry<String, String> entry :entrySet) {
//获取到了所有的键值对对象:一一获取
//K getKey():通过键值对对象获取键
String key = entry.getKey() ;
//V Value():通过键值对对象获取值
String value = entry.getValue() ;
System.out.println(key+"="+value);
}
2.1HashMap集合
2.1.1HashMap简介
1)HashMap 是一个散列表,它存储的内容是键值对映射
2)HashMap 继承与AbstractMap,实现了Map,Cloneable,java.io.Serializable接口
3)HashMap 的实现是不同步的,这意味着它不是线程安全的,它的key,value都可以为null.
4)HashMap 中的映射不是有序的
2.1.2HashMap的构造方法
HashMap();//默认构造
HashMap(int capacity);//指定"容量大小"的构造
HashMap(int capacity,float loadFactor);//指定"容量大小"和"加载因子"的构造
HashMap(Map<? extends K, ? extends V>map);//包含"子Map"的构造
2.2TreeMap集合
2.2.1简介
1)TreeMap 是一个有序的key-value集合，它是通过红黑树实现的。
2)TreeMap 继承于AbstractMap，所以它是一个Map，即一个key-value集合。
3)TreeMap 实现了NavigableMap接口，意味着它支持一系列的导航方法。比如返回有序的key集合。
4)TreeMap 实现了Cloneable接口，意味着它能被克隆。
5)TreeMap 实现了java.io.Serializable接口，意味着它支持序列化。
2.2.2TreeMap集合的排序
1)TreeMap() :创建一个空TreeMap,元素自然排序
TreeMap<Integer,String> TreeMap = new TreeMap<>();
2)TreeMap(Comparator comparator):创建一个空TreeMap,按照指定的comparator排序
TreeMap<Integer,String> TreeMap = new TreeMap(Comparator.排序方法);
2.2.3构造方法
// 默认构造函数。使用该构造函数，TreeMap中的元素按照自然排序进行排列。
TreeMap();
// 创建的TreeMap包含Map
TreeMap(Map<? extends K, ? extends V> copyFrom);
// 指定Tree的比较器
TreeMap(Comparator<? super K> comparator);
// 创建的TreeSet包含copyFrom
TreeMap(SortedMap<K, ? extends V> copyFrom);
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
