对ArrayList集合、Iterator 迭代器、LinkedList 链表、HashMap散列表的基础认识

ArrayList集合

• 它是提供一种存储空间可变的存储模型，存储的数据容量可以发生改变
• 它的特点是：底层是数组实现的，长度可变
• 添加数据的时候不需要考虑索引，默认将数据添加到末尾

ArrayList类常用的方法

构造方法：public ArrayList()  创建一个空的集合对象

成员方法：

示例代码：

 
​   public static void main(String[] args) {
        //	add(E e) 将指定的元素追加到此列表的末尾。
        //	add(int index, E element) 在此列表中的指定位置插入指定的元素。
        ArrayList arrayList=new ArrayList<>();
        arrayList.add("1");
        arrayList.add("2");
        arrayList.add("3");
        arrayList.add(1,"4");
        System.out.println(arrayList);
        // addAll(Collection c) 按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾。(在这里使用）
        ArrayList arrayList1=new ArrayList<>();
        arrayList1.add("11");
        arrayList1.add("22");
        arrayList.addAll(arrayList1);
        System.out.println(Arrays.toString(new ArrayList[]{arrayList}));
    }
}
//运行结果：[1, 4, 2, 3]
//        [[1, 4, 2, 3, 11, 22]]

示例代码：

 public static void main(String[] args) {
        //clear() 从列表中删除所有元素。
        ArrayList arrayList=new ArrayList<>();
        arrayList.add("1");
        arrayList.add("2");
        arrayList.add("3");
        arrayList.add(1,"4");
        arrayList.clear();
        System.out.println(arrayList);
    }
//运行结果：没有输出
 public static void main(String[] args) {
        //contains(Object o) 如果此列表包含指定的元素，则返回 true 。
        ArrayList arrayList=new ArrayList<>();
        arrayList.add("1");
        arrayList.add("2");
        arrayList.add("3");
        arrayList.add(1,"4");
        System.out.println(arrayList.contains("3"));
    }
//运行结果：true
 
 public static void main8(String[] args) {
        //set(int index, E element)用指定的元素替换此列表中指定位置的元素。
        ArrayList arrayList = new ArrayList<>();
        arrayList.add("1");
        arrayList.add("2");
        arrayList.add("3");
        arrayList.add("4");
        arrayList.add("5");
        //remove(int index)删除该列表中指定位置的元素。
        //remove(Object o)从列表中删除指定元素的第一个出现（如果存在）。
        System.out.println(arrayList.set(2,"6));
        System.out.println(arrayList.remove(2));
        System.out.println(arrayList.remove("5"));
        System.out.println(arrayList);
    }
​
​
​

示例代码：

 public static void main(String[] args) {
        //iterator()以正确的顺序返回该列表中的元素的迭代器。
        // listIterator()返回列表中的列表迭代器（按适当的顺序）。
        //listIterator(int index)从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。
        //indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
        //lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
        ArrayList arrayList = new ArrayList<>();
        arrayList.add("1");
        arrayList.add("2");
        arrayList.add("3");
        arrayList.add("4");
        arrayList.add("5");
        System.out.println(arrayList.iterator());
        System.out.println(arrayList.listIterator());
        System.out.println(arrayList.listIterator(1));
        int i= arrayList.indexOf("4");
        int j= arrayList.lastIndexOf("3");
        System.out.println(i);
        System.out.println(j);
    }

示例代码：

​
 public static void main(String[] args) {
        //toArray()以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。
        //subList(int fromIndex, int toIndex)返回此列表中指定的 fromIndex （包括）和 toIndex之间的独占视图。
        //isEmpty()如果此列表不包含元素，则返回 true 。
        ArrayList arrayList = new ArrayList<>();
        arrayList.add("1");
        arrayList.add("2");
        arrayList.add("3");
        arrayList.add("4");
        arrayList.add("5");
        System.out.println(arrayList);
        Object[] objects=arrayList.toArray();
        System.out.println(objects);
        System.out.println(arrayList.toArray().length);
        System.out.println(arrayList.subList(0,3));
        System.out.println(arrayList.isEmpty());
    }
 
​

Iterator迭代器

• 它是Java集合框架的一种机制，是一种遍历集合（如列表、集合和映射等）的接口
• 它提供一种统一的方式来访问集合中的元素，而不需要了解底层集合的具体实现细节。
• 它是一种用于访问集合的方法，可用于迭代ArrayList和HashSet等集合
• Java Iterator迭代器是一种单向遍历机制，只能从前往后遍历集合中的元素，不能往回遍历
• 同时，在使用迭代器遍历集合是，不能直接修改集合中的元素，可能会导致ConcurrentMOdificationException异常，解决方法是：使用迭代器中的remove（）方法来删除当前元素，亦或者建立一个集合，记录需要删除的元素，之后统一删除，亦或者不使用Iterator迭代器遍历

Iterator迭代器常见使用方法

示例代码：

  public static void main(String[] args) {
        //迭代器
        ArrayList arrayList = new ArrayList<>();
        arrayList.add("1");
        arrayList.add("2");
        arrayList.add("3");
        arrayList.add("4");
        //返回迭代器
        Iterator iterator = arrayList.iterator() ;
        //使用hasNext()是否有下一个元素 next取出下一个元素
        //while循环
          while(iterator.hasNext()){
              System.out.print(iterator.next()+" ");
          }
    }

这里首先集合获取迭代器使用Iterator()方法，让迭代器iterator逐个返回集合中所有元素最简单的方法是是使用while循环

LinkedList链表

• 链表（Linked list) 是一种常见的基础数据结构，是一种线性表，但是并不按照线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址
• 链表分单向链表和双向链表，它是一种数据容器
• 它与ArrayList 相比，LinkedList更加擅长增加和删除的操作

LinkedList链表常见方法

示例代码

   public static void main(String[] args) {
        //添加
        //void addFirst(E e)在此列表的开头插入指定的元素
        //void addLast(E e)将指定的元素追加到此列表的末尾
        LinkedList list=new LinkedList<>();
        list.addFirst("十二路谭腿");
        list.addFirst("洪家铁线拳");
        list.addFirst("五郎八卦棍");
        list.addFirst("太极拳");
        list.addFirst("狮吼功");
        list.addFirst("蛤蟆功");
        list.addLast("如来神掌");
        System.out.println(list);
        System.out.println(list.size());
        //获取
        //E getFirst()返回此列表的第一个元素
        //E getLast()返回此列表中的最后一个元素。
        System.out.println(list.getFirst());
        System.out.println(list.getLast());
        System.out.println("-----------------");
        //弹出栈结构
        //E pollFirst()检索并删除此列表的第一个元素，如果此列表为空，则返回null；
        //E pollLast()检索并删除此列表的最后个元素，如果此列表为空，则返回null；
        System.out.println(list.pollFirst());
        System.out.println(list.pollFirst());
        System.out.println(list.pollLast());
        System.out.println(list);
        //push 压入
        //void push(E e)将元素推送到此列表所表示的堆栈中
        list.push("六指琴魔");
        System.out.println(list);
        //删除
        //E removeFirst() 从此列表中删除并返回第一个元素
        //E removeLast() 从此列表中删除并返回最后一个元素
        String  hh=list.removeFirst();
        System.out.println(hh);
        String ty=list.removeLast();
        System.out.println(ty);
        System.out.println(list);
    }

HashMap散列表

• 它存储的内容是键值对映射
• 它实现了Map接口，根据HashCode值存储数据，具有很快的访问速度，最多允许一条记录的键为null,不支持线程同步，其次HashMap是无序的，既不会记录插入的顺序

HashMap散列表的常见使用

常见方法

示例代码：

 public static void main(String[] args) {
        HashMap map=new HashMap<>();
        //public V put(K key, V value) : 把指定的键与指定的值添加到Map集合中。
        map.put("aa","打工豹");
        map.put("bb","野猪蓬蓬");
        map.put("cc","鬣狗");
        map.put("dd","三嫂");
        System.out.println(map);
        //public V remove(Object key) : 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
        System.out.println(map.remove("bb"));
        System.out.println(map);
        //public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
        System.out.println(map.get("aa"));
        System.out.println(map.get("cc"));
        //public Set keySet() : 获取Map集合中所有的键，存储到Set集合中。
        Set keys=map.keySet();
        System.out.println(keys);
        //public Set> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。
        //public boolean containKey(Object key) :判断该集合中是否有此键。
    }

map的遍历

示例代码：

 public static void main(String[] args) {
        //方式1:键找值方式
        System.out.println("---------方式1:键找值方式-----------");
        HashMap map=new HashMap<>();
        map.put("白小纯","候小妹");
        map.put("罗峰","许昕");
        map.put("许青","紫玄");
        map.put("楚梁","姜月白");
        Set hs=map.keySet();
        for(String key:hs){
            String value=map.get(key);
            System.out.println(key+"---"+value);
        }
        //方式2:键值对方式
        System.out.println("---------方式2:键值对方式------------");
       HashMap map1=new HashMap<>();
       map1.put("唐三","小舞");
       map1.put("戴沐白","朱竹清");
       map1.put("奥斯卡","宁荣荣");
       map1.put("马红俊","白沉香");
       Set> entries=map1.entrySet();
        for (Map.Entry entry:entries) {
            String key1= entry.getKey();
            String value1 =entry.getValue();
            System.out.println(key1+"---"+value1);
        }
        //方式3：lambda表达式方式
        System.out.println("---------方式3：lambda表达式方式------------");
        HashMap map2=new HashMap<>();
        map2.put("阿星","如来神掌");
        map2.put("苦力强","十二路谭腿");
        map2.put("早餐铺老板","五郎八卦棍");
        map2.put("洋衣店裁缝","洪家铁线拳");
        //利用匿名内部类来遍历集合
        map2.forEach(new BiConsumer() {
            @Override
            public void accept(String key2, String value2) {
                System.out.println(key2+"---"+value2);
            }
        });
        //利用lambda表达式来遍历集合
        map2.forEach((String key2,String value2)->{
            System.out.println(key2+"---"+value2);
        });
        //简化lambda表达式来遍历集合
        map2.forEach((key2,value2)-> System.out.println(key2+"---"+value2));
    }

总结

ArrayList集合、Iterator 迭代器、LinkedList 链表、HashMap散列表中所展示的方法只是较为常见的，如果遇到特殊情况，还需到它指定的API中查找对应的方法