集合(Collection集合,Map集合,Collections工具类)

1.Collection

Collection集合共性方法

        Collection<String> collection =new ArrayList<>();
        collection.add("a");//添加，返回Boolean,添加成功返回true
        collection.remove("a");//删除，返回Boolean,删除成功返回true
        collection.clear();//清空集合
        boolean contains = collection.contains("a");//是否包含“a”这个字符串
        boolean empty = collection.isEmpty();//判断是否为空
        int size = collection.size();//集合长度size；数组长度length
        Object[] objects = collection.toArray();//集合转换数组

1.1 List(有序,有索引,允许重复元素)

常用方法一: 包含带索引方法(特有的方法)

 .add()//指定位置添加
 .get()//获取指定位置元素
 .remove()//指定位置移除
 .set()//指定位置替换

常用方法二: list集合3种遍历方式

        //普通for循环
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);
        }
        //迭代器
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String s= iterator.next();
            System.out.println(s);
        }
        //增强for循环
        for (String s : list) {
            System.out.println(s);
        }

常用方法三: 两个List集合取交集

//两个集合取交集
List<String> list1 = new ArrayList<>();
//省略 往list中添加的过程......
List<String> list2 = new ArrayList<>();
//省略 往list中添加的过程......
list1.retainAll(list2);

常用方法四: List集合拼接成String( 自定义自定义分割符 )

//这个要注意List中要是String类型,否则会出现 类转换异常
List<String> list = new ArrayList<>();
//省略 往list中添加字符串的过程......

// 方式一，可以用stream流
String s= list.stream().collect(Collectors.joining("#"));

// 方式二，String.join()方法
String s= String.join(",", list);

常用方法五: 字符串转换为List

String str = "a,b,c";
List<String> list = Arrays.asList(str.split(","));//这个Arrays.asList()得到的list长度是不可改变的,当添加和删除元素时会抛异常UnsupportedOperationException
//如果需要对这个list添加删除等,还需要把这个集合遍历一下,存入到ArrayList中

1.1.1 ArrayList(底层数组，查询快，增删慢，多线程)

//多态创建集合对象
List list= new ArrayList();

1.1.2 LinkedList(底层链表，查询慢，增删快，多线程)

//注意：使用LinkedList特有方法，不能使用多态创建对象了
LinkedList linkedList = new LinkedList();

操作首位元素方法(特有的)

//首尾位置 添加
addFirst() <=> push()/ addLast()
//首尾位置 获取
getFirst() / getLast()
//首尾位置 获取
removeFirst()<=>pop() / removeLast()

1.1.3 Vector(底层数组,单线程,1.0版本最早期集合，现在几乎不用了)

1.2 Set(无索引，不包含重复元素)

不能使用普通for循环

set集合存储不重复元素:
前提 : 存储的元素重写hashCode()和equals()方法。
原理 : 在调用add()方法时会先调用hashCode()方法比较地址中是否有这个哈希值，没有–>存储，有（哈希冲突）–>调用再调用euqals()方法比较是否是相同元素，不相同就存，相同就不存

1.2.1 HashSet (哈希表结构，查询速度快，无序)

如果用HashSet 存储自定义类型数据,一定要重写hashCode()和equals()方法,才能保证HashSet集合的去重的特性.

Set set = new HashSet();

1.2.2 LinkedHashSet(继承了HashSet，哈希表+链表结构 , 有序)

链表结构是记录元素的存储顺序的,保证了集合的有序

2.Map

Map中的key必须重写hashCode()方法和equals()方法才能保证key的唯一性。

常用方法

//添加
map.put(key,value);//如果key重复了，会出现value值覆盖

//查找
map.get(key);

//删除
map.remove(key);// key存在返回值是value,key不存在放回null

//是否包含指定的key
boolean b = map.containsKey(key);

2.2.1 HashMap(数组+单项链表/哈希表结构, 无序, 多线程, 可有一个null键)

结构:
1.8之前 数组+单项链表 结构
1.8之后 数组+单项链表/红黑树(链表长度超过8之后变成红黑树) 结构

自定义类作为键值

		//自定义类作为vlaue
        Map<String,Student> map = new HashMap<>();
        //自定义类作为key
        Map<Student,String> map = new HashMap<>();

Map集合的遍历方式(Map集合无法直接遍历)

		//方法一: keySet()
        Map<String,Object> map = new HashMap<>();
        //省略map中添加值....
        Set<String> stringSet = map.keySet();//map中所有的key存到set集合中
        //迭代器遍历,也可以通过增强for遍历
        Iterator<String> iterator = stringSet.iterator();//遍历获取每一个key
        while (iterator.hasNext()) {
            String key = iterator.next();
            Object value = map.get(key);//通过key 获取value值
            System.out.println(value);
        }


		//方法二: entrySet()
		Map<String, Object> map = new HashMap<>();
        //省略map中添加值....
        Set<Map.Entry<String, Object>> entrySet = map.entrySet();//map中所有的entry对象(键值对对象)存到set集合中
        for (Map.Entry<String, Object> entry : entrySet) {
            String key = entry.getKey();//获取key
            Object value = entry.getValue();//获取value
            System.out.println(key+"和"+value);
        }

2.2.2 LinkedHashMap(继承HashMap,哈希表+链表结构，有序)

LinkedHashMap linkedHashMap = new LinkedHashMap();

2.2.3 Hashtable(几乎不用了,被HashMap取代了)

1.0版本的双列集合,底层是哈希表结构,单线程(线程安全的)
Hashtable键和值都不允许为null

2.2.4 Properties(Hashtable集合子类,唯一一个和IO流相结合的集合)

属性集合:
特点:
1.存储属性名和属性值
2.属性名和属性值都是字符串类型
3.没有泛型
4.和流有关

        /****************基本方法****************/
        //创建集合
        Properties properties = new Properties();
        //添加属性
        properties.setProperty("username","张三");
        properties.setProperty("password","123456");
        //获取value
        String val = properties.getProperty("username");
        //遍历方法一: keySet 和 entrySet都可以
        //遍历方法二: stringPropertyNames 遍历出属性名的set集合
        Set<String> keyNames = properties.stringPropertyNames();

        /****************和流有关的方法****************/

        //1.list方法
        //创建打印流
        PrintWriter pw = new PrintWriter(new File("d:\\aaa.txt"));
        //list方法打印
        properties.list(pw);
        pw.close();

        //2.store方法
        //字节输出流  一般这属性用properties扩展名
        FileOutputStream fos = new FileOutputStream(new File("d:\\bbb.properties"));
        //保存方法
        properties.store(fos,"随便写个注释");
        fos.close();

        //3.load方法
        FileInputStream fis = new FileInputStream(new File("d:\\bbb.properties"));
        //加载
        properties.load(fis);
        fis.close();
        System.out.println(properties);

2.2.5 TreeMap

3.Collections(集合工具类)

3.1、Collections.addAll（）往集合中添加所有元素

        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"a","b","c","d","e");//往集合中添加所有元素
        System.out.println(list);

3.2、Collections.shuffle（）随机打乱集合顺序

        ArrayList<String> list = new ArrayList<>();
        Collections.shuffle(list);//随机打乱集合顺序(每次执行集中的元素顺序都不一样)
        System.out.println(list);

3.3、Collections.sort（list）将集合中元素排序(默认升序)，参数只能穿list集合

		//Integer排序：
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,17,3,14,6,10);//往集合中添加所有元素
        Collections.sort(list);//将集合中元素按照升序排序，参数只能穿list集合
        System.out.println(list);
        ____________________________________________________
		//String排序：
		ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"d","e","c","a","b");//往集合中添加所有元素
        Collections.sort(list);
        System.out.println(list);
	   ____________________________________________________
		//自定义类型排序(自定义类)
		public class Student implements Comparable<Student> {
		    private String name;
		    private int age;
		    //省略了toString/构造/geter/setter等...

		    //重写排序规格
		    @Override
		    public int compareTo(Student o) {
		        return this.getAge()-o.getAge();//按照年龄升序排序
		        //return 0;//默认的return 0;是认为元素都是相同的
		        
		       /* 
		       Comparable接口排序规格
				自己（this.）-参数（o.）：升序
				参数（o.）-自己（this.）：降序
				*/
		    }
		}

		//业务代码中就可以对这个类排序了.......
		Collections.sort(Student);

3.4、Collections.sort(list, new Comparator()）自定义排序

		//比较自定义类(方法一)
        List<Student> list = new ArrayList<>();
        Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //按照 int类型 年龄排序-->升序
                int result = o1.getAge()-o2.getAge();
                //如果年龄相同,再使用姓名第一个字 String类型 排序(升序)
                if(result == 0){
                    result = o1.getName().charAt(0)-o2.getName().charAt(0)
                }
                return result;
            }
        });
       ____________________________________________________
		//自定义类型排序(方法二:java8 写法)
		
		List<Student> list= new ArrayList<>;// 创建集合
		//日期字符串排序 节次排序(Student属性 bitherday和number 为String类型)
		Comparator<Student> comparingDate = Comparator.comparing(Student::getBitherday);
		Comparator<Student> comparingNUM = Comparator.comparing(Student::getNumber).reversed();//降序
		// 多个字段联合排序：生日升序,number降序
		list.sort(comparingDate.thenComparing(comparingNUM));

3.5 其他CollectionUtils

// 判断 集合(list/set/map) 是否为空
CollectionUtils.isEmpty(集合)
// 判断 List/Set 中是否包含某个对象
CollectionUtils.containsInstance(Collection collection, Object element)
// 判断 List/Set 是否包含小集合
CollectionUtils.containsAny(Collection big, Collection small)
// 返回 List/Set 中最后一个元素
CollectionUtils.lastElement( list)  

// 两个集合取交集
Collection<String> collection = CollectionUtils.retainAll(listA, listB);
// 两个集合取并集
Collection<String> collection = CollectionUtils.union(listA, listB);
// 两个集合取差集
Collection<String> collection = CollectionUtils.subtract(listA, listB);

3.5 Collections.singleton(null) 去除 null 元素

//去除 null 元素
oldList.removeAll(Collections.singleton(null)); 
//去除 空 元素
oldList.removeAll(Collections.singleton("")); 

4.Hash值

定义:hash值是一个十进制的整数,由本地系统(native)随机给出(就是对象的地址值,是一个逻辑地址,是模拟出来的地址,不是数据实际存储的物理地址)

.hashCode()//获取hash值

哈希冲突:两个元素不同,但是哈希值相同就是哈希冲突.

哈希表结构查询数据快的原因:
是因为先根据hash值分组了,将hash值相同的元素挂到一个链表上,如果挂载的元素超过8位就将这个链表的结构转换为红黑树.