Java集合框架

集合框架被设计成的目标：

高性能、高效
允许不同类型的结合，以类似的方式进行工作，有高度的互操作性
对一个集合的扩展和适应必须是简单的

请添加图片描述

两种容器：集合Collection、图Map

集合接口被分为了三种子类型：List、Set、Queue

具体的实现类：ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkHashMap

集合接口

集合框架定义了一些接口，每个接口都提供了不同的功能。
详情可见:https://www.runoob.com/java/java-collections.html

Set和List区别

Set是一个集合，无序而且不允许被重复
Set检索效率低下
List和数组相似，但是它可以被动态地增长，会自动增加List的长度

Java ArrayList

ArrayList是一个可以被动态修改的数组，它和普通数组的区别就是没有固定的长度，可以随时被更改（增加或者删除）
ArrayList继承了AbstractList，并且实现了List接口
ArrayList位于java.util包中，使用之前必须导入它

import java.util.ArrayList;
ArrayList<E> objectName = new ArrayList<>()

E是泛型数据类型，用于设置objectName的数据类型，只能作为引用数据类型
objectName 对象名字

添加元素

public static void main(String[] args){ArrayList<String> sites = new ArrayList<String>();sites.add("Google");sites.add("Bing");sites.add("Youtube");sites.add("Bilibili");System.out.println(sites);}

访问元素

使用get()方法来访问元素

System.out.println(sites.get(1));
//访问第一个

修改元素

使用set方法来修改ArrayList中的元素

sites.set(2,"Wiki");
//第一个参数是索引的位置，第二个位置是修改之后的值

删除元素

使用remove方法可以用于删除元素

sites.remove(3);
//删除3号元素

输出元素数量

使用size()来输出ArrayList()中的元素个数

sites.size();

迭代数组列表

使用for来迭代数组中列表中的元素

for(int i=0;i<sites.size();i++){System.out.println(sites.get(1));
}

当然Java中还封装了for–each循环，我们也可通过for-each来迭代元素

for(String i:sites){System.out.println(i);
}

其他的引用类型

ArrayList中的元素实际上是对象，在上述的实例中，数组列表元素都是字符串String类型。
如果我们需要存储其他的类型，而只能为引用数据类型，这个时候我们就需要使用到基本类型的包装类，即Java的装箱

ArrayList排序

Collections类也是一个非常有用的类，位于java.utils包中，提供sort()方法对字符或者数字列表进行排序，以下的实例对字母进行排序。


import java.util.ArrayList;import java.util.Collections;  
// 引入 Collections 类
public class RunoobTest {public static void main(String[] args) {ArrayList<Integer> myNumbers = new ArrayList<Integer>();        myNumbers.add(33);myNumbers.add(15);myNumbers.add(20);myNumbers.add(34);        myNumbers.add(8);        myNumbers.add(12);        Collections.sort(myNumbers);  // 数字排序        for (int i : myNumbers) {System.out.println(i);     }   }
}

LinkedList

链表LinkedList是一种常见的基础类型数据结构，是一种线性表，但是不会按照线性的顺序来存储数据，而是每个节点里面存储了下一个结点的地址

与ArrayList相比较，LinkedList的增加和删除操作的效率更高，但是查找和修改的效率更低。

建议使用ArrayList的情况

频繁地访问列表中的某一个元素
只需要在列表末尾进行添加和删除的元素的操作

建议使用LinkedList的情况

需要通过循环迭代来访问列表中的某些元素
需要频繁地在列表开头、中间、末尾等地方进行增加和删除元素的操作

LinkedList 类位于 java.util 包中，使用前需要引入它，语法格式如下：

// 引入 LinkedList 类
import java.util.LinkedList; LinkedList<E> list = new LinkedList<E>();   
// 普通创建方法或者
LinkedList<E> list = new LinkedList(Collection<? extends E> c);
// 使用集合创建链表

以下是存放LinkList的一个实例，这个实例中使用了LinkedList来存放了String类型的变量

import java.util.LinkedList;public class Init {//main函数，程序入口public static void main(String[] args) {LinkedList<String> sites = new LinkedList<String>();sites.add("google");sites.add("baidu");sites.add("yahoo");System.out.println(sites);for(String i:sites){System.out.println(i);}}
}

在LinkedList中添加了很多的方法，给我们提供了很多方便的地方，例如getFirst()取第一个，getLast()取最后一个等，详见：
https://www.runoob.com/java/java-linkedlist.html

Java HashSet

Java HashSet是基于HashMap来实现的，是一个不允许有重复元素的集合。
允许具有null值。
无序，不会记录顺序。
不是线程安全的，多个线程尝试修改了它，那么结果也会具有不确定性。
它实现了Set接口。
他的基本元素实际上是对象，那么一些基本的类型可以使用它的包装类。
导入包：java.util.HashSet

添加元素

使用add()方法来添加元素

import java.util.HashSet;public class Init {//main函数，程序入口public static void main(String[] args) {HashSet<Integer> newhashset = new HashSet<Integer>();newhashset.add(1);newhashset.add(2);newhashset.add(3);System.out.println(newhashset);}
}

判断元素是否存在

使用contains()方法来判断元素是否存在

import java.util.HashSet;public class Init {//main函数，程序入口public static void main(String[] args) {HashSet<Integer> newhashset = new HashSet<Integer>();newhashset.add(1);newhashset.add(2);newhashset.add(3);System.out.println(newhashset.contains(3));}
}

删除元素

使用remove()方法来删除某个元素

import java.util.HashSet;public class Init {//main函数，程序入口public static void main(String[] args) {HashSet<Integer> newhashset = new HashSet<Integer>();newhashset.add(1);newhashset.add(2);newhashset.add(3);System.out.println(newhashset.contains(3));newhashset.remove(3);System.out.println(newhashset.contains(3));}
}

清空

使用clear方法清空所有的元素，变成空的集合

import java.util.HashSet;public class Init {//main函数，程序入口public static void main(String[] args) {HashSet<Integer> newhashset = new HashSet<Integer>();newhashset.add(1);newhashset.add(2);newhashset.add(3);System.out.println(newhashset);newhashset.clear();System.out.println(newhashset);}
}

计算大小

使用size()方法来计算大小

import java.util.HashSet;public class Init {//main函数，程序入口public static void main(String[] args) {HashSet<Integer> newhashset = new HashSet<Integer>();newhashset.add(1);newhashset.add(2);newhashset.add(3);System.out.println(newhashset.size());}
}

迭代HashSet

通过foreach循环来迭代HashSet中的元素

import java.util.HashSet;public class Init {//main函数，程序入口public static void main(String[] args) {HashSet<Integer> newhashset = new HashSet<Integer>();newhashset.add(1);newhashset.add(2);newhashset.add(3);for(Integer item:newhashset){System.out.println(item);}}
}

HashMap

HashMap是一个散列表，用于存储键值对的映射
HashMap实现了Map接口，根据键的HashCode值存储数据，具有很快的访问速度，最多允许的一条记录的键为null，不支持线程同步
HashMap是无序的
HashMap 继承于AbstractMap，实现了 Map、Cloneable、java.io.Serializable 接口。

初始化一个键值对

使用类的初始化来建立一个HashMap

HashMap<Integer, String> sites = new HashMap<Integer, String>();

添加元素

通过put()方法来添加键值对映射

public class Init {//main函数，程序入口public static void main(String[] args) {HashMap<Integer, String> sites = new HashMap<Integer, String>();sites.put(1,"Google");sites.put(2,"Baidu");sites.put(3,"Microsoft");System.out.println(sites);}
}

{1=Google, 2=Baidu, 3=Microsoft}

访问元素

使用get(key)方法来通过key获取value

System.out.println(sites.get(3));

删除元素

使用remove(key)方法类删除key对应的键值对(key-value)

import java.util.HashMap;public class Init {//main函数，程序入口public static void main(String[] args) {HashMap<Integer, String> sites = new HashMap<Integer, String>();sites.put(1,"Google");sites.put(2,"Baidu");sites.put(3,"Microsoft");System.out.println(sites);sites.remove(2);System.out.println(sites);}
}

{1=Google, 2=Baidu, 3=Microsoft}
{1=Google, 3=Microsoft}

删除所有元素

使用clear()方法来删除所有的元素

import java.util.HashMap;public class Init {//main函数，程序入口public static void main(String[] args) {HashMap<Integer, String> sites = new HashMap<Integer, String>();sites.put(1,"Google");sites.put(2,"Baidu");sites.put(3,"Microsoft");System.out.println(sites);sites.clear();System.out.println(sites);}
}

{1=Google, 2=Baidu, 3=Microsoft}
{}

迭代HashMap

使用for-each来迭代HashMap的元素
如果你只想获取 key，可以使用 keySet() 方法，然后可以通过 get(key) 获取对应的 value，如果你只想获取 value，可以使用 values() 方法。

import java.util.HashMap;public class Init {//main函数，程序入口public static void main(String[] args) {HashMap<Integer, String> sites = new HashMap<Integer, String>();sites.put(1,"Google");sites.put(2,"Baidu");sites.put(3,"Microsoft");for(Integer i : sites.keySet()){System.out.println("Key: "+i+", Values: "+sites.get(i));}for(String value: sites.values()){System.out.println(value+" ");}}
}

Key: 1, Values: Google
Key: 2, Values: Baidu
Key: 3, Values: Microsoft
Google
Baidu
Microsoft

Iterator迭代器

Java迭代器是Java集合框架中的一种机制，提供了一种在不暴露集合内部实现的情况下遍历集合元素的方法。
是一种访问集合的方法，可用于迭代ArrayList、HashSet等集合。
Iterator是Java迭代器最简单的实现
三个基本操作：next()、hasNext()、remove()

获取一个迭代器

使用iterator()方法来初始化一个迭代器

import java.util.Iterator;public class Init {//main函数，程序入口public static void main(String[] args) {ArrayList<String>list = new ArrayList<String>();list.add("Zhangsan");list.add("Lisi");list.add("Wangwu");Iterator<String> it = list.iterator();System.out.println(it.next());System.out.println(it.next());System.out.println(it.next());}
}

Zhangsan
Lisi
Wangwu

如果超过了遍历的范围，就会报错

循环集合元素

import java.util.ArrayList;
import java.util.Iterator;public class Init {//main函数，程序入口public static void main(String[] args) {ArrayList<String>list = new ArrayList<String>();list.add("Zhangsan");list.add("Lisi");list.add("Wangwu");Iterator<String> it = list.iterator();while(it.hasNext()){System.out.println(it.next());}}
}

删除元素

使用remove()方法来删除元素
下面方法通过remove()删除"Lisi"元素

import java.util.ArrayList;
import java.util.Iterator;public class Init {//main函数，程序入口public static void main(String[] args) {ArrayList<String>list = new ArrayList<String>();list.add("Zhangsan");list.add("Lisi");list.add("Wangwu");Iterator<String> it = list.iterator();while(it.hasNext()){String tmp = it.next();if(tmp.equals("Lisi")){it.remove();}}}
}