javase

day16/day16.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

day16/src/com/four/day16/fanxing01/Demo01.java

@@ -0,0 +1,2 @@
+package com.four.day16.fanxing01;public class Demo01 {
+}

day16/src/com/four/day16/fanxing01/Student.java

@@ -0,0 +1,2 @@
+package com.four.day16.fanxing01;public class Student {
+}

day16/src/com/four/day16/fanxing02/ComparaUtils.java

@@ -0,0 +1,20 @@
+package com.four.day16.fanxing02;
+
+public class ComparaUtils {
+
+    /**
+     * 方法 比较
+     * 参数
+     * 返回值 负数  0 正整数
+     */
+    public static <T> Integer compare( T t1, T t2 ){
+        //逻辑
+        //强转
+        Comparable t11 = (Comparable) t1;
+        Comparable t22 = (Comparable) t2;
+
+        return t11.compareTo(t22);
+    }
+
+
+}

day16/src/com/four/day16/fanxing02/Demo01.java

@@ -0,0 +1,2 @@
+package com.four.day16.fanxing02;public class Demo01 {
+}

day16/src/com/four/day16/fanxing02/Demo02.java

@@ -0,0 +1,23 @@
+package com.four.day16.fanxing02;
+
+public class Demo01 {
+
+
+    //泛型方法  有参数无返回值
+    public static  <T> void m2( T t ) {
+        System.out.println("t:"+t);
+    }
+
+    //泛型方法  有参数返回值 返回泛型
+    public static <T> T m3( T t ) {
+        System.out.println("t:"+t);
+        return t;
+    }
+
+    //泛型方法  有参数返回值 返回泛型
+    public static <T> boolean m4( T t ) {
+        System.out.println("t:"+t);
+        return true;
+    }
+
+}

day16/src/com/four/day16/fanxing02/Demo03.java

@@ -0,0 +1,23 @@
+package com.four.day16.fanxing02;
+
+public class Demo03 {
+
+
+    public static void main(String[] args) {
+
+        //传入类型 就是T
+        Demo01.m2("oooooooo");
+
+        //有返回
+        Integer i = Demo01.m3(11111111);
+        System.out.println("i = " + i);
+
+        boolean b1 = Demo01.m4("123");
+        boolean b2 = Demo01.m4(1.2);
+
+        System.out.println(b1);
+        System.out.println(b2);
+
+    }
+
+}

day16/src/com/four/day16/fanxing02/Person.java

@@ -0,0 +1,2 @@
+package com.four.day16.fanxing02;public class Person {
+}

day16/src/com/four/day16/fanxing03/TestWild.java

@@ -0,0 +1,4 @@
+package com.four.day16.fanxing03;
+
+public class TestWild {
+}

day16/src/com/four/day16/fanxing03/TestWild2.java

@@ -0,0 +1,71 @@
+package com.four.generic;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+public class TestWild2 {
+    /*
+    定义一个方法，这个方法的作用是用于遍历一个Collection系列的集合。
+    遍历的效果是：
+        第1个元素：xxx
+        第2个元素：xxx
+        第3个元素：xxx
+
+    要求，集合的元素类型只能是Number或Number的子类。
+
+ 此时<? extends Number>可能是<Double>，<Integer>，<BigDecimal>。。。。
+ 它们必须是继承Number类
+ */
+    public void print(Collection<? extends Number> coll){
+        int count = 0;
+        for (Object object : coll) {//增强for循环，或foreach循环。
+            count++;
+            System.out.println("第" + count +"个元素：" + object);
+        }
+    }
+/*    @Test
+    public void test1(){
+        //第一个集合
+        ArrayList<String> list = new ArrayList<>();
+        list.add("hello");
+        list.add("world");
+        list.add("java");
+
+        print(list);//因为String不是Number的子类
+    }*/
+
+    @Test
+    public void test2(){
+        //第二个集合
+        ArrayList<Integer> list = new ArrayList<>();
+        list.add(10);
+        list.add(20);
+        list.add(30);
+
+        print(list);
+    }
+
+    @Test
+    public void test3(){
+        //第三个集合
+        ArrayList<Double> list = new ArrayList<>();
+        list.add(10.0);
+        list.add(20.0);
+        list.add(30.0);
+
+        print(list);
+    }
+
+    @Test
+    public void test4(){
+        //第三个集合
+        ArrayList<Object> list = new ArrayList<>();
+        list.add(10.0);
+        list.add(20.0);
+        list.add(30.0);
+
+//        print(list);//Object是Number的父类
+    }
+}

day16/src/com/four/day16/fanxing03/TestWild3.java

@@ -0,0 +1,71 @@
+
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+public class TestWild3 {
+    /*
+    定义一个方法，这个方法的作用是用于遍历一个Collection系列的集合。
+    遍历的效果是：
+        第1个元素：xxx
+        第2个元素：xxx
+        第3个元素：xxx
+
+    要求，集合的元素类型必须指定为Number或Number的父类。
+
+ 此时<? super Number>可能是<Number>，<Object>
+ 它们必须Number类或Number的父类
+ */
+    public void print(Collection<? super Number> coll){
+        int count = 0;
+        for (Object object : coll) {//增强for循环，或foreach循环。
+            count++;
+            System.out.println("第" + count +"个元素：" + object);
+        }
+    }
+    @Test
+    public void test1(){
+        //第一个集合
+        ArrayList<String> list = new ArrayList<>();
+        list.add("hello");
+        list.add("world");
+        list.add("java");
+
+//        print(list);//因为String不是Number的父类
+    }
+
+    @Test
+    public void test2(){
+        //第二个集合
+        ArrayList<Integer> list = new ArrayList<>();
+        list.add(10);
+        list.add(20);
+        list.add(30);
+
+//        print(list);//Integer也不是Number的父类
+    }
+
+    @Test
+    public void test3(){
+        //第三个集合
+        ArrayList<Double> list = new ArrayList<>();
+        list.add(10.0);
+        list.add(20.0);
+        list.add(30.0);
+
+//        print(list);//Double也不是Number的父类
+    }
+
+    @Test
+    public void test4(){
+        //第三个集合
+        ArrayList<Object> list = new ArrayList<>();
+        list.add(10.0);
+        list.add(20.0);
+        list.add(30.0);
+
+        print(list);//Object是Number的父类
+    }
+}

day16/src/com/four/day16/homework/Circle.java

@@ -0,0 +1,2 @@
+package com.four.day16.homework;public class Circle {
+}

day16/src/com/four/day16/homework/Demo01.java

@@ -0,0 +1,2 @@
+package com.four.day16.homework;public class Demo01 {
+}

day16/src/com/four/day16/homework/Demo02.java

@@ -0,0 +1,79 @@
+package com.four.day16.homework;
+
+import org.junit.Test;
+
+import java.util.*;
+import java.util.function.Predicate;
+
+public class Demo01 {
+
+    @Test
+    public void test01(){
+        Collection<String> coll = new ArrayList<>();
+        coll.add("hello");
+        coll.add("java");
+        coll.add("world");
+        coll.add("four");
+        coll.add("love");
+        coll.add("you");
+        coll.add("mom");
+        coll.add("dad");
+        coll.add("noon");
+
+        //接口  Predicate  断言型接口  返回boolean 判断型接口
+        // 方法  boolean test(T t); 方法声明。 功能。传入参数 判断是否符合某种条件。 判断的方法。
+        //Predicate  是否符合回文字符串。
+
+        // 需要计算的方法。
+        //接口使用 匿名内部类。
+        Predicate<String> predicate = new Predicate<>() {
+            @Override
+            public boolean test(String s) {
+                //是否符合回文字符串。
+                return s.equals(new StringBuilder(s).reverse().toString());
+            }
+        };
+
+        //removeIf
+        coll.removeIf(predicate);
+
+        System.out.println(coll);
+
+        //调用方法的参数。必须符合。
+
+    }
+
+    @Test
+    public void test02() {
+        Random random = new Random();
+        HashSet<Integer> set = new HashSet<>();
+
+        while (set.size() < 10 ){
+            set.add(random.nextInt(20));
+        }
+
+//        for (int i = 1; i <=10 ; i++) {
+//            set.add(random.nextInt(50));
+//        }
+
+        System.out.println("100以内的随机偶数个数有：" + set.size());
+        System.out.println(set);
+    }
+
+    @Test
+    public void test03() {
+
+        TreeSet<Circle> treeSet = new TreeSet<>();
+
+        //添加时排序
+        treeSet.add(new Circle(5));
+        treeSet.add(new Circle(1));
+        treeSet.add(new Circle(2));
+        treeSet.add(new Circle(4));
+        treeSet.add(new Circle(6));
+
+        System.out.println(treeSet);
+
+    }
+
+}

day16/src/com/four/day16/list01/Demo01.java

@@ -0,0 +1,2 @@
+package com.four.day16.list01;public class Demo01 {
+}

day16/src/com/four/day16/list01/Demo02.java

@@ -0,0 +1,57 @@
+package com.four.day16.list01;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+public class Demo01 {
+
+
+    @Test
+    public void test01(){
+        //删除 看传递的参数 int类型
+        // remove（object） boolean remove(Object o);  兼容的
+        // remove（下标）         E remove(int index); //匹配的
+        //构成 重载
+        //调用方法 参数 匹配的 兼容的
+        List<Integer> list = new ArrayList();
+
+        list.add(1);
+        list.add(2);
+        list.add(3);
+        list.add(4);
+        list.add(1);
+
+        //多态
+        /*
+            Collection c = new ArrayList();
+            只能使用Collection 里面声明的方法。不能使用特有的方法ArrayList
+
+            List<Integer> list = new ArrayList();
+         */
+
+        list.remove(1); //??
+        System.out.println(list);
+
+    }
+
+
+    @Test
+    public void test02(){
+
+        // remove（object） boolean remove(Object o);  兼容的
+        // remove（下标）         E remove(int index); //匹配的
+        List<String> list = new ArrayList();
+
+        list.add("1");
+        list.add("2");
+
+        list.remove("1"); //??
+        System.out.println(list);
+
+    }
+
+
+}

day16/src/com/four/day16/list01/Demo03.java

@@ -0,0 +1,117 @@
+package com.four.day16.list01;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.UnaryOperator;
+
+public class Demo02 {
+
+    //set（下标，新元素）
+    @Test
+    public void test01(){
+        List<String> list = new ArrayList();
+        list.add("a");
+        list.add("b");
+        list.add("c");
+        list.add("d");
+
+        String i = list.set(1, "aaa");
+
+        System.out.println(i);
+
+        System.out.println(list);
+
+    }
+
+    /*
+    replaceAll（UnaryOperator接口的实现类对象）：
+    需要编写匿名内部类实现UnaryOperator接口，重写apply抽象方法
+
+    R apply(T t); 传入 A 返回 B。 函数式 接口 Funcion
+
+    public interface UnaryOperator<T> extends Function<T, T> {
+    A apply(A a); 传入 A 返回 A 返回的A 替换传入A。
+
+     */
+    @Test
+    public void test02(){
+        List<Integer> list = new ArrayList();
+        list.add(1);
+        list.add(10);
+        list.add(100);
+        list.add(1000);
+
+        UnaryOperator<Integer> s = new UnaryOperator<>() {
+            @Override
+            public Integer apply(Integer s) {
+                //传入Integer 返回每个数字
+                // >= 100 不改变
+                // < 100   乘以 100
+                if ( s < 100 ){
+                    return s * 100;
+                }else {
+                    return s;
+                }
+            }
+        };
+
+        //replaceAll
+        list.replaceAll(s);
+
+        System.out.println(list);
+
+    }
+
+    /*
+    - sort(null)：用Comparable接口的compareTo方法比较大小
+    - sort(Comparator接口的实现类对象)：用定制比较器Comparator的compare方法比较大小
+     */
+    @Test
+    public void test03(){
+        List<String> list = new ArrayList();
+        list.add("中国");
+        list.add("韩国");
+        list.add("日本");
+        //null代表不传入比较器。 实现Comparable
+        list.sort(null);
+
+        System.out.println(list);
+    }
+
+    @Test
+    public void test04(){
+        List<Person> list = new ArrayList();
+        list.add(new Person());
+        list.add(new Person());
+        list.add(new Person());
+        //null代表不传入比较器。 实现Comparable
+        list.sort(null);
+
+        System.out.println(list);
+    }
+
+    @Test
+    public void test05(){
+        List<Person> list = new ArrayList();
+        list.add(new Person());
+        list.add(new Person());
+        list.add(new Person());
+
+        Comparator<Person> comparator = new Comparator<>() {
+            @Override
+            public int compare(Person o1, Person o2) {
+                return o1.equals(o2) == true ? 1 : -1;
+            }
+        };
+        list.sort(comparator);
+
+        System.out.println(list);
+    }
+
+
+
+}

day16/src/com/four/day16/list01/Demo04.java

@@ -0,0 +1,101 @@
+package com.four.day16.list01;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.function.UnaryOperator;
+
+public class Demo03 {
+
+
+
+    /*
+    replaceAll（UnaryOperator接口的实现类对象）：
+    需要编写匿名内部类实现UnaryOperator接口，重写apply抽象方法
+
+    replaceAll 替换，经过一个方法 apply 方法，将方法的返回值替换方法的参数。
+
+    参数类型  UnaryOperator 继承了 Funcation 接口
+
+    R apply(T t); 传入 t 返回 R。 举例：1 映射为 等级一
+
+    public interface UnaryOperator<T> extends Function<T, T> {
+
+    A apply(A a); 传入 A 返回 A 返回的A 替换传入A。
+
+     */
+    @Test
+    public void test02(){
+        //需求 将字符串的第一个字符变为大写。
+        List<String> list = new ArrayList<>();
+        list.add("fadfa");
+        list.add("gsdfg");
+        list.add("vdfsvfd");
+        list.add("hdsf");
+
+        UnaryOperator<String> stringUnaryOperator = new UnaryOperator<>() {
+            @Override
+            public String apply(String s) {
+                //s 遍历集合的每一个元素
+                String first = s.substring(0, 1);
+                String next = s.substring(1);
+
+                return first.toUpperCase() + next;
+            }
+        };
+        list.replaceAll(stringUnaryOperator);
+
+        System.out.println(list);
+    }
+
+    /*
+    - sort(null)：用Comparable接口的compareTo方法比较大小 ,排序。
+    - sort(Comparator接口的实现类对象)：用定制比较器Comparator的compare方法比较大小
+     */
+    @Test
+    public void test03(){
+        List<String> list = new ArrayList();
+        list.add("中国");
+        list.add("韩国");
+        list.add("日本");
+        //null代表不传入比较器。 实现Comparable
+        list.sort(null);
+
+        System.out.println(list);
+    }
+
+    @Test
+    public void test04(){
+        List<Person> list = new ArrayList();
+        list.add(new Person());
+        list.add(new Person());
+        list.add(new Person());
+        //null代表不传入比较器。 实现Comparable
+        list.sort(null);
+
+        System.out.println(list);
+    }
+
+    @Test
+    public void test05(){
+        List<Person> list = new ArrayList();
+        list.add(new Person());
+        list.add(new Person());
+        list.add(new Person());
+
+        Comparator<Person> comparator = new Comparator<>() {
+            @Override
+            public int compare(Person o1, Person o2) {
+                return o1.equals(o2) == true ? 1 : -1;
+            }
+        };
+        list.sort(comparator);
+
+        System.out.println(list);
+    }
+
+
+
+}

day16/src/com/four/day16/list01/Demo05.java

@@ -0,0 +1,80 @@
+package com.four.day16.list01;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.List;
+import java.util.function.UnaryOperator;
+
+public class Demo04 {
+
+    //E get（下标）：返回[下标]对应的元素
+    @Test
+    public void test02(){
+//       Collection coll = new ArrayList();
+//        //看左边有没有声明方法。
+//        //coll.get();
+//        //转
+//       List a= (List) coll;
+//       a.get(1);
+
+        List<String> list = new ArrayList();
+        list.add("a");
+        list.add("b");
+        list.add("c");
+        list.add("d");
+
+        String s = list.get(1);
+        System.out.println(s);
+
+        String s1 = list.get(10);
+        System.out.println(s1);
+    }
+
+
+    //List<E> subList(起始下标，终止下标 不包含)：返回子集
+    @Test
+    public void test03(){
+        List<String> list = new ArrayList();
+        list.add("a");
+        list.add("b"); //1
+        list.add("c"); //2
+        list.add("d"); //3
+
+        List<String> strings = list.subList(1, 3);
+        System.out.println(strings);
+    }
+
+
+    //int indexOf（元素）：返回元素首次出现的下标
+    @Test
+    public void test04(){
+
+        List<String> list = new ArrayList();
+        list.add("a");
+        list.add("b"); //1
+        list.add("c"); //2
+        list.add("d"); //3
+
+        int i1 = list.indexOf("a");
+        System.out.println(i1);
+
+    }
+
+    //int lastIndexOf（元素）：返回元素最第一次的下标
+    @Test
+    public void test05(){
+        List<String> list = new ArrayList();
+        list.add("a");
+        list.add("b"); //1
+        list.add("c"); //2
+        list.add("d"); //3
+        list.add("d"); //4
+
+        int i1 = list.lastIndexOf("d");
+        System.out.println(i1);
+    }
+
+}

day16/src/com/four/day16/list01/Person.java

@@ -0,0 +1,2 @@
+package com.four.day16.list01;public class Person {
+}

day16/src/com/four/day16/list02/Demo.java

@@ -0,0 +1,2 @@
+package com.four.day16.list02;public class Demo {
+}

day17/day17.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

day17/src/com/day17/link01/Demo01.java

@@ -0,0 +1,2 @@
+package com.day17.link01;public class Demo01 {
+}

day17/src/com/day17/link01/Demo02.java

@@ -0,0 +1,111 @@
+package com.day17.link01;
+
+import org.junit.Test;
+
+import java.util.LinkedList;
+
+public class Demo01 {
+
+    @Test
+    public void test5(){
+        LinkedList<String> ls = new LinkedList<>();
+        ls.addLast("a1");
+        ls.addLast("a2");
+        ls.addLast("a3");
+        ls.addLast("a4");
+        //栈结构
+        //        String s1 = ls.removeLast();
+        //        String s2 = ls.removeLast();
+
+        //队列结构
+        String s1 = ls.removeFirst();
+        String s2 = ls.removeFirst();
+
+        System.out.println(s1);
+        System.out.println(s2);
+    }
+
+
+    @Test
+    public void test4(){
+        LinkedList<String> ls = new LinkedList<>();
+        ls.push("a1");
+        ls.push("a2");
+        ls.push("a3");
+        ls.push("a4");
+
+        String pop1 = ls.pop();
+        String pop2 = ls.pop();
+
+        System.out.println(pop1);
+        System.out.println(pop2);
+    }
+
+
+    @Test
+    public void test3(){
+        LinkedList<String> ls = new LinkedList<>();
+        ls.add("a1");
+        ls.add("a2");
+        ls.add("a3");
+        ls.add("a4");
+
+        String poll1 = ls.poll();
+        String poll2 = ls.poll();
+        String poll3 = ls.poll();
+
+        System.out.println(poll1);
+        System.out.println(poll2);
+        System.out.println(poll3);
+
+    }
+
+    @Test
+    public void test2(){
+        LinkedList<String> ls = new LinkedList<>();
+        ls.add("a1");
+        ls.add("a2");
+        ls.add("a3");
+        ls.add("a4");
+
+        String peek1 = ls.peek();
+        String peek2 = ls.peek();
+        String peek3 = ls.peekLast();
+
+        System.out.println(peek1);
+        System.out.println(peek2);
+        System.out.println(peek3);
+
+    }
+
+    @Test
+    public void test1(){
+        LinkedList<String> ls = new LinkedList<>();
+
+        ls.offerFirst("a1");
+        ls.offerFirst("a2");
+        ls.offerFirst("a3");
+        ls.offerFirst("a4");
+
+        System.out.println(ls);
+
+    }
+
+
+
+    @Test
+    public void test(){
+        LinkedList<String> ls = new LinkedList<>();
+
+        ls.offer("a1");
+        ls.offer("a2");
+        ls.offer("a3");
+        ls.offer("a4");
+
+        System.out.println(ls);
+
+    }
+
+
+
+}

day17/src/com/day17/map01/Demo01.java

@@ -0,0 +1,2 @@
+package com.day17.map01;public class Demo01 {
+}

day17/src/com/day17/map01/Demo02.java

@@ -0,0 +1,56 @@
+package com.day17.map01;
+
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Demo01 {
+
+    //put(key ,value )：添加一对键值对
+    @Test
+    public void test() {
+        Map<Integer,Object> map = new HashMap();
+        map.put(1,new Object());
+        map.put(2,"123");
+        map.put(2,"123456"); //key相同 取代
+        map.put(3, 1.1111 );
+        map.put(null, null);
+
+        System.out.println(map);
+        //key 不能重复。 hashcode 和 equals
+    }
+
+
+    @Test
+    public void test1() {
+        Map<String,Person> map = new HashMap();
+
+        map.put("zs",new Person("zs",20));
+        map.put("ls",new Person("ls",20));
+        map.put("ww",new Person("ww",20));
+
+        System.out.println(map);
+    }
+
+    //putAll(另一个Map)：将另一个Map中的键值对添加到当前Map中
+    @Test
+    public void test2() {
+        Map<String,String> map1 = new HashMap();
+        map1.put("a","zs");
+        map1.put("b","ls");
+        map1.put("c","ww");
+
+        Map<String,String> map2 = new HashMap();
+        map2.put("d","zs");
+        map2.put("e","zs");
+        map2.put("f","zs");
+
+        map1.putAll(map2);
+
+        System.out.println(map1);
+
+
+    }
+
+}

day17/src/com/day17/map01/Demo03.java

@@ -0,0 +1,48 @@
+package com.day17.map01;
+
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Demo02 {
+
+    //put(key ,value )：添加一对键值对
+    @Test
+    public void test() {
+        Map<Integer,Object> map = new HashMap();
+        map.put(1,new Object());
+        map.put(2,"123");
+        map.put(2,"123456"); //key相同 取代
+        map.put(3, 1.1111 );
+        map.put(null, null);
+
+        Object remove = map.remove(null);
+        System.out.println(remove);
+
+        Object remove1 = map.remove(3);
+        System.out.println(remove1);
+
+        System.out.println(map);
+    }
+
+    //remove(key, value)：要求key,value都对应再删除一对键值对
+    //clear()：清空map集合
+    @Test
+    public void test2() {
+
+        Map<Integer,String > map = new HashMap();
+        map.put(1,"123");
+        map.put(2,"123456");
+        map.put(3,"1.1111");
+
+        boolean remove = map.remove(1, "1234"); //v不匹配 删除不掉的
+        System.out.println(remove);
+
+        map.clear();
+        System.out.println(map);
+    }
+
+
+
+}

day17/src/com/day17/map01/Demo04.java

@@ -0,0 +1,75 @@
+package com.day17.map01;
+
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.BiFunction;
+
+public class Demo03 {
+
+
+    //replace(key，新value)
+    @Test
+    public void test2() {
+
+        Map<Integer,String > map = new HashMap();
+        map.put(1,"aa");
+        map.put(2,"bb");
+        map.put(3,"cc");
+
+        map.replace(2,"bbbb");
+        //map.put(2,"bbbb");
+
+        System.out.println(map);
+
+    }
+
+    //replace(key，旧value，新value)
+    @Test
+    public void test3() {
+        Map<Integer,String > map = new HashMap();
+        map.put(1,"aa");
+        map.put(2,"bb");
+        map.put(3,"cc");
+
+        map.replace(2,"bbb","bbbbbb");
+        System.out.println(map);
+
+    }
+
+    //replaceAll(BiFunction接口的实现类)，
+    // 需要用匿名内部类实现BiFunction接口接口，
+    //  BiFunction<? super K, ? super V, ? extends V>
+    //  方法 R apply(T t, U u);
+    //  传入 t u 返回 R 用R当作 map中新的value
+
+    //  使用方法 V apply(K k, V v);  map  K  V
+
+    // 重写apply方法，新Value类型  apply（key，旧value）
+    @Test
+    public void test4() {
+        Map<Integer,String > map = new HashMap();
+        map.put(1,"aa");
+        map.put(2,"bb");
+        map.put(3,"cc");
+
+        BiFunction<Integer, String, String> biFunction = new BiFunction<>() {
+            @Override
+            public String apply(Integer integer, String s) {
+
+                String upperCase = s.toUpperCase();
+                return upperCase;
+            }
+        };
+
+        map.replaceAll(biFunction);
+
+        System.out.println(map);
+    }
+
+
+
+
+
+}

day17/src/com/day17/map01/Demo05.java

@@ -0,0 +1,77 @@
+package com.day17.map01;
+
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Demo05 {
+
+
+    //V get(key)：根据key查询value
+    @Test
+    public void test2() {
+
+        Map<Integer,String > map = new HashMap();
+        map.put(1,"aa");
+        map.put(2,"bb");
+        map.put(3,"cc");
+
+        String s = map.get(11);
+        System.out.println(s);
+
+    }
+
+    //V getOrDefault(key)：根据key查询value，如果该key对应的value不存在，用默认值返回
+    @Test
+    public void test3() {
+        Map<Integer,String > map = new HashMap();
+        map.put(1,"aa");
+        map.put(2,"bb");
+        map.put(3,"cc");
+
+//        String s = map.get("11");
+//        byte[] bytes = s.getBytes();
+
+        String dd = map.getOrDefault(11, "dd");
+        byte[] bytes = dd.getBytes();
+        System.out.println(dd);
+    }
+
+    //boolean containsKey(key)：判断某个key有没有
+    //boolean containsValue(value)：判断某个value有没有
+    //boolean isEmpty()：判断是否为空
+    //int size()：返回键值对的数量
+    @Test
+    public void test4() {
+        Map<Integer,String > map = new HashMap();
+        map.put(1,"aa");
+        map.put(2,"bb");
+        map.put(3,"cc");
+
+        boolean b = map.containsKey(1);
+        System.out.println(b);
+
+        boolean b1 = map.containsValue("aaa");
+        System.out.println(b1);
+
+        boolean empty = map.isEmpty();
+        System.out.println(empty);
+
+        //map.clear();
+
+//        boolean empty1 = map.isEmpty();
+//        System.out.println(empty1);
+
+        int size = map.size();
+        System.out.println(size);
+
+
+    }
+
+
+
+
+
+
+}

day17/src/com/day17/map01/Person.java

@@ -0,0 +1,2 @@
+package com.day17.map01;public class Person {
+}

day17/src/com/day17/map02/Demo01.java

@@ -0,0 +1,2 @@
+package com.day17.map02;public class Demo01 {
+}

day17/src/com/day17/map02/Demo02.java

@@ -0,0 +1,106 @@
+package com.day17.map02;
+
+import org.junit.Test;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class Demo01 {
+
+    //Hashtable<K,V>：哈希表
+    @Test
+    public void test() {
+        Hashtable<Integer,Object> hashtable = new Hashtable<>();
+        hashtable.put(1,"a");
+        hashtable.put(2,"b");
+
+        //hashtable.put(null,null);
+        System.out.println(hashtable);
+
+    }
+
+    //LinkedHashMap<K,V>
+    @Test
+    public void test2() {
+        LinkedHashMap<Integer,Object> linkedHashMap = new LinkedHashMap<>();
+
+        linkedHashMap.putFirst(1,"a");
+        linkedHashMap.putFirst(2,"a");
+        linkedHashMap.putFirst(3,"a");
+
+
+        System.out.println(linkedHashMap);
+
+    }
+
+    //TreeMap<K,V>：红黑树
+    @Test
+    public void test3() {
+
+        //默认 Comparable
+        TreeMap<Integer,Object> treeMap = new TreeMap<>();
+        treeMap.put(3,"a");
+        treeMap.put(1,"a");
+        treeMap.put(2,"a");
+
+        System.out.println(treeMap);
+
+
+    }
+
+    //TreeMap<K,V>：红黑树
+    @Test
+    public void test4() {
+
+        Comparator<String> stringComparator = new Comparator<>() {
+            @Override
+            public int compare(String o1, String o2) {
+                return -o1.compareTo(o2);
+            }
+        };
+        //简化
+        Comparator<String> stringComparator1 = ( o1,  o2) -> -o1.compareTo(o2);
+        //定制比较器
+        TreeMap<String,Object> treeMap = new TreeMap<>(stringComparator1);
+        treeMap.put("a","a");
+        treeMap.put("c","a");
+        treeMap.put("b","a");
+        treeMap.put("k","a");
+        treeMap.put("e","a");
+
+        System.out.println(treeMap);
+
+        //new TreeSet();
+
+
+    }
+
+
+    //Properties
+    @Test
+    public void test5() {
+        Properties properties = new Properties();
+
+        properties.put("1","a");
+        properties.put("2","a");
+        properties.put("3","a");
+
+        System.out.println(properties);
+
+    }
+
+    //做配置文件使用
+    @Test
+    public void test6() throws IOException {
+        Properties properties = new Properties();
+        FileInputStream fileInputStream = new FileInputStream("C:\\Users\\secga\\Desktop\\250714资料\\01基础\\code\\javase\\day17\\src\\jdbc.properties");
+        properties.load(new InputStreamReader(fileInputStream));
+
+        System.out.println(properties);
+
+    }
+
+}

day18/day18.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

day18/src/com/four/day18/colls/Demo01.java

@@ -0,0 +1,2 @@
+package com.four.day18.colls;public class Demo01 {
+}

day18/src/com/four/day18/srcs/Demo01.java

@@ -0,0 +1,2 @@
+package com.four.day18.srcs;public class Demo01 {
+}

day18/src/com/four/day18/srcs/MyArrayList.java

@@ -0,0 +1,2 @@
+package com.four.day18.srcs;public class MyArrayList {
+}

day18/src/com/four/day18/srcs/MyLinkedList.java

@@ -0,0 +1,2 @@
+package com.four.day18.srcs;public class MyLinkedList {
+}

day18/src/hjhh.java

@@ -0,0 +1,2 @@
+package PACKAGE_NAME;public class hjhh {
+}

day19/day19.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

day19/src/com/four/day19/iterator01/Demo.java

@@ -0,0 +1,2 @@
+package com.four.day19.iterator01;public class Demo {
+}

day19/src/com/four/day19/iterator01/Demo02.java

@@ -0,0 +1,2 @@
+package com.four.day19.iterator01;public class Demo02 {
+}

day19/src/com/four/day19/iterator02/Demo01.java

@@ -0,0 +1,2 @@
+package com.four.day19.iterator02;public class Demo01 {
+}

day19/src/com/four/day19/iterator02/Demo02.java

@@ -0,0 +1,2 @@
+package com.four.day19.iterator02;public class Demo02 {
+}

day19/src/com/four/day19/iterator02/MyArrayList.java

@@ -0,0 +1,157 @@
+package com.four.day18.srcs;
+
+import java.util.Arrays;
+import java.util.Objects;
+
+/*
+    MyArrayList
+    存储任意类型，泛型指定类型。
+ */
+public class MyArrayList<E> {
+
+    //存储数组 长度 10.
+    private Object[] elementData = new Object[5]; ;
+    //元素的个数
+    private int size = 0;
+
+    //无参构造
+
+    /**
+     * 添加方法
+     */
+    public boolean add(E e) {
+        //检查要不要扩容，如果需要，就进行扩容
+        //Ctrl + Alt + m 抽取方法的快捷键
+        grow();
+        //添加
+        elementData[size++] = e;
+        return true;
+    }
+
+    public boolean add (int index, E e) {
+        //判断
+        if ( index < 0 || index > size - 1 ){
+            new ArrayIndexOutOfBoundsException("index out of bounds");
+        }
+        //检查要不要扩容，如果需要，就进行扩容
+        grow();
+        //操作
+        System.arraycopy(elementData, index, elementData, index + 1, size - index);
+
+        //元素赋值
+        elementData[index] = e;
+        //元素个数++
+        size++;
+        return true;
+    }
+
+
+    /**
+     * 检查要不要扩容，如果需要，就进行扩容
+     */
+    private void grow() {
+        if ( size >= elementData.length ){
+
+            //旧的数组
+            Object[] oldElement = elementData;
+            //修改数组长度
+            int newLength = elementData.length * 2;
+            //新数组
+            elementData = new Object[newLength];
+            //复制元素
+            // elementData 元数组  pos  位置   dest  新数组    length 长度。
+            System.arraycopy(oldElement,0,elementData,0,size);
+            //elementData = Arrays.copyOf(elementData, elementData.length + elementData.length/2);
+        }
+    }
+
+
+    /**
+     * 删除 根据索引删除
+     * @param index
+     * @return
+     */
+    public boolean remove(int index ) {
+        //判断
+        if ( index < 0 || index > size - 1 ){
+            new ArrayIndexOutOfBoundsException("index out of bounds");
+        }
+
+        //删除移动
+        System.arraycopy(elementData,index+1,elementData,index,size - index-1);
+        //最后一位置为空null
+        elementData[size-1] = null;
+        //--
+        size--;
+
+        return true;
+    }
+
+    /**
+     * 根据 对象删除
+     * @param  obj
+     * @return
+     */
+    public int remove(Object obj ) {
+        //遍历数组 获取对应 obj的下标
+        for (int i = 0; i < size; i++) {
+            if (Objects.equals(elementData[i],obj)){
+                //获取索引
+                remove(i);
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    /**
+     * 查询返回索引
+     * @param obj
+     * @return
+     */
+    public int indexOf( Object obj ){
+        //遍历数组 获取对应 obj的下标
+        for (int i = 0; i < size; i++) {
+            if (Objects.equals(elementData[i],obj)){
+                //获取索引
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    /**
+     * 查询返回索引
+     * @param obj
+     * @return
+     */
+    public int lastIndexOf( Object obj ){
+        //遍历数组 获取对应 obj的下标
+        for (int i = size-1; i >= 0; i--) {
+            if (Objects.equals(elementData[i],obj)){
+                //获取索引
+                return i;
+            }
+        }
+        return -1;
+    }
+
+
+    //toString
+
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("[");
+        //字符串拼接
+        for (int i = 0; i < size; i++) {
+            if ( i == size - 1 ){
+                sb.append(elementData[i]+"]");
+            }else {
+                sb.append(elementData[i]+",");
+            }
+        }
+        return sb.toString();
+    }
+}

day19/src/com/four/day19/iterator02/MyLinkedList.java

@@ -0,0 +1,96 @@
+package com.four.day18.srcs;
+
+import java.util.Objects;
+import java.util.StringJoiner;
+
+public class MyLinkedList<E> {
+    private Node<E> first;//用于记录双向链表的头结点的地址，默认值是null
+    private Node<E> last;//用于记录双向链表的尾结点的地址，默认值是null
+    private int size;//记录双向链表中结点的数量，同时就是元素个数
+
+    //内部类，静态成员内部类，因为在Node内部类中，没有用到外部类MyLinkedList的任何非静态成员
+    private static class Node<E>{
+        Node<E> previous;//记录前一个结点的地址
+        E data;
+        Node<E> next;//记录下一个结点的地址
+
+        Node(Node<E> previous, E data, Node<E> next) {
+            this.previous = previous;
+            this.data = data;
+            this.next = next;
+        }
+    }
+
+    public void add(E e){//把新结点添加到链表的最后
+        //（1）创建新结点，把e包装到新结点中
+        Node<E> newNode = new Node<>(last,e,null);
+        /*
+        Node(last,e, null)
+        last代表链表原来的最后一点，它将会是新结点的前一个结点，所以新结点的previous等于它
+        这里null是因为新结点后面没有其他结点了
+         */
+        //（2）分情况讨论
+        if(first == null){//说明链表是空的   或 if(last == null) 或 if(size==0)
+            first = newNode;//新结点成了链表的第一个结点
+        }else{//说明链表是非空的
+            last.next = newNode; //链表原来的最后一个结点，需要指向新结点
+        }
+
+        last = newNode;//新结点成了链表的最后一个结点
+
+        //元素或结点个数+1
+        size++;
+    }
+
+
+    private Node<E> findNode(Object target){
+        Node<E> node = first;
+        while(node != null){
+            if(Objects.equals(node.data, target)){
+                break;
+            }
+            node = node.next;
+        }
+        return node;//如果没找到,node=null，如果找到了，node是目标结点的地址
+    }
+
+
+    public void remove(Object target){
+        //找到target对应的结点
+        Node<E> node = findNode(target);
+        if(node == null){
+            return;//结束remove，不删除
+        }
+
+        Node<E> before = node.previous;
+        Node<E> after = node.next;
+
+        if(before == null){//被删除结点node是第一个结点
+            first = after;
+        }else{
+            before.next = after;
+        }
+
+        if(after == null){//被删除结点node是最后一个结点
+            last = before;
+        }else{
+            after.previous = before;
+        }
+
+        //元素个数减少
+        size--;
+    }
+
+    public String toString(){
+        //拼接所有结点的data，返回
+        StringJoiner joiner = new StringJoiner(",","[","]");
+        Node<E> node = first;
+        while(node!= null){
+            joiner.add(node.data+"");
+            node = node.next;//让node往右移动
+        }
+
+        return joiner.toString();
+    }
+
+}

day19/src/com/four/day19/map01/Demo01.java

@@ -0,0 +1,2 @@
+package com.four.day19.map01;public class Demo01 {
+}

day19/src/com/four/day19/map01/Demo02.java

@@ -0,0 +1,2 @@
+package com.four.day19.map01;public class Demo02 {
+}