Java集合
什么是集合？
集合类是一个大小可变的容器。
集合类的特点：类型可以不确定，大小可以不确定
使用场景：存储的数据要经常发生改变
常用集合
集合主要分为Collection和Map两大类：
Collection：是单列集合的顶层父类，是一个独立元素的序列，这些个元素都服从一条或者多条规则。
List必须按照插入的顺序保存元素，而Set不能有重复的元素。即Collection分为List和Set两大分支。
【重点】
Collection：无序，可重复
List系列集合：有序，可重复，有索引。
-- ArrayList：添加的元素是有序，可重复，有索引
-- LinekdList：添加的元素是有序，可重复，有索引
Set系列集合：添加的元素是无序，不可重复，无索引
-- HashSet：添加的元素是无序，不可重复，无索引
-- LinkedHashSet：添加的元素是有序，不可重复，无索引
-- TreeSet：按照大小默认升降序,不可重复，无索引
Map：存储方式key:value键值对
Conllection集合
什么是Conllection集合？
什么是Conllection集合？
Conllection集合常用方法
| 方法名 | 说明 |
|---|---|
| public boolean add(E e) | 在集合末尾新增一个元素 |
| public void clear | 清空集合中的所有元素 |
| public boolean remove(E e) | 删除指定的元素，返回是否删除成功 |
| public boolean isEmpty() | 判断当前集合是否为空 |
| public boolean contains(Object obj) | 判断当前集合中是否包含指定的对象 |
| public Object[] toArray() | 把集合中的元素，存储到数组中 |
| 把集合中的元素，存储到数组中 | 返回集合中的元素个数 |
List集合
ArrayList实现了长度可变的数组，在内存中分配连续的空间。遍历元素和随机访问元素的效率比较高。底层数据结构是数组，线程不安全。（它是我们用得非常非常多的一个集合）
实现方式：
ArrayList list = new ArrayList();//创建一个ArrayList集合，底层Object[] elementData初始化为{}
list.add(new Person("张三",1));//第一次调用add()时，在底层创建了长度10的数组，并将数据张三添加到elementDate中
定义存储类型
ArrayList<Person> list = new ArrayList<>(); //对象类型
list.add("张三",1);
ArrayList<String> list = new ArrayList<>(); //String类型
list.add("张三");
ArrayList<Integer> list = new ArrayList<>(); //包装类型 Boolean Byte Character Short Integer Long Float Double
list.add(1);
List集合常用方法：
| 方法名 | 说明 |
|---|---|
| public boolean add(E e) | 在集合末尾新增一个元素 |
| public boolean add(int index, E element) | 在指定位置添加元素 |
| public boolean remove(Object o) | 删除指定的元素，返回是否删除成功 |
| public E remove(int index) | 删除指定索引处的元素，返回被删除的元素 |
| public E set(int index,E element) | 修改指定索引处的元素，返回被修改的元素 |
| public E get(int index) | 返回指定索引处的元素 |
| public int size() | 返回集合中的元素个数 |
| indexOf(Object o) | 查询指定元素的位置 lastIndexOf也一样，只是从尾部开始遍历 |
List集合常用方法的使用：
ArrayList<String> list = new ArrayList<>();
list.add("张三"); //添加一个元素
list.add(5,"张三"); //在指定索引处添加一个元素
list.remove("张三"); //删除一个元素
System.out.println(list.remove("张三")); //删除一个元素并输出true|false
list.remove(1); //删除指定索引处的元素
list.set(0,"李四"); //修改指定索引的元素，返回被修改的元素
list.get(0); //获取指定索引的元素
list.size(); //获取集合中元素个数
list.lidexOf("李四"); //获取指定元素的位置
List遍历方式：
// 第一种遍历方式:普通for循环
for (int i = 0; i < arrayList.size(); i++) {
System.out.println(arrayList.get(i));
}
// 第二种遍历方式:增强for循环
for (String string : arrayList) {
System.out.println(string);
}
// 第三种遍历方式:迭代器
Iterator<String> iterator = arrayList.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
Map集合
Map集合结构体系
什么是Map集合？
Map集合是一种双列集合，每个元素包含两个值。
Map集合的每个元素的格式：
Map集合的特点
1.Map集合都是由键决定的。
2.Map集合的键都是无序、不重复、无索引。
--Map集合后面重复的键对应的元素会覆盖前面的整个元素!
3.Map集合的值是无要求的。
4.Map集合的键值对都可以为null。
HashMap和LinkedHashMap的区别
HashMap:元素按照键是无序、不重复、无索引，值不做要求。
LinkedHashMap：元素按照键是有序、不重复、无索引、值不做要求。
Map集合使用:
1.Map集合存储的信息更加具体丰富。
//Conllection:{"张三","男",23,"中国","深圳","程序员"}
//Map:{name="张三",sex="男",age=23,country="中国",city="深圳",occupation="程序员"}
Map<Person,String> maps = new HashMap<>
maps.put(new Person("张三","男","23"),"中国");
2.Map集合适合存储对象数据
Map集合常用方法：
| 方法名 | 说明 |
|---|---|
| public v put(K key, V value) | 把指定的键与指定的值添加到Map集合中 |
| public v remove(Object key) | 删除指定的值所对应的元素 |
| public boolean isEmpty() | 判断集合是否为空 |
| abstract int size() | 获取集合大小 |
| public v get(Object key) | 根据键获取指定元素 |
| public set keySet() | 获取Map集合中所有的键，存储到Set集合中 |
| 获取Map集合中所有的键，存储到Set集合中 | 获取Map集合中所有的值，存储到Conllection集合中 |
| public set<Map.Entry<K,V>> entrySet() | 获取到Map集合中所有的键值对对象的集合(Set集合) |
| public boolean containKey(Object key) | 判断该集合中是否包含某个键 |
| public boolean containValue(Object value) | 判断该集合中是否包含某个值 |
Map用法：
Map<String,Integer> maps = new HashMap<>();
maps.put("张三",1); //添加元素
maps.put(null,null);
maps.clear(); //清空集合
maps.isEmpty(); //判断集合是否为空，为空返回true,不为空返回false
maps.get("张三"); //根据键获取对应值 返回1
maps.size(); //获取集合大小
maps.remove("张三"); //根据键删除某个元素 返回1
maps.containsKey("张三"); //判断集合是否包含 张三 ，返回true或flase
maps.containsValue(1); //判断集合是否包含键 1 ，返回true或flase
//map集合的键是无序不重复的，所以返回的是一个Set集合
Set<String> keys = maps.keySet();//获取Map集合中所有的键，存储到Set集合中
//Map集合的值是不能做要求的，可能重复，所以要用Conllection集合接收!
Conllection<Integer> values = maps.values();//将maps集合中的值存入到Conllection集合中
Map集合的遍历：
map集合3中遍历方式：
1.“键找值”的方式遍历：先获取Map集合全部的键，再根据遍历键找值。
2.“键值对”的遍历方式：难度较大。
3.Lambda表达式遍历
//通过键找值方式遍历
Set<String> keys = maps.keySet();
for(String key:keys){
Integer value = maps.get(key); //通过键获取对应的值
System.out.println(key + "=" + value);
}
}
//Lamboda表达式遍历
maps.forEach(k , v) ->{
System.out.println(k + "=>" + v);
}
Collections工具类
什么是Collections工具类?
java.utils.Collections:是集合工具类
Conllections常用方法：
| 方法名 | 说明 |
|---|---|
| public static boolean addAll(Conlection<? super T> c,T... emlements) | 给集合对象批量添加元素 |
| public static void shuffle(List<?> list) | 打乱集合顺序 |
| public static void sort(List list) | 将集合中元素按照默认规则排序 |
| public static void sort(List list,Comparator<? super T>) | 将集合中的元素按照指 |
Conllections常用方法的使用：
List<String> name = new ArrayList<>();
//给集合添加多个元素
//Conllections.addAll(集合名,需要添加的元素);
Conllections.addAll(name,"张三","李四","王五");
//打乱集合顺序
Conllections.shuffle(name);
//默认升序排序
Conllections.sort(name);
//自定义比较规则排序
List<Person> persons = new ArrayList<>();
Person person1 = new Person("张三",1,"男");
Person person2 = new Person("李四",2,"男");
Person person3 = new Person("王五",3,"男");
Person person4 = new Person("赵六",4,"男");
Conllections.addAll(persons,person1,person2,person3,person4);
//自定义规则
Conllections.sort(persons,new Comparator<Person>){
@Override
public int compare(Person p1,Person p2){
//年龄比较升序
if(p1.getAge() > p2.getAge()) return 1;
if(p1.getAge() < p2.getAge()) return -1;
/*
//年龄比较降序
if(p1.getAge() > p2.getAge()) return -1;
if(p1.getAge() < p2.getAge()) return 1;
*/
return 0;
}
}
