集合体系java

Collection:单列集合：每个元素只包含一个值

Collection集合存储的是地址

Collection的三种遍历方法如下

//迭代器是用来遍历集合的专用方式（数组没有迭代器），在java中迭代器的代表是Iterator
//boolean hasNext():询问当前位置是否有元素存在
//E next():获取当前位置的元素，并同时将迭代器指向下一个元素处
public class CollectionTest3 {public static void main(String[] args) {Collection<String> c = new ArrayList<>();c.add("java1");c.add("java2");c.add("java3");//从集合对象获取迭代器对象Iterator<String> iterator = c.iterator();while(iterator.hasNext()){System.out.println(iterator.next());}//增强For循环：可以遍历数组或集合,本质就是迭代器遍历集合的简便写法/*for(元素的数据类型 变量名：数组或者集合)*/for(String s:c){System.out.println(s);}//使用Lambda表达式遍历c.forEach(new Consumer<String>() {@Overridepublic void accept(String s) {System.out.println(s);}});c.forEach((String s) -> {System.out.println(s);});c.forEach( s -> {System.out.println(s);});c.forEach( s -> System.out.println(s));c.forEach(System.out::println);}
}

1. List系列集合：添加的元素是有序，可重复，有索引。

List集合存储的是内容

四种遍历方式如下

public class ListTest1 {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("java1");list.add("java2");list.add("java2");//        System.out.println(list);//for循环遍历for (int i = 0; i < list.size(); i++) {System.out.println(list.get(i));}//迭代器遍历Iterator<String> iterator = list.iterator();while(iterator.hasNext()){System.out.println(iterator.next());}//增强for循环for (String s : list) {System.out.println(s);}//Lambda表达式遍历list.forEach( System.out::println);}
}

a. ArrayList：有序，可重复，有索引（基于数组实现）

查询快，增删慢

查询速度快（是根据索引查询数据快）
删除效率低：可能需要把后边很多数据进行前移
添加数据效率极低：可能需要把后边很多数据后移，再添加元素；或者也可能进行数组的扩容

底层原理：（1）利用无参构造器创建的集合，会在底层创建一个默认长度为0的数组

（2）添加第一个元素时，底层会创建一个新的长度为10的数组

（3）存满时，会扩容1.5倍

（4）如果一次添加多个元素，1.5倍还放不下，则创建数组的长度以实际为准

b. LinkedList：有序，可重复，有索引（基于双向链表实现）

适合用作队列，栈

查询慢，增删相对较快，但对首尾进行增删改查的速度是极快的

（API中有在头部增加删除元素，在尾部增加删除元素方法）

2. Set系列集合：添加的元素是无序，不重复，无索引.

a. HashSet : 无序，不重复，无索引（基于哈希表实现，底层基于Map实现的，只是只要键数据，不要值数据）

增删改查性能都较好

哈希值：java中每个对象都有一个哈希值，是一个int类型的数据

哈希表：数组+链表+红黑树

底层原理：（1）创建一个默认长度16的数组，默认加载因子为0.75，数组名为table

（2）使用元素的哈希值对数组长度求余计算出应存入的位置

（3）判断当前位置是否为null，如果是null直接存入

（4）如果不为null，表示有元素，则调用equals方法比较

相等，则不存；不相等，则存入数组

（数组占满后，扩容16*0.75=12个）

JDK8之前，新元素存入数组，占老元素位置，老元素挂在下面（链表）

JDK8之后，新元素挂在老元素下面（链表），当链表长度超过8，且数组长度
>=64时，自动将链表转成红黑树

如果Set集合认为两个内容一样的对象是重复的，必须重写对象的HashCode()方法和equals()方法

b. LinkedHashSet : 有序，不重复，无索引（基于哈希表实现，底层基于LinkedHashMap实现）

每个元素都额外多了一个双链表的机制记录它前后元素的位置

c. TreeSet : 按照大小默认升序排序，不重复，无索引（基于红黑树实现）

存储自定义的对象时，必须制定规则排序，支持如下两种方法（见对象排序的两种方法）

Map:双列集合，每个元素包含两个值（键值对）

键不可以重复，值可以重复

在做购物车时，商品与购买数量是一对数据等等

把Map集合变成Set集合（把一个键值对看成一个元素）

Set<Map.Entry<String, Integer>> entries = map.entrySet();

map集合三种遍历方式如下

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;public class MapTest1 {public static void main(String[] args) {Map<String,Integer> map = new HashMap<>();map.put("张三",20);map.put("张三",21);map.put("李四",19);map.put("王五",20);System.out.println(map);//键找值//获取map集合的全部键Set<String> keys = map.keySet();System.out.println(keys);//遍历全部的键，获得值for (String key : keys) {Integer i = map.get(key);System.out.println(key+"==>"+i);}//把键值对看成一个整体进行遍历//1.调用map集合提供的entrySet方法，把map集合转换成键值对类型的set集合Set<Map.Entry<String, Integer>> entries = map.entrySet();//entires = {(张三=21),(李四=19),(王五=20)}for (Map.Entry<String, Integer> entry:entries) {String key = entry.getKey();Integer value = entry.getValue();System.out.println(key+"==>"+value);}//lambda表达式遍历map.forEach((k,v) -> {System.out.println(k+"==>"+v);});//即map.forEach(new BiConsumer<String, Integer>() {@Overridepublic void accept(String k, Integer i) {System.out.println(k+"==>"+i);}});}
}

1.HashMap(由键决定特点)：无序，不重复,无索引（基于哈希表实现）

键相同时，后边的内容会覆盖前边的

public class MapTest1 {public static void main(String[] args) {Map<String,Integer> map = new HashMap<>();map.put("手表",2);map.put("手表",15);map.put("手机",5);map.put(null,null);System.out.println(map);//{null=null, 手表=15, 手机=5}}
}

HashMap集合是一种增删改查数据，性能都较好的集合
但是他是无序的，不能重复，没有索引支持的（由键决定的特点）
HashMap的键依赖HashCode方法和equals方法保证键的唯一
如果存储的是自定义类型的对象，可以通过重写通过 HashCode方法和equals方法，这样可以保证多

个对象内容一样时，HashMap集合就能认为是重复的

a.LinkedHashMap:有序，不重复，无索引

底层数据结构依然是基于哈希表实现的，只是每个键值对元素又额外的多了一个双链表的机制记录元素顺序（保证有序）

2.TreeMap:按照大小默认升序排序，不重复，无索引

集合的并发修改异常

使用迭代器遍历时，又同时在删除集合中的数据，程序就会出现并发修改异常
使用增强for循环，lambda表达式遍历集合并删除数据，没有办法解决bug

解决办法

  List<String> list = new ArrayList<>();list.add("java1");list.add("java2");list.add("java2");list.add("java21");list.add("java3");list.add("java11");//迭代器遍历Iterator<String> iterator = list.iterator();while(iterator.hasNext()){String name = iterator.next();if (name.contains("1")){
//                list.remove(name);//会出现并发错误，会漏删iterator.remove();//删除迭代器当前遍历到的数据，每删除一个数据后，相当于在底层做了i--}}//for循环遍历for (int i = 0; i < list.size(); i++) {String name = list.get(i);if (name.contains("1")){list.remove(name);i--;}}

可变参数

就是一种特殊形参，定义在方法，构造器的形参列表里，格式是：数据类型，参数名称

特点和好处

好处：可以不传数据给他；可以同时传一个或者同时传多个数据给他；也可以传一个数组给她
好处：常常用来灵活的接收数据

注意：

一个形参列表中，只能有一个可变参数
可变参数必须放到形参列表的最后边

public class ParamTest {public static void main(String[] args) {test();test(1);test(1,2);test(new int[]{1,2,3});}//一个形参列表中，只能有一个可变参数//可变参数必须放到形参列表的最后边public static void test(int...nums){//可变参数在方法内部，本质就是一个数组System.out.println(nums.length);System.out.println(Arrays.toString(nums));System.out.println("----------------");}
}