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

ArrayList集合

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

ArrayList类常用的方法

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

成员方法：

add(E e)	将指定的元素添加到此列表的末尾
add(int index,E element)	在此列表中的指定位置插入指定的元素
addAll(Collection<? extends E> c)	按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾

示例代码：

​   public static void main(String[] args) {
        //	add(E e) 将指定的元素追加到此列表的末尾。
        //	add(int index, E element) 在此列表中的指定位置插入指定的元素。
        ArrayList<String> arrayList=new ArrayList<>();
        arrayList.add("1");
        arrayList.add("2");
        arrayList.add("3");
        arrayList.add(1,"4");
        System.out.println(arrayList);
        // addAll(Collection<? extends E> c) 按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾。(在这里使用）
        ArrayList<String> 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]]

clear()	从列表中删除所有元素
contains(Obiect o )	如果此列表中包含指定的元素，则返回true
set(int index,E element)	用指定的元素替换此列表中指定的元素
remove(int index)	删除该列表中指定位置的元素
remove(Object o)	从列表中删除元素的第一个出现（如果存在）

示例代码：

 public static void main(String[] args) {
        //clear() 从列表中删除所有元素。
        ArrayList<String> 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<String> 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<String> 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);
    }
​

​

​

iterator()	以正确的顺序返回该列表中的元素的迭代器
listIterator	返回列表中的列表迭代器
list Iterator(int index)	从列表中的指定位置开始，返回列表中的元素（按正确顺序的列表迭代器
indexOf(Object o)	返回此列表中指定元素的第一次出现的索引，如果此列表中不包含元素，则返回-1
lastIndexOf（Object o)	返回此列表中指定元素的最后依次出现的索引，如果此列表不包含元素，则返回-1

示例代码：

 public static void main(String[] args) {
        //iterator()以正确的顺序返回该列表中的元素的迭代器。
        // listIterator()返回列表中的列表迭代器（按适当的顺序）。
        //listIterator(int index)从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。
        //indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
        //lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
        ArrayList<String> 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);
    }

toArray()	以正确的顺序（从第一个到最后一个元素—）返回一个包含此列表中所有元素的数组
subList(int fromIndex, int toIndex)	返回此列表中指定的fromIndex(包括）和toIndex之间的独占视图
isEmpty()	如果此列表中不包含元素，则返回true

示例代码：

​
 public static void main(String[] args) {
        //toArray()以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。
        //subList(int fromIndex, int toIndex)返回此列表中指定的 fromIndex （包括）和 toIndex之间的独占视图。
        //isEmpty()如果此列表不包含元素，则返回 true 。
        ArrayList<String> 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迭代器常见使用方法

next（）	用来返回迭代的下一个元素，并把指针向后移动一位
hasNext()	用来判断集合中是否有下一个元素可以迭代。如果返回true,说明可以迭代
remove()	从集合中删除最后访问的元素

示例代码：

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

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

LinkedList链表

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

LinkedList链表常见方法

（添加）void addFirst(E e)	在此列表的开头插入指定的元素
（添加）void addLast(E e)	将指定元素追加到此列表的末尾
（获取）getFirst()	返回此列表的第一个元素
（获取）getLast(）	返回此列表中的最后一个元素
（弹出栈结构）pollFirst()	检索并删除此列表的第一个元素，如果此列表为空，则返回null
（弹出栈结构）pollLast()	检索并删除此列表的最后一个元素,如果此列表为空，则返回null
（压入）void push(E e)	将元素推送到此列表所表示的堆栈中
（删除）removeFirst()	从此列表中删除并返回第一个元素
（删除）removeLast()	从此列表中删除并返回最后一个元素

示例代码

   public static void main(String[] args) {
        //添加
        //void addFirst(E e)在此列表的开头插入指定的元素
        //void addLast(E e)将指定的元素追加到此列表的末尾
        LinkedList<String> 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 V put (K key,V value)	把指定的键与指定的值添加到map集合中
public  V remove (Object key)	把指定的键所对应的键值对元素在map集合中删除，返回被删除元素的值
public  V get (Object key)	根据指定的键，在Map集合中获取对应的值
public Set<K> keySet()	获取Map集合中所有的键，存储到Set集合中
public Set<Map.Entry<K,V>> enteySet()	获取到Map集合中所有的键值对对象的集合
public  boolean containKey(Object key)	判断该集合中是否有此键

示例代码：

 public static void main(String[] args) {
        HashMap<String,String> 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<K> keySet() : 获取Map集合中所有的键，存储到Set集合中。
        Set<String> keys=map.keySet();
        System.out.println(keys);
        //public Set<Map.Entry<K,V>> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。
        //public boolean containKey(Object key) :判断该集合中是否有此键。
    }

map的遍历

示例代码：

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