java:集合

 

 

 

import java.util.ArrayList;
import java.util.List;

/**
 * Collection接口:用于储存单个对象的集合
 * List接口：
 * 1.有序的
 * 2.允许多个null元素
 * 3.具体的实现有常用的:ArrayList Vector LinkedList
 * Set接口:
 *
 */


public class ListDemo {
    private static void arrayList(){
        //使用集合来存储多个不同类型的元素(对象)，那么在处理时会比较麻烦，实际开发中，不建议
        //这样使用，我们应该在一个集合中存储相同的类型对象
        List<String> list = new ArrayList<>();
        list.add("苍老师");
        list.add("李老师");
        list.add("张老师");
        list.add("毕老师");
        //list.add(10);

        //遍历集合
        int size = list.size();
        for (int i = 0; i < size; i++) {
            System.out.println(list.get(i));
        }
        System.out.println(list.contains("苍老师"));
    }

    public static void main(String[] args) {

    }

}

 

package com.vince;

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

/**
 * Set接口
 * 1、无序的（不保证顺序）
 * 2、不允许重复元素
 * HashSet、TreeSet、LinkedHashSet
 * 
 * 如果要排序，选择treeSet
 * 如果不要排序，也不用保正顺序选择HashSet
 * 不要排序，要保正顺序，选择LinkedHashSet
 * @author vince
 * @description
 */
public class SetDemo {
    
    /**
     * 哈希表和链接列表实现,
     * 维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，即按照将元素插入到 set 中的顺序（插入顺序）进行迭代。
     */
    private static void linkedHashSet(){
        LinkedHashSet<Cat> set = new LinkedHashSet<>();
        Cat c1 = new Cat("miaomiao",5,1);
        Cat c2 = new Cat("huahua",2,2);
        Cat c3 = new Cat("tom",5,3);
        Cat c4 = new Cat("miaomiao",3,1);
        set.add(c1);
        set.add(c2);
        set.add(c3);
        set.add(c4);
        
        for(Cat c: set){
            System.out.println(c);
        }
    }
    
    /**
     * 有序的，基于TreeMap(二叉树数据结构)，对象需要比较大小，通过对象比较器来实现，
     * 对象比较器还可以用来去除重复元素,如果自定义的数据类，没有实现比较器接口，将无法添加到TreeSet集合中。
     * 
     */
    private static void treeSet(){
        TreeSet<Cat> tree = new TreeSet<>(new CatComparator());
        Cat c1 = new Cat("miaomiao",5,1);
        Cat c2 = new Cat("huahua",2,2);
        Cat c3 = new Cat("tom",5,3);
        Cat c4 = new Cat("miaomiao",3,1);
        tree.add(c1);
        tree.add(c2);
        tree.add(c3);
        tree.add(c4);
        System.out.println(tree.size());
        
        for(Cat c: tree){
            System.out.println(c);
        }
        
        
        
        
    }
    /**
     * HashSet
     * 1、实现原理，基于哈希表（HashMap）实现
     * 2、不允许重复，可以有一个NULL元素
     * 3、不保证顺序恒久不变
     * 4、添加元素时把元素作为HashMap的key存储，HashMap的value使用一个固定的object对象
     * 5、排除重复元素是通过equals来检查对象是否相同
     * 6、判断两个对象是否相同，先判断两个对象的hashCode是否相同（如果两个对象的hashCode相同，不一定是同一个对象，如果不同，那一定不是
     * 同一个对象），如果不同，则两个对象不是同一个对象，如果相同，还要进行equals判断，equals相同则是同一个对象，不同则不是同一个对比象。
     * 7、自定义对象要认为属性值都相同时为同一个对象，有这种需求时，那么我们要重写对象所在类的hashCode和equals方法。
     * 
     * 小结
     * (1)哈希表的存储结构：数组+链表，数组里的每个元素以链表的形式存储
     * (2)如何把对象存储到哈希表中，先计算对象的hashCode值，再对数组的长度求余数,来决定对象要存储在数组中的哪个位置 
     * (3)解决hashSet中的重复值使用的方式是，参考第6点
     */
    private static void hashSet(){
        Set<String> set = new HashSet<>();
        set.add("飞飞");
        set.add("备备");
        set.add("亮亮");
        set.add("关关");
        set.add("曹操");
        set.add("亮亮");
        System.out.println(set.size());
        String[] names = set.toArray(new String[]{});
        for(String s: names){
            System.out.println(s);
        }
        
        Cat c1 = new Cat("miaomiao",5,1);
        Cat c2 = new Cat("huahua",2,2);
        Cat c3 = new Cat("tom",5,3);
        Cat c4 = new Cat("miaomiao",5,1);
        Set<Cat> cats = new HashSet<>();
        cats.add(c1);
        cats.add(c2);
        cats.add(c3);
        cats.add(c4);
        //cats.add(c1);
        System.out.println(cats.size());
        
        for(Cat c: cats){
            System.out.println(c);
        }
        System.out.println("c1="+c1.hashCode());
        System.out.println("c2="+c2.hashCode());
        System.out.println("c3="+c3.hashCode());
        System.out.println("c4="+c4.hashCode());
    }

    public static void main(String[] args) {
//        hashSet();
//        treeSet();
        linkedHashSet();
    }

}

 

package com.vince;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * 集合的输出（迭代）
 * @author vince
 * @description
 */
public class IteratorDemo {

    
    //断言接口
    private static void predicateTest(){
        List<String> list = Arrays.asList("Larry", "Moe", "Curly","Tom","QF_vince"); 
        List<String> result = filter(list,(s)->s.contains("o"));
        result.forEach(System.out::println);
    }
    
    private static List<String> filter(List<String> list,Predicate<String> p){
        List<String> results = new ArrayList<>();
        
        for (String s : list) {
            if(p.test(s)){ //测试是否符合要求
                results.add(s);
            }
        }
        
        return results;
    }
    
    //Supplier 代表结果供应商
    private static void supplierTest(){
        List<Integer> list = getNums(10,()->(int)(Math.random() * 100));
        list.forEach(System.out::println);
    }
    
    private static List<Integer> getNums(int num,Supplier<Integer> sup){
         List<Integer> list = new ArrayList<>();
         for(int i=0;i<num;i++){
             list.add(sup.get());
         }
         return list;
    }
    
    //表示接受一个参数并产生结果的函数
    private static void functionTest(){
        String s = strToUpp("qf_vince",(str)->str.toUpperCase());
        System.out.println(s);
    }
    
    public static String strToUpp(String str,Function<String,String> f){
        return f.apply(str);
    }
    
    
    /**
     * JDK1.8新的迭代方法
     */
    private static void foreach(){
        List<String> list = new ArrayList<>();
        list.add("tom");
        list.add("jack");
        list.add("job");
        list.add("lily");
        
        //Consumer
        list.forEach(s->System.out.println(s));
        //list.forEach(System.out::println);
    }
    
    private static void enumeration(){
        Vector<String> vs = new Vector<>();
        vs.add("tom");
        vs.add("jack");
        vs.add("job");
        vs.add("lily");
        
        Enumeration<String> es = vs.elements();
        while(es.hasMoreElements()){
            System.out.println(es.nextElement());
        }
    }
    
    //foreach(1.5后)
    private static void foreach(Collection<Cat> c){
        for(Cat cat: c){
            System.out.println(cat);
        }
    }
    
    //iterator(1.5之前统一的迭代集合方式)
    private static void iterator(Collection<Cat> c){
            Iterator<Cat> iter = c.iterator();
            while(iter.hasNext()){
                System.out.println(iter.next());
            }
    }

    public static void main(String[] args) {
        List<Cat> list = new ArrayList<>();
        Cat c1 = new Cat("miaomiao",5,1);
        Cat c2 = new Cat("huahua",2,2);
        Cat c3 = new Cat("tom",5,3);
        Cat c4 = new Cat("miaomiao",3,1);
        list.add(c1);
        list.add(c2);
        list.add(c3);
        list.add(c4);
//        iterator(list);
//        foreach(list);
        
//        enumeration();
//        foreach();
//        functionTest();
//        supplierTest();
        predicateTest();
        
    }

}

 

 

---

package com.vince;

import java.util.Collection;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

/**
 * Map接口：
 * 1、键值对存储一组对象
 * 2、Key不能重复（唯一），Value可以重复
 * 3、具体的实现类：HashMap TreeMap Hashtable LinkedHashMap
 * 4、HashMap 与 Hashtable的区别？
 * 
 * 5、如何选择使用哪个？
 * 
 * 6、数据结构:数组、链表、二叉树（红黑树）、哈希表（数组+链表）、栈、队列
 * @author vince
 * @description
 */
public class MapDemo {
    
    /**
     * 基于二叉树的红黑树实现
     */
    private static void treeMap(){
        Map<String,String> map = new TreeMap<>();
//        map.put("one", "Lily");
//        map.put("two", "Tom");
//        map.put("three", "Bin");
//        map.forEach((key,value)->System.out.println(key+"->"+value));
//        
        Map<Dog,String> dogs = new TreeMap<>();
        dogs.put(new Dog(1,"2ha",3), "dog1");
        dogs.put(new Dog(1,"wangwang",2), "dog2");
        dogs.put(new Dog(3,"hsq",4), "dog3");
        dogs.forEach((key,value)->System.out.println(key+"->"+value));
    }
    
    /**
     * LinkedHashMap是HashMap的子类，由于HashMap不能保正顺序恒久不变，此类使用一个双重链表来维护
     * 元素添加的顺序。
     */
    private static void linkedHashMap(){
        Map<String,String> table = new LinkedHashMap<>();
        table.put("one", "Lily");
        table.put("two", "Tom");
        table.put("three", "Bin");
        table.forEach((key,value)->System.out.println(key+"->"+value));
    }
    
    /**
     * JDK1.0开始
     * 基于哈希表实现（数组+链表）
     * 默认数组大小为11，加载因子0.75
     * 扩充方式：原数组大小<<1 (*2) +1 
     * 线程安全的，用在多线程访问时
     */
    private static void hashtable(){
        
        Map<String,String> table = new Hashtable<>();
        table.put("one", "Lily");
        table.put("two", "Tom");
        table.put("three", "Bin");
        
        table.forEach((key,value)->System.out.println(key+"->"+value));
    }
    /**
     * HashMap的现实原理：
     * 1、基于哈希表（数组+链表+二叉树（红黑树） ）1.8JDK
     * 2、默认加载因子为0.75，默认数组大小是16，
     * 3、把对象存储到哈希表中，如何存储？
     *     把key对象通过hash()方法计算hash值，然后用这个hash值对数组长度取余数（默认16），来决定该对KEY对象
     * 在数组中存储的位置 ，当这个位置 有多个对象时，以链表结构存储，JDK1.8后，当链表长度大于8时，链表将转换为
     * 红黑树结构存储。
     * 这样的目的，是为了取值更快，存储的数据量越大，性能的表现越明显
     * 
     * 4、扩充原理：当数组的容量超过了75%，那么表示该数组需要扩充，如何扩充？
     * 扩充的算法是：当前数组容量<<1 （相当于是乘2），扩大1倍, 扩充次数过多，会影响性能，每次扩充表示哈希表重新
     * 散列（重新计算每个对象的存储位置），我们在开发中尽量要减少扩充次数带来的性能问题。
     * 5、线程不安全，适合在单线程中使用
     */
    private static void hashMap(){
        Map<Integer,String> map = new HashMap<>();
        map.put(1, "Tom");
        map.put(2, "Jack");
        map.put(3, "Vince");
        map.put(4, "Bin");
        map.put(5, "Lily");
        
        System.out.println("size="+map.size());
        //从MAP中取值
        System.out.println(map.get(1));//通过key取value
        
        //map的遍历 1 遍历Entry
        Set<Entry<Integer,String>> entrySet = map.entrySet();
        for(Entry e: entrySet){
            System.out.println(e.getKey()+"->"+e.getValue());
        }
        System.out.println("--------");
        //2 遍历键
        Set<Integer> keys = map.keySet();
        for(Integer i: keys){
            String value = map.get(i);
            System.out.println(i+"->"+value);
        }
        System.out.println("--------");
        //3 遍历值 
        Collection<String> values = map.values();
        for(String value: values){
            System.out.println(value);
        }
        System.out.println("--------");
        //4 foreach
        map.forEach((key,value)->System.out.println(key+"->"+value));
        
        System.out.println(map.containsKey(7));
        
        //hash
        Integer key = 1434;

         System.out.println( 1434 % 16 );
        
    }

    public static void main(String[] args) {
//        hashMap();
//        hashtable();
        treeMap();
    }

}

---

---

 

---

 

package com.vince;

import java.util.Optional;

/**
 * Optional JDK1.8容器类
 * @author vince
 * @description
 */
public class OptionalDemo {

    public static void main(String[] args) {
        //创建Optional对象的方式
        Optional<String> optional = Optional.of("bin");
//        Optional<String> optional2 = Optional.ofNullable("bin");
        Optional<String> optional3 = Optional.empty();
        
        System.out.println(optional.isPresent());
        System.out.println(optional.get());
        
        optional.ifPresent((value)->System.out.println(value));
        
        System.out.println(optional.orElse("无值"));
        
        System.out.println(optional.orElseGet(()->"default"));
        
//        try {
//            optional3.orElseThrow(Exception::new);
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
        
        Optional<String> optional4 = optional.map((value)->value.toUpperCase());
        System.out.println(optional4.orElse("no found"));
        
        optional4 = optional.flatMap((value)->Optional.of(value.toUpperCase()+"-flatMap"));
        System.out.println(optional4.orElse("no found"));
        
        optional4 = optional.filter((value)->value.length()>3);
        System.out.println(optional4.orElse("这个值的长度小于3"));
    }
}

---

 

package com.vince;

import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

/**
 * Queue接口：队列，是一种先进先出的线性数据结构（排队）
 * LinkedList类实现了queue接口
 * 请求队列，消息队列，任务
 * 
 * Deque接口：双端队列
 * Stack：堆栈 :先进后出
 * @author vince
 * @description
 */
public class QueueDequeDemo {
    
    private static void stack(){
        Stack<String> s = new Stack<>();
        //压栈
        s.push("Bin");
        s.push("Tom");
        s.push("Lily");
        
        System.out.println(s.pop());
        System.out.println(s.pop());
        System.out.println(s.pop());
        
        
    }
    private static void deque(){
        Deque<String> deque = new LinkedList<>();
        deque.add("小花");
        deque.add("小黑");
        deque.add("小小");
        deque.add("小白");
        deque.add("小丽");
        
        System.out.println(deque.getFirst());
        System.out.println(deque.getLast());
        
    }
    private static void queue(){
        Queue<String> queue = new LinkedList<>();
        queue.add("小花");
        queue.add("小黑");
        queue.add("小小");
        queue.add("小白");
        queue.add("小丽");
        
        System.out.println(queue.size());
        System.out.println(queue.peek());
        System.out.println(queue.size());
        System.out.println(queue.poll());
        System.out.println(queue.size());
    }

    public static void main(String[] args) {
//        queue();
//        deque();
        stack();
        
    }

}

---

 一对多关系：

package com.vince;

import java.util.HashSet;

//一个老师对应多个学生；
public class Teacher {

    private String name;
    private int age;
    private String sex;
    //因为一对多，所以学生要设置集合
    private HashSet<Student> students = new HashSet<>();
    
    
    public HashSet<Student> getStudents() {
        return students;
    }
    public void setStudents(HashSet<Student> students) {
        this.students = students;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Teacher(String name, int age, String sex) {
        super();
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public Teacher() {
        super();
        // TODO Auto-generated constructor stub
    }
    @Override
    public String toString() {
        return "Teacher [name=" + name + ", age=" + age + ", sex=" + sex + "]";
    }
    
}

package com.vince;

public class Student {
    
    private String name;
    private int age;
    private Teacher teacher;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
    public Teacher getTeacher() {
        return teacher;
    }
    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
    
}

package com.vince;

import java.util.Iterator;



public class OneToManyDemo {
    public static void main(String[] args) {
        
        Teacher t1 = new Teacher("张老师",18,"女");
        Student s1 = new Student("小李",10);
        Student s2 = new Student("小王",12);
        Student s3 = new Student("小赵",11);
        
        //关联关系：
        t1.getStudents().add(s1);
        t1.getStudents().add(s2);
        t1.getStudents().add(s3);
        
        s1.setTeacher(t1);
        s2.setTeacher(t1);
        s3.setTeacher(t1);
        
        Print(t1);
    }

    private static void Print(Teacher t1) {
        // TODO Auto-generated method stub
        System.out.println(t1.getName());
        for(Student s: t1.getStudents()) {
            System.out.println(s);
        }
    }

}

多对多关系(不建议存在这种方式,关系复杂)：

 　　一般把多对多分成两个一对多关系：

 

---

ConcreteAggregate

package iterator;

/**
 * 迭代器接口的具体实现类
 * @author vince
 * @description
 */
public class ConcreteIterator implements Iterator{

    private MyList list = null;
    private int index;//迭代器的指针
    public ConcreteIterator(MyList list) {
        this.list = list;
    }
    @Override
    public boolean hasNext() {
        if(index>=list.getSize())
            return false;
        else return true;
    }

    @Override
    public Object next() {
        Object obj = list.get(index);
        index++;
        return obj;
    }

}

package iterator;

/**
 * 迭代器的接口
 * @author vince
 * @description
 */
public interface Iterator {
    public boolean hasNext();
    public Object next();
}

package iterator;

/**
 * 容器的接口
 * @author vince
 * @description
 */
public interface MyList {
    void add(Object e);
    Object get(int index);
    Iterator iterator();
    int getSize();
    
}

package iterator;

/**
 * 迭代器模式
提供一个方法按顺序遍历一个集合内的元素，而又不需要暴露该对象的内部表示。

应用场景
1、访问一个聚合的对象，而不需要暴露对象的内部表示
2、支持对聚合对象的多种遍历
3、对遍历不同的对象，提供统一的接口。

迭代器模式的角色构成
(1)迭代器角色（Iterator）:定义遍历元素所需要的方法，一般来说会有这么三个方法：
    取得下一个元素的方法next()，判断是否遍历结束的方法hasNext()），移出当前对象的方法remove(),
(2)具体迭代器角色（Concrete Iterator）：实现迭代器接口中定义的方法，完成集合的迭代。
(3)容器角色(Aggregate):  一般是一个接口，提供一个iterator()方法，
    例如java中的Collection接口，List接口，Set接口等
(4)具体容器角色（ConcreteAggregate）：就是抽象容器的具体实现类，
    比如List接口的有序列表实现ArrayList，List接口的链表实现LinkList，
    Set接口的哈希列表的实现HashSet等。

 * @author vince
 * @description
 */
public class Test {

    public static void main(String[] args) {
        MyList list = new ConcreteAggregate();
        list.add("刘备");
        list.add("张飞");
        list.add("关羽");
        list.add("曹操");
        list.add("诸葛亮");
        Iterator iter = list.iterator();
        while(iter.hasNext()){
            System.out.println(iter.next());
        }
    }

}

---

 

https://blog.csdn.net/feiyanaffection/article/details/81394745