java中集合API

一、简述

• Collection：
  最基础的集合接口，所有具体集合类都直接或简介实现了这个接口
• Map：
  以键值对方式存储
• Iterator：
  迭代器，常用语遍历集合中的元素

二、Collection

常见方法：

• add(E e): 将元素添加到集合中，如果集合不支持添加操作则抛出UnsupportedOperationException异常。
• clear()：清空操作
• contains(Object o): 是否包含指定元素，有则返回true/无 false
• isEmpty(): 是否为空
• iterator():返回一个迭代器，用于遍历元素
• remove(Object o):从集合中移除指定元素
• size(): 返回集合元素个数
• toArray():将集合中元素转换为数组

（1）.List

• 有序性：List保持元素的插入顺序。
• 可重复性：List允许同一个元素出现多次。
• 索引访问：提供了基于索引(可以理解为下标)的方法来访问和修改列表中的元素。

1.ArrayList：

数组列表，既有数组的特性又有列表的特性，能够动态调整列表大小，访问元素非常快，单插入和删除操作较慢，尤其是列表中间进行这些操作，原因是需要移动元素

import java.util.ArrayList;

public class ArrayListDemo01 {
    public static void main(String[] args) {
		ArrayList<String> 	zqstar = new ArrayList<>();

		//添加
		zqstar.add("内马尔");
		zqstar.add("德布劳内");
		zqstar.add("萨拉赫");

		if(zqstar.contains("内马尔")){
			System.out.println("内马尔 is in the list.");
		}

		// 获取并打印指定索引处的元素
        String secondZqStar = zqstar.get(1);
        System.out.println("Second zqstar is: " + secondZqStar);
		// 替换指定位置的元素
        zqstar.set(2, "博格巴");
        System.out.println("List after replacement: " + zqstar );
		// 删除指定位置的元素
        zqstar.remove(1);
        System.out.println("List after deletion: " + zqstar);
        // 清空列表
        zqstar.clear();
        System.out.println("List is empty now? " + zqstar.isEmpty());
		
	}
}

手搓简易版ArrayList

package com.example.test.api;

import java.util.Arrays;

public class MyArrayList {
    /*存储数据*/
    private Object[] data;
    private int size;

    /*用于记录有效元素的个数*/
    public MyArrayList() {
        this.data = new Object[16];
    }

    public MyArrayList(int capacity) {
        this.data = new Object[capacity];
    }

    //向size位置添加新的元素
    public void add(Object element) {
        //判断是否需要扩容
        if (size == data.length) {
            data = Arrays.copyOf(data, 2 * data.length);
        }
        //存储
        data[size] = element;
        size++;
    }

    //删除
    public boolean remove(Object obj) {
        if (size == 0) return false;
        //遍历找元素
        boolean flag = false;
        for (int i = 0; i < size; i++) {
            if (data[i].equals(obj)) {
                //从i+1开始，将后面的元素往前移动一位(删除下标为i的元素)
                System.arraycopy(data, i + 1, data, i, size - i - 1);
                flag = true;
                break;
            }
        }
        if (!flag) return false;
        data[--size] = null;
        size--;
        return true;
    }

    public int size() {
        return size;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("[");
        for (int i = 0; i < size; i++) {
            sb.append(data[i]).append(",");
        }
        sb.deleteCharAt(sb.lastIndexOf(","));
        sb.append("]");
        return sb.toString();
    }
}

2. LinkedList

实现了List接口，底层是双向链表

• 优点：插入或删除元素的性能较好，适合频繁进行首尾插入和删除操作的场景。
• 缺点：读取元素时需要从头或尾开始遍历链表，性能较差，不适合需要随机访问元素的场景。

package api;

import java.util.ArrayList;
import java.util.LinkedList;

public class LinkedListTests {
    public static void main(String[] args) {
        LinkedList<Integer> list=new LinkedList<>();
        list.add(100);
        list.add(200);
        //在头部添加
        list.addFirst(500);
        //在尾部添加
        list.addLast(600);
        System.out.println(list);
        //移除头部元素,返回值为被移除的元素
        Integer first = list.removeFirst();
        //移除尾部元素,返回值为被移除的元素
        Integer last = list.removeLast();
        System.out.println("first="+first+";last="+last);
        System.out.println(list);
        System.out.println(list.contains(Integer.valueOf(200)));
    }
}

（2） Set

HashSet
实现了Set接口，不允许元素重复，无序
添加、查询和删除等操作都具有较高的效率

package api;

import java.util.Collection;
import java.util.HashSet;
import java.util.Set;

public class HashSetTests {
    public static void main(String[] args) {
        Collection c1=new HashSet();
        c1.add("one");
        c1.add("one");//不会添加重复元素
        c1.add("two");
        System.out.println(c1.size());
        System.out.println(c1);
        Set<Integer> c2=new HashSet<>();
        c2.add(100);
        c2.add(100);
        c2.add(200);
        c2.add(200);
        System.out.println(c2);
        c2.remove(200);
        System.out.println(c2);
    }
}

三、Map

键值对方式存储

1.HashMap

底层数据结构是散列桶（数组、链表、红黑树），数组用于存储桶，桶里装着一个链表或红黑树。
java8之后，链表为了解决哈希冲突，链表长度大于8之后会转换为红黑树，红黑树的节点小于6时会转换为链表。取8为临界值是因为可以更好的平衡时间和空间复杂度。
**特点：**无序，键和值都允许为null，非同步，不是线程安全的
put（）方法插入键值对
get（） 方法获取指定键对应的值
remove（） 删除指定键的值
遍历：

//键值对的方式
 for (Map.Entry<String, Integer> entry : hashMap.entrySet()) {
     System.out.println("键: " + entry.getKey() + ", 值: " + entry.getValue());
        }

//键找值的方式
//所有key取出来存到一个Set集合中
Set<String> keySet = map.keySet();

//迭代器遍历
Iterator<Map.Entry<String,Integer>> iterator = entrySet.iterator();
While (iterator.hasNext()) {
	Map.Entry<String,Integer> entry = iterator.next();
	String key = entry.getKey();
	Integer value = entry.getValue();
	System.out.println(key+","+value);
}

2. TreeMap

底层是红黑树
**特点：**数据有序，比HashMap多实现了NavigableMap接口，非同步

三、Iterator接口

常见方法
hasNext（） 判断是否还有下一个元素，boolean类型
next（）获取当前指针指向的元素，调用移动指针

Collection c = new ArrayList();
        c.add(100);
        c.add(200);
        c.add("Hello kugou");
        Iterator iterator = c.iterator();
        while (iterator.hasNext()){
            Object obj = iterator.next();;
            System.out.println(obj);
        }

Collections工具类

1.对集合元素进行排序

List<Integer> List = Arrays.asList(array);数组转换为List
Collections.sort(list);
System.out.println(list);

//实现Comparable接口
package api;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

class Student implements Comparable<Student>{
    private String name;
    private int score;
    public Student(String name,int score){
        this.name=name;
        this.score=score;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }

    /**
     * 当我们使用Collections的sort方法进行排序时,
     * 底层会调用待排序对象内部的compareTo方法
     * @param o the object to be compared.
     * @return 0表示等于,负数小于,正数表示大于
     */
    @Override
    public int compareTo(Student o) {
        return this.score-o.score;
    }
}
/**
 * 通过Collections对多个学生按成绩进行排序.
 */
public class CollectionSortDemo02 {
    public static void main(String[] args) {
        List<Student> list=new ArrayList<>();
        list.add(new Student("Tony",91));
        list.add(new Student("Mike",90));
        list.add(new Student("Jack",97));
        Collections.sort(list);
        System.out.println(list);
    }
}

)

2.基于Comparator，自定义方法(内部类)进行排序

package api;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**电影对象类型*/
class Film{
    private String name;
    private int score;
    public Film(String name,int score){
        this.name=name;
        this.score=score;
    }

    public int getScore() {
        return score;
    }

    @Override
    public String toString() {
        return "Film{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}
public class CollectionSortDemo03 {
    public static void main(String[] args) {
        Film f1=new Film("马尔扎哈",90);
        Film f2=new Film("阿斯特拉",87);
        Film f3=new Film("魔童哪吒",93);
        List<Film> list=new ArrayList<Film>();
        list.add(f1);
        list.add(f2);
        list.add(f3);
        Collections.sort(list,new Comparator<Film>(){
        @Override
        public int compare(Film o1,Film o2){
        return o1.getScore()-o2.getScore();
        }
     });
     System.out.println(list);
  }
}