java基础——容器

参考:https://how2j.cn/k/collection/collection-arraylist/363.html?p=136471

1.容器的优势
数组的局限性:比如 声明长度是10的数组不用的数组就浪费了,超过10的个数,又放不下

为了解决数组的局限性,引入容器类的概念。 最常见的容器类就是 ArrayList
容器的容量"capacity"会随着对象的增加自动增长 ,只需要不断往容器里增加英雄即可,不用担心会出现数组的边界问题。

2.ArrayList
维护索引和对应索引的值
常用方法:add,get,indexOf,set,remove,size,contains,addAll,clear

ArrayList heros = new ArrayList();
heros.add(new Hero("hero"));  // 追加
heros.add(3, specialHero);  // 插入指定位置
heros.contains(specialHero)  // 判断容器中是否存在
heros.get(5)  // 索引取值
heros.indexOf(specialHero)
heros.remove(2);  // 根据索引删除
heros.remove(specialHero);  //根据对象删除
heros.set(5, new Hero("hero 5"));  //替换对应索引的值
heros.size()  
Hero hs[] = (Hero[])heros.toArray(new Hero[]{});  //转换为数组,需要提供类型,默认转Object数组
heros.addAll(anotherHeros);  // 容器扩展
heros.clear();  //清空

// ArrayList实现了接口List,常见的写法会把引用声明为接口List类型 java.util.List
List heros = new ArrayList();

3.泛型
不指定泛型的容器,可以存放任何类型的元素,指定了泛型的容器,只能存放指定类型的元素以及其子类

ArrayList 默认接受Object类型的对象,若不指定泛型 取出对象为Objecs类型,需要强制转换后才能调用对应类型的方法(如强制转换为APHero类型或者ADHero类型)

		//声明容器的时候,就指定了这种容器,只能放Hero,放其他的就会出错
        List<Hero> genericheros = new ArrayList<Hero>();
		// List<Hero> genericheros2 = new ArrayList<>(); 简写
		
        genericheros.add(new Hero("盖伦"));
        //如果不是Hero类型,根本就放不进去
        //genericheros.add(new Item("冰杖"));  报错
          
        //除此之外,还能存放Hero的子类
        genericheros.add(new APHero());

        //并且在取出数据的时候,不需要再进行转型了,因为里面肯定是放的Hero或者其子类
        Hero h = genericheros.get(0);

4.ArrayList遍历

		List<Hero> heros = new ArrayList<Hero>();
 
        // 放5个Hero进入容器
        for (int i = 0; i < 5; i++) {
            heros.add(new Hero("hero name " + i));
        }
 
        // 第一种遍历 for循环
        for (int i = 0; i < heros.size(); i++) {
            Hero h = heros.get(i);
            System.out.println(h);
        }

		//第二种遍历,使用迭代器
        Iterator<Hero> it= heros.iterator();
        //从最开始的位置(空位置,索引0的前一个)判断"下一个"位置是否有数据
        //如果有就通过next取出来,并且把指针向下移动,直到"下一个"位置没有数据
        while(it.hasNext()){
            Hero h = it.next();
            System.out.println(h);
        }
        
        //迭代器的for写法
        for (Iterator<Hero> iterator = heros.iterator(); iterator.hasNext();) {
            Hero hero = (Hero) iterator.next();
            System.out.println(hero);
        }

		// 第三种,增强for循环,无法进行ArrayList的初始化,无法获得索引,但可以自定义下表变量
        for (Hero h : heros) {
            System.out.println(h);
        }

5.LinkedList
与ArrayList一样,LinkedList也实现了List接口,因此包含add,remove,contains等等方法
除了实现了List接口外,LinkedList还实现了双向链表结构Deque,可以很方便的操作头尾元素

		//LinkedList是一个双向链表结构的list
        List<Hero> ll =new LinkedList<Hero>();
         
        //所以可以很方便的在头部和尾部插入数据
        ll.addLast(new Hero("hero1"));
        //在最前面插入新的英雄
        ll.addFirst(new Hero("heroX"));
        
        //查看最前面的英雄
        System.out.println(ll.getFirst());
        //查看最后面的英雄
        System.out.println(ll.getLast());
        
        //取出最前面的英雄
        System.out.println(ll.removeFirst());
        //取出最后面的英雄
        System.out.println(ll.removeLast());
        //取出会从容器中删除
        System.out.println(ll);

LinkedList 除了实现了List和Deque外,还实现了Queue接口(队列)
Queue是先进先出队列 FIFO,常用方法:offer 在最后添加元素,poll 取出第一个元素,peek 查看第一个元素

        //Queue代表FIFO 先进先出的队列
        Queue<Hero> q= new LinkedList<Hero>();
          
        //在最后添加元素
        q.offer(new Hero("Hero1"));
        //取出第一个Hero,FIFO 先进先出
        Hero h = q.poll();
        //查看第一个元素
        h=q.peek();

6.ArrayList和LinkedList的区别
ArrayList 插入,删除数据慢(需要维护索引);LinkedList插入,删除数据快
ArrayList是顺序结构,所以定位很快,根据索引就能直接找到;
LinkedList 是链表结构,不维护索引,想要找到100号元素,只能遍历过去

从头部添加数据,链表快很多,尾部添加 两个差不多,理论上链表更快(不需要新增最后一个元素的索引)

如果从中间或指定索引插入或修改数据就要看情况了(看是遍历耗时更多还是修改耗时更多)

7.工具类Collections
Collections是容器的工具类,就如同Arrays是数组的工具类

		//初始化集合numbers
        List<Integer> numbers = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            numbers.add(i);
        }
         
        Collections.reverse(numbers);  //reverse 使List中的数据发生翻转
		Collections.shuffle(numbers);  // 打乱
		Collections.sort(numbers);     //排序
        Collections.swap(numbers,0,5);  // 交换位置
		Collections.rotate(numbers,2);	// 数据向右滚动

8.HashMap
对应python中的字典

		HashMap<String,String> dictionary = new HashMap<>();
        dictionary.put("adc", "物理英雄");
        System.out.println(dictionary.get("adc"));

        for (String key : map.keySet()) {
        	System.out.println("key= "+ key + " and value= " + map.get(key));
        	}

        for (String v : map.values()) {
            System.out.println("value= " + v);
        	}

9.各个容器的区别

ArrayList: 有顺序 ;HashSet(对应python中的集合,没有value的字典): 无顺序

List中的数据可以重复;Set中的数据不能重复(key不能重复),判断的标准:先比较hashcode,不同再比较equals

HashMap中可以使用 null;Hashtable不行

发布了105 篇原创文章 · 获赞 8 · 访问量 2万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 技术黑板 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览