Java9 集合

集合

目录：

1. 集合概念
2. Collection接口
3. List接口与实现类
4. 泛型和工具类
5. set接口与实现类
6. Map接口与实现类

概念：
对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能

和数组的区别：

1. 数组长度固定，集合长度不固定
2. 数组可以存储基本类型和引用类型，集合只能存储引用类型

位置:java.util.*

Collection体系集合

包括List和Set
List包括ArrayList、LinkedList、Vector
Set包括HashSet、SortedSet（TreeSet）

List接口特点：
有序、有下标、元素可重复
Set接口特点：
无序、无下标、元素不可重复

Collection父接口
特点：代表一组任意类型的对象，无序、无下标、不能重复

方法：
boolean add(Object obj)//添加一个对象
boolean addAll(Collection c)//将一个集合中的所有对象添加到此集合中
void clear()//清空此集合中所有对象
boolean contains(object o)//检查此集合中是否包含o对象
boolean equals(object o)//比较此集合是否与指定对象相等
boolean isEmoty()//判断此集合是否为空
boolean remove(Object o)//在此集合中移除o对象
int size()//返回此集合中的元素个数
Object[] toArray()//将集合转换成数组

使用：
1.添加元素
2.删除元素
3.遍历元素
4.判断

package CollectionsStudy;

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

/**
 * Collections使用
 */
//1.添加元素
    //删除元素
    //遍历元素
    //判断
public class Demo1 {
    public static void main(String[] args) {
    //创建集合
        Collection collection = new ArrayList();

        //1.添加元素
        collection.add("苹果");
        collection.add("西瓜");
        collection.add("榴莲");
        System.out.println("元素个数:"+collection.size());
        System.out.println(collection);
        //删除元素
       // collection.remove("榴莲");
       // System.out.println("删除之后："+collection.size());
      //  System.out.println(collection);

        //遍历元素
        //1方式
        System.out.println("------------");
        for (Object object:collection) {
            System.out.println(object);
        }
        System.out.println("--------------");
        //2方式
        //在iterator迭代器中不能使用Collect.remove删除，否则会出现ConcurrentModificationException  并发修改异常
        //可以使用迭代器iterato.remove
        Iterator it=collection.iterator();
        while (it.hasNext()){
            String s =(String)it.next();
            System.out.println(s);
        }
        //判断
        //1.判断是否存在
        System.out.println(collection.contains("苹果"));
    }
}

List子接口
特点：有序、有下标、元素可以重复

方法：
void add(int index,Object o)//在index位置插入对象o
boolean addAll()//添加集合y
object get(int index)//返回集合中指定位置的元素
List subList(int fromIndex,int toIndex)//返回fromIndex和toIndex之间的元素

ArrayList【重点】：
数据结构实现，查询快、增删慢

jdk1.2，运行效率快、线程不安全
源码分析：
	默认容量=10
		若没有向集合添加任何元素时，容量0，添加一个元素之后，容量10每次扩容大小的原来的1.5倍
	存放元素的数组 elementData
	实际元素个数：size
	添加元素：add

Vector：

数组结构实现，查询快、增删慢
JDK1.0，运行效率慢，线程安全

package CollectionsStudy;

import java.util.Enumeration;
import java.util.Vector;

/**
 * Vector集合
 */
public class Demo2 {
    public static void main(String[] args) {
        Vector vector = new Vector<>();
        //添加元素
        vector.add("苹果");
        vector.add("香蕉");
        vector.add("草莓");

        System.out.println("元素个数:"+vector.size());
        System.out.println(vector.toString());

        //遍历
        //使用枚举
        Enumeration en =vector.elements();
        while (en.hasMoreElements()){
            String o=(String) en.nextElement();
            System.out.println(o);
        }
        //判断
        System.out.println(vector.contains("苹果"));
        System.out.println(vector.isEmpty());//是否为空
        
    }
}

LinkedList：
链表结构实现，增删快，查询慢

package CollectionsStudy;

import java.util.LinkedList;

/**
 * lindedList使用
 * 存储结构：双向链表
 */
public class Demo3 {
    public static void main(String[] args) {
        LinkedList linkedList =new LinkedList<>();

        linkedList.add("1");
        linkedList.add("2");
        linkedList.add("3");
        linkedList.add("4");

        System.out.println("元素个数："+linkedList.size());
        System.out.println(linkedList.toString());

        
    }
}

ArrayList和LinkedList区别：
ArrayList:必须开辟连续空间，查询快，增删慢
LinkedList：无需开辟连续空间，查询慢，增删快

泛型

• Java泛型是JDK1.5引入的一个新特性，其本质就是参数化类型，把类型作为参数传递
• 常见形式由泛型类、泛型接口、泛型方法
• 语法：
• <T,…>T称为类型占位符，表示一种引用类型
• 好处：
• 提高代码的重用性
• 防止类型转换异常，提高代码的安全性

泛型类
语法，类名
T是类型占位符，表示一种引用类型，如果编写多个使用逗号隔开

package CollectionsStudy;

/**
 * 泛型类
 */
public class MyGeneric<T> {
    //创建变量
    T t;
    //作为方法的参数
    public void show(T t){
        
        System.out.println(t);
    }
    //泛型作为方法的返回值
    public T getT(){
        return  t;
    }
}

//测试泛型类

package CollectionsStudy;

/**
 * 测试泛型类
 */
public class TestGeneric {
    public static void main(String[] args) {
        MyGeneric<String> myGeneric =new MyGeneric<String>();
        myGeneric.t="Hello";
        myGeneric.show("大家好");
        String string =myGeneric.getT();

        MyGeneric<Integer> myGeneric1=new MyGeneric<Integer>();
        myGeneric1.t=100;
        myGeneric1.show(200);
        Integer integer =myGeneric1.getT();
        System.out.println(string);
    }
}

泛型集合

概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致

特点：
编译时即可检查，而非运行时抛出异常
访问时，不必类型转换
不同泛型之间引用不能相互赋值，泛型不存在多态

Set集合

特点：无序、无下标，元素不可重复

方法：继承collecction

HashSet【重点】
基于HashCode实现元素不重复
当存入元素的哈希码相同时，会调用equals进行确认，如果为true，则拒绝后者存入

TreeSet：
基于排列顺序实现元素不重复

package CollectionsStudy;

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

/**
 * set使用
 */
public class Demo4 {
    public static void main(String[] args) {
        Set<String> set=new HashSet<>();
        //添加数据
        set.add("华为");
        set.add("小米");
        set.add("苹果");
        System.out.println("数据个数:"+set.size());
        System.out.println(set.toString());
        System.out.println("----打印数据----");
        for (String string:set) {
            System.out.println(string);
        }

        System.out.println("---------");
        Iterator<String> it =set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

HashSet：
基于HashCode计算元素存放的位置
当存入元素的哈希码相同时，会调用equals进行确认，如结果为true，则拒绝后者存入

package CollectionsStudy;

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

/**
 * HashSet集合使用
 * 存储结构：哈希表（数组+链表+红黑树）
 * 存储过程：
 *  1.根据hashcode计算保存的位置，如果此位置为空，则直接保存，如果不为空，执行第二部
 *  2.再执行equals方法，如果equals方法为true，则认为是重复，否则，形成链表
 *  
 */
public class Demo5 {
    public static void main(String[] args) {
        //新建集合
        HashSet<String> hashSet =new HashSet<String>();
        hashSet.add("刘德华");
        hashSet.add("梁兆伟");
        hashSet.add("凌志玲");
        hashSet.add("周润发");
        System.out.println("元素个数:"+hashSet.size());
        System.out.println(hashSet.toString());

        //删除
//        hashSet.remove("刘德华");
//        System.out.println("删除之后："+hashSet.size());
        //遍历
        Iterator<String> it=hashSet.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

    }

}

TreeSet
基于排列顺序实现元素不重复
实现了SortedSet接口，对集合元素自动排序
元素对象的类型必须实现Comparable接口，指定排序规则
通过CompareTo方法确定是否为重复元素

package CollectionsStudy;

import java.util.TreeSet;

/**
 *  TreeSet
 *  存储结构：红黑树
 *  要求：元素必须实现Compareable接口，compareTo()方法返回值为0，认为是重复元素
 */
public class Demo6 {
    public static void main(String[] args) {
        TreeSet<String> treeSet =new TreeSet<>();
        treeSet.add("1");
        treeSet.add("2");
        treeSet.add("3");
        treeSet.add("4");
        System.out.println("元素个数:"+treeSet.size());
        System.out.println(treeSet.toString());
        
        
    }
}

Map集合

包括了HashMap和TreeMap

特点：
1.用于存储任意键值对（key-value）
2.键：无序、无下标、不允许重复（唯一）
3.值：无序、无下标、允许重复

方法：
put(k key,v value):将对象存入集合中，关联键值。key重复则重复原值
object get(Object key)根据键获取对应的值
set 返回所有的key
Collection values()返回包含值得Collection集合
Set<Map.Entry<K,V>>键值匹配得Set集合

//HashMap
jdk1.2版本，线程不安全，运行效率快；允许用null作为key或是value

package CollectionsStudy;

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

/**
 * Map接口得使用
 * 特点：1.存储键值对2.键不能重复，值可以 3.无序
 */
public class Demo8 {
    public static void main(String[] args) {
        Map<String,String> map=new HashMap<>();
        map.put("cn","中国");
        map.put("usa","美国");
        map.put("uk","英国");

        System.out.println("元素个数："+map.size());
        System.out.println(map.toString());

        //删除
//        map.remove("usa");

        //遍历
        Set<String> keySet=map.keySet();
        for (String key:keySet) {
            System.out.println(key+"---"+map.get(key));
        }

        System.out.println("------------------");
        //entrySet
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String,String> entry:entries) {
            System.out.println(entry.getKey()+"---"+entry.getValue());
        }
    }
}

//Hashtable
JDk1.0版本，线程安全，运行效率慢；不允许null作为key或是value

//Properties:
Hashtable的子类，要求key和value都是String。通常用于配置文件的读取

//TreeMap
实现了SortedMap接口，可以对key自动排序

Colletions工具类

概念：集合工具类，定义了除了存取意外的集合常用方法

方法：
public static void reverse(List<?> list) //反转集合中的元素的顺序
public static void shuffle(List<?> list)随机重置集合元素的顺序
public static void sort (List list)//升序排序(元素类型必须实现Comparable接口)

binarySearch 二分查找值 返回时位置下标
copy 复制
补充：
list转成数组
Integer[] arr=list.toArray(new Integer[0]);
数组转成集合
String[] name={“张三”,“里斯”,“王五”};
List list2=Arrays.asList(name);
//数组转换城一个集合，受限集合，不能添加和删除