Java集合

List集合

List集合特点：元素存取是有序的,能存储重复的元素有索引，可以通过三种方式循环(普通for循环、迭代器、增强for循环(for-each))

创建集合：List list = new ArrayList<>();

注意：不要在 for-each 循环里进行元素的 remove/add 操作。remove 元素请使用 Iterator 方式，如果是并发操作，需要对 Iterator 对象加锁。

Arraylist集合

特点:长度可变，类型不固定，是泛型,底层实现主要基于数组,ArrayList方便查询

创建集合: ArrayList list = new ArrayList
();

增加：list.add(20);

删除：list.remove(0);//根据索引删除

修改：set(int index,Element e) 改，list.set(0,100);

查询：System.out.println(list.get(0));

ArrayList遍历：

1.for循环加list.size加list.get

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

2.lambda表达式的写法,增强for循环,是用来专门遍历数组和集合的原理其实还是个迭代器遍历的过程中，不能对集合中的元素进行增删操作，只遍历元素。

for(集合元素数据
类型 对象名：数组|集合)

for (String s :list){
System.out.println(s);
}//对象名随便的

forEach + Lambda表达式

list.forEach( (str) ->{
System.out.println(str);
});

list.forEach(System.out::println);

格式：for(元素数据类型 变量名：数组/集合){}

3.遍历方式：迭代器 每个集合对象.iterator()都有

Iterator<String> iter= list.iterator();
// hasNext()判断是否有下一个元素
while(iter.hasNext()){
// next()返回下一个元素
System.out.println(iter.next());
}

LinkedList

特点：底层是链表结构，LinkedList方便添加或删除

创建集合：LinkedList link = new LinkedList();

LinkedList特有的：addFirst(E e):添加首个元素，addLast(E e):添加到最后，getFirst(E e):获取首个元素，getLast(E e):获取到最后元素,link.removeFirst()删除最后一个元素

LInkedList可以实现栈和队列的操作： push入栈(压栈) 增加集合中的元素，pop出栈(弹栈) 减少集合中的元素 弹一个减少一个弹出最后进来的，peek查询

offer入队(加入队列) 增加集合中的元素，poll出队(离开队列) 减少集合中的元素 离开一个减少一个 离开先进来的，peek查询将要出队的元素 不减少集合中的元素

Vector

特点：底层是数组结构,被ArrayList替代了,Vector是线程安全的，同步，效率低。ArrayList是线程不安全的，异步的，效率高。

创建集合:Vector stack = new Vector<>();

增删改查同上

Set集合

Set集合特点：元素存取是无序的，不能存储重复的元素没有索引，只能通过迭代器或增强for循环遍历集合中元素

HashSet、TreeSet、LinkedHashSetSe，t集合接口的父类是Collection接口

创建集合：Set set = new HashSet<>();

添加元素 ：add()

HashSet

是Set接口的实现类

特点：不包含重复的元素，元素是无序，底层数据结构是哈希表，没有索引，只能通过迭代器或增强for循环遍历集合中元素对集合的迭代顺序不作任何保证，也就是说不保证存储和取出元素顺序是一致

创建集合：HashSet set = new HashSet<>();

添加元素：add(E e)

取元素：因为没有索引，不能通过get(int index),所以要通过迭代
器去取元素

删除元素：remove(E e)， set.remove(“hello”)
元素个数： size()

遍历用迭代器或者增强for循环

哈希值

TreeSet

是Set接口的子类,底层是依赖于TreeMap,是一种基于红黑数的实现，元素唯一，没有索引。排序方式有两种：自然排序和比
较器排序。

创建集合：TreeSet set = new TreeSet<>();

默认是使用的自然排序(升序) 如果是数字，从小打大，先比较字符串第一字符，如果相同比较第二字符，以此
类推

比较器排序 自定义对象。如果是自定义的类，要去实现Comparable接口,重写compareTo()方法(内部比较强)

// 要重写compareTo()方法
@Override
public int compareTo(Student s) {
// 先去比较年龄，如果年龄相同，再按照姓名比较(升序)
if(s.getAge()-this.getAge()==0){ // 说明年龄
相同
// 比较姓名 compareTo(String s):按字典顺序
比较两个字符串。
return
s.getName().compareTo(this.getName());
}
// 年龄不同
return this.getAge()-s.getAge();
}

LinkedHashSet

是HashSet的子类，特点是有顺序的，存储和取出的顺序相同(怎么存就怎么取)，线程不安全的，运行速度较快。

特点：哈希表和链表实现的Set接口,由链表保证元素有序,由哈希表保证元素唯一

创建集合：LinkedHashSet set = new LinkedHashSet<>();

遍历：迭代器和增强for循环

单列集合总结

Collection接口：
– List接口 ：有序的，元素可以重复
– ArrayList实现类 ： 查询快，增删慢，底层数组结构，线程
不安全的，效率高，异步
– LinkedList实现类：查询慢，增删快，底层链表结构
– Vector实现类：线程安全的，效率低，同步，底层数组结
构，被ArrayList替代了
– Set接口 ：无序的，元素不可重复的
– HashSet实现类：存储的自定义类，要重写equals和
hashCode，底层哈希表结构

– LinkedHashSet孙子类 : 有序并唯一 ，怎么存就怎么
取，底层链表和哈希表结构
– TreeSet实现类：自然排序（升序）、比较器排序（用于自
定义类，要实现Comparable,重写compareTo()和实现
Comparator，重写compare()方法）底层红黑树结构

Optional 类

Optional 类的引入很好的解决空指针异常。

Map集合

Map特点：key键唯一，value值可以不唯一

Map常用的子类：HashMap,TreeMap,Hashtable(被HashMap替代),LinkedHashMap，Properties

HashMap

HashMap元素是无序的，键和值都是泛型，底层数据结构是哈希表结构。

HashMap<K,V> K：映射所维护的键的类型 V：映射值的类型

Map集合的特点：键值对映射关系,一个键对应一个值,键不能重复，值是可以重复的,元素存取是无序的

创建集合：Map<String, Integer> hashMap = new HashMap<>();

添加元素:put(K key, V value)

根据键取元素:get(K key)

根据键删除对应的元素:remove(K key)

获取所有的键：keySet()

JDK7 及以前版本：HashMap 是 数组+链表结构。
JDK8 ：HashMap 是 数组+链表+红黑树

方式一⭐：通过keySet()获取所有的键，再遍历所有的键集，根
据每个键找对应的值。

// 遍历map集合 第一步：获取所有键的集合，用
ketSet()方法获取
Set<String> set = map.keySet();
// 第二步：遍历所有的键集，获取每个键
for(String key : set){
// 第三步：根据每个键找到对应的值
String value= map.get(key);
System.out.println(key+":"+value);
}

方式二：使用Map集合的entrySet()方法，通过entrySet()获取所有的键值对对象的集合，之后遍历键值对对象集合，获取到每个键值
对对象，再根据键值对对象找到键和值，借助Entry中两个方法 getKey（）：获取键 getValue() ：获取值

1. 获取所有键值对对象的集合，用Set<Map.Entry<K, V>>entrySet()方法获取
2. 遍历所有的键值对对象的集合，得到每一个键值对对象，用增强for实现，得到每一个Map.Entry

// 遍历map集合 第一步：获取所有键值对对象的集合
Set<Map.Entry<String, String>> entrySet =
map.entrySet();
// 第二步：遍历所有的键值对对象的集合，得到每一个键
值对对象
for(Map.Entry<String, String>
mapEntry:entrySet){
// 第三步：根据键值对对象获取每个键和每个值
String key = mapEntry.getKey(); // 调用内
部接口的方法
String value = mapEntry.getValue(); //
调用内部接口的方法
System.out.println(key+":"+value);
}

TreeMap

TreeMap也是Map的子类，底层的数据结构是红黑树结构，有序，可以对元素的键进行排序，排序方式有两种：自然排序和比较器排序

创建集合：Map<String, Integer> treeMap = new TreeMap<>();

LinkedHashMap

LinkedHashMap是HashMap的子类：
Linked链表结构，保证元素有顺序,键有序，
Hash是哈希结构，保证元素唯一
这两个约束都是对键起作用
LinkedHashMap的底层是链表实现的，保证怎么存怎么取，保持插入顺序，相对HashMap查询速度更快

创建集合：Map<String, Integer> linkedHashMap = new LinkedHashMap<>();

Hashtable

面试题：HashMap与Hashtable有什么区别？
Hashtable是Map接口的实现类，底层数据结构是哈希表结构，和HashMap一样的，被HashMap替代了。
1.Hashtable是线程安全，同步的，运行速度慢，而HashMap是线程不安全的，运行速度更快。
2.和 HashMap 不相同的是Hashtable不允许存储null键和null值，而HashMap是允许存储null键和null值
和 HashMap 相同的是，Hashtable 不能保证 key - value 对的顺序。
Hashtable有个子类是Properties类依然还在使用。

创建集合：Map<String, Integer> hashtable = new Hashtable<>();

Properties

是一个Map集合类
是Hashtable集合类的一个子类，该对象是用来处理属性文件的。由于属性文件的 key 和 value 都是字符串类型，所以Properties的
键和值都是String数据类型。存取数据的时候，建议使用setPropert y和 getProperty 方法。
Properties可以保存到流中store()和从流中加载load()

Optional first =distinct.findFirst();

ConcurrentHashMap

线程安全且高效的实现，数组，链表，红黑数

Map<String, Integer> concurrentHashMap = new ConcurrentHashMap<>();

Properties集合

load(Reader)
使用Properties类中的load()方法读取，将“输入流”加载到
Properties集合对象中，根据key来获取value的值。
store(Writer,comment)
因为properties文件数据是以集合形式存储，所以可以用put()方法
将KV键值对存入Properties集合中，再通过输出流使用store()方法
将集合中的临时数据，持久化写入硬盘中存储。

@Test
public void test01() throws IOException {
    //创建Properties对象
    Properties prop = new Properties();
    //字符流
    FileReader fr = new FileReader("druid.properties");
    prop.load((fr));//加数据
    System.out.println(prop);
    //根据key取value
    String v=prop.getProperty("password");//取值
    System.out.println(v);
   

}
@Test
public void test02() throws IOException {
    //创建Properties对象
    FileWriter fw = new FileWriter("data.properties");
    创建Properties集合对象
    Properties prop = new Properties();
    //先向集合中添加一些数据
    prop.setProperty("小验证","赵薇");
    prop.setProperty("及时雨","宋江");
    //把集合中读数据写到文件中
    prop.store(fw,"描述");
    //释放资源
    fw.close();
}
`