Java集合

集合

 

容器类ArrayList

容器的容量会随着对象的增加自动增长，不需要考虑边界

常见容器类：ArrayList

ArrayList实现了接口List类型

 public static void main(String[] args) {
         //新建容器类
         ArrayList<Integer> ints = new ArrayList<Integer>();
         ArrayList<Integer> ints1 = new ArrayList<Integer>();
         ints.add(1);
         ints.add(2);
         ints.add(3);
         ints1.add(1);
         ints1.add(2);
         ints1.add(3);
         //contains判断是否存在
         System.out.println(ints.contains(1));
         //get(i)获取指定位置i的对象
         System.out.println(ints.get(0));
         //indexOf判断对象所处的位置
         System.out.println(ints.indexOf(2));
         //remove(i)删除i位置的对象
         ints.remove(0);
         //set(i,x)将i位置的对象替换为x
         ints.set(0,4);
         //size()获取ArrayList的大小
         System.out.println(ints.size());
         //addAll添加另一个容器的所有对象
         ints.addAll(ints1);
         //toArray转换为数组
         //用法待补充
         //清空ArrayList
         ints.clear();
     }

 

 

泛型

不指定泛型的容器，可以存放任何类型的元素

指定了泛型的容器，只能存放指定类型的元素及其子类

 //引入泛型Generic：容器+<Type>
 //声明容器的时候，就指定了这种容器，只能放Hero及其子类，放其他的就会出错
 List<Hero> genericheros = new ArrayList<Hero>();

 

遍历

 //for循环遍历
 for (int i = 0; i < heros.size(); i++) {
     Hero h = heros.get(i);
     System.out.println(h);
 }
 ​
 //迭代器iterator遍历
 //while写法
 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循环遍历
 //缺点：无法用于初始化，无法得知当前的下标
 for (Hero h : heros) {
     System.out.println(h);
 }

 

LinkedList

LinkedList实现了双向链表Deque、队列Queue接口

 LinkedList<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());
 ​
 //LinkedList实现了List和Queue接口
 List ll =new LinkedList<Hero>();
 Queue<Hero> q= new LinkedList<Hero>();          
 //offer插入队列末尾
 q.offer(new Hero("Hero1"));
 //poll取出队列头
 Hero h = q.poll();
 //peek查看队列头但不取出
 h=q.peek();

 

 

HashMap

HashMap以键值对的方式储存数据

键key不可以重复，值可以重复

 HashMap<String,String> dictionary = new HashMap<>();
 //put(关键字,值)插入
 dictionary.put("1", "123");
 dictionary.put("2", "456");
 dictionary.put("3", "789");
 //get(关键值)输出
 System.out.println(dictionary.get("3"));//输出789

 

HashSet

HashSet中的元素不能重复、无序

HashSet不提供get方法获取指定位置的元素，只能通过迭代器或增强型for循环，

 HashSet<Integer> numbers = new HashSet<Integer>();
  //add(值)插入
 numbers.add(9);
 numbers.add(5);
 numbers.add(1);
 // Set中的元素排列，不是按照插入顺序
 System.out.println(numbers);
 ​
 //
 for (Iterator<Integer> iterator = numbers.iterator(); iterator.hasNext();) {
     Integer i = (Integer) iterator.next();
     System.out.println(i);
 }
 for (Integer i : numbers) {
     System.out.println(i);
 }

 

HashSet内部封装了一个HashMap，HashSet作为Map的key，而value是名为PRESENT的静态Object对象，一个类属性

 

 

Collection

Collection是队列Set List Queue和双向链表Deque的接口

Collection和Map之间没有关系，Collection存放对象，Map存放键值对

 

 

Collections

Collections是一个类，容器的工具类

 

集合框架的比较

• ArrayList vs HashSet

  • ArrayList：有序、可重复

  • HashSet：无序、不可重复

• ArrayList vs LinkedList

  • ArrayList：插入删除慢，定位快（顺序）

  • LinkedList：插入删除快，定位慢（链表）

• HashMap vs HashTable

  • HashMap：可以存null，非线程安全类

  • HashTable：不能存null，线程安全类

• 其他几种Set

  • HashSet： 无序

  • LinkedHashSet： 按照插入顺序

  • TreeSet： 从小到大排序

 

hashcode原理

HashMap查找比ArrayList查找快

HashMap通过计算关键字的hash值，生成键值对，查找时直接定位，只有hashcode相同时需要比较