java基础-集合

集合

集合：存储多个数据的，长度不固定
数组：长度是固定的

---

Collection

Collection接口：无序，不唯一

list:

有序：添加的顺序
不唯一：可以添加重复的元素

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

/*
            List       有序：添加的顺序
                       不唯一：可以添加重复的元素
                  ArrayList
                        数组
                  LinkedList
                        链表
         */
         /*
            泛型：规定输入数据的类型
            Collection<引用数据类型>
        */
public class ListTest {
    public static void main(String[] args) {
        //多态
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("张三");
        list.add("张三");
        System.out.println(list);//[张三, 张三, 张三]
        list.add(1, "李四");
        System.out.println(list);//[张三, 李四, 张三, 张三]

        List<String> list1 = new ArrayList<>();
        list1.add("你好");
        list1.add("你好");
        list.addAll(list1);
        System.out.println(list);//[张三, 李四, 张三, 张三, 你好, 你好]
        //添加到指定位置
        list.addAll(0, list1);
        System.out.println(list);//[你好, 你好, 张三, 李四, 张三, 张三, 你好, 你好]

        //通过下标获取指定元素
        System.out.println(list.get(2));//张三
        //是否包含指定元素
        System.out.println(list.contains("李四"));//true

        //删除第一次出现的指定元素
        list.remove("你好");
        System.out.println(list);//[你好, 张三, 李四, 张三, 张三, 你好, 你好]
        //删除指定下标对应的元素
        list.remove(6);
        System.out.println(list);//[你好, 张三, 李四, 张三, 张三, 你好]

        //修改指定下标为指定元素
        list.set(2, "张三");
        System.out.println(list);//[你好, 张三, 张三, 张三, 张三, 你好]

        //查找指定元素第一次出现的下标
        System.out.println(list.indexOf("你好"));//0
        //查找指定元素最后一次出现的下标
        System.out.println(list.lastIndexOf("你好"));//5

        //长度
        System.out.println(list.size());//6
        //是否为空
        System.out.println(list.isEmpty());//false
        //清空
        list.clear();
        System.out.println(list);//[]

        List<String> list2 = new ArrayList<>();
        list2.add("李");
        list2.add("李四");
        list2.add("李四");
        list2.add("李");
        //获取一个子集合 [开始下标,结束下标)
        List<String> list22 = list2.subList(1, 3);
        System.out.println(list22);//[李四, 李四]

        //new String[]0}类型数组对象
        String[] array = list2.toArray(new String[]{});
        for (String s : array) {
            System.out.println(s.toLowerCase());
        }

		//遍历
        List<String> list3 = new ArrayList<>();
        list3.add("张三");
        list3.add("李四");
        list3.add("王五");
        System.out.println(list3);//[张三, 李四, 王五]
        //普通for循环遍历
        for (int i = 0; i < list3.size(); i++) {
            System.out.println(list3.get(i));
        }
        //增强for循环
        for (String s:list3) {
            System.out.println(s);
        }
        //迭代器遍历 创建iterator对象
        Iterator<String> iterator = list3.iterator();
        //iterator.hasNext()判断光标的后面是否还有元素
        while(iterator.hasNext()){
            //iterator.next()获取指定元素
            System.out.println(iterator.next());
        }
        System.out.println("=============");
        //ListIterator:可以实现从后向前遍历
        // 前提是需要先从前向后遍历，将光标放到最后
        //创建ListIterator对象
        ListIterator<String> listIterator = list3.listIterator();
        while(listIterator.hasNext()){
            String ele = listIterator.next();
            if (ele.equals("李四")) {
                listIterator.remove();//删除元素
                listIterator.add("赵六");//新增元素
            }
            //iterator.next()获取指定元素
            System.out.println(ele);
        }
        //判断是否有前一个
        while(listIterator.hasPrevious()){
            //获取当前元素前一个下标
            System.out.println(listIterator.previousIndex());
            //获取前一个数据
            System.out.println(listIterator.previous());
        }
        //forEach遍历
        list3.forEach(System.out::println);
    }
}

ArraysList

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;

public class CollectionTest {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        //add(添加元素) 会将一个集合作为一个元素处理
        collection.add(10);
        collection.add(20);
        //collection.add(new Date());
        System.out.println(collection);//[10, 20]

        Collection c1 = new ArrayList();
        c1.add("张三");
        c1.add("李四");
        c1.add(collection);
        System.out.println(c1);//[张三, 李四, [10, 20]]
        //addAll(添加集合) 会将集合中的每一个元素，进行单独处理
        c1.addAll(collection);
        System.out.println(c1);//[张三, 李四, [10, 20], 10, 20]
        //判断集合内有多少数据
        System.out.println(c1.size());//5

        //判断指定元素是否在集合内
        System.out.println(collection.contains(10));//true

        //删除集合内的指定元素
        System.out.println(collection.remove(10));//true
        System.out.println(collection);//[20]
        System.out.println(c1);//[张三, 李四, [20], 10, 20]
        //删除集合
        System.out.println(c1.removeAll(collection));//true
        System.out.println(c1);//[张三, 李四, [20], 10]

        Collection c2 = new ArrayList();
        c2.add(10);
        c2.add(20);
        c2.add(30);
        Collection c3 = new ArrayList();
        c3.add(10);
        c3.add(30);
        //求交集
        c2.retainAll(c3);
        System.out.println(c2);//[10, 30]

        //判断集合是否为空
        System.out.println(c3.isEmpty());//false

        //清除集合内所有元素
        c1.clear();
        System.out.println(c1.isEmpty());//true
        System.out.println(c1.size());//0

        //遍历集合
        Collection c4 = new ArrayList();
        c4.add(10);
        c4.add(20);
        c4.add(new Date());
        for (Object o:c4) {
            System.out.println(o);
        }
        //创建一个迭代器
        Iterator iterator = c4.iterator();
        //hasNext():判断游标/光标的后面是否还有数据 （有-》true ；无-》false）
        //next():拿到指定的数据
        while (iterator.hasNext()){
            Object obj = iterator.next();
            System.out.println(obj);
        }
        //增强for
        A a = new A();
        //表面是for循环遍历实际底层也是迭代器
    }
}
class A implements Iterable{

    @Override
    public Iterator iterator() {
        return null;
    }
}

快速失败机制

import java.util.ArrayList;
import java.util.Collection;

public class CollectionTest2 {
    public static void main(String[] args) {
        /*
            泛型：规定输入数据的类型
            Collection<引用数据类型>
        */
        /*
            modCount:记录集合操作的次数
            在集合进行便利的时候，不要使用集合对象直接新增或者删除元素
            删除的时候使用iterator去操作
         */
        Collection<String> c1 = new ArrayList<>();
        c1.add("张三");
        c1.add("李四");
        c1.add("王五");
        System.out.println(c1);
        /*同步修改异常ConcurrentModificationException
        * 快速失败机制*/
        for (String s : c1) {
            if (s.equals("张三")) {
                c1.remove("李四");
            }
        }
        System.out.println(c1);
    }
}

LinkedList

Set:

无序：不是按照添加的顺序输出
唯一：不可以添加重复元素
注意：相较于Collection没有新增方法
使用set集合存储自定义类型数据，需要去重写hashCode和equals方法

HashSet

无序：不是添加的顺序
唯一：元素唯一

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class HashSet1 {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("张三");
        set.add("张三");
        set.add("张三");
        set.add("李四");
        set.add("王五");
        //无序：不是添加的顺序，唯一：元素唯一，添加多个相同元素也只保留一个
        System.out.println(set);//[李四, 张三, 王五]

        //遍历方式只有两种：增强for、迭代器
        for (String s : set) {
            System.out.println(s);
        }
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        //HashSet存储自定义数据
        Set<Person> personSet = new HashSet<>();
        personSet.add(new Person("张三",18));
        personSet.add(new Person("李四",19));
        personSet.add(new Person("张三",18));
        //若想实现相同对象唯一则需要重写equals、hashCode方法
        System.out.println(personSet.size());//3--》2
        System.out.println(personSet);
    }
}
class Person{
    String name;
    int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person)) return false;

        Person person = (Person) o;

        if (age != person.age) return false;
        return name != null ? name.equals(person.name) : person.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

LinkedHashSetTreeSet

有序：添加顺序
唯一：元素唯一

import java.util.LinkedHashSet;

public class LinkedHashSet1 {
    public static void main(String[] args) {
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add("1");
        linkedHashSet.add("12");
        linkedHashSet.add("12");
        linkedHashSet.add("13");
        linkedHashSet.add("13");
        linkedHashSet.add("14");
        System.out.println(linkedHashSet);//[1, 12, 13, 14]
        //存储自定义数据，若想实现相同对象唯一则需要重写equals、hashCode方法
    }
}

TreeSet

有序：自然顺序
唯一：元素唯一

import java.util.Set;
import java.util.TreeSet;

public class TreeSet1 {
    public static void main(String[] args) {
        Set<Integer> integerSet = new TreeSet<>();
        integerSet.add(10);
        integerSet.add(12);
        integerSet.add(20);
        integerSet.add(20);
        integerSet.add(-10);
        System.out.println(integerSet);//[-10, 10, 12, 20]
        Set<String> stringSet = new TreeSet<>();
        stringSet.add("z");
        stringSet.add("a");
        stringSet.add("d");
        stringSet.add("a");
        System.out.println(stringSet);//[a, d, z]

        Set<Person1> personSet = new TreeSet<>();
        personSet.add(new Person1("张三",18));
        personSet.add(new Person1("李四",16));
        personSet.add(new Person1("王五",17));
        personSet.add(new Person1("王五",17));
        personSet.add(new Person1("赵六",20));
        System.out.println(personSet);
    }
}
class Person1 implements Comparable<Person1>{
    String name;
    int age;

    public Person1() {
    }

    public Person1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person1)) return false;

        Person1 person1 = (Person1) o;

        if (age != person1.age) return false;
        return name != null ? name.equals(person1.name) : person1.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

    @Override
    public String toString() {
        return "Person1{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }


    @Override
    public int compareTo(Person1 o) {
        return this.age-o.age;
    }
}

Map

Map:存储数据
存储键值对（key ，value）

HashMap

1. key是无序唯一
2. 当key重复时 会替换原有旧值
3. value可以重复

import java.util.*;

public class HashMap1  {
    public static void main(String[] args) {
        //HashMap:
        // 1. key是无序唯一
        // 2. 当key重复时 会替换原有旧值
        // 3. value可以重复
        Map<Integer,String> map = new HashMap<>();
        map.put(1,"张三");
        map.put(2,"李四");
        map.put(2,"张三");
        map.put(1,"李四");
        map.put(3,"李四");

        System.out.println(map);//{1=李四, 2=张三, 3=李四}
        //当前Map集合内键值对的数量
        System.out.println(map.size());//3

        System.out.println(map.isEmpty());//false

        //删除指定Key的键值对  返回对应的value值
        System.out.println(map.remove(2));//张三

        System.out.println(map.get(1));//李四
        //获取所有key
        Set<Integer> integerSet = map.keySet();
        for (Integer i:integerSet) {
            System.out.println(map.get(i));
        }

        System.out.println("============");
        //获取所有value
        Collection<String> values = map.values();
        Iterator<String> iterator = values.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

        //判断指定键或值是否在集合内
        System.out.println(map.containsKey(2));//false
        System.out.println(map.containsValue("李四"));//true

        //遍历
        // map.entrySet()获取的就是键值对
        Set<Map.Entry<Integer, String>> entries = map.entrySet();
        for (Map.Entry<Integer,String> e:entries) {
            //获取键值对
            System.out.println(e);
        }
    }
}

LinkedHashMap

1. key：有序:添加顺序;重复替换旧值
2. value： 满足泛型即可，可以重复

import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

public class LinkedHashMap1 {
    public static void main(String[] args) {
        //key:有序：添加顺序;重复替换旧值
        //value 满足泛型即可，可以重复
        LinkedHashMap<String,String> map = new LinkedHashMap<>();
        map.put("张三","18");
        map.put("张三","19");
        map.put("李四","18");
        map.put("王五","18");
        System.out.println(map);//{张三=19, 李四=18, 王五=18}

        //遍历
        //此set内存储了map内所有的键值对
        Set<Map.Entry<String, String>> entries = map.entrySet();
        Iterator<Map.Entry<String, String>> iterator = entries.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }
}

TreeMap

1. key：有序:自然顺序，重复替换旧值
2. value： 满足泛型即可，可以重复

import java.util.Set;
import java.util.TreeMap;

public class TreeMap1 {
    public static void main(String[] args) {
        TreeMap<Integer,String> map = new TreeMap<>();
        map.put(1,"张三");
        map.put(10,"李四");
        map.put(3,"张三");
        map.put(3,"李四");
        map.put(-1,"王五");
        System.out.println(map);//{-1=王五, 1=张三, 3=李四, 10=李四}

        Set<Integer> integerSet = map.keySet();
        for (Integer i:integerSet
             ) {
            System.out.println(i+"="+map.get(i));
        }
    }
}

Collections工具类

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

public class CollectionsTest {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        Collections.addAll(list,1,2,3,4,5,6,7,8,9,2,1);
        System.out.println(list);//[1, 2, 3, 4, 5, 6, 7, 8, 9, 2, 1]
        //统计指定元素在集合内出现的次数
        int frequency = Collections.frequency(list, 1);
        System.out.println(frequency);//2
        //排序，升序
        Collections.sort(list);
        System.out.println(list);//[1, 1, 2, 2, 3, 4, 5, 6, 7, 8, 9]
        //二分查找，获取指定元素对应的下标
        int index = Collections.binarySearch(list, 4);
        System.out.println(index);//5
        //倒序，无排序功能
        Collections.reverse(list);
        System.out.println(list);//[9, 8, 7, 6, 5, 4, 3, 2, 2, 1, 1]
        //打乱顺序
        Collections.shuffle(list);
        System.out.println(list);//

        List<Integer> destList = new ArrayList<>();
        Collections.addAll(destList,1,2,3,4,5,6,7,8,9,10,11);
        //集合的复制Collections.copy(目标集合,数据源集合);
        // 使用时注意目标集合的长度要>=数据源集合的长度
        //否则报错
        Collections.copy(destList,list);
        System.out.println(destList);

        List<String> stringList = new ArrayList<>();
        Collections.addAll(stringList,"张三","李四","王五");
        System.out.println(stringList);//[张三, 李四, 王五]
        //指定元素按下标进行交换
        Collections.swap(stringList,0,2);
        System.out.println(stringList);//[王五, 李四, 张三]

        //返回的集合不能修改 Collections.unmodifiableList();
        List<String> stringList1 = Collections.unmodifiableList(stringList);
        System.out.println(stringList1);


        List<Person2> person2List = new ArrayList<>();
        person2List.add(new Person2("张三",18));
        person2List.add(new Person2("李四",10));
        person2List.add(new Person2("王五",17));
        System.out.println(person2List);//[Person2{name='张三', age=18}, Person2{name='李四', age=10}, Person2{name='王五', age=17}]
        //实现接口方式排序
        Collections.sort(person2List);
        System.out.println(person2List);//[Person2{name='李四', age=10}, Person2{name='王五', age=17}, Person2{name='张三', age=18}]


        List<Student> studentList = new ArrayList<>();
        studentList.add(new Student("张三",19));
        studentList.add(new Student("李四",17));
        studentList.add(new Student("王五",20));
        System.out.println(studentList);//[Student{name='张三', age=19}, Student{name='李四', age=17}, Student{name='王五', age=20}]
        //匿名内部类方式比较
        Collections.sort(studentList, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.age-o2.age;
                //return o2.age-o1.age;//倒序 return -(o1.age-o2.age);
            }
        });
        System.out.println(studentList);//[Student{name='李四', age=17}, Student{name='张三', age=19}, Student{name='王五', age=20}]
    }
}
class Student{
    String name;
    int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}


class Person2 implements Comparable<Person2>{
    String name;
    int age;

    public Person2() {
    }

    public Person2(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person2{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Person2 o) {
        return this.age-o.age;
    }
}