集合浅解

集合

集合，见名知意，就是把某些东西放在一起。但是它不同于数组。

简单的数据结构

数组：数组在内存中开辟了连续的内存空间，方便查找和修改
链表：链表是指在内存中开辟了每一块首尾相连地内存，尾部为null。其特点是方便增减。只需更换链接即可。

代码如下：

     public class IOdemo1{
       private int age;
       priate IOdemo1 io;
        public void IOdemo1(int age){
        this.age=age;
         }
        public void setIOdemo1(IOdemo1 io){
          this.io=io;
         }
      }

   public class test{
     public static void main(String[] args){
     IOdemo1 io=new IOdemo1(10);
     IOdemo1 io1=new IOdemo1(10);
     IOdemo1 io2=new IOdemo1(10);
      io.setIOdemo1(io1);
      io1.setIOdemo1(io2);
     }
    }

从代码中，我们看到，每一个实例化的对象，都会接到下一个对象，这就是链表
- 二叉树：
- 插入第一个数。如果比其大，则放在右边，反之放左边。
- 2，5，9，1，4
- hash表（散列表）：
- 散列表是由数组与链表组成。链表嵌在数组后边

Iterable

Iterable为集合的超级父类，多数集合都实现了这个接口。

List:

List类下由两个集合子类，分别是ArrayList和LinkedList

ArrayList:底层由数组实现，特点和数组一样。方便查找但是不方便增删。

代码如下：

   public static void main(String[] args) {
        java.util.List list=new ArrayList();
        list.add("asdasd");
        list.add("vcs");
        list.add("qwe");
    for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
            }

     运行结果：asdasd  vcs  qwe

LinkedList:底层由链表组成，特点与链表相同，方便增删但不方便查找。

代码如下：

    public static void main(String[] args) {
    java.util.List list=new java.util.LinkedList();
    list.add("admi");
    list.add("sdf");
    list.add(0, "sdj");
    for (Object object : list) {
        System.out.println(object);

    }
    System.out.println("----------------------");
     list.remove(2);
     for (Object object : list) {
            System.out.println(object);
        }
    }

    运行结果：
    sdj
    admi
    sdf
    ----------------------
    sdj
    admi

Set:

注：以tree开头的都是二叉树形式的存储结构，以hash开头的都是hash表的存储结构。
TreeSet:采用二叉树形式的存储结构。改集合会自动排序，查询速度比list快速。但是不如hashSet快，使用TreeSet需要重写Comparable和equlas。

代码如下：

Set set=new HashSet<>();
    set.add("asd");
    set.add("fdv");

    Iterator iterator = set.iterator();
    while(iterator.hasNext()){
        System.out.println(iterator.next());
    }

Iterator 可迭代的迭代器父类是Iterable 均可使用，Iterator可以在方法中使用foreach循环去遍历数据。

foreach代码如下：

     for (Object object : set) {
            System.out.println(object);
        }

HashSet:

Map（映射）:

映射是以key—-value存的，如果相同的key则不存，而不是以value去分辨
HashMap

允许使用null键null值：

 HashMap map = new HashMap();
        map.put("a", "abc");
        map.put("b", "dsc");
        map.put("c", "ffc");
        Set keySet = map.keySet();
        for (Object object : keySet) {
            System.out.println(map.get(object));
        }

HashTable

不能使用null键null值
TreeMap

key必须实现Comparable

根据key排序
Properties

配置文件

可读可写，一般只读
用法与HashMap相同

泛型：

当我们写Comparator的时候，会发现后边跟这个T，这个T是什么呢，就是我们说的泛型。其实就是我们并不确定要传什么类型的，而是根据这个不确定的类型去写一些我们定制的方法或者规范。

 public class MyList<T> {
    List<T> list=new ArrayList<>();
    public void add(T t){
        list.add(t);
    }
    public T get(int index){
        return list.get(index);
    }
    public static void main(String[] args) {
    //      MyList<Student> list=new MyList<>();
    //      list.add(new Student("asd", 10, false));
    //      Student student = list.get(0);
        String msg;
        int error;

    }

集合

简单的数据结构

Iterable

List:

Set:

Map（映射）:

泛型：

猜你喜欢