美文网首页
Ⅶ.容器

Ⅶ.容器

作者: 唐騦忆 | 来源:发表于2020-02-27 17:30 被阅读0次

1. 集合(Collection.List.ArrayList)

优势:效率高
劣势:不够灵活,需要预先指定大小

2. 链表(Collecttion.List.LinkedList)

3. 哈希(Collecttion.set.HashSet)

4. 哈希(Map.HashMap)

5. collection方法

Collection<String> c = new ArrayList<String>();
Collection<String> b = new ArrayList<String>();
#容器大小
c.size();
#容器是否为空
c.isEmpty();
#增加引用
c.add("town");
#移出引用(对象未被删除)
c.remove("town");
#移出所有引用
c.clear();
#转换为数组
c.toArray;
#是否包含
c.Contains("town");

#添加所有b元素到c中
c.addAll(b);
#从c中移出与b相同的元素
c.removeAll(b);
#从c中移出与b不同的元素
c.retainAll(b);
#c是否包含完全包含b
c.ContainsAll(b);

6. 泛型

本质:数据类型的参数化,泛型的处理在编译器中进行。
<T.E.V><class>
用于指定容器内所能存入的数据类型。

类泛型:类实例化时可以实例化多种集合

public class MyCollection<E>{
  Object[] objs = new Object[5];
  public void set(E e,int index){
    Object[index] = e;
  }
  public E get(int index){
    return (E) objs[index];
  }
public static void main(String[] args){
  MyCollection<String> mc = new MyColletion<String>();
  mc.set("town",0);
  String a = mc.get(0);
}
}

集合泛型:规定集合内所能填入的内容

 ArrayList<APHero> heros = new ArrayList<APHero>();
public class TestGeneric {
 
    public static void main(String[] args) {
        ArrayList<APHero> heros = new ArrayList<APHero>();
         
        //只有APHero可以放进去    
        heros.add(new APHero());
         
        //ADHero甚至放不进去
        //heros.add(new ADHero());
         
        //获取的时候也不需要进行转型,因为取出来一定是APHero
        APHero apHero =  heros.get(0);
         
    }
}

通配符
ArrayList heroList<? extends Hero> 表示这是一个Hero泛型或者其子类泛型
heroList 的泛型可能是Hero
heroList 的泛型可能是APHero
heroList 的泛型可能是ADHero
所以 可以确凿的是,从heroList取出来的对象,一定是可以转型成Hero的
但是,不能往里面放东西,因为
放APHero就不满足<ADHero>
放ADHero又不满足<APHero>

import java.util.ArrayList;
  
import charactor.ADHero;
import charactor.APHero;
import charactor.Hero;
   
public class TestGeneric {
   
    public static void main(String[] args) {
          
        ArrayList<APHero> apHeroList = new ArrayList<APHero>();
        apHeroList.add(new APHero());
         
        ArrayList<? extends Hero> heroList = apHeroList;
          
        //? extends Hero 表示这是一个Hero泛型的子类泛型
          
        //heroList 的泛型可以是Hero
        //heroList 的泛型可以使APHero
        //heroList 的泛型可以使ADHero
          
        //可以确凿的是,从heroList取出来的对象,一定是可以转型成Hero的
          
        Hero h= heroList.get(0);
          
        //但是,不能往里面放东西
        heroList.add(new ADHero()); //编译错误,因为heroList的泛型 有可能是APHero
          
    }
      
}

ArrayList heroList<? super Hero> 表示这是一个Hero泛型或者其父类泛型
heroList的泛型可能是Hero
heroList的泛型可能是Object
可以往里面插入Hero以及Hero的子类
但是取出来有风险,因为不确定取出来是Hero还是Object

public class TestGeneric {
    public static void main(String[] args) {
  
        ArrayList<? super Hero> heroList = new ArrayList<Object>();
          
        //? super Hero 表示 heroList的泛型是Hero或者其父类泛型
          
        //heroList 的泛型可以是Hero
        //heroList 的泛型可以是Object
          
        //所以就可以插入Hero
        heroList.add(new Hero());
        //也可以插入Hero的子类
        heroList.add(new APHero());
        heroList.add(new ADHero());
          
        //但是,不能从里面取数据出来,因为其泛型可能是Object,而Object是强转Hero会失败
        Hero h= heroList.get(0);
          
    }
  
}

?
只能以Object的形式取出来
并且不能往里面放对象,因为不知道到底是一个什么泛型的容器

        //?泛型通配符,表示任意泛型
        ArrayList<?> generalList = apHeroList;
 
        //?的缺陷1: 既然?代表任意泛型,那么换句话说,你就不知道这个容器里面是什么类型
        //所以只能以Object的形式取出来
        Object o = generalList.get(0);
 
        //?的缺陷2: 既然?代表任意泛型,那么既有可能是Hero,也有可能是Item
        //所以,放哪种对象进去,都有风险,结果就什么什么类型的对象,都不能放进去
        generalList.add(new Item()); //编译错误 因为?代表任意泛型,很有可能不是Item
        generalList.add(new Hero()); //编译错误 因为?代表任意泛型,很有可能不是Hero
        generalList.add(new APHero()); //编译错误  因为?代表任意泛型,很有可能不是APHero

如果希望只取出,不插入,就使用? extends Hero
如果希望只插入,不取出,就使用? super Hero
如果希望,又能插入,又能取出,就不要用通配符?

泛型不能进行父子类型转换。

应用:二叉树

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

public class Node<T> {

        // 左子节点
        public Node<T> leftNode;
        // 右子节点
        public Node<T> rightNode;

        // 值
        public T value;

        // 插入 数据
        public void add(T t) {
            // 如果当前节点没有值,就把数据放在当前节点上
            if (null == value)
                value = t;

                // 如果当前节点有值,就进行判断,新增的值与当前值的大小关系
            else {
                // 新增的值,比当前值小或者相同

                if ((Double) t >((Double)value) ) {
                    if (null == leftNode)
                        leftNode = new Node();
                    leftNode.add(t);
                }
                // 新增的值,比当前值大
                else {
                    if (null == rightNode)
                        rightNode = new Node();
                    rightNode.add(t);
                }

            }

        }

        // 中序遍历所有的节点
        public List<T> values() {
            List<T> values = new ArrayList<T>();

            // 左节点的遍历结果
            if (null != leftNode)
                values.addAll(leftNode.values());

            // 当前节点
            values.add( value);

            // 右节点的遍历结果
            if (null != rightNode)

                values.addAll(rightNode.values());

            return values;
        }

        public static void main(String[] args) {

            double randoms[] = new double[] { 67.1, 7, 30, 73, 10, 0.1, 78.1, 81, 10, 74 };

            Node roots = new Node();
            for (double number : randoms) {
                roots.add(number);
            }

            System.out.println(roots.values());

        }
    }


相关文章

  • Docker入门(3)---Docker容器

    Docker 容器操作 启动容器 启动已终止容器 容器查看 停止容器 进入容器 删除容器

  • Docker容器管理

    目录 创建容器 启动容器 停止容器 进入容器 删除容器 容器迁移 1. 创建容器 docker创建容器可以用doc...

  • Docker 容器命令

    运行容器 运行Redis容器: 容器列表 停止容器 停止Redis 启动容器 停止Redis 端口映射 删除容器 ...

  • 一、容器

    (1)容器分类 <1>顺序容器(序列容器) <2>关联容器 <3>容器适配器 (2)vector容器 <1>概念 ...

  • docker容器命令

    1、查看运行的容器 2、查看所有的容器 3、创建容器 4、进入容器 5、启动容器 6、停止容器 7、删除容器 8、...

  • spring的父子容器及配置

    spring父子容器 spring总的上下文容器有父子之分,父容器和子容器。** 父容器对子容器可见,子容器对父容...

  • STL--vector、deque、list、set、map、s

    vector(向量容器) deque(双端队列容器) list(链表容器) set(集合容器) map(映射容器)

  • docker容器基本操作

    启动交互式容器 查看容器 自定义容器的名字 重启启动停止的容器 删除停止的容器 守护式容器 什么是守护式容器: 能...

  • 面试知识点(5)STL

    容器类型 STL容器主要分为 顺序容器 vector(向量容器) deque(双端队列容器) list(双向链...

  • 标准模板库(容器)

    vector 向量容器 List 容器 map 容器

网友评论

      本文标题:Ⅶ.容器

      本文链接:https://www.haomeiwen.com/subject/clqdbctx.html