集合相关1

数组特点 存储数据类型相同的元素集合 ，创建前给定长度且一旦创建长度不变，满员后，要重新创建，将元素复制过去。缺点 删除，添加则要移动元素。

Java为解决数据存储单一情况，提供许多不同结构的集合类，让我们可以根据不同场景进行数据存储选择，让使用起来更加方便

集合容器中默认可以添加Object类 习惯在集合类型只保存一种类型，保存多个类型，会涉及到类型转换

泛型：在声明式自定义参数类型

单列集合：一次放进一个值或对象

Collection ：定义单链接口的所有方法

list:可以重复

set:不可重复

双链 ： 键，值，

list:可以重复

arrarylist:数组列表，底层有一个数组，可以动态扩展数组长度，查询快，添加删除慢并提供一个一些列的方法操作

import java.util.ArrayList;
​
public class Deno1 {
    public static void main(String[] args) {
        ArrayList arr=new ArrayList();
        arr.add("q");
        arr.add("1");
        arr.add("cb");
        arr.remove("1");
        System.out.println(arr);
        ArrayList ar=new ArrayList();
        ar.add("123");
        ar.add("abc");
        ar.add("456");
        ar.add("123");
        ar.add("789");
        ar.remove("123");//根据内容，匹配的第一个元素成功ture
        ar.remove(0);//删除并返回指定位置的元素
        System.out.println(ar);
        System.out.println(ar.get(1));//获取指定位置的元素
        System.out.println(ar.set(2,"156"));//替换并返回指定位置的元素
        /*
        add(E e)
            public boolean add(E e) {
               ensureCapacityInternal(size + 1);  //检测元素是否放下
                elementData[size++] = e;
                  return true;
                }
           add(0,"e")在指定位置添加元素
         */
        ArrayList<Integer>arr1=new ArrayList();
        arr1.add(1);
        arr1.add(2);
        arr1.add(3);
        arr1.add(4);
        arr1.add(4);
        System.out.println(arr1);
        System.out.println(arr1.isEmpty());//判断是否为空
        System.out.println(arr1.set(2,6));
        System.out.println(arr1.size());
        System.out.println(arr1.indexOf(4));
        System.out.println(arr1.lastIndexOf(4));
​
    }
}

linklist:链表列表，底层是一个链表，查询慢，添加删除快

li.add("abcdefght");//向链表末尾添加
li.add(1, "g");//向指定位置插入
// System.out.println(li.get(2));
System.out.println(li.remove());//删除并返回第一个
System.out.println(li.removeFirst());//删除并返回第一个

list接口集合迭代遍历

ist接口实现类 /遍历方式 for循环 允许操作元素注意索引的变化与元素位置的移动
         for(int i=0;i<ar.size();i++){
          System.out.println(ar.get(i));
         }
         2.增强for循环 遍历元素时不允许修改元素（删除，增加）
​
     */
   for(String s:ar){
​
       System.out.println(ar);
   }
    Iterator<String> it =ar.iterator();//list迭代器  获得集合的迭代对象
     while(it.hasNext()){
         String s=it.next();
         if(s.equals("a")){
             it.remove();
         }
     }
    System.out.println(ar);
    ListIterator<String> listIterator=ar.listIterator();//listIterator
    while(listIterator.hasPrevious()){
        System.out.println(listIterator.hasPrevious());
    }
}

Vector:

Set接口（继承Collection接口）

HashSet ：元素无序，不能添加重复元素

Treeset：元素按照一定顺序排列不能重复存储元素，底层使用树结构

set:元素不重复

set:元素时不重复
Hashset:元素无序
HashSet:在添加元素时如何判断元素重复的。向集合添加元素时每次比较equals()比较内容效率低，
调用Hashcode（）---Object中的hashcode（）返回的是对象地址（不调用这个）
会调用类中重写的hashode()返回的是根据内容计算的哈希值，遍历时会用hash 值先比较啊hi发相等提高比较
效率，可能存在内容不同，哈希值相同，此情况下再强调equals（）比较内容，这ji提高效率又保证安全

Map接口

键映射到值的对象，键最多映射到一个值，一个映射不能包含重复的值

Hashmap

treemap

hashtable

package Map;

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

public class HashMapDemo {
    public static void main(String[] args) {
        HashMap<String, String> hashMap = new HashMap<>();
        /*
        HashMap 底层数据结构
            哈希表
        static final int hash(Object key)
        {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
            }

          Map 数据存储是键：值的形式存储
          键不能重复，值可以重复
          一个键只能映射到一个值
          HashMap：
            键是无序

         */
        hashMap.put("q", "we");//hashmap 中添加一组键，值对
        hashMap.put("t", "yu");
        hashMap.put("o", "po");
        hashMap.put("q", "aaa");
        hashMap.put("v", "lo");
        //hashMap.clear();//清空hashmap
        System.out.println(hashMap);
        System.out.println(hashMap.remove("t"));//删除指定键值，返回对应值
        System.out.println(hashMap.isEmpty());//判断键值对的个数是否为空
        System.out.println(hashMap.size());//hashmap的大小
        System.out.println(hashMap.get("o"));//获取键值
        /*map遍历
        1先拿到所有的键，遍历键，根据键找值
         */
        Set<String> keyset = hashMap.keySet();
        for (String ke : hashMap.keySet()) {
            System.out.println(ke);
        }
        //方法2
        Set<Map.Entry<String, String>> entries = hashMap.entrySet();
        for (Map.Entry en : entries) {
            System.out.println(en.getKey() + ":" + en.getValue());
        }

    }
}

泛型

public class Genericity<A> {
        /*
            关于为什么要使用泛型？
                -有的时候不知道要用什么传入什么参数，同时又需要不断地进行父类子类的转化，太过于麻烦，所以有了这个东西
         */
 
        A[] objects = (A[])new Object[30];//强制类型转换
 
 
        //<A>可以是任意标识符,也可以定义多个泛型(键值对)
 
    public void add(A obj){
        //形参类型也是由外部定义的
    }
 
    public A get(){
        //返回值也是由外部指定
        return null;
    }
 
    public static void main(String[] args) {
        //在存储方面有些优势，任何类型的数据都可以存储，但是缺点在于不好取出
 
        //定义<A>之后，这里所有类型都可以通过A来替换
 
        /*
            在定义时，为类指定类型，在编译期间添加数据时进行类型的校验
            -传参时只能用类来传递类型(integer),不能用基本数据类型(int)来传递
            -泛型的类型参数可以有多个
            -没有指定默认为object
         */
 
        Genericity<String> genericity1=new Genericity<>();//变量类型由外部指定
        genericity1.add("");
        //返回值为String
        genericity1.get();
        //同理也可以使用Integer
        Genericity<Integer> genericity2=new Genericity<>();
        genericity2.add(213);//传入的实参类型需要与泛型的参数类型相同
        //返回值为Integer
        genericity2.get();
    }
 
 
    A name;
 
}