集合
Collection单列集合
1.特点
2.常用方法（Collection都可用）
遍历方式
迭代器遍历
Iterator<String> it = c.iterator();//此处c是之前定义好的集合
//第二步：用于判断当前位置是否有元素可以获取
//解释：hasNext()方法返回true，说明有元素可以获取；反之没有
while(it.hasNext()){
//第三步：获取当前位置的元素，然后自动指向下一个元素.
String e = it.next();
System.out.println(s);
}-
当调用iterator()方法获取迭代器时，当前指向第一个元素
-
hasNext()方法则判断这个位置是否有元素，如果有则返回true，进入循环
-
调用next()方法获取元素，并将当月元素指向下一个位置，
-
等下次循环时，则获取下一个元素，依此内推
增强For遍历
ForEach遍历
List系列集合
特点：有序，可重复，有索引
ArrayList：底层基于数组。
LinkedList：底层基于链表（双向）。可用于设计栈结构，队列结构。
Set系列集合
HashSet：无序，不重复，无索引。
LinkedHashSet：有序，不重复，无索引。
TreeSet：排序，不重复，无索引。
HashSet底层原理
去重原理：equals方法。对象存入集合，需重写hashCode和equals方法。
LinkedHashSet底层原理
额外在每个元素间添加了双链表维持关系。
TreeSet排序
第一种：让元素的类实现Comparable接口，重写compareTo方法
@Override
public int compareTo(Student o) {
//this：表示将要添加进去的Student对象
//o: 表示集合中已有的Student对象
return this.age-o.age;//结果是正数、负数、还是零，决定元素放在后面、前面还是不存。
}第二种：在创建TreeSet集合时，通过构造方法传递Compartor比较器对象
Set<Student> students = new TreeSet<>(new Comparator<Student>{
@Override
public int compare(Student o1, Student o2){
//需求：按照学生的身高排序
return Double.compare(o1,o2);
}
});并发修改异常
因为迭代器遍历机制，规定迭代器遍历集合的同时，不允许集合自己去增删元素，否则就会出现这个异常。
解决方法：不使用集合的删除方法，而是使用迭代器的删除方法
Collections工具类
Map集合
所谓双列集合，就是说集合中的元素是一对一对的。Map集合中的每一个元素是以key=value的形式存在的，一个key=value就称之为一个键值对，而且在Java中有一个类叫Entry类，Entry的对象用来表示键值对对象。
所有的Map集合有如下的特点：键不能重复，值可以重复，每一个键只能找到自己对应的值。
特点
常用方法
Map集合遍历
1.遍历得出所有键，通过键得出所有值。
2.通过Entry对象遍历。
//调用Map集合提供entrySet方法，把Map集合转换成键值对类型的Set集合
Set<Map.Entry<String, Double>> entries = map.entrySet();
for (Map.Entry<String, Double> entry : entries) {
String key = entry.getKey();
double value = entry.getValue();
System.out.println(key + "---->" + value);
}3.ForEach
Map集合底层原理
HashMap底层数据结构: 哈希表结构
JDK8之前的哈希表 = 数组+链表
JDK8之后的哈希表 = 数组+链表+红黑树
哈希表是一种增删改查数据，性能相对都较好的数据结构
往HashMap集合中键值对数据时，底层步骤如下
第1步：当你第一次往HashMap集合中存储键值对时，底层会创建一个长度为16的数组
第2步：把键然后将键和值封装成一个对象，叫做Entry对象
第3步：再根据Entry对象的键计算hashCode值（和值无关）
第4步：利用hashCode值和数组的长度做一个类似求余数的算法，会得到一个索引位置
第5步：判断这个索引的位置是否为null，如果为null,就直接将这个Entry对象存储到这个索引位置
如果不为null，则还需要进行第6步的判断
第6步：继续调用equals方法判断两个对象键是否相同
如果equals返回false，则以链表的形式往下挂
如果equals方法true,则认为键重复，此时新的键值对会替换就的键值对。
HashMap底层需要注意这几点：
1.底层数组默认长度为16，如果数组中有超过12个位置已经存储了元素，则会对数组进行扩容2倍
数组扩容的加载因子是0.75，意思是：16*0.75=12
2.数组的同一个索引位置有多个元素、并且在8个元素以内(包括8)，则以链表的形式存储
JDK7版本：链表采用头插法（新元素往链表的头部添加）
JDK8版本：链表采用尾插法（新元素我那个链表的尾部添加）
3.数组的同一个索引位置有多个元素、并且超过了8个，则以红黑树形式存储
LinkedHashMap，TreeMap底层均与Set中类似。
Stream流
获取流
// 1、如何获取List集合的Stream流？
List<String> names = new ArrayList<>();
Collections.addAll(names, "张三丰","张无忌","周芷若","赵敏","张强");
Stream<String> stream = names.stream();
// 2、如何获取Set集合的Stream流？
Set<String> set = new HashSet<>();
Collections.addAll(set, "刘德华","张曼玉","蜘蛛精","马德","德玛西亚");
Stream<String> stream1 = set.stream();
stream1.filter(s -> s.contains("德")).forEach(s -> System.out.println(s));
// 3、如何获取Map集合的Stream流？
Map<String, Double> map = new HashMap<>();
map.put("古力娜扎", 172.3);
map.put("迪丽热巴", 168.3);
map.put("马尔扎哈", 166.3);
map.put("卡尔扎巴", 168.3);
Set<String> keys = map.keySet();
Stream<String> ks = keys.stream();
Collection<Double> values = map.values();
Stream<Double> vs = values.stream();
Set<Map.Entry<String, Double>> entries = map.entrySet();
Stream<Map.Entry<String, Double>> kvs = entries.stream();
kvs.filter(e -> e.getKey().contains("巴"))
.forEach(e -> System.out.println(e.getKey()+ "-->" + e.getValue()));
// 4、如何获取数组的Stream流？
String[] names2 = {"张翠山", "东方不败", "唐大山", "独孤求败"};
Stream<String> s1 = Arrays.stream(names2);
Stream<String> s2 = Stream.of(names2);中间方法
/**
* 目标：掌握Stream流提供的常见中间方法。
*/
public class StreamTest3 {
public static void main(String[] args) {
List<Double> scores = new ArrayList<>();
Collections.addAll(scores, 88.5, 100.0, 60.0, 99.0, 9.5, 99.6, 25.0);
// 需求1：找出成绩大于等于60分的数据，并升序后，再输出。
scores.stream().filter(s -> s >= 60).sorted().forEach(s -> System.out.println(s));
List<Student> students = new ArrayList<>();
Student s1 = new Student("蜘蛛精", 26, 172.5);
Student s2 = new Student("蜘蛛精", 26, 172.5);
Student s3 = new Student("紫霞", 23, 167.6);
Student s4 = new Student("白晶晶", 25, 169.0);
Student s5 = new Student("牛魔王", 35, 183.3);
Student s6 = new Student("牛夫人", 34, 168.5);
Collections.addAll(students, s1, s2, s3, s4, s5, s6);
// 需求2：找出年龄大于等于23,且年龄小于等于30岁的学生，并按照年龄降序输出.
students.stream().filter(s -> s.getAge() >= 23 && s.getAge() <= 30)
.sorted((o1, o2) -> o2.getAge() - o1.getAge())
.forEach(s -> System.out.println(s));
// 需求3：取出身高最高的前3名学生，并输出。
students.stream().sorted((o1, o2) -> Double.compare(o2.getHeight(), o1.getHeight()))
.limit(3).forEach(System.out::println);
System.out.println("-----------------------------------------------");
// 需求4：取出身高倒数的2名学生，并输出。 s1 s2 s3 s4 s5 s6
students.stream().sorted((o1, o2) -> Double.compare(o2.getHeight(), o1.getHeight()))
.skip(students.size() - 2).forEach(System.out::println);
// 需求5：找出身高超过168的学生叫什么名字，要求去除重复的名字，再输出。
students.stream().filter(s -> s.getHeight() > 168).map(Student::getName)
.distinct().forEach(System.out::println);
// distinct去重复，自定义类型的对象（希望内容一样就认为重复，重写hashCode,equals）
students.stream().filter(s -> s.getHeight() > 168)
.distinct().forEach(System.out::println);
Stream<String> st1 = Stream.of("张三", "李四");
Stream<String> st2 = Stream.of("张三2", "李四2", "王五");
Stream<String> allSt = Stream.concat(st1, st2);
allSt.forEach(System.out::println);
}
}终结方法
/**
* 目标：Stream流的终结方法
*/
public class StreamTest4 {
public static void main(String[] args) {
List<Student> students = new ArrayList<>();
Student s1 = new Student("蜘蛛精", 26, 172.5);
Student s2 = new Student("蜘蛛精", 26, 172.5);
Student s3 = new Student("紫霞", 23, 167.6);
Student s4 = new Student("白晶晶", 25, 169.0);
Student s5 = new Student("牛魔王", 35, 183.3);
Student s6 = new Student("牛夫人", 34, 168.5);
Collections.addAll(students, s1, s2, s3, s4, s5, s6);
// 需求1：请计算出身高超过168的学生有几人。
long size = students.stream().filter(s -> s.getHeight() > 168).count();
System.out.println(size);
// 需求2：请找出身高最高的学生对象，并输出。
Student s = students.stream().max((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight())).get();
System.out.println(s);
// 需求3：请找出身高最矮的学生对象，并输出。
Student ss = students.stream().min((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight())).get();
System.out.println(ss);
// 需求4：请找出身高超过170的学生对象，并放到一个新集合中去返回。
// 流只能收集一次。
List<Student> students1 = students.stream().filter(a -> a.getHeight() > 170).collect(Collectors.toList());
System.out.println(students1);
Set<Student> students2 = students.stream().filter(a -> a.getHeight() > 170).collect(Collectors.toSet());
System.out.println(students2);
// 需求5：请找出身高超过170的学生对象，并把学生对象的名字和身高，存入到一个Map集合返回。
Map<String, Double> map =
students.stream().filter(a -> a.getHeight() > 170)
.distinct().collect(Collectors.toMap(a -> a.getName(), a -> a.getHeight()));
System.out.println(map);
// Object[] arr = students.stream().filter(a -> a.getHeight() > 170).toArray();
Student[] arr = students.stream().filter(a -> a.getHeight() > 170).toArray(len -> new Student[len]);
System.out.println(Arrays.toString(arr));
}
}
10万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
