集合体系结构（Collection，list系列，数据结构，set系列，哈希表，各种二叉树，树，红黑树。。。演示代码，超详细）

Collection 集合特点

代码演示

import java.util.ArrayList;
import java.util.Collection;

public class Main {
    public static void main(String[] args) {
        Collection<Object> cool=new ArrayList<>();
//添加
        cool.add("aaa");
        cool.add("bmy");
        cool.add("ssg");//[aaa, bmy, ssg]
//删除
        cool.remove("aaa");//[bmy, ssg]
//清楚
     //   cool.clear();

//        判断当前的元素是否存在
      boolean s=  cool.contains("ssg");
      System.out.println(s);//存在返回true

//        判断集合是否为空
        boolean result =cool.isEmpty();
        System.out.println(result);

//        集合长度
        int size=cool.size();
        System.out.println(size);
        System.out.println(cool);

    }
}

 collection遍历方式

迭代器遍历

迭代器不依赖索引 

在这个的基础上添加个循环就能访问所有的元素了

 

• it.next 是迭代器（Iterator）接口中的方法，用于获取迭代器中的下一个元素，并将迭代器指针移动到下一个位置。在使用迭代器遍历集合或数组时，通常会先通过 hasNext 方法检查是否还有下一个元素，然后再调用 next 方法获取元素。

遍历代码 

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class iterator {
    public static void main(String[] args) {

        Collection<String> coll=new ArrayList<>();
        coll.add("akm");
        coll.add("gfc");
        coll.add("ef");
        coll.add("gvc");
        coll.add("ged");
        Iterator<String> It= coll.iterator();
        while (It.hasNext()){
String str=It.next();
System.out.println(str);

        }

    }
}

删除集合里面某个元素

        while (It.hasNext()){
String str=It.next();
if ("ef".equals(str)){
    It.remove();
}

 

 

总结

 增强for遍历

实例代码

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class iterator {
    public static void main(String[] args) {

        Collection<String> coll=new ArrayList<>();
        coll.add("akm");
        coll.add("gfc");
        coll.add("ef");
        coll.add("gvc");
        coll.add("ged");

        for (String s : coll) {
            System.out.println(s);
        }
    }
}

 lambda表达式遍历

总结

 list集合特点

 

代码演示

package list;

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

public class list {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("aaa");
        list.add("efa");
        list.add("gfg");
        list.add("wrv");


//给集合的指定位置添加元素
        list.add(0,"vvv");
        System.out.println(list);//[vvv, aaa, efa, gfg, wrv]
//        删除集合中的元素
       String remove= list.remove(1);
System.out.println(remove);
list.remove("vvv");
System.out.println(list);
//修改指定索引处的元素，打印修改后的值
        list.set(2,"akm");
        System.out.println(list);

    }
}

 list集合的遍历方式

代码演示 

package list;

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

public class list {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("aaa");
        list.add("efa");
        list.add("gfg");
        list.add("wrv");

//一下三种方式可以遍历集合
        //1.迭代器
        Iterator<String> it=list.iterator();
        while (it.hasNext()){
            String str= it.next();
            System.out.println(str);
        }

        //2.


        //增强for
        for (String s : list) {
            System.out.println(s);
        }

//普通遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

    }
}

 列表迭代器

局限性，必须先把指针移动到最后，才能倒着遍历 

五种遍历方式对比

 数据结构概述 

 

 Array list集合底层原理

linked list集合

 

泛型深入

 

 

 

 

 

树 

二叉树也是长这样的 

 二叉查找树

 

 平衡二叉树，在查找二叉树的基础上多了一个条件

  

 

 

Set系列集合

 

 

演示代码

package set;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class sett {
    public static void main(String[] args) {
        Set<String> st=new HashSet<>();
        st.add("小一");
        st.add("小二");
        st.add("小三");
        st.add("小四");
        st.add("小五");
            System.out.println(st);//[小三, 小二, 小四, 小一, 小五]

        Iterator<String> it = st.iterator();
        while (it.hasNext()){
            String s= it.next();
            System.out.println(s);
        }
System.out.println("******************");
        for (String s : st) {
            System.out.println(s);
        }

    }
}

 hashset

 

 

演示代码

package set;

import java.util.HashSet;

public class test {
    public static void main(String[] args) {
        student s1=new student("aisan",20);
        student s2=new student("bahts",23);
        student s3=new student("calam",15);
        student s4=new student("bahts",23);

        HashSet<student> hs=new HashSet<>();



        System.out.println( hs.add(s1));
        System.out.println( hs.add(s2));
        System.out.println( hs.add(s3));
        System.out.println( hs.add(s4));
        System.out.println(hs);


    }
}

 （代码不包含学生对象）

linkedhashset 

 

（其实就是和上面的代码类似）

总结 

treeset

 

代码演示

package set;

import java.util.Iterator;
import java.util.TreeSet;

public class treeset {
    public static void main(String[] args) {
        TreeSet<Integer>  ts=new TreeSet<>();
        ts.add(5);
        ts.add(9);
        ts.add(1);
        ts.add(4);
        ts.add(3);
        System.out.println(ts);//[1, 3, 4, 5, 9]

        Iterator<Integer> it =ts.iterator();

        for (Integer integer : ts) {
            System.out.println(integer);
        }

    }
}

练习题 

使用默认排序进行排序，因为treeset的底层是红黑树，所以需要置顶排序规则，上面的hashset之类的不用重写排序规则

（将学生类里面使用上面的接口就可以了）

package set;

import java.util.Set;
import java.util.TreeSet;

public class stu {
    public static void main(String[] args) {
        student s1=new student("ali",52);
        student s2=new student("nur",15);
        student s3=new student("ibr",22);
        student s4=new student("sall",22);

        TreeSet<student> ts=new TreeSet<>();
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);

System.out.println(ts);
    }
}

中间就是标准的JavaBean 

 

 

package set;

import java.util.Comparator;
import java.util.TreeSet;

public class anchangdu {
    public static void main(String[] args) {

        TreeSet<String> ts=new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //按照长度进行排序
                int i=o1.length()-o2.length();
                //如果一样长。按照字母进行排序
                i=i==0?o1.compareTo(o2):i;

                return i;

            }
        });
        ts.add("ad");
        ts.add("mhed");
        ts.add("b");
        System.out.println(ts);
    }
}

 

总结

 使用场景总结，重中之重