疯狂java讲义零基础

new Thread(new Runnable() {
 @Override public void run() { 
//业务代码 
} }).start();

 new Thread(()->{  //业务代码  }).start();

()  -> { }
// () 为参数列表    ->  为运算符(读作goes to)		{ } 为方法体

public class Exe1 { public static void main(String[] args) { 
ReturnOneParam lambda1 = a -> doubleNum(a);
 System.out.println(lambda1.method(3)); 
//lambda2 引用了已经实现的 doubleNum 方法  此种用法在mybatisplus中用来构建sql语句时常用
 ReturnOneParam lambda2 = Exe1::doubleNum; System.out.println(lambda2.method(3));
 Exe1 exe = new Exe1(); 
//lambda4 引用了已经实现的 addTwo 方法 
ReturnOneParam lambda4 = exe::addTwo; System.out.println(lambda4.method(2)); }
 /**  
  * 要求
  * 1.参数数量和类型要与接口中定义的一致     
  * 2.返回值类型要与接口中定义的一致      
  */ 
public static int doubleNum(int a) {
 return a * 2;
 } 
public int addTwo(int a) { 
return a + 2; 
} }

interface ItemCreatorBlankConstruct {
    Item getItem();
}
interface ItemCreatorParamContruct {
    Item getItem(int id, String name, double price);
}

public class Exe2 {
    public static void main(String[] args) {
        ItemCreatorBlankConstruct creator = () -> new Item();
        Item item = creator.getItem();

        ItemCreatorBlankConstruct creator2 = Item::new;
        Item item2 = creator2.getItem();

        ItemCreatorParamContruct creator3 = Item::new;
        Item item3 = creator3.getItem(112, "鼠标", 135.99);
    }
}

Thread t = new Thread(() -> {
    for (int i = 0; i < 10; i++) {
      System.out.println(2 + ":" + i);
    }
  });
t.start();

ArrayList<Integer> list = new ArrayList<>();

Collections.addAll(list, 1,2,3,4,5);

//lambda表达式 方法引用
list.forEach(System.out::println);

list.forEach(element -> {
    if (element % 2 == 0) {
        System.out.println(element);
    }
});

ArrayList<Item> items = new ArrayList<>();
    items.add(new Item(11, "小牙刷", 12.05 ));
    items.add(new Item(5, "日本马桶盖", 999.05 ));
    items.add(new Item(7, "格力空调", 888.88 ));
    items.add(new Item(17, "肥皂", 2.00 ));	
    items.add(new Item(9, "冰箱", 4200.00 ));

items.removeIf(ele -> ele.getId() == 7);

//通过 foreach 遍历，查看是否已经删除
items.forEach(System.out::println);

ArrayList<Item> list = new ArrayList<>();
list.add(new Item(13, "背心", 7.80));
list.add(new Item(11, "半袖", 37.80));
list.add(new Item(14, "风衣", 139.80));
list.add(new Item(12, "秋裤", 55.33));

/*
        list.sort(new Comparator<Item>() {
            @Override
            public int compare(Item o1, Item o2) {
                return o1.getId()  - o2.getId();
            }
        });
        */

list.sort((o1, o2) -> o1.getId() - o2.getId());

System.out.println(list);

import java.util.function.Consumer;
public class Main {
    public static void main(String[] args) {

        int num = 10;

        Consumer<String> consumer = ele -> {
            System.out.println(num);
        };

        //num = num + 2;
        consumer.accept("hello");
    }
}

interface 接口名{
    修饰符 default 返回值 方法名(){
        //方法体
    }
}

interface 接口名{
    修饰符 static 返回值 方法名(){
        //方法体
    }
}

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

public static void main(String[] args) {
   fun1(()->{
       int[] arr={10,22,78,3,56,43,29,75};
       Arrays.sort(arr);
       return arr[arr.length-1];
   });
}

private static void fun1(Supplier<Integer> supplier){
    Integer max = supplier.get();
    System.err.println("max = "+max);
}

@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);
}

public static void main(String[] args) {
      fun1( msg->{
          System.err.println(msg+" ---转换为大写--- "+msg.toUpperCase());
      });
   }

   private static void fun1(Consumer<String> consumer){
       consumer.accept("consumer accept");
   }

public static void main(String[] args) {
     fun1( msg->{
         System.err.println(msg+" ---转换为大写--- "+msg.toUpperCase());
     },msg2->{
         System.err.println(msg2+" ---转换成小写--- "+msg2.toLowerCase());
     });
  }

  private static void fun1(Consumer<String> c1,Consumer<String> c2){
      String str = "consumer accept";
      c1.andThen(c2).accept(str);  //c1先执行，执行完毕再执行c2
  }

public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);
}

public static void main(String[] args) {
      fun1( msg->{
          return Integer.parseInt(msg);
      });
   }

   private static void fun1(Function<String,Integer> function){
       System.err.println(function.apply("123345"));
   }

@FunctionalInterface
public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);
}

Collection中加入了default方法获取Stream流
List<String> list = new ArrayList<>();
 list.stream();

 Set<String> set = new HashSet<>();
 set.stream();

Map<String,Object> map=new HashMap<>();
  map.keySet().stream();
  map.values().stream();
  map.entrySet().stream();

String[] s1={"aa","bb","cc"};
Stream.of(s1);

public class Tests_forEach {
    public static void main(String[] args) {
    List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("张三四");
        list.add("王五");
        list.add("赵六");
        list.add("张三三");
        list.add("周八");
        // 函数模型：获取流 --> 逐一消费流中的元素
         // 函数模型：获取流 --> 逐一消费流中的元素
        list.stream().forEach(System.err::println);
        /*
        * 虽然方法名称叫做【forEach】，但是与for循环中的【for-each】昵称不同，该方法并不保证元素的逐一消费动作在流中是被有序执行的
        * */
        System.out.println("==========================");
        // parallelStream()方法可以得到并行流
        list.parallelStream().forEach((String name)->{
            System.out.println(name);
        });
    }
}

public class Tests_filter {
    public static void main(String[] args) {
        // 获取stream流
        Stream<String> stream = Stream.of("张三", "张三四", "王五", "赵六", "张三三", "周八");
        // 需求：过滤处
        stream.filter((String name)->{
            return name.startsWith("张");
        }).forEach((String name)->{
            System.out.println(name);
        });
    }
}

public class Tests_limit {
    public static void main(String[] args) {
        // 获取stream流
        Stream<String> stream = Stream.of("张三", "张三四", "王五", "赵六", "张三三", "周八");
        // 需求：保留前3个元素
        stream.limit(3).forEach((String name) -> {
            System.out.println(name);
        });
        System.out.println("===========================");
        // 如果流的获取长度 大于 流当前的长度，则不操作
 
        stream.limit(10).forEach(name-> System.out.println(name)); // 异常： stream has already
                                                // been operated upon or closed 流已**作或关闭
 
        Stream<String> stream1 = Stream.of("张三", "张三四", "王五", "赵六", "张三三", "周八");
        stream1.limit(10).forEach(name-> System.out.println(name));
    }
}

public class Tests_skip {
    public static void main(String[] args) {
        // 获取stream流
        Stream<String> stream = Stream.of("张三", "张三四", "王五", "赵六", "张三三", "周八");
        // 需求：跳过前3个
        stream.skip(3).forEach(name-> System.out.println(name));
    }
}

public class MapDemo {
    public static void main(String[] args) {
        //获取所有学生的姓名，并形成一个新的集合
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student(1,19,"张三","M",true));
        students.add(new Student(1,18,"李四","M",false));
        students.add(new Student(1,21,"王五","F",true));
        students.add(new Student(1,20,"赵六","F",false));

        List<String> collect = students.stream().map(Student::getName).collect(Collectors.toList());
        collect.forEach(s -> System.out.print(s + " "));
    }
}

//结果：张三 李四 王五 赵六

List<Integer> sortLists = new ArrayList<>();
sortLists.add(1);
sortLists.add(4);
sortLists.add(6);
sortLists.add(3);
sortLists.add(2);
List<Integer> afterSortLists = sortLists.stream().sorted((In1,In2)->
       In1-In2).collect(Collectors.toList());

public static void main(String[] args) {
    Stream<String> original1 = Stream.of("Java", "C", "Python");
    Stream<String> original2 = Stream.of("Hadoop", "Spark");
    Stream<String> result = Stream.concat(original1, original2);
    result.forEach(System.out::println);
}

public static void main(String[] args) {
    List<Integer> integers = Arrays.asList(1, 2, 3, 4, 4, 5, 5, 6, 7, 8, 2, 2, 2, 2);
    integers.stream().distinct().collect(Collectors.toList());
    
}

String s = Stream.of("1", "2", "3", "4", "5", "6")
                // identity 是默认值
                .reduce("0",(x, y) -> {
                    System.out.println("x= "+x+" y= "+y);
                    return x +y;
                });
        System.out.println(s);
/**
输出结果：
    x= 0 y= 1
    x= 01 y= 2
    x= 012 y= 3
    x= 0123 y= 4
    x= 01234 y= 5
    x= 012345 y= 6
    0123456
*/

List<String> maxLists = new ArrayList<>();
maxLists.add("a");
maxLists.add("b");
maxLists.add("c");
maxLists.add("d");
maxLists.add("e");
maxLists.add("f");
maxLists.add("hahaha");
int maxLength = maxLists.stream().mapToInt(s->s.length()).max().getAsInt();

System.out.println("字符串长度最长的长度为"+maxLength);

//  判断集合中没有有为‘c’的元素：
List<String> matchList = new ArrayList<>();
matchList.add("a");
matchList.add("a");
matchList.add("c");
matchList.add("d"); 
boolean isExits = matchList.stream().anyMatch(s -> s.equals("c"));

//判断集合中是否全不为空
List<String> matchList = new ArrayList<>();
matchList.add("a");
matchList.add("");
matchList.add("a");
matchList.add("c");
matchList.add("d");
boolean isNotEmpty = matchList.stream().noneMatch(s -> s.isEmpty());

public class Tests {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("张三四");
        list.add("王五");
        list.add("赵六");
        list.add("张三三");
        list.add("周八");
        // 需求：过滤出姓张的并且长度为3的元素
        Stream<String> stream1 = list.stream().filter(name -> name.startsWith("张")).filter(name -> name.length() == 3);
 
        // stream 收集到单列集合中
        List<String> list1 = stream1.collect(Collectors.toList());
        System.out.println(list1);
 
        // stream 收集到单列集合中
        Set<String> set1 = stream1.collect(Collectors.toSet());
        System.out.println(set1);
        
        // 将stream流中的元素转成Array数组对象
        Object[] arr = stream1.toArray();
        System.out.println(Arrays.toString(arr))
    }
}

//串行流转换为并行流
   Stream<String> parallel = Stream.of("1", "2", "3", "4", "5", "6")
           .parallel();
   //List接口直接获取并行流
   Stream<Object> parallelStream = new ArrayList<Object>().parallelStream();

public final class Optional<T> extends Object

public static void main(String[] args) {
    Optional<String> op1 = Optional.of("nihao");
    Optional<Object> op2 = Optional.empty();

    //1、get()方法获取值，有值返回值，无值抛出NoSuchElementException 异常
    System.out.println(op1.get());    //nihao
    System.out.println(op2.get());    //No value present

    //2、isPresent() 判断是否包含值，包含值返回true，不包含返回false
    //   ifPresent(T->{...}) 如果存在值就执行Lambda表达式
    System.out.println(op1.isPresent());  //true
    System.out.println(op2.isPresent());  //false

    //3、 orElse(T t) 如果调用对象包含值，就返回该值，否则返回t
    //   orElseGet(Supplier s) 如果调用对象包含值，就返回该值，否则返回Lambda表达式的返回值
    System.out.println(op1.orElse("hi"));   //nihao
    System.out.println(op2.orElse("123"));  //123
    
}

//获取当前日期
LocalDate currDate=LocalDate.now();
//指定日期
LocalDate noeDay=LocalDate.of(2020, 1, 11);
//通过字符串指定日期
LocalDate towDay=LocalDate.parse("2020-01-11");

// 年
int year = currDate.getYear();
// 月
int month = currDate.getMonthValue();
// 一月的第几天
int day = currDate.getDayOfMonth();
// 一周的第几天
int week = currDate.getDayOfWeek().getValue();

//   时间比较（LocalDate重写了equals方法，让日期的比较也变得简单了。）

System.out.println("比较两个日期是否相同："+date1.equals(date2));  //true
//isBefore在之前
boolean isBefore=LocalDate.parse("2020-01-11").isBefore(LocalDate.parse("2020-01-10"));
//isAfter在之后
boolean isAfter=LocalDate.parse("2020-01-11").isAfter(LocalDate.parse("2020-01-10"));

// 日期加减
System.out.println("当前时间"+LocalDate.now());
System.out.println("当前时间加1天"+LocalDate.now().plusDays(1));
System.out.println("当前时间加1月"+LocalDate.now().plusMonths(1));
System.out.println("当前时间加1年"+LocalDate.now().plusYears(1));

//LocalDate的atTime()方法或LocalTime的atDate()方法将LocalDate或LocalTime合并成一个LocalDateTime。
//LocalDateTime与LocalDate和LocalTime之间可以相互转化
LocalDateTime datetime4=LocalDate.now().atTime(LocalTime.now());
LocalDateTime datetime5=LocalTime.now().atDate(LocalDate.now());

//ZonedDateTime-创建时区时间。用于处理带时区的日期和时间。ZoneId表示不同的时区。大约有40不同的时区。

Set<String> allZoneIds=ZoneId.getAvailableZoneIds();
//创建时区：
ZoneId zoneId=ZoneId.of("Asia/Shanghai");
//把LocalDateTime转换成特定的时区：
ZonedDateTime zonedDateTime=ZonedDateTime.of(LocalDateTime.now(), zoneId);
//获取当前时区
ZoneId z=ZoneId.systemDefault();
//获取日期时间：
ZonedDateTime dd = ZonedDateTime.now();
ZonedDateTime date1 = ZonedDateTime.parse("2015-12-03T10:15:30+05:30[Asia/Shanghai]");

LocalDateTime dateTime=LocalDateTime.now();
String str=dateTime.format(DateTimeFormatter.ISO_DATE_TIME);
System.out.println(str);
str = dateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
System.out.println(str);

//日期时间差
LocalDate today = LocalDate.now();
LocalDate birthDate = LocalDate.of(1993, Month.OCTOBER, 19);
Period p = Period.between(birthDate, today);   //  birthDate - today
System.out.printf("年龄 : %d 年 %d 月 %d 日", p.getYears(), p.getMonths(), p.getDays()); 

//时分秒时间差
Instant inst1 = Instant.now();
Instant inst2 = inst1.plus(Duration.ofSeconds(10));
System.out.println("Difference in milliseconds : " + Duration.between(inst1, inst2).toMillis()); 
System.out.println("Difference in seconds : " + Duration.between(inst1, inst2).getSeconds());

//ChronoUnit类可用于在单个时间单位内测量一段时间，例如天数或秒
LocalDate startDate = LocalDate.of(1993, Month.OCTOBER, 19);
System.out.println("开始时间  : " + startDate);
LocalDate endDate = LocalDate.of(2017, Month.JUNE, 16);
System.out.println("结束时间 : " + endDate);
long daysDiff = ChronoUnit.DAYS.between(startDate, endDate);
System.out.println("两天之间的差在天数   : " + daysDiff);//两天之间的差在天数   : 8641

节点流针对的是具体的数据源操作的流，比如正对文件操作的流，针对字符数组操作的流，针对管道操作的流，针对字符串操作的流，
因此节点流只能处理固定数据格式存储的数据，因此如果在网络编程中不知道对方传递的是什么格式的数据时使用比较困难。
具体有：
FileInputStream /FileOutputStream
FileReader / FileWriter
ByteArrayInputStream / ByteArrayOutputStream
ByteArrayReader / ByteArrayWriter
PipedInputStream /PipedOutputStream
PipedReader / PipedWriter
StringReader / StringWriter

包装流实际上是对节点流的一种封装，性能比节点流更加强大，用到的是【装饰器设计模式】，包装流的强大的地方在于可以接受任意格式的节点
流数据，对于网络编程常用的是包装流来处理。
具体有
BufferedInputStream /BufferedOutputStream
BufferedReader / BufferedWriter
InputStreamReader /OutputStreamWriter
ObjectInputStream /ObjectOutputStream

public static void main(String[] args) {
        int a = 5;
        Date d = new Date();
        // 警告
        System.out.println(d.getYear());
}
// Date类中的getYear()函数
@Deprecated
public int getYear() {
   return normalize().getYear() - 1900;
}

@SuppressWarnings("all")
public static void main(String[] args) {
    int a = 5;
    Date d = new Date();
    System.out.println(d.getYear());
}

/**
 * @ClassName: Foo
 * @Author: Tang
 * @Date: 2021/6/4 15:01
 */
public class Foo {
    @Test
    public static void m1() {

    }

    @Test
    public static void m2() {
        throw new RuntimeException("m2 function error");
    }

    @Test
    public static void m3() {
    }

    @Test
    public static void m4() {
        throw new RuntimeException("m4 function error");
    }

    @Test
    public static void m5() {
    }
}

public class Demo1 {
    public static void main(String[] args)throws Exception {
        // 记录通过以及不同的个数
        int pass = 0, failed = 0;
        String className = "exmple.com.demo8.Foo";
        // 获取Foo类中的所有方法
        for (Method m : Class.forName(className).getMethods()) {
            // 判断是否有@Test注解
            if (m.isAnnotationPresent(Test.class)) {
                try {
                    m.invoke(null);
                    pass++;
                } catch (Throwable ex) {
                    System.out.printf("测试: %s 失败: %s %n", m, ex.getCause());
                }
            }
        }
        System.out.printf("通过: %d, 失败 %d%n", pass, failed);
    }
}
// 表示该注解会保留在class文件中
@Retention(RetentionPolicy.RUNTIME)
// 表示该注解只会作用于方法上
@Target(ElementType.METHOD)
@interface  Test {

}

public class Foo {
    // 给a赋值
    @SingleTest(1)
    public static void m1(int a) {
        if (a < 0) {
            throw new RuntimeException("m1 function parameter error");
        }
    }
    // 等价于@SingleTest(-2)
    @SingleTest(value = -2)
    public static void m2(int b) {
        if (b < 0) {
            throw new RuntimeException("m2 function parameter error");
        }
    }
}

public class Demo2 {
    public static void main(String[] args) throws ClassNotFoundException {
        int pass = 0, failed = 0;
        String className = "exmple.com.demo8.Foo";
        for (Method m : Class.forName(className).getMethods()) {
            // 判断是否有SingleTest注解
            if (m.isAnnotationPresent(SingleTest.class)) {
                // 输出函数名
                System.out.println(m.getName());
                // 获取方法上的注解
                SingleTest st = m.getAnnotation(SingleTest.class);

                try {
                    // 将获取到的值赋值给方法的形参
                    m.invoke(null, st.value()); // 等价SingleTest.value()
                    pass++;
                } catch (Throwable e) {
                    System.out.printf("测试: %s 失败: %s %n", m, e.getCause());
                    failed++;
                }

            }

        }
        System.out.printf("通过: %d, 失败: %d%n", pass, failed);
    }
}

// 表示该注解会保留在class文件中
@Retention(RetentionPolicy.RUNTIME)
// 表示该注解只能用于方法中
@Target(ElementType.METHOD)
@interface SingleTest {
    // 定义一个int类型变量，默认值为0
    // 与int a() default 0;等价
    int value() default 0;
}

// 表示该注解会保留在class文件中
@Retention(RetentionPolicy.RUNTIME)
// 表示该注解只能用于方法中
@Target(ElementType.METHOD)
@interface SingleTest {
    // 定义一个int类型变量，默认值为0
    int a() default 0;
    int b() default 0;
}

// 使用注解时
@SingleTest(a = 1)
public static void m1(int a) {
    if (a < 0) {
      throw new RuntimeException("m1 function parameter error");
    }
}
@SingleTest(a = -2, b = 2)
public static void m2(int a, int b) {
  if (b < 0) {
     throw new RuntimeException("m2 function parameter error");
  }
}

// 反射机制给方法形参赋值时
m.invoke(null, st.a(), st.b()); // 等价于SingleTest.a()

public class Demo3 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class c1 = Class.forName("exmple.com.demo8.MySupperClass1");
        Class c2 = Class.forName("exmple.com.demo8.MySubClass1");
        System.out.println("使用了@Inherited: ");
        System.out.println("父类: " + c1.getAnnotations().length);
        System.out.println("子类:" + c2.getAnnotations().length);

        System.out.println("没有使用@Inherited: ");
        Class c3 = Class.forName("exmple.com.demo8.MySupperClass2");
        Class c4 = Class.forName("exmple.com.demo8.MySubClass2");
        System.out.println("父类:" + c3.getAnnotations().length);
        System.out.println("子类:" + c4.getAnnotations().length);
    }
}
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@interface MyAnnotation1 {}

@MyAnnotation1
class MySupperClass1 {}

class MySubClass1 extends MySupperClass1 {}

@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2 {}

@MyAnnotation2
class MySupperClass2 {}

class MySubClass2 extends MySupperClass2 {}

public class Demo4 {
    public static void main(String[] args) throws ClassNotFoundException {
        String className = "exmple.com.demo8.Student";
        // 获取目标对象的所有方法
        for (Method m : Class.forName(className).getMethods()) {
            // 判断是否有容器注解
            if (m.isAnnotationPresent(RepeatableAnnotations.class)) {
                RepeatableAnnotation[] annos =                               m.getAnnotationsByType(RepeatableAnnotation.class);

                for (RepeatableAnnotation anno : annos) {
                    System.out.println(anno.a() + "," + anno.b() + "," + anno.c());
                    try {
                        // 将获取到的值传递给方法形参
                        m.invoke(null, anno.a(), anno.b(), anno.c());
                    } catch (Throwable ex) {
                        System.out.printf("测试: %s 失败: %s %n", m, ex.getCause());
                    }

                }
            }

        }

    }
}
class Student {
    @RepeatableAnnotation(a = 1, b = 2, c = 3)
    @RepeatableAnnotation(a = 1, b = 2, c = 4)
    public static void add(int a, int b, int c) {
        if (c != a + b) {
            throw new RuntimeException("add function error");
        }
    }
}
@Retention(RetentionPolicy.RUNTIME)
// 运行该注解可以重复标注
@Repeatable(RepeatableAnnotations.class)
@interface RepeatableAnnotation {
    int a() default 0;
    int b() default 0;
    int c() default 0;
}
// 容器注解
@Retention(RetentionPolicy.RUNTIME)
@interface RepeatableAnnotations {
    RepeatableAnnotation[] value();
}

FileOutputStream(File file) 
FileOutputStream(String name)

public class OutputStreamDemo {
    public static void main(String[] args) throws IOException {
        OutputStream fos = new FileOutputStream("demo1.txt");
  /*
   * 创建字节输出流对象了做了几件事情：
   * A:调用系统功能去创建文件
   * B:创建fos对象
   * C:把fos对象指向这个文件
   */

        //写数据
        fos.write("hello,IO".getBytes());
        fos.write("java".getBytes());

        //释放资源
        //关闭此文件输出流并释放与此流有关的所有系统资源。
        fos.close();
  /*
   * 为什么一定要close()呢?
   * A:让流对象变成垃圾，这样就可以被垃圾回收器回收了
   * B:通知系统去释放跟该文件相关的资源
   */
        //java.io.IOException: Stream Closed
        //fos.write("java".getBytes());
    }
}

public void write(int b) //写一个字节
public void write(byte[] b) //写一个字节数组
public void write(byte[] b,int off,int len) //写一个字节数组的一部分

public class OutputStreamDemo2 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("demo2.txt");

        // 调用write()方法
        fos.write(97); //97 -- 底层二进制数据 -- 通过记事本打开 -- 找97对应的字符值 -- a

        //public void write(byte[] b):写一个字节数组
        byte[] bys={98,99,100,101};
        fos.write(bys);

        //public void write(byte[] b,int off,int len):写一个字节数组的一部分
        fos.write(bys,1,3);

        //释放资源
        fos.close();
    }
}

windows:\r\n
linux:\n
Mac:\r

public class OutputStreamDemo3 {
    public static void main(String[] args) throws IOException {
        // 创建一个向具有指定 name 的文件中写入数据的输出文件流。
        // 如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。
        FileOutputStream fos = new FileOutputStream("demo2.txt",true);

        // 写数据
        for (int x = 0; x < 10; x++) {
            fos.write(("hello" + x).getBytes());
            fos.write("\r\n".getBytes());
        }

        //释放资源
        fos.close();
    }
}

public class OutputStreamDemo4 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("demo1.txt");
            fos.write("java".getBytes());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 如果fos不是null，才需要close()
            if (fos != null) {
                // 为了保证close()一定会执行，就放到这里了
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

int read() //一次读取一个字节
int read(byte[] b) //一次读取一个字节数组

public class InputStreamDemo {
    public static void main(String[] args) throws IOException {
        InputStream fis=new FileInputStream("demo1.txt");
        int by = 0;
        // 读取，赋值，判断
        while ((by = fis.read()) != -1) {
            System.out.print((char) by);
        }

        // 释放资源
        fis.close();
    }
}

public class InputStreamDemo2 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis=new FileInputStream("demo1.txt");
        //数组的长度一般是1024或者1024的整数倍
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = fis.read(bys)) != -1) {
            System.out.print(new String(bys, 0, len));
        }

        // 释放资源
        fis.close();
    }
}

public class BufferedOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        BufferedOutputStream bos=new
                BufferedOutputStream(new FileOutputStream("demo1.txt"));
        bos.write("hello".getBytes());
        bos.close();
    }
}

public class BufferedInputStreamDemo {
    public static void main(String[] args) throws IOException {
        BufferedInputStream bis=new
                BufferedInputStream(new FileInputStream("demo1.txt"));
        int by=-1;
        while((by=bis.read())!=-1){
            System.out.print((char)by);
        }
        bis.close();
    }
}

public class CopyFile {
    public static void main(String[] args) throws IOException {
        String strFile="国旗歌.mp4";
        String destFile="demo3.mp4";
        long start = System.currentTimeMillis();
        //copyFile(strFile,destFile); //共耗时：75309毫秒
        //copyFile2(strFile,destFile); //共耗时：153毫秒
        //copyFile3(strFile,destFile);//共耗时：282毫秒
        copyFile4(strFile,destFile);//共耗时：44毫秒
        long end = System.currentTimeMillis();
        System.out.println("共耗时：" + (end - start) + "毫秒");
    }

    /**
     * 基本字节流一次读写一个字节
     */
    public static void copyFile(String srcFile,String destFile) throws IOException {
        FileInputStream fis=new FileInputStream(srcFile);
        FileOutputStream fos=new FileOutputStream(destFile);

        int by=0;
        while((by=fis.read())!=-1){
            fos.write(by);
        }

        fis.close();
        fos.close();
    }

    /**
     * 基本字节流一次读写一个字节数组
     */
    public static void copyFile2(String srcFile,String destFile) throws IOException{
        FileInputStream fis=new FileInputStream(srcFile);
        FileOutputStream fos=new FileOutputStream(destFile);

        int len=0;
        byte[] bys=new byte[1024];
        while((len=fis.read(bys))!=-1){
            fos.write(bys,0,len);
        }

        fis.close();
        fos.close();
    }

    /**
     * 高效字节流一次读写一个字节
     */
    public static void copyFile3(String srcFile,String destFile) throws IOException{
        BufferedInputStream bis=new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(destFile));

        int by=0;
        while((by=bis.read())!=-1){
            bos.write(by);
        }

        bis.close();
        bos.close();
    }

    /**
     * 高效字节流一次读写一个字节数组
     */
    public static void copyFile4(String srcFile,String destFile) throws IOException{
        BufferedInputStream bis=new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(destFile));

        int len=0;
        byte[] bys=new byte[1024];
        while((len=bis.read(bys))!=-1){
            bos.write(bys,0,len);
        }

        bis.close();
        bos.close();
    }
}

FileInputStream fileInputStream = new FileInputStream(filePath);
BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);

/**
 * 序列化就是将一个对象转换成字节序列，方便存储和传输。
 - 序列化：ObjectOutputStream.writeObject()
 - 反序列化：ObjectInputStream.readObject()
 */
public class SerializableDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        String objectFile="demo6.txt";

        //序列化
        serialize(objectFile);
        //反序列化
        deserialize(objectFile);
    }

    //序列化
    public static void serialize(String objectFile) throws IOException {
        A a=new A(1,"aaa");
        ObjectOutputStream objectOutputStream=new ObjectOutputStream(new FileOutputStream(objectFile));
        //序列化
        objectOutputStream.writeObject(a);
        objectOutputStream.close();
    }

    //反序列化
    public static void deserialize(String objectFile) throws IOException, ClassNotFoundException {
        ObjectInputStream objectInputStream=new ObjectInputStream(new FileInputStream(objectFile));
        A a2=(A)objectInputStream.readObject();
        System.out.println(a2);
        objectInputStream.close();
    }

    private static class A implements Serializable {

        private int x;
        private String y;

        A(int x, String y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public String toString() {
            return "x = " + x + "  " + "y = " + y;
        }
    }
}

x = 1  y = aaa

private static class A implements Serializable {

        private int x;
        private transient String y; //transient 关键字可以使一些属性不会被序列化。

        A(int x, String y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public String toString() {
            return "x = " + x + "  " + "y = " + y;
        }
    }

x = 1  y = null

InetAddress.getByName(String host);
InetAddress.getByAddress(byte[] address);

public class NetDemo {
    public static void main(String[] args) throws UnknownHostException {
        // public static InetAddress getByName(String host)
        InetAddress address = InetAddress.getByName("LAPTOP-D9966H06");
        //InetAddress address = InetAddress.getByName("223.3.108.211");
        //InetAddress address = InetAddress.getByName("192.168.2.1");

        // 获取两个东西：主机名，IP地址
        // public String getHostName()
        String name = address.getHostName();
        // public String getHostAddress()
        String ip = address.getHostAddress();
        System.out.println(name + "---" + ip);
    }
}

public static void main(String[] args) throws IOException {

    URL url = new URL("http://www.baidu.com");

    /* 字节流 */
    InputStream is = url.openStream();

    /* 字符流 */
    InputStreamReader isr = new InputStreamReader(is, "utf-8");

    /* 提供缓存功能 */
    BufferedReader br = new BufferedReader(isr);

    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }

    br.close();
}

public class SendDemo {
    public static void main(String[] args) throws IOException {
        //1. 创建发送端Socket对象
        DatagramSocket ds=new DatagramSocket();

        //2. 创建数据，并把数据打包
        byte[] bys="hello".getBytes();
        // 长度
        int length = bys.length;
        // IP地址对象
        InetAddress address = InetAddress.getByName("LAPTOP-D9966H06");
        // 端口
        int port = 10086;
        DatagramPacket dp = new DatagramPacket(bys, length, address, port);

        //3. 调用Socket对象的发送方法发送数据包
        ds.send(dp);

        //4. 释放资源
        ds.close();
    }
}

public class ReceiveDemo {
    public static void main(String[] args) throws IOException {
        //1. 创建接收端Socket对象
        DatagramSocket ds=new DatagramSocket(10086);

        //2. 创建一个数据包(接收容器)
        byte[] bys=new byte[1024];
        int length=bys.length;
        DatagramPacket dp=new DatagramPacket(bys,length);

        //3. 调用Socket对象的接收方法接收数据
        //public void receive(DatagramPacket p)
        ds.receive(dp);//阻塞式

        //4. 解析数据包，并显示在控制台
        InetAddress inetAddress=dp.getAddress();
        String ip=inetAddress.getHostAddress();
        // public byte[] getData():获取数据缓冲区
        // public int getLength():获取数据的实际长度
        byte[] bys2 = dp.getData();
        int len = dp.getLength();
        String s = new String(bys2, 0, len);
        System.out.println(ip + "传递的数据是:" + s);

        //5. 释放资源
        ds.close();
    }
}

public class ReceiveDemo2 {
    public static void main(String[] args) throws IOException {
        DatagramSocket ds=new DatagramSocket(12345);

        while (true){
            byte[] bys=new byte[1024];
            DatagramPacket dp=new DatagramPacket(bys,bys.length);

            ds.receive(dp);
            //阻塞式

            String ip=dp.getAddress().getHostAddress();
            String s = new String(dp.getData(), 0, dp.getLength());
            System.out.println(ip + "传递的数据是:" + s);
        }

        //接收端应该一直开着等待接收数据，不需要释放资源
        //ds.close();
    }
}

public class SendDemo2 {
    public static void main(String[] args) throws IOException {
        DatagramSocket ds=new DatagramSocket();

        //封装键盘录入数据
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        String line=null;

        while(true){
            line=br.readLine();
            if("-1".equals(line)){
                break;
            }
            byte[] bys=line.getBytes();
            DatagramPacket dp=
                    new DatagramPacket(bys,bys.length,InetAddress.getByName("LAPTOP-D9966H06"),12345);
            ds.send(dp);
        }

        br.close();
        //4. 释放资源
        ds.close();
    }
}

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //1. 创建发送端的Socket对象:这一步如果成功，就说明连接已经建立成功了。
        Socket socket=new Socket("LAPTOP-D9966H06",8888);

        //2. 获取输出流，写数据
        OutputStream outputStream=socket.getOutputStream();
        outputStream.write("hello".getBytes());

        //3. 释放资源
        socket.close();
    }
}

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //1. 创建接收端的Socket对象
        ServerSocket serverSocket=new ServerSocket(8888);

        //2. 监听客户端连接。返回一个对应的Socket对象
        Socket socket=serverSocket.accept();

        //3. 获取输入流，读取数据显示在控制台
        InputStream inputStream=socket.getInputStream();

        byte[] bys = new byte[1024];
        int len = inputStream.read(bys);
        // 阻塞式方法
        String str = new String(bys, 0, len);

        String ip = socket.getInetAddress().getHostAddress();

        System.out.println(ip + "---" + str);

        //4. 释放资源
        socket.close();
    }
}

public class ServerDemo2 {
    public static void main(String[] args) throws IOException {
        //1. 创建接收端的Socket对象
        ServerSocket serverSocket=new ServerSocket(8888);

        //2. 监听客户端连接。返回一个对应的Socket对象
        Socket socket=serverSocket.accept();

        //3. 获取输入流，读取数据显示在控制台
        InputStream inputStream=socket.getInputStream();
        byte[] bys = new byte[1024];
        int len = inputStream.read(bys);
        String str = new String(bys, 0, len);
        String ip = socket.getInetAddress().getHostAddress();
        System.out.println(ip + "---" + str);

        //向客户端发送数据
        OutputStream outputStream=socket.getOutputStream();
        outputStream.write("数据已经收到".getBytes());

        //4. 释放资源
        socket.close();
    }
}

public class ClientDemo2 {
    public static void main(String[] args) throws IOException {
        //1. 创建发送端的Socket对象:这一步如果成功，就说明连接已经建立成功了。
        Socket socket=new Socket("LAPTOP-D9966H06",8888);

        //2. 获取输出流，写数据
        OutputStream outputStream=socket.getOutputStream();
        outputStream.write("hello".getBytes());

        //从服务端获取反馈信息
        InputStream inputStream=socket.getInputStream();
        byte[] bys=new byte[1024];
        int len=inputStream.read(bys);
        String reback=new String(bys,0,len);
        System.out.println("reback:"+reback);

        //3. 释放资源
        socket.close();
    }
}

public class ServerDemo3 {
    public static void main(String[] args) throws IOException {
        //1. 创建接收端的Socket对象
        ServerSocket serverSocket=new ServerSocket(8888);

        //2. 监听客户端连接。返回一个对应的Socket对象
        Socket socket=serverSocket.accept();

        //3. 获取输入流，读取数据显示在控制台
        //这里对输入流要进行包装
        InputStream inputStream=socket.getInputStream();
        BufferedReader br=new BufferedReader(new InputStreamReader(inputStream));
        String line=null;
        while((line=br.readLine())!=null){
            System.out.println(line);
        }

        //4. 释放资源
        socket.close();
    }
}

public class ClientDemo3 {
    public static void main(String[] args) throws IOException {
        //1. 创建发送端的Socket对象:这一步如果成功，就说明连接已经建立成功了。
        Socket socket=new Socket("LAPTOP-D9966H06",8888);

        //键盘录入数据
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

        //2. 获取输出流，写数据
        //对输出流进行包装
        OutputStream outputStream=socket.getOutputStream();
        BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(outputStream));

        String line=null;

        while(true){
            line=br.readLine();
            if("-1".equals(line)){
                break;
            }
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        //3. 释放资源
        socket.close();
    }
}

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> evenNumbers = numbers.stream()
                                   .filter(num -> num % 2 == 0)
                                   .collect(Collectors.toList()); //[2, 4]

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<Integer> nameLengths = names.stream()
                                 .map(String::length)  //映射为长度
                                 .collect(Collectors.toList()); //  [5, 3, 7]

List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5);
List<Integer> sortedNumbers = numbers.stream()
                                     .sorted()
                                     .collect(Collectors.toList()); //  [1, 1, 2, 3, 4, 5, 5, 6, 9]

List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 3, 3, 4, 4, 4, 4);
List<Integer> distinctNumbers = numbers.stream()
                                       .distinct()
                                       .collect(Collectors.toList());// [1, 2, 3, 4]

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> limitedNumbers = numbers.stream()
                                      .limit(3)
                                      .collect(Collectors.toList());// [1, 2, 3]

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> skippedNumbers = numbers.stream()
                                      .skip(2)
                                      .collect(Collectors.toList());// [3, 4, 5]

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.stream()
     .forEach(System.out::println);//控制台输出每个字符串

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> collectedNames = names.stream()
                                   .collect(Collectors.toList());// 将流中的元素收集到List中

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
long count = names.stream()
                  .count();// 返回3