java-Stream流

双列集合：一次需要存一对数据 分别为键和值
建不能重复，值可以重复
建和值是一一对应的
建+值整体叫做，键值对或者键值对对象 在java中叫做 ”Entry对象
Map: Hasmap LinkedHashmap
Treemap
put remove clear containskey containsValue isEmpty size

Map<String,String> m = new HashMap<>();
m.put(“郭靖”,“黄蓉”)
添加数据时，如果建不存在，直接把键值对对象添加到map集合中。返回null
如果键时存在的，那么会把原有的键值对对象覆盖，并把被覆盖的值进行返回
m.remove(“郭靖”) 返回值 “黄蓉”
m.clear() 无返回值
m.containsKey(“郭靖”) true false
m.containsValue(“黄蓉”)；
m.isEmpty();
m.size();

Map 遍历方式：

Map<String,String> map = new HashMap<>();
map.put("步惊云","楚楚")
set<String> keys = map.keySet();
for (Map key:keys){
	String value = map.get(key);
}
通过键值对对象进行遍历
通过一个方法获取所有的键值对对象，返回一个set集合
Set<Map.Entry<String,String>> entries = map.entrySet();
for(Map.Entry<String,String> entry:entries){
	String key = entry.getKey();
	String value = entry.getValue();
}
  利用lambda 表达式进行遍历
map.forEach(new BiConsumer<String,String>(){
@override
public void accept(String key,String value){
		System.out.println(key+"+"+value);
	}
})

map.forEach((String key,String value)->{
	System.out.println(key+"+"+value);
});

map.forEach((key,value)->System.out.println(key+"+"+value));

HashMap 的特点：HashMap 是Map 里面的一个实现类
特点由键决定的：无序、不重复、无索引
HashMap 和HashSet底层原理是一模一样的，都是哈希表结构
依赖hashCode方法和equals 方法保证键的唯一
如果键存储的是自定义对象 ，需要重写hashCode和equals方法
如果值存储自定义对象，不需要重写hashcode和equals方法

HashMap<Student,String>hm = new HashMap<>();
Student s1 = new Student("zhangsan",23);
hm.put(s1,"江苏")
Set<Student> keys = hm.KeySet();
for(Student key:keys){
	String value = hm.get(key);
	System.out.println(key+"="+value);
}

LinkedHashMap: 有序、不重复无索引
有序：保证存储和取出的元素顺序一致
原理：底层数据结构依然是哈希表，只是每个键值对元素又额外的多了一个双链表的机制记录存储的顺序

LinkedHashMap<String,Integer> lhm = new LinkedHashMap<>();
lhm.put("a",123);  添加 覆盖

TreeMap：底层红黑树
由键决定特性：不重复，无索引，可排序
可排序：对建进行排序，默认从小到大
两种排序规则：
实现Comparable接口，指定比较规则
创建集合时传递Comparator 比较器的对象，指定规则

创建集合对象
TreeMap<Integert,String> tm = new TreeMap<>();
tm.put(1,"红牛");
tm.put(2,"可口可乐");
默认按照键进行升序
修改为降序
TreeMap<Integer,String> tm = new TreeMap<>(new Comparator<Integer>(){
	@override
	public int compare(Integer o1,Integer o2){
			return o2 - o1;
	}
})
#########################
TreeMap<Student,String> tm = new TreeMap<>();
Student s1 = new Student("zhangsan",23);
Student s2 = new Student("lisi",24);

在 Student 类中重写compareTo 
@override
public int compareTo(Student o){
	this：表示当前添加的元素
	o:表示已经在红黑树中存在的元素
	返回值：负数：表示当前要添加的元素时小的，存左边
			正数：表示当前要添加的元素是大的，存右边
			0：表示当前添加的元素已经储存在 舍弃
	按照年龄升序，年龄一样的按照姓名排序，同姓名同年龄为同一个人
int i = this.getAge() - o.getAge();
i = i == 0 ?this.getName().compareTo(o.getName()): i ;
return i;
}

可变参数:int...args  有多个参数 可变参数写到最后
public static int getSum(int...args){}

Colleactions 常用的API 
addAll() shuffle() sort() sort() binarySearch() copy() fill() max/min() swap()

ArrayList<String> list = new ArrayList<>();
Collections.shuffle(list);

不可变集合：

创建不可变的List集合

Listlist = List.of(“e”,“q”,“1”)

创建不可变的Set集合
Setset= Set.of(“e”,“q”,“1”)

创建不可变Map集合
Map<String,String>map = Map.of(“lisi”:“xian”) 最多添加10个 超过10个 ofEntries

Stream 流

ArrayList<String> list1 = new ArrayList<>();
list1.add("张三","张我我","张委屈恶气")
list1.stream().filter(name->name.startsWith("账").filter(name.length()==3).forEach(name -> System.out.pringln(name)))

单列集合： default Streamstream() Collection中的默认方法
双列集合 无 无法直接使用
数组 public static Stream stream(T[] array) Arrays工具类中的静态方法
一堆零散数据 public static Stream of(T… values) Stream 接口中的静态方法

//1.单列集合

ArrayList<String> list = new ArrayList<>()
Collections.addAll(list,"f","d","s","a")
Stream<String> stream1 = list.stream()

list.stream().forEach(s -> System.out.pringln(s))

//2 双列集合

HashMap<String,Integer> hm = new HashMap<>();
hm.put("aaa",111)
hm.put("aqwqaa",222)
hm.keySet().stream().forEach(s -> System.out.println(s))
hm.entrySet().stream().forEach(s -> System.out.println(s))

//3 数组

int[] arr1 = {1,2,3,4,5,6}
Arrays.stream(arr1).forEach(s -> System.out.println(s))

//4 零散数据

Stream.of(1,2,3,4,5).forEach(s -> System.out.println(s))
//可以传递数组，但是数组里数据必须是引用数据类型的

Stream 流的中间方法：修改流中的数据，不会影响原来集合或者数组中的数据
filter 过滤
limit 获取前几个元素
skip 跳过前几个元素
distinct 元素去重 依赖 hashCode和equals 方法
contact 合并a和b两个流为一个流
map 转换流中的数据类型

filter 过滤
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"张无忌-15","张三丰-115","张敏-15","萧峰-20","虚竹-18")；
list.stream().filter(s->s.startswWith("张")).forEach(s->System.out.println(s));

limit 过滤
list.stream().limit(3).forEach(s->System.out.println(s))
skip  
list.stream().skip(4).forEach(s->System.out.println(s))

distinct
list.stream().distinct().forEach(s->System.out.println(s))
contact
Stream.contact(list1.stream(),list2.stream())

map
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"张无忌-15","张三丰-115","张敏-15","萧峰-20"）;
需求：获取里面的年龄 并进行打印
String->int
//第一个类型：流中原本的数据类型
//第二个类型：表示转换之后的数据
//apply的形参s:依次表示流里面的每一个数据
//返回值：表示转换之后大的数据
当map方法执行完毕之后，流上的数据就变成了整数
list.stream().map(new Function<String,Integer>(){
		@override
		public Integer apply(String s){
			String[] arr = s.split("-");
			String ageString = arr[1];
			int age = Integer.parseInt(ageString);
			return age;
		}
}).forEach(s->System.out.pringln(s))

list.stream().map(s->Integet.parseInt(s.split("-")[1])).forEach(s->System.out.pringln(s));

Stream 终结方法
forEach() 遍历
count() 统计
toArray() 收集流中的数据，放到数组中
collect() 收集流中的数据，放到集合中

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"张无忌-15","张三丰-115","张敏-15","萧峰-20");

list.stream().forEach(new Consumer<String>(){
		@override
		public void accept(String s){
			System.out.println(s);
		}
})
list.stream().forEach(s->System.out.pringln(s))

count：
long count  = list.stream().count();

toArray:创建一个指定类型的数字
底层将流里面的每一个数据放到数组里面
apply 形参：流中数据的个数，和数组长度保持一致
apply返回值 具体类型的数组
String[] arr = list.stream().toArray(new IntFunction<String[]>()
		@override
		public String[] apply(int value){
			return new String[value];
		}
){}

String[] arr2 = list.stream().toArray(value->new String[value])


收集 
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"张无忌-男-15","张三丰-女-115","张敏-女-15","萧峰-20");

收集到list集合
List<String> newList = list.stream().filter(s->"男"。equals(s.split("-")[1])).collect(Collectors.toList());

收集到Set集合当中 会去重
Set<String> newList2 = list.stream().filter(s->"男"。equals(s.split("-")[1])).collect(Collectors.toSet());

收集到Map集合中  注意：键不能重复
   toMap ：参数一表示键的生成规则 
   			参数二表示值的生成规则
   		参数一：
   		Function 泛型一：表示流中每一个数据的类型
   				泛型二：表示Map集合中键的数据类型
   				方法 apply 形参：依次表示流里面的每一个数据
   						方法体：生成键的代码
   						返回值：已经生成的键 			
list.stream().filter(s->"男"。equals(s.split("-")
			.collect(Collectors.toMap( new Function<String,String>(){
									@override
									public String apply(String s){
											return s.split("-")[0];					
									}
				                 },
				            new Function<String,Integer>(){
								@Override
								public  Integer apply(String s){
									return  Integer.parseInt(s.split("-")[2]);
									}
								}     
		))


list.stream().filter(s->"男"。equals(s.split("-")
			.collect(Collectors.toMap(
					s -> s.split("-")[0],
					s -> Integer,parseInt(s.split("-")[2])
						));
	.