Java集合类详解

集合类

Java集合类详解

概述

集合类就是一个动态对象数组
与之相关的接口包括

  • Collection
    • List
      • ArrayList
      • Vector
      • LinkedList
    • Set
      • HashSet
        • LinkedHashSet （按照插入顺序存放的，不重复的）
      • SortedSet
        • TreeSet
    • Queue
      • LinkedList
  • Map
    • hashMap
    • weakhashMap
    • SortedMap
      • TreeMap
  • Map.Entry
  • Iterator
    • ListIterator
  • Enumeration 最早的输出的接口

Collection接口

       @Override
        public boolean contains(Object o) {
            return false;
        }

        @Override
        public Iterator<Integer> iterator() {
            return null;
        }

        @Override
        public Object[] toArray() {
            return new Object[0];
        }

        @Override
        public <T> T[] toArray(T[] a) {
            return null;
        }


        @Override
        public boolean containsAll(Collection<?> c) {
            return false;
        }

        @Override
        public boolean addAll(Collection<? extends Integer> c) {
            return false;
        }

        @Override
        public boolean removeAll(Collection<?> c) {
            return false;
        }

        @Override
        public boolean retainAll(Collection<?> c) {
            return false;
        }

        @Override
        public void clear() {
        }

注意 al.retainAll(al1); 相当于求交集然后放在al中 Integer []array1=al.toArray(new Integer[]{});
Object []array2=al.toArray(); 两个获得Array的方法，第一个是通过泛型指定了数组的类型，第二个返回的是Object[]数组，使用的时候需要转型

List接口

可以重复 ，可以认为是一个数组，可以通过索引取出数据
List对于Collection有很大的扩充 新增包括

  • 指定位置增加数据
  • 指定位置增加一组数据
  • 取得指定位置数据
  • 在指定位置删除数据
  • subList(from,to)返回子List
    • al1=al.subList(0,1); 等

数据的顺序与插入顺序一样

LinkedList类

同时实现了List和Queue接口，就是一个链表的封装

   LinkedList<String> ll=new LinkedList<String>();
    ll.add("eq");
    ll.add("eq1");
    ll.add("eq2");
    ll.add("eq3");
    ll.addFirst("23");
    ll.addLast("233");
    System.out.println(ll);

Queue接口

element找到头 offer在队列尾加元素
peek找到头
poll找到头并删除
remove删除头

Set

其中的方法与Collection的完全一样

  • 顺序与插入的顺序无关
  • 不重复的，如果重复插入会忽略
TreeSet
  • 数据是排序的！！，实际上也是SortedSet的一个子类
HashSet
  • 数据散列存放
TreeSet自动排序原理

要排序必须可比较，因此TreeSet指定的类必须实现了Comparable方法

判断重复元素的原理

使用equals和hashCode方法来判断 首先判断hashCoede是否一样，不相同则为不同元素，相同则调用equals()来最终决定，因此将元素加入Set的的时候最好复写这两个方法

  • 对象相等->hashcode一定相等
  • hashCode相等->对象不一定相等

SortedSet接口

是自动排序的 方法

  • 返回首尾元素
  • 返回任意一段子SortedSet headSet/tailSet/subSet

Iterator接口

Collection的输出方式

  • Iterator
  • ListIterator
  • foreach
  • Enumeration

集合的输出最好一定是用Iterator接口
Iterator是迭代输出接口
通过Collection.iterator()实例化
hasnext()判断是否有内容，并且移动指针
在使用迭代输出的时候，不要使用集合类的remove方法，而是要用iterator的remove方法，尽量不要再输出时删除
单向操作

ListIterator接口

继承自Iterator
可以双向的输出
只有List接口才有实例化该接口的方法 只能现正向输出，后逆向输出，不能倒过来 

   List ls=new ArrayList(); 
  ls.add("hello"); 
  ls.add("world"); 
  ls.add("!!!");    
  ListIterator ll=ls.listIterator();
    while (ll.hasNext()){
        System.out.print(ll.next());
    }
    while (ll.hasPrevious()){
        System.out.print(ll.previous());
    }

foreach

可以用于输出集合或者数组中的内容，定义为：

for(type element: array){
     System.out.println(element);
　　}

举例如下

    int s[]={0,1,2,3,4,5};
    for(int w:s){
        System.out.println(w);
    }
    List<Integer> l=new ArrayList<Integer>();
    l.add(2);
    l.add(3);
    l.add(4);
    for(int w:l){
        System.out.println(w);
    }

    int ss[][]={{1,2,3},{4,5,6}};
    //这里展示一下不规则数组
    int sss[][]=new int[2][];
    sss[0]=new int[3];
    sss[1]=new int[5];
    for(int x[]:ss){
        for(int y:x){
            System.out.println(y);
        }
    }

Map接口

Map.Entry接口

是Map的内部接口
指的是一个key->value的对象

实际上Map保存的是Map.Entry的对象，其实也相当于一组对象的集合

常见方法

  • containsKey
  • containsValue
  • get
  • KeySet 返回Key的Set集合
  • Values 返回Value的Collection集合

常用的子类

  • HashMap
  • HashTable 比较老的类，与HashMap相比类似于ArraList与Vector的关系
  • TressMap 按照Key的排序类
  • WeakHashMap
WeakHashMap

当Map的某些内容长期不使用的时候，会自动删除掉
在垃圾回收的时候，会把没有被引用的数据删掉

Map输出，可以获得KeySet然后打印Value，或者使用Map.Entry来迭代输出

    Map<String,String> m=new HashMap<String,String>();
    m.put("1","11"); m.put("2","22");m.put("3","33");

    Set<Map.Entry<String,String>> ms=m.entrySet();
    //迭代器输出
    Iterator<Map.Entry<String,String>> msi=ms.iterator();
    while (msi.hasNext()){
        Map.Entry<String,String> me=msi.next();
        System.out.println(me.getKey()+" "+me.getValue());
    }
    //foreach输出
    for(Map.Entry<String,String> me:ms){
        System.out.println(me.getKey()+" "+me.getValue());
    }

作为Key，实际上是一个Set了，不能重复，是通过equals和hashCode来判断的，所以使用非系统类作为键值的话，应该复写这两个方法

IdentityHashMap

允许key是重复的，比较键（和值）时使用引用相等性代替对象相等性

我们说的Map的键值不能重复，就是说对象equals的时候不能想等。而InentityHashMap中必须使用同一个引用才能认为是相等的

    Map<String,String> mm=new IdentityHashMap<String,String >();
    mm.put(new String("123"),"1");
    mm.put(new String("123"),"2");
    Set<Map.Entry<String,String>> ms1=mm.entrySet();
    for(Map.Entry<String,String> me:ms1){
        System.out.println(me.getKey()+" "+me.getValue());
    }
//这段代码可以打印出结果，但是，由于“123”的引用都丢失了，实际上你通过get(i)是取不出来任何数据的

SoretdMap/TreeMap

按照key进行排序，可以获得第一个/最后一个key，获得部分的Map的集合

    SortedMap<String,String> sm=new TreeMap<String,String>();
    sm.put("A","AA");
    sm.put("C","CC");
    sm.put("B","BB");
    System.out.println(sm.lastKey());
    System.out.println(sm.firstKey());
    sm.subMap("B","C");

对象引用强度说明

  • 强引用
    • 即使jvm内存不足，也不回收这个对象
  • 软引用
    • 内存不足时，才回收
  • 弱引用
    • 不管内存咋样，只要能回收了就回收了
  • 虚引用
    • 跟没有引用一样

Collections 集合操作类

主要的是对于一些常见的集合的操作，都是一些静态的处理方法，可以用到，如下

    java.util.Collections.addAll(l, "d", "qwe", "asd");
    java.util.Collections.reverse(l);
    java.util.Collections.replaceAll(l,"d","ddd");
    java.util.Collections.binarySearch(l,"qwe");
    java.util.Collections.sort(l);
    java.util.Collections.swap(l,2,3);

Stack类

是Vector的子类

    Stack<String> stack=new Stack<String>();
    stack.push("1");

    stack.add(3,"10"); //栈中间加入
    stack.peek();//得到栈顶不弹出
    stack.search("2");//搜索

Properities 属性类

是hashtable的子类

    Properties pro=new Properties();
    pro.setProperty("1","11");
    pro.setProperty("2","22");
    pro.setProperty("3","33");

    pro.storeToXML(new FileOutputStream("D:/a.xml"),"MYXML");

    Properties pro1=new Properties();

    pro1.loadFromXML(new FileInputStream("D:/a.xml"));
    pro1.list(System.out);
    System.out.println("1"+"  "+pro1.getProperty("1"));

可以保存到xml或者普通文件。实际上就是一个Map，可以使用Map的全部操作。通过list可以列出全部的属性。
store和load方法来与文件进行交互!!!!

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/Coder-Pig/p/6513338.html