JAVA笔记-集合

集合(Collection),是用来存放对象的数据结构,长度可变,可以存放不同类型的对象,并且还提供了一组操作成批对象的方法.Collection接口层次结构 中的根接口,接口不能直接使用,但是该接口提供了添加元素/删除元素/管理元素的父接口公共方法.
由于List接口与Set接口都继承了Collection接口,因此这些方法对于List集合和Set集合是通用的.

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

public class TestCollection {
    public static void main(String[] args) {
        Collection<Integer> a = new ArrayList<>();
        a.add(100);
        a.add(200);
        a.add(300);
        System.out.println(a);
        /*测试集合中的常用方法*/
//        a.clear();//清空集合
        System.out.println(a.hashCode());//打印集合对象地址值
        System.out.println(a.equals(200));
        System.out.println(a.contains(200));//判断集合中是否包含元素200
        System.out.println(a.isEmpty());//判断集合是否为空
        a.remove(200);//删除集合中指定元素200
        System.out.println(a);
        System.out.println(a.size());//获取集合中元素的个数

        Object[] array = a.toArray();//将集合对象转为数组
        System.out.println(Arrays.toString(array));

        Collection<Integer> c2 = new ArrayList<>();
        c2.add(2);
        c2.add(3);
        c2.add(4);
        System.out.println(c2);

        System.out.println(a);
        System.out.println(c2);
        System.out.println(a.contains(c2));//判断a集合中是否包含c2集合的所有元素
        a.addAll(c2);//将c2集合元素全部添加到a
        System.out.println(a);
        System.out.println(c2);
        a.removeAll(c2);//删除a集合中属于c2的元素
        a.add(5);
        c2.add(5);
        System.out.println(a);
        System.out.println(c2);
//        System.out.println(a.retainAll(c2) );//保留a集合与c2的交集
//        System.out.println(a);

        /*集合遍历
        * 1.获取迭代器 集合名.iterator()
        * 2.通过迭代器判断集合中是否有下一个元素*/
        Iterator<Integer> it = a.iterator();
        while (it.hasNext()){
            Integer num = it.next();
            System.out.println(num);
        }
    }
}

List 

有序的colletion(也称为序列).此接口的用户可以对列表中的每个元素的插入位置进行精确的控制,用户可以根据元素的整数索引(在列表中的位置)来访问元素,并搜索列表中的元素，

1. 元素有下标
2. 元素有序
3. 允许存放重复元素

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

public class TestList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张一");
        list.add("张二");;
        list.add("张三");
        list.add("张四");
        System.out.println(list);
        System.out.println(list.contains("张一"));
        System.out.println(list.isEmpty());
        System.out.println(list.size());
        System.out.println(Arrays.toString(list.toArray()));

        List<String> list1 = new ArrayList<>();
        list1.add("1");
        list1.add("12");
        list1.add("123");
        list1.add("1234");
        System.out.println(list1);
        list1.addAll(list);
        System.out.println(list1);
        System.out.println(list1.containsAll(list));
        list1.retainAll(list);
        System.out.println(list1);
        System.out.println(list1);
//        list1.removeAll(list);
        System.out.println(list1.containsAll(list));
        list1.add(1,"333");
        list1.add(1,"333");
        System.out.println(list1);
        System.out.println(list1.indexOf("333") );//判断元素第一次出现的下标
        System.out.println(list1.lastIndexOf("333"));//判断元素最后一次出现的下标
        System.out.println(list1.remove(1));//根据下标删除元素，并返回对应元素
        System.out.println(list1.set(1,"444") );//修改元素
        System.out.println(list1 .get(1));//获取元素
        System.out.println(list1.addAll(1,list) );//指定位置添加集合元素
        System.out.println(list1);

        for(int i = 0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        System.out.println("*****方式一*******");
        //高效for循环
        for(String s:list){
            System.out.println(s);
        }
        System.out.println("*****方式二*******");
        //使用父接口继承的迭代器
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
    }
        System.out.println("*****方式三*******");
        ListIterator<String> it1 = list.listIterator();
        while (it1.hasNext()){
            System.out.println(it1.next());
        }

     }

}

LinkedList

1.  LinkedList内存地址不连续，依靠节点之间的地址连接
2. 有下标，从0开始，普通节点保存上一个节及下一个节点地址
3. 都节点仅下一个节点地址，尾节点仅上一个节点地址

import java.util.LinkedList;

public class TestLinkedList {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("张一");
        list.add("张二");
        list.add("张三");
        list.add("张四");
        
        list.addFirst("王五");
        list.addLast("李四") ;
        System.out.println(list);
        System.out.println(list.getFirst());
        System.out.println(list.getLast());

        System.out.println(list.removeFirst() );
        System.out.println(list);

        LinkedList<String> list1 = new LinkedList<>();
        list1.add("喜羊羊");
        list1.add("美羊羊");
        list1.add("懒羊羊");
        list1.add("沸羊羊");
        System.out.println(list1);
        System.out.println(list1.element());//获取集和首元素
        System.out.println(list1.peek());//获取集合首元素
        System.out.println(list1.peekFirst() );
        System.out.println(list1.peekLast() );//获取尾元素

        System.out.println(list1.offer("灰太狼"));//添加尾元素
        System.out.println(list1.offerFirst("红太郎"));
        System.out.println(list1);

        System.out.println(list1.poll() );//删除首元素
        System.out.println(list1.pollFirst() );//删除首元素
        System.out.println(list1.pollLast() );//删除尾元素
        System.out.println(list1);
    }
}

Arrylist底层是数组结构，查询快，增删慢，适合查询场合较多的场景

LinkedList底层是链表结构，查询慢，增删快，适合增删操作较多的场景

Map 

Java.util接口Map<K,V>。 类型参数 : K - 表示此映射所维护的键 V – 表示此映射所维护的对应的值
也叫做哈希表、散列表. 常用于键值对结构的数据.其中键不能重复,值可以重复

1. 根据键取值，键不允许重复
2. 存放无序的数据
3. 初始容量16

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

public class TestMap {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>();
        map.put(9528,"深圳");
        map.put(9529,"广州");
        map.put(9530,"成都");
        map.put(9531,"贵阳");
        map.put(9532,"贵阳");
        System.out.println(map);

        System.out.println(map);
        System.out.println(map.isEmpty());
        System.out.println(map.size());
        System.out.println(map.containsKey(9530));
        System.out.println(map.containsValue("广州"));
        System.out.println(map.get(9528));//根据key获取value值
        System.out.println();
        System.out.println(map.remove(9528));//g根据key值删除键值对
        System.out.println(map.values());
        /*想要遍历map中的数据，但是map并没有迭代器
        * 所以需闲将map转set集合，将map中所有的key值存入set--keySet()*/
        Set<Integer> set = map.keySet();
        Iterator<Integer> it = set.iterator();
        while (it.hasNext()){
            System.out.println(map.get(it.next()));
        }

        Set<Map.Entry<Integer, String>>  set1 = map.entrySet();
        Iterator<Map.Entry<Integer, String>> it1 = set1.iterator();
        while (it1.hasNext()){
            Map.Entry<Integer, String>  entry = it1.next();
            System.out.println("***");
            System.out.println(entry.getKey());
            System.out.println(it1.next().getValue());
        }
    }
}

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class TestMap1 {
    public static void main(String[] args) {
        System.out.println("请输入需要计算的字符串");
        String str = new Scanner(System.in).nextLine();
        Map<Character,Integer> map = new HashMap<>();

        for(int i = 0;i < str.length() ;i++) {
            char key = str.charAt(i);
            Integer vaule = map.get(key);
            if (vaule == null) {
                map.put(key, 1);
            } else {
                map.put(key, vaule + 1);
            }
        }
        System.out.println(map);
    }
}

1. HashMap的结构是数组+链表 或者 数组+红黑树 的形式
2. HashMap底层的Entry[ ]数组，初始容量为16，加载因子是0.75f,扩容按约为2倍扩容
3. 当存放数据时,会根据hash(key)%n算法来计算数据的存放位置，n就是数组的长度,其实也就是集合的容量，当计算到的位置之前没有存过数据的时候,会直接存放数据，当计算的位置,有数据时,会发生hash冲突/hash碰撞，解决的办法就是采用链表的结构,在数组中指定位置处以后元素之后插入新的元素，就是说数组中的元素都是最早加入的节点
4. 如果链表的长度>8且数组长度>64时，链表会转为红黑树，当链表的长度<6时，红黑树会重新恢复成链表

 set 

1.  Set是一个不包含重复数据的Collection
2. 集合中的数据是无序的
3. 集合中的元素不可以重复 – 常用来给数据去重
4. 可以存null值，单最多一个
5. 自定义对象想去重，需重写equals()和hashcode()方法

import java.util.Objects;

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

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return id == student.id && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, id);
    }
}


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

public class TestSet2 {
    public static void main(String[] args) {
        /*如果set集合中存放自定义类型，需要添加重写的equals()和
        * hashcode()方法，否则S3和S4会认为是两个不同对象，因为
        * 地址不同，不会去重*/
        Set<Student> set = new HashSet<>();
        Student s1 = new Student("张三",11);
        Student s2 = new Student("张四",12);
        Student s3 = new Student("张五",13);
        Student s4 = new Student("张五",13);

        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        System.out.println(set);
    }
}