JavaSE 基础笔记

//psvm
public static void main(String[] args) {
	//sout
    System.out.println()
}

public class 类名称{
  //属性
  数据类型1 数据名称1；//成员变量
  static 数据类型2 数据名称2；//类变量
  //服务（方法）
  返回类型 方法名称(形参){
    数据类型3 数据名称3；//局部变量
    具体服务；
  }

}

class Student {
    String name;   //学生类的属性
    int age;
    public void eat() {
        System.out.println(name + "在吃饭");   // 学生类的行为（方法）
    }
    public Student() {
        System.out.println("这是自定义的一个不带参数的构造方法");
    }
}
public class TestDemo3 {
    public static void main(String[] args) {
        Student student1 = new Student();
    }
}

class Student {
    String name;
    String gender;
    int age;
    long studentID;
    // 该构造方法可由IDEA自动生成
    public Student(String name, String gender, int age, long studentID) {  
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.studentID = studentID;
    }
}
public class TestDemo2 {
    public static void main(String[] args) {
        Student stu1 = new Student("张三", "男", 19, 231245431);
        System.out.println("姓名:" + stu1.name + " 性别:" + stu1.gender + " 年龄:" + stu1.age + " 学号:" + stu1.studentID);
    }
}

public Date(int year, int month, int day) {
        // 那函数体中到底是谁给谁赋值？成员变量给成员变量？参数给参数？参数给成员变量？
        // 成员变量给参数？估计自己都搞不清楚了
        year = year;            // 当传入的参数相同是怎么办！
        month = month;
        day = day;
}

public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
 Date date1 = new Date(2022, 4, 2)

class Cat {
    public void jump() {
        System.out.println("这个猫在跳！！！");
    }
    public void run() {
        this.jump();        // 在run方法中用this.方法名调用当前对象的一个成员方法jump
        System.out.println("这个猫在跑！！！");
    }
}
public class TestDemo2 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.run();
    }
}

class Cat {
    String name;
    int age;
    Cat() {
        System.out.println("这是自定义的一个不带参数的构造函数");
    }
 
    public Cat(String name, int age) {
        this();            // 调用另一个不带参数的构造方法
        
        this.name = name;
        this.age = age;
        System.out.println(this.name + this.age + "岁了");
        System.out.println("这是自定义的一个带两个参数的构造函数");
    }
}
public class TestDemo2 {
    public static void main(String[] args) {
        Cat cat = new Cat("小花", 3);
    }
}

if (a % 2 == 0) {
		System.out.println("a是偶数");
	} else {
		System.out.println("a是奇数");
	}

if (x >= 3) {
			y = 2 * x + 1;
		} else if (x >= -1 && x < 3) {
			y = 2 * x;
		} else if (x <= -1) {
			y = 2 * x - 1;
		}

public class SwitchDemo {
	public static void main(String[] args) {
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		
		//接收数据
		System.out.println("请输入一个数字(1-7)：");
		int weekday = sc.nextInt();
		
		//switch语句实现选择
		switch(weekday) {
		case 1:
			System.out.println("星期一");
			break;
		case 2:
			System.out.println("星期二");
			break;
		case 3:
			System.out.println("星期三");
			break;
		case 4:
			System.out.println("星期四");
			break;
		case 5:
			System.out.println("星期五");
			break;
		case 6:
			System.out.println("星期六");
			break;
		case 7:
			System.out.println("星期日");
			break;
		default:
			System.out.println("你输入的数字有误");
			break;
		}
	}
}

public class Test {
    public static void main(String args[]) {
        int [] numbers = {10, 20, 30, 40, 50};
        
        for ( int x : numbers ) {
            System.out.print( x );
            System.out.print(",");
        }
        
        System.out.print();
        String [] names = {"James", "Larry", "Tom", "Lacy"};
        
        for ( String name : names ) {
            System.out.print( name );
            System.out.print(",");
        }
    }
}

int x=1;
		while(x<=10) {
			System.out.println("HellloWorld");
			x++;
        }

/*
 * break:中断的意思
 * 使用场景：
 * 		A:switch语句中
 * 		B:循环中
 * 注意：
 * 		离开使用场景是没有意义的。
 * 作用：
 * 		跳出循环，让循环提前结束
 */
public class BreakDemo {
	public static void main(String[] args) {
		//break;
		
		for(int x=1; x<=10; x++) {
			if(x == 3) {
				break;
			}
			System.out.println("HelloWorld");
		}
	}
}

/*
 * continue:继续的意思
 * 使用场景：
 * 		循环中
 * 注意：
 * 		离开使用场景是没有意义的
 * 作用：
 * 		结束一次循环，继续下一次的循环
 * 区别：
 * 		break:退出循环
 * 		continue:结束一次循环，继续下一次的循环
 */
public class ContinueDemo {
	public static void main(String[] args) {
		//continue;
		
		for(int x=1; x<=10; x++) {
			if(x == 3) {
				//break;
				continue;
			}
			System.out.println("HelloWorld");
		}
	}
}

public class ReturnDemo {
	public static void main(String[] args) {
		getStr();
	}

	public String getStr() {
        return "Hello";
    }

}

& | ^ ! && ||

@Test
public void getClz() {
    try {
        // 方法一，使用 Class.forName 静态方法
        Class<?> classBook = Class.forName("com.jourwon.reflect.Book");

        // 方法二：直接通过 类名.class 的方式得到
        Class clz = Book.class;

        // 方法三：使用类对象的 getClass() 方法。
        Book book1 = new Book();
        Class<? extends Book> book1Class = book1.getClass();

        System.out.println(classBook == clz);
        System.out.println(classBook == book1Class);

    } catch (Exception ex) {
        ex.printStackTrace();
    }
}

public class ReflectClass {

    private static final Logger log = LoggerFactory.getLogger(ReflectClass.class);

    // 创建对象
    @Test
    public void reflectNewInstance() {
        try {
            Class<?> classBook = Class.forName("com.jourwon.reflect.Book");

            Object objectBook = classBook.newInstance();
            Book book = (Book) objectBook;
            book.setName("Java高级特性-反射-创建对象");
            book.setAuthor("JourWon");
            log.info(book.toString());

        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    // 反射私有的构造方法
    @Test
    public void reflectPrivateConstructor() {
        try {
            Class<?> classBook = Class.forName("com.jourwon.reflect.Book");
            Constructor<?> declaredConstructorBook = classBook.getDeclaredConstructor(String.class, String.class);
            // 暴力反射
            declaredConstructorBook.setAccessible(true);
            Object objectBook = declaredConstructorBook.newInstance("Java高级特性-反射-反射私有的构造方法", "JourWon");
            Book book = (Book) objectBook;
            log.info(book.toString());
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    // 反射私有属性
    @Test
    public void reflectPrivateField() {
        try {
            Class<?> classBook = Class.forName("com.jourwon.reflect.Book");
            Object objectBook = classBook.newInstance();
            Field fieldTag = classBook.getDeclaredField("TAG");
            fieldTag.setAccessible(true);
            String tag = (String) fieldTag.get(objectBook);
            log.info(tag);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }


    // 反射私有方法
    @Test
    public void reflectPrivateMethod() {
        try {
            Class<?> classBook = Class.forName("com.jourwon.reflect.Book");
            Method methodBook = classBook.getDeclaredMethod("declaredMethod", int.class);
            methodBook.setAccessible(true);
            Object objectBook = classBook.newInstance();
            String string = (String) methodBook.invoke(objectBook, 0);

            ReflectClass.

            log.info(string);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }


}

在编程领域，除了语法糖，还有语法盐和语法糖精的说法

public class SwitchDemoString {
    public static void main(String[] args) {
        String str = "world";
        switch (str) {
        case "hello":
            System.out.println("hello");
            break;
        case "world":
            System.out.println("world");
            break;
        default:
            break;
        }
    }
}

public class SwitchStringDemo {

    public static void main(String[] args) {
        String str;
        String string = str = "world";
        int n = -1;
        switch (string.hashCode()) {
            case 99162322: {
                if (!string.equals("hello")) break;
                n = 0;
                break;
            }
            case 113318802: {
                if (!string.equals("world")) break;
                n = 1;
            }
        }
        switch (n) {
            case 0: {
                System.out.println("hello");
                break;
            }
            case 1: {
                System.out.println("world");
                break;
            }
        }
    }

}

Map<String, String> map = new HashMap<String, String>();  
map.put("name", "JourWon");  
map.put("wechat", "JourWon");  
map.put("blog", "https://blog.csdn.net/ThinkWon");  

Map map = new HashMap();  
map.put("name", "JourWon");  
map.put("wechat", "JourWon");  
map.put("blog", "https://blog.csdn.net/ThinkWon");   

class 类名称 <泛型标识> {
  private 泛型标识 /*（成员变量类型）*/ 变量名; 
  .....

  }
}

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
...
}
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
...
}
123456

//设置泛型类Generic
public class Generic<T> {
	//泛型里面的变量数据类型为T，在使用时由外部传入
    private T key;

    public Generic() {
    }
	// 泛型方法 getKey 的返回值类型为 T，T 的类型由外部指定
    public Generic(T key) {
        this.key = key;
    }
	//同上
    public T getKey() {
        return key;
    }

    public void setKey(T key) {
        this.key = key;
    }
}

public class Test<T> {    
    public static T one;   // 编译错误    
    public static T show(T one){ // 编译错误    
        return null;    
    }    
}  

public class Test2<T> {   
	// 泛型类定义的类型参数 T 不能在静态方法中使用  
    public static <E> E show(E one){ // 这是正确的，因为 E 是在静态方法签名中新定义的类型参数    
        return null;    
    }    
}  

public class MultiType <E,T> {
	E value1;
	T value2;
	
	public E getValue1(){
		return value1;
	}
	
	public T getValue2(){
		return value2;
	}
}

//泛型类
public class Generic<T> { 
 
    private T key;

    public Generic(T key) { 
        this.key = key;
    }

    public T getKey(){ 
        return key;
    }
}
//调用时，在<>中传入具体数据类型
@ Test
public void test() {
	Generic<String> generic = new Generic<>();// 传入 String 类型，这样就指定了这个对象的数据类型为String类型
	//如果在使用时用了非String类型，则会在编译时报错，不会再运行时报错
	
	// <> 中什么都不传入，等价于 Generic<Object> generic = new Generic<>();
	Generic generic = new Generic();
}
//指定类型以后，相对于实体类为
public class Generic { 
 
    private String key;

    public Generic(String key) { 
        this.key = key;
    }

    public String getKey() { 
        return key;
    }
}

public interface 接口名<类型参数> {
    ...
}

interface IUsb<U, R> {

    int n = 10;
    U name;// 报错！ 接口中的属性默认是静态的，因此不能使用类型参数声明

    R get(U u);// 普通方法中，可以使用类型参数

    void hi(R r);// 抽象方法中，可以使用类型参数

    // 在jdk8 中，可以在接口中使用默认方法, 默认方法可以使用泛型接口的类型参数
    default R method(U u) {
        return null;
    }
}

//定义一个接口 IA 继承了 泛型接口 IUsb，在 接口 IA 定义时必须确定泛型接口 IUsb 中的类型参数。
// 在继承泛型接口时，必须确定泛型接口的类型参数
interface IA extends IUsb<String, Double> {
	...
}

// 当去实现 IA 接口时，因为 IA 在继承 IUsu 接口时，指定了类型参数 U 为 String，R 为 Double
// 所以在实现 IUsb 接口的方法时，使用 String 替换 U,用 Double 替换 R
class AA implements IA {
    @Override
    public Double get(String s) {
        return null;
    }
    @Override
    public void hi(Double d) {
		...
    }
}

//定义一个类 BB 实现了 泛型接口 IUsb，在 类 BB 定义时需要确定泛型接口 IUsb 中的类型参数。
// 实现接口时，需要指定泛型接口的类型参数
// 给 U 指定 Integer， 给 R 指定了 Float
// 所以，当我们实现 IUsb 方法时，会使用 Integer 替换 U, 使用 Float 替换 R
class BB implements IUsb<Integer, Float> {
    @Override
    public Float get(Integer integer) {
        return null;
    }
    @Override
    public void hi(Float afloat) {
		...
    }
}

// 实现泛型接口时没有确定类型参数，则默认为 Object
// 建议直接写成 IUsb<Object, Object>
class CC implements IUsb {//等价 class CC implements IUsb<Object, Object> 
    @Override
    public Object get(Object o) {
        return null;
    }
    @Override
    public void hi(Object o) {
    	...
    }
}

// DD 类定义为 泛型类，则不需要确定 接口的类型参数
// 但 DD 类定义的类型参数要和接口中类型参数的一致
class DD<U, R> implements IUsb<U, R> { 
	...
}

public <类型参数> 返回类型 方法名（类型参数 变量名） {
    ...
}

/**
     *
     * @param t 传入泛型的参数
     * @param <T> 泛型的类型
     * @return T 返回值为T类型
     * 说明：
     *   1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
     *   2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
     *   3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
     *   4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E等形式的参数常用于表示泛型。
     */
    public <T> T genercMethod(T t){
        System.out.println(t.getClass());
        System.out.println(t);
        return t;
    }
 
 
public static void main(String[] args) {
    GenericsClassDemo<String> genericString  = new GenericsClassDemo("helloGeneric"); //这里的泛型跟下面调用的泛型方法可以不一样。
    String str = genericString.genercMethod("hello");//传入的是String类型,返回的也是String类型
    Integer i = genericString.genercMethod(123);//传入的是Integer类型,返回的也是Integer类型
}
 
 
class java.lang.String
hello
 
 
class java.lang.Integer
123                  

public class Demo {  
  public static void main(String args[]) {  
    GenericMethod d = new GenericMethod(); // 创建 GenericMethod 对象  
    
    String str = d.fun("汤姆"); // 给GenericMethod中的泛型方法传递字符串  
    int i = d.fun(30);  // 给GenericMethod中的泛型方法传递数字，自动装箱  
    System.out.println(str); // 输出 汤姆
    System.out.println(i);  // 输出 30

	GenericMethod.show("Lin");// 输出: 静态泛型方法 Lin
  }  
}

class GenericMethod {
	// 普通的泛型方法
	public <T> T fun(T t) { // 可以接收任意类型的数据  
    	return t;
  	} 

	// 静态的泛型方法
	public static <E> void show(E one){     
         System.out.println("静态泛型方法 " + one);
    }
}  

public class Test {

	// 这是一个简单的泛型方法  
    public static <T> T add(T x, T y) {  
        return y;  
    }

    public static void main(String[] args) {  
        // 一、不显式地指定类型参数
        //（1）传入的两个实参都是 Integer，所以泛型方法中的<T> == <Integer> 
        int i = Test.add(1, 2);
        
        //（2）传入的两个实参一个是 Integer，另一个是 Float，
        // 所以<T>取共同父类的最小级，<T> == <Number>
		Number f = Test.add(1, 1.2);

		// 传入的两个实参一个是 Integer，另一个是 String，
		// 所以<T>取共同父类的最小级，<T> == <Object>
        Object o = Test.add(1, "asd");
  
        // 二、显式地指定类型参数
        //（1）指定了<T> = <Integer>，所以传入的实参只能为 Integer 对象    
        int a = Test.<Integer>add(1, 2);
		
		//（2）指定了<T> = <Integer>，所以不能传入 Float 对象
        int b = Test.<Integer>add(1, 2.2);// 编译错误
        
        //（3）指定<T> = <Number>，所以可以传入 Number 对象
        // Integer 和 Float 都是 Number 的子类，因此可以传入两者的对象
        Number c = Test.<Number>add(1, 2.2); 
    }  
}

public class GenericType {
    public static void main(String[] args) {  
        ArrayList<String> arrayString = new ArrayList<String>();   
        ArrayList<Integer> arrayInteger = new ArrayList<Integer>();   
        System.out.println(arrayString.getClass() == arrayInteger.getClass());// true
    }  
}
1234567

public class Caculate<T> {
	private T num;
}

public class Caculate {
	public Caculate() {}// 默认构造器，不用管
	
	private Object num;// T 被替换为 Object 类型
}
12345

public class Caculate<T extends Number> {
	private T num;
}
123

public class Caculate {
	public Caculate() {}// 默认构造器，不用管

	private Number num;
}
12345

public class GenericType {
    public static void main(String[] args) {  
        ArrayList<Integer> arrayInteger = new ArrayList<Integer>();// 设置验票系统   
        arrayInteger.add(111);// 观众进场，验票系统验票，门票会被收走（类型擦除）
        Integer n = arrayInteger.get(0);// 获取观众信息，编译器会进行强制类型转换
        System.out.println(n);
    }  
}

	Integer n = arrayInteger.get(0);// 这条代码底层如下：
	
	//（1）get() 方法的返回值返回的是 Object 类型
	Object object = arrayInteger.get(0);
	//（2）编译器自动插入 Integer 的强制类型转换
	Integer n = (Integer) object;
123456

public class Collections {
    // 把 src 的每个元素复制到 dest 中:
    public static <T> void copy(List<? super T> dest, List<? extends T> src) {
        for (int i = 0; i < src.size(); i++) {
        	// 获取 src 集合中的元素，并赋值给变量 t，其数据类型为 T
            T t = src.get(i);
            // 将变量 t 添加进 dest 集合中 
            dest.add(t);// 添加元素进入 dest 集合中
        }
    }
}

public class Collections {
    // 把 src 的每个元素复制到 dest 中:
    public static <T> void copy(List<? super T> dest, List<? extends T> src) {
        ...
        // 获取 <? super T> 集合的元素只能赋值给 Object 对象
        T t = dest.get(0); // 编译错误
        // 不能向 <? extends T> 集合中添加任何类型的对象，除了 null
        src.add(t); // 编译错误
    }
}

// 将 List<Integer> 复制到 List<Number>
List<Number> numList = ...;
List<Integer> intList = ...;
Collections.copy(numList, intList);// 编译正确

// 不能将 List<Number> 复制到 List<Integer>
Collections.copy(intList, numList);// 编译错误

public class Collections {
    public static <T> void copy(List<? super T> dest, List<? extends T> src) {
        for (int i = 0; i < src.size(); i++) {
            T t = src.get(i); // src 是 producer
            dest.add(t); // dest 是 consumer
        }
    }
}

public class TestMethod<U> {
	public <T, S> T testMethod(T t, S s) {
		return null;
	}
}

public class Generic<T> { 
    // key 这个成员变量的数据类型为 T, T 的类型由外部传入  
    private T key;

	// 泛型构造方法形参 key 的类型也为 T，T 的类型由外部传入
    public Generic(T key) { 
        this.key = key;
    }
    
	// 泛型方法 getKey 的返回值类型为 T，T 的类型由外部指定
    public T getKey(){ 
        return key;
    }
}

List<Object> objectList;
List<String> stringList;
      
objectList = stringList;// 编译错误

public class Test {
	public static void main(String[] args) {
		// 创建一个 ArrayList<String> 集合
		List<String> list = new ArrayList(); 
		
		fillNumList(list);// 编译正确
		fillObjList(list);// 编译错误
	}
	
	public static void fillList(List list) {
		...
	}

	public static void fillObjList(List<Object> list) {
		...
	}
}

List<?> listOfAnyType;
List<Object> listOfObject = new ArrayList<Object>();
List<String> listOfString = new ArrayList<String>();
List<Integer> listOfInteger = new ArrayList<Integer>();
      
listOfAnyType = listOfString;// 编译正确
listOfAnyType = listOfInteger;// 编译正确
listOfObjectType =  listOfString;// 编译错误

List listOfRawTypes = new ArrayList();
listOfRawTypes.add("abc");
listOfRawTypes.add(123);

String item = (String) listOfRawTypes.get(0);// 获取元素时需要显式的类型转换
// 编译器不报错，但运行时会产生 ClassCastException异常，因为 Integer不能被转换为 String
item = (String) listOfRawTypes.get(1);
      
List<String> listOfString = new ArrayList();
listOfString.add("abcd");
listOfString.add(1234);// 编译器直接报错
item = listOfString.get(0); // 不需要显式的类型转换，编译器会自动转换

public static void main(String[] args) {
    int i = 10;
    Integer n = i;
}

public static void main(String args[]) {
    int i = 10;
    Integer n = Integer.valueOf(i);
}

public static void main(String[] args) {
    Integer i = 10;
    int n = i;
}

public static void main(String args[]) {
    Integer i = Integer.valueOf(10);
    int n = i.intValue();
}

public static void main(String[] args) {
    //打印方法的多参数
    print("CSDN-ThinkWon", "简书-JourWon", "博客:https://blog.csdn.net/ThinkWon");
}

public static void print(String... strs) {
    for (int i = 0; i < strs.length; i++) {
        System.out.println(strs[i]);
    }
}

public static void main(String[] args) {
    //本质是创建一个数组
    print(new String[]{"CSDN-ThinkWon", "\u7b80\u4e66-JourWon", "\u535a\u5ba2:https://blog.csdn.net/ThinkWon"});
}

public static void print(String[] strs) {
    for (int i = 0; i < strs.length; i++)
        System.out.println(strs[i]);
}

public enum T {
    SPRING,SUMMER;
}

public final class T extends Enum<T> {
    public static final /* enum */ T SPRING = new T("SPRING", 0);
    public static final /* enum */ T SUMMER = new T("SUMMER", 1);
    private static final /* synthetic */ T[] $VALUES;

    public static T[] values() {
        return (T[])$VALUES.clone();
    }

    public static T valueOf(String name) {
        return Enum.valueOf(T.class, name);
    }

    private T(String string, int n) {
        super(string, n);
    }

    static {
        $VALUES = new T[]{SPRING, SUMMER};
    }
}

public class OutterClass {

    private String userName;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public static void main(String[] args) {

    }

    class InnerClass {
        private String name;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }
}

public class AssertTest {
    public static void main(String args[]) {
        int a = 1;
        int b = 1;
        assert a == b;
        System.out.println("CSDN-ThinkWon");
        assert a != b : "ThinkWon";
        System.out.println("博客:https://blog.csdn.net/ThinkWon");
    }
}

public class Test {
    public static void main(String[] args) {
        int i = 10_000;
        System.out.println(i);
    }
}

public static void main(String args[]) {
    String[] strs = {"CSDN-ThinkWon", "简书-JourWon", "博客:https://blog.csdn.net/ThinkWon"};
    for (String s : strs) {
        System.out.println(s);
    }
    System.out.println();

    List<String> strList = Arrays.asList(strs);
    //for（数据类型 变量名 ： 遍历的集合名称）
    for (String s : strList) {
        System.out.println(s);
    }
}

public static void main(String args[]) {
    String[] strs;
    String[] arrstring = strs = new String[]{"CSDN-ThinkWon", "\u7b80\u4e66-JourWon", "\u535a\u5ba2:https://blog.csdn.net/ThinkWon"};
    int n = arrstring.length;
    for (int i = 0; i < n; ++i) {
        String s = arrstring[i];
        System.out.println(s);
    }
    System.out.println();

    List<String> strList = Arrays.asList(strs);
    Iterator<String> iterator = strList.iterator();
    while (iterator.hasNext()) {
        String s = iterator.next();
        System.out.println(s);
    }
}

public static void main(String args[]) {
    try (BufferedReader br = new BufferedReader(new FileReader("d:\\ hello.xml"))) {
        String line;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
    } catch (IOException e) {
        // handle exception
    }
}

public static void main(String[] args) {
    List<String> strList = new ArrayList<>();
    strList.add("CSDN-ThinkWon");
    strList.add("简书-JourWon");
    strList.add("博客:https://blog.csdn.net/ThinkWon");

    strList.forEach(s -> System.out.println(s));
}

public class Lambda_test01 {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            //实现runnable接口
            @Override
            public void run() {
                System.out.println("匿名Run线程启动");
            }
        }).start();
    }
}

public class Lambda_test01 {
    public static void main(String[] args) {
        new Thread(run()->{
                System.out.println("匿名Run线程启动");
            }).start();
    }
}

public class Lambda_test01 {
    public static void main(String[] args) {
        //实现runnable接口
        new Thread(() -> System.out.println("匿名Run线程启动")).start();
    }
}

public class LambdaTest {
    public static void main(String[] args) {
//对printNum()方法进行调用
        LambdaTest.printNum(new IntPredicate() { //对接口的实现
            @Override
            public boolean test(int value) {  
                return value%2==0;
            }
        });
    }
//自定义一个printNum()方法
    public static void printNum(IntPredicate predicate){
        int[] arr={1,2,3,4,5,6,7,8,9,10};
        for (int i:arr){
            if(predicate.test(i)){
                System.out.println(i);
            }
        }
    }
}

public class LambdaTest {
    public static void main(String[] args) {
        LambdaTest.printNum((int value)-> {
                return value%2==0;
            });
    }
     public static void printNum(IntPredicate predicate){
        int[] arr={1,2,3,4,5,6,7,8,9,10};
        for (int i:arr){
            if(predicate.test(i)){
                System.out.println(i);
            }
        }
    }
}

//原代码为输入Interger类型的age转换成String类型的age
//这个匿名内部类符合使用前提，所以我们只要关注调用的类名String及方法名valueOf（）
	new Function<Interger,String>{
		@Override
		public String apply(Interger age){
			retrun String.valueOf(age);
		}
	} 	
//改写成
String::valueOf

 		List<String> list = Arrays.asList("apple", "banana", "orange");
        Stream<String> stream = list.stream();
		合并操作
       Stream<String> stream = Arrays.asList("apple", "banana", "orange").steam();

		Integer[] arr = {1,2,3,5};
        Stream<Integer> stream = Arrays.stream(arr);
        stream.forEach(integer -> System.out.println(integer));
        Stream<Integer> arr1 = Stream.of(arr);
        arr1.forEach(integer -> System.out.println(integer));

Map<String, Integer> map = new HashMap<>();
map.put("蜡笔小新",19);
map.put("黑子",17);
map.put("日向翔阳",16);
Stream<Map.Entry<String，Integer>> stream = map.entryset().stream() ;
stream.forEach(new Consumer<Map.Entry<String, Integer>>() {
            @Override
            public void accept(Map.Entry<String, Integer> stringIntegerEntry) {
                System.out.println(stringIntegerEntry.getValue());
            }
        });
// stream.forEach(stringIntegerEntry -> System.out.println(stringIntegerEntry.getValue()));

//是Map.Entry接口的对象集合
Set<Map.Entry<K, V>> entrySet();
//Entry接口中的方法有
interface Entry<K,V> {
	  K getKey();//获取键
	  V getValue();//获取值
	  V setValue(V value);//获取旧值
	  //以及boolean equals(Object o)， int hashCode();等方法
}

//接口为Predicate的对象方法
Stream<T> filter(Predicate<? super T> predicate);
//重写Predicate方法，返回的是一个boolean类型
new Predicate<T>() {
    @Override
    public boolean test(T t) {
         return false;
    }
}

List<String> strings=new ArrayList<>();
strings.add("abcde");
strings.add("ac");
strings.stream().filter(new Predicate<String>() {
    @Override
    public boolean test(String s) {
 //重写方法中把String 类型名称设置为s，外部Strings数组传到重写的Predicate方法中再传到s中，再调用length方法判断是否大于2
         return s.length()>2;
    }
});
//strings.stream().filter(s -> s.length() > 2);

//接口有apply方法，Function(传入类型，转换类型)
public interface Function<T, R> {
  R apply(T t);
  }
  //重写apply方法
  .map(new Function<Author, Object>() {
                    @Override
                    //public 转换类型 apply（传入类型）
                    public Object apply(Author author) {
                        return null;
                    }
                })

//使用自定义的引用类型Author，静态方法为getAuthors（）
List<Author> authors = getAuthors();
        authors.stream()
        //使用map接口中的Function(传入参数，转换参数)
        //这个源码使用了
                  .map(new Function<Author, String>() {
                    @Override
                    public String apply(Author author) {
                        return author.getName();
                    }
                })
//authors.stream().map(author -> author.getName());

//distinct方法是依赖Object的equals方法来判断是否是相同对象的。所以需要注意重写equals方法。

public class StreamDemo_01 {
    public static void main(String[] args) {
        List<Author> authors = getAuthors();
        authors.stream()
                .distinct();
    }

//1.空参
Stream<T> sorted();
//2.传入接口类型
Stream<T> sorted(Comparator<? super T> comparator);
//2.1接口方法为copare方法
int compare(T o1, T o2);

@Data
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode//用于后期的去重使用
//使用空参sorted方法时，要实现对应排序类型的实体类，对应Comparable中compareTo方法
public class Author implements Comparable<Author> {
    //id
    private Long id;
    //姓名
    private String name;
    //年龄
    private Integer age;
    //简介
    private String intro;
    //作品
    private List<Book>books;
    @Override
    public int compareTo(Author o) {
        return this.getAge()-o.getAge();
    }
}

 List<Author> authors = getAuthors();
        authors.stream()
                .distinct()
                .sorted()
                .forEach(new Consumer<Author>() {
                    @Override
                    public void accept(Author author) {
                        System.out.println(author.getName());
                    }
                });

 List<Author> authors = getAuthors();
        authors.stream()
                .distinct()
                .sorted(new Comparator<Author>() {
                    @Override
                    public int compare(Author o1, Author o2) {
                        return o1.getAge()-o2.getAge();
                    }
                })
                .forEach(new Consumer<Author>() {
                    @Override
                    public void accept(Author author) {
                        System.out.println(author.getName());
                    }
                });

//lambda表达式
List<Author> authors = getAuthors();
        authors.stream()
                .distinct()
                .sorted((o1, o2) -> o1.getAge()-o2.getAge())
                .forEach(author -> System.out.println(author.getName()));

Stream<T> limit(long maxSize);//调用方法

  authors.stream()
                .distinct()
                .sorted((o1, o2) -> o1.getAge()-o2.getAge())
                .limit(2)
                .forEach(author -> System.out.println(author.getName()));

Stream<T> skip(long n);//调用方法

 authors.stream()
                .distinct()
                .sorted((o1, o2) -> o1.getAge()-o2.getAge())
                .limit(2)
                .skip(2)
                .forEach(author -> System.out.println(author.getName()));

//接口方法为Function而且是继承Stream流的
<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

//把List集合引用类型Author转换成指定类型String
.flatMap(new Function<Author, Stream<String>>() {
                    @Override
                    //重写apply方法，传入List集合，名称为author
                    public Stream<String> apply(Author author) {
                        //转换成List集合的book名称并转换成Stream流,一定要转换成流，否则报类型异常
                        return author.getBook().Stream;
                    }
                })
//简写成lambad式子，只关注重写方法里面的参数名称和方法体中一个方法
.flatMap(author->author.getBook().Stream)

//forEach接口里面有comsumer接口 
void forEach(Consumer<? super T> action);
//Consumer接口方法
public interface Consumer<T> {
    void accept(T t);
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}
//重写accpet方法
.forEach(new Consumer<T>() {
                    @Override
                    public void accept(T t) {
                        //方法体一般是打印语句
                        
                    }
                });

.forEach(new Consumer<Book>() {
                    @Override
                    public void accept(Book book) {
                        System.out.println(book.getName());
                    }
                });
//lambda表达式
//重写方法中参数名称book
//方法体
.forEach(book->System.out.println(book.getName()));

    long count();//直接调用的方法，而且无参

.count()

//两个方法都是以接口comparator为主
Optional<T> max(Comparator<? super T> comparator);
Optional<T> min(Comparator<? super T> comparator);


//内部实现了compare方法，注意要重写equals方法
public interface Comparator<T> {
	int compare(T o1, T o2);
	 boolean equals(Object obj);
	 }

 List<Author> authors = getAuthors();
 		//min传出来的类型是Optional类型，需要使用Optional的方法
        Optional<Author> min = authors.stream()
                .min(new Comparator<Author>() {
                    @Override
                    public int compare(Author o1, Author o2) {
                        return o1.getAge() - o1.getAge();
                    }
                });
        System.out.println(min.get());
 //简化代码
    List<Author> authors = getAuthors();
        Optional<Author> min = authors.stream()
                .min((o1, o2) -> o1.getAge() - o1.getAge());
        System.out.println(min.get());

//collect是一个比较复杂的接口，方便使用设计了一个Collectors工具类，内部有很多方法
.collect(Collectors.方法名)
//经典的为
Collectors.toList()获取List集合。
Collectors.toSet()获取Set集合
Collectors.toMap()获取一个Map集合，map的key为o1，value为o2

  List<Author> authors = getAuthors();
        List<String> nameList = authors.stream()
                .map(author -> author.getName())
                .collect(Collectors.toList());
        System.out.println(nameList);

  List<Author> authors = getAuthors();
        Set<Book> bookSet = authors.stream()
                .flatMap(author -> author.getBooks().stream())
                .collect(Collectors.toSet());
        System.out.println(bookSet);

//1.
List<Author> authors = getAuthors();
		//2.
        Map<String, List<Book>> map = authors.stream()
        		//3.
                .distinct()
                //4.
                .collect(Collectors.toMap(new Function<Author, String>() {
                	//4.1传入Author数据，转换成getName为key
                    @Override
                    public String apply(Author author) {
                        return author.getName();
                    }
                }
                //4.24.1传入Author数据，转换成getBooks为value
                , new Function<Author, List<Book>>() {
                    @Override
                    public List<Book> apply(Author author) {
                        return author.getBooks();
                    }
                }));
        //把转换成的map数据命名为map并打印
        System.out.println(map);
//lambda表达式
.collect(Collectors.toMap(author -> author.getName(), author -> author.getBooks()))

//布尔类型的方法，参数为Predicate接口方法。
boolean anyMatch(Predicate<? super T> predicate);
//Predicate接口方法
public interface Predicate<T> {
	boolean test(T t);
	...//xxxMatch方法不同之处
	}
//重写test方法
.anyMatch(new Predicate<T>() {
                     @Override
                     public boolean test(T t) {
                         return false;
                     }
                 })

 List<Author> authors = getAuthors();
         authors.stream()
                 .anyMatch(new Predicate<Author>() {
                     @Override
                     public boolean test(Author author) {
                         return author.getAge()>29;
                     }
                 });
//简写lambda
 .anyMatch(author -> author.getAge()>29);

//布尔类型的方法，参数为Predicate接口方法。
boolean allMatch(Predicate<? super T> predicate);
//Predicate接口方法
public interface Predicate<T> {
	boolean test(T t);
	...
	}
//重写test方法
.anyMatch(new Predicate<T>() {
                     @Override
                     public boolean test(T t) {
                         return false;
                     }
                 })

//例子：判断是否所有的作家都是成年人
 List<Author> authors = getAuthors();
        boolean b = authors.stream()
                .allMatch(new Predicate<Author>() {
                    @Override
                    public boolean test(Author author) {
                        return author.getAge() >=18;
                    }
                });
        System.out.println(b);
//简化lambda表达式
.allMatch(author -> author.getAge() >=18);

//同anyMath和allMath的源码

//例子：判断作家是否都没有超过100岁的。
 List<Author> authors = getAuthors();
        boolean b = authors.stream()
                .noneMatch(new Predicate<Author>() {
                    @Override
                    public boolean test(Author author) {
                        return author.getAge() > 100;
                    }
                });
        System.out.println(b);
//简写lambda表达式
.noneMatch(author->author.getAge()>100)

//同max和min方法中数据类型为Optional，参数为空参
Optional<T> findAny();
//所以调用该方法后要返回Optional类型的参数，再调用Optional类型的方法

//例子：获取任意一个年龄大于18的作家，如果存在就输出他的名字
     List<Author> authors = getAuthors();
        Optional<Author> optionalAuthor = authors.stream()
                .filter(author -> author.getAge() > 18)
                .findAny();
        optionalAuthor.ifPresent(new Consumer<Author>() {
            @Override
            public void accept(Author author) {
                System.out.println(author.getName());
            }
        });

////同max和min方法中数据类型为Optional，参数为空参
Optional<T> findFirst();
////所以调用该方法后要返回Optional类型的参数，再调用Optional类型的方法

//例子：获取一个年龄最小的作家，并输出他的姓名。
 List<Author> authors = getAuthors();
        Optional<Author> first = authors.stream()
                .sorted(new Comparator<Author>() {
                    @Override
                    public int compare(Author o1, Author o2) {
                        return o1.getAge() - o2.getAge();
                    }
                })
                .findFirst();
        first.ifPresent(new Consumer<Author>() {
            @Override
            public void accept(Author author) {
                System.out.println(author.getName());
            }
        });
 //简写lambda表达式
 List<Author> authors = getAuthors();
        Optional<Author> first = authors.stream()
                .sorted((o1, o2) -> o1.getAge() - o2.getAge())
                .findFirst();
        first.ifPresent(author -> System.out.println(author.getName()));

//双参(初始值，BinaryOperator的接口方法)
T reduce(T identity, BinaryOperator<T> accumulator);
//内部计算方法,传入初始值identity命名为result，遍历Stream流中元素，对初始值和流中元素进行操作
T result = identity;
for (T element : this stream)
	result = accumulator.apply(result, element)
return result;
//等同于
int[] arr = {1,2,3,4}
T result = 初始值；
for(int i ：arr){
	result = result*i;
}
//单参，并且返回类型是Optional方法类
 Optional<T> reduce(BinaryOperator<T> accumulator);
 //内部的计算方式如下： 实际上就是把第一个元素作为初始化值，再拿和这个变量进行相应的计算
  boolean foundAny = false;
     T result = null;
     for (T element : this stream) {
         if (!foundAny) {//把第一个值放入result
             foundAny = true;
             result = element;
         }
         else
             result = accumulator.apply(result, element);
     }
     return foundAny ? Optional.of(result) : Optional.empty();
 //三参，并行流会提及
 <U> U reduce(U identity,
                 BiFunction<U, ? super T, U> accumulator,
                 BinaryOperator<U> combiner);

//返回类型中是BinaryOperator继承BiFunction
@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T> {
  	//比较器：最小值
    public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
    }
	//比较器：最大值
    public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
    }
}

 List<Author> authors = getAuthors();
        Integer sum = authors.stream()
                .distinct()
                .map(author -> author.getAge())
                .reduce(0, new BinaryOperator<Integer>() {
                    @Override
                    public Integer apply(Integer integer, Integer integer2) {
                        return integer + integer2;
                    }
                });
        System.out.println(sum);
//简写lambda
.reduce(0, (integer, integer2) -> integer + integer2);

 //        使用reduce求所有作者中年龄的最小值
 List<Author> authors = getAuthors();
        Optional<Integer> min = authors.stream()
                .map(author -> author.getAge())
                .reduce(new BinaryOperator<Integer>() {
                    @Override
                    public Integer apply(Integer result, Integer element) {
                        return result > element ? element : result;
                    }
                });
        min.ifPresent(new Consumer<Integer>() {
            @Override
            public void accept(Integer age) {
                System.out.println(age);
            }
        });
//简化lambda
List<Author> authors = getAuthors();
        Optional<Integer> min = authors.stream()
                .map(author -> author.getAge())
                .reduce((result, element) -> result > element ? element : result);
        min.ifPresent(age -> System.out.println(age));

Author author = getAuthor();
if(author!=null){
     System.out.println(author.getName());
}

//该方法和of()方法的作用一样，但value允许为null
   public static <T> Optional<T> ofNullable(T value) {
       //这里传入的值用三元符判断，如果为空则返回empty静态方法（这样避免了空指针异常），不为空则用of()方法创建Optional类
        return value == null ? empty() : of(value);
    }
//该方法返回一个value为空的Optional对象，静态方法
    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }
//该方法用于指定value创建一个Optional对象，value不能为null，否则抛出异常  
    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

Author author = getAuthor();
Optional<Author> authorOptional = Optional.ofNullable(author);

//ifPresent()方法接受一个Consumer对象（消费函数），如果包装对象的值非空，运行Consumer对象的accept()方法，进行安全消费 
public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }
//重写accept方法
ifPresent(new Consumer<String>() {
            @Override
            public void accept(String s) {
                
            }
        })

  Optional<String> optional = Optional.of("thinkwon");
        optional.ifPresent(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
//简写lambda表达式
optional.ifPresent(s -> System.out.println(s));

public boolean isPresent() {
        return value != null;
    }

//空参，调用方法  
public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

public T orElse(T other) {
        return value != null ? value : other;
    }

///orElseGet()方法接受一个Supplier对象，如果包装对象的值非空，运行Supplier对象的get()方法，进行安全获取
public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }
//重写空参的get方法
@FunctionalInterface
public interface Supplier<T> {
    T get();
}

Optional<String> s = Optional.ofNullable(null);
        s.orElseGet(new Supplier<String>() {
            @Override
            public String get() {
                return "我不知道呀";
            }
        });
        System.out.println(s);
//简化lambda
s.orElseGet(() -> "我不知道呀");

// 
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }

 //1.get方法为空参
 //2.指定异常类型及提示
 Optional.ofNullable(null).orElseThrow(new Supplier<RuntimeException>() {
            @Override
            public RuntimeException get() {
                return new RuntimeException("我不知道的异常呀");
            }
        });
//简化lambda
 Optional.ofNullable(null).orElseThrow(() -> new RuntimeException("我不知道的异常呀"));

 //filter()方法接受一个Predicate对象，符合过滤条件代码，返回该对象本身，反之返回空的对象
 public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }
    //Predicate接口方法
    @FunctionalInterface
public interface Predicate<T> {
 boolean test(T t);
 }

 Optional.of("thinkwon")
                .filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length()>2;
            }
        }).ifPresent(s -> System.out.println(s));
//简写成lambda表达式
//1.参数名为s（传入的是字符串，所以默认为String类型，名称默认为s）
//2.方法体为s.length()>2
filter(s -> s.length()>2)

//和Stream流中map方法一样
public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent())
            return empty();
        else {
            return Optional.ofNullable(mapper.apply(value));
        }
    }
    //和Stream流中flatmap方法一样
    public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent())
            return empty();
        else {
            return Objects.requireNonNull(mapper.apply(value));
        }
    }

* @see     java.lang.Thread
 * @see     java.util.concurrent.Callable
 */
@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

S parallel();//直接调用的方法

 Stream<T> peek(Consumer<? super T> action);

Stream.of("one", "two", "three","four").peek(u -> u.toUpperCase())
                .forEach(System.out::println);
/*结果
one
two
three
four
*/
Stream.of("one", "two", "three","four").map(u -> u.toUpperCase())
                .forEach(System.out::println);
/*结果
ONE
TWO
THREE
FOUR
*/

default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }
//本质上还是转换成Stream流

 List<Author> authors = getAuthors();
        authors.parallelStream()
                .map(author -> author.getAge())
                .map(age -> age + 10)
                .filter(age->age>18)
                .map(age->age+2)
                .forEach(System.out::println);

The common interface extended by all annotation types.

@Override
public String toString() {
    return "Hello Annotation";
}
1234

//例子
@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation{
    
    int id();
    
    String msg();

}

@TestAnnotation(id=3, msg="hello annotation")
public class Test {

}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface IntegerVaule{
   int value() default 0;
   String name() default "";
}

public class QuicklyWay {
   
   @IntegerVaule(20)
   public int age;
   
   @IntegerVaule(value = 10000, name = "MONEY")
   public int money;
 
}

{
    "key1" : 1,
    "key2" : "string"
}

[ "Google", "Runoob", "Taobao" ]

{
    //对象
    "name":"网站",
    "money":3.22,
    "status":0,
    "valid":true,
    "address":null,
    //左边是对象，右边是数组
    "sites": [
        //数组里面再套对象的键值对
        { "name":"Google", "info":[ "Android", "Google 搜索", "Google 翻译" ] },
        { "name":"Runoob", "info":[ "菜鸟教程", "菜鸟工具", "菜鸟微信" ] },
        { "name":"Taobao", "info":[ "淘宝", "网购" ] }
    ]
}

src
	main
		java
			com
				jourwon
					prop
						PropertiesTest
		resources
			config.properties
			prop.properties

username=root
password=123456

public static void main(String[] args) throws IOException {
    Properties properties = new Properties();
    OutputStream output = null;//输出流先设置null值
    try {
        //创建文件输出流对象
        output = new FileOutputStream("src/main/resources/config.properties");
        //调用setProperty方法将键值对保存到内存中
        properties.setProperty("username", "root");
        properties.setProperty("password", "123456");

        // 保存键值对到文件中
        properties.store(output, "JourWon modify");

    } catch (IOException io) {
        io.printStackTrace();
    } finally {
        if (output != null) {
            try {
                output.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

#JourWon modify
#Mon Sep 09 14:23:44 CST 2019
password=123456
username=root

public static void main(String[] args) throws IOException {
    // PropertiesTest.getPath1();
    // PropertiesTest.getPath2();
    // PropertiesTest.getPath3();
    // PropertiesTest.getPath4();
    // PropertiesTest.getPath5();
    PropertiesTest.getPath6();
}

/**
     * 一、 使用java.util.Properties类的load(InputStream in)方法加载properties文件
     * 主要是需要加上src这个文件夹名。路径配置需要精确到绝对地址级别
     *
     * @return
     */
public static void getPath1() throws IOException {
    InputStream in = new BufferedInputStream(new FileInputStream(
        new File("src/main/resources/prop.properties")));

    printKeyValue(in);

}

/**
     * 二、 使用java.util.ResourceBundle类的getBundle()方法
     * 注意：这个getBundle()方法的参数只能写成包路径+properties文件名，注意不需要带上后缀名。
     *
     * @return
     */
public static void getPath2() {
    ResourceBundle rb = ResourceBundle
        .getBundle("prop");

    printKeyValueRb(rb);
}

/**
     * 三、 使用java.util.PropertyResourceBundle类的构造函数
     *
     * @return
     */
public static void getPath3() throws IOException {
    InputStream in = new BufferedInputStream(new FileInputStream("src/main/resources/prop.properties"));
    ResourceBundle rb = new PropertyResourceBundle(in);

    printKeyValueRb(rb);
}

/**
     * 四、 使用class变量的getResourceAsStream()方法
     * 注意：getResourceAsStream()方法的参数按格式写到包路径+properties文件名+.后缀
     *
     * @return
     */
public static void getPath4() throws IOException {
    InputStream in = PropertiesTest.class
        .getResourceAsStream("/prop.properties");

    printKeyValue(in);
}

/**
     * 五、
     * 使用class.getClassLoader()所得到的java.lang.ClassLoader的
     * getResourceAsStream()方法
     * getResourceAsStream(name)方法的参数必须是包路径+文件名+.后缀
     * 否则会报空指针异常
     *
     * @return
     */
public static void getPath5() throws IOException {
    InputStream in = PropertiesTest.class.getClassLoader()
        .getResourceAsStream("./././prop.properties");

    printKeyValue(in);
}

/**
     * 六、 使用java.lang.ClassLoader类的getSystemResourceAsStream()静态方法
     * getSystemResourceAsStream()方法的参数格式也是有固定要求的
     *
     * @return
     */
public static void getPath6() throws IOException {
    InputStream in = ClassLoader
        .getSystemResourceAsStream("./././prop.properties");

    printKeyValue(in);
}


/**
     * 单独抽取的方法，用户检测能否正确操纵Properties
     *
     * @param inputStream
     * @throws IOException
     */
public static void printKeyValue(InputStream inputStream) throws IOException {
    Properties properties = new Properties();
    properties.load(inputStream);
    Set<Object> keys = properties.keySet();
    for (Object key : keys) {
        System.out.println(key + " = " + properties.get(key));
    }

    if (inputStream != null) {
        inputStream.close();
    }
}

public static void printKeyValueRb(ResourceBundle rb) {
    Set<String> keys = rb.keySet();
    for (String key : keys) {
        System.out.println(key + " = " + rb.getString(key));

    }
}

/**
  * 输出properties的key和value
  */
public static void printProp(Properties properties) {
    System.out.println("---------（方式一）------------");
    for (String key : properties.stringPropertyNames()) {
        System.out.println(key + "=" + properties.getProperty(key));
    }

    System.out.println("---------（方式二）------------");
    //返回属性key的集合
    Set<Object> keys = properties.keySet();
    for (Object key : keys) {
        System.out.println(key.toString() + "=" + properties.get(key));
    }

    System.out.println("---------（方式三）------------");
    Set<Map.Entry<Object, Object>> entrySet = properties.entrySet();
    //返回的属性键值对实体
    for (Map.Entry<Object, Object> entry : entrySet) {
        System.out.println(entry.getKey() + "=" + entry.getValue());
    }

    System.out.println("---------（方式四）------------");
    Enumeration<?> e = properties.propertyNames();
    while (e.hasMoreElements()) {
        String key = (String) e.nextElement();
        String value = properties.getProperty(key);
        System.out.println(key + "=" + value);
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<persons>
    <person id="p001">
        <name>张三</name>
    </person>
    <person id="p002">
        <name>李四</name>
    </person>
</persons>

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5">
    <servlet>
        <servlet-name>HelloMyServlet</servlet-name>
        <servlet-class>com.jourwon.HelloMyServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HelloMyServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
</web-app>

<?xml version="1.0" encoding="UTF-8"?>

<servlet>

<web-app version="2.5">

<![CDATA[
    任意内容
]]>

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5">
    <servlet>
        <servlet-name>HelloMyServlet</servlet-name>
        <servlet-class>com.jourwon.HelloMyServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HelloMyServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
</web-app>

<dependency>
    <groupId>org.dom4j</groupId>
    <artifactId>dom4j</artifactId>
    <version>2.1.1</version>
</dependency>

public class Dome4jTest {

    public static void main(String[] args) throws DocumentException {
        // 1 创建核心对象（new 方式）
        SAXReader saxReader = new SAXReader();
        //2 加载xml文档 获得dom树（核心对象调用read读取xml文件）
        Document doc = saxReader.read("E:\\IdeaProjects\\demo1\\src\\main\\resources\\demo.xml");
        //3 获得根元素（文档对象下面就是根元素）
        Element root = doc.getRootElement();
        //4 获得子元素（根节点下所有子元素）
        List<Element> list = root.elements();

        for (Element e : list) {
            // elementText("标签名") 获得指定名称元素的文本值 （指定标签的文本值）
            // getName() 获得当前元素名
            if ("servlet".equals(e.getName())) {
                System.out.println(e.elementText("servlet-name"));
                System.out.println(e.getName());
            }

        }
    }

}

HelloMyServlet
servlet

格式:
<!DOCTYPE 根元素名 [dtd语法]>
12

格式:
<!DOCTYPE 根元素名 SYSTEM "约束文件的位置">
例如:
<!DOCTYPE web-app SYSTEM "web-app_2_3.dtd">
1234

<?xml version="1.0" encoding="UTF-8" ?>
<!ELEMENT web-app (servlet*, servlet-mapping* , welcome-file-list?) >
<!ELEMENT servlet (servlet-name, description?, (servlet-class|jsp-file))> 
<!ELEMENT servlet-mapping (servlet-name, url-pattern) >
<!ELEMENT servlet-name (#PCDATA)>
<!ELEMENT servlet-class (#PCDATA)>
<!ELEMENT url-pattern (#PCDATA)>
<!ELEMENT welcome-file-list (we1come-fi1e+)> 
<!ELEMENT welcome-file (#PCDATA)>
<!ATTLIST web-app version CDATA #IMPLIED>
12345678910

格式:
<!DOCTYPE 根元素名 PUBLIC "约束文件的名称" "约束文件的位置">
如mybatis中mapper的约束
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
12345

标签（元素）语法：
<!Element 元素名称 数据类型|包含内容>

数据类型:#PCDATA:普通文本 使用的时候一般用()引起来

功能：能出现那些标签，以及出现顺序

包含内容:该元素下可以出现哪些元素 用()引起来

符号:
            *   出现任意次
            ?   出现1次或者0次
            +   出现至少1次
            |   或者
            ()  分组
            ,   顺序（元素出现先后顺序，按照都好标记顺序出现）

栗子如下：（上图约束图中的代码）
<!ELEMENT web-app (servlet*,servlet-mapping* , welcome-file-list?) >
<!ELEMENT servlet-name (#PCDATA)>

ps：元素名就是xml中能够出现的元素标签名
属相的约束语法：
                
    属性:
        格式:
            <!ATTLIST 元素名 属性名 属性类型 属性是否必须出现>
        属性类型:
            ID:唯一
            CDATA:普通文本
        属性是否必须出现
            REQUIRED:必须出现
            IMPLIED:可以不出现


例如：
<!ATTLIST web-app version CDATA #IMPLIED>
12345678910111213141516171819202122232425262728293031323334353637

xml和schema的关联.
        格式:
            <根标签 xmlns="..." ...>
            <根标签 xmlns:别名="..." ...>
    名称空间:
        关联约束文件
        规定元素是来源于那个约束文件的
    例如:
        一个约束文件中规定 table(表格)  表格有属性 row和col
        还有一个约束文件规定 table(桌子) 桌子有属性 width和height
        
        在同一个xml中万一我把两个约束文件都导入了,
            在xml中我写一个table,这个table有什么属性????
        我们为了避免这种情况的发生,可以给其中的一个约束起个别名
        使用的时候若是没有加别名那就代表是来自于没有别名的约束文件
            例如 table(表格) 给他起个别名  xmlns:a="..."
            在案例中使用 a:table 代表的是表格
            若在案例中直接使用 table 代表的是桌子
        
     ps:在一个xml文件中只能有一个不起别名;
注意:
    schema约束本身也是xml文件.
12345678910111213141516171819202122

<?xml version="1.0" encoding="UTF-8"?>
<!-- 
    
    模拟servlet2.5规范，如果开发人员需要在xml使用当前Schema约束，必须包括指定命名空间。
    格式如下：
    <web-app xmlns="http://www.example.org/web-app_2_5" 
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://www.example.org/web-app_2_5 web-app_2_5.xsd"
            version="2.5">
-->
<xsd:schema xmlns="http://www.w3.org/2001/XMLSchema" 
    targetNamespace="http://www.example.org/web-app_2_5"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:tns="http://www.example.org/web-app_2_5" 
    elementFormDefault="qualified">
    
    <xsd:element name="web-app">
        <xsd:complexType>
            <xsd:choice minOccurs="0" maxOccurs="unbounded">
                <xsd:element name="servlet">
                    <xsd:complexType>
                        <xsd:sequence>
                            <xsd:element name="servlet-name"></xsd:element>
                            <xsd:element name="servlet-class"></xsd:element>
                        </xsd:sequence>
                    </xsd:complexType>
                </xsd:element>
                <xsd:element name="servlet-mapping">
                    <xsd:complexType>
                        <xsd:sequence>
                            <xsd:element name="servlet-name"></xsd:element>
                            <xsd:element name="url-pattern"></xsd:element>
                        </xsd:sequence>
                    </xsd:complexType>
                </xsd:element>
                <xsd:element name="welcome-file-list">
                    <xsd:complexType>
                        <xsd:sequence>
                            <xsd:element name="welcome-file" maxOccurs="unbounded"></xsd:element>
                        </xsd:sequence>
                    </xsd:complexType>
                </xsd:element>
            </xsd:choice>
            <xsd:attribute name="version" type="double" use="optional"></xsd:attribute>
        </xsd:complexType>
    </xsd:element>
</xsd:schema>

name1: zhangsan
name2: 'zhangsan \n lisi'
name3: "zhangsan \n lisi"
age: 18
flag: true
12345

date: 2019/01/01
1

people:
    name: zhangsan
    age: 20
123

people: {name:zhangsan,age: 20}
1

pets:
    - dog
    - pig
    - cat
1234

pets: [dog,pig,cat]
1

peoples:
    - name: zhangsan
      age: 22
    - name: lisi
      age: 20
    - {name: wangwu,age: 18}
123456

public class Person {

    private String lastName;
    private Integer age;
    private Boolean boss;

    private Date birth;
    private Map<String,Object> maps;
    private List<Dog> lists;
    private Dog dog;
    private String[] arr;
｝
public class Dog {
    private String name;
    private Integer age;
}
12345678910111213141516

person:
  boss: false
  maps:
    k1: v1
    k2: 14
  lists:
    - name: d1
      age: 2
    - name: d2
      age: 3
    - {name: d3,age: 4}
  birth: 2017/12/15
  dog:
    name: p_dog
    age: 15
  age: 13
  last-name: 张三
  arr: [s1,s2,s3]
123456789101112131415161718

server:
  port: 8081
spring:
  profiles:
    active: prod #激活对应的文档块

---
server:
  port: 8083
spring:
  profiles: dev #指定属于哪个环境


---

server:
  port: 8084
spring:
  profiles: prod  #指定属于哪个环境