目录
单列集合
一次添加一个数据 Collection
List系列集合：添加的元素是有序（存数据和取数据的顺序）、可重复、有索引
Set系列集合：添加的元素是无序（存数据和取数据的顺序）、不重复、无索引
Collection是单列集合的祖宗父接口，功能是全部单列集合都可以继承使用
add、clear、remove、contains（是否包含对象）、isEmpty、size
package Chapter07;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo1 {
public static void main(String[] args) {
// 接口对象，不能直接创建对象 创建其实现类的对象
Collection<String> coll = new ArrayList<String>();
//1. add 返回boolean List系列 -> true Set系列 -> 元素存在 ？ false : true
coll.add("aaa");
coll.add("bbb");
coll.add("ccc");
System.out.println(coll); // [aaa, bbb, ccc]
//2. clear
coll.clear(); // []
//3. remove 删除对象 存在 ？ true ： false
System.out.println(coll.remove("aaa"));
System.out.println(coll); // [bbb, ccc]
//4.contains 底层依赖 equals方法 自定义对象，Javabean需要重写方法
System.out.println(coll.contains("bbb")); // true
System.out.println(coll); // [bbb, ccc]
//5.isEmpty
System.out.println(coll.isEmpty()); // false
System.out.println(coll); // [bbb, ccc]
//6.size
System.out.println(coll); // [bbb, ccc]
System.out.println(coll.size()); // 2
}
}
遍历集合对象
迭代器（删除元素时候使用）、增强for、lambda
package Chapter07;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.function.Consumer;
public class CollectionDemo2 {
public static void main(String[] args) {
// 接口对象，不能直接创建对象 创建其实现类的对象
Collection<String> coll = new ArrayList<String>();
coll.add("aaa");
coll.add("bbb");
coll.add("ccc");
System.out.println(coll); // [aaa, bbb, ccc]
//1.迭代器遍历 1)迭代器遍历时，不能使用集合的方法添加或删除 使用迭代器中的remove删除 2) 迭代器指针不会复位
Iterator<String> iterator = coll.iterator();
while (iterator.hasNext()) {
String str = iterator.next();
System.out.println(str);
}
//2.增强 for 遍历 第三方变量
for (String str : coll) {
System.out.println(str);
}
//3.lambda表达式遍历
coll.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
// lambda表达式
coll.forEach(s -> System.out.println(s));
}
}
数据结构
栈、队列
二叉树 -> 查找二叉树 -> 平衡二叉树
红黑树
添加节点规则
Set系列的集合
HashSet：无序，不重复，无索引
-
HashSet 集合底层采取哈希表存储结构
-
哈希表组成------------ jdk8- 数组+链表 jdk8+ 数组+链表+红黑树
-
底层原理 1）.创建默认长度为16，加载因子（HashSet的扩容时机）为0.75 的数组
2）.int index = （数组长度 - 1）* 哈希值 算出索引值
3）.如果算出的位置已经有元素，调用equalsf方法比较属性值，如果属性值一样不存入数据，如 果不一样，形成链表（8-之前，新元素存入数组，老元素挂在新元素下，8+之后，老元素存 入数组，新元素挂在老元素下）
-
jdk8+以后 当链表的长度超过8且数组长度>=64时，会转换为红黑树
-
如果集合存储的是自定义对象，必须重写hashCode和equals方法 alt+insert String和Integer不需要重写
LinkedHashSet：有序，不重复，无索引
-
数据的储存和取出顺序一样
-
底层数据结构是哈希表，但是每个元素又多了一个双链表机制记录存储顺序，
-
第一个元素的内部会记录第二个元素的地址值，第二个元素的内部会记录第一个元素的地址值
-
在遍历时，遍历的是双向链表
TreeSet：可排序，不重复，无索引
按照元素的默认规则，从小到大排序 Integer，Double 从小到大 字符串，字符从 ASCII （字典）码比较升序
TreeSet集合底层基于红黑树的数据结构实现排序，不需要重写hashCode和equals方法
两种比较方式：
1.默认比较规则/自然排序 Javabean类实现Comparable接口指定比较规则
2.比较器排序，创建TreeSet对象时候，传递比较器Comparator指定规则
默认使用第一种，第一种不能满足要求，使用第二种
使用场景
集合中，元素可重复 ArrayList
集合中，增删操作明显多于查询操作，使用LinkedList
集合中，元素去重 HashSet
集合中，元素去重，而且保持存取顺序 LinkedHashSet
集合中，元素进行排序，使用TreeSet集合
双列集合
一次添加两列数据
一次存储一对数据，分别为键和值
键不能重复，值可以重复
键和值是一一对应的，每一个键只能找到自己对应的值
键+值这个整体 称之为键值对，键值对象
map集合的遍历
一、键找值
package Chapter08;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;
public class MapDemo01 {
public static void main(String[] args) {
Map<String,String> map = new HashMap<>();
map.put("A","a");
map.put("B","b");
map.put("C","c");
Set<String> keySet = map.keySet();
for (String string : keySet) {
String s = map.get(string);
System.out.println(string + "=" + s);
}
keySet.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
String value = map.get(s);
System.out.println(s + " = " + value);
}
});
Iterator<String> iterator = keySet.iterator();
while(iterator.hasNext()){
String next = iterator.next();
String value = map.get(next);
System.out.println(next + " = " + value);
}
}
}
二、键值对
package Chapter08;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;
public class MapDemo02 {
public static void main(String[] args) {
Map<String,String> map = new HashMap<>();
map.put("A","a");
map.put("B","b");
map.put("C","c");
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> entry : entries) {
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key + "=" +value);
}
entries.forEach(new Consumer<Map.Entry<String, String>>() {
@Override
public void accept(Map.Entry<String, String> stringStringEntry) {
String key = stringStringEntry.getKey();
String value = stringStringEntry.getValue();
System.out.println(key+"="+value);
}
});
Iterator<Map.Entry<String, String>> iterator = entries.iterator();
while (iterator.hasNext()){
Map.Entry<String, String> next = iterator.next();
String key = next.getKey();
String value = next.getValue();
System.out.println(key + " = " + value);
}
}
}
三、lambda表达式
package Chapter08;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
public class MapDemo03 {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("A", "a");
map.put("B", "b");
map.put("C", "c");
map.forEach(new BiConsumer<String, String>() {
@Override
public void accept(String s, String s2) {
System.out.println(s + " = " + s2);
}
});
map.forEach((key,value)-> System.out.println(key + " = " + value));
}
}
HashMap：对于键 无序、不重复、无索引
HashMap和HashSet底层相同，都是哈希表结结构
利用hashCode和equals方法保证键的唯一
如果键的位置存储的是自定义对象，需重写hashCode和equals方法
如果值的位置存储的是自定义对象，不需重写hashCode和equals方法
LinkedHashMap：对于键 有序、不重复、无索引
这里的有序是指保证存入和取出的顺序一致
与HashMap底层相同，都是哈希表结结构，只是每个键值对元素多一个双链表机制的记录存储的顺序
TreeMap：对于键，不重复，无索引，可排序
TreeMap和TreeSet的底层原理相同，都是红黑树结构
默认按照键的从小到大的顺序排列，也可以自定义规则
1.实现Comparable接口
2.创建集合时传递Comparator比较器对象
965
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
