[网络协议]Java 枚举类、时间类型、UDP、操作流

Java 枚举类

1.什么是枚举类

比较特殊的类
 * 		定义方式：
 * 		enum 名称{}
 * 		不能直接new对象
 * 		常量 类型就是枚举类型
 * java.lang.Enum{}
 * 		jdk1.5之后才有的类

2.枚举类和普通类的区别:

	1.普通类的对象是使用的时候使用new关键字创建
 * 	2.枚举类的对象自己在类中已经定义好的，只能使用这几个对象，不能自己创建
    枚举类的注意点：
 * 	1.构造方法只能使用默认和private，枚举类型中的构造方法，仅限在本类中使用
 * 	2.成员的定义只能在常量之后

Java 时间类型

1.时间类型：

Date Calendar SimpleDateFormat
 *  JDK1.8以后才有
 *  LocalDate:年月日
 *  LocalTime:时分秒
 *  LocalDateTime:年月日时分秒

2.时间分量的操作：

  static now() 获取当前的系统时间
 *  static of:设置时间分量
 *  minusXXX:减少时间分量
 *  plusXXX:增加时间分量

3.日期和字符串之间的转换

 *  日期与字符串之间的转换
 *  DateTimeFormatter:
 *  parse():将字符串转日期
 *  format():将日期转字符串
     
     public static void main(String[] args) {
		LocalDate date = LocalDate.now();
		System.out.println(date);
		LocalTime time = LocalTime.now();
		System.out.println(time);
		
		LocalDateTime dateTime = LocalDateTime.now();
		System.out.println(dateTime);
		
		//时间分量的操作
		//of:设置时间分量
		
		//plus():增加时间分量的值
		//minusXXX:减时间分量的值
		LocalDate date2 = LocalDate.of(20, 8, 8);
		System.out.println(date2);
		LocalDateTime dateTime2 = LocalDateTime.of(date, time);
		System.out.println(dateTime2);
		//增加时间分量
		LocalDateTime dateTime3 = dateTime2.plusYears(2);
		System.out.println(dateTime3);
		
		//字符串与日期的转换 对象.format(转的格式)
		//将字符串转日期：LocalDate.parse(需要转的字符串，格式)
		//日期的字符串
		DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
		
		String format = dateTime2.format(formatter);
		System.out.println(format);
		
		//字符串转日期
		String str = "2012-30-21";
		LocalDate parse = LocalDate.parse(str,formatter);
		System.out.println(parse);
		//获取时间分量getXXX()
		int year = parse.getYear();
		System.out.println(year);
		int dayOfYear = parse.getDayOfYear();
		System.out.println(dayOfYear);
	}
}

Java Stream操作流

1.stream对象的获取

1.Stream对象的获取
* 		Collection:stream():串行流 单线程
* 			parallelStream()：并行流 多线程
* 		Arrays.stream():将数组转化为Stream对象
* 			数组可以存储基本数据类型，集合中是包装类
* 		of():存储数据 Stream<? extends Object> of = Stream.of(1,"two",2,3,4,"five");
* 		generate()：产生数据 Stream.generate(Math::random).limit(20).forEach(System.out::println);
* 		iterate()：根据规则遍历数据 Stream.iterate(1, x -> x+2).limit(20).forEach(System.out::println);
    无限数据流limit()
*2. 链式操作：减少代码的操作

2.Stream中的方法

Stream中常用的方法：
 * 	Stream limit():获取流中的多少个数据
 * 	skip():跳过流中的多少个数据
 * 	distinct():去重，把流中的重复数据去掉
 * 	filter():过滤，Predicate test()抽象方法 list.removeIf();
 * 	count()：返回流中数据的个数
 * 	map(Function apply):映射 原本流中数据，根据映射规则得到新的数据流
 * 	sorted():排序new Comparator();

Stream:
 * 	boolean allMatch(Predicate);判断流中数据是否全部满足给定的条件
 * 	boolean anyMatch(Predicate): 判断流中数据是否满足给定的条件
 *	boolean noneMatch(Predicate):判断流中数据是否全部不满足给定条件
 * 	
 * 	Future get();Callable接口
 * 	Optional max:流中最大值
 * 	Optional min:流中最小值
 *  get():获取存入的值

public static void main(String[] args) {
		//跳过无限流中的前5个之后获取5个数据
		Stream<Integer> stream = Stream.iterate(1,x -> x+2).skip(5).limit(5);
		stream.forEach(System.out::println);
		Stream.of(1,23,2,4,5,4,4).distinct().forEach(System.out::println);;
		Stream.of(1,2,3,4,5,2,3).filter(new Predicate<Integer>(){ 
			public boolean test(Integer t) {
				return t > 4;
			}
		}).forEach(System.out::println);;
		long count = Stream.of(2,2,4,5,6,2).filter(new Predicate<Integer>() {
			public boolean test(Integer t) {
				return t > 4;
			}
		}).count();
		//将流中的数据扩大10倍
		Stream<Integer> map = Stream.of(1,2,3,4,2,5).map(new Function<Integer, Integer>() {
			public Integer apply(Integer t){
				return t*10;
			}
		});
		map.forEach(System.out::println);
		Stream.of(1,2,3,4,1,2,3).map(x -> x*10).forEach(System.out::println);
		
		Stream.of(1,2,3,45,3,2).sorted(new Comparator<Integer>() {
			public int compare(Integer o1, Integer o2) {
				return o1 - o2;
			}
		}).forEach(System.out::println);;
		Stream.of(1,2,3,4,2,1,5,3).sorted((t1,t2) -> t2 - t1).forEach(System.out::println);
		
	}

     
     public static void main(String[] args) {
		boolean allMatch = Stream.of(1,2,3,4,5).allMatch(new Predicate<Integer>() {
			@Override
			public boolean test(Integer t) {
				return t > 0;
			}
		});
		
		System.out.println(allMatch);
		boolean anyMatch = Stream.of(1,2,3,4,5).anyMatch(new Predicate<Integer>() {
			@Override
			public boolean test(Integer t) {
				return t > 0;
			}
		});
		System.out.println(anyMatch);
		Optional<Integer> max = Stream.of(1,2,3,4,5,6).max((t1,t2) -> t1 - t2);
		Integer max2 = max.get();
		System.out.println(max2);
		Optional<Integer> min = Stream.of(1,2,3,4,5,6).min((t1,t2) -> t1 - t2);
		Integer min2 = max.get();
		System.out.println(min2);
	}

3.Java UDP

UDP:
 * 	数据包：
 * 	DatagramSocket：
 * 	DatagramPacket:
 * 		send():发送数据包
 * 		recevie():接受数据包
     
public class UDPSever {
     public static void main(String[] args) throws Exception {
         byte[] bs = new byte[1024];
         DatagramPacket packet = new DatagramPacket(bs, bs.length);
         DatagramSocket socket = new DatagramSocket(8088);

         socket.receive(packet);
         System.out.println(new String(packet.getData()).trim());
         socket.close();
         System.out.println("关闭服务端");
      }
}

public class UDPClient {
	public static void main(String[] args) throws Exception {
		byte[] bs = "我是客户端，往服务端发送数据".getBytes();
		InetAddress host = InetAddress.getLocalHost();
		DatagramPacket packet = new DatagramPacket(bs, bs.length,host,8088);
		DatagramSocket socket = new DatagramSocket(8080);
		System.out.println("发送数据完成！");
		socket.close();
	}
}