Java基础-----容器

容器

1.1单例集合

1.2双例集合
基于key与value的结构存储数据


2List接口介绍
2.1List接口特点
有序：有序（元素存入集合的顺序和取出顺序一致）。List中每个元素都有索引标记，可以根据元素的索引标记（在List中的位置）访问元素，从而精确控制这些元素
可重复：List允许加入重复的元素，满足e1.equals(e2)的元素可重复加入到容器。

ArrayList容器类
ArrayList是List接口的实现类，是List存储特征的具体实现
ArrayList底层是用数组实现的存储，特点：查询效率高、增删效率低、线程不安全。

package com.bjsxt;

import java.util.ArrayList;
import java.util.List;
/*
有关ArrayList的
ArrayList添加、获取、删除、替换、集合的转换
容器的清空、判断容器是否为空、查找容器是否有指定元素
查找元素第一次出现的位置
查找元素最后一次出现的位置
将单列集合转换为数组
两个容器之间的并集操作--跟数学是一样的
两个容器之间的交集操作
* */
public class ArrayListTest {
    public static void main(String[] args) {
        //实例化ArrayList容器
        List<String> list = new ArrayList<>();
        //添加元素
        System.out.println("--------添加元素---------");
        boolean flag = list.add("sda"); //true
        boolean flag2 = list.add("das"); //true
        System.out.println(flag);
        //在指定位置添加元素
        System.out.println("----------在指定位置添加元素------");
        list.add(1,"sb");
        System.out.println(list); //[sda, sb, das]

//        System.out.println(list.get(0));
        System.out.println(list.get(1));
        System.out.println(list.get(2));
        //size(),返回列表中元素的个数，获取元素的过程
        for(int i=0;i<list.size() ;i++){
            System.out.println(list.get(i));
        }

        System.out.println("----------删除指定位置元素--------------");
        //根据指定位置删除元素,输出元素后面的元素会自动向前移
        String value = list.remove(1);
        for(int i=0;i<list.size() ;i++){
            System.out.println(list.get(i));
        }
        System.out.println("----------删除指定元素---------------");
        //删除指定元素,如果删除的元素原本就不存在，则flag3为false
        boolean flag3 = list.remove("sda");
        System.out.println(flag3);
        for(int i=0;i<list.size() ;i++){
            System.out.println(list.get(i));
        }
        System.out.println("-----------替换元素---------------");
        //替换元素,set()的返回值是被替换的那个元素
        String a1 = list.set(0,"zdczc");
        System.out.println(a1);   //das
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }

        System.out.println("-----------清空容器------------");
        list.clear();
        System.out.println(list.size());

        System.out.println("-----------判断容器是否为空--------");
        list.add("zc");
        list.add("dd");
        list.add("zc");
        boolean flag4 = list.isEmpty();
        System.out.println(flag4);

        System.out.println("------判断容器中是否包含指定元素-------");
        boolean flag5 = list.contains("zc");
        System.out.println(flag5);  //true
        boolean flag6 = list.contains("ads");
        System.out.println(flag6);  //false

        System.out.println("---------查找元素的位置--------");
        System.out.println("------查找元素第一次出现的位置------");
        int index = list.indexOf("zc");  // 返回值为int型，如果元素不存在返回-1
        System.out.println(index);
        System.out.println("------查找元素最后一次出现的位置------");
        //如果元素不存在返回-1
        int index1 = list.lastIndexOf("zc");
        System.out.println(index1);


        System.out.println("--------将单例集合转换为数组---------");
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        System.out.println("-------------Object[]----------");
        //将ArrayList转换为Object[],java强制类型转换只能是对单个元素的强制转换
        //但是不能在转换额数组做强制类型转换
        Object[] arr = list.toArray();
        for (int i=0;i<arr.length;i++){
            String str = (String) arr[i];
            System.out.println(str);
        }
        System.out.println("---------将单例集合转换为指定类型的数组-------------");
        //类型需要参考泛型中的类型
        String[] arr2 = list.toArray(new String[list.size()]);
        for(int i=0;i<arr2.length;i++){
            System.out.println(arr2[i]);
        }

        System.out.println("----------容器的并集操作,addAll(),返回值为boolean类型---------");
        //不能对没有元素的容器进行并操作。
        List<String> a = new ArrayList<>();
        a.add("a");
        a.add("b");
        a.add("c");

        List<String> b = new ArrayList<>();
        b.add("b");
        b.add("c");
        b.add("d");
        boolean flag7 = a.addAll(b);  //a并b,并到的结果放在a中
        System.out.println(flag7);   //成功返回true，失败返回false
        System.out.println(a);  //此时a为a,b,c,b,c,d

        System.out.println("------------容器的交集操作，retainAll(),返回值为boolean------");
        List<String> c = new ArrayList<>();
        c.add("a");
        c.add("b");
        c.add("c");

        List<String> d = new ArrayList<>();
        d.add("b");
        d.add("c");
        d.add("d");
        boolean flag8 = c.retainAll(d);
        System.out.println(flag8);
        System.out.println(c);  //交集之后的结果放在c中
        System.out.println(d);

        System.out.println("-----------容器的差集操作，removeAll()，返回值为boolean----------------------");
        List<String> c1 = new ArrayList<>();
        c1.add("a");
        c1.add("b");
        c1.add("c");

        List<String> d1 = new ArrayList<>();
        d1.add("b");
        d1.add("c");
        d1.add("d");
        boolean flag9 = c1.removeAll(d1);
        System.out.println(flag8);
        System.out.println(c1);  //差集之后的结果放在c1中
        System.out.println(d1);
    }
}

Vector容器
vector底层使用数组实现的，相关的方法都加了同步检查，因此“线程安全、效率低”比如。indexOf()就增加了synchronized同步标记

import java.util.List;
import java.util.Vector;
public class VectorTest {
    public static void main(String[] args) {
        //实例化Vector
        List<String> v = new Vector<>();
        v.add("a");
        v.add("b");
        v.add("c");
        for(int i=0;i<v.size();i++){
            System.out.println(v.get(i));
        }
        System.out.println("-----------------------");
        for(String str:v){
            System.out.println(str);
        }
    }
}

Stack容器
Stack栈容器，是Vector的一个子类，它实现了一个标准的后进先出的栈

package com.bjsxt;
import java.util.Stack;
import java.util.Vector;
public class StackTest {
   public static void main(String[] args) {
        //实例化栈容器
        Stack<String> stack = new Stack<>();
        //将元素添加到栈当中
        stack.push("a");
        stack.push("b");
        stack.push("c");

        //获取栈容器的元素
        String pop1 = stack.pop();
        String pop2 = stack.pop();
        System.out.println(pop1);
        System.out.println(pop2);
        //判断栈是否为空,返回值为boolean
        System.out.println(stack.empty());
        //查看栈顶元素，只查看
        System.out.println(stack.peek());
        //返回元素在栈容器中的位置,从栈顶开始查，栈顶为1
        System.out.println(stack.search("a"));

        String str = "...{......[....(....)....]......}...";
        StackTest stacktest = new StackTest();
        stacktest.symmetry(str);
    }

    //匹配符号的对称性
    public void symmetry(String s){

        //实例化Stack
        Stack<String> stack = new Stack<>();
        boolean flag = true;
        //匹配字符串获取字符
        for(int i=0;i<s.length();i++){
            char c = s.charAt(i);
            if (c == '{'){
                stack.push("}");
            }
            if(c == '['){
                stack.push("]");
            }
            if(c == '('){
                stack.push(")");
            }

            //判断符号是否匹配
            if(c == '}' || c == ']' || c == ')'){
                if(stack.empty()){
                    flag = false;
                    break;
                }
                String x = stack.pop();
                if(x.charAt(0) != c){
                    flag = false;
                    break;
                }
            }
        }
        if(stack.empty()==true){
            System.out.println("括号对称");
        }
        else{
            System.out.println("括号匹配");
        }
    }
}

LinkedList容器
底层是由双线链表实现的。
linkedList实现了list接口，所以LinkList是具备List的存储特征的（有序、元素有重复）
当LinkList由自己定义时，则具有以下方法

LinkList相关操作

package com.bjsxt;
import java.util.LinkedList;
import java.util.List;
public class LinkedListTest {
    public static void main(String[] args) {
        //使用方式
        List<String> list = new LinkedList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("a");

        //获取元素
        for(int i=0;i<list.size();i++){

            System.out.println(list.get(i));
        }
        System.out.println("-----------------");
        for(String str :list){
            System.out.println(str);
        }
        System.out.println("--------LinkList--------------");
        System.out.println("--------添加头字符----------");
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.addFirst("a");
        linkedList.addFirst("b");
        linkedList.addFirst("c");
        for(String str :linkedList){
            System.out.println(str);
        }
        System.out.println("---------添加尾字符-----------");
        LinkedList<String> linkedList1 = new LinkedList<>();
        linkedList1.addLast("a");
        linkedList1.addLast("b");
        linkedList1.addLast("c");
        for(String str1 :linkedList1){
            System.out.println(str1);
        }
        System.out.println("---------去掉头尾-----------");
        linkedList1.removeFirst();
        linkedList1.removeLast();
        for(String str3 :linkedList1){
            System.out.println(str3);
        }
        System.out.println("-------pop方法,去掉栈顶---------");
        linkedList1.pop();
        for(String str4 :linkedList1){
            System.out.println(str4);
        }
        System.out.println("-----------------------------");
        linkedList1.push("a");
        for(String str3 :linkedList1){
            System.out.println(str3);
        }
        System.out.println(linkedList1.isEmpty());
    }
}

set接口
Set接口继承Collection，Set接口中没有新增方法，方法和Collection保持完全一致。Set特点：无序，不可重复。无序值Set中的元素没有索引，我们只能遍历查找，不可重复指不允许加入重复的元素。

Hashset容器类

package com.bjsxt;
import java.util.HashSet;
import java.util.Set;
public class HashSetTest {
    public static void main(String[] args) {
        //实例化HashSet
        Set<String> set = new HashSet<>();
        //添加元素
        set.add("a");
        set.add("b");
        set.add("c");
        set.add("d");
        set.add("a");
        //获取元素,在Set容器中没有索引，所以没有对应的get（int index）
        System.out.println(set); //a,b,c,d 所以Set容器中不允许有重复的元素出现
        for(String str:set){
            System.out.println(str);
        }
        //删除元素
        boolean flag = set.remove("a");
        System.out.println(set);
        //返回元素个数
        System.out.println(set.size());
    }
}

HasSet存储特征：
HashSet是一个不保证元素的顺序且没有重复元素的集合，是线程不安全的，HashSet允许有null元素
无序：在HashSet中底层使用HashMap存储元素的，HashMap底层使用的是数组与链表实现元素的存储。元素在数组中存放时，就是哈希函数
不重复：当两个元素的哈希值进行运算后得到相同的在数组中的位置，会调用元素的equals()方法判断两个元素是否相同，如果相同则不添加该元素。如果相同则使用单链表保存该元素。
HashSet在存储自定义类的时候，要重写equals()和hashcode()方法
自己定义的USER类

package com.bjsxt;

import java.util.Objects;

public class User {
    private String username;
    private int userage;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public int getUserage() {
        return userage;
    }

    public void setUserage(int userage) {
        this.userage = userage;
    }

    public User(String username, int userage) {
        this.username = username;
        this.userage = userage;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return userage == user.userage &&
                Objects.equals(username, user.username);
    }

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

    public User() {
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", userage=" + userage +
                '}';
    }
}

用hashcode调用

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

public class HashSetTest {
    public static void main(String[] args) {
        System.out.println("------------------");
        //实例化HashSet
        Set<User> set1 = new HashSet<>();
        User u = new User("sd",40);
        User u1 = new User("sd",40);
        set1.add(u);
        set1.add(u1);
        System.out.println(u.hashCode());
        System.out.println(u1.hashCode());
        System.out.println(set1);
    }
}

还有别的容器，有用到在去看吧
单例容器案例
1、使用list类型容器

import java.util.ArrayList;
import java.util.List;
/*
* 产生随机数，在容器中存入1-10这十个随机数
* */
public class ListDemo {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();

        while(true){
            //产生随机数
            int num = (int)(Math.random()*10+1);
            // 判断当前元素是否存在
            if(!list.contains(num)){
                list.add(num);
            }
            //结束循环
            if(list.size()==10){
                break;
            }
        }
        System.out.println(list);
    }
}

2、使用set容器

/*
 * 产生随机数，在容器中存入1-10这十个随机数
 * */
import java.util.HashSet;
import java.util.Set;
public class SetDemo {
    public static void main(String[] args) {
        //set容器不允许有重复元素出现
        Set<Integer> set = new HashSet<>();
        while(true){
            int num = (int)(Math.random()*10+1);
            set.add(num);
            if(set.size()==10){
                break;
            }
        }
        for(Integer str:set){
            System.out.println(str.hashCode());
        }
        //结果为1-10有序的，因为Integer数值通过hashcode的mod16时，得到的值整好是数组下标
        System.out.println(set);
    }
}

容器双例集合

1、Map接口
1.1Map接口特点
Map接口定义了双例集合的存储特征，它并不是Collection接口的子接口，双例集合的存储特征是以Key与value结构为单位进行存储的，体现的是数学中的函数y=f(x)
Map与Collection的区别

• Collection中的容器，元素是孤立存在的，向集合中存储元素采用一个元素的存储方式。
• Map中的穷奇，元素是成对存在的，每个元素由键与值两部分组成，通过键可以找对应的值
• Collection中的容器称为单例集合，Map中的容器称为双例集合
• Map中的集合不能包含重复的键，值可以重复，每个键只能对应一个值
• Map中常用容器为HashMap，TreeMap等

1.2Map常用的方法
2、HashMap容器类
HashMap是Map接口的接口实现类，它采用哈希算法实现，是Map接口常用的实现类，由于底层采用了哈希表存储数据，所以要求键不能重复，如果发生重复，新的值会替换旧的值，HashMap在查找、删除、修改方面有非常高的效率。
HashMap相关操作：

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

public class HashMapTest {

    public static void main(String[] args) {
        //实例化HashMap容器
        Map<String, String> map = new HashMap<>();

        String value = map.put("a","A");
        System.out.println(value); //null
        String value1 = map.put("a","B");
        System.out.println(value1); //结果为A，这是HashMap存入元素的特点

        System.out.println("--------------获取元素-------------");
        //这个得需要知道key
        String value2 = map.get("a");
        System.out.println(value2);

        System.out.println("---------------获取元素2------------");
        map.put("b","B");
        map.put("c","C");
        map.put("d","D");
        map.put("e","E");
        //获取HashMap中所有元素,使用KeySet与get方法一起使用,map.keySet()方法返回的是set<>容器
        Set<String> keys = map.keySet();
        for(String key:keys){
            String v1 = map.get(key);
            System.out.println(key+"---"+v1);
        }

        System.out.println("-----------------获取元素3--------------");
        //使用entrySet返回值是Map.Entry类型。
        Set<Map.Entry<String,String>>  entrySet = map.entrySet();
        for(Map.Entry<String,String> entry:entrySet){
            String key = entry.getKey();
            String v = entry.getValue();
            System.out.println(key+"-----"+v);
        }

        System.out.println("---------------Map容器的并集操作-----------");
        //两个并集的泛型要相同
        Map<String,String> map2 = new HashMap<>();
        map2.put("f","F");
        map2.put("c","cc");
        System.out.println(map2);
        //并集,如果并集时两个容器有key值，则当前容器的value被覆盖掉
        map2.putAll(map);
        System.out.println(map2);
        Set<String> keys1 = map2.keySet();
        for(String key:keys1){
            System.out.println("key: "+key+" value: "+map2.get(key));
        }

        System.out.println("----------------Map容器删除元素------------------");
        //remove返回值为value
        String v =  map.remove("e");
        System.out.println(map);
        System.out.println(v);

        System.out.println("-----------------判断key或value是否存在----------");
        System.out.println("-----------------判断key是否存在----------------");
        boolean flag = map.containsKey("a");
        System.out.println(flag);

        System.out.println("------------------判断value是否存在---------------");
        boolean flag1 = map.containsValue("A");
        System.out.println(flag1);
    }
}

TreeMap容器类
TreeMap和HashMap同样实现了Map接口，所以，对于API接口用法来说是没有区别的。HashMAp效率高于TreeMap；TreeMap是可以对键进行排序的一种容器，在需要对键排序时可选用TreeMap，TreeMap底层是基于红黑树实现的