【Java学习笔记】Java 集合框架（1）

→教程网站

1 存放多个对象

1.1数组

声明一个数组用于存放对象，会浪费或放不下

package collection;

import charactor.Hero;

public class TestCollection {
    public static void main(String[] args){
        Hero hero[] = new Hero[10];
        //声明长度为10的数组用于存放英雄
        //超过数组长度会报错
        hero[9] = new Hero("Tim");
    }
}

1.2 ArrayList

为解决数组的局限性问题，引入容器类，最常见的容器类为ArrayList。它可以随增加扩大

package collection;

import charactor.Hero;

import java.util.ArrayList;

public class TestCollection {
   @SuppressWarnings("rawtypes")
    public static void main(String[] args){
       ArrayList heros = new ArrayList();
       heros.add(new Hero("Tim"));
       System.out.println(heros.size());

       heros.add(new Hero("Jimmy"));
       System.out.println(heros.size());
   }
}

2 ArrayList的常用方法

add 增加
contains 判断是否存在
get 获取指定位置的对象
indexOf 获取对象所处的位置
remove 删除
set 替换
size 获取大小
toArray 转换为数组
addAll 把另一个容器所有对象都加进来
clear 清空

package collection;

import charactor.Hero;

import java.util.ArrayList;

public class TestCollection {
   @SuppressWarnings("rawtypes")
    public static void main(String[] args){
       ArrayList heros = new ArrayList();
       //直接add对象
       for (int i = 0; i < 5; i++) {
           heros.add(new Hero("hero"+i));
       }
       //在特殊位置插入对象
       Hero oneHero = new Hero("Hero one");
       heros.add(3,oneHero);
       System.out.println(heros);

       System.out.println(heros.contains(oneHero));
       System.out.println("索引为3的对象为"+heros.get(3));
       System.out.println("hero4的索引为"+heros.indexOf("hero4"));

       heros.remove(1);//根据下标删除
       System.out.println("删除索引为1的对象后："+heros);
       heros.set(2,new Hero("hero new"));//根据索引替换对象
       System.out.println("替换索引为2的对象后："+heros);
       Hero hs[] = (Hero[])heros.toArray(new Hero[]{});//转化为数组
       System.out.println("转化为数组："+hs);

       //addAll把另一个容器中的对象加入进来
      ArrayList addHeros = new ArrayList();
      addHeros.add(new Hero("Hero A"));
      addHeros.add(new Hero("Hero B"));

      heros.addAll(addHeros);
      System.out.println("加入另一个容器中的对象后输出为："+heros);

   }
}

输出结果

[hero0, hero1, hero2, Hero one, hero3, hero4]
true
索引为3的对象为Hero one
hero4的索引为-1
删除索引为1的对象后：[hero0, hero2, Hero one, hero3, hero4]
替换索引为2的对象后：[hero0, hero2, hero new, hero3, hero4]
转化为数组：[Lcharactor.Hero;@65ab7765
加入另一个容器中的对象后输出为：[hero0, hero2, hero new, hero3, hero4, Hero A, Hero B]

2.1List接口

package collection;

import charactor.Hero;

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

public class TestCollection {

   public static void main(String[] args){
      List heros = new ArrayList();
      heros.add(new Hero("Tim"));
      System.out.println(heros.size());
   }

}

3 泛型

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

4 遍历（for/iterator/for:）

4.1迭代器(iterator)

package collection;

import charactor.Hero;

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

public class TestCollection {

   public static void main(String[] args){
     List<Hero> heros = new ArrayList<Hero>();

     for(int i = 0; i < 5; i++){
        heros.add(new Hero("hero name"+i));
     }


      Iterator<Hero> it = heros.iterator();
      //使用while的iterator
     while (it.hasNext()){
        Hero h = it.next();
        System.out.println(h);
     }

     //使用for的iterator
      for(Iterator<Hero> iterator = heros.iterator();iterator.hasNext();){
         Hero hero = (Hero) iterator.next();
         System.out.println(hero);
      }
   }

}

5 LinkedList

5.1 双向链表Deque

除了实现了List接口外，LinkedList还实现了双向链表结构Deque，可以很方便的在头尾插入删除数据

package collection;

import charactor.Hero;

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

public class TestCollection {

   public static void main(String[] args) {
      LinkedList<Hero> ll = new LinkedList<Hero>();
      //在头部或尾部插入数据
      ll.addLast(new Hero("hero1"));
      ll.addLast(new Hero("hero2"));
      ll.addLast(new Hero("hero3"));
      ll.addLast(new Hero("hero4"));
      //查看最前面或者后面的英雄
      System.out.println(ll.getFirst());
      System.out.println(ll.getLast());
      //去除最前面或最后面的英雄
      ll.removeFirst();
      ll.removeLast();
   }
}

5.2队列 Queue

offer 在最后添加元素
poll 取出第一个元素
peek 查看第一个元素

package collection;

import charactor.Hero;


import java.util.LinkedList;

public class TestCollection {

   public static void main(String[] args) {
      LinkedList<Hero> ll = new LinkedList<Hero>();
      //用offer插入数据
      ll.offer(new Hero("hero1"));
      ll.offer(new Hero("hero2"));
      ll.offer(new Hero("hero3"));

      System.out.println(ll);
      //peek查看第一个元素
      ll.peek();
      //poll移除第一个元素
      ll.poll();
      System.out.println(ll);

   }
}

输出

[hero1, hero2, hero3]
[hero2, hero3]

5.3用LinkedList实现Stack栈

Stack接口

package collection;

import charactor.Hero;

public interface Stack
{
    public void push(Hero h);
    public void pull();
    public void peek();
}

MyStack类

package collection;

import charactor.Hero;

import java.util.LinkedList;

public class MyStack implements Stack {

    LinkedList<Hero> ll = new LinkedList<Hero>();

    @Override
    public void push(Hero h){
        ll.addLast(h);
    }

    @Override
    public void peek(){
        ll.getLast();
    }

    @Override
    public void pull(){
        System.out.println(ll.getLast());
        ll.removeLast();
    }

    public static void main(String[] args){
        MyStack heroStack = new MyStack();
        for (int i = 0; i <5 ; i++) {
            Hero h =new Hero("hero"+i);
            heroStack.push(h);
            System.out.println(h);
        }

        for(int i = 0; i <5 ;i++){
            heroStack.pull();
        }
    }

}