image.png
数组是一种简单的线性序列，可以快速地访问数组元素，效率高。如果从效率和类型检查的角度讲，数组是最好的。但不灵活。容量需要事先定义好，不能随着需求的变化而扩容

Collection接口

image.png

  1. //容器常用方法
  2. public class CollectionInterface {
  3.     public static void main(String[] args) {
  4.         Collection<String> c = new ArrayList<>();
  6.         System.out.println(c.size());        //容器元素数量
  7.         System.out.println(c.isEmpty());    //判断容器是否为空
  9.         c.add("张三");                    //添加某个元素
  10.         c.add("李四");
  12.         System.out.println(c);
  13.         System.out.println(c.size());
  15.         Object[] objs = c.toArray();
  16.         System.out.println(objs);          //转换成object数组
  18.         c.remove("李四");            //移除某个元素 并不是删除了 存储的只是对象的地址
  19.         System.out.println(c);
  21.         c.clear();                    //清除容器内所有元素
  22.         System.out.println(c);
  23.     }
  24. }

list

List是有序、可重复的容器，允许多个null元素

  • 有序：List中每个元素都有索引标记。可以根据元素的索引标记(在List中的位置)访问元素，从而精确控制这些元素。

  • 可重复：List允许加入重复的元素。更确切地讲，List通常允许满足 e1.equals(e2) 的元素重复加入容器。

    1. 除了Collection接口中的方法，**List多了一些跟顺序(索引)有关的方法**：

List接口常用的实现类有3个：ArrayList（数组）、LinkedList（链表）和Vector（向量）
image.png

ArrayList

  1. public static void text03() {
  2.         List<String> list = new ArrayList<>();
  3.         list.add("a");
  4.         list.add("b");
  5.         list.add("c");
  6.         list.add("d");
  8.         System.out.println(list);
  10.         list.add(2,"e");            //添加指定位置的数据
  11.         System.out.println(list);
  13.         list.remove(2);                //删除指定位置的数据
  14.         System.out.println(list);
  16.         list.set(2,"e");            //修改指定位置的元素
  17.         System.out.println(list);
  19.         System.out.println(list.get(2));//返回指定索引位置的数据
  21.         list.add("e");
  22.         list.add("f");
  23.         list.add("g");
  25.         System.out.println(list);
  27.         System.out.println(list.indexOf("e"));    // 返回第一个索引匹配的位置
  28.         System.out.println(list.lastIndexOf("e"));    //返回最后个索引匹配的位置    
  30.     }

ArrayList底层是用数组实现的存储。 特点：查询效率高，增删效率低，线程不安全。一般使用它

注：List集合中的toString继承自AbstractCollection，它重写了Object里定义的toString方法；所以直接输出集合可以遍历

arraylist重写

  1. //arraylist重写
  2. public class RwArrayList2<E>{    //增加范型
  3.     //类的属性全部私有
  4.     private Object elementDate[];    //核心数组存储内容
  5.     private int size;    //数组元素长度
  6.     private static final int DEFALT_CAPACITY=10;    //静态变量
  8.     public RwArrayList2() {        //构造器方法
  9.         elementDate = new Object[DEFALT_CAPACITY];//默认数组长度
  10.     }
  11.     public RwArrayList2(int capacity) {            //构造器方法
  12.         elementDate = new Object[capacity];        //定义数组长度
  13.     }
  15.     //添加方法
  16.     public void add(E obj) {
  17.         //扩容操作
  18.         if (size == elementDate.length) {
  19.             //扩大数组长度的一半
  20.             Object[] newarray = new Object[elementDate.length+(elementDate.length>>1)];
  21.             //拷贝原数组
  22.             System.arraycopy(elementDate, 0, newarray, 0, elementDate.length);
  23.             elementDate = newarray; //把老数组指向新数组地址 
  24.         }
  25.         elementDate[size++] = obj;
  26.     }
  29.     public E get(int index) {
  30.         check(index);    //检查索引
  31.         return (E)elementDate[index];
  32.     }
  34.     public void set(int index,E s2) {
  35.         check(index);
  36.         elementDate[index] = s2;
  38.     }
  40.     public void check(int index) {
  41.         //判断索引合法性
  42.         if(index < 0 || index > elementDate.length) {
  43.             throw new RuntimeException("索引不合法: "+index);
  44.         }
  46.     }
  48.     public void remove(E element) {
  49.         //将element与所有元素比较 获得第一个返回true的 返回
  50.         for (int i = 0; i < size; i++) {
  51.             if(element.equals(get(i))){
  52.                 remove(i);
  53.             }
  54.         }
  56.     }
  57.     //删除操作 
  58.     public void remove(int index) {
  59.         //核心是数组拷贝
  60.         int num = elementDate.length-index-1;
  61.         if(num >0) {
  62.             System.arraycopy(elementDate, index+1, elementDate, index, num);
  63.         }
  64.             elementDate[size-1] = null;
  65.             size--;
  66.     }
  69.     //重写tostring方法 打印数组内数据
  70.     @Override
  71.     public String toString() {
  72.         StringBuilder b1 = new StringBuilder();
  74.         b1.append("[");
  75.         for (int i = 0; i < size; i++) {
  76.             b1.append(elementDate[i]+" ");
  77.         }
  78.         b1.setCharAt(b1.length()-1, ']'); //改变最后一个字符
  79.         return b1.toString();
  80.     }
  82.     public static void main(String[] args) {
  83.         RwArrayList2 s1 = new RwArrayList2();    //数组对象
  85.         for (int i = 0; i < 20; i++) {
  86.             s1.add("h"+i);
  87.         }
  88.         s1.add("a");
  89.          s1.add("b");
  91.          s1.set(10, "aa");
  92.          System.out.println(s1);
  93.          System.out.println(s1.get(10));
  94.          s1.remove("aa");
  95.          System.out.println(s1);
  96.     }
  97. }

LinkedList

LinkedList底层用双向链表实现的存储。特点：查询效率低，增删效率高，线程不安全。它的每个数据节点中都有两个指针，分别指向前一个节点和后一个节点
image.png

重写Linkedlist

  1. //重写Linkedlist
  2. public class RwLinkedList <E>{
  4.     private Node first;
  5.     private Node last; 
  6.     private int size;
  9.     public void add(E element) {
  10.         Node node =new Node(element);
  11.         if (first == null) {
  12.             first = node;
  13.             last = node;
  14.         }else {
  15.             node.previous = last;
  16.             node.next = null;
  18.             last.next = node;
  19.             last = node;
  20.         }
  21.         size++;
  22.     }
  25.     public E get(int index) {
  26.         if (index<0 || index>size-1) {
  27.             throw new RuntimeException("索引不合法:"+index);
  28.         }
  29.         Node temp = getNode(index);
  31.         return temp != null?(E)temp.element:null;
  32.     }
  34.     //封装获取节点
  35.     public Node getNode(int index) {
  36.         Node temp = null;
  37.         if (index<=(size>>1)) {        //size右移一位相当于除以2
  38.             temp = first;
  39.             for (int i = 0; i < index; i++) {
  40.                 temp = temp.next;
  41.             }
  42.         }else {
  43.             temp = last;
  44.             for (int i = size-1; i > index; i--) {
  45.                 temp = temp.previous;
  46.             }
  47.         }
  48.         return temp;
  49.     }
  52.     public void remove(int index) {
  53.         if (index<0 || index>size-1) {
  54.             throw new RuntimeException("索引不合法:"+index);
  55.         }
  56.         Node temp = getNode(index);
  57.         if(temp!=null) {
  58.             Node upNode = temp.previous; 
  59.             Node dowNode = temp.next;
  61.             if(upNode!=null) {
  62.                 upNode.next = dowNode;
  63.             }
  64.             if(dowNode != null) {
  65.                 dowNode.previous = upNode;
  66.             }
  67.             //删除第一个元素时
  68.             if(index == 0) {
  69.                 first = dowNode;
  70.             }
  71.             //删除最后一个元素时
  72.             if(index == size-1) {
  73.                 last = upNode;
  74.             }
  76.             size--;
  77.         }
  78.     }
  81.     public void insert(int index,E element) {
  83.         Node newnNode = new Node(element);
  84.         Node tempNode = getNode(index);
  86.         if (tempNode!=null) {
  87.             Node upNode = tempNode.previous;
  88.             if (index == 0) {        //插入首元素
  89.                 first = newnNode;
  90.                 newnNode.next = tempNode;
  91.                 tempNode.previous = newnNode;
  92.             }else if (index == size-1) {    //插入尾元素
  93.                 last = newnNode;
  94.                 tempNode.next = newnNode;
  95.                 newnNode.previous = tempNode;
  96.             }else {
  97.                 upNode.next = newnNode;
  98.                 newnNode.previous = upNode;
  100.                 newnNode.next = tempNode;
  101.                 tempNode.previous = newnNode;
  102.             }
  103.         }
  104.     }
  107.     //规范输出格式
  108.     @Override
  109.     public String toString() {
  110.         StringBuilder s1 = new StringBuilder();
  111.         s1.append("[");
  112.         Node temp = first;
  113.         while (temp != null) {
  114.             s1.append(temp.element+" ");
  115.             temp = temp.next;
  116.         }
  117.         s1.setCharAt(s1.length()-1, ']');
  118.         return s1.toString();
  119.     }
  121.     public static void main(String[] args) {
  122.         RwLinkedList<String> list = new RwLinkedList<>();
  123.         list.add("a");
  124.         list.add("b");
  125.         list.add("c");
  126.         list.add("e");
  127.         list.add("f");
  128.         list.add("g");
  130.         list.remove(5);
  131.         list.insert(1, "aa");
  132.         System.out.println(list);
  133.         System.out.println(list.get(3));    
  134.     }                
  135. }

Vector

Vector与ArrayList一样，也是通过数组实现的，但它支持线程的同步，即某一时刻只有一个线程能够写Vector.但实现同步需要很高的花费。因此，访问它比访问ArrayList慢

set

Set容器特点：无序、不可重复，只允许一个null元素。无序指Set中的元素没有索引（没有get方法），只能遍历查找;不允许加入重复的元素

  1. //基本用法
  2. public class TestHashSet {
  3.     public static void main(String[] args) {
  4.         Set<String> s1 = new HashSet<String>();
  6.         s1.add("a");
  7.         s1.add("b");
  8.         s1.add("a");
  9.         System.out.println(s1);
  10.         s1.remove("a");
  11.         System.out.println(s1);
  13.         Set<String> s2 = new HashSet<String>();
  14.         s2.add("A");
  15.         s2.addAll(s1);
  16.         System.out.println(s2);
  18.     }
  19. }

TreeSet

TreeSet底层实际是用TreeMap实现的，通过key来存储Set的元素。TreeSet内部需要对存储的元素进行排序，因此，我们对应的类需要实现Comparable接口。

  1. public class TreeSet {
  2.     public static void main(String[] args) {
  3.         Set<Integer> s1 = new java.util.TreeSet<Integer>();
  5.         s1.add(3);
  6.         s1.add(2);
  7.         s1.add(1);
  9.         //按元素递增模式输出
  10.         for(Integer i:s1) {
  11.             System.out.println(i);
  13.         Set<employee2> s2 = new java.util.TreeSet<>();
  14.         s2.add(new employee2(1001, "A", 10000));
  15.         s2.add(new employee2(1003, "B", 20000));
  16.         s2.add(new employee2(1004, "C", 30000));
  18.         for(employee2 i:s2) {
  19.             System.out.println(i);
  20.         }        
  21.     }
  22. }

Map接口

Map就是用来存储“键(key)-值(value) 对”的。 Map类中存储的 “键值对” 通过键来标识，所以“键对象”不能重复。这就是一种成对存储的关系。
image.png

Map 接口的实现类有HashMap、TreeMap、HashTable、Properties等。

常用方法

  1. //常用方法
  2. public static void main(String[] args) {
  3.         Map<Integer, String> m1 = new HashMap<>();
  5.         m1.put(1, "a");
  6.         m1.put(2, "b");
  7.         m1.put(3, "c");
  9.         System.out.println(m1.get(1));
  10.         System.out.println(m1.size());
  11.         System.out.println(m1.containsValue("a"));
  13.         Map<Integer, String> m2 = new HashMap<>();
  14.         m2.put(4, "A");        //注意键不能重复
  15.         m2.put(5, "B");
  16.         m2.put(6, "C");
  18.         m1.putAll(m2);
  19.         System.out.println(m1);
  20.     }

HashMap采用哈希算法实现，是Map接口最常用的实现类。 由于底层采用了哈希表存储数据，要求键不能重复，如果发生重复，新的键值对会替换旧的键值对。 HashMap在查找、删除、修改方面都有非常高的效率。

HashTable类和HashMap用法几乎一样，底层实现几乎一样，只不过HashTable的方法添加了synchronized关键字确保线程同步检查，效率较低

HashMap与HashTable的区别

  • HashMap
    • 线程不安全，效率高
    • 允许key或value为null
    • 初始容量是16，扩容是2n
    • 在首次调用put方法时放入元素时才会初始化数组
  • HashTable
    • 线程安全，效率低
    • 不允许key或value为null
    • 初始容量是11，扩容2n+1
    • 构造函数里面就初始化数组


TreeMap

TreeMap和HashMap实现了同样的接口Map，因此，用法对于调用者来说没有区别。HashMap效率高于TreeMap;在需要排序的Map时才选用TreeMap。

  1. public class TestTreeMap {
  2.     public static void main(String[] args) {
  3.         Map<Integer, String> map1  = new TreeMap<>();
  4.         map1.put(10, "a");
  5.         map1.put(20, "b");
  6.         map1.put(30, "c");
  8.         //按照key递增的方式排序
  9.         for(Integer key:map1.keySet()) {
  10.             System.out.println(key+"--"+map1.get(key));
  11.         }
  13.         Map<employee2, String> treeMap = new TreeMap<>();
  14.         treeMap.put(new employee2(1001, "张三",6000),"。。。");
  15.         treeMap.put(new employee2(1002, "张",3000),"。。");
  16.         treeMap.put(new employee2(1003, "张4",5000),"。");
  18.         for(employee2 key:treeMap.keySet()) {
  19.             System.out.println(key+"--"+treeMap.get(key));
  20.         }
  22.     }
  24. }
  26. //Comparable接口可按照自定义变量进行递增
  27. class employee2 implements Comparable<employee2>{
  28.     int id;
  29.     String name;
  30.     int salary;
  32.     public employee2(int id, String name, int salary) {
  33.         super();
  34.         this.id = id;
  35.         this.name = name;
  36.         this.salary = salary;
  37.     }
  39.     @Override
  40.     public String toString() {
  41.         return "id:"+id+" name:"+name+" salary:"+salary;
  42.     }
  44.     //按照工资排序
  45.     @Override
  46.     public int compareTo(employee2 o) {//负数：小于  0：等于 正数：大于
  47.         if(this.salary > o.salary) {
  48.             return 1;
  49.         }else if (this.salary < o.salary) {
  50.             return -1;
  51.         }else {        //工资相等
  52.             if(this.id > o.id) {
  53.                 return 1;
  54.             }else if (this.id <o.id) {
  55.                 return -1;
  56.             }else {
  57.                 return 0;
  58.             }
  59.         }
  60.     }
  62. }

接口使用的选择

1.png

Iterator迭代器遍历容器

遍历容器元素(List/Set/Map)
hashnext（）：如果任有元素可以迭代，则返回true

  1. public class TestIterator {
  2.     public static void main(String[] args) {
  3.         TestIterator();
  4.         TestIterator2();
  5.         TestIterator3();
  6.         TestIterator4();
  7.     }
  8.     public static void TestIterator() {
  9.         List<String> list = new ArrayList<>();
  11.         list.add("a");
  12.         list.add("b");
  13.         list.add("c");
  15.         //用迭代器遍历list
  16.         for(Iterator<String> iterator= list.iterator(); iterator.hasNext();) {
  17.             String temp = iterator.next();
  18.             System.out.println(temp);
  19.         }
  20.         System.out.println("******");
  21.     }
  23.     public static void TestIterator2() {
  24.         Set<String> set1 = new HashSet<>();
  26.         set1.add("a");
  27.         set1.add("b");
  28.         set1.add("c");
  30.         //用迭代器遍历set
  31.         for(Iterator<String> iterator= set1.iterator(); iterator.hasNext();) {
  32.             String temp = iterator.next();
  33.             System.out.println(temp);
  34.         }
  35.         System.out.println("******");
  36.     }
  38.     public static void TestIterator3() {
  39.         Map<Integer, String> map1 = new HashMap<>();
  41.         map1.put(1, "a");
  42.         map1.put(2, "b");
  43.         map1.put(3, "c");
  45.         //获取hashmap的位桶数组
  46.         Set<Entry<Integer, String>> se = map1.entrySet();
  48.         //用迭代器遍历map
  49.         //法一：取出map内的每一个结点，再遍历每一个节点的key
  50.         for(Iterator<Entry<Integer, String>> iterator= se.iterator(); iterator.hasNext();) {
  51.             Entry<Integer, String> temp = iterator.next();
  53.             System.out.println(temp.getKey()+"--"+temp.getValue());
  54.         }
  55.         System.out.println("******");
  56.     }
  59.     public static void TestIterator4() {
  60.         Map<Integer, String> map1 = new HashMap<>();
  62.         map1.put(1, "a");
  63.         map1.put(2, "b");
  64.         map1.put(3, "c");
  66.         //通过map1获取key和value的集合 再去遍历它们
  67.         Set<Integer > keySet = map1.keySet();
  69.         //用迭代器遍历map 法2：直接遍历map节点的集合
  70.         for(Iterator<Integer> iter = keySet.iterator(); iter.hasNext();) {
  71.             Integer key = iter.next();
  72.             System.out.println(key+"--"+map1.get(key));
  73.         }
  74.         System.out.println("******");
  76.         //jdk8新特性 函数式编程
  77.         map.forEach((key,value)-> System.out.println(key+"="+value));
  79.     }
  80. }

Collections工具类

类 java.util.Collections 提供了对Set、List、Map进行排序、填充、查找元素的辅助方法。

  1. public class TestCollections {
  2.     public static void main(String[] args) {
  3.         List<String> list = new ArrayList<String>();
  4.         for(int i=0; i<10; i++) {
  5.             list.add("a"+i);
  6.         }
  7.         System.out.println(list);
  9.         //逆序排序
  10.         Collections.reverse(list);
  11.         System.out.println(list);
  13.         //随机排列数组中的元素
  14.         Collections.shuffle(list);
  15.         System.out.println(list);
  17.         //正常排序
  18.         Collections.sort(list);
  19.         System.out.println(list);
  21.         //二分查找
  22.         System.out.println(Collections.binarySearch(list, "a1"));    
  24.         //用一个特定的对象覆盖重写整个容器
  25.         Collections.fill(list, "b");
  26.         System.out.println(list);
  27.     }
  28. }