day19_0717课堂笔记
day19_0717课堂笔记
1、CML解析
xml解析:读取xml文件中的数据(节点名,属性,节点之间的文本)
package com.wse.xml01;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.util.Iterator;
import java.util.List;
/**
* xml解析:
* 读取xml文件中的数据(节点名,属性,节点之间的文本)
*/
public class XMLDemo01 {
public static void main(String[] args) throws Exception {
String path = "day19_0717/src/persons.xml";
System.out.println(getDecument(path));
print(getDecument(path));
//Document d = modify(getDecument(path));//修改完数据只存储在内存中，文件为修改，需写出
// write(path,d);
//print(getDecument(path));
}
/*
* 写出到指定xml文件
*/
public static void write(String path,Document document) throws Exception {
//1.构建格式器
OutputFormat format = OutputFormat.createPrettyPrint();
//2.构建输出流
XMLWriter writer = new XMLWriter(new FileOutputStream(path),format);
//3、写出
writer.write(document);
writer.flush();
writer.close();
}
/*
* 修改原节点中的内容
* 原结构中添加新节点
* 删除原有节点
* 修改原有属性
*/
public static Document modify(Document document){
//1.获取根节点
Element root = document.getRootElement();
//2.找到Student节点->名字为陈亮 哪一个|id为4的哪一个
List<Element> list = root.elements("Student");
//遍历list,每一个element就是每一个子节点Student
for (Element element:list){
//获取Student节点的属性，id
String id = element.attributeValue("id");
//判断id是否为4
if ("4".equals(id)){
//获取年龄节点
Element age = element.element("age");
//修改年龄节点
int i =Integer.valueOf(age.getText())+1;
age.setText(i+"");
//添加一个新节点subject->java
element.addElement("Subject").setText("java");
}
}
//删除Person节点 父元素.remove(子元素)
root.remove(root.element("Person"));
return document;
}
//创建一个xml,把指定的数据写入xml文件中(1.构建一个Document,完善 document对象,2.把document写到指定文件中)
/*
*
* 北京尚学堂
* 上海尚学堂
*
*/
public static Document createDocument(){
//1.创建Document对象
return null;
}
//遍历获取资源
/**
* 打印xml文档内容的方法
* @param document xml文档
*/
public static void print(Document document) {
//1.获取根节点
Element rootElement = document.getRootElement();
//2.获取子节点
List<Element> elements = rootElement.elements();
//3.遍历子节点
for (Element element : elements) {
String id = element.attributeValue("id");
System.out.println("id=" + id);
//遍历子节点
Iterator<Element> elementIterator = element.elementIterator();
while (elementIterator.hasNext()) {
Element next = elementIterator.next();
System.out.println(next.getName() + "-->" + next.getText());
}
}
}
//获取Document对象
/**
* 获取xml文档的方法
* @param path xml文件路径
* @return xml文档
* @throws DocumentException
*/
public static Document getDecument(String path) throws DocumentException {
//1、指定文件路径
File file = new File(path);
//2构建SAXReader对象
SAXReader reader = new SAXReader();
//3、读取获取Document
Document document = reader.read(file);
return document;
}
}
2、Stream
Stream流
-
stream 是数据渠道，用于操作数据源（集合、数组）所生产的元素序列。
-
集合->数据存储 IO: 数据的传输 Stream:数据的处理 -
特点:
- 1.stream是不能存储数据,只能对数据进行一些列流式的操作
- 2.stream->惰性加载|延迟执行,一系列流式的操作会在要结果的时候一起执行
- 3.不会修改源数据
- 4.每次操作回去得到一个新的流,不能对同一个stream执行多次操作 ,因为源 流操作过以后就被破坏了
-
stream使用步骤:
- 1)获取流 3中方式
- 2)一系列 的中间操作
- 3)终止操作(得到结果)
2.1获取Stream的3中方式
public class Demo01 {
static List<Person> list = Arrays.asList(
new Person("wse", 11, 10000),
new Person("nb", 14, 1000),
new Person("lch", 16, 100),
new Person("znj", 19, 100),
new Person("lch", 17, 100)
);
public static void main(String[] args) {
//获取流
//1.Collection ->stream()
Stream stream = list.stream();
//2.Arrays->stream()
String[] arr = {
"wse","nb"};
Stream<String> stream1 = Arrays.stream(arr);
//3.Stream.of()
Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5);
//4.无限流
Stream<Integer> limit = Stream.iterate(0, (x) -> x + 2).limit(10);
limit.forEach(System.out::println);
}
}
2.2中间操作
package com.wse.stream02;
import com.wse.entify.Person;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
/*
* 筛选与 切片
* filter-接收Lambda，从流中排除某些元素
* Stream filter(Predicate predicate)
返回由与此给定谓词匹配的此流的元素组成的流。
* limit-截断流，使其元素不超过给定数量
* Stream limit(long maxSize)
返回由此流的元素组成的流，截短长度不能超过 maxSize 。
*
* skip-跳过元素，返回一个扔掉了前n个元素的流，若流中元素不足n个，则返回一个空流。
* Stream skip(long n)
在丢弃流的第一个 n元素后，返回由该流的 n元素组成的流。
*
* distinct-筛选，通过流所生产元素的hashCode()和equals()去除重复元素
* Stream distinct()
返回由该流的不同元素（根据 Object.equals(Object) ）组成的流。
*
*排序
* 1. sorted(Comparable)-自然排序
* Stream sorted()
返回由此流的元素组成的流，根据自然顺序排序。
* 2. sorted(Comparator)-定制排序
* Stream sorted(Comparator comparator)
返回由该流的元素组成的流，根据提供的 Comparator进行排序。
*
*/
public class Demo02 {
static List<Person> list = Arrays.asList(
new Person("胡歌",35,20000),
new Person("彭于晏",33,15000),
new Person("刘畅",20,10),
new Person("姜亚坤",25,100),
new Person("姜亚坤",23,1000),
new Person("姜亚坤",23,1000)
) ;
public static void main(String[] args) {
//1.filter-接收Lambda，从流中排除某些元素Stream filter(Predicate predicate)
//返回由与此给定谓词匹配的此流的元素组成的流。
//处理集合，获取年龄大于30的Person
Stream<Person> personStream = list.stream().filter((e) -> e.getAge() > 30);
personStream.forEach(System.out::println);
/*Person [name=胡歌, age=35, salary=20000.0]
Person [name=彭于晏, age=33, salary=15000.0]*/
System.out.println("==============================");
//2.limit-截断流，使其元素不超过给定数量,获取集合中前三个Person
list.stream().limit(3).forEach(System.out::println);
/* Person [name=胡歌, age=35, salary=20000.0]
Person [name=彭于晏, age=33, salary=15000.0]
Person [name=刘畅, age=20, salary=10.0]*/
System.out.println("=====================");
//3.skip-跳过元素，返回一个扔掉了前n个元素的流，若流中元素不足n个，则返回一个空流。
list.stream().limit(2).skip(1).forEach(System.out::println);
// Person [name=彭于晏, age=33, salary=15000.0]
System.out.println("------------------------------------");
//4.distinct-筛选，通过流所生产元素的hashCode()和equals()去除重复元素
list.stream().filter((e)->e.getAge()<30).distinct().forEach(System.out::println);
//获取list中左右人的姓名
List<String> list1 = new ArrayList<>();
for (Person p :list){
list1.add(p.getName());
}
System.out.println(list1);//[胡歌, 彭于晏, 刘畅, 姜亚坤, 姜亚坤, 姜亚坤]
//容器进行去重
//准备新容器
List<String> names = new ArrayList<>();
for (String s :list1){
//如果新容器中不包含就放入
if (!names.contains(s)){
names.add(s);
}
}
System.out.println(names);//[胡歌, 彭于晏, 刘畅, 姜亚坤]
/*Stream sorted()
返回由此流的元素组成的流，根据自然顺序排序。*/
names.stream().sorted().forEach(System.out::println);
//按年龄倒叙排列
list.stream().sorted((e1,e2)->e2.getAge()-e1.getAge()).forEach(System.out::println);
}
}
2.3终止操作
package com.wse.stream02;
import com.wse.entify.Person;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
/*终止操作:
* 查找于匹配
* *boolean allMatch(Predicate predicate)
返回此流的所有元素是否与提供的谓词匹配。
* boolean anyMatch(Predicate predicate)
返回此流的任何元素是否与提供的谓词匹配。
*boolean noneMatch(Predicate predicate)
返回此流的元素是否与提供的谓词匹配。
* Optional findAny()
返回描述流的一些元素的Optional如果流为空，则返回一个空的Optional 。
*Optional findFirst()
返回描述此流的第一个元素的Optional如果流为空，则返回一个空的Optional 。
*/
public class Demo04 {
static List<Person> list = Arrays.asList(
new Person("胡歌",35,20000),
new Person("彭于晏",33,15000),
new Person("金城武",38,11000),
new Person("吴彦祖",40,16000),
new Person("刘畅",21,10),
new Person("姜亚坤",25,100),
new Person("姜亚坤",25,100));
public static void main(String[] args) {
//判断集合中Person的年龄是否全部大于20
boolean flag = list.stream().allMatch((e) -> e.getAge() >= 20);
System.out.println(flag);//true
//判断是否有Person的薪资大于20000
boolean flag1 = list.stream().anyMatch((e) -> e.getSalary() > 20000);
System.out.println(flag1);//false
//判断是不是没有人的薪资大于10000
boolean flag2 = list.stream().noneMatch((e) -> e.getSalary() > 10000);
System.out.println(flag2);//false
//获取年龄最大的值
Optional<Integer> max = list.stream().map(Person::getAge).sorted((x, y) -> y - x).findFirst();
System.out.println(max.get());//40
//获取任意一个人名 collection提供的并行流parallelStream()
Optional<String> any = list.parallelStream().map(Person::getName).findAny();
System.out.println(any.get());
//count() 一个有多少人
long count = list.stream().count();
System.out.println(count);//7
//max()获取薪资最高的人
Optional<Person> max1 = list.stream().max(Comparator.comparingDouble(Person::getSalary));
System.out.println(max1.get());
}
}
2.4map()
package com.wse.stream02;
import com.wse.entify.Person;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
/*
* map(Function mapper))
* 把流中的数据,当做apply(T t) 方法参数传递,经过运算,最终返回一个结果,map方法租后会返回一个包含着新结果的流
* flatMap() 会把多个流合并成一个流
*/
public class Demo03 {
static List<Person> list = Arrays.asList(
new Person("胡歌",35,20000),
new Person("彭于晏",33,15000),
new Person("金城武",38,11000),
new Person("吴彦祖",40,16000),
new Person("刘畅",20,10),
new Person("姜亚坤",25,100),
new Person("姜亚坤",25,100));
public static void main(String[] args) {
List<String> ls = Arrays.asList("aaa","bbb","ccc");
// Stream map(Function mapper)
//返回由给定函数应用于此流的元素的结果组成的流。
ls.stream().map(String::toUpperCase).forEach(System.out::println);
//获取所有的姓名给然后去重打印
list.stream().map(Person::getName).distinct().forEach(System.out::println);
//把字符串中的每一个字符遍历打印 {
{a,a,a},{b,b,b},{c,c,c}}
Stream<Stream> streamStream = ls.stream().map(Demo03::strHandler);
streamStream.forEach((e)->{
e.forEach(System.out::println);
});
//flatMap() {a,a,a,b,b,b,c,c,c}
// Stream flatMap(Function> mapper)
//返回由通过将提供的映射函数应用于每个元素而产生的映射流的内容来替换该流的每个元素的结果的流。
ls.stream().flatMap(Demo03::strHandler).forEach(System.out::println);
}
public static Stream strHandler(String str){
List<Character> list1 = new ArrayList<>();
char[] chars = str.toCharArray();
for (char c :chars){
list1.add(c);
}
return list1.stream();
}
}
2.5规约与收集
package com.wse.stream02;
import com.wse.entify.Person;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
/*
* 规约与收集
* reduce: 根据指定的运算,把流中的数据进行反复的结合,最终得到一个结果
*/
public class Demo05 {
static List<Person> ls = Arrays.asList(
new Person("胡歌",35,20000),
new Person("彭于晏",33,15000),
new Person("金城武",38,11000),
new Person("吴彦祖",40,16000),
new Person("刘畅",20,10),
new Person("姜亚坤",25,100),
new Person("姜亚坤",25,100));
public static void main(String[] args) {
List<Integer> l = Arrays.asList(1,2,3,4,5,6,7);
//求所有数的和
Integer sum = l.stream().reduce(0, (x, y) -> x + y);
System.out.println(sum);
//求所有薪资的和
Optional<Double> reduce = ls.stream().map(Person::getSalary).reduce(Double::sum);
System.out.println(reduce.get());
Optional<Integer> reduce1 = ls.stream().map(Person::getAge).reduce(Integer::sum);
System.out.println(reduce1.get());
String str = "abcskhlksakjahaskdfhlk";
//统计a出现的次数
List<Character> list1 = new ArrayList<>();
char[] chars = str.toCharArray();
for (char c: chars){
list1.add(c);
}
System.out.println(list1);
Optional<Integer> reduce2 = list1.stream().map((e) -> {
if (e.equals('a')) {
return 1;
} else {
return 0;
}
}).reduce((x, y) -> x + y);
System.out.println(reduce2.get());
}
}