目录
1、数组导入：
2、单列集合
List接口
1、ArrayList：数组列表
ArrayList类中的方法
2、LinkedList：链表列表
3、Vector：数组列表
4、list集合的遍历
1、for循环遍历
2、增强for循环
3、迭代器遍历
Set接口
1、HashSet
编辑
2、TreeSet
3、双列集合
map接口
1、HashMap
HashMap的底层结构：
HashMap的遍历
2、HashTable
3、TreeMap
1、数组导入：
容器---->数组：
一组数据类型相同的元素集合 创建数组时，必须给定长度，而且一旦创建长度不能变。 一旦数组装满元素，需要创建一个新的数组，将元素复制过去。
缺点： 如果我们从数组中间删除了一个元素或者添加一个元素，需要移动后面的元素。 如果数组装满了，超过了数组的最大长度，会创建新的数组将旧数组复制到新数组上。
java中为了解决数据存储单一的情况，提供了许多不同结构的集合类。让我们可以根据不同的场景进行数据存储选择。
提供了数组实现的集合,链表实现的集合,哈希结构,树结构... 让iava程序员使用起来就非常方便。
2、单列集合
单例集合指的是：一次放进去一个值（对象）。集合实现Collection接口，定义了单例集合共有的方法。
List接口
特点：List类中可以有重复元素
1、ArrayList：数组列表
底层有一个数组，可以动态扩展数组的长度，并提供一个一系列方法操作。
特点：查询快， 中间增加、删除慢。
ArrayList类中的方法
arrayList.add()--->添加 arrayList.remove()---->删除 arrayList.get()----->获取指定位置上的元素 arrayList.indexOf()----->查找给定元素第一次出现的位置 arrayList.lastIndexOf()---->从后往前查找指定元素第一次出现的位置 arrayList.set(int index,E element)---->将指定位置上的元素替换并返回原来的值arrayList.clear()----->清空 arrayList.isEmpty()----->判断是否为空 arrayList.contains()----->判断是否包含指定元素 arrayList.size()----->返回集合中元素的个数
public class Demo3 {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add("a");
arrayList.add("b");
arrayList.add("c");
arrayList.add("d");
arrayList.add("e");
System.out.println(arrayList.remove("b"));//boolean类型，根据内容删除匹配的第一个元素,删除成功返网true,否则返回false
System.out.println(arrayList.remove(1));//删除并返回指定位置的值
System.out.println(arrayList.get(1));//获取指定位置上的元素
System.out.println(arrayList.indexOf("d"));//查找第一次出现的位置
System.out.println(arrayList.lastIndexOf("d"));//从后查找，第一次出现的位置
System.out.println(arrayList.set(1, "v"));//将指定位置上的元素替换并返回原来的值
arrayList.clear();
System.out.println(arrayList.isEmpty());
System.out.println(arrayList.contains("c"));//判断是否包含指定元素
System.out.println(arrayList.size());//返回集合中元素的个数
for (int i = 0; i < arrayList.size(); i++) {
System.out.println(arrayList.get(i));
}
}
}
2、LinkedList：链表列表
底层是一个链表结构。
特点：查询慢，增加、删除快
linkedList.add("a")---->向链表末尾添加元素
linkedList.add(2, "y")---->向链表指定的位置插入元素
linkedList.get(2)----->获取指定位置上的元素
linkedList.remove("y")----->删除
linkedList.remove(1)------>删除并返回指定元素的值
linkedList.removeFirst())----->删除第一个元素并返回其值
linkedList.pop()----->出栈
linkedList.clear()------>清空
linkedList.contains()----->判断是否包含指定元素
linkedList.isEmpty()----->判断是否为空
linkedList.size()----->返回集合中元素的个数
3、Vector：数组列表
特点：相对于ArrayList是线程安全的。其他与arraylist相似。、
4、list集合的遍历
1、for循环遍历
允许操作（删除）元素的.
（注意索引的变化与元素位置的移动）
public class List1 {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("a");
arrayList.add("b");
arrayList.add("r");
System.out.println(arrayList);
/*
List 接口实现类/List集合遍历方式
1、for循环遍历，允许操作（删除）元素的.
注意索引的变化与元素位置的移动
*/
for (int i = 0; i < arrayList.size(); i++) {
if ("a".equals(arrayList.get(i))) {
arrayList.remove("a");
i--;
}
}
System.out.println(arrayList);
}
}
2、增强for循环
增强for循环遍历元素时, 不允许修改集合元素(删除,添加)
public class List2 {
/*
List接口实现类/List集合遍历
方式2:增强for循环
增强for循环遍历元素时, 不允许修改集合元素(删除,添加)
*/
public static void main(String[] args) {
ArrayList<String> arrayList=new ArrayList<>();
arrayList.add("a");
arrayList.add("b");
arrayList.add("r");
for(String s:arrayList){
//arrayList.remove("a");ConcurrentModificationException报错
System.out.println(arrayList);
}
System.out.println(arrayList);
}
}
3、迭代器遍历
迭代器只能对list接口下的实现类遍历
public class List3 {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("a");
arrayList.add("b");
arrayList.add("r");
/*
List接口实现类/List集合遍历
方式3:使用迭代器遍历
获得集合对象的选代器对象
*/
Iterator<String> it = arrayList.iterator();
while (it.hasNext()) {//判断数组是否遍历完成 0！=3，next,3==3,false结束
String s = it.next();//获取到下一个元素
if (s.equals("a")) {
it.remove();//使用迭代器对象删除元素
}
System.out.println(arrayList);
}
}
}
//迭代器2
public class List4 {
public static void main(String[] args) {
ArrayList<String> arrayList=new ArrayList<>();
arrayList.add("a");
arrayList.add("b");
arrayList.add("f");
arrayList.add("b");
arrayList.add("g");
System.out.println(arrayList);
System.out.println("从指定位置往后遍历");
ListIterator<String> listIterator=arrayList.listIterator(2);//
while(listIterator.hasNext()){
System.out.println(listIterator.next());
}
System.out.println("从（最后）后往前遍历");
ListIterator<String> listIterator1=arrayList.listIterator(arrayList.size());//
while (listIterator.hasPrevious()){
System.out.println(listIterator.previous());
}
}
}
Set接口
特点：Set类中不能有重复元素
1、HashSet
无序的，通过hashCode和equals方法判断元素是否有序。
在添加元素时，是如何判断元素重复的：
（当我们向集合中添加一个元素时,如果每次都使用equals()比较内容是否相等效率会很低）
因此该如何比较呢？
先判断hashcode()值是否相等，如果相等，不一定内容相同，即此情况下会出现哈希冲突，再用equals()比较内容。
在底层会先调用hashcode()-- 0bject中的hashcode()返回的是对象的地址(但是我们不调用这个) 我们需要：调用类中重写的Hashcode(),返回的是根据内容计算的哈希值
遍历时,会用哈希值先比较是否相等,会提高比较的效率，
但是哈希值会存在问题。内容不同,哈希相同
此种情况下,再调用equals()比较内容，这样设计既提高判断效率,又保证安全。
public static void main(String[] args) {
HashSet<String> set=new HashSet<>();
set.add(new String("asdfgdfgdfgsa"));
set.add("bgbgbgghjdnbu");
set.add("通话");
set.add("重地");
for(String s:set){
System.out.println(set);
}
}
2、TreeSet
有序的，可以给Set集合中的元素进行指定方式的排序。存储的对象必须实现Comparable接口。
可以给Set集合中的元素进行指定方式的排序。存储的对象必须实现Comparable接口。
特点:
1、有序的
2、不能存储重复元素的
3、存储时可以根据值进行排序，底层使用了树形结构，树结构本身即是有序的
向树形结构中添加元素时，如何判断元素大小以及元素是否重复？
向TreeSet中添加的元素类型，必须实现Comparable接口，重写compareTo方法
每次添加元素时，调用compareTo()方法进行比较大小
（第一个为根节点，比他大的在右边，比它小的在左边）
package A_集合单例.Set.TreeSet;
import java.util.Objects;
public class Student implements Comparable<Student> {
private String name;
private int num;
public Student(String name, int num) {
this.name = name;
this.num = num;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Student)) return false;
Student student = (Student) o;
return getNum() == student.getNum() &&
Objects.equals(getName(), student.getName());
}
@Override
public int hashCode() {
return Objects.hash(getName(), getNum());
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", num=" + num +
'}';
}
@Override
public int compareTo(Student o) {
return this.num - o.num;
}
}
package A_集合单例.Set.TreeSet;
import java.util.TreeSet;
public class StudentTest {
public static void main(String[] args) {
TreeSet<Student> treeSet=new TreeSet<>();
Student s1=new Student("张三1",103);
Student s2=new Student("张三2",101);
Student s3=new Student("张三3",102);
Student s4=new Student("张三4",104);
treeSet.add(s1);
treeSet.add(s2);
treeSet.add(s3);
treeSet.add(s4);
System.out.println(treeSet);
}
}
3、双列集合
map接口
map接口：
数据存储是(键：值)键值对的形式存储。 键不能重复的，（重复了覆盖原键），值可以重复 通过键可以找到值 一个键只能映射到一个值
1、HashMap
键是无序的，可以存储键为空，值为空的值。
{
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
map.put("a","ddd");
map.put("b","eee");
map.put("c","fff");
map.put("e","ttt");
map.put("a","dd");//向map中添加一组 键值对
System.out.println(map.remove("b"));//删除指定的键值,返回对应的值
map.clear();//清空键值对
System.out.println(map.isEmpty());//判空
System.out.println(map.containsKey("b"));
System.out.println(map.containsValue("eee"));
System.out.println(map.get("c"));
System.out.println(map);
}
}HashMap的底层结构：
哈希表（数组） 链表 红黑树
对于HashMap详细的讲解可看，（讲解很清楚）：https://blog.csdn.net/Wooo_e/article/details/136974366?spm=1001.2014.3001.5501
HashMap的遍历
HashMap两种遍历方式：
1、根据键找值
2、利用map.Entry键值对的查找
package B_集合双列.hashmap;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo2 {
/*
1、用key计算哈希值
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
2、
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
*/
public static void main(String[] args) {
HashMap<String,String> map=new HashMap<>();
map.put("a","aa");
map.put("b","bb");
map.put("c","ccc");
map.put(null,null);
System.out.println(map);
//map遍历
//方式1、先拿到所有的键 遍历键 根据键找值
Set<String> keyset = map.keySet();
for(String s: keyset) {
System.out.println(s + ":" + map.get(s));
}
//方式2、推荐的遍历
Set<Map.Entry<String, String>> entries = map.entrySet();
for(Map.Entry entry:entries){
System.out.println(entry.getKey()+":"+entry.getValue());
}
}
}
2、HashTable
HashTable的底层实现： 也是用到key的哈希值,计算位置,判断元素是否重复。 但是方法上都添加了synchronized锁 Hashtbale中不能存储为null的键和为null的值
package B_集合双列.hashtable;
import java.util.Hashtable;
public class Demo1 {
public static void main(String[] args) {
Hashtable<String,String> hashtable=new Hashtable<>();
hashtable.put("a","bb");
hashtable.put("c","cc");
hashtable.put("b","ff");
hashtable.put("a","aa");
//hashtable.put("d",null);//报错
System.out.println(hashtable);
}
}
3、TreeMap
TreeMap 底层使用树形结构存储键值（红黑树） 键可以排序 键元素类型必须实现Comparable接口，重写compareTo()方法.在TreeMap中，可以存储值为null，但是键不能为null。
package B_集合双列.TreeMap;
import java.util.TreeMap;
public class Demo1 {
public static void main(String[] args) {
TreeMap<Integer,String> treeMap=new TreeMap<>();
treeMap.put(3,"aa");
treeMap.put(2,"bb");
treeMap.put(1,"ff");
treeMap.put(4,"jj");
treeMap.put(5,"oo");
System.out.println(treeMap.get(3));
System.out.println(treeMap.containsKey(2));
System.out.println(treeMap.size());
System.out.println(treeMap);
}
}
持续更新ing........
![BUUCTF---misc---[MRCTF2020]ezmisc](https://img-blog.csdnimg.cn/direct/ed29b26778864db1858ab986f21e2ef8.png)
