Java 集合 泛型 Set & Map

// TODO 集合 - Collection
        // 泛型语法
        ArrayList<Person6> list = new ArrayList();

//        Person6 user = new User6();
//        user.testUser();  // 无法使用 （多态约束使用场景）
//        user.testPerson();
        Person6 person = new Person6();
        User6 user = new User6();

        list.add(person);
        //list.add(user);

        //list.remove(0);

        // 从集合中获取的对象类型是Object
//        Object o = list.get(0);
//        // 如果想要执行对象的方法，那么需要进行强制类型转换
//        if ( o instanceof Person6 ) {      // 如果o属于Person6类型
//            Person6 p = (Person6) o;
//            p.testPerson();
//        }
        Person6 person6 = list.get(0);
        person6.testPerson();
 

    }
}
class Person6 {
    public void testPerson() {
        System.out.println("person...");
    }
}
class User6 {
    public void testUser() {
        System.out.println("user...");
    }
}

 // 泛型语法
        // TODO 泛型和类型的区别
        //  类型：用于约束外部对象的使用场景
        //  泛型：用于约束内部对象的使用场景
        //  有时也把泛型称之为类型参数
        //  类型存在多态的使用，而泛型没有多态
        MyContainer<User7> myContainer = new MyContainer();
        //myContainer.data = new Object();

        test(myContainer);

    }
    public static void test(MyContainer<User7> myContainer) {
        System.out.println(myContainer);
    }
}
// TODO 容器类
class MyContainer<C> {
    public C data;
}
class User7 {

}

 // Sort 排序
        ArrayList list = new ArrayList();
        list.add(1);
        list.add(3);
        list.add(2);

        // 1，3，2 => 3,1,2 => 3,2,1
        // 3，2，1

        // 排序需要传递一个实现了比较器接口的对象
        list.sort( new NumberComparator());

        System.out.println(list);
    }
}
class NumberComparator implements Comparator<Integer> {
    @Override
    public int compare(Integer o1, Integer o2) {
        // TODO 如果第一个数比第二个数大，那么返回结果为正数，表示升序
        //return o1 - o2;
        // TODO 如果第一个数比第二个数小，那么返回结果为负数，表示降序
        //return o2 - o1;
        // TODO 如果第一个数与第二个数一样大，那么返回结果为0
        return 0;
    }
}

  // HashSet ： Hash + Set
        // Hash ： 哈希算法，散列算法
        // ArrayList : 底层是数组
        // LinkedList : 底层是双向链表
        HashSet set = new HashSet();
        // TODO 增加数据
        set.add("zhangsan");
        set.add("zhangsan");
        set.add("lisi");
        set.add("wangwu");

        // TODO 修改数据

        // TODO 删除数据
        //set.remove("wangwu");

        // TODO 查询数据
        for (Object o : set) {
            System.out.println(o);
        }

        System.out.println(set);
    }
}

    HashSet set = new HashSet();

        ArrayList list = new ArrayList();
        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu");
        set.addAll(list);

        Object[] objects = set.toArray();
        System.out.println(set.isEmpty());
        //set.clear();
        System.out.println(set.contains("zhangsan"));
        System.out.println(set.size());
        Object clone = set.clone();
        System.out.println(clone);

        System.out.println(set);
    }
}

 // HashSet 底层数据结构为 数组 + 单向链表

        HashSet set = new HashSet();

        User9 user1 = new User9();
        user1.id = 1001;
        user1.name = "zhangsan";
        System.out.println(user1.hashCode());

        User9 user2 = new User9();
        user2.id = 1001;
        user2.name = "zhangsan";
        System.out.println(user2.hashCode());

        User9 user3 = new User9();
        user3.id = 1002;
        user3.name = "lisi";


        set.add(user1);
        set.add(user2);
        set.add(user3);

        System.out.println(set);

    }
}
class User9 {
    public int id;
    public String name;

    @Override
    // 类似于内存地址
    public int hashCode() {
        return id;
    }

    @Override
    // 判断两个对象的属性是否完全相同
    public boolean equals(Object obj) {
        if (obj instanceof User9) {
            User9 otherUser = (User9) obj;
            if ( otherUser.id == this.id ) {
                if( otherUser.name.equals(this.name )) {
                    return true;
                }
            }
            return false;
        } else {
            return false;
        }
    }

    @Override
    public String toString() {
        return "User["+ id +","+ name +"]";
    }
}

 // ArrayBlockingQueue : Array + Blocking(阻塞，堵住) + Queue
        ArrayBlockingQueue queue = new ArrayBlockingQueue(3);
        // add方法如果增加不了数据了就直接发生错误
//        queue.add("zhangsan");
//        queue.add("lisi");
//        queue.add("wangwu");
//        queue.add("zhaoliu");  // 发生错误，Queue full

//        queue.put("zhangsan");
//        System.out.println("第一个人挂号");
//        queue.put("lsii");
//        System.out.println("第二个人挂号");
//        queue.put("wangwu");
//        System.out.println("第三个人挂号");
//        queue.put("zhaoliu");
//        System.out.println("第四个人挂号");

        boolean zhangsan = queue.offer("zhangsan");
        System.out.println(zhangsan);
        boolean lisi = queue.offer("lisi");
        System.out.println(lisi);
        boolean wangwu = queue.offer("wangwu");
        System.out.println(wangwu);
        boolean zhaoliu = queue.offer("zhaoliu");
        System.out.println(zhaoliu);

//        System.out.println(queue.poll());
//        System.out.println(queue.poll());
//        System.out.println(queue.poll());
//        System.out.println(queue.poll());

        System.out.println(queue.take());
        System.out.println(queue.take());
        System.out.println(queue.take());

//        queue.size();
//        queue.isEmpty();
//        queue.clear();
//        queue.contains("zhangsan");


        System.out.println(queue);
    }
}

  // HashMap : Hash + Map
        // 数据存储是无序的
        HashMap map = new HashMap();

        // 添加数据: put
        // 修改数据，put方法也可以修改数据，返回值就是被修改的值
        map.put("zhangsan","1");
        System.out.println(map.put("zhangsan", "4"));
        map.put("lsii","2");
        map.put("wangwu","3");

        // TODO 查询数据
        System.out.println(map.get("zhangsan"));

        // TODO 删除数据
        System.out.println(map.remove("wangwu"));

        System.out.println(map);

    }
}

  HashMap<String, String> map = new HashMap();

        // 添加数据
        // 修改数据
//        map.put("a","0");
//        Object oldVal = map.put("a", "1");
//        System.out.println(oldVal);
//
//        // 添加数据
//        map.putIfAbsent("b","2");
//        map.putIfAbsent("b","3");
//
//        Object b = map.replace("b", "4");
//        System.out.println(b);

        map.clear();
        map.put("zhangsan","1");
        map.put("lisi","2");
        map.put("wangwu","3");

        // TODO 获取map集合中所有的key
//        Set set = map.keySet();
//        for (Object k : set) {
//            System.out.println(map.get(k));
//        }
//        System.out.println(map.containsKey("zhangsan"));
//
//        Collection values = map.values();
//        for (Object value : values) {
//            System.out.println(value);
//        }
//
//        System.out.println(map.containsValue("2"));
//
//        System.out.println(map);

        // TODO 获取键值对对象
//        Set<Map.Entry<String, String>> entries = map.entrySet();
//        for (Map.Entry<String, String> entry : entries) {
//            System.out.println(entry.getKey() + "=" + entry.getValue());
//        }

        //map.remove("zhangsan");

        map.remove("zhangsan","1");

        map.size();

        map.clone();

        map.isEmpty();

        map.clear();

        System.out.println(map);

    }
}

 // Hashtable
        Hashtable table = new Hashtable();
        HashMap map = new HashMap();
        map.put(null,null);
//        table.put();
//        table.get();
//        table.remove();
        // TODO 1.实现方式是不一样的 : 继承父类不一样
        // TODO 2.底层结构的容量不同 : HashMap（16），Hashtable（11）
        // TODO 3.HashMap的K，V都可以为null, Hashtable的K，V不能是null
        // TODO 4.HashMap的数据定位采用的是Hash算法，Hashtable采用的是Hashcode
        // TODO 5.HashMap的性能较高，Hashtable性能较低（考虑多线程并发执行发生冲突会额外增加特殊操作）
    }
}