集合框架(二)
回顾
Collection、List、Set的特点
Collection：不唯一的，无序的
List：不唯一的 有序
Set：唯一的 无序的
Collection和Collections的区别？
Collection是集合的顶级接口
Collections是集合的工具类
ArrayList的常用API
存储数据：
boolean add(Object obj); 向集合后追加元素
void add(int index,Object obj); 向集合的指定位置添加元素 原有位置元素 依次后移
删除数据：
remove(int index); 根据下标来删除元素
remove(Object obj); 将指定值删除
获取集合的长度： size();
**获取集合中的元素：**get(int index);
**判断集合中是否包含指定元素：**contains(Object obj);
LinkedList的常用API
addFirst(Object obj);
addLast(Object);
removeFirst();
removeLast();
getFirst();
getLast();
ArrayList和LinkedList的区别
ArrayList 底层是数组结构，它在每一次增删时都会重新创建新的数组，所以在增删方面效率比较低。因为数组有固定的下标，所以在查询方面效率比较高。
LinkedList 底层是链表结构(数据值和指针域组成) ，在增删方面尤其是首尾增删效率比较高，但是因为没有固定的下标，所以在查询方面效率比较低。
HashSet
equals() hashcode()
集合的遍历
ArrayList：
1.for(int i = 0; i < list.size(); i++){
}
2.增强for
for(临时类型 临时的变量名 : 集合名){
}
3.迭代器
Iterator<xxx> iterator = list.iterator();
while(iterator.hasNext()){
iterator.next();
}
LinkedList：
同上！
HashSet：
1.增强for
2.迭代器
1.Map的使用
HashMap
HashTable
课程编码和课程信息对应的需求。
BD001 -> Java课程
BD002 -> UI课程
BD003 -> C#课程
Key -Value 键值对 夫妻对！
常用API
- put(Object key,Object value); 存储键值对
- get(Object key); 根据键(唯一的)获取值
- containsKey(Object key); 判断是否包含指定键
- containsValue(Object value); 判断是否包含指定值
- size(); 获取集合长度
- Set keySet(); 获取所有键集合
- Collection values(); 获取所有值的集合
- clear(); 清空所有数据
Map集合的遍历
-
使用迭代器
1.1Map集合获取所有的键集合
1.2遍历键集合(迭代器)，然后通过键获取值
-
使用增强for
2.1Map集合获取所有的键集合
2.2遍历键集合(增强for)，然后通过键获取值
-
使用键值对集合
3.1Map集合获取entrySet(键值对的Set集合)
3.2遍历entrySet将其中每一个entry取出来
3.3从entry中将键和值取出来
public static void main(String[] args) {
// 创建集合
Map<String,String> map = new HashMap<String,String>();
// 添加到集合中 存储时无序
map.put("CN", "中国");
map.put("US", "美国");
map.put("UK", "英国");
// 键必须唯一 值可以重复
// 如果给相同的key进行赋值 那么会进行覆盖(更新)
map.put("CN", "中国1");
System.out.println("---------------1--------------------");
Collection<String> values = map.values(); // 所有值的集合
for (String value : values) {
System.out.println(value);
}
System.out.println("----------------2-------------------");
Set<String> keySet = map.keySet();//所有键的集合
for (String key : keySet) {
System.out.println(key);
//根据键获取值
String value = map.get(key);
System.out.println("打印值"+value);
}
//可以用map的迭代器遍历
Iterator<String> iterator = keySet.iterator();
while(iterator.hasNext()) {
String key = iterator.next();
String value = map.get(key);
System.out.println(key +"=="+value);
}
System.out.println("---------------3--------------------");
//获取所有键值对集合
Set<Entry<String, String>> entrySet = map.entrySet();
for (Entry<String, String> entry : entrySet) {
System.out.println(entry);
String key = entry.getKey(); // 获取键
String value = entry.getValue();//获取值
System.out.println(key+" -- > "+value);
}
//可以用map的迭代器遍历
Iterator<Entry<String, String>> iterator2 = entrySet.iterator();
while(iterator.hasNext()) {
Entry<String, String> next = iterator2.next();
String key = next.getKey();
String value = next.getValue();
System.out.println(key +"=="+value);
}
}
2. 泛型的作用
包装类型
必须使用引用数据类型
public class Demo3 {
public static void main(String[] args) {
// 泛型：用来限制集合中元素的类型(获取数据后可以不用强转)
// 泛型在限定类型时，类型必须是引用数据类型
// int -> Integer
/*ArrayList<Integer> arrayList = new ArrayList<Integer>();
arrayList.add(20);*/
// double -> Double
/*ArrayList<Double> arrayList = new ArrayList<Double>();
arrayList.add(20.1);
System.out.println(arrayList);*/
// byte -> Byte
// short -> Short
// long -> Long
// float -> Float
// boolean -> Boolean
// char -> Character
// 基本数据类型是没有方法和属性(类的信息)的
Integer a = 10;
}
}
3. Collections的了解
常用API
- sort(集合); 给集合进行排序 升序
List<Integer> list=Arrays.asList(1,7,2,3,6,5);
Collections.sort(list);
System.out.println(list);//[1, 2, 3, 5, 6, 7]
- max() / min() 获取最大值 最小值
- shuffle() 打乱集合内元素
public static void main(String[] args) {
List<Integer> list=Arrays.asList(1,2,3,6,5);
Integer max = Collections.max(list);
System.out.println(max);//输出最大值6
}
