list数组的迭代器remove list的迭代器类型

相对于数组（Array）来说，集合长度可变，更加适合现代开发要求。可以存储任何类型的数据，也可以结合泛型来存储具体的类对象，集合类通常存在于java.util包中

集合分为两大体系

• Collection体系
• Map体系
  Collection和Map分别是两个体系的顶层接口

集合作为参数

集合作为参数的时候是引用传递

Collection体系

主要有三个子接口

• List（列表）
• Set（集）
• Queue（队列）

List和Set中的元素有序可重复，Set中的元素不可重复。

List实现类

• ArrayList
• LinkedList

Set实现类

• HashSet(无序)
• TreeSet(有序)

Queue实现类

• 数组
• 链表

List

集合是有序的，可以对每个元素的插入位置进行精确的控制，可以通过索引来访问元素，遍历数组。
实现类中ArrayList底层通过数组来实现，通过元素增加来动态扩容。LinkList底层通过链表来实现，随着元素的不断增加不断向链表的后端增加节点。

ArrayList

• 实现了List，得到了List集合框架的基础功能
• 实现RandomAccess,获得了快速随机访问元素的功能。RandomAcess是一个标记接口，没有任何方法
• 实现了Cloneable，得到了clone()方法，可以实现克隆功能
• 实现了Serializable，可以被序列化，通过序列化去传输，典型的应用就是Hessian协议

LinkedList

• 实现了List，得到了List集合框架的基础功能
• 实现了Cloneable，得到了clone()方法，可以实现克隆功能
• 实现了Serializable，可以被序列化，通过序列化去传输，典型的应用就是Hessian协议
• 实现了Deque，Deque是一个双向队列，既可以先入先出，又可以先入后出。及可以头部添加元素，也可以尾部添加元素

List常用方法

public static void main(String[] args) {
//        初始化ArrayList
        List<String> list= new ArrayList<>();
        System.out.println("List内容："+list.toString());
        System.out.println("List长度:"+list.size());
//        添加内容
        list.add("good");
        list.add("123");
        list.add(2,"hello");//不可以向三号位置添加，会报错溢出
        System.out.println("List内容："+list.toString());
        System.out.println("List长度:"+list.size());
//        修改内容
        list.set(1,"xiugai");
        System.out.println("List内容："+list.toString());
        System.out.println("List长度:"+list.size());
//        获取List内容
        String a=list.get(1);
        System.out.println("a:"+a);
//        迭代器遍历集合（ArrayList遍历器为Iterator，LinkedList为ListItr
        Iterator<String> iterator =list.iterator();
        while (iterator.hasNext()){
            String next=iterator.next();
            System.out.println("next:"+next);
//            for循环迭代集合：
            for(String str:list){
                System.out.println("str:"+str);
//                判断功能：
         boolean isEmpty = list.isEmpty();
         boolean isContain = list.contains("my");

//                把集合转换成数组：
          String[] strArray =list.toArray(new String[]{});
            }
        }
    }

结果：

List内容：[]
List长度:0
List内容：[good, 123, hello]
List长度:3
List内容：[good, xiugai, hello]
List长度:3
a:xiugai
next:good
str:good
str:xiugai
str:hello
next:xiugai
str:good
str:xiugai
str:hello
next:hello
str:good
str:xiugai
str:hello

List排序

List<String> b= new ArrayList<String>();
        Collections.addAll(b,"z x c v b".split(" "));
        System.out.println(b);
        Collections.sort(b);
        System.out.println(b);
        Collections.sort(b, new Comparator<String>() {
            @Override
            //return<0交换,>=0不交换
            public int compare(String o1, String o2) {
                if (o1.compareTo(o2) > 0) {
                    return -1;
                }else {
                    return 1;
                }

            }
        });
        System.out.println(b);

输出结果

[z, x, c, v, b]
[b, c, v, x, z]
[z, x, v, c, b]

Map体系

以键值对(key,value)形式存在，Key必须唯一。

可以分为三类

• 通用Map，用于应用程序中管理映射，通常在java.util程序包中实现
• 专用Map，不需要亲自创建，可以通过其他类对其进行访问
• 帮助我们实现自己Map类的抽象类

类型区别

HashMap
import java.util.Map来使用
根据键(key)的HashCode值存储数据，根据键获取它的值，有很快的访问速度。
只允许一个记录的键为Null，多条会覆盖，允许多条记录的值为Null
HashMap的key和value必须使用包装类或者实体类

TreeMap
把保存的记录根据键(key)排序，默认是升序，可以改变排序方式。不允许key为Null

Hashtable
key和value都不可以为Null.允许线程同步，即任意时刻只有一个线程写，所以写入比较慢

LinkedHashMap
保存插入顺序，先得到的记录是先插入的。循序kye和value为Null

//初始化
Map<String,String> map =new HashMap<String,String>();
//插入元素
map.put("key1","value1");
//获取元素
map.get("key1")
//去除元素
map.remove("key1")
//清空map
map.clear();

hashmap.put问题

Map<String,Object> map = new HashMap<String, Object>();
        map.put("first","2");
        System.out.println(map);
        map.put("first","1");
        System.out.println(map);
        map.put("first","3");
        System.out.println(map);
        //有同名的输出最后一个
        System.out.println(map.get("first"));

输出结果

{first=2}
{first=1}
{first=3}
3

map.entry<k,v>

学习自

//非entryset方法
Set keys = map.keySet( );
if(keys != null) {
Iterator iterator = keys.iterator( );
while(iterator.hasNext( )) {
Object key = iterator.next( );
Object value = map.get(key);

//map.entrySet返回一个Set,Set的每一项为一个数据结构，包含key和value
Set entries = map.entrySet( );
if(entries != null) {
Iterator iterator = entries.iterator( );
while(iterator.hasNext( )) {
Map.Entry entry =iterator.next( );
Object key = entry.getKey( );
Object value = entry.getValue();

for (Map.Entry<Object, Object> entry : map.entrySet()) {
     int value = entry.getValue();
     String key = entry.getKey();     
 }

Iterator 迭代器

学习自

迭代器是一种设计模式，用来遍历数据结构中的全部内容
(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：iterator()方法是java.lang.Iterable接口,被Collection继承。

(2) 使用next()获得序列中的下一个元素。

(3) 使用hasNext()检查序列中是否还有元素。

(4) 使用remove()将迭代器新返回的元素删除。