一.集合框架
1.单例集合的体系结构
List接口：
1.有序的集合。
2.允许存储重复的元素。
有索引，可以使用普通for循环。
ArrayList：底层是数组实现的，查询快 增删慢。
LinkedList：底层是链表实现的，查询慢 增删快。
Set接口：
1.不允许存储重复的元素。
2.没有索引，不能使用for循环遍历。
HashSet：底层是哈希表+（红黑树）实现的，无索引，不能存储重复元素，存取无序。
LinkedHashSet：底层是哈希表+链表实现的，无索引，不能存储重复元素，可以保证存储顺序。
TreeSet：底层是二叉树实现的，一般用于排序。
二.ArrayList集合
1.
数组的长度是不可以改变的。ArrayList集合的长度是可以改变的。
对于ArrayList来说，有一个尖括号<E>代表泛型。
泛型：也就是装载集合中的所有元素，全都是统一的类型。
注意，泛型只能是引用类型，不能是基本类型。
//从jdk1.7开始，右侧尖括号可以不写类型，但是<>本身还是要写的。
ArrayList<String> list = new ArrayList<>();
System.out.println(list);//[]
//向集合中添加一些数据，使用add（）方法。
list.add("李三");
System.out.println(list);
list.add("张武");
list.add("王六");
list.add("李四");
System.out.println(list);
// list.add(100);//错误写法，因为创建的时候尖括号已经说明了是字符串，添加进去的元素必修是字符串。
2.ArrayList常用方法
public boolean add(E e); : 向集合中添加元素，参数的类型和泛型一致。对于ArrayList来说 add（） 添加一定会成功。
public E get(int index); :从集合当中获取元素，参数是索引编号，返回值是对应的位置的元素。
public E remove(int index); :从集合当中删除元素，参数是索引编号，返回值是被删掉的元素。
public int size(); : 获取集合的长度，返回值是集合中包含的元素个数。
ArrayList<String> list = new ArrayList<>();
System.out.println(list);
//add()
list.add("张三");
list.add("李四");
boolean success = list.add("王五");
System.out.println(list);
System.out.println("添加的动作是否成功："+success);
//set（） 方法用于替换动态数组中指定索引的元素
list.set(1,"囡囡");
System.out.println(list);
//get（） 索引从0开始
String name = list.get(0);
System.out.println(name);
//remove
String remove = list.remove(2);
System.out.println("被删除的元素为："+remove);
System.out.println(list);
//size()
int size = list.size();
System.out.println("集合的长度为："+size);
3.总结
1.arrayList由于本质是数组，所以它在数据的查询方面会很快，而在插入删除这些方面，性能下降很多，有移动很多数据才能达到应有的效果。 2.arrayList可以存放null。 3.如果希望向ArrayList集合中存储基本数据类型 要使用对应的包装类。
三.Collection集合
1.Collection是所有单列集合的父接口，因此在Collection中定义了单列集合（List和Set）一些通用的方法，用于操作所有的单列集合。方法如下：
boolean add(E e); 向集合中添加元素。boolean remove(E e); 删除集合中的某个元素。
void clear(); 清空集合中的所有元素。
boolean contains(E e); 判断集合中是否包含某个元素。
boolean isEmpty(); 判断集合是否为空。
int size(); 获取集合的长度。
Object[] toArray(); 将集合转成一个数组。
//创建集合
Collection<String> list = new ArrayList<>();
//boolean add(E e); 向集合中添加元素。
list.add("Hello");
list.add("World");
list.add("heima");
list.add("java");
System.out.println(list); //[Hello, World, heima, java]
//boolean contains(E e); 判断集合中是否包含某个元素。
boolean result1 = list.contains("java");
System.out.println(result1);//true
//boolean remove(E e); 删除集合中的某个元素。
boolean result = list.remove("Hello");
System.out.println(result); //true
System.out.println(list); //[World, heima, java]
//void clear(); 清空集合中的所有元素。
list.clear();
System.out.println(list); //[]
//boolean isEmpty(); 判断集合是否为空。
boolean empty = list.isEmpty();
System.out.println(empty); //true
//int size(); 获取集合的长度。
int size = list.size();
System.out.println(size); // 0
//Object[] toArray(); 将集合转成一个数组
list.add("AAA");
list.add("bbb");
list.add("CCC");
Object[] array = list.toArray();
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
四.Iterator迭代器
1.概念：即Collection集合元素通用的获取方式，在去元素之前先判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出来
一直把集合中的所有元素都取出来，这种取出方式的专业术语叫做迭代。
java.util.Iterator接口：迭代器（对集合进行遍历）常用方法：
boolean hasNext() 如果迭代具有更多元素，则返回 true 。
判断集合中还有没有下一个元素，有就返回true，没有就返回false
E next() 返回迭代中的下一个元素。
Iterator迭代器，是一个接口，无法直接使用，需要使用Iterator接口的实现类对象，获取实现类的方式比较特殊.
Collection接口中有一个方法，叫iterator（）这个方法返回的是迭代器的实现类对象
Iterator<E> iterator()； 返回此集合中元素的迭代器。
迭代器的使用步骤（重点）
1.使用集合中的方法iterator（）获取迭代器的实现类对象，使用Iterator接口接收（多态）
2.使用Iterator接口中的hasNext（）方法判断还有没有下一个元素。
3.使用Iterator接口中的next（）方法取出集合中的下一个元素。
Collection<String> coll = new ArrayList<>();
coll.add("AAA");
coll.add("BBB");
coll.add("CCC");
coll.add("DDD");
coll.add("EEE");
coll.add("FFF");
//1.使用集合中的方法iterator（）获取迭代器的实现类对象，使用Iterator接口接收（多态）
//注意：迭代器是有泛型的，集合是什么泛型，迭代器就是什么泛型。
Iterator<String> iterator = coll.iterator();//迭代器的实现类对象把指针（索引）指向集合的-1索引
while (iterator.hasNext()){
String s = iterator.next();
System.out.println(s);
}
五.泛型
1.创建集合对象使用泛型
好处：
1.避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型。
2.把运行期异常提升到了编译期。
弊端：
泛型是什么类型，只能存储什么类型。
2.创建集合对象不使用泛型
好处：
默认是Object类型，可以存储任何数据。
弊端：
不安全，会引发异常。
六.List集合
List接口的特点：
1.有序的集合。
2.有索引，包含一些带索引的方法。
3.允许存储重复的元素。
List接口带有索引的方法（特有）：
public void add(int index , E element) 将指定的元素插入此列表中的指定位置
public E get(int index) 返回此列表中指定位置的元素。
public E remove(int index) 删除该列表中指定位置的元素。
public E set(int index, E element) 用指定的元素替换此列表中指定位置的元素。
//创建一个集合,多态.
List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("a");
System.out.println(list);//[a, b, c, d, a]
//public void add(int index , E element) 将指定的元素插入此列表中的指定位置
list.add(2,"kuangshenshuo");//[a, b, kuangshenshuo, c, d, a]
System.out.println(list);
//public E remove(int index) 删除该列表中指定位置的元素。
String remove = list.remove(2);
System.out.println("被删除的元素为："+remove);//kuangshenshuo
System.out.println(list);//[a, b, c, d, a]
//public E get(int index) 返回此列表中指定位置的元素。
String s = list.get(3);
System.out.println("返回集合中索引为3的元素是："+s);
System.out.println(list);
//public E set(int index, E element) 用指定的元素替换此列表中指定位置的元素。
String s1 = list.set(4, "替换的元素");
System.out.println("被替换的元素为："+s1);//被替换的元素为：a
System.out.println(list);//[a, b, c, d, 替换的元素]
七.LinkedList集合
LinkedList集合的特点：1.底层是链表结构：查询慢，增删快。
2.里面包含了大量的操作首尾元素的方法。
注意，使用LinkedList特有的方法时，不能使用多态。
void addFirst(E e) 在该列表开头插入指定的元素。
void addLast(E e) 将指定的元素追加到此列表的末尾。
void push(E e) 将元素推送到由此列表表示的堆栈上。
E getFirst() 返回此列表中的第一个元素。
E getLast() 返回此列表中的最后一个元素。
E removeFirst() 从此列表中删除并返回第一个元素。
E removeLast() 从此列表中删除并返回最后一个元素。
E pop() 从此列表表示的堆栈中弹出一个元素。
LinkedList<String> linked = new LinkedList<>();
linked.add("a");
linked.add("b");
linked.add("c");
linked.add("d");
System.out.println(linked);//[a, b, c, d]
//void addFirst(E e) 在该列表开头插入指定的元素。
linked.addFirst("WWW");
System.out.println(linked);//[WWW, a, b, c, d]
//void addLast(E e) 将指定的元素追加到此列表的末尾。
linked.addLast("kuangshenshuo");
System.out.println(linked);//[WWW, a, b, c, d, kuangshenshuo]
//void push(E e) 将元素推送到由此列表表示的堆栈上。
linked.push("ABCDE");
System.out.println(linked);//[ABCDE, WWW, a, b, c, d, kuangshenshuo]
//linked.clear();
if (!linked.isEmpty()){
// E getFirst() 返回此列表中的第一个元素。
String first = linked.getFirst();
System.out.println(first);//ABCDE
//E getLast() 返回此列表中的最后一个元素。
String last = linked.getLast();
System.out.println(last);//kuangshenshuo
}
//E removeFirst() 从此列表中删除并返回第一个元素。
//E removeLast() 从此列表中删除并返回最后一个元素。
//E pop() 从此列表表示的堆栈中弹出一个元素。
String s = linked.removeFirst();
System.out.println("被移除的第一个元素是："+s);//被移除的第一个元素是：ABCDE
String s1 = linked.removeLast();
System.out.println("被移除的最后一个元素是："+s1);//被移除的最后一个元素是：kuangshenshuo
System.out.println(linked);//[WWW, a, b, c, d]
String pop = linked.pop();
System.out.println(pop);//WWW
System.out.println(linked);//[a, b, c, d]
八.Set集合
java.util.Set接口 extends Collection接口Set集合接口的特点：
1.不允许存储重复的元素。
2.没有索引，不能使用普通for循环遍历集合。
public static void main(String[] args) {
Set<Integer> set = new HashSet<>();
set.add(1);
set.add(2);
set.add(3);
set.add(4);
//使用迭代器遍历
Iterator<Integer> iterator = set.iterator();
while (iterator.hasNext()){
Integer i = iterator.next();
System.out.println(i);
}
//使用增强for遍历集合
for (int i:
set) {
System.out.println(i);
}
}
java.util.HashSet集合 implements Set接口
HashSet特点：
1.不允许存储重复的元素。
2.没有索引，不能使用普通for循环遍历集合。
3.是一个无序的集合。
4.底层是哈希表结构，查询速度非常快。 Set集合保证存储的元素唯一：
存储的元素（String，Integer.... Student,Person...）必须重写HashCode方法和equals方法。
九.LinkedHashSet集合
java.util.LinkedHashSet集合 extends HashSet集合LinkedHashSet集合的特点：
底层是一个哈希表（数组/链表+红黑树）+链表 ，多了一条链表保证元素有序。
public static void main(String[] args) {
HashSet<String> set = new HashSet<>();
set.add("abc");
set.add("www");
set.add("it");
set.add("heima");
set.add("www");
System.out.println(set);//[abc, www, heima, it]
LinkedHashSet<String> linked = new LinkedHashSet<>();
linked.add("abc");
linked.add("www");
linked.add("it");
linked.add("heima");
linked.add("www");
System.out.println(linked);//[abc, www, it, heima]
}
十.Map集合
java.util.Map<k,v> 接口Map集合的特点：
1.Map集合是一个双列集合，一个元素包含俩个值。（一个key，一个value）。
2.Map集合中的元素，key和value的数据类型可以相同，也可以不同。
3.Map集合中的元素，key是不允许重复的，value是可以重复的。
4.Map集合中的元素，key和value是一一对应的。
java.util.HashMap<k,v> 集合 implements Map<k,v>接口
HashMap集合的特点：
1.HashMap底层是哈希表，查询速度特别快。
2.HashMap是一个无序的集合。
java.util.LinkedHashMap<k,v> extend HashMap<k,v>集合
LinkedHashMap集合的特点：
1.LinkedHashMap集合的底层是哈希表+链表（保证迭代顺序）。
2.LinkedHashMap集合是一个有序的集合。
1.Map接口中的常用方法
/*
public V put(K key, V value) 将指定的值与此映射中的指定键相关联。
存储键值对的时候 key不重复，返回值是null。
存储键值对的时候 key重复，会使用新的value值替换map中重复key对应的的value，返回被替换的value值。
*/
public static void show01(){
//创建集合
Map<String, String> map = new HashMap<>();
String put = map.put("1", "2");
System.out.println(put);//null
System.out.println(map);//{1=2}
String put1 = map.put("1", "3");
System.out.println(put1);//2
System.out.println(map);//{1=3}
map.put("100","200");
map.put("1000","2000");
map.put("10000","20000");
System.out.println(map);
}
/*
public V remove(Object key) 从该地图中删除指定键的映射（如果存在）,返回被删除的value值。
key存在，返回被删除的value值。
key不存在，返回null。
*/
public static void show02(){
Map<Integer, String> map = new HashMap<>();
map.put(1,"张三");
map.put(2,"李四");
map.put(3,"王五");
System.out.println(map);//{1=张三, 2=李四, 3=王五}
String v1 = map.remove(2);
System.out.println("被删除的元素的值："+v1);//被删除的元素的值：李四
System.out.println(map);//{1=张三, 3=王五}
String v2 = map.remove("4");
System.out.println("被删除的元素的值："+v2);//被删除的元素的值：null
}
/*
public V get(Object key) 返回指定键映射到的值，如果此映射不包含键的映射，则返回 null 。
*/
private static void show03() {
Map<Integer, String> map = new HashMap<>();
map.put(1,"张三");
map.put(2,"李四");
map.put(3,"王五");
System.out.println(map);//{1=张三, 2=李四, 3=王五}
String s = map.get(2);
System.out.println("键为2所对应的值为："+s);//键为2所对应的值为：李四
String s1 = map.get(4);
System.out.println("键为4所对应的值为："+s1);//键为4所对应的值为：null
}
/*
boolean containsKey(Object key) 如果此映射包含指定键的映射，则返回 true 。
*/
private static void show04() {
Map<Integer, String> map = new HashMap<>();
map.put(1,"张三");
map.put(2,"李四");
map.put(3,"王五");
boolean b = map.containsKey(1);
System.out.println(b);//true
}
2.Map集合的第一种遍历方式：通过键找值
Map集合中的方法：
Set<K> keySet() 返回此地图中包含的键的Set视图 。
实现步骤：
1.使用Map集合中的方法keySet() ，把Map集合中的key取出来，存储到一个Set集合中。
2.遍历Set集合，获取每一个元素key。
3.通过Map集合中的get()方法通过每一个key找到对应的value。
Map<String,Integer> map = new HashMap<>();
map.put("张三",1);
map.put("李四",2);
map.put("王五",3);
Set<String> set = map.keySet();
//使用迭代器来遍历set集合
Iterator<String> it = set.iterator();
while (it.hasNext()){
String key = it.next();
Integer value = map.get(key);
System.out.println(key+"="+value);
}
System.out.println("-----------------");
//使用增强for来遍历set集合
for (String key:set){
Integer value = map.get(key);
System.out.println(key+"="+value);
}
3.Map集合遍历的第二种方法：使用Entry对象遍历。
在Map接口中有一个内部接口Entry，作用：当Map集合一创建，那么就会在Map集合中创建一个Entry对象，
用来记录键与值，（键与值的映射关系）。
Map集合中的方法：
Set<Map.Entry<K,V>> entrySet() 返回此地图中包含的映射的Set视图。
实现步骤：
1.使用Map集合中的方法，entrySet() ，把Map集合中的多个Entry对象取出来。
2.遍历Set集合，获取每一个Entry对象。
3.使用Entry对象中的方法getKey()和 getValue()获取键和值。
Map<Integer,String> map = new HashMap<>();
map.put(1,"张三");
map.put(2,"李四");
map.put(3,"王五");
Set<Map.Entry<Integer, String>> entry = map.entrySet();
//使用迭代器遍历
Iterator<Map.Entry<Integer, String>> it = entry.iterator();
while (it.hasNext()){
Map.Entry<Integer, String> obj = it.next();
System.out.println(obj.getKey()+"="+obj.getValue());
}
System.out.println("==============");
//使用增强for遍历
for (Map.Entry<Integer,String> obj:entry
) {
System.out.println(obj.getKey()+"="+obj.getValue());
}
4.HashMap集合存储自定义类型的键值。
Map集合保证key是唯一的：作为key的元素，必须重写HashCode（）方法equals（）方法。
/*
HashMap集合存储自定义类型的键值。
key:String类型
String类型重写HashCode（）方法equals（）方法，保证了key唯一。
value：Student类型
value值可以重复，（同名同年龄的人视为同一个人）。
*/
private static void show01() {
//创建HashMap集合
HashMap<String,Student> map = new HashMap<>();
//往集合中添加元素
map.put("北京",new Student("张三",18));
map.put("上海",new Student("李四",19));
map.put("广州",new Student("王五",20));
map.put("北京",new Student("赵六",21));
//遍历集合
Set<String> set = map.keySet();
for (String key: set
) {
System.out.println(key+"-->"+map.get(key));
}
System.out.println("--------------");
Set<Map.Entry<String, Student>> entrySet = map.entrySet();
for (Map.Entry<String,Student> obj: entrySet
) {
System.out.println(obj.getKey()+"-->"+obj.getValue());
}
}
/*
HashMap集合存储自定义类型的键值。
key:Student类型
Student类型重写HashCode（）方法equals（）方法，保证了key唯一。
value：String类型
可以重复
*/
private static void show02(){
//创建HashMap集合
HashMap<Student,String> map = new HashMap<>();
//往集合中添加元素
map.put(new Student("张三",18),"法国");
map.put(new Student("李四",19),"法国");
map.put(new Student("王五",20),"法国");
map.put(new Student("张三",18),"英国国");
//遍历集合
Set<Student> set = map.keySet();
for (Student key:set
) {
System.out.println(key+"-->"+map.get(key));
}
}
5.LinkedHashMap
java.util.LinkedHashMap<k,v> extends HashMap<k,v>Map接口的哈希表和链表的实现，具有可预知的迭代顺序。
底层原理：
哈希表+链表（有序的）
HashMap<String, String> map = new HashMap<>();
map.put("a","b");
map.put("c","b");
map.put("d","b");
map.put("a","c");
System.out.println(map);//{a=c, c=b, d=b} 无序的 ，key不允许重复。
System.out.println("============");
LinkedHashMap<String, String> lhp = new LinkedHashMap<>();
lhp.put("a","b");
lhp.put("c","b");
lhp.put("d","b");
lhp.put("a","c");
System.out.println(lhp);//{a=c, c=b, d=b} 有序的，key不允许重复
标签：map,list,System,println,集合,out From： https://www.cnblogs.com/1997Li/p/17997046