【Java】Java学习笔记11-List Set Queue Map 工具类

最新推荐文章于 2024-07-27 13:31:57 发布

离澈澈澈

最新推荐文章于 2024-07-27 13:31:57 发布

阅读量133

点赞数

文章标签： java

本文链接：https://blog.csdn.net/liche33/article/details/104445614

版权

集合

（一）Collection接口

第一个级别的（见笔记10）

（二）List接口

第二个级别的还有Set

Collection下有两个子接口：是为了实现接种不同的规范

List：有序（和放入元素的顺序相同）

Set：是否有序、无序（也要取决于实现类）、不可以放入重复元素

1.List接口的常用实现类

ArrayList（底层使用动态实现类）：适合做查询

LinkedList（底层使用链表实现）：适合做添加、删除元素，不适合做查询

2.ArrayList创建集合对象，相关方法

跟Collection接口多出来的方法

（注意比较，为什么Collection没有？跟Set接口的实现）

public class Day14_1_List {
  public static void main(String[] args) {
	List<Integer> list=new ArrayList<>();
//	1.addAll(int index,其他集合) 能够将参数集合插入到原集合对象中的index位置。
	for (int i = 0; i < 10; i++) {
		list.add(i);
	}
	List<Integer> list2=new ArrayList<>();
	list2.add(100);
	list2.add(200);
	list.addAll(5, list2);
	list.forEach(System.out::println);
	
//	[思考] Collction没有这个方法？ 
//	如果Collction有这个方法，那么意味着Set和List都会继承这个方法。
//	Set本身元素是无序的， 所以没有index
	
	
//	2.add(int index ,e)  将参数的元素插入到集合中指定的位置
	list.add(5, 100);
	list.forEach(System.out::println);
	
//	list.add(e)是Collction接口下的方法  对于List 和Set的规范来说一致，只是具体规则不同。
	
	
//	3.remove(int index) 根据位置删除某一个元素，并返回该元素
	System.out.println(list.remove(5));
	list.forEach(System.out::println);
	
//	4.remove(Object o) 根据元素内容删除某一个元素。
	list.remove(Integer.valueOf(100));
	list.forEach(System.out::println);
	
//	5. set(int index,e) 指定一个位置index上的元素，为e
	list.set(5, 100);
	list.forEach(System.out::println);
	
//	6.replaceAll()根据某一个规则，替换掉所有符合规则的元素
//	UnaryOperator<Integer>接口：规则：传入一个old元素，传出有一个new元素
	list.replaceAll((t)->t+100);
	list.forEach(System.out::println);
//	
//	list.replace  set就可以设置某一个元素的值是另外一个值。
		
//	7.get(int index)返回参数指定位置上的元素
	System.out.println(list.get(0));
	
//	8.indexof(元素)  返回参数在集合中第一次出现的位置 ，如果不存在则返回-1
//	lastIndexOf    返回参数在集合中最后一次出现的位置
	list.set(6, 600);
	System.out.println(list.indexOf(Integer.valueOf(600)));
	System.out.println(list.lastIndexOf(600));
	
	
//	9.sort(比较器接口)
	list.set(6, -6);
	list.sort(null);  //按照自然排序  元素对象的Comparable接口
	list.forEach(System.out::println);
	
	list.sort((t1,t2)->t2-t1);
	list.forEach(System.out::println);
	
//	10.subList(fromIndex, toIndex) 根据位置获取list的子集
//	包含开头不包含结束
	List<Integer> l=list.subList(2, 6);
	l.forEach(System.out::println);
	
//	11.listIterator list 迭代器
	
//3.关于list实现类对象的迭代器
	ListIterator<Integer> li=list.listIterator();
	ListIterator<Integer> li2=list.listIterator(2);//可以指定参数，指定指针位置
//	跟之前的Iterator迭代器对象对比来看多出来的功能：扩充了Iterator接口的功能。
//	可以获取前一个元素(索引、元素、是否有前一个元素、set  add )
//	(1)hasPrevious（）判断是否有前一个元素
	System.out.println(li.hasPrevious());
	System.out.println(li2.hasPrevious());
	
//	(2)Previous（）获得前一个元素，指针会移动（next()）指针也会移动
	System.out.println(li2.previous());
	System.out.println(li.previous());
	
//	(3)nextIndex 获得下一个元素的位置   :指针不动 
	previousIndex获得上一个元素的位置  :指针不动
	
	System.out.println(li2.nextIndex());//2
	System.out.println(li.nextIndex());//0
	ListIterator<Integer> li2=list.listIterator(10);
//	list.listIterator(10)参数含义：调用next方法 时候，即将获取的元素位置。
	System.out.println(li2.previous());//9
	System.out.println(li2.previousIndex());//8
	
//	(4)remove: 最后一次调用next返回的元素，最后一次previous，返回的元素
//	如果没有前驱或者没有后继，调用会报错
	ListIterator<Integer> li2=list.listIterator(10);
	System.out.println(li2.previous());//9
	System.out.println(li2.previous());//8
	System.out.println(li2.previous());//7
	li2.remove();
	while(li2.hasPrevious()){
		System.out.println(li2.previous());
	}
	while(li2.hasNext()){
		System.out.println(li2.next());
	}
    
	list.forEach(System.out::println);
	//迭代器是list对象的底层数据结构，如果删除了某个元素，则list对象也是被改变
	
//	(5)set（元素e）当前操作的元素修改成e （最后一次调用的next，最后一次调用previous）
	ListIterator<Integer> li2=list.listIterator(10);
	System.out.println(li2.previous());//9
	li2.set(5000);//将9这个位置的元素修改成e
	
	ListIterator<Integer> li2=list.listIterator();
	li2.next();
	li2.set(5000);
	System.out.println(li2.previous());
	list.forEach(System.out::println);

//	(6)add(元素e) 下一次调用next方法，返回元素的前面 加入e
	ListIterator<Integer> li2=list.listIterator(10);
	System.out.println(li2.next());
    li2.previous();
    li2.add(5000);
    System.out.println(li2.previous());
    
	li2.add(6000);
	System.out.println(li2.next());
	System.out.println(li2.previous());
	
	list.forEach(System.out::println);
	
	
其他的实现类：Linkedlist 和ArrayList区别
	List<Integer> listA=new ArrayList<>();
	List<Integer> listL=new LinkedList<>();
//	对象下的方法几乎完全一致，但是底层存储不一样。
//	ArrayList 动态数组
//	LinkedList 采用链表
//  }
//}

（三）Set接口

Set继承了Collection接口，相对于List来说，Set原接口：不可重复，但是是否有序，取决于子接口
常用实现类：
(1)HashSet：注重于元素不可重复
(2)LinkedHashSet：继承HashSet，内部使用链表来存储数据结构。所以可以有序（进入元素顺序和出去的顺序一致）
(3)TreeSet: 用来实现Set的子接口（SortedSet、NavigableSet）

1.HashSet

最普通的实现Set 的实现类：注重于元素不可重复
底层数据结构来实现：采用哈希码来决定每个元素存储的位置。
不能重复：hash码不能重复
没有顺序：hash码产生的规则，来存储元素，不能够保证元素本身的大小确定存储位置的前后。
虽然没有顺序，但是每一次输出的结果是一致的（set的同一性，每一次规则得到的都是一致）

public class Day14_1_List {
public static void main(String[] args) {
	  Set<Integer> set=new HashSet<>();
	  set.add(1000);
	  set.add(500);
	  set.add(10);
	  set.add(100000);
	  set.forEach(System.out::println);
}
}

2.LinkedHashSet

继承了HashSet，底层使用双向链表来维护元素的顺序。

public class Day14_1_List {
	  public static void main(String[] args) {
		  Set<Integer> set=new LinkedHashSet<>();
		  set.add(1000);
		  set.add(500);
		  set.add(10);
		  set.add(100000);
		  set.forEach(System.out::println);
	  }
}

3.SortedSet

Set的子接口SortedSet

不仅仅有序，同时还要求放入的元素必须是可排序的元素
【可排序元素】：（1）元素对象实现Comparable接口 (2) SortSet，实现类中，加入Compartor比较器
任选其一。
（1）创建（实现比较的功能）：想创建SortedSet对象成功，必须遵循元素可排序
实现类【TreeSet】

class Person implements Comparable<Person>{
class Person {
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	@Override
	public int compareTo(Person o) {
		return o.getAge()-this.getAge();//大到小
	}
}
public class Day14_1_List {
public static void main(String[] args) {
//	  Integer内部实现了Comparable下面compareTo方法
//	  SortedSet<Integer> set=new TreeSet<>();
//	  set.add(1000);
//	  set.add(500);
//	  set.add(10);
//	  set.add(100000);
//	  set.forEach(System.out::println);
	  
//	  方式一：元素放入Person对象(可以自己Person下实现Comparable)
//	  SortedSet<Person> set=new TreeSet<>();
//	  set.add(new Person("张三1",20));
//	  set.add(new Person("张三2",30));
//	  set.add(new Person("张三3",40));
//	  set.forEach(System.out::println);
	  
//	  方式二：也可以在创建TreeSet对象时指定Comparator比较器
	  SortedSet<Person> set=new TreeSet<>((p1,p2)->p2.getAge()-p1.getAge());
	  set.add(new Person("张三1",20));
	  set.add(new Person("张三2",30));
	  set.add(new Person("张三3",40));
	  set.forEach(System.out::println);
	  
//	  如果两种方式都有，则方式二覆盖方式一
}
}

（2）SortedSet接口下的方法

public class Day14_1_List {
public static void main(String[] args) {
	SortedSet<Integer> set=new TreeSet<>();
//	1.set.comparator();//返回TreeSet对象的比较器
//	System.out.println(set.comparator());
	
//	2.subset(startE,endE) 返回子集
//	startE:开始元素(不是索引，是元素)
//	endE  ：结束元素（不包含）
//	元素不存在也不会报错
	set.add(100);
	set.add(300);
	set.add(200);
//	SortedSet<Integer> sub=set.subSet(100, 300);
//	SortedSet<Integer> sub=set.subSet(100, 10000);
//	sub.forEach(System.out::println);
	
//	3. headset(元素) ：返回前n个元素（参数是元素， 不是位置）， 但是不包含第n元素
//	set.headSet(300).forEach(System.out::println);
	
//	4.tailset(元素)：返回后n个元素，包含第n个元素
	set.tailSet(100).forEach(System.out::println);
	
//	5.first\last返回第一个元素、返回最后一个元素（sorted）
	System.out.println(set.first());
	System.out.println(set.last());
}
}

4.SortedSet/NavigableSet

Set的子接口SortedSet，SortedSet的子接口NavigableSet
对于SortedSet的扩展（有序、必须排序、多了扩展方法）

public class Day14_1_List {
	public static void main(String[] args) {
		NavigableSet<Integer>  set=new TreeSet<>();
		for (int i = 0; i < 10; i+=2) {
			set.add(i);
		}
//		1.lower(e)元素e，返回比e小一号的值
		System.out.println(set.lower(5));
		
//		2.floor(e) 小于等于参数e的值
		System.out.println(set.floor(5));
		
//		3.higher(e) 大于参数e一号的值： 
		System.out.println(set.higher(5));
		
//		4.ceiling(e) 大于等于参数e的值
		System.out.println(set.ceiling(5));
		
//		
//		5.set.pollFirst() 返回最小值，而且删除这个值
//		System.out.println(set.pollFirst());
//		System.out.println("=======");
		set.forEach(System.out::println);
		
//		6.set.pollLast() 返回最大值，而且删除这个值
//		System.out.println(set.pollLast());
//		System.out.println("=======");
//		set.forEach(System.out::println);
		Iterator<Integer> it=set.descendingIterator();//获得逆序的迭代器
		it.forEachRemaining(System.out::println);
	}
}

（四）Queue队列

第一个：Queue接口
java下的Queue接口，对应于数据结构中的：堆栈、队列
实现类不同，接口不同

使用实现类：LinkedList PriorityQueue （非阻塞，没有容量）
队列实现类不仅仅包含上面两种：阻塞、非阻塞
LinkedList : 先进先出 —队列
PriorityQueue：优先队列—可以实现堆栈的效果，甚至高于堆栈的效果

public class Day14_2_Queue {
  public static void main(String[] args) {
//	1. 创建
	  Queue<Integer> q1=new LinkedList<>();//LinkedList  1.2
	  Queue<Integer> q2=new PriorityQueue<>();//PriorityQueue1.5 
	  Queue<Integer> q3=new ArrayBlockingQueue<>(5);

//	2.相关方法
//	  （1）add 添加元素。如果成功添加则返回true，否则，添加失败会报错。
//	  q1.add(1);
	  q2.add(1);
//	    offer 跟add一样，不同就是如果添加失败返回false
	  q2.offer(2);
	  q2.offer(3);
	  q2.offer(4);
	  q2.add(null); 
	  q1.add(null);  null对于队列来说，不允许放入null的元素。
	 
//	  （2）remove 删除队列头部元素，如果删除失败，报错
	  q2.remove();
	  System.out.println(q2.poll()) ;//实现了删除的功能，但是如果删除失败，会返回null
	 
//	  (3)element() 返回队列头部的元素  如果失败则抛异常
//	     peek() 失败反会null
	  System.out.println(q2.element());
	 
	  while(q2.size()>0){
			 System.out.println(q2.poll());
	  }
	  System.out.println(q2.poll());
	 
//	 3.优先队列自定义排序
//	  构造器下实现比较器
	  Queue<Integer> q2=new PriorityQueue<>((a,b)->b-a);
	  q2.add(200);
	  q2.add(50);
	  q2.add(-50);
	  q2.add(80);
	  while(q2.size()>0){
		  System.out.println(q2.poll());//才可以按照顺序（比较器的顺序）进行输出
      }

	  q2.forEach(System.out::println);//不能够输出达到排序的效果

第二个：Deque接口：双端队列
可以实现队列的效果，也可以实现堆栈的效果。
实现类也可以使用LinkedList

	  Deque<Integer> q=new LinkedList<>();
	  q.addLast(1);
	  q.addFirst(100);
	 
//	  Deque可以实现堆栈的功能。单独实现了对于堆栈的方法
	  q.push(200);
	  q.pop();  //q.remove();
	 
//	  [实现类]LinkedList 、ArrayDeque
//	           双向链表      数组实现
	}
}

（五）Map接口

Map接口对应的实现类中，存储的是很多个键值对：（两个元素对象）
key：键
value：值
key不能重复：因为key的底层是使用set来实现。
Map<K,V>
实现类：
（1）HashMap
（2）LinkedHashMap
（3）TreeMap(用来实现子接口 SortedMap，NaviableMap)

注意，就是跟之前set不同，在于每个元素都是键值对，针对的是否可排序、有序，针对key来说的。

 public class Day14_3_Map {
   public static void main(String[] args) {
//	   1.创建
//	   HashMap为例：无序、key不可重复的
	   Map<Integer,Integer> map=new HashMap<>();	
	   
//     2.相关方法
//	   （1）put(key,value)加入键值对
	   map.put(1, 100);
	   map.put(2, 200);
	   map.put(1, 1000);
	   
//	   get(key)获取键值对---根据key获取值 ,得到value
	   System.out.println( map.get(1));
	   System.out.println( map.get(2));
	   
//	  (2) map.putAll(m); 将参数指定的键值对，放入到当前map对象中
	   Map<Integer,Integer> map1=new HashMap<>();	
	   map1.put(10, 10000);
	   map1.put(1, 20000);
	   map.putAll(map1);
	   System.out.println(map.get(10));
	   System.out.println(map.get(1));
	   
//	   put方法，只要key相同，就会覆盖掉
//	   (3)map.putIfAbsent(key, value) 当key不存在的时候，就会加入键值对
//	   如果已经存在，则不会加入
	   map.putIfAbsent(3, 300);
	   System.out.println(map.get(3));
	   
//	  (4) remove(key) 根据key删除指定的键值对，同时返回删除key对应的value
//	   System.out.println(map.remove(3));
//	   System.out.println(map.get(3));
	   System.out.println("========");
//	   （5）remove（key,value） 根据key和value删除键值对。
//	   map.remove(3, 200);
	   map.remove(3, 300);
	   System.out.println(map.get(3));
	  
//	  (6) clear清空键值对
//	   map.clear();
//	   System.out.println(map.size());
	   
//	   (7)getOrDefault(key,defaultValue) 
//	      如果key不存在，则使用defaultValue来代替value输出
	   System.out.println(map.getOrDefault(1, 999));
	   
//	   (8)size 返回键值对的格式
//	   （9）map.isEmpty()判断map是否没有键值对
	   System.out.println(map.isEmpty());
	   
//	   (10) map.containsKey(key) 判定是否包含指定的key
//	   （11）map.contatinsValue(value) 判定是否包含指定的value
	   System.out.println(map.containsKey(1));
	   System.out.println(map.containsValue(999));
	   
//	  (12)获取全部的键，全部的值
//	   map.keySet()
//	   map.values()
	   System.out.println(map.keySet());
	   System.out.println(map.values());
	   
//	   (13)获取全部的键值对
	   Set<Map.Entry<Integer, Integer>> entry=  map.entrySet();
	   System.out.println(entry);
	   for (Map.Entry<Integer, Integer>  e: entry) {
		   System.out.println(e.getKey()+":"+e.getValue());
	   }
	   
//	   (14) map.replace(key, value)  使用参数key到map中找到对应的键值对，将value替换原来的value
	   map.replace(2, 20000);
	   System.out.println(entry);
	  
//	   (15) map.replace(key, oldValue, newValue)  根据key和oldvalue找键值对，使用newValue来替换值
	   map.replace(2, 50000, 40000);
	   System.out.println(entry);
	   
//	   (16)map.replaceAll(BiFunction接口（ k,v,newvalue）);
//	   将键值为k和v 将它的v替换成newvalue
	   map.replaceAll((k,v)->v*100);
	   System.out.println(entry);
	   
//	   (17) map.computeIfAbsent(key, mappingFunction) 按照规则加入不存在的键值对
//	   如果存在，则不会进行更新value
	   map.computeIfAbsent(4, (k)->k*10000);
	   System.out.println(entry);
	   
//	   (18)map.computeIfPresent(key, remappingFunction) 
//	   如果key存在，而且在方法中，调用到key和value的值。则使用计算的值来替换原来的值
	   map.computeIfPresent(4, (k,v)->k+1);
	   System.out.println(entry);
	   
//	   (19)map.compute(key, remappingFunction) 无论key是否存在，都会使用function
//	   计算之后的值替换oldvalue。如果不存在 ，则追加键值对
	   map.compute(100, (k,v)->k+5);
	   System.out.println(entry);
	   
	  
//	   (20)map.merge(key, value, remappingFunction) 合并
//	   如果key不存在，则使用参数value当value
//	 如果key存在，则使用function计算出来的newvalue来替换原来的oldvalue
//	   注意：新计算的值，里面的参数使用的全部都是oldvalue
	   map.merge(200, 600, (k,v)->k+10);
	   System.out.println(entry);
	   map.merge(200, 600, (k,v)->k+10);
	   System.out.println(entry);
	   
//3. 遍历
//	   三种方式 
//	   (1)keyset
	   Set<Integer> s=map.keySet();
	   s.forEach(k->System.out.println(k+":"+map.get(k)));
	   
//	   (2)entryset
	   Set<Map.Entry<Integer, Integer>>  set2=map.entrySet();
//	   [(key1:value1),(key2:value2),(key3:value3) ]
	   set2.forEach(e->System.out.println(e.getKey()+":"+e.getValue()));
	   
//	   (3)forEach   
	   map.forEach((k,v)->System.out.println(k+":"+v));
	   //map.forEach((k,v)->System.out::prinln); 不能简化。  接口参数和system参数一致，都是一个
	   
	   
//4. 子接口SortedMap（地位跟SortedSet类似）	 
//	 继承了Map接口，另行创建的新接口 必须要放入可排序的元素
	   
//	【可排序】对于key可排序
//	   SortedMap<Integer,Integer> tmap=new TreeMap<>();
	   SortedMap<Integer,Integer> tmap=new TreeMap<>((k1,k2)->k2-k1);
	   tmap.put(1, 100);
	   tmap.put(2, 200);
	   tmap.put(5, 500);
	   tmap.put(3, 300);
	   tmap.put(4, 400);
	   System.out.println(tmap.entrySet());
	   
	   
	   
	   
	   
//5. 子接口NavigableMap 继承SortedMap子接口（地位跟NavigableSet类似）	
//	   提供了导航方式，可以找到大一号、小一号的元素。。。
	   NavigableMap<Integer,Integer> tmap1=new TreeMap<>();
	   tmap1.put(1, 100);
	   tmap1.put(2, 200);
	   tmap1.put(5, 500);
	   tmap1.put(3, 300);
	   tmap1.put(4, 400);
   }
}

（六）工具类

Arrays 工具：针对于数组的一系列操作
Collections工具：针对于集合的工具类

1.Arrays

(1)sort
(2)asList(数组对象)：将数组对象转换成集合

public class Day15_1_ToolClass {
public static void main(String[] args) {
//	不能将1，2,3,4转换成集合类型，能够把整个数组当成一个元素转换成集合类型的一个元素
//	int [] t=new int[]{1,2,3,4};
	
//	能够Integer[] 转换成集合类型，数组中的每个元素，对应集合中的每个元素
	Integer [] t=new Integer[3];
	t[0]=200;
	t[1]=300;
	t[2]=400;
	List<Integer> list=Arrays.asList(t);//转换成“假”arraylist对象
//	list.add(500);
//	list.forEach(System.out::println);
//	ArrayList
//	使用的时候需要注意的地方：
//	asList方法获得的集合，不是原本ArraysList，而是Arrays下面自定义内部类，
//	这个内部类也继承AbstractList类实现了一部分接口，但是，内部真正重写方法很少。
//	没有扩容以及删除元素的方法。
	
//	放入到数组中？ 长度不变、访问速度要求很快。
//	如果asList设计成直接返回ArraysList（原本），返回对象会很大。
	
//	设计者将返回值设置成了，Arrays下的内部类ArrayList
//	【造成的问题】无法扩容、删除元素
//	Collection接口addAll
	List<Integer> linew=new ArrayList<>();
	linew.addAll(list);//将假的arrayllist对象放入到真的arraylist
	linew.add(500);
	linew.forEach(System.out::println);
}
}

2.Collections工具类

专门为集合提供的一系列方法，很多方法都是静态的，（跟Arrays类似）

class Person implements Comparable<Person>{
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public int compareTo(Person o) {
		return this.getAge()-o.getAge();
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
}
public class Day15_1_ToolClass {
	public static void main(String[] args) {
		List<Integer> list=new ArrayList<>();
		list.add(100);
		list.add(-200);
		list.add(300);
		list.add(400);
		
		

```
	//（1）sort  排序（要求实现comparable接口，实现comparator比较器）
	Collections.sort(list);
	list.forEach(System.out::println);
	
	List<Person> listp=new ArrayList<Person>();
	listp.add(new Person("张三",20));
	listp.add(new Person("张三1",30));
	listp.add(new Person("张三2",40));
```

//		Collections.sort(listp);
		Collections.sort(listp, (p1,p2)->p1.getAge()-p2.getAge());
		listp.forEach(System.out::println);
		
//		（2）binarySearch
		System.out.println(Collections.binarySearch(list, -100));
		
//		(3)reverse反转
		Collections.reverse(list);
		list.forEach(System.out::println);
		
//		(4)shuffle 洗牌
		Collections.shuffle(list);
		list.forEach(System.out::println);
		
//		(5)fill填充 将所有的元素都填充成第二个参数
//		Collections.fill(list, 1000);
//		list.forEach(System.out::println);
		
		
//		（6）min  max
		System.out.println(Collections.max(list));
		System.out.println(Collections.min(list));
		System.out.println(Collections.max(listp,(p1,p2)->p1.getAge()-p2.getAge()));
//		System.out.println(Collections.min(listp));
		
//		(7)frequency
		list.add(100);
		System.out.println(Collections.frequency(list, 100));
		
//		(8)replaceAll
		Collections.replaceAll(list, 100, 10000);
		list.forEach(System.out::println);
	}
}

（七）聚合操作

【概念】对于集合元素，进行一连串相关操作（过滤、映射、迭代），跟数据库中聚合函数（min max count）
多条记录的结果合成一个。区别在于，java中的聚合操作，结果不一定是将多条记录合成一条记录，也有可能是扩展、过滤

【管道】一序列顺序的聚合操作，叫成管道，管道包括多个操作。（1,2,3,4,5）
多个操作又分为两类：中间操作，终端操作
【流】是一个元素序列，聚合操作通过流来进行操作的。
看成是传送带上面的被处理元素。
被处理：可以添加元素、修改元素、删除元素

聚合操作跟普通的迭代访问区别
例如：foreach
（1）对比来说，两种操作都可以输出数据源中的元素。
（2）不同：
第一：外部迭代器对集合进行操作，使用是数据源（集合对象下迭代器）来进行迭代。
聚合操作，使用的的内部迭代方式（list.stream(),内部迭代器）
第二：外部迭代器迭代元素之后，可以对数据的底层元素进行修改操作。
聚合操作是通过流来进行运算，不会将数据的源数据进行修改（相当于流数据是复制的数据）

class Dog{
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Dog(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Dog other = (Dog) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	@Override
	public String toString() {
		return "Dog [name=" + name + ", age=" + age + "]";
	}
	
	
}
public class Day15_2_stream {
	public static void main(String[] args) {
		List<Integer> list=new ArrayList<>();
		for(int i=0;i<10;i++){
			list.add(i);
		}
		外部集合下的迭代器访问元素(使用外部迭代器)
//		list.forEach(System.out::println);
		stream内部迭代器（流内部的迭代器）
//		list.stream().forEach(System.out::println);
		
//	3.聚合操作（中间操作）
//	(1)filter过滤
		//对流的操作不修改数据源
		list.stream().filter(t-> t>=5).forEach(System.out::println);
//		list.forEach(System.out::println);
	list.removeIf(t->t<5);
//		list.forEach(System.out::println); 使用list下的方法，相当于修改了数据源
	
//    （2）map、mapToInt  mapToLong
//	    map映射的意思，将一个值，映射成一个特定的值
		List<Dog> listp=new ArrayList<>();
		listp.add(new Dog("abc",2));
		listp.add(new Dog("bcd",13));
		listp.add(new Dog("def",4));
		listp.add(new Dog("def1",6));
		listp.add(new Dog("def2",10));
		
//		函数式编程
//		listp.stream().filter(d->d.getAge()<4).map(d->"名字："+d.getName()).forEach(System.out::println);;
		
		
//	 (3) distinct 去重重复
//		distinct使用是equals比较
//		listp.stream().distinct().forEach(System.out::println);
		
//	(4)sorted排序
//		listp.stream().mapToInt(d->d.getAge()).sorted().forEach(System.out::println);
//		listp.stream().sorted((d1,d2)->d1.getAge()-d2.getAge()).forEach(System.out::println);
//		
//	(5) peek
//		跟foreach实现的功能一样，只不过中间操作，不是终端操作。
//		listp.stream().mapToInt(d->d.getAge()).sorted().forEach(System.out::println);
//		void forEach(IntConsumer action);
//  	IntStream peek(IntConsumer action);
//		listp.stream().mapToInt(d->d.getAge()).sorted().peek(System.out::println);

//	(6)limit(maxsize)做一个限制  如果集合中元素的个数>limit个数，其余的删除
//		listp.stream().limit(2).forEach(System.out::println);
		
//	(7)skip(n) 跳过元素，n代表跳过n个元素之后才输出
		listp.stream().skip(2).forEach(System.out::println);
	
		
//	4.缩减操作——终端操作
//		（1）max
		System.out.println(listp.stream().mapToInt(d->d.getAge()).max().getAsInt());
		System.out.println(listp.stream().max((d1,d2)->d1.getAge()-d2.getAge()));
		
//		（2）min
		System.out.println(listp.stream().mapToInt(d->d.getAge()).min().getAsInt());
		System.out.println(listp.stream().min((d1,d2)->d1.getAge()-d2.getAge()));
		
//		（3）sum
		int v=listp.stream().mapToInt(d->d.getAge()).sum();
		System.out.println(v);
		
//		（4）count 个数
		System.out.println(listp.stream().mapToInt(d->d.getAge()).count());
		System.out.println(listp.stream().count());
		
//		（5）average
		System.out.println(listp.stream().mapToInt(d->d.getAge()).average());
		
		
//		（6）reduce
//		合二为一
//		{1,2,3,4,5}
//		 a b    条件 +
//		 1 2    
//		 3 3
//		 6 4
//		 10 5
//		 15
		System.out.println(listp.stream().mapToInt(d->d.getAge()).reduce((a,b)->a+b).getAsInt());
//		获取最大值或者最小值的工功能
		System.out.println(listp.stream().mapToInt(d->d.getAge()).reduce((a,b)->a>b?a:b).getAsInt());
		System.out.println(listp.stream().mapToInt(d->d.getAge()).reduce((a,b)->a<b?a:b).getAsInt());
}
}

离澈澈澈

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【Java】Java学习笔记11-List Set Queue Map 工具类

集合（一）Collection接口第一个级别的（见笔记10）（二）List接口第二个级别的还有Set Collection下有两个子接口：是为了实现接种不同的规范 List：有序（和放入元素的顺序相同） Set：是否有序、无序（也要取决于实现类）、不可以放入重复元素1.List接口的常用实现类 ArrayList（底层使用动态实现类）：适合做查询 Lin...
复制链接

扫一扫